决策树的python代码实例

决策树是一种常用的机器学习算法，可以用于分类和回归问题。在Python中，我们可以使用scikit-learn库来构建决策树模型。以下是一个简单的代码示例：

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier
from sklearn.model_selection import train_test_split

# 加载鸢尾花数据集
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(iris.data, iris.target, test_size=0.3, random_state=42)

# 构建决策树模型
clf = DecisionTreeClassifier()
clf.fit(X_train, y_train)

# 在测试集上评估模型
score = clf.score(X_test, y_test)
print("Accuracy:", score)

这个代码示例加载了鸢尾花数据集，将数据集分为训练集和测试集，并使用DecisionTreeClassifier构建了一个决策树模型。最后，在测试集上评估了模型的性能，并输出了准确率。你可以根据自己的需要调整模型参数，例如树的最大深度等。

相关问题

决策树模型python代码实例

决策树是一种常用的机器学习算法，它通过构建一系列规则来进行分类或回归任务。在Python中，我们可以使用sklearn库中的`DecisionTreeClassifier`或`DecisionTreeRegressor`来创建决策树模型。这里是一个简单的例子，展示如何使用`sklearn`创建一个分类的决策树：

# 导入必要的库
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

# 加载鸢尾花数据集
iris = load_iris()
X = iris.data
y = iris.target

# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建决策树分类器
clf = DecisionTreeClassifier()

# 训练模型
clf.fit(X_train, y_train)

# 预测测试集
y_pred = clf.predict(X_test)

# 计算准确率
accuracy = accuracy_score(y_test, y_pred)
print(f"Accuracy: {accuracy}")

# 示例代码展示了基本流程，包括加载数据、划分样本、训练模型、预测以及评估性能。

决策树分类算法python代码实例

决策树分类算法的Python代码实例可以通过以下步骤实现：

1. 构建数据集：将样本数据转换为可用于决策树分类算法的格式。

2. 计算数据集信息熵：使用信息熵来衡量数据集的混乱程度。

3. 计算信息增益：通过计算每个属性的信息增益来确定最佳的分裂属性。

4. 构造决策树：使用递归的方式构造决策树。

5. 实例化构造决策树：使用构造好的决策树对新的数据进行分类。

以下是一个简单的决策树分类算法的Python代码实例：

# 导入必要的库
import pandas as pd
import numpy as np

# 构建数据集
data = {'Outlook': ['Sunny', 'Sunny', 'Overcast', 'Rainy', 'Rainy', 'Rainy', 'Overcast', 'Sunny', 'Sunny', 'Rainy', 'Sunny', 'Overcast', 'Overcast', 'Rainy'],
        'Temperature': ['Hot', 'Hot', 'Hot', 'Mild', 'Cool', 'Cool', 'Cool', 'Mild', 'Cool', 'Mild', 'Mild', 'Mild', 'Hot', 'Mild'],
        'Humidity': ['High', 'High', 'High', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'Normal', 'Normal', 'High', 'Normal', 'High'],
        'Wind': ['Weak', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Weak', 'Weak', 'Strong', 'Strong', 'Weak', 'Strong'],
        'Play': ['No', 'No', 'Yes', 'Yes', 'Yes', 'No', 'Yes', 'No', 'Yes', 'Yes', 'Yes', 'Yes', 'Yes', 'No']}
df = pd.DataFrame(data)

# 计算数据集信息熵
def entropy(target_col):
    elements, counts = np.unique(target_col, return_counts=True)
    entropy = np.sum([(-counts[i]/np.sum(counts)) * np.log2(counts[i]/np.sum(counts)) for i in range(len(elements))])
    return entropy

# 计算信息增益
def InfoGain(data, split_attribute_name, target_name="Play"):
    total_entropy = entropy(data[target_name])
    vals, counts = np.unique(data[split_attribute_name], return_counts=True)
    Weighted_Entropy = np.sum([(counts[i]/np.sum(counts)) * entropy(data.where(data[split_attribute_name]==vals[i]).dropna()[target_name]) for i in range(len(vals))])
    Information_Gain = total_entropy - Weighted_Entropy
    return Information_Gain

# 构造决策树
def ID3(data, originaldata, features, target_attribute_name="Play", parent_node_class=None):
    # 如果所有目标值都相同，则返回该值
    if len(np.unique(data[target_attribute_name])) <= 1:
        return np.unique(data[target_attribute_name])[0]
    # 如果数据集为空，则返回父节点中最常见的目标值
    elif len(data) == 0:
        return np.unique(originaldata[target_attribute_name])[np.argmax(np.unique(originaldata[target_attribute_name], return_counts=True)[1])]
    # 如果特征集为空，则返回父节点中最常见的目标值
    elif len(features) == 0:
        return parent_node_class
    # 如果以上情况都不满足，则继续构造决策树
    else:
        # 设置父节点的目标值
        parent_node_class = np.unique(data[target_attribute_name])[np.argmax(np.unique(data[target_attribute_name], return_counts=True)[1])]
        # 选择最佳分裂属性
        item_values = [InfoGain(data, feature, target_attribute_name) for feature in features]
        best_feature_index = np.argmax(item_values)
        best_feature = features[best_feature_index]
        # 构造决策树
        tree = {best_feature:{}}
        features = [i for i in features if i != best_feature]
        for value in np.unique(data[best_feature]):
            value = value
            sub_data = data.where(data[best_feature] == value).dropna()
            subtree = ID3(sub_data, originaldata, features, target_attribute_name, parent_node_class)
            tree[best_feature][value] = subtree
        return(tree)

# 实例化构造决策树
def predict(query, tree, default = 'Yes'):
    for key in list(query.keys()):
        if key in list(tree.keys()):
            try:
                result = tree[key][query[key]]
            except:
                return default
            result = tree[key][query[key]]
            if isinstance(result, dict):
                return predict(query, result)
            else:
                return result

# 测试样本分类
data = {'Outlook': 'Sunny', 'Temperature': 'Cool', 'Humidity': 'High', 'Wind': 'Strong'}
tree = ID3(df, df, df.columns[:-1])
print(predict(data, tree))