Adaboost算法

Yeahhh！

已于 2024-05-17 17:10:19 修改

阅读量1.3k

点赞数 22

分类专栏：机器学习文章标签：机器学习算法人工智能

于 2024-04-09 19:34:21 首次发布

本文链接：https://blog.csdn.net/qq_62767376/article/details/137564509

版权

机器学习专栏收录该内容

16 篇文章 1 订阅

订阅专栏

第1关：什么是集成学习

任务描述

本关任务：根据本节课所学知识完成本关所设置的选择题。

闯关要求

根据所学知识完成右侧选择题！！！

1、对于一个二分类问题，假如现在训练了500个子模型，每个模型权重大小一样。若每个子模型正确率为51%，则整体正确率为多少？若把每个子模型正确率提升到60%，则整体正确率为多少？（C)


A、51%,60%

B、60%,90%

C、65.7%,99.99%

D、65.7%，90%

第2关： Boosting

任务描述

本关任务：根据本节课所学知识完成本关所设置的选择题。 ####相关知识为了完成本关任务，你需要掌握：1.Boosting。 #####Boosting 提升方法基于这样一种思想：对于一个复杂任务来说，将多个专家的判断进行适当的综合所得出的判断，要比其中任何一个专家单独的判断好。

历史上，Kearns和Valiant首先提出了强可学习和弱可学习的概念。指出：在PAC学习的框架中，一个概念，如果存在一个多项式的学习算法能够学习它，并且正确率很高，那么就称这个概念是强可学习的；一个概念，如果存在一个多项式的学习算法能够学习它，学习的正确率仅比随机猜测略好，那么就称这个概念是弱可学习的。非常有趣的是Schapire后来证明强可学习与弱可学习是等价的，也就是说，在PAC学习的框架下，一个概念是强可学习的充分必要条件是这个概念是弱可学习的。

这样一来，问题便成为，在学习中，如果已经发现了弱学习算法，那么能否将它提升为强学习算法。大家知道，发现弱学习算法通常要比发现强学习算法容易得多。那么如何具体实施提升，便成为开发提升方法时所要解决的问题。

与bagging不同，boosting采用的是一个串行训练的方法。首先，它训练出一个弱分类器，然后在此基础上，再训练出一个稍好点的弱分类器，以此类推，不断的训练出多个弱分类器，最终再将这些分类器相结合，这就是boosting的基本思想，流程如下图：

可以看出，子模型之间存在强依赖关系，必须串行生成。boosting是利用不同模型的相加，构成一个更好的模型，求取模型一般都采用序列化方法，后面的模型依据前面的模型。

1、现在有一份数据，你随机的将数据分成了n份，然后同时训练n个子模型，再将模型最后相结合得到一个强学习器，这属于boosting方法吗？（B)

A、是

B、不是

C、不确定

第3关：Adaboost算法流程

任务描述

本关任务：用Python实现Adaboost，并通过鸢尾花数据集中鸢尾花的2种属性与种类对Adaboost模型进行训练。我们会调用你训练好的Adaboost模型，来对未知的鸢尾花进行分类。

编程要求

根据提示，在右侧编辑器补充 Python 代码，实现Adaboost算法，并利用训练好的模型对鸢尾花数据进行分类。

测试说明

只需返回分类结果即可，程序内部会检测您的代码，预测正确率高于95%视为过关。

#encoding=utf8

import numpy as np

#adaboost算法
class AdaBoost:
    '''
    input:n_estimators(int):迭代轮数
          learning_rate(float):弱分类器权重缩减系数
    '''
    def __init__(self, n_estimators=50, learning_rate=1.0):
        self.clf_num = n_estimators
        self.learning_rate = learning_rate
    
    def init_args(self, datasets, labels):
        
        self.X = datasets
        self.Y = labels
        self.M, self.N = datasets.shape
        
        # 弱分类器数目和集合
        self.clf_sets = []
        
        # 初始化weights
        self.weights = [1.0/self.M]*self.M
        
        # G(x)系数 alpha
        self.alpha = []    
    def _G(self, features, labels, weights):
        '''
        input:features(ndarray):数据特征
              labels(ndarray):数据标签
              weights(ndarray):样本权重系数
        '''
        #********* Begin *********#
        m = len(features)
        error = 100000.0 # 无穷大
        beat_v = 0.0
        #单维features
        features_min = min(features)
        features_max = max(features)
        n_step = (features_max-features_min+self.learning_rate) // self.learning_rate
        direct,compare_array = None,None
        for i in range(1,int(n_step)):
            v = features_min + self.learning_rate * i

            if v not in features:
                # 误分类计算
                compare_array_positive = np.array(
                    [1 if features[k] > v else -1 for k in range(m)])
                weight_error_positive = sum([
                    weights[k] for k in range(m)
                    if compare_array_positive[k] != labels[k]
                ])

                compare_array_nagetive = np.array(
                    [-1 if features[k] > v else 1 for k in range(m)])
                weight_error_nagetive = sum([
                    weights[k] for k in range(m)
                    if compare_array_nagetive[k] != labels[k]
                ])

                if weight_error_positive < weight_error_nagetive:
                    weight_error = weight_error_positive
                    _compare_array = compare_array_positive
                    direct = 'positive'
                else:
                    weight_error = weight_error_nagetive
                    _compare_array = compare_array_nagetive
                    direct = 'nagetive'

                # print('v:{} error:{}'.format(v, weight_error))
                if weight_error < error:
                    error = weight_error
                    compare_array = _compare_array
                    best_v = v
        return best_v, direct, error, compare_array
    # 计算alpha
    def _alpha(self, error):
        return 0.5 * np.log((1 - error) / error)

    # 规范化因子
    def _Z(self, weights, a, clf):
        return sum([
            weights[i] * np.exp(-1 * a * self.Y[i] * clf[i])
            for i in range(self.M)
        ])

    # 权值更新
    def _w(self, a, clf, Z):
        for i in range(self.M):
            self.weights[i] = self.weights[i] * np.exp(
                -1 * a * self.Y[i] * clf[i]) / Z

    # G(x)的线性组合
    def _f(self, alpha, clf_sets):
        pass

    def G(self, x, v, direct):
        if direct == 'positive':
            return 1 if x > v else -1
        else:
            return -1 if x > v else 1

    def fit(self, X, y):
        self.init_args(X, y)

        for epoch in range(self.clf_num):
            axis = 0
            final_direct = 'null'
            best_clf_error, best_v, clf_result = 100000, None, None
            # 根据特征维度, 选择误差最小的
            for j in range(self.N):
                features = self.X[:, j]
                # 分类阈值，分类误差，分类结果
                v, direct, error, compare_array = self._G(
                    features, self.Y, self.weights)

                if error < best_clf_error:
                    best_clf_error = error
                    best_v = v
                    final_direct = direct
                    clf_result = compare_array
                    axis = j  # axis数字代表第几个属性列

                # print('epoch:{}/{} feature:{} error:{} v:{}'.format(epoch, self.clf_num, j, error, best_v))
                if best_clf_error == 0:
                    break

            # 计算G(x)系数a
            a = self._alpha(best_clf_error)
            self.alpha.append(a)
            # 记录分类器
            self.clf_sets.append((axis, best_v, final_direct))
            # 规范化因子
            Z = self._Z(self.weights, a, clf_result)
            # 权值更新
            self._w(a, clf_result, Z)
                

        #********* End *********#            
    def predict(self, feature):
        result = 0.0
        for i in range(len(self.clf_sets)):
            axis, clf_v, direct = self.clf_sets[i]
            f_input = feature[axis]
            result += self.alpha[i] * self.G(f_input, clf_v, direct)
        # sign
        return 1 if result > 0 else -1
    
    def score(self, X_test, y_test):
        right_count = 0
        for i in range(len(X_test)):
            feature = X_test[i]
            if self.predict(feature) == y_test[i]:
                right_count += 1
        
        return right_count / len(X_test)

第4关：sklearn中的Adaboost

任务描述

本关任务：你需要调用sklearn中的Adaboost模型，并通过鸢尾花数据集中鸢尾花的2种属性与种类对Adaboost模型进行训练。我们会调用你训练好的Adaboost模型，来对未知的鸢尾花进行分类。

编程要求

填写ada_classifier(train_data,train_label,test_data)函数完成鸢尾花分类任务，其中：

train_data：训练样本
train_label：训练标签
test_data：测试样本

测试说明

只需返回预测结果即可，程序内部会检测您的代码，预测正确率高于95%视为过关。

#encoding=utf8
from sklearn.tree import DecisionTreeClassifier
from sklearn.ensemble import AdaBoostClassifier

def ada_classifier(train_data,train_label,test_data):
    '''
    input:train_data(ndarray):训练数据
          train_label(ndarray):训练标签
          test_data(ndarray):测试标签
    output:predict(ndarray):预测结果
    '''
    #********* Begin *********#
    ada=AdaBoostClassifier(base_estimator=DecisionTreeClassifier
         (max_depth=2,min_samples_split=10,min_samples_leaf=5),
         n_estimators=50,learning_rate=0.2)
    ada.fit(train_data,train_label)
    predict=ada.predict(test_data)

    

    #********* End *********# 
    return predict

Yeahhh！

关注

22
点赞
踩
24

收藏

觉得还不错? 一键收藏
0
评论
Adaboost算法

集成学习方法是一种常用的机器学习方法，分为bagging与boosting两种方法，应用十分广泛。集成学习基本思想是：对于一个复杂的学习任务，我们首先构造多个简单的学习模型，然后再把这些简单模型组合成一个高效的学习模型。实际上，就是“三个臭皮匠顶个诸葛亮”的道理。集成学习采取投票的方式来综合多个简单模型的结果，按bagging投票思想，如下面例子：假设一共训练了5个简单模型，每个模型对分类结果预测如上图，则最终预测结果为：A:2B:33>2结果为B。
复制链接

扫一扫