• 知道boosting集成原理和实现过程
• 知道bagging和boosting集成的区别
• 知道AdaBoost集成原理

• 每一个训练器重点关注前一个训练器不足的地方进行训练
• 通过加权投票的方式，得出预测结果
• 串行的训练方式

• 区别一:数据方面
  • Bagging：对数据进行采样训练；
  • Boosting：根据前一轮学习结果调整数据的重要性。
• 区别二:投票方面
  • Bagging：所有学习器平权投票；
  • Boosting：对学习器进行加权投票。
• 区别三:学习顺序
  • Bagging的学习是并行的，每个学习器没有依赖关系；
  • Boosting学习是串行，学习有先后顺序。
• 区别四:主要作用
  • Bagging主要用于提高泛化性能（解决过拟合，也可以说降低方差）
  • Boosting主要用于提高训练精度 （解决欠拟合，也可以说降低偏差）

1. 初始化工作：初始化 10 个样本的权重，每个样本的权重为：0.1
2. 构建第一个基学习器：

a.寻找最优分裂点

- 1.对特征值 x 进行排序，确定分裂点为：0.5、1.5、2.5、3.5、4.5、5.5、6.5、7.5、8.5
- 2.当以 0.5 为分裂点时，有 5 个样本分类错误，错误率5/10
- 3.当以 1.5 为分裂点时，有 4 个样本分类错误，错误率4/10
- 4.当以 2.5 为分裂点时，有 3 个样本分类错误，错误率3/10
- 5.当以 3.5 为分裂点时，有 4 个样本分类错误，错误率4/10
- 6.当以 4.5 为分裂点时，有 5 个样本分类错误，错误率5/10
- 7.当以 5.5 为分裂点时，有 4 个样本分类错误，错误率4/10
- 8.当以 6.5 为分裂点时，有 5 个样本分类错误，错误率5/10
- 9.当以 7.5 为分裂点时，有 4 个样本分类错误，错误率4/10
- 10.当以 8.5 为分裂点时，有 3 个样本分类错误，错误率3/10
- 11.最终，选择以 2.5 作为分裂点（出现相同概率的情况使用奥卡姆剃刀选择最简单的情况），计算得出基学习器错误率为：3/10=0.3

b.计算模型权重: 1/2 * np.log((1-0.3)/0.3)=0.4236  （numpy中的计算公式np.log）

1. 构建第二个弱学习器

1.寻找最优分裂点：

• 对特征值 x 进行排序，确定分裂点为：0.5、1.5、2.5、3.5、4.5、5.5、6.5、7.5、8.5
• 当以 0.5 为分裂点时，有 5 个样本分类错误，错误率为：0.07143 * 2 +0.16667 * 3= 0.64287
• 当以 1.5 为分裂点时，有 4 个样本分类错误，错误率为：0.07143 * 1 + 0.16667 * 3 = 0.57144       
• 当以 2.5 为分裂点时，有 3 个样本分类错误，错误率为：0.16667 * 3 = 0.57144。。。 。。。
• 当以 8.5 为分裂点时，有 3 个样本分类错误，错误率为：0.07143 * 3  = 0.21429
• 最终，选择以 8.5 作为分裂点，计算得出基学习器错误率为：0.21429

2.计算模型权重：1/2 * np.log((1-0.21429)/0.21429)=0.64963

3.分类正确的样本：1、2、3、7、8、9、10，其权重调整系数为：0.5222

4.分类错误的样本：4、5、6，其权重调整系数为：1.9148

5.分类正确样本权重值：

        a.样本 0、1、2、、9 为：0.0373

        b.样本 6、7、8 为：0.087

6.分类错误样本权重值：0.1368

7.归一化 Zt 值为：0.0373 * 4 + 0.087 * 3 + 0.1368 * 3 = 0.8206

8.最终权重：

        a.样本 0、1、2、9 为 ：0.0455

        b.样本 6、7、8 为：0.1060

        c.样本 3、4、5 为：0.1667

此时得到：

• 构建第三个弱学习器

• 强学习器

• from sklearn.ensemble import AdaBoostClassifier
  • api链接:AdaBoostClassifier — scikit-learn 1.6.1 documentation

from sklearn.preprocessing import LabelEncoder

# 创建一个 LabelEncoder 对象
le = LabelEncoder()

# 假设我们有一些类别标签
labels = ['cat', 'dog', 'mouse', 'cat', 'dog']

# 使用 fit_transform 方法将标签转换为整数编码
encoded_labels = le.fit_transform(labels)

print(encoded_labels)  # 输出: [0 1 2 0 1]

# 如果需要将整数编码转换回原始标签，可以使用 inverse_transform 方法
original_labels = le.inverse_transform(encoded_labels)

print(original_labels)  # 输出: ['cat' 'dog' 'mouse' 'cat' 'dog']

• 0：表示类别标签 'cat'。在输入列表 ['cat', 'dog', 'bird', 'cat', 'bird'] 中，'cat' 是第一个出现的类别标签，因此被分配了整数标签 0。
• 1：表示类别标签 'dog'。'dog' 是第二个出现的类别标签，因此被分配了整数标签 1。
• 2：表示类别标签 'bird'。'bird' 是第三个出现的类别标签，因此被分配了整数标签 2。

• 重复标签：

# 获取数据
import pandas as pd
df_wine = pd.read_csv('data/wine.data')

# 修改列名
df_wine.columns = ['Class label', 'Alcohol', 'Malic acid', 'Ash', 'Alcalinity of ash', 'Magnesium', 'Total phenols',
'Flavanoids', 'Nonflavanoid phenols', 'Proanthocyanins', 'Color intensity', 'Hue', 'OD280/OD315 of diluted wines',
'Proline']

# 去掉一类(1,2，3)
df_wine = df_wine[df_wine['Class label'] != 1]

# 获取特征值和目标值
X = df_wine[['Alcohol', 'Hue']].values
y = df_wine['Class label'].values
​
from sklearn.preprocessing import LabelEncoder
from sklearn.model_selection import train_test_split

# 类别转化 (2,3)=>(0,1)
le = LabelEncoder()
y = le.fit_transform(y)

# 划分训练集和测试集
X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.4,random_state=1)
​
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import AdaBoostClassifier

# 机器学习(决策树和AdaBoost)
tree = DecisionTreeClassifier(criterion='entropy',max_depth=1,random_state=0)
ada= AdaBoostClassifier(base_estimator=tree,n_estimators=500,learning_rate=0.1,random_state=0)
from sklearn.metrics import accuracy_score

# 决策树和AdaBoost分类器性能评估
# 决策树性能评估
tree = tree.fit(X_train,y_train)
y_train_pred = tree.predict(X_train)
y_test_pred = tree.predict(X_test)
tree_train = accuracy_score(y_train,y_train_pred)
tree_test = accuracy_score(y_test,y_test_pred)
print('Decision tree train/test accuracies %.3f/%.3f' % (tree_train,tree_test))
# Decision tree train/test accuracies 0.845/0.854
​
# AdaBoost性能评估
ada = ada.fit(X_train,y_train)
y_train_pred = ada.predict(X_train)
y_test_pred = ada.predict(X_test)
ada_train = accuracy_score(y_train,y_train_pred)
ada_test = accuracy_score(y_test,y_test_pred)
print('Adaboost train/test accuracies %.3f/%.3f' % (ada_train,ada_test))
# Adaboost train/test accuracies 1/0.875 

• 什么是Boosting 【知道】
  • 随着学习的积累从弱到强
  • 代表算法：Adaboost，GBDT，XGBoost，LightGBM
• bagging和boosting的区别【知道】
  • 区别一:数据方面
    • Bagging：对数据进行采样训练；
    • Boosting：根据前一轮学习结果调整数据的重要性。
  • 区别二:投票方面
    • Bagging：所有学习器平权投票；
    • Boosting：对学习器进行加权投票。
  • 区别三:学习顺序
    • Bagging的学习是并行的，每个学习器没有依赖关系；
    • Boosting学习是串行，学习有先后顺序。
  • 区别四:主要作用
    • Bagging主要用于提高泛化性能（解决过拟合，也可以说降低方差）
    • Boosting主要用于提高训练精度 （解决欠拟合，也可以说降低偏差）
• AdaBoost构造过程【知道】
  • 步骤一：初始化训练数据权重相等，训练第一个学习器;
  • 步骤二：AdaBoost反复学习基本分类器;
  • 步骤三：对m个学习器进行加权投票