这一期：adaboost的初步实现

# _*_cording = utf.8_*_
# 下一期会出一个以类方式或方法的形式写一个循环迭代的adaboost
import numpy as np
import pandas as pd
# import torch.nn
import sys
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import f1_score, accuracy_score

"""
   adaboost: n 个学习器解决模型欠拟合的问题
           1. 首先计算第一个弱分类器G1;
                    01: 准备数据；
                    02：提取X,Y；
                    03：设定初始化样本权重
                    04：实例化第一个弱分类器并训练（depth=1）
                    05: 统计样本误差率e1;
                    06：根据公式得到第一个弱分类器G1的权重
           2.计算第二个弱分类器G2;
                    01：在一个弱分类器的样本权重w1基础上更新得到w2;
                    02：对样本权重w2归一化；
                    03：实例化弱分类器G2并训练；
                    04：统计样本误差率e2;
                    05: 根据公式得到第二个弱分类器G2的权重；
           3.计算第三个弱分类器G3；
           ....
           5.直到学习器达到一定次数或错误率达到最小值停止迭代
   
           
"""
# 准备数据
df = pd.DataFrame([[0, 1],
                   [1, 1],
                   [2, 1],
                   [3, -1],
                   [4, -1],
                   [5, -1],
                   [6, 1],
                   [7, 1],
                   [8, 1],
                   [9, -1]])

# 提取数据信息
X = df.iloc[:, :-1]
Y = df.iloc[:, -1]
print(X)
print(Y)

# 初始化第一个若学习器的权重
w1 = np.ones(df.shape[0]) / df.shape[0]
print(w1)
# 构造弱分类器G1
model1 = DecisionTreeClassifier(max_depth=1)     # deep=1; 深度为1的分类器
model1.fit(X, Y, sample_weight=w1)

# 计算误差率
print(w1[model1.predict(X) != Y])
e1 = sum(w1[model1.predict(X) != Y])
print('统计后第一个弱学习器的总误差率:', e1)
# 统计第一个G1的权重
a1 = 0.5 * np.log((1-e1)/e1)
print('总的G1的权重a1:', a1)

# 统计第二个弱分类器G2的权重,更新权重
print('_' * 50)
w2 = w1 * np.exp(-a1 * Y * model1.predict(X))
print(w2)
# 归一化w2
w2 = np.array(w2 / sum(w2))
print(w2)
# 实例化弱分类器G2并训练
model2 = DecisionTreeClassifier(max_depth=1)
model2.fit(X, Y, sample_weight=w2)
# 计算误差率
print(w2[model2.predict(X) != Y])
e2 = sum(w2[model2.predict(X) != Y])
# 统计第二个G2的权重
a2 = 0.5 * np.log((1-e2)/e2)
print('总的G2的权重a2:', a2)

# 统计第三个弱分类器G3的权重,更新权重
print('_' * 50)
w3 = w2 * np.exp(-a2 * Y * model2.predict(X))
print(w3)
# 归一化w3
w3 = np.array(w3 / sum(w3))
print(w3)
# 实例化弱分类器G3并训练
model3 = DecisionTreeClassifier(max_depth=1)
model3.fit(X, Y, sample_weight=w3)
# 计算误差率
print(w3[model3.predict(X) != Y])
e3 = sum(w3[model3.predict(X) != Y])
a3 = 0.5 * np.log((1-e3)/e3)
print('G3的权重a3:', a3)

# # 最终分类器的线性组合f3
# f3 = a1 * model1 + a2 * model2 + a3 * model3
# ### 最终分类器G
# G = np.sign(f3)

# 预测
print('--------------------预测----------------------')
y_hat = np.sign(a1 * model1.predict(X) + a2 * model2.predict(X) + a3 * model3.predict(X))
print(Y.tolist())
print(y_hat)


### 结果数据
   0
0  0
1  1
2  2
3  3
4  4
5  5
6  6
7  7
8  8
9  9
0    1
1    1
2    1
3   -1
4   -1
5   -1
6    1
7    1
8    1
9   -1
Name: 1, dtype: int64
[0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1 0.1]
[0.1 0.1 0.1]
统计后第一个弱学习器的总误差率: 0.30000000000000004
总的G1的权重a1: 0.4236489301936017
__________________________________________________
0    0.065465
1    0.065465
2    0.065465
3    0.065465
4    0.065465
5    0.065465
6    0.152753
7    0.152753
8    0.152753
9    0.065465
Name: 1, dtype: float64
[0.07142857 0.07142857 0.07142857 0.07142857 0.07142857 0.07142857
 0.16666667 0.16666667 0.16666667 0.07142857]
[0.07142857 0.07142857 0.07142857]
总的G2权重a2: 0.6496414920651304
__________________________________________________
0    0.037302
1    0.037302
2    0.037302
3    0.136775
4    0.136775
5    0.136775
6    0.087039
7    0.087039
8    0.087039
9    0.037302
Name: 1, dtype: float64
[0.04545455 0.04545455 0.04545455 0.16666667 0.16666667 0.16666667
 0.10606061 0.10606061 0.10606061 0.04545455]
[0.04545455 0.04545455 0.04545455 0.04545455]
总的权重a3: 0.752038698388137
--------------------预测----------------------
[1, 1, 1, -1, -1, -1, 1, 1, 1, -1]
[ 1.  1.  1. -1. -1. -1.  1.  1.  1. -1.]

Process finished with exit code 0