Aadboost分类器原理

最新推荐文章于 2022-04-17 02:03:28 发布
最新推荐文章于 2022-04-17 02:03:28 发布
阅读量649 收藏 3
点赞数
分类专栏： 机器学习

一、分类过程
这里写图片描述

这就是Adaboost的结构，最后的分类器YM是由数个弱分类器（weak classifier）组合而成的,相当于最后m个弱分类器来投票决定分类，而且每个弱分类器的“话语权”α不一样。

这里阐述下算法的具体过程：

这里写图片描述

二、分类原理
可以看到整个过程就是和最上面那张图一样，前一个分类器改变权重w，同时组成最后的分类器
如果一个训练样例 在前一个分类其中被误分，那么它的权重会被加重，相应地，被正确分类的样例的权重会降低
使得下一个分类器 会更在意被误分的样例，那么其中那些α和w的更新是怎么来的呢？
下面我们从前项分步算法模型的角度来看看Adaboost：

这里写图片描述

三、C代码实现
adaboost.h

#ifndef _ADABOOST_H_
#define _ADABOOST_H_ 
#define MAX_FEATURE 100
#define MAX_SAMPLES 500
//#define DEBUG  
struct Sample
{
    double weight;
    double feature[MAX_FEATURE];
    int    indicate;
};
struct SampleHeader
{
    int samplesNum;
    int featureNum;

    //double feature[MAX_SAMPLES][MAX_FEATURE];
    struct Sample samples[MAX_SAMPLES];

};

struct Stump
{
    int left;
    int right;
    double alpha;
    int fIdx;
    double ft;
};

struct Classifier
{
    struct Stump stump;
    struct Classifier* next;
};


struct ClassifierHeader
{
    int classifierNum;
    struct Classifier* classifier;
};
struct IdxHeader
{
    int samplesNum;
    int featureNum;

    double feature[MAX_FEATURE][MAX_SAMPLES];

};

#endif

adaboost.c

#include "stdio.h"
#include "assert.h"
#include "string.h"
#include "stdlib.h"
#include "math.h"
#include "adaboost.h"

//#define DEBUG
#define DATA_NAME ".//ionospheredata.txt"
SampleHeader sampleHeader;
IdxHeader idx;
int k = 0;

//==================================================================
//函数名：  sort
//作者：    qiurenbo
//日期：    2014-11-25
//功能：    冒泡排序
//输入参数：double a[]
//          n   数组长度
//返回值：  无
//修改记录：
//==================================================================
//将弱分类器对每个样本的输出值进行排序
void sort(double a[], int n)
{
    double tmp;
    for (int i = 0; i < n - 1; i++)
    {
        for (int j = 0; j < n - i - 1; j++)
        {
            if (a[j] > a[j + 1])
            {
                tmp = a[j];
                a[j] = a[j + 1];
                a[j + 1] = tmp;
            }
        }
    }
}

//==================================================================
//函数名：  countFeature
//作者：    qiurenbo
//日期：    2014-11-25
//功能：    计算一行上有多少特征
//输入参数：char* buf 文本的一行
//返回值：  特征个数
//修改记录：
//==================================================================
//计算特征数目
int countFeature(const char* buf)
{
    const char* p = buf;
    int   cnt = 0;
    while (*p != NULL)
    {
        if (*p == ',')
            cnt++;
        p++;
    }

    return cnt;
}

//==================================================================
//函数名：  setFeature
//作者：    qiurenbo
//日期：    2014-11-25
//功能：    将读取的特征分配到正负样本结构体上
//输入参数：char* buf 文本的一行
//返回值：  无
//修改记录：
//==================================================================
//将从文件中读取的特征分配到idx.feature和sampleHeader.samples
//sampleHeader.samples保存原始特征数据，idx.feature用于对特征进行排序
//g和b分别表示正样本和负样本
void setFeature(char* buf)
{
    int i = 0;
    struct Sample sample;

    char*p = strtok(buf, ",");

    sample.feature[i++] = atof(p);
    k++;
    while (1)
    {
        if (*p != 'g' && *p != 'b')
            sample.feature[i++] = atof(p);

        else
            break;

        p = strtok(NULL, ",");
    }

    if (*p == 'g')
        sample.indicate = 1;
    else if (*p == 'b')
        sample.indicate = -1;
    else
        assert(0);

    //idx 每行是所有样本的同一特征
    for (i = 0; i < sampleHeader.featureNum; i++)
        idx.feature[i][idx.samplesNum] = sample.feature[i];

    sampleHeader.samples[sampleHeader.samplesNum] = sample;
    sampleHeader.samplesNum++;
    idx.samplesNum++;

};


//==================================================================
//函数名：  loadData
//作者：    qiurenbo
//日期：    2014-11-25
//功能：    读取文本数据
//输入参数：char* buf 文本的一行
//返回值：  无
//修改记录：
//==================================================================
//按行读取特征文件，并用setFeature函数处理特征，再对每个特征下所有样本值进行排序
void loadData()
{
    FILE *fp = NULL;
    char buf[1000];
    int featureCnt = 0;
    double* featrue = NULL;
    double* featruePtr = NULL;
    int i = 0;

    fp = fopen(DATA_NAME, "r");
    assert(fp);


    //fgets从文件结构体指针fp中读取一行，保存到buf指向的字符数组中，每次最多读取1000个字符。
    //如果文件中的该行，不足bufsize个字符，则读完该行就结束。
    //如若该行（包括最后一个换行符）的字符数超过bufsize-1，则fgets只返回一个不完整的行，但是，缓冲区总是以NULL字符结尾，对fgets的下一次调用会继续读该行。
    //函数成功将返回buf，失败或读到文件结尾返回NULL。因此我们不能直接通过fgets的返回值来判断函数是否是出错而终止的，应该借助feof函数或者ferror函数来判断。
    fgets(buf, 1000, fp);
    idx.featureNum = sampleHeader.featureNum = countFeature(buf);

    setFeature(buf);
    //统计样本数

    while (!feof(fp)) //feof(fp)有两个返回值:如果遇到文件结束，函数feof（fp）的值为非零值，否则为0。
    {

        fgets(buf, 1000, fp);
        setFeature(buf);


    }

    fclose(fp);

    for (i = 0; i < idx.featureNum; i++)
        sort(idx.feature[i], idx.samplesNum);




}


//==================================================================
//函数名：  CreateStump
//作者：    qiurenbo
//日期：    2014-11-26
//功能：    创建一个stump分类器
//输入参数：无
//返回值：  stump
//修改记录：
//==================================================================
//遍历所有样本的所有特征，以当前样本的特征作为阈值计算error，选取具有最小error的特征作为弱分类器
//stump：fIdx--feature index
//stump: ft--feature value
//stumo: alpha--1/2log(1/error-1)
//stump: left,right = [-1 1] -- left=1,right=-1表示小于阈值的是正样本，left=-1,right=1表示大于阈值的是正样本
//error：计算分类错误样本的权重的和，认为小于阈值的是正样本，大于阈值的是负样本
//flipErr：计算分类错误样本的权重的和，认为小于阈值的是负样本，大于阈值的是正样本

Stump CreateStump()
{
    int i, j, k;
    Stump stump;
    double min = 0xffffffff;
    double err = 0;
    double flipErr = 0;

    double feature;
    int indicate;
    double weight;
    double pre;
    for (i = 0; i < idx.featureNum; i++)
    {
        pre = 0xffffffff;
        for (j = 0; j < idx.samplesNum; j++)
        {

            err = 0;
            double rootFeature = idx.feature[i][j];

            //跳过相同的值
            if (pre == rootFeature)
                continue;


            for (k = 0; k < sampleHeader.samplesNum; k++)
            {
                feature = sampleHeader.samples[k].feature[i];
                indicate = sampleHeader.samples[k].indicate;
                weight = sampleHeader.samples[k].weight;
                if ((feature <  rootFeature  && indicate != 1) || \
                    (feature >= rootFeature && indicate != -1)
                    )
                    err += weight;

            }

            //左边是1，还是右边是1，选取error最小的组合
            flipErr = 1 - err;
            err = err < flipErr ? err : flipErr;

            //选取具有最小err的特征rootFeature
            if (err < min)
            {
                min = err;
                stump.fIdx = i;
                stump.ft = rootFeature;
                if (err < flipErr)
                {
                    stump.left = 1;
                    stump.right = -1;
                }
                else
                {

                    stump.left = -1;
                    stump.right = 1;
                }
            }

            pre = rootFeature;
        }
    }


    stump.alpha = 0.5*log(1.0 / min - 1);
    return stump;
}


//==================================================================
//函数名：  reSetWeight
//作者：    qiurenbo
//日期：    2014-11-26
//功能：    每次迭代重新调整权重
//输入参数：stump
//返回值：  无
//修改记录：
//==================================================================
//rs表示样本按照阈值分类结果
//
void reSetWeight(struct Stump stump)
{
    int i;
    double z = 0;

    //计算规范化因子z
    for (i = 0; i < sampleHeader.samplesNum; i++)
    {
        double feature = (sampleHeader.samples[i]).feature[stump.fIdx];
        double rs = feature < stump.ft ? stump.left : stump.right;
        rs = stump.alpha * rs * sampleHeader.samples[i].indicate;

        z += sampleHeader.samples[i].weight * exp(-1.0 * rs);
    }



    //调整各个样本的权值
    for (i = 0; i < sampleHeader.samplesNum; i++)
    {
        double feature = (sampleHeader.samples[i]).feature[stump.fIdx];
        double rs = feature < stump.ft ? stump.left : stump.right;
        rs = stump.alpha * rs * sampleHeader.samples[i].indicate;

        sampleHeader.samples[i].weight = sampleHeader.samples[i].weight * exp(-1.0 * rs) / z;


    }

#ifdef DEBUG

    //debug
    for (i = 0; i < 10; i++)
    {
        double feature = (sampleHeader.samples[i]).feature[stump.fIdx];
        double rs = feature < stump.ft ? stump.left : stump.right;
        rs = stump.alpha * rs * sampleHeader.samples[i].indicate;
        printf("weight:%lf, rs:%lf\n", sampleHeader.samples[i].weight, rs);
    }


    //getchar();

#endif
}

//==================================================================
//函数名：  AdaBoost
//作者：    qiurenbo
//日期：    2014-11-26
//功能：    adaboost训练弱分类器
//输入参数：interation  迭代次数
//返回值：  无
//修改记录：
//==================================================================
void AdaBoost(int interation)
{
    int i;
    struct ClassifierHeader head;
    struct Classifier* pCls = NULL;
    struct Classifier* tmp = NULL;
    head.classifierNum = interation;

    loadData();

    //设置初始样本权重
    for (i = 0; i < sampleHeader.samplesNum; i++)
        sampleHeader.samples[i].weight = 1.0 / sampleHeader.samplesNum;


    head.classifier = (struct Classifier*)malloc(sizeof(struct Classifier));
    pCls = head.classifier;
    pCls->stump = CreateStump();
    reSetWeight(pCls->stump);
    //printf("completed:%lf%%\r", 1.0/head.classifierNum*100);
    printf("+-----------+--+-------+\n");
    printf("|   alpha   |id|  ft   |\n");
    printf("+-----------+--+-------+\n");
    printf("|%.9lf|%2d|%+.4lf|\n", pCls->stump.alpha, pCls->stump.fIdx, pCls->stump.ft);
    printf("+-----------+--+-------+\n");
    for (i = 1; i < head.classifierNum; i++)
    {

        pCls = pCls->next = (struct Classifier*)malloc(sizeof(struct Classifier));

        pCls->stump = CreateStump();
        reSetWeight(pCls->stump);
        printf("|%.9lf|%2d|%+.4lf|\n", pCls->stump.alpha, pCls->stump.fIdx, pCls->stump.ft);
        printf("+-----------+--+-------+\n");
        //printf("completed:%lf%%\r", 1.0*(i+1)/head.classifierNum*100);

    }


    printf("\n");

    for (i = 0, pCls = head.classifier; i < head.classifierNum; i++)
    {
        tmp = pCls;
        pCls = tmp->next;
        free(tmp);
    }

}

void main()
{

    AdaBoost(100);
    system("pause");
}
CV_XJTU_GK
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Adaboost分类器 haar特征 整理
liulina603的专栏
03-04 2万+
Adaboost是一种迭代算法，其核心思想是针对同一个训练集训练不同的分类器(弱分类器)，然后把这些弱分类器集合起来，构成一个更强的最终分类器(强分类器)。 其算法本身是通过改变数据分布来实现的，它根据每次训练集之中每个样本的分类是否正确，以及上次的总体分类的准确率，来确定每个样本的权值。 将修改过权值的新数据集送给下层分类器进行训练，最后将每次训练得到的分类器最后融合起来，作为最后的决策分类
支持向量机通俗导论（理解SVM的三层境界）
weixin_30535843的博客
01-22 1260
支持向量机通俗导论（理解SVM的三层境界） 作者：July 。致谢：pluskid、白石、JerryLead。说明：本文最初写于2012年6月，而后不断反反复复修改&优化，修改次数达上百次，最后修改于2016年1月。 前言 动笔写这个支持向量机(support vector machine)是费了不少劲和困难...
adaboost分类器
weixin_45738641的博客
12-15 845
定义：Adaboost是一种迭代算法，其核心思想是针对同一个训练集训练不同的分类器(弱分类器)，然后把这些弱分类器集合起来，构成一个更强的最终分类器（强分类器）。 算法原理： （1）初始化训练数据（每个样本）的权值分布：如果有N个样本，则每一个训练的样本点最开始时都被赋予相同的权重：1/N。 （2）训练弱分类器。具体训练过程中，如果某个样本已经被准确地分类，那么在构造下一个训练集中，它的权重就被降...
kNN分类器简单原理
ai_d_d的博客
04-17 786
k-近邻算法的概述 电影分类 kNN
光衰减器分类方式及原理
01-12
光衰减器的原理　光衰减器是光纤通信设备检测（如光功率计计量，光功率衰减，接收机灵敏度测量等）中必不可少的测试仪器之一。随着光纤通信技术的不断发展，光纤通信设备和器件生产厂商对光衰减器的性能指标要求也...
浅谈编码器分类及其原理
07-19
生活中经常使用的电梯是如何精确的把人们送到指定楼层的?机床又是如何做到精确切割物料的?伺服电机又是如何保证旋转位置...这一切都要归功于一种神器——编码器，可是编码器又是什么?他又是如何精确的测量电机位置的呢?
详解光纤衰减器原理分类及应用
01-19
　光纤衰减器制作工作原理：（1）空气隔离技术:光在光纤中传输受到全反射定律的制约，无法散射出来，保持强度的相对稳定。而一旦其脱离光纤，在光纤与光纤之间加入空气间隔，光就会散射出去，从而引起光的衰减。（2...
SVM分类器原理.doc
11-10
SVM分类器原理 SVM（Support Vector Machine，支持向量机）是一种基于统计学习理论的机器学习方法，由Boser、Guyon、Vapnik在COLT-92上首次提出。SVM在解决小样本、非线性及高维模式识别问题中表现出许多特有的优势...
光纤连接器原理和分类
10-25
设备和系统之间灵活连接的需要，必须有一种能在光纤与光纤之间进行可拆卸(活动)连接的器件，使光路能按所需的通道进行传输，以实现和完成预定或期望的目的和要求，能实现这种功能的器件就叫连接器。
adboost算法的matlab实现
06-01
用matlab实现adboost算法，是实用。
级联分类器原理
diaomache7783的博客
08-01 1170
一、人脸检测算法分类 目前人脸检测方法主要分为两大类，基于知识和基于统计。 基于知识的人脸检测方法主要包括：模板匹配，人脸特征，形状与边缘，纹理特征，颜色特征。 基于统计的人脸检测方法主要包括：主成分分析与特征脸法，神经网络模型，隐马尔可夫模型，支持向量机，Adaboost算法。 基于知识的方法将人脸看成不同特征的特定组合，即通过人脸的眼睛、嘴巴、鼻子、耳朵等特征及其组合关系来检测人脸。...
adboost
TongJiBenBen的专栏
03-05 834
adboost:分类问题被一系列的弱分类器“分而治之”
Boost算法（GDBT,AdaBoost，XGBoost）原理
akenseren的博客
06-22 1442
原文链接：点击打开链接简单地来说，提升Boost就是指每一步都产生一个弱预测模型，然后加权累加到总模型中，然后每一步弱预测模型生成的的依据都是损失函数的负梯度方向，这样若干步以后就可以达到逼近损失函数局部最小值的目标。首先Boost肯定是一个加法模型，它是由若干个基函数及其权值乘积之和的累加，即其中b是基函数，beta是基函数的系数，这就是我们最终分类器的样子，现在的目标就是想办法使损失函数的期望...
贝叶斯分类器（一）
zhangph1229的博客
08-04 2万+
贝叶斯推理提供了一种概率（主要应用条件概率）学习手段，根据以往数据的概率分布和已观察到的数据进行推理判断。对数据量大的问题十分适用，在云计算和大数据时代再次成为研究热点。贝叶斯分类器分成两个部分，第一部分对基础知识、贝叶斯决策论、极大似然估计、朴素贝叶斯分类器和半朴素贝叶斯分类器进行介绍，第二部分对贝叶斯网进行详细介绍。
机器学习之五——adaBoost
weixin_41310804的博客
01-25 1144
一、adaBoost介绍 对一个数据集，adaBoost算法的核心思想是使用多个“弱分类器”训练该数据集，最终集成出一个“强分类器”。这里“弱分类器”的意思是比随机预测好一些但不会好太多的分类器。由于弱分类器非常好构造，并且多个弱分类器集成的强分类器效果又非常好，所以笔者认为adaBoost是一个非常优秀且便捷的算法，其步骤如下： 1. 初始时给数据集中的每条数据分配一个权重，由于是刚开始，每个数据集的权重相等； 2. 用第一个弱分类器训练数据集，然后筛选出预测错误的数据，增大这部分数据的权重，同时减
AdaBoost算法实例详解
热门推荐
胖胖大海的博客
05-23 2万+
AdaBoost算法其实很精炼，算法流程也好理解，但是看了算法的解释版本之后，什么前向分布算法，什么指数损失函数之后有点迷糊了。抛开这些理论性的推导不谈（其实是因为能力有限），通过例子直观的了解AdaBoost算法的计算过程。 简要叙述一下AdaBoost算法的主要过程： AdaBoost为每个数据样本分配权重，权重符合概率分布，初始权重符合均匀分布，串行训练M个模型，依据每轮训练的模型的错误率（被误分类样本的权重之和）确定当前模型在最终模型中的权重，以及更新训练样本的权重，误分类样本权重升高，分类正确
Adaboost算法原理分析和实例+代码（简明易懂）
hhsh49的博客
02-23 1835
Adaboost算法原理分析和实例+代码（简明易懂）    【尊重原创，转载请注明出处】 http://blog.csdn.net/guyuealian/article/details/70995333     本人最初了解AdaBoost算法着实是花了几天时间，才明白他的基本原理。也许是自己能力有限吧，很多资料也是看得懵懵懂懂。网上找了一下关于Adaboost算法原理分析，大都是你复制我，我摘抄...
【机器学习】Adboost 算法 整理
CWS_chen
06-01 3615
Adaboost是adaptive boosting（自适应boosting）的缩写，其核心思想是针对同一个训练集训练不同的分类器(弱分类器)，然后把这些弱分类器集合起来，构成一个更强的最终分类器（强分类器）。它有一个明显的特点就是排除一些不必要的特征值，把模型训练放在关键特征值数据上。它的算法过程如下： Adaboost从以上概念可以看出它有两种分类器，一种是y1称之为弱分类器，另外一种是Y...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值