数据挖掘之决策树

 import numpy as np

    
  
    
 # 计算信息熵
    
 def calcInfoEntropy(feature, label):
    
     '''
    
     计算信息熵
    
     :param feature:数据集中的特征，类型为ndarray
    
     :param label:数据集中的标签，类型为ndarray
    
     :return:信息熵，类型float
    
     '''
    
  
    
     #*********** Begin ***********#
    
     feature = np.array(feature)
    
     label = np.array(label)
    
     # 统计不同类别的数量
    
     label_counts = np.bincount(label)
    
     # 计算每个类别的概率
    
     label_probs = label_counts / len(label)
    
     # 计算信息熵
    
     info_entropy = -np.sum(label_probs * np.log2(label_probs + 1e-10))
    
  
    
     return info_entropy
    
     #*********** End *************#
    
  
    
  
    
 # 计算条件熵
    
 def calcHDA(feature, label, index, value):
    
     '''
    
     计算信息熵
    
     :param feature:数据集中的特征，类型为ndarray
    
     :param label:数据集中的标签，类型为ndarray
    
     :param index:需要使用的特征列索引，类型为int
    
     :param value:index所表示的特征列中需要考察的特征值，类型为int
    
     :return:信息熵，类型float
    
     '''
    
  
    
     #*********** Begin ***********#
    
     feature = np.array(feature)
    
     label = np.array(label)
    
     # 筛选出index列特征值等于value的样本
    
     mask = (feature[:, index] == value)
    
     # 根据mask筛选样本
    
     feature_subset = feature[mask]
    
     label_subset = label[mask]
    
     # 计算条件熵
    
     cond_entropy = calcInfoEntropy(feature_subset, label_subset)
    
  
    
     return cond_entropy
    
     #*********** End *************#
    
  
    
  
    
 def calcInfoGain(feature, label, index):
    
     '''
    
     计算信息增益
    
     :param feature:测试用例中字典里的feature
    
     :param label:测试用例中字典里的label
    
     :param index:测试用例中字典里的index，即feature部分特征列的索引
    
     :return:信息增益，类型float
    
     '''
    
  
    
     #*********** Begin ***********#
    
     feature = np.array(feature)
    
     label = np.array(label)
    
     # 计算原始数据集的信息熵
    
     base_entropy = calcInfoEntropy(feature, label)
    
     # 获取index列的特征值集合
    
     values = np.unique(feature[:, index])
    
     # 计算条件熵
    
     cond_entropy = sum([(len(feature[feature[:, index] == value]) / len(feature)) * calcHDA(feature, label, index, value) for value in values])
    
     # 计算信息增益
    
     info_gain = base_entropy - cond_entropy
    
  
    
     return info_gain
    
     #*********** End *************#
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-17/vpWrzo5wR1U9XCNEceuiPbfa7Gn6.png)

 import numpy as np

    
 from copy import deepcopy
    
 from collections import Counter
    
 class DecisionTree(object):
    
     #计算熵
    
     def calcInfoEntropy(self, label):
    
     label_set = set(label)
    
     result = 0
    
     for l in label_set:
    
         count = 0
    
         for j in range(len(label)):
    
             if label[j] == l:
    
                 count += 1
    
         p = count/len(label)
    
         result -= p*np.log2(p)
    
     return result
    
  
    
     #计算条件熵
    
     def calcHDA(self, feature, label, index, value):
    
     count = 0
    
     sub_feature = []
    
     sub_label = []
    
     for i in range(len(feature)):
    
         if feature[i][index] == value:
    
             count += 1
    
             sub_feature.append(feature[i])
    
             sub_label.append(label[i])
    
     pHA = count/len(feature)
    
     e = self.calcInfoEntropy(sub_label)
    
     return pHA*e
    
  
    
  
    
     #计算信息增益
    
     def calcInfoGain(self, feature, label, index):
    
     base_e = self.calcInfoEntropy(label)
    
     f = np.array(feature)
    
     f_set = set(f[:, index])
    
     sum_HDA = 0
    
     for l in f_set:
    
         sum_HDA += self.calcHDA(feature, label, index, l)
    
     return base_e - sum_HDA
    
  
    
  
    
     def __init__(self):
    
     #决策树模型
    
     self.tree = {}
    
  
    
     def fit(self, feature, label):
    
     '''
    
     :param feature: 训练数据集所有特征组成的ndarray
    
     :param label:训练数据集中所有标签组成的ndarray
    
     :return: None
    
     '''
    
  
    
     #************* Begin ************#
    
     def build_tree(feature, label):
    
         # 1. 判断停止条件，例如：当所有样本属于同一类别时停止
    
         if len(set(label)) == 1:
    
             return label[0]
    
         # 2. 判断特征集是否为空或所有特征值相同，返回样本中出现最多的类别
    
         if len(feature[0]) == 0 or len(set([tuple(row) for row in feature])) == 1:
    
             return Counter(label).most_common(1)[0][0]
    
  
    
         # 3. 计算每个特征的信息增益
    
         best_feature_index = None
    
         best_info_gain = -float('inf')
    
         for i in range(len(feature[0])):
    
             info_gain = self.calcInfoGain(feature, label, i)
    
             if info_gain > best_info_gain:
    
                 best_info_gain = info_gain
    
                 best_feature_index = i
    
  
    
         # 4. 根据最佳特征划分数据集
    
         best_feature_values = set(feature[:, best_feature_index])
    
         sub_trees = {}
    
         for value in best_feature_values:
    
             sub_feature = [row for row in feature if row[best_feature_index] == value]
    
             sub_label = [label[i] for i in range(len(label)) if feature[i][best_feature_index] == value]
    
             sub_trees[value] = build_tree(np.array(sub_feature), np.array(sub_label))
    
  
    
         return {'feature_index': best_feature_index, 'sub_trees': sub_trees}
    
  
    
     self.tree = build_tree(feature, label)
    
     #************* End **************#
    
  
    
     def predict(self, feature):
    
     '''
    
     :param feature:训练数据集所有特征组成的ndarray
    
     :return:预测结果，如np.array([0, 1, 2, 2, 1, 0])
    
     '''
    
  
    
     #************* Begin ************#
    
     def classify(tree, sample):
    
         if isinstance(tree, dict):
    
             feature_index = tree['feature_index']
    
             sub_trees = tree['sub_trees']
    
             value = sample[feature_index]
    
             if value in sub_trees:
    
                 return classify(sub_trees[value], sample)
    
         else:
    
             return tree
    
     
    
     predictions = []
    
     for sample in feature:
    
         predictions.append(classify(self.tree, sample))
    
     
    
     return np.array(predictions)
    
     
    
     #************* End **************#
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-17/pHbwsvVqSkQnGdWBeaD7z4JFtO8u.png)

 from sklearn import datasets

    
  
    
 #加载鸢尾花数据集
    
 iris = datasets.load_iris()
    
  
    
 #X表示特征，y表示标签
    
 X = iris.data
    
 y = iris.target
    
    
    
    
    python
    
    

 clf = tree.DecisionTreeClassifier()

    
 clf.fit(X_train, Y_train)
    
 result = clf.predict(X_test)
    
    
    
    
    python
    
    

 from sklearn.tree import DecisionTreeClassifier

    
  
    
 def iris_predict(train_sample, train_label, test_sample):
    
     '''
    
     实现功能：1.训练模型 2.预测
    
     :param train_sample: 包含多条训练样本的样本集，类型为ndarray
    
     :param train_label: 包含多条训练样本标签的标签集，类型为ndarray
    
     :param test_sample: 包含多条测试样本的测试集，类型为ndarry
    
     :return: test_sample对应的预测标签
    
     '''
    
     
    
     # ************* Begin ************#
    
     dt = DecisionTreeClassifier(max_depth=3)
    
     dt.fit(train_sample, train_label)
    
     return dt.predict(test_sample)
    
     # ************* End **************#
    
    
    
    
    python
    
    
![](https://ad.itadn.com/c/weblog/blog-img/images/2025-08-17/Zvgq3SHWOmxRbKTAJrFlcLksfyMX.png)