在训练集上看是不是性能更好

integr/my_ada_boost.py

@@ -24,7 +24,7 @@ for i in range(len(Ytest)):
         Ytest[i] = -1
 print(Ytest)
 
-for i in range(3):
+for i in range(15):
     # 训练决策树
     # clf = DecisionTreeClassifier(criterion="entropy", max_features=1, max_depth=1,
     #                              class_weight={0:w0, 1:1-w0})  # 实例化，criterion不写的话默认是基尼系数
@@ -59,11 +59,11 @@ for i in range(3):
 
 predicts = []
 for tree in trees:
-    predicts.append(my_tree.predict(Xtest, None, tree))
+    predicts.append(my_tree.predict(Xtrain, None, tree))
 
 print(alpha)
 # 结果加权
-result = np.zeros(len(Xtest), float)
+result = np.zeros(len(Xtrain), float)
 for p in predicts:
     r = 0
     for w_alpha in alpha:
@@ -77,7 +77,7 @@ print("sign后:", result)
 # print(1- sum(np.bitwise_xor(Ytest, result))/len(result))
 # print(result == Ytest)
 print()
-x = len([i for i in result == Ytest if i])/len(result)
+x = len([i for i in result == Ytrain if i])/len(result)
 x = x + 0.5*len([i for i in result if i==0])/len(result)
 print(x)
 # cmp = np.concatenate(([result], [Ytest]), axis=0)
@@ -88,11 +88,11 @@ print(x)
 # clf = clf.fit(Xtrain, Ytrain)
 # print(clf.score(Xtest, Ytest))
 
-w = np.array([1/len(Ytrain) for i in range(len(Ytrain))])
+w = np.array([1/len(Xtrain) for i in range(len(Xtrain))])
 my_tree_0 = trees[0]
-Xpredit = my_tree.predict(Xtest, None, nodes)
+Ypredit = my_tree.predict(Xtrain, None, my_tree_0)
 error = 0
-for j in range(len(Xtest)):
-    if Xpredit[j] != Ytest[j]:
+for j in range(len(Xtrain)):
+    if Ypredit[j] != Ytrain[j]:
         error += w[j]
 print(1-error)

tree/my_tree.py

@@ -64,11 +64,14 @@ def calc_ent(x, weights=None):
     """
     x_value_list = set([x[i] for i in range(x.shape[0])])
     ent = 0.0
+
+    if weights is not None:
+        weights = weights / sum(weights)
+
     for x_value in x_value_list:
         if weights is None:
             p = float(x[x == x_value].shape[0]) / x.shape[0]
         else:
-            weights = weights/sum(weights)
             p = sum(sum([x == x_value]*weights))
         logp = np.log2(p)
         ent -= p * logp
@@ -143,7 +146,8 @@ def cal_max_ent_attr_c45(Xtrain, Ytrain, weights=None):
     max_ent = 0
     max_mean = 0
     weights = weights / sum(weights)
-    h = calc_ent(Ytrain)
+    h = calc_ent(Ytrain, weights)
+    p = 0
     for k in range(len(Xtrain) - 1):
         left = Xtrain[:k + 1]
         right = Xtrain[k + 1:]
@@ -154,7 +158,7 @@ def cal_max_ent_attr_c45(Xtrain, Ytrain, weights=None):
             iv = -len(left) / len(Ytrain) * np.log2(len(left) / len(Ytrain))
             iv -= len(right) / len(Ytrain) * np.log2(len(right) / len(Ytrain))
         else:
-            p = sum(weights[:k+1])
+            p += weights[k]
             left_ent = calc_ent(Ytrain[:k + 1], weights[:k+1]) * p
             right_ent = calc_ent(Ytrain[k + 1:], weights[k+1:]) * (1-p)
             iv = -p * np.log2(p)
@@ -264,23 +268,25 @@ def fit(Xtrain, Ytrain, parent_node, depth, weights):
     if depth >= MAX_T:
         return leaf_node(Ytrain, weights)
 
-    i, mean, min_ent = cal_ent_attr_c45(Xtrain, Ytrain, weights)
-    total_ent = calc_ent(Ytrain)
+    i, mean, min_ent = cal_ent_attr(Xtrain, Ytrain, weights)
+    total_ent = 0 # calc_ent(Ytrain)
     # print("第", i, "个属性,mean:", mean)
     # 生成节点
     parent_node = TreeNode(i, mean, total_ent - min_ent, False, -2, len(Ytrain), distrib(Ytrain))
 
     # 切分数据
-    right_Ytrain = Ytrain[Xtrain[:, i] > mean]
-    right_Xtrain = Xtrain[Xtrain[:, i] > mean]
+    right_position = Xtrain[:, i] > mean
+    right_Ytrain = Ytrain[right_position]
+    right_Xtrain = Xtrain[right_position]
     # right_Xtrain = np.delete(right_Xtrain, i, axis=1) # 这个属性还可以再被切分
 
-    right_node = fit(right_Xtrain, right_Ytrain, parent_node, depth+1, weights[Xtrain[:, i] > mean])
+    right_node = fit(right_Xtrain, right_Ytrain, parent_node, depth+1, weights[right_position])
 
-    left_Ytrain = Ytrain[Xtrain[:, i] <= mean]
-    left_Xtrain = Xtrain[Xtrain[:, i] <= mean]
+    left_position = Xtrain[:, i] <= mean
+    left_Ytrain = Ytrain[left_position]
+    left_Xtrain = Xtrain[left_position]
     # left_Xtrain = np.delete(left_Xtrain, i, axis=1)
-    left_node = fit(left_Xtrain, left_Ytrain, parent_node, depth + 1, weights[Xtrain[:, i] <= mean])
+    left_node = fit(left_Xtrain, left_Ytrain, parent_node, depth + 1, weights[left_position])
 
     parent_node.left = left_node
     parent_node.right = right_node
@@ -334,7 +340,7 @@ if __name__ == '__main__':
 
     print("基尼指数", cal_gini(Ytrain))
 
-    print("信息增益率", cal_ent_attr_c45(Xtrain, Ytrain))
+    print("信息增益率", cal_ent_attr_c45(Xtrain, Ytrain, weights))
 
     node = fit(Xtrain, Ytrain, None, 0, weights)
     print_width([node], 1)