决策树python代码不用sklearn

在Python中，如果不使用scikit-learn库构建决策树，可以使用内置的`copy`模块和`collections`模块来模拟基本的决策树算法。以下是一个简单的示例，它创建了一个递归函数来构建决策树：

class DecisionTreeNode:
    def __init__(self, feature=None, value=None, left=None, right=None, *, is_leaf=False, prediction=None):
        self.feature = feature
        self.value = value
        self.left = left
        self.right = right
        self.is_leaf = is_leaf
        self.prediction = prediction

def gini_impurity(data, labels):
    # 计算基尼不纯度
    unique_labels, counts = np.unique(labels, return_counts=True)
    impurity = sum((count / len(labels)) * (1 - count / len(labels)) for count in counts)
    return impurity

def entropy(data, labels):
    # 计算熵
    _, counts = np.unique(labels, return_counts=True)
    probabilities = counts / len(labels)
    entropy = -sum(prob * np.log2(prob) for prob in probabilities if prob > 0)
    return entropy

def find_best_split(data, features, labels):
    best_gini = float('inf')
    best_feature_index = None
    best_value = None
    
    for i, feature in enumerate(features):
        splits = data[feature].unique()
        
        for val in splits:
            left_data = data[data[feature] != val]
            right_data = data[data[feature] == val]

            if len(left_data) == 0 or len(right_data) == 0:
                continue
            
            gini = gini_impurity(labels[left_data], left_data[labels])
            info_gain = entropy(labels, labels) - (len(left_data) / len(data)) * gini - (len(right_data) / len(data)) * gini

            if info_gain < best_gini:
                best_gini = info_gain
                best_feature_index = i
                best_value = val
                
    return best_feature_index, best_value

# 示例用法
def build_tree(data, features, labels, depth=0, max_depth=5):
    impurity_before_split = gini_impurity(labels, labels)

    if depth >= max_depth or impurity_before_split == 0 or len(np.unique(labels)) <= 1:
        leaf_node = DecisionTreeNode(is_leaf=True, prediction=np.argmax(np.bincount(labels)))
        return leaf_node

    best_feature_index, best_value = find_best_split(data, features, labels)
    
    left_data = data[data[features[best_feature_index]] != best_value]
    right_data = data[data[features[best_feature_index]] == best_value]
    
    left_child = build_tree(left_data, features, labels, depth + 1, max_depth)
    right_child = build_tree(right_data, features, labels, depth + 1, max_depth)
    
    tree_node = DecisionTreeNode(feature=features[best_feature_index], value=best_value,
                                 left=left_child, right=right_child)
    
    return tree_node

# 使用示例
data = ...  # 假设这是包含特征和标签的数据集
features = ...  # 特征列名列表
labels = data['label_column']  # 假设标签列名为'label_column'

root = build_tree(data, features, labels)

注意，这只是一个基础版本的决策树，实际应用中你可能需要处理缺失值、剪枝等问题，并提供用户输入数据来进行预测。