24/8/11算法笔记AdaBoost二分类算法进阶

最新推荐文章于 2024-09-14 22:25:23 发布
最新推荐文章于 2024-09-14 22:25:23 发布
阅读量913 收藏 12
点赞数 15
文章标签： 算法 笔记 分类
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yyyy2711/article/details/141107887
版权

AdaBoost（Adaptive Boosting）是一种流行的集成学习算法，特别适用于二分类问题。它通过组合多个弱分类器来构建一个强分类器，提高模型的预测性能。以下是 AdaBoost 算法的关键步骤和特点：

  1. 初始化：为训练数据集中的每个样本分配初始权重，通常所有样本的初始权重都是相等的。

  2. 迭代训练弱分类器：在每一轮迭代中，AdaBoost 训练一个弱分类器（通常是决策树桩或感知机）。每个弱分类器尝试基于当前样本权重进行预测。

  3. 计算错误率：计算当前弱分类器的错误率，即它错误分类的样本所占的比例。

  4. 计算弱分类器的权重：根据错误率计算弱分类器的权重（alpha）。错误率越低，分配给该弱分类器的权重越大。

  5. 更新样本权重：根据当前弱分类器的性能更新所有样本的权重。被当前弱分类器错误分类的样本的权重会增加，而正确分类的样本的权重会减少。

  6. 归一化：调整总权重，使得所有样本权重的总和为1。

  7. 组合弱分类器：将所有弱分类器的预测结果结合起来，形成最终的强分类器。对于二分类问题，通常是通过加权多数投票来实现的。

  8. 终止条件：达到预定的迭代次数，或者当添加更多的弱分类器不再显著提高模型性能时停止。

AdaBoost 算法的特点包括：

  • 适应性强：AdaBoost 能够适应数据的变化，通过不断调整样本权重来关注难以分类的样本。
  • 易于实现：AdaBoost 算法相对容易实现，并且可以应用于各种类型的弱分类器。
  • 对噪声和异常值敏感：AdaBoost 可能会过度关注被错误分类的样本，包括噪声和异常值。
  • 容易解释：AdaBoost 构建的模型相对容易解释，因为它是基于一系列简单的弱分类器。
  • 提高性能：AdaBoost 通过集成多个弱分类器，通常能够显著提高模型的预测性能。

import numpy as np
import matplotlib.pyplot as plt
x = np.linspace(-1,1,50)

y = np.exp(x)
print('--------------',np.exp(0))
print('**************',np.exp(-0.2))
print('++++++++++++++',np.exp(0.3))
plt.plot(x,np.full(50,fill_value=1))
plt.plot(x,y)

手撕代码

创建数据
import numpy as np
from sklearn.ensemble import AdaBoostClassifier
import graphviz
from sklearn import tree

X = np.arange(10).reshape(-1,1)#二维，机器学习要求数据必须是二维

y = np.array([1,1,1,-1,-1,-1,1,1,1,-1])
display(X,y)

使用AdaBoost建模
#SAMME 表示构建树的时候，采用相同的裂分方式
model = AdaBoostClassifier(n_estimators=3,algorithm='SAMME')

model.fit(X,y)

y_=model.predict(X)
display(y,y_)#准确率100%

第一棵树可视化
print('第一棵树是什么',model[0])
dot_data = tree.export_graphviz(model[0],filled=True,rounded=True)
graphviz.Source(dot_data)

第二第二棵树

dot_data = tree.export_graphviz(model[1],filled=True,rounded=True)
graphviz.Source(dot_data)

第三棵树
dot_data = tree.export_graphviz(model[2],filled=True,rounded=True)
graphviz.Source(dot_data)

第一棵树代码构建

w1 = np.full(shape = 10,fill_value=0.1)#初始的样本权重

cond = y ==1#类别1条件
p1 = w1[cond].sum()
p2 = 1-p1
display(p1,p2)

gini1 = p1*(1-p1)+p2*(1-p2)
print('方式1计算gini系数',gini1)

gini2 = 1-p1**2-p2**2
print('方式2计算gini系数',gini2)

拆分条件计算
gini_result = []
best_split = {}#最佳裂分条件，X[0]<=2.5
lower_gini = 1#比较

for i in range(len(X)-1):
    split = X[i:i+2].mean()#裂分条件
    cond = (X<=split).ravel()#变成一维的，左边数据
    left = y[cond]
    right = y[~cond]#取反
    
    gini_left = 0
    gini_right = 0
    for j in np.unique(y):#y表示类别
        p_left = (left ==j).sum()/left.size#计算左边某个类别的概率
        gini_left = p_left*(1-p_left)
        p_right = (right ==j).sum()/right.size
        gini_right = p_right*(1-p_right)
        
    #左右两边的gini系数合并
    left_p = cond.sum()/cond.size
    right_p = 1-left_p
    
    gini = gini_left*left_p+gini_right*right_p
    gini_result.append(gini)
    if gini<lower_gini:
        lower_gini = gini
        best_split.clear()
        best_split['X[0]<='] = split
print(gini_result)
print('最佳裂分条件是')
print(best_split)

计算误差
y1_ = model[0].predict(X)#某个大夫问诊情况

error1=(y!=y1_).mean()
error1
0.3
from sklearn.metrics import accuracy_score

accuracy_score(y,y1_)
0.7
accuracy = (y==y1_).mean()
accuracy

0.7

计算第一个弱学习器（决策树，大夫）的权重

alpha_1=1/2*np.log((1-error1)/error1)
alpha_1
0.42364893019360184
alpha_1=1/2*np.log(accuracy/(1-accuracy))
alpha_1
0.4236489301936017
更新样本权重
w1#没有训练学习，所以都一样

#上一次权重的基础上进行更新

#y表示真实的目标值
#ht[X]表示当前弱学习器预测的结果
w2 = w1*np.exp(-alpha_1*y*y1_)
w2 = w2/w2.sum()#权重归一化
display(w1,w2)
display(y,y1_)

#算法预测所悟的样本

第二棵树代码构建
y

cond = y ==-1
w2[cond].sum()
0.2857142857142857
cond2 =y ==1
np.round(w2[cond2].sum(),3)

gini系数计算

print(w2)

cond = y == 1#类别1条件
p1 = w2[cond].sum()   #使用新的样本权重分布
p2 = 1-p1
display(p1,p2)

gini1 = p1*(1-p1)+p2*(1-p2)
print('方式1计算gini系数',gini1)

gini2 = 1-p1**2-p2**2
print('方式2计算gini系数',gini2)

拆分条件的计算
gini_result = []
best_split = {}#最佳裂分条件，X[0]<=2.5
lower_gini = 1#比较

for i in range(len(X)-1):
    split = X[i:i+2].mean()#裂分条件
    cond = (X<=split).ravel()#变成一维的，左边数据
    left = y[cond]
    right = y[~cond]#取反
    
    # left_p = cond.sum()/cond.size  #这种方式适用于每个样本权重一样
    left_p = w2[cond]/w2[cond].sum() #归一化，左侧每个样本在自己组内的概率
    right_p = w2[~cond]/w2[~cond].sum()#归一化右侧每个样本在自己组内概率
    
    #左右两个边的gini系数
    gini_left = 0
    gini_right = 0
    for j in np.unique(y):#y表示类别
        cond_left = left ==j #左侧某个类别
        p1 = left_p[cond_left].sum()#左侧某个类别的概率
        gini_left += p1*(1-p1)
        
        cond_right = right ==j #右侧某个类别
        p2 = right_p[cond_right].sum()#右侧某个类别的概率
        gini_right += p2*(1-p2)
        
    #左右两边的gini系数合并

    p1=cond.sum()/cond.size #左侧划分数据所占比例
    p2 = 1 -p1#右侧划分数据所占比例
    gini = gini_left*p1+gini_right*p2
    gini_result.append(gini)
    if gini<lower_gini:
        lower_gini = gini
        best_split.clear()
        best_split['X[0]<='] = split
print(gini_result)
print('最佳裂分条件是')
print(best_split)

计算误差
y2_ = model[1].predict(X)#某个大夫问诊情况

error2=(y!=y2_).mean()
error2
0.3
error2 = ((y!=y2_)*w2).sum()#考虑权重，因为即使错了，误差也小
error2

0.21428571428571427

计算第二个弱学习器权重
alpha_2=1/2*np.log((1-error2)/error2)
alpha_2
0.6496414920651304
#上一次权重的基础上进行更新

#y表示真实的目标值
#ht[X]表示当前弱学习器预测的结果
w3 = w2*np.exp(-alpha_2*y*y2_)
w3 = w3/w3.sum()     #权重归一化
w3

第三棵树代码构建
gini系数
cond = y ==1#类别1条件
p1 = w3[cond].sum()   #使用新的样本权重分布
p2 = 1-p1
display(p1,p2)

gini1 = p1*(1-p1)+p2*(1-p2)
print('方式1计算gini系数',gini1)

gini2 = 1-p1**2-p2**2
print('方式2计算gini系数',gini2)

拆分条件计算
gini_result = []
best_split = {}#最佳裂分条件，X[0]<=2.5
lower_gini = 1#比较

for i in range(len(X)-1):
    split = X[i:i+2].mean()#裂分条件
    cond = (X<=split).ravel()#变成一维的，左边数据
    left = y[cond]
    right = y[~cond]#取反
    
    # left_p = cond.sum()/cond.size  #这种方式适用于每个样本权重一样
    left_p = w3[cond]/w3[cond].sum() #归一化，左侧每个样本在自己组内的概率
    right_p = w3[~cond]/w3[~cond].sum()#归一化右侧每个样本在自己组内概率
    
    #左右两个边的gini系数
    gini_left = 0
    gini_right = 0
    for j in np.unique(y):#y表示类别
        cond_left = left ==j #左侧某个类别
        p1 = left_p[cond_left].sum()#左侧某个类别的概率
        gini_left += p1*(1-p1)
        
        cond_right = right ==j #右侧某个类别
        p2 = right_p[cond_right].sum()#右侧某个类别的概率
        gini_right += p2*(1-p2)
        
    #左右两边的gini系数合并

    p1=cond.sum()/cond.size #左侧划分数据所占比例
    p2 = 1-p1#右侧划分数据所占比例
    gini = gini_left*p1+gini_right*p2
    gini_result.append(gini)
    if gini<lower_gini:
        lower_gini = gini
        best_split.clear()
        best_split['X[0]<='] = split
print(gini_result)
print('最佳裂分条件是')
print(best_split)

计算误差
y3_ = model[2].predict(X)#某个大夫问诊情况

error3=((y!=y3_)*w3).sum()
error3

计算第三棵树的权重
alpha_3=1/2*np.log((1-error3)/error3)
alpha_3
0.752038698388137
更新权重
#上一次权重的基础上进行更新

#y表示真实的目标值
#ht[X]表示当前弱学习器预测的结果
w4 = w3*np.exp(-alpha_3*y*y3_)
w4 = w4/w4.sum()     #权重归一化
w4

弱学习器聚合
print('每一个弱学习器的预测结果')
display(y1_,y2_,y3_)
F = alpha_1*y1_+alpha_2*y2_+alpha_3*y3_
#得多个弱学习器，整合，变成了强分类器F(x)
print('强分类器合并结果\n',F)
print('强分类器最终结果如下\n',np.array([1 if i>0 else-1 for i in F]))

print('算法预测结果\n',model.predict(X))

算法VS自己的代码
model.estimator_errors_#三棵树的误差情况
array([0.3       , 0.21428571, 0.18181818])
print('自己计算的误差',error1,np.round(error2,8),np.round(error3,8))
自己计算的误差 0.3 0.21428571 0.18181818
model.estimator_weights_ #权重==话语权
array([0.84729786, 1.29928298, 1.5040774 ])
print('自己计算的权重',np.round(2*alpha_1,8),np.round(2*alpha_2,8),np.round(2*alpha_3,8))
自己计算的权重 0.84729786 1.29928298 1.5040774
计算概率
model.predict_proba(X)#类别大，划分到对应哪个类别

model.predict(X)
array([ 1,  1,  1, -1, -1, -1,  1,  1,  1, -1])

手写代码计算概率

#计算类别
y1_proba = (y1_ == np.array([[-1],[1]])).T.astype(np.int8)
y1_proba

y2_proba = (y2_ == np.array([[-1],[1]])).T.astype(np.int8)
y2_proba

y3_proba = (y3_ == np.array([[-1],[1]])).T.astype(np.int8)
y3_proba

proba = y1_proba*alpha_1*2+y2_proba*alpha_2*2+y3_proba*alpha_3*2
proba/=(alpha_1+alpha_2+alpha_3)*2
proba

proba[:,0]*=-1
proba

proba = proba.sum(axis=1)
proba

#拆分
proba = np.vstack([-proba,proba]).T/2
proba

#softmax概率转换
np.exp(proba)/(np.exp(proba)).sum(axis=1).reshape(-1,1)

model.predict_proba(X)

青椒大仙KI11
关注
白话机器学习算法理论+实战之EM聚类
Miracle8070
02-14 3354
1. 写在前面 如果想从事数据挖掘或者机器学习的工作，掌握常用的机器学习算法是非常有必要的，比如我之前写过的一篇十大机器学习算法的小总结，在这简单的先捋一捋， 常见的机器学习算法： 监督学习算法：逻辑回归，线性回归，决策树，朴素贝叶斯，K近邻，支持向量机，集成算法Adaboost等 无监督算法：聚类，降维，关联规则, PageRank等 为了详细的理解这些原理，曾经看过西瓜书，统计学习方法，机...
算法岗常见面试题
热门推荐
炼金术的修行
09-06 1万+
深度学习/机器学习 1.讲一讲faster_rcnn RCNN 首先从rcnn讲起，rcnn可以称得上是用深度学习进行目标检测的开山之作。其方法是首先用Selective Search算法选出约2000-3000个候选区域(region proposal)，然后将这些区域图块归一化成227*227的图像，再通过CNN提取特征，得到4096维的特征。接下来分为两步：对上面每一个区域得到的特征都用一...
说一下Adaboost，权值更新公式。当弱分类器是Gm时，每个样本的的权重是w1，w2...，请写出最终的决策公式。
weixin_48331187的博客
10-20 541
权值更新公式是Adaboost算法关键的一部分，通过关注分类错误的样本并调整样本权重，使得模型更加关注错误样本，提高整体的分类准确率。权重更新公式为：wij^(m+1) = wij^(m) * exp(-αm) / Zm，其中Zm是归一化因子，保证样本权重之和为1。权重更新公式为：wij^(m+1) = wij^(m) * exp(αm) / Zm，其中Zm是归一化因子。其中，αm等于 ln((1 - ɛm) / ɛm)，ɛm是该轮分类器的误差率，即被错误分类的样本权重之和。
数据挖掘：理论与算法学习笔记
m0_52899614的博客
12-28 1949
后剪枝则是先从训练集中生成一棵完整的决策树，然后自底向上的考察每一个非叶结点，和预剪枝相反，如果将该结点对应的子树替换为叶结点能给决策树带来性能上的提升，则将该子树替换为叶结点。原理：根据特征的先验概率（训练样本分析得到的概率），利用贝叶斯公式计算出其后验概率（要分类对象特征的条件概率），选择概率值最大的类作为该特征所属的类。信息增益越大越好，即该属性的效能越高，越有区分度。Elman Network：此算法有一定的记忆性，通过之前的输入推出答案，输出不仅仅取决于当前的输入，还取决于之前的输入。
AdaBoost算法分类
qq_34739497的博客
11-26 733
前言 在我们学习AdaBoost算法之前我们可以先来了解一下起源，增加一下学习兴趣。 boost 算法系列的起源来自于PAC Learnability(PAC 可学习性)。这套理论主要研究的是什么时候一个问题是可被学习的，当然也会探讨针对可学习的问题的具体的学习算法。这套理论是由Valiant提出来的，也因此（还有其他贡献哈）他获得了2010年的图灵奖。同时 ,Valiant和 Kearns首
笔记——AdaBoost算法
qq_25222187的博客
11-23 272
Outline 弱学习算法「提升」为强学习算法的理论依据 Adaboost 算法 Adaboost 算法的例子 Adaboost 算法的例子的实现步骤 思考   1. 弱学习算法「提升」为强学习算法的理论依据： 因此新问题是「如果存在弱学习算法，那么能否把它们提升为强学习算法？」 提升方法boosting：常用的统计学习方法。在分类问题中通过改变训练样本的权重，学习多个分类...
一文速学-XGBoost模型算法原理以及实现+Python项目实战_xgboost金融领域模型实战
2401_84166376的博客
04-28 1075
集成模型Boosting补完计划第三期了，之前我们已经详细描述了AdaBoost算法模型和GBDT原理以及实践。通过这两类算法就可以明白Boosting算法的核心思想以及基本的运行计算框架，余下几种Boosting算法都是在前者的算法之上改良得到，尤其是以GBDT算法为基础改进衍生出的三种Boosting算法：XGBoost、LightGBM、CatBoost。
机器学习算法笔记 集成学习模型融合
YUN_L_I的博客
09-16 544
集成学习（Ensemble Learning），广泛用于分类和回归任务。最初的思想：使用一些（不同的）方法改变原始训练样本的分布，从而构建多个不同的分类器，并将这些分类器线性组合得到一个更强大的分类器，来做最后的决策。 集成学习的理论基础来自于Kearns 和 Valiant提出的基于PAC（probably approximately correct）的可学习理论，PAC定义了学习算法的强弱：...
计算左边（比自己小的元素）的最长距离
wniuniu_的博客
09-14 106
前言：一般做的题目都是使用单调栈来求出距离这个点最近的那个比这个数大或小的元素，但是如果是需要找到最远的那个元素呢？我们可以用到类似逆序对的思路，我们先进行排序从小到大，接着我们先处理左边，每次维护一个最小的下标。
Java数据结构（十）——冒泡排序、快速排序
xiaokuer_的博客
09-11 1060
文章介绍了冒泡排序和快速排序，快速排序的内容包括：划分方式、优化策略以及非递归实现
深度优先算法，广度优先算法，hill climbing，贪心搜索，A*算法，启发式搜索算法是什么，比起一般搜索法算法有什么区别
mimo_mimo的博客
09-10 1133
A算法通过维护一个优先队列（通常是最小堆），并根据启发式函数（如g(n) + h(n)，其中g(n)是从起点到当前点的实际距离，h(n)是从当前点到目标点的估计距离）来评估节点的优先级。它从图的某个顶点V0开始，依次访问V0的各个未被访问过的邻接点，然后从这些邻接点出发，再依次访问它们的未被访问过的邻接点，直到图中所有已被访问过的顶点的邻接点都被访问到。它从当前的节点开始，和周围的邻居节点的值进行比较，如果当前节点不是最大的，就用最高的邻居节点来替换当前节点，从而实现向“山峰”的高处攀爬的目的。
C语言程序设计-练习篇
最新发布
2402_85207276的博客
09-14 622
·三角形的判断 ·使用指针打印数组内容 ·字符串逆序 ·计算求和 ·打印水仙花数
专题三_二分查找算法_算法详细总结
2301_80636070的博客
09-09 977
二分查找经典题目。首先最重要的就是判断循环的结束条件，left>right,因为在这之前，left==right的时候，仍然要判断一次nums[left]是否等于target，所以循环条件就是while(left
Codeforces Round 969 (Div. 2) C. Dora and C++ （裴蜀定理）
2302_79440616的博客
09-10 412
取模，这样就能够得到所有数的最简形式（可以当成是让所有数尽可能消去。所以在这时候我们就可以让输入的所有数都去对。那么在取模之后我们现在排序，得到的极差就是。可以想到使用同样是需要给出两个定值的。由于这里给出了a和b两个数，我们。的判断，因为不排除有这种情况存在。，那么这里我们还要进行一次。，这样我们会取到最优解。
leecode100题-双指针-三数之和
kian9one的博客
09-10 390
固定i，即可转换为寻找满足 nums[l]+nums[r]=−nums[i] 的三元组，因为不能包含重复的三元组，以下两个三元组只能取一个，而后我们再考虑其是否满足 nums[l]+nums[r]=−nums[i]。先对数组排序，设一非递减的数组示例和初始三指针位置及名字如下所示。不同的三元组是 [-1,0,1] 和 [-1,-1,2]。移动指针的时候，需要规避连续的重复元素。答案中不可以包含重复的三元组。，判断是否存在三元组。
拥塞控制算法为何失效，网络为何难以测量？
Netfilter
09-14 1090
所以你知道实验室仿真的宇宙第一算法为啥拉了吧，也就不用再问为什么部署了 bbr 却还不如 cubic 了吧，如果你还希望研发一个精准的，普适的端到端算法，我劝你改行去卖皮鞋，至少还有很多经理市场。这和上一篇说的测量系统容量的方法并不矛盾，因为对于网络传输系统而言，系统是动态变化的，在流量部署到系统上并开始传输时，没有全局视图，就不能指望全局公平，留下的 gap 是固有的，没法靠算法弥补。，超级经典的一篇论文，我推荐过不止一次，因此我本文不谈异构问题，说点别的，比如拓扑。对，就是要砸，因为我不干了。
92-java 分代回收算法
weixin_41775999的博客
09-14 142
Java的垃圾收集器使用了分代垃圾收集策略，这是基于这样一个假设：不同的对象的生命周期是不一样的。年轻代（Young Generation）、老年代（Old Generation）和永久代（Perm Generation，在Java 8中被元数据区取代）在这个例子中，我们创建了一个新的Object对象，然后将它的引用设置为null，这样这个对象就不再被任何活动线程引用，符合垃圾收集的条件。方法，通知JVM执行垃圾收集，但是具体何时发生垃圾收集是不确定的，取决于JVM的垃圾收集策略和运行环境。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值