bbzz2
bbzz2

AdaBoost



版权声明：本文为博主原创文章，未经博主允许不得转载。

一、原理

 

AdaBoost（Adaptive Boosting，自适应提升）算法是由来自AT&T实验室的Freund和Schapire于1995年首次提出，该算法解决了早期Boosting算法的一些实际执行难题，而且该算法可以作为一种从一系列弱分类器中产生一个强分类器的通用方法。正由于AdaBoost算法的优异性能，Freund和Schapire因此获得了2003年度的哥德尔奖（Gödel Prize，该奖是在理论计算机科学领域中最负盛名的奖项之一）。

假设我们有一个集合{(x1, y1),(x2, y2), …, (xN,yN)}，每一个数据项xi是一个表示事物特征的矢量，yi是一个与其相对应的分类yi∈{-1, 1}，即xi要么属于-1，要么属于1。AdaBoost算法通过M次迭代得到了一个弱分类器集合{k1, k2,…, kM}，对于每一个数据项xi来说，每个弱分类器都会给出一个分类结果来，即km(xi)∈{-1, 1}。这M个弱分类器通过某种线性组合（式1所示）就得到了一个强分类器Cm，这样我们就可以通过Cm来判断一个新的数据项xk是属于-1，还是1。这就是一个训练的过程。

在进行了第m-1次迭代后，我们可以把这m-1个弱分类器进行线性组合，所得到的强分类器为：

（1）

式中，α为k的权值，并且m > 1。当进行第m次迭代时，AdaBoost就通过增加一个弱分类器的方式扩展成另一个的强分类器：

（2）

只有使Cm的分类结果强于Cm-1，算法迭代才有意义。那么如何能够使Cm的性能优于Cm-1呢？这就由增加的那个第m个弱分类器km及其它的权值αm来决定。我们用所有数据项xi的指数损失的总和来定义Cm的误差E，从而判断km和αm是否为最优，即：

（3）

令  ，wi(m)表示在第m-1次迭代后，对训练数据项xi所分配的权重，而在第1次迭代时，所使用的权重为1，即wi(1) = 1。那么，上式可以重写为：

（4）

我们可以把上式拆分成两项：

（5）

式中，yi=km(xi)的意思是对xi来说，第m次迭代得到的弱分类器km的分类结果与其实际的分类y相同，要么都等于-1，要么都等于1，即分类正确，所以它们的乘积一定等于1，即yi km(xi)= 1；而yi≠km(xi)的意思是对xi来说，第m次迭代得到的弱分类器km的分类结果与其实际的分类y不相同，其中一个如果等于-1，那么另一个一定等于1，即分类错误，所以它们的乘积一定等于-1，即yi km(xi)= -1。所以式5中的前一项表示的是对所有y等于km的那些数据项xi的误差求和；而第二项表示的是对所有y不等于km的那些数据项xi的误差求和。我们又可以把式5写出如下形式：

（6）

从上式我们可以看出，如果αm一定的话，强分类器Cm的误差大小完全取决于第二项中的 的大小，也就是取决于该次迭代中被分类错误的那些权值 的大小。

为了使误差E最小，我们需要对式5进行求导：

（7）

令上式等于0，则权值αm为：

（8）

令 表示误差率，其值为：

（9）

则式8为：

（10）

经过以上分析，我们导出了AdaBoost算法：在每次迭代中，我们选择使 为最小的分类器km，并得到误差率 （式9），应用该误差率 我们又得到了权值αm（式10），则最终强分类器就由Cm-1提升为Cm= Cm-1 + αmkm。而在每次迭代后，得到的每个训练样本数据的权值wi(m+1)为：

（11）

需要说明的是，权值仍然可以按照前面介绍的 方法计算，但式11更简单，在应用迭代时效率更高。

基于以上的分析，我们给出AdaBoost的计算步骤：

1、设有n个样本x1, …, xn，它们所希望得到的输出（即分类）为y1, …, yn，y∈{-1, 1}；

2、初始化每个样本的权值 ，它们都为 ；

3、进行迭代：m = 1, …, M

①找到使误差率 最小的弱分类器km(x)，并得到 （式9）；

②计算km(x)的权值αm（式10）；

③得到新的强分类器Cm(x)（式2）；

④更新每个样本的权值wi(m+1)（式11）；

⑤对权值wi(m+1)进行归一化处理，使∑iwi(m+1)= 1；

4、得到最终的强分类器

（12）

从式12可以看出，强分类器是由权值αm和弱分类器km(x)决定的。权值αm由式10计算得到，而弱分类器可以用上一篇文章介绍的决策树的方法得到，那种最简单的、每个中间节点只能被分叉为左、右两个分支（stumps）的决策树就足以完成对弱分类器的设计。也就是说，每一个弱分类器就是一个决策树，而该决策树是由加权后的样本构建而成，由于每次迭代的权值wi(m)不同，所以每次迭代所构建的决策树也是不同的。当要应用AdaBoost预测样本x时，只要把该样本带入不同的决策树（即弱分类器）进行预测即可，预测的结果就是km(x)，然后应用式12把不同的决策树的预测结果进行加权和，最后判断其符号。OpenCV就是采用的这种方法。当用决策树的形式的时候，权值αm的计算公式为：

（13）

而每个训练样本数据的权值wi(m+1)则为：

（14）

AdaBoost算法可分为DiscreteAdaboost，Real AdaBoost，LogitBoost和Gentle AdaBoost。前面我们给出的是Discrete Adaboost算法的原理和计算步骤。虽然这四种算法的基本结构相似的，但彼此之间还是有一些差异。Discrete AdaBoost的每个弱分类的输出结果是1或-1，在组成强分类器的过程中，这种离散形式的弱分类器就略显粗糙。而Real Adaboost的每个弱分类器输出是该样本属于某一类的概率，即弱分类器km是通过一个对数函数将0-1的概率值映射到实数域，sign(km)给出的是一个分类，而|km|给出的就是一个置信度的度量。Real Adaboost的迭代过程为：

①基于每个样本的权值wi(m)，拟合一个分类概率估计pm(x)=P(y=1|x)∈[0,1]，它表示样本属于分类结果为1的概率；

②得到该次迭代的弱分类器km(x)：

（15）

③更新权值wi(m+1)：

（16）

④归一化权值使∑iwi(m+1)= 1。

则最终的强分类器C为：

（17）

LogitBoost算法是逻辑回归技术在AdaBoost的应用，弱分类器的选取并不是基于分类结果yi，而是基于加权最小二乘法。设迭代之前强分类器C0(x) = 0，每个训练样本数据的概率估计p0(xi) = 0.5，则LogitBoost算法的迭代过程为：

①计算工作响应zi(m)：

（18）

式中

（19）

②计算权值wi(m)：

（20）

③应用权值wi(m)，基于从zi(m)到xi的加权最小二乘法回归方法，拟合弱分类器km(x)；

④更新pm(xi)：

（21）

⑤更新强分类器

（22）

最终的强分类器为式17。

Gentle AdaBoost算法与LogitBoost算法相似，但参数的选择上更简单。弱分类器km(x)是由基于权值wi(m)的从yi到xi的加权最小二乘法的回归拟合得到。每次迭代得到强分类器Cm(x)和权值分别wi(m+1)为：

（23）

（24）

这里的权值仍然需要进行归一化处理。强分类器仍然为式17。

OpenCV实现了上述四种类型的AdaBoost，并且弱分类器都是采用CART决策树的方法，其中DiscreteAdaboost和Real AdaBoost应用的是分类树，因为它们的分类结果是类的形式，而LogitBoost和Gentle AdaBoost应用的是回归树，因为它们的分类结果是数值的形式。

 

二、源码分析

 

下面我们就给出OpenCV的源码分析。

 

我们先看构建Boosting的参数：

[cpp] view plain copy print ?
  1. CvBoostParams::CvBoostParams()  
  2. {  
  3.     boost_type = CvBoost::REAL;  
  4.     weak_count = 100;  
  5.     weight_trim_rate = 0.95;  
  6.     cv_folds = 0;  
  7.     max_depth = 1;  
  8. }  
CvBoostParams::CvBoostParams()
{
    boost_type = CvBoost::REAL;
    weak_count = 100;
    weight_trim_rate = 0.95;
    cv_folds = 0;
    max_depth = 1;
}
[cpp] view plain copy print ?
  1. CvBoostParams::CvBoostParams( int _boost_type, int _weak_count,  
  2.                                         double _weight_trim_rate, int _max_depth,  
  3.                                         bool _use_surrogates, const float* _priors )  
  4. {  
  5.     boost_type = _boost_type;  
  6.     weak_count = _weak_count;  
  7.     weight_trim_rate = _weight_trim_rate;  
  8.     split_criteria = CvBoost::DEFAULT;    //分叉准则，即用什么方法计算决策树节点的纯度  
  9. /***************************** 
  10. CvBoost::DEFAULT为特定的Boosting算法选择默认系数 
  11. CvBoost::GINI使用基尼指数，这是Real AdaBoost的默认方法，也可以被用于Discrete Adaboost 
  12. CvBoost::MISCLASS使用错误分类率，这是Discrete Adaboost的默认方法，也可以被用于Real AdaBoost 
  13. CvBoost::SQERR使用最小二乘准则，这是LogitBoost和Gentle AdaBoost的默认及唯一方法 
  14. ******************************/  
  15.     cv_folds = 0;    //表示构建决策树时，不执行剪枝操作  
  16.     max_depth = _max_depth;  
  17.     use_surrogates = _use_surrogates;  
  18.     priors = _priors;  
  19. }  
CvBoostParams::CvBoostParams( int _boost_type, int _weak_count,
                                        double _weight_trim_rate, int _max_depth,
                                        bool _use_surrogates, const float* _priors )
{
    boost_type = _boost_type;
    weak_count = _weak_count;
    weight_trim_rate = _weight_trim_rate;
    split_criteria = CvBoost::DEFAULT;    //分叉准则，即用什么方法计算决策树节点的纯度
/*****************************
CvBoost::DEFAULT为特定的Boosting算法选择默认系数
CvBoost::GINI使用基尼指数，这是Real AdaBoost的默认方法，也可以被用于Discrete Adaboost
CvBoost::MISCLASS使用错误分类率，这是Discrete Adaboost的默认方法，也可以被用于Real AdaBoost
CvBoost::SQERR使用最小二乘准则，这是LogitBoost和Gentle AdaBoost的默认及唯一方法
******************************/
    cv_folds = 0;    //表示构建决策树时，不执行剪枝操作
    max_depth = _max_depth;
    use_surrogates = _use_surrogates;
    priors = _priors;
}

其中参数的含义为：

boost_type表示Boosting算法的类型，可以是CvBoost::DISCRETE、CvBoost::REAL、CvBoost::LOGIT或CvBoost::GENTLE这4类中的任意一个，OpenCV推荐使用GentleAdaBoost或Real AdaBoost算法

_weak_count表示弱分类器的数量，即迭代的次数

_weight_trim_rate表示裁剪率，在0～1之间，默认值为0.95，在迭代过程中，那些归一化后的样本权值wi(m)小于该裁剪率的样本将不进入下次迭代

_max_depth表示构建决策树的最大深度

_use_surrogates表示在构建决策树时，是否使用替代分叉属性

_priors表示样本的先验概率

[cpp] view plain copy print ?
  1. CvBoost类的两个构造函数：  
  2. CvBoost::CvBoost( const Mat& _train_data, int _tflag,  
  3.                const Mat& _responses, const Mat& _var_idx,  
  4.                const Mat& _sample_idx, const Mat& _var_type,  
  5.                const Mat& _missing_mask,  
  6.                CvBoostParams _params )  
  7. //_train_data训练的样本数据  
  8. //_tflag训练数据的特征属性类型，如果为CV_ROW_SAMPLE，表示样本是以行的形式储存的，即_train_data矩阵的每一行为一个样本（或特征矢量）；如果为CV_COL_SAMPLE，表示样本是以列的形式储存的  
  9. //_responses分类的结果，即分类的响应值  
  10. //_var_idx标识感兴趣的特征属性，即真正用于训练的那些特征属性，该值的形式与_sample_idx变量相似  
  11. //_sample_idx标识感兴趣的样本，即真正用于训练的样本，该值必须是一维矩阵的形式，即矢量的形式，并且类型必须是8UC1、8SU1或者32SC1。如果为8UC1或8SU1，则该值的含义是用掩码的形式表示对应的样本，即0表示不感兴趣的样本，其他数为感兴趣的样本，因此矢量的元素数量必须与训练样本数据_train_data的样本数一致；如果为32SC1，则该值的含义是那些感兴趣的样本的索引，而不感兴趣的样本的索引不在该矢量中出现，因此该矢量的元素数量可以小于或等于_train_data的样本数  
  12. //_var_type特征属性的形式，是类的形式还是数值的形式，用掩码的形式表现对应特征属性的形式，0表示为数值的形式，1表示为类的形式。该值必须是一维矩阵，并且元素的数量必须是真正用于训练的那些特征属性的数量加1，多余的一个元素表示的是响应值的形式，即是分类树还是回归树  
  13. //_missing_mask缺失的特征属性，用掩码的形式表现对应的特征属性，0表示没有缺失，而且必须与_train_data的矩阵尺寸大小一致  
  14. //_params为构建Boosting的参数  
  15. {  
  16.     // CvSeq* weak，用于保存决策树，即最终的强分类器  
  17.     weak = 0;  
  18.     // CvDTreeTrainData* data，所训练的样本数据  
  19.     data = 0;  
  20.     // const char* default_model_name，该机器学习的模型名称  
  21.     default_model_name = "my_boost_tree";  
  22.     //所有变量的类型都为CvMat*  
  23.     // active_vars表示那些对决策树的分叉起到作用的特征属性的索引值，该索引值是只相对于参与训练决策树的那些特征属性  
  24.     // active_vars_abs表示那些对决策树的分叉起到作用的特征属性的索引值，但与active_vars变量不同，该索引值是针对所有的特征属性  
  25.     // orig_response训练样本的原始响应值，即样本的分类，为-1或1  
  26.     // sum_response弱分类器线性组合后的样本输出分类，即强分类器的分类结果  
  27.     // weak_eval：弱分类器的分类评估结果，即弱分类器的响应值  
  28.     // subsample_mask训练样本集的掩码集，即每一个样本都有一个掩码，当该值为0时，该样本被去掉，训练的时候不使用该样本  
  29.     //weights每个训练样本数据的权值，即wi(m)  
  30.     // subtree_weights每个决策树所应用的样本权值，它的值虽然也是wi(m)，但样本的顺序与weights不同，即subtree_weights针对的是具体决策树  
  31.     active_vars = active_vars_abs = orig_response = sum_response = weak_eval =  
  32.         subsample_mask = weights = subtree_weights = 0;  
  33.     //AdaBoost训练  
  34.     train( _train_data, _tflag, _responses, _var_idx, _sample_idx,  
  35.           _var_type, _missing_mask, _params );  
  36. }  
CvBoost类的两个构造函数：
CvBoost::CvBoost( const Mat& _train_data, int _tflag,
               const Mat& _responses, const Mat& _var_idx,
               const Mat& _sample_idx, const Mat& _var_type,
               const Mat& _missing_mask,
               CvBoostParams _params )
//_train_data训练的样本数据
//_tflag训练数据的特征属性类型，如果为CV_ROW_SAMPLE，表示样本是以行的形式储存的，即_train_data矩阵的每一行为一个样本（或特征矢量）；如果为CV_COL_SAMPLE，表示样本是以列的形式储存的
//_responses分类的结果，即分类的响应值
//_var_idx标识感兴趣的特征属性，即真正用于训练的那些特征属性，该值的形式与_sample_idx变量相似
//_sample_idx标识感兴趣的样本，即真正用于训练的样本，该值必须是一维矩阵的形式，即矢量的形式，并且类型必须是8UC1、8SU1或者32SC1。如果为8UC1或8SU1，则该值的含义是用掩码的形式表示对应的样本，即0表示不感兴趣的样本，其他数为感兴趣的样本，因此矢量的元素数量必须与训练样本数据_train_data的样本数一致；如果为32SC1，则该值的含义是那些感兴趣的样本的索引，而不感兴趣的样本的索引不在该矢量中出现，因此该矢量的元素数量可以小于或等于_train_data的样本数
//_var_type特征属性的形式，是类的形式还是数值的形式，用掩码的形式表现对应特征属性的形式，0表示为数值的形式，1表示为类的形式。该值必须是一维矩阵，并且元素的数量必须是真正用于训练的那些特征属性的数量加1，多余的一个元素表示的是响应值的形式，即是分类树还是回归树
//_missing_mask缺失的特征属性，用掩码的形式表现对应的特征属性，0表示没有缺失，而且必须与_train_data的矩阵尺寸大小一致
//_params为构建Boosting的参数
{
    // CvSeq* weak，用于保存决策树，即最终的强分类器
    weak = 0;
    // CvDTreeTrainData* data，所训练的样本数据
    data = 0;
    // const char* default_model_name，该机器学习的模型名称
    default_model_name = "my_boost_tree";
    //所有变量的类型都为CvMat*
    // active_vars表示那些对决策树的分叉起到作用的特征属性的索引值，该索引值是只相对于参与训练决策树的那些特征属性
    // active_vars_abs表示那些对决策树的分叉起到作用的特征属性的索引值，但与active_vars变量不同，该索引值是针对所有的特征属性
    // orig_response训练样本的原始响应值，即样本的分类，为-1或1
    // sum_response弱分类器线性组合后的样本输出分类，即强分类器的分类结果
    // weak_eval：弱分类器的分类评估结果，即弱分类器的响应值
    // subsample_mask训练样本集的掩码集，即每一个样本都有一个掩码，当该值为0时，该样本被去掉，训练的时候不使用该样本
    //weights每个训练样本数据的权值，即wi(m)
    // subtree_weights每个决策树所应用的样本权值，它的值虽然也是wi(m)，但样本的顺序与weights不同，即subtree_weights针对的是具体决策树
    active_vars = active_vars_abs = orig_response = sum_response = weak_eval =
        subsample_mask = weights = subtree_weights = 0;
    //AdaBoost训练
    train( _train_data, _tflag, _responses, _var_idx, _sample_idx,
          _var_type, _missing_mask, _params );
}
[cpp] view plain copy print ?
  1. CvBoost::CvBoost()  
  2. {  
  3.     data = 0;  
  4.     weak = 0;  
  5.     default_model_name = "my_boost_tree";  
  6.   
  7.     active_vars = active_vars_abs = orig_response = sum_response = weak_eval =  
  8.         subsample_mask = weights = subtree_weights = 0;  
  9.     have_active_cat_vars = have_subsample = false;  
  10.   
  11.     clear();    //清空一些参数  
  12. }  
CvBoost::CvBoost()
{
    data = 0;
    weak = 0;
    default_model_name = "my_boost_tree";

    active_vars = active_vars_abs = orig_response = sum_response = weak_eval =
        subsample_mask = weights = subtree_weights = 0;
    have_active_cat_vars = have_subsample = false;

    clear();    //清空一些参数
}
两个train函数：
[cpp] view plain copy print ?
  1. bool CvBoost::train( CvMLData* _data,    //训练样本数据  
  2.              CvBoostParams _params,    //构建Boosting的参数  
  3.              bool update )  
  4. //update表示是更新分类器，还是重新创建分类器，默认是false，表示重新创建  
  5. {  
  6.     bool result = false;  
  7.   
  8.     CV_FUNCNAME( "CvBoost::train" );  
  9.   
  10.     __BEGIN__;  
  11.     //从_data变量中提取各类数据  
  12.     const CvMat* values = _data->get_values();  
  13.     const CvMat* response = _data->get_responses();  
  14.     const CvMat* missing = _data->get_missing();  
  15.     const CvMat* var_types = _data->get_var_types();  
  16.     const CvMat* train_sidx = _data->get_train_sample_idx();  
  17.     const CvMat* var_idx = _data->get_var_idx();  
  18.     //调用另一个train函数  
  19.     CV_CALL( result = train( values, CV_ROW_SAMPLE, response, var_idx,  
  20.         train_sidx, var_types, missing, _params, update ) );  
  21.   
  22.     __END__;  
  23.   
  24.     return result;  
  25. }  
  26.   
  27. bool  
  28. CvBoost::train( const CvMat* _train_data, int _tflag,  
  29.               const CvMat* _responses, const CvMat* _var_idx,  
  30.               const CvMat* _sample_idx, const CvMat* _var_type,  
  31.               const CvMat* _missing_mask,  
  32.               CvBoostParams _params, bool _update )  
  33. {  
  34.     bool ok = false;    //算法训练正确与否的标识变量  
  35.     //定义一段内存空间  
  36.     CvMemStorage* storage = 0;  
  37.   
  38.     CV_FUNCNAME( "CvBoost::train" );  
  39.   
  40.     __BEGIN__;  
  41.   
  42.     int i;  
  43.     //调用CvBoost::set_params()函数，设置并判断Boosting参数的正确性  
  44.     set_params( _params );  
  45.     //释放active_vars和active_vars_abs矩阵变量  
  46.     cvReleaseMat( &active_vars );  
  47.     cvReleaseMat( &active_vars_abs );  
  48.     
  49.     if( !_update || !data )    //需要重新建立分类器，或者没有训练样本数据  
  50.     {  
  51.         //调用CvBoost::clear()函数，清空一些参数  
  52.         clear();  
  53.         //实例化CvDTreeTrainData类，并通过set_data函数设置决策树的训练样本数据，倒数第二个参数表示是否共享决策树，最后一个参数表示是否可以添加分类标签，该参数实现了把决策树中用于交叉验证的子集空间用于存储每个决策树的样本权值的目的  
  54.         data = new CvDTreeTrainData( _train_data, _tflag, _responses, _var_idx,  
  55.             _sample_idx, _var_type, _missing_mask, _params, true, true );  
  56.         //确保Boosting只能用于两类问题  
  57.         if( data->get_num_classes() != 2 )  
  58.             CV_ERROR( CV_StsNotImplemented,  
  59.             "Boosted trees can only be used for 2-class classification." );  
  60.         //创建一块内存空间，用于存储决策树weak  
  61.         CV_CALL( storage = cvCreateMemStorage() );  
  62.         //为AdaBoost创建一个序列  
  63.         weak = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvBoostTree*), storage );  
  64.         storage = 0;  
  65.     }  
  66.     else    //否则，为训练样本数据赋值  
  67.     {  
  68.         data->set_data( _train_data, _tflag, _responses, _var_idx,  
  69.             _sample_idx, _var_type, _missing_mask, _params, true, true, true );  
  70.     }  
  71.     //如果AdaBoost算法的类型为Logit AdaBoost或Gentle AdaBoost，则生成一个样本响应值的副本  
  72.     if ( (_params.boost_type == LOGIT) || (_params.boost_type == GENTLE) )  
  73.         data->do_responses_copy();  
  74.     //这里是第一次调用CvBoost::update_weights()函数，因此它的作用是初始化权值，该函数在后面有详细的介绍  
  75.     update_weights( 0 );  
  76.     //执行AdaBoost算法，进行M次迭代  
  77.     for( i = 0; i < params.weak_count; i++ )  
  78.     {  
  79.         //定义一个弱分类器，它是用决策树的方法得到的  
  80.         CvBoostTree* tree = new CvBoostTree;  
  81.         //用决策树的方法训练得到一个弱分类器，如果训练失败，则退出迭代循环，CvBoostTree类中的train函数在后面给出详细的介绍，其中参数subsample_mask表示样本数据的掩码，如果样本数据相应位的值为1，则表示该样本可用，如果为0，则不可用  
  82.         if( !tree->train( data, subsample_mask, this ) )  
  83.         {  
  84.             delete tree;    //删除该弱分类器  
  85.             break;    //退出循环  
  86.         }  
  87.         //cvCheckArr( get_weak_response());    //检查该弱分类器的输出响应  
  88.         //把得到的弱分类器tree添加进强分类器weak队列中  
  89.         cvSeqPush( weak, &tree );  
  90.         //更新权值，以备下次迭代循环之用  
  91.         update_weights( tree );  
  92.         //裁剪去掉那些权值wi(m+1)太小的训练样本数据  
  93.         trim_weights();  
  94.         //计算样本中没有被置1的数量，如果为零，则说明下次迭代将没有训练样本  
  95.         if( cvCountNonZero(subsample_mask) == 0 )  
  96.             break;    //退出迭代  
  97.     }  
  98.   
  99.     if(weak->total > 0)    //得到了若干个弱分类器  
  100.     {  
  101.         //计算active_vars和condensed_idx变量，这两个变量在预测时要用到，该函数的详细介绍在后面  
  102.         get_active_vars(); // recompute active_vars* maps and condensed_idx's in the splits.  
  103.         data->is_classifier = true;    //重新赋值  
  104.         data->free_train_data();    //释放一些矩阵变量  
  105.         ok = true;    //标识变量  
  106.     }  
  107.     else    //没有得到弱分类器  
  108.         clear();    //清空一些参数  
  109.   
  110.     __END__;  
  111.     //得到了Boosting分类器，返回true，否则返回false  
  112.     return ok;      
  113. }  
bool CvBoost::train( CvMLData* _data,    //训练样本数据
             CvBoostParams _params,    //构建Boosting的参数
             bool update )
//update表示是更新分类器，还是重新创建分类器，默认是false，表示重新创建
{
    bool result = false;

    CV_FUNCNAME( "CvBoost::train" );

    __BEGIN__;
    //从_data变量中提取各类数据
    const CvMat* values = _data->get_values();
    const CvMat* response = _data->get_responses();
    const CvMat* missing = _data->get_missing();
    const CvMat* var_types = _data->get_var_types();
    const CvMat* train_sidx = _data->get_train_sample_idx();
    const CvMat* var_idx = _data->get_var_idx();
    //调用另一个train函数
    CV_CALL( result = train( values, CV_ROW_SAMPLE, response, var_idx,
        train_sidx, var_types, missing, _params, update ) );

    __END__;

    return result;
}

bool
CvBoost::train( const CvMat* _train_data, int _tflag,
              const CvMat* _responses, const CvMat* _var_idx,
              const CvMat* _sample_idx, const CvMat* _var_type,
              const CvMat* _missing_mask,
              CvBoostParams _params, bool _update )
{
    bool ok = false;    //算法训练正确与否的标识变量
    //定义一段内存空间
    CvMemStorage* storage = 0;

    CV_FUNCNAME( "CvBoost::train" );

    __BEGIN__;

    int i;
    //调用CvBoost::set_params()函数，设置并判断Boosting参数的正确性
    set_params( _params );
    //释放active_vars和active_vars_abs矩阵变量
    cvReleaseMat( &active_vars );
    cvReleaseMat( &active_vars_abs );
  
    if( !_update || !data )    //需要重新建立分类器，或者没有训练样本数据
    {
        //调用CvBoost::clear()函数，清空一些参数
        clear();
        //实例化CvDTreeTrainData类，并通过set_data函数设置决策树的训练样本数据，倒数第二个参数表示是否共享决策树，最后一个参数表示是否可以添加分类标签，该参数实现了把决策树中用于交叉验证的子集空间用于存储每个决策树的样本权值的目的
        data = new CvDTreeTrainData( _train_data, _tflag, _responses, _var_idx,
            _sample_idx, _var_type, _missing_mask, _params, true, true );
        //确保Boosting只能用于两类问题
        if( data->get_num_classes() != 2 )
            CV_ERROR( CV_StsNotImplemented,
            "Boosted trees can only be used for 2-class classification." );
        //创建一块内存空间，用于存储决策树weak
        CV_CALL( storage = cvCreateMemStorage() );
        //为AdaBoost创建一个序列
        weak = cvCreateSeq( 0, sizeof(CvSeq), sizeof(CvBoostTree*), storage );
        storage = 0;
    }
    else    //否则，为训练样本数据赋值
    {
        data->set_data( _train_data, _tflag, _responses, _var_idx,
            _sample_idx, _var_type, _missing_mask, _params, true, true, true );
    }
    //如果AdaBoost算法的类型为Logit AdaBoost或Gentle AdaBoost，则生成一个样本响应值的副本
    if ( (_params.boost_type == LOGIT) || (_params.boost_type == GENTLE) )
        data->do_responses_copy();
    //这里是第一次调用CvBoost::update_weights()函数，因此它的作用是初始化权值，该函数在后面有详细的介绍
    update_weights( 0 );
    //执行AdaBoost算法，进行M次迭代
    for( i = 0; i < params.weak_count; i++ )
    {
        //定义一个弱分类器，它是用决策树的方法得到的
        CvBoostTree* tree = new CvBoostTree;
        //用决策树的方法训练得到一个弱分类器，如果训练失败，则退出迭代循环，CvBoostTree类中的train函数在后面给出详细的介绍，其中参数subsample_mask表示样本数据的掩码，如果样本数据相应位的值为1，则表示该样本可用，如果为0，则不可用
        if( !tree->train( data, subsample_mask, this ) )
        {
            delete tree;    //删除该弱分类器
            break;    //退出循环
        }
        //cvCheckArr( get_weak_response());    //检查该弱分类器的输出响应
        //把得到的弱分类器tree添加进强分类器weak队列中
        cvSeqPush( weak, &tree );
        //更新权值，以备下次迭代循环之用
        update_weights( tree );
        //裁剪去掉那些权值wi(m+1)太小的训练样本数据
        trim_weights();
        //计算样本中没有被置1的数量，如果为零，则说明下次迭代将没有训练样本
        if( cvCountNonZero(subsample_mask) == 0 )
            break;    //退出迭代
    }

    if(weak->total > 0)    //得到了若干个弱分类器
    {
        //计算active_vars和condensed_idx变量，这两个变量在预测时要用到，该函数的详细介绍在后面
        get_active_vars(); // recompute active_vars* maps and condensed_idx's in the splits.
        data->is_classifier = true;    //重新赋值
        data->free_train_data();    //释放一些矩阵变量
        ok = true;    //标识变量
    }
    else    //没有得到弱分类器
        clear();    //清空一些参数

    __END__;
    //得到了Boosting分类器，返回true，否则返回false
    return ok;    
}
更新权值函数，当要初始化权值时，参数tree为0，表示此时还没有弱分类器：
[cpp] view plain copy print ?
  1. void  
  2. CvBoost::update_weights( CvBoostTree* tree ) {  
  3.   double initial_weights[2] = { 1, 1 };    //该变量只有在初始化权值时用到  
  4.   update_weights_impl( tree, initial_weights );  
  5. }  
void
CvBoost::update_weights( CvBoostTree* tree ) {
  double initial_weights[2] = { 1, 1 };    //该变量只有在初始化权值时用到
  update_weights_impl( tree, initial_weights );
}
更新权值的核心函数：
[cpp] view plain copy print ?
  1. void  
  2. CvBoost::update_weights_impl( CvBoostTree* tree, double initial_weights[2] )  
  3. {  
  4.     CV_FUNCNAME( "CvBoost::update_weights_impl" );  
  5.   
  6.     __BEGIN__;  
  7.     //n表示训练样本的数量  
  8.     int i, n = data->sample_count;  
  9.     double sumw = 0.;    //表示权值的和，权值归一化时要用  
  10.     int step = 0;  
  11.     float* fdata = 0;  
  12.     int *sample_idx_buf;  
  13.     const int* sample_idx = 0;  
  14.     cv::AutoBuffer inn_buf;  
  15.     //根据AdaBoost类型的不同，定义不同大小的缓存，Discrete和Real时为0，LogitBoost和Gentle时为所有训练样本的数据长度，存储着样本响应值的副本  
  16.     size_t _buf_size = (params.boost_type == LOGIT) || (params.boost_type == GENTLE) ? (size_t)(data->sample_count)*sizeof(int) : 0;  
  17.     if( !tree )    //初始化权值，因为此时还没有弱分类器  
  18.         _buf_size += n*sizeof(int);    //增加_buf_size的大小，增加的长度为所有训练样本的数据长度，存储着样本响应值  
  19.     else    //训练样本的迭代过程中  
  20.     {  
  21.         //如果发生了样本裁剪，则_buf_size的增加长度为没有被裁剪掉的样本数据长度，即此次迭代中真正用到的那些样本的数据长度，存储的内容为该次迭代的训练样本数据的响应值  
  22.         if( have_subsample )  
  23.             _buf_size += data->get_length_subbuf()*(sizeof(float)+sizeof(uchar));  
  24.     }  
  25.     //为inn_buf分配_buf_size大小的内存空间  
  26.     inn_buf.allocate(_buf_size);  
  27.     // cur_buf_pos指向inn_buf的空间的首地址  
  28.     uchar* cur_buf_pos = (uchar*)inn_buf;  
  29.     //如果是LogitBoost和Gentle类型  
  30.     if ( (params.boost_type == LOGIT) || (params.boost_type == GENTLE) )  
  31.     {  
  32.         //得到步长  
  33.         step = CV_IS_MAT_CONT(data->responses_copy->type) ?  
  34.             1 : data->responses_copy->step / CV_ELEM_SIZE(data->responses_copy->type);  
  35.         fdata = data->responses_copy->data.fl;    //指向样本响应值的副本  
  36.         sample_idx_buf = (int*)cur_buf_pos;    //指向inn_buf空间  
  37.         // cur_buf_pos指向此次迭代训练的样本数据的首地址  
  38.         cur_buf_pos = (uchar*)(sample_idx_buf + data->sample_count);  
  39.         //得到训练样本序列索引  
  40.         sample_idx = data->get_sample_indices( data->data_root, sample_idx_buf );  
  41.     }  
  42.     // dtree_data_buf指向训练数据的内存首地址，训练数据是以矩阵的形式进行存储的  
  43.     CvMat* dtree_data_buf = data->buf;  
  44.     // length_buf_row表示当前训练样本的数量，因为并不是所有的样本都用于本次迭代，有一些样本被剪切掉了  
  45.     size_t length_buf_row = data->get_length_subbuf();  
  46.     //进入if的条件是在第一次迭代之前，即还没有弱分类器的时候，它的作用是初始化一些变量和参数  
  47.     if( !tree ) // before training the first tree, initialize weights and other parameters  
  48.     {   
  49.         // class_labels_buf表示分类结果，即响应值  
  50.         int* class_labels_buf = (int*)cur_buf_pos;  
  51.         // cur_buf_pos指向另一块内存空间  
  52.         cur_buf_pos = (uchar*)(class_labels_buf + n);  
  53.         //得到训练样本的响应值，也就是样本的分类结果  
  54.         const int* class_labels = data->get_class_labels(data->data_root, class_labels_buf);  
  55.         // in case of logitboost and gentle adaboost each weak tree is a regression tree,  
  56.         // so we need to convert class labels to floating-point values  
  57.         //由于LogitBoost和Gentle需要浮点型的数据，构建它们的弱分类器的决策树是回归树，所以需要重新定义一些变量，因为这些变量在初始化时都是整型的  
  58.         //w0用于初始化权值wi(1)  
  59.         double w0 = 1./n;  
  60.         // p[2] = { 1, 1 }，表示两类问题的先验概率  
  61.         double p[2] = { initial_weights[0], initial_weights[1] };  
  62.         //释放、重新分配一些矩阵  
  63.         cvReleaseMat( &orig_response );  
  64.         cvReleaseMat( &sum_response );  
  65.         cvReleaseMat( &weak_eval );  
  66.         cvReleaseMat( &subsample_mask );  
  67.         cvReleaseMat( &weights );  
  68.         cvReleaseMat( &subtree_weights );  
  69.         //重新定义一些矩阵  
  70.         CV_CALL( orig_response = cvCreateMat( 1, n, CV_32S ));  
  71.         CV_CALL( weak_eval = cvCreateMat( 1, n, CV_64F ));  
  72.         CV_CALL( subsample_mask = cvCreateMat( 1, n, CV_8U ));  
  73.         CV_CALL( weights = cvCreateMat( 1, n, CV_64F ));  
  74.         CV_CALL( subtree_weights = cvCreateMat( 1, n + 2, CV_64F ));  
  75.         //如果在设置Boosting参数的时候设置了_priors值，并且AdaBoost算法为Discrete Adaboost或Real AdaBoost，则表示样本属性有先验概率，即have_priors为true，则需要根据训练样本的数量计算先验概率，具体内容见上一篇关于决策树的介绍  
  76.         if( data->have_priors )  
  77.         {  
  78.             // compute weight scale for each class from their prior probabilities  
  79.             //根据_priors值计算两类问题的两个分类结果的先验概率  
  80.             int c1 = 0;  
  81.             //样本的分类class_labels，即响应值，只能为0或者为1   
  82.             for( i = 0; i < n; i++ )  
  83.                 c1 += class_labels[i];    //统计响应值为1的样本数量  
  84.             //响应值为0的先验概率  
  85.             p[0] = data->priors->data.db[0]*(c1 < n ? 1./(n - c1) : 0.);  
  86.             //响应值为1的先验概率  
  87.             p[1] = data->priors->data.db[1]*(c1 > 0 ? 1./c1 : 0.);  
  88.             //归一化p[0]和p[1]  
  89.             p[0] /= p[0] + p[1];  
  90.             p[1] = 1. - p[0];  
  91.         }  
  92.   
  93.         if (data->is_buf_16u)    //训练样本数量小于65536个，即可以用一个unsigned short数据类型表示该数量  
  94.         {  
  95.             // data->get_cv_labels函数访问的就是labels指向的空间，表示全体样本索引与构建决策树的样本索引的映射关系  
  96.             unsigned short* labels = (unsigned short*)(dtree_data_buf->data.s + data->data_root->buf_idx*length_buf_row +  
  97.                 data->data_root->offset + (data->work_var_count-1)*data->sample_count);  
  98.             //遍历所有样本数据  
  99.             for( i = 0; i < n; i++ )  
  100.             {  
  101.                 // save original categorical responses {0,1}, convert them to {-1,1}  
  102.                 //原始数据的响应值为0或1，我们要把它转换为-1或1的形式  
  103.                 // 0 × 2 – 1 = -1；1 × 2 - 1 = 1  
  104.                 orig_response->data.i[i] = class_labels[i]*2 - 1;  
  105.                 // make all the samples active at start.  
  106.                 // later, in trim_weights() deactivate/reactive again some, if need  
  107.                 //第一次开始训练的时候，所有样本数据都应该被使用，所以样本对应的掩码都为1，表示可以使用，而在训练迭代的过程中，也许会有一些样本通过trim_weights()函数被裁剪掉，这时该样本的掩码就要为0  
  108.                 subsample_mask->data.ptr[i] = (uchar)1;  
  109.                 // make all the initial weights the same.  
  110.                 //初始化每个样本数据的权值，即步骤2。class_labels[i]不是为0就是为1，而在没有先验分类概率的情况下p[0]和p[1]都为1，即前面原理分析中步骤2的每个样本数据的权值为1/n；而在有先验分类概率的情况下，每个样本数据的权值还要根据响应值用先验概率p[0]或p[1]再乘以1/n  
  111.                 weights->data.db[i] = w0*p[class_labels[i]];  
  112.                 // set the labels to find (from within weak tree learning proc)  
  113.                 // the particular sample weight, and where to store the response.  
  114.                 //顺序存储样本的索引值，即得到一种映射关系  
  115.                 labels[i] = (unsigned short)i;  
  116.             }  
  117.         }  
  118.         else    //样本数据大于65536个，则需要用一个int数据类型表示  
  119.         {  
  120.             int* labels = dtree_data_buf->data.i + data->data_root->buf_idx*length_buf_row +  
  121.                 data->data_root->offset + (data->work_var_count-1)*data->sample_count;  
  122.   
  123.             for( i = 0; i < n; i++ )  
  124.             {  
  125.                 // save original categorical responses {0,1}, convert them to {-1,1}  
  126.                 orig_response->data.i[i] = class_labels[i]*2 - 1;  
  127.                 // make all the samples active at start.  
  128.                 // later, in trim_weights() deactivate/reactive again some, if need  
  129.                 subsample_mask->data.ptr[i] = (uchar)1;  
  130.                 // make all the initial weights the same.  
  131.                 weights->data.db[i] = w0*p[class_labels[i]];  
  132.                 // set the labels to find (from within weak tree learning proc)  
  133.                 // the particular sample weight, and where to store the response.  
  134.                 labels[i] = i;  
  135.             }  
  136.         }  
  137.   
  138.         if( params.boost_type == LOGIT )    //LogitBoost类型  
  139.         {  
  140.             CV_CALL( sum_response = cvCreateMat( 1, n, CV_64F ));    //定义矩阵  
  141.             //遍历所有样本，初始化变量  
  142.             for( i = 0; i < n; i++ )  
  143.             {  
  144.                 sum_response->data.db[i] = 0;    //清零  
  145.                 //如果样本的响应值为1，则该样本对应的响应值副本为2；如果响应值不为1，则为-2  
  146.                 fdata[sample_idx[i]*step] = orig_response->data.i[i] > 0 ? 2.f : -2.f;  
  147.             }  
  148.   
  149.             // in case of logitboost each weak tree is a regression tree.  
  150.             // the target function values are recalculated for each of the trees  
  151.             data->is_classifier = false;    // LogitBoost类型应用的是回归树  
  152.         }  
  153.         else if( params.boost_type == GENTLE )    // Gentle AdaBoost类型  
  154.         {  
  155.             //遍历所有样本，初始化变量  
  156.             for( i = 0; i < n; i++ )  
  157.                 //样本的响应值副本的值与原始响应值一致  
  158.                 fdata[sample_idx[i]*step] = (float)orig_response->data.i[i];  
  159.   
  160.             data->is_classifier = false;    // Gentle AdaBoost类型应用的是回归树  
  161.         }  
  162.     }  
  163.     else    //真正进入循环迭代，更新权值的过程  
  164.     {  
  165.         // at this moment, for all the samples that participated in the training of the most  
  166.         // recent weak classifier we know the responses. For other samples we need to compute them  
  167.         //在上一次迭代中，如果利用的裁剪后的样本数据，说明有一些样本被裁剪掉而没有它们的弱分类器（即决策树）的响应值，但在后更新权值时，是需要所有的训练样本数据，因此这里我们通过构建好的决策树来预测这些裁剪掉的样本，从而得到它们的响应值  
  168.         if( have_subsample )    //有训练样本被掩码裁剪掉  
  169.         {  
  170.             // values表示需要预测的样本数据  
  171.             float* values = (float*)cur_buf_pos;  
  172.             // values空间的长度为本次迭代训练样本的实际长度  
  173.             cur_buf_pos = (uchar*)(values + data->get_length_subbuf());  
  174.             uchar* missing = cur_buf_pos;    //missing表示样本缺失特征属性的掩码  
  175.             // cur_buf_pos再次指向一段内存空间  
  176.             cur_buf_pos = missing + data->get_length_subbuf() * (size_t)CV_ELEM_SIZE(data->buf->type);  
  177.   
  178.             CvMat _sample, _mask;  
  179.   
  180.             // invert the subsample mask  
  181.             //保留的样本掩码为1，裁剪掉的为0，现在反转掩码，即保留的为0，裁剪掉的为1  
  182.             cvXorS( subsample_mask, cvScalar(1.), subsample_mask );  
  183.             //得到裁剪掉的样本数据  
  184.             data->get_vectors( subsample_mask, values, missing, 0 );  
  185.             //定义矩阵  
  186.             _sample = cvMat( 1, data->var_count, CV_32F );    //表示裁剪掉的样本  
  187.             _mask = cvMat( 1, data->var_count, CV_8U );    //表示对应样本所缺失的特征  
  188.   
  189.             // run tree through all the non-processed samples  
  190.             //遍历所有样本，但只处理那些被裁剪掉的样本  
  191.             for( i = 0; i < n; i++ )  
  192.                 if( subsample_mask->data.ptr[i] )    //被裁剪掉的样本数据  
  193.                 {  
  194.                     _sample.data.fl = values;    //赋值  
  195.                     _mask.data.ptr = missing;    //赋值  
  196.                     values += _sample.cols;    //指向下一个样本  
  197.                     missing += _mask.cols;    //指向下一个样本  
  198.                     //通过预测得到被裁剪掉的样本的弱分类器的响应值  
  199.                     weak_eval->data.db[i] = tree->predict( &_sample, &_mask, true )->value;  
  200.                 }  
  201.         }  
  202.   
  203.         // now update weights and other parameters for each type of boosting  
  204.         //根据不同类型更新权值  
  205.         if( params.boost_type == DISCRETE )    //Discrete Adaboost类型  
  206.         {  
  207.             // Discrete AdaBoost:  
  208.             //   weak_eval[i] (=f(x_i)) is in {-1,1}  
  209.             //   err = sum(w_i*(f(x_i) != y_i))/sum(w_i)  
  210.             //   C = log((1-err)/err)  
  211.             //   w_i *= exp(C*(f(x_i) != y_i))  
  212.   
  213.             double C, err = 0.;  
  214.             double scale[] = { 1., 0. };  
  215.             //遍历所有样本数据  
  216.             for( i = 0; i < n; i++ )  
  217.             {  
  218.                 //得到上次迭代后每个训练样本数据的权值，即wi(m)  
  219.                 double w = weights->data.db[i];  
  220.                 //权值之和，即式9中的分母部分  
  221.                 sumw += w;  
  222.                 //分类器分类错误的那些训练样本数据的权值之和，即式9中的分子部分  
  223.                 // weak_eval表示该次迭代的弱分类器的分类结果，orig_response为实际的分类结果，weak_eval->data.db[i] != orig_response->data.i[i]的作用是判断分类是否正确，正确为0，错误为1  
  224.                 err += w*(weak_eval->data.db[i] != orig_response->data.i[i]);  
  225.             }  
  226.             //得到误差率，即式9  
  227.             if( sumw != 0 )  
  228.                 err /= sumw;  
  229.             //log_ratio(x)为内嵌函数，该函数的输出为ln[x/(1-x)]  
  230.             //C和err的值为式13，C表示该次迭代得到的弱分类器的权值，即αm  
  231.             C = err = -log_ratio( err );  
  232.             // scale[1]为式10中括号内的部分，该值肯定大于1，而此时scale[0]仍然为1  
  233.             scale[1] = exp(err);  
  234.   
  235.             sumw = 0;  
  236.             //再次遍历训练样本数据，更新样本权值wi(m+1)  
  237.             for( i = 0; i < n; i++ )  
  238.             {  
  239.                 //分类正确为scale[0]，分类错误为scale[1]，即式14  
  240.                 double w = weights->data.db[i]*  
  241.                     scale[weak_eval->data.db[i] != orig_response->data.i[i]];  
  242.                 sumw += w;    //权值之和，后面归一化要用  
  243.                 weights->data.db[i] = w;    //赋值  
  244.             }  
  245.             //为弱分类器的权值赋值，即该决策树tree的每节点值都乘以C，也就是得到了式12的αmkm(x)  
  246.             tree->scale( C );  
  247.         }  
  248.         else if( params.boost_type == REAL )    // Real AdaBoost类型  
  249.         {  
  250.             // Real AdaBoost:  
  251.             //   weak_eval[i] = f(x_i) = 0.5*log(p(x_i)/(1-p(x_i))), p(x_i)=P(y=1|x_i)  
  252.             //   w_i *= exp(-y_i*f(x_i))  
  253.             //weak_eval变量在计算前为弱分类器km(x)，但在遍历循环后被赋予新的含义，为式16中的e指数中的指数部分  
  254.             for( i = 0; i < n; i++ )  
  255.                 weak_eval->data.db[i] *= -orig_response->data.i[i];  
  256.             //计算式16的e指数  
  257.             cvExp( weak_eval, weak_eval );  
  258.             //遍历训练样本数据，更新权值wi(m)  
  259.             for( i = 0; i < n; i++ )  
  260.             {  
  261.                 //式16，得到权值wi(m+1)  
  262.                 double w = weights->data.db[i]*weak_eval->data.db[i];  
  263.                 sumw += w;    //权值之和，后面归一化要用  
  264.                 weights->data.db[i] = w;    //赋值  
  265.             }  
  266.         }  
  267.         else if( params.boost_type == LOGIT )     //LogitBoost类型  
  268.         {  
  269.             // LogitBoost:  
  270.             //   weak_eval[i] = f(x_i) in [-z_max,z_max]  
  271.             //   sum_response = F(x_i).  
  272.             //   F(x_i) += 0.5*f(x_i)  
  273.             //   p(x_i) = exp(F(x_i))/(exp(F(x_i)) + exp(-F(x_i))=1/(1+exp(-2*F(x_i)))  
  274.             //   reuse weak_eval: weak_eval[i] <- p(x_i)  
  275.             //   w_i = p(x_i)*1(1 - p(x_i))  
  276.             //   z_i = ((y_i+1)/2 - p(x_i))/(p(x_i)*(1 - p(x_i)))  
  277.             //   store z_i to the data->data_root as the new target responses  
  278.   
  279.             const double lb_weight_thresh = FLT_EPSILON;  
  280.             const double lb_z_max = 10.;  
  281.             /*float* responses_buf = data->get_resp_float_buf(); 
  282.             const float* responses = 0; 
  283.             data->get_ord_responses(data->data_root, responses_buf, &responses);*/  
  284.   
  285.             /*if( weak->total == 7 ) 
  286.                 putchar('*');*/  
  287.   
  288.             for( i = 0; i < n; i++ )  
  289.             {  
  290.                 //式22  
  291.                 double s = sum_response->data.db[i] + 0.5*weak_eval->data.db[i];  
  292.                 sum_response->data.db[i] = s;    //赋值  
  293.                 weak_eval->data.db[i] = -2*s;    //该变量式21要用  
  294.             }  
  295.             //计算e指数  
  296.             cvExp( weak_eval, weak_eval );  
  297.             //遍历所有训练样本数据  
  298.             for( i = 0; i < n; i++ )  
  299.             {  
  300.                 //式21，得到更新后的pm(xi)  
  301.                 double p = 1./(1. + weak_eval->data.db[i]);  
  302.                 //w为权值wi(m)，式20  
  303.                 double w = p*(1 - p), z;  
  304.                 //确保w是具有一定意义的正数  
  305.                 w = MAX( w, lb_weight_thresh );  
  306.                 weights->data.db[i] = w;    //权值赋值  
  307.                 sumw += w;    //权值之和，后面归一化要用  
  308.                 //计算工作响应zi(m)  
  309.                 if( orig_response->data.i[i] > 0 )    //样本数据属于y = 1的一类  
  310.                 {  
  311.                     z = 1./p;  
  312.                     fdata[sample_idx[i]*step] = (float)MIN(z, lb_z_max);  
  313.                 }  
  314.                 else    //样本数据属于y = -1的一类  
  315.                 {  
  316.                     z = 1./(1-p);  
  317.                     fdata[sample_idx[i]*step] = (float)-MIN(z, lb_z_max);  
  318.                 }  
  319.             }  
  320.         }  
  321.         else    //Gentle AdaBoost类型  
  322.         {  
  323.             // Gentle AdaBoost:  
  324.             //   weak_eval[i] = f(x_i) in [-1,1]  
  325.             //   w_i *= exp(-y_i*f(x_i))  
  326.             //确保为Gentle AdaBoost类型  
  327.             assert( params.boost_type == GENTLE );  
  328.             //计算式24中e指数中的指数部分  
  329.             for( i = 0; i < n; i++ )  
  330.                 weak_eval->data.db[i] *= -orig_response->data.i[i];  
  331.             //计算式24中的e指数  
  332.             cvExp( weak_eval, weak_eval );  
  333.   
  334.             for( i = 0; i < n; i++ )  
  335.             {  
  336.                 //式24，更新权值  
  337.                 double w = weights->data.db[i] * weak_eval->data.db[i];  
  338.                 weights->data.db[i] = w;    //赋值  
  339.                 sumw += w;    //权值之和，后面归一化要用  
  340.             }  
  341.         }  
  342.     }  
  343.   
  344.     // renormalize weights  
  345.     //归一化权值wi(m+1)  
  346.     if( sumw > FLT_EPSILON )  
  347.     {  
  348.         sumw = 1./sumw;  
  349.         for( i = 0; i < n; ++i )  
  350.             weights->data.db[i] *= sumw;  
  351.     }  
  352.   
  353.     __END__;  
  354. }  
void
CvBoost::update_weights_impl( CvBoostTree* tree, double initial_weights[2] )
{
    CV_FUNCNAME( "CvBoost::update_weights_impl" );

    __BEGIN__;
    //n表示训练样本的数量
    int i, n = data->sample_count;
    double sumw = 0.;    //表示权值的和，权值归一化时要用
    int step = 0;
    float* fdata = 0;
    int *sample_idx_buf;
    const int* sample_idx = 0;
    cv::AutoBuffer inn_buf;
    //根据AdaBoost类型的不同，定义不同大小的缓存，Discrete和Real时为0，LogitBoost和Gentle时为所有训练样本的数据长度，存储着样本响应值的副本
    size_t _buf_size = (params.boost_type == LOGIT) || (params.boost_type == GENTLE) ? (size_t)(data->sample_count)*sizeof(int) : 0;
    if( !tree )    //初始化权值，因为此时还没有弱分类器
        _buf_size += n*sizeof(int);    //增加_buf_size的大小，增加的长度为所有训练样本的数据长度，存储着样本响应值
    else    //训练样本的迭代过程中
    {
        //如果发生了样本裁剪，则_buf_size的增加长度为没有被裁剪掉的样本数据长度，即此次迭代中真正用到的那些样本的数据长度，存储的内容为该次迭代的训练样本数据的响应值
        if( have_subsample )
            _buf_size += data->get_length_subbuf()*(sizeof(float)+sizeof(uchar));
    }
    //为inn_buf分配_buf_size大小的内存空间
    inn_buf.allocate(_buf_size);
    // cur_buf_pos指向inn_buf的空间的首地址
    uchar* cur_buf_pos = (uchar*)inn_buf;
    //如果是LogitBoost和Gentle类型
    if ( (params.boost_type == LOGIT) || (params.boost_type == GENTLE) )
    {
        //得到步长
        step = CV_IS_MAT_CONT(data->responses_copy->type) ?
            1 : data->responses_copy->step / CV_ELEM_SIZE(data->responses_copy->type);
        fdata = data->responses_copy->data.fl;    //指向样本响应值的副本
        sample_idx_buf = (int*)cur_buf_pos;    //指向inn_buf空间
        // cur_buf_pos指向此次迭代训练的样本数据的首地址
        cur_buf_pos = (uchar*)(sample_idx_buf + data->sample_count);
        //得到训练样本序列索引
        sample_idx = data->get_sample_indices( data->data_root, sample_idx_buf );
    }
    // dtree_data_buf指向训练数据的内存首地址，训练数据是以矩阵的形式进行存储的
    CvMat* dtree_data_buf = data->buf;
    // length_buf_row表示当前训练样本的数量，因为并不是所有的样本都用于本次迭代，有一些样本被剪切掉了
    size_t length_buf_row = data->get_length_subbuf();
    //进入if的条件是在第一次迭代之前，即还没有弱分类器的时候，它的作用是初始化一些变量和参数
    if( !tree ) // before training the first tree, initialize weights and other parameters
    { 
        // class_labels_buf表示分类结果，即响应值
        int* class_labels_buf = (int*)cur_buf_pos;
        // cur_buf_pos指向另一块内存空间
        cur_buf_pos = (uchar*)(class_labels_buf + n);
        //得到训练样本的响应值，也就是样本的分类结果
        const int* class_labels = data->get_class_labels(data->data_root, class_labels_buf);
        // in case of logitboost and gentle adaboost each weak tree is a regression tree,
        // so we need to convert class labels to floating-point values
        //由于LogitBoost和Gentle需要浮点型的数据，构建它们的弱分类器的决策树是回归树，所以需要重新定义一些变量，因为这些变量在初始化时都是整型的
        //w0用于初始化权值wi(1)
        double w0 = 1./n;
        // p[2] = { 1, 1 }，表示两类问题的先验概率
        double p[2] = { initial_weights[0], initial_weights[1] };
        //释放、重新分配一些矩阵
        cvReleaseMat( &orig_response );
        cvReleaseMat( &sum_response );
        cvReleaseMat( &weak_eval );
        cvReleaseMat( &subsample_mask );
        cvReleaseMat( &weights );
        cvReleaseMat( &subtree_weights );
        //重新定义一些矩阵
        CV_CALL( orig_response = cvCreateMat( 1, n, CV_32S ));
        CV_CALL( weak_eval = cvCreateMat( 1, n, CV_64F ));
        CV_CALL( subsample_mask = cvCreateMat( 1, n, CV_8U ));
        CV_CALL( weights = cvCreateMat( 1, n, CV_64F ));
        CV_CALL( subtree_weights = cvCreateMat( 1, n + 2, CV_64F ));
        //如果在设置Boosting参数的时候设置了_priors值，并且AdaBoost算法为Discrete Adaboost或Real AdaBoost，则表示样本属性有先验概率，即have_priors为true，则需要根据训练样本的数量计算先验概率，具体内容见上一篇关于决策树的介绍
        if( data->have_priors )
        {
            // compute weight scale for each class from their prior probabilities
            //根据_priors值计算两类问题的两个分类结果的先验概率
            int c1 = 0;
            //样本的分类class_labels，即响应值，只能为0或者为1 
            for( i = 0; i < n; i++ )
                c1 += class_labels[i];    //统计响应值为1的样本数量
            //响应值为0的先验概率
            p[0] = data->priors->data.db[0]*(c1 < n ? 1./(n - c1) : 0.);
            //响应值为1的先验概率
            p[1] = data->priors->data.db[1]*(c1 > 0 ? 1./c1 : 0.);
            //归一化p[0]和p[1]
            p[0] /= p[0] + p[1];
            p[1] = 1. - p[0];
        }

        if (data->is_buf_16u)    //训练样本数量小于65536个，即可以用一个unsigned short数据类型表示该数量
        {
            // data->get_cv_labels函数访问的就是labels指向的空间，表示全体样本索引与构建决策树的样本索引的映射关系
            unsigned short* labels = (unsigned short*)(dtree_data_buf->data.s + data->data_root->buf_idx*length_buf_row +
                data->data_root->offset + (data->work_var_count-1)*data->sample_count);
            //遍历所有样本数据
            for( i = 0; i < n; i++ )
            {
                // save original categorical responses {0,1}, convert them to {-1,1}
                //原始数据的响应值为0或1，我们要把它转换为-1或1的形式
                // 0 × 2 – 1 = -1；1 × 2 - 1 = 1
                orig_response->data.i[i] = class_labels[i]*2 - 1;
                // make all the samples active at start.
                // later, in trim_weights() deactivate/reactive again some, if need
                //第一次开始训练的时候，所有样本数据都应该被使用，所以样本对应的掩码都为1，表示可以使用，而在训练迭代的过程中，也许会有一些样本通过trim_weights()函数被裁剪掉，这时该样本的掩码就要为0
                subsample_mask->data.ptr[i] = (uchar)1;
                // make all the initial weights the same.
                //初始化每个样本数据的权值，即步骤2。class_labels[i]不是为0就是为1，而在没有先验分类概率的情况下p[0]和p[1]都为1，即前面原理分析中步骤2的每个样本数据的权值为1/n；而在有先验分类概率的情况下，每个样本数据的权值还要根据响应值用先验概率p[0]或p[1]再乘以1/n
                weights->data.db[i] = w0*p[class_labels[i]];
                // set the labels to find (from within weak tree learning proc)
                // the particular sample weight, and where to store the response.
                //顺序存储样本的索引值，即得到一种映射关系
                labels[i] = (unsigned short)i;
            }
        }
        else    //样本数据大于65536个，则需要用一个int数据类型表示
        {
            int* labels = dtree_data_buf->data.i + data->data_root->buf_idx*length_buf_row +
                data->data_root->offset + (data->work_var_count-1)*data->sample_count;

            for( i = 0; i < n; i++ )
            {
                // save original categorical responses {0,1}, convert them to {-1,1}
                orig_response->data.i[i] = class_labels[i]*2 - 1;
                // make all the samples active at start.
                // later, in trim_weights() deactivate/reactive again some, if need
                subsample_mask->data.ptr[i] = (uchar)1;
                // make all the initial weights the same.
                weights->data.db[i] = w0*p[class_labels[i]];
                // set the labels to find (from within weak tree learning proc)
                // the particular sample weight, and where to store the response.
                labels[i] = i;
            }
        }

        if( params.boost_type == LOGIT )    //LogitBoost类型
        {
            CV_CALL( sum_response = cvCreateMat( 1, n, CV_64F ));    //定义矩阵
            //遍历所有样本，初始化变量
            for( i = 0; i < n; i++ )
            {
                sum_response->data.db[i] = 0;    //清零
                //如果样本的响应值为1，则该样本对应的响应值副本为2；如果响应值不为1，则为-2
                fdata[sample_idx[i]*step] = orig_response->data.i[i] > 0 ? 2.f : -2.f;
            }

            // in case of logitboost each weak tree is a regression tree.
            // the target function values are recalculated for each of the trees
            data->is_classifier = false;    // LogitBoost类型应用的是回归树
        }
        else if( params.boost_type == GENTLE )    // Gentle AdaBoost类型
        {
            //遍历所有样本，初始化变量
            for( i = 0; i < n; i++ )
                //样本的响应值副本的值与原始响应值一致
                fdata[sample_idx[i]*step] = (float)orig_response->data.i[i];

            data->is_classifier = false;    // Gentle AdaBoost类型应用的是回归树
        }
    }
    else    //真正进入循环迭代，更新权值的过程
    {
        // at this moment, for all the samples that participated in the training of the most
        // recent weak classifier we know the responses. For other samples we need to compute them
        //在上一次迭代中，如果利用的裁剪后的样本数据，说明有一些样本被裁剪掉而没有它们的弱分类器（即决策树）的响应值，但在后更新权值时，是需要所有的训练样本数据，因此这里我们通过构建好的决策树来预测这些裁剪掉的样本，从而得到它们的响应值
        if( have_subsample )    //有训练样本被掩码裁剪掉
        {
            // values表示需要预测的样本数据
            float* values = (float*)cur_buf_pos;
            // values空间的长度为本次迭代训练样本的实际长度
            cur_buf_pos = (uchar*)(values + data->get_length_subbuf());
            uchar* missing = cur_buf_pos;    //missing表示样本缺失特征属性的掩码
            // cur_buf_pos再次指向一段内存空间
            cur_buf_pos = missing + data->get_length_subbuf() * (size_t)CV_ELEM_SIZE(data->buf->type);

            CvMat _sample, _mask;

            // invert the subsample mask
            //保留的样本掩码为1，裁剪掉的为0，现在反转掩码，即保留的为0，裁剪掉的为1
            cvXorS( subsample_mask, cvScalar(1.), subsample_mask );
            //得到裁剪掉的样本数据
            data->get_vectors( subsample_mask, values, missing, 0 );
            //定义矩阵
            _sample = cvMat( 1, data->var_count, CV_32F );    //表示裁剪掉的样本
            _mask = cvMat( 1, data->var_count, CV_8U );    //表示对应样本所缺失的特征

            // run tree through all the non-processed samples
            //遍历所有样本，但只处理那些被裁剪掉的样本
            for( i = 0; i < n; i++ )
                if( subsample_mask->data.ptr[i] )    //被裁剪掉的样本数据
                {
                    _sample.data.fl = values;    //赋值
                    _mask.data.ptr = missing;    //赋值
                    values += _sample.cols;    //指向下一个样本
                    missing += _mask.cols;    //指向下一个样本
                    //通过预测得到被裁剪掉的样本的弱分类器的响应值
                    weak_eval->data.db[i] = tree->predict( &_sample, &_mask, true )->value;
                }
        }

        // now update weights and other parameters for each type of boosting
        //根据不同类型更新权值
        if( params.boost_type == DISCRETE )    //Discrete Adaboost类型
        {
            // Discrete AdaBoost:
            //   weak_eval[i] (=f(x_i)) is in {-1,1}
            //   err = sum(w_i*(f(x_i) != y_i))/sum(w_i)
            //   C = log((1-err)/err)
            //   w_i *= exp(C*(f(x_i) != y_i))

            double C, err = 0.;
            double scale[] = { 1., 0. };
            //遍历所有样本数据
            for( i = 0; i < n; i++ )
            {
                //得到上次迭代后每个训练样本数据的权值，即wi(m)
                double w = weights->data.db[i];
                //权值之和，即式9中的分母部分
                sumw += w;
                //分类器分类错误的那些训练样本数据的权值之和，即式9中的分子部分
                // weak_eval表示该次迭代的弱分类器的分类结果，orig_response为实际的分类结果，weak_eval->data.db[i] != orig_response->data.i[i]的作用是判断分类是否正确，正确为0，错误为1
                err += w*(weak_eval->data.db[i] != orig_response->data.i[i]);
            }
            //得到误差率，即式9
            if( sumw != 0 )
                err /= sumw;
            //log_ratio(x)为内嵌函数，该函数的输出为ln[x/(1-x)]
            //C和err的值为式13，C表示该次迭代得到的弱分类器的权值，即αm
            C = err = -log_ratio( err );
            // scale[1]为式10中括号内的部分，该值肯定大于1，而此时scale[0]仍然为1
            scale[1] = exp(err);

            sumw = 0;
            //再次遍历训练样本数据，更新样本权值wi(m+1)
            for( i = 0; i < n; i++ )
            {
                //分类正确为scale[0]，分类错误为scale[1]，即式14
                double w = weights->data.db[i]*
                    scale[weak_eval->data.db[i] != orig_response->data.i[i]];
                sumw += w;    //权值之和，后面归一化要用
                weights->data.db[i] = w;    //赋值
            }
            //为弱分类器的权值赋值，即该决策树tree的每节点值都乘以C，也就是得到了式12的αmkm(x)
            tree->scale( C );
        }
        else if( params.boost_type == REAL )    // Real AdaBoost类型
        {
            // Real AdaBoost:
            //   weak_eval[i] = f(x_i) = 0.5*log(p(x_i)/(1-p(x_i))), p(x_i)=P(y=1|x_i)
            //   w_i *= exp(-y_i*f(x_i))
            //weak_eval变量在计算前为弱分类器km(x)，但在遍历循环后被赋予新的含义，为式16中的e指数中的指数部分
            for( i = 0; i < n; i++ )
                weak_eval->data.db[i] *= -orig_response->data.i[i];
            //计算式16的e指数
            cvExp( weak_eval, weak_eval );
            //遍历训练样本数据，更新权值wi(m)
            for( i = 0; i < n; i++ )
            {
                //式16，得到权值wi(m+1)
                double w = weights->data.db[i]*weak_eval->data.db[i];
                sumw += w;    //权值之和，后面归一化要用
                weights->data.db[i] = w;    //赋值
            }
        }
        else if( params.boost_type == LOGIT )     //LogitBoost类型
        {
            // LogitBoost:
            //   weak_eval[i] = f(x_i) in [-z_max,z_max]
            //   sum_response = F(x_i).
            //   F(x_i) += 0.5*f(x_i)
            //   p(x_i) = exp(F(x_i))/(exp(F(x_i)) + exp(-F(x_i))=1/(1+exp(-2*F(x_i)))
            //   reuse weak_eval: weak_eval[i] <- p(x_i)
            //   w_i = p(x_i)*1(1 - p(x_i))
            //   z_i = ((y_i+1)/2 - p(x_i))/(p(x_i)*(1 - p(x_i)))
            //   store z_i to the data->data_root as the new target responses

            const double lb_weight_thresh = FLT_EPSILON;
            const double lb_z_max = 10.;
            /*float* responses_buf = data->get_resp_float_buf();
            const float* responses = 0;
            data->get_ord_responses(data->data_root, responses_buf, &responses);*/

            /*if( weak->total == 7 )
                putchar('*');*/

            for( i = 0; i < n; i++ )
            {
                //式22
                double s = sum_response->data.db[i] + 0.5*weak_eval->data.db[i];
                sum_response->data.db[i] = s;    //赋值
                weak_eval->data.db[i] = -2*s;    //该变量式21要用
            }
            //计算e指数
            cvExp( weak_eval, weak_eval );
            //遍历所有训练样本数据
            for( i = 0; i < n; i++ )
            {
                //式21，得到更新后的pm(xi)
                double p = 1./(1. + weak_eval->data.db[i]);
                //w为权值wi(m)，式20
                double w = p*(1 - p), z;
                //确保w是具有一定意义的正数
                w = MAX( w, lb_weight_thresh );
                weights->data.db[i] = w;    //权值赋值
                sumw += w;    //权值之和，后面归一化要用
                //计算工作响应zi(m)
                if( orig_response->data.i[i] > 0 )    //样本数据属于y = 1的一类
                {
                    z = 1./p;
                    fdata[sample_idx[i]*step] = (float)MIN(z, lb_z_max);
                }
                else    //样本数据属于y = -1的一类
                {
                    z = 1./(1-p);
                    fdata[sample_idx[i]*step] = (float)-MIN(z, lb_z_max);
                }
            }
        }
        else    //Gentle AdaBoost类型
        {
            // Gentle AdaBoost:
            //   weak_eval[i] = f(x_i) in [-1,1]
            //   w_i *= exp(-y_i*f(x_i))
            //确保为Gentle AdaBoost类型
            assert( params.boost_type == GENTLE );
            //计算式24中e指数中的指数部分
            for( i = 0; i < n; i++ )
                weak_eval->data.db[i] *= -orig_response->data.i[i];
            //计算式24中的e指数
            cvExp( weak_eval, weak_eval );

            for( i = 0; i < n; i++ )
            {
                //式24，更新权值
                double w = weights->data.db[i] * weak_eval->data.db[i];
                weights->data.db[i] = w;    //赋值
                sumw += w;    //权值之和，后面归一化要用
            }
        }
    }

    // renormalize weights
    //归一化权值wi(m+1)
    if( sumw > FLT_EPSILON )
    {
        sumw = 1./sumw;
        for( i = 0; i < n; ++i )
            weights->data.db[i] *= sumw;
    }

    __END__;
}
裁剪去掉那些权值过小的样本数据：
[cpp] view plain copy print ?
  1. void  
  2. CvBoost::trim_weights()  
  3. {  
  4.     //CV_FUNCNAME( "CvBoost::trim_weights" );  
  5.   
  6.     __BEGIN__;  
  7.     //count为训练样本总数，nz_count表示裁剪以后保留下来的样本总数  
  8.     int i, count = data->sample_count, nz_count = 0;  
  9.     double sum, threshold;  
  10.     //裁剪率weight_trim_rate要在0和1之间  
  11.     if( params.weight_trim_rate <= 0. || params.weight_trim_rate >= 1. )  
  12.         EXIT;  
  13.   
  14.     // use weak_eval as temporary buffer for sorted weights  
  15.     //样本权值weights暂时保存到weak_eval中，以便用于对其进行排序  
  16.     cvCopy( weights, weak_eval );  
  17.     //对样本权值按由小到大的顺序进行排序  
  18.     icvSort_64f( weak_eval->data.db, count, 0 );  
  19.   
  20.     // as weight trimming occurs immediately after updating the weights,  
  21.     // where they are renormalized, we assume that the weight sum = 1.  
  22.     sum = 1. - params.weight_trim_rate;  
  23.     //由小到大遍历所有训练样本，找到裁剪率所对应的那个权值  
  24.     for( i = 0; i < count; i++ )  
  25.     {  
  26.         double w = weak_eval->data.db[i];  
  27.         if( sum <= 0 )  
  28.             break;  
  29.         sum -= w;  
  30.     }  
  31.     //得到阈值  
  32.     threshold = i < count ? weak_eval->data.db[i] : DBL_MAX;  
  33.     //再次遍历所有训练样本（这一次不是按照大小顺序遍历），确定哪些样本被裁剪掉  
  34.     for( i = 0; i < count; i++ )  
  35.     {  
  36.         double w = weights->data.db[i];    //得到权值  
  37.         //权值与阈值比较，权值大则f为1，反之f为0  
  38.         int f = w >= threshold;  
  39.         //把权值大于阈值的样本所对应的掩码为置1，反之清0  
  40.         subsample_mask->data.ptr[i] = (uchar)f;  
  41.         nz_count += f;    //计数  
  42.     }  
  43.     // nz_count < count表示有裁剪掉的样本，此时have_subsample为1，反之为0  
  44.     have_subsample = nz_count < count;  
  45.   
  46.     __END__;  
  47. }  
void
CvBoost::trim_weights()
{
    //CV_FUNCNAME( "CvBoost::trim_weights" );

    __BEGIN__;
    //count为训练样本总数，nz_count表示裁剪以后保留下来的样本总数
    int i, count = data->sample_count, nz_count = 0;
    double sum, threshold;
    //裁剪率weight_trim_rate要在0和1之间
    if( params.weight_trim_rate <= 0. || params.weight_trim_rate >= 1. )
        EXIT;

    // use weak_eval as temporary buffer for sorted weights
    //样本权值weights暂时保存到weak_eval中，以便用于对其进行排序
    cvCopy( weights, weak_eval );
    //对样本权值按由小到大的顺序进行排序
    icvSort_64f( weak_eval->data.db, count, 0 );

    // as weight trimming occurs immediately after updating the weights,
    // where they are renormalized, we assume that the weight sum = 1.
    sum = 1. - params.weight_trim_rate;
    //由小到大遍历所有训练样本，找到裁剪率所对应的那个权值
    for( i = 0; i < count; i++ )
    {
        double w = weak_eval->data.db[i];
        if( sum <= 0 )
            break;
        sum -= w;
    }
    //得到阈值
    threshold = i < count ? weak_eval->data.db[i] : DBL_MAX;
    //再次遍历所有训练样本（这一次不是按照大小顺序遍历），确定哪些样本被裁剪掉
    for( i = 0; i < count; i++ )
    {
        double w = weights->data.db[i];    //得到权值
        //权值与阈值比较，权值大则f为1，反之f为0
        int f = w >= threshold;
        //把权值大于阈值的样本所对应的掩码为置1，反之清0
        subsample_mask->data.ptr[i] = (uchar)f;
        nz_count += f;    //计数
    }
    // nz_count < count表示有裁剪掉的样本，此时have_subsample为1，反之为0
    have_subsample = nz_count < count;

    __END__;
}
计算active_vars和active_vars_abs值，这两个值的含义都是记录那些对决策树的分叉起到作用的特征属性的索引值，active_vars存储的索引值是只相对于参与训练决策树的那些特征属性，而active_vars_abs存储的索引值是针对所有的特征属性，包括那些被掩码掉的特征属性
[cpp] view plain copy print ?
  1. const CvMat*  
  2. CvBoost::get_active_vars( bool absolute_idx )  
  3. {  
  4.     CvMat* mask = 0;  
  5.     CvMat* inv_map = 0;  
  6.     CvMat* result = 0;  
  7.   
  8.     CV_FUNCNAME( "CvBoost::get_active_vars" );  
  9.   
  10.     __BEGIN__;  
  11.   
  12.     if( !weak )    //确保已得到分类器  
  13.         CV_ERROR( CV_StsError, "The boosted tree ensemble has not been trained yet" );  
  14.     //还没有为active_vars和active_vars_abs变量赋值  
  15.     if( !active_vars || !active_vars_abs )  
  16.     {  
  17.         CvSeqReader reader;  
  18.         int i, j, nactive_vars;  
  19.         CvBoostTree* wtree;  
  20.         const CvDTreeNode* node;  
  21.   
  22.         assert(!active_vars && !active_vars_abs);  
  23.         mask = cvCreateMat( 1, data->var_count, CV_8U );  
  24.         inv_map = cvCreateMat( 1, data->var_count, CV_32S );  
  25.         cvZero( mask );    //mask矩阵清零  
  26.         cvSet( inv_map, cvScalar(-1) );    //inv_map矩阵赋值为-1  
  27.   
  28.         // first pass: compute the mask of used variables  
  29.         //把强分类器序列weak保存到reader变量中  
  30.         cvStartReadSeq( weak, &reader );  
  31.         //遍历所有的弱分类器  
  32.         for( i = 0; i < weak->total; i++ )  
  33.         {  
  34.             CV_READ_SEQ_ELEM(wtree, reader);    //得到一个弱分类器，即决策树  
  35.   
  36.             node = wtree->get_root();    //得到决策树的根节点  
  37.             assert( node != 0 );    //确保根节点不为零，即该决策树存在  
  38.             for(;;)    //遍历决策树的各个节点  
  39.             {  
  40.                 const CvDTreeNode* parent;    //定义父节点  
  41.                 for(;;)    沿着左分子向叶节点遍历  
  42.                 {  
  43.                     CvDTreeSplit* split = node->split;    //分叉属性  
  44.                     //遍历该节点的所有分叉属性，包括最佳分叉属性和替代分叉属性  
  45.                     for( ; split != 0; split = split->next )  
  46.                         mask->data.ptr[split->var_idx] = 1;    //分叉属性相应位置1  
  47.                     if( !node->left )    //到达了叶节点，则退出for死循环  
  48.                         break;  
  49.                     node = node->left;    //下一个左分支  
  50.                 }  
  51.                 //从叶节点沿着右分支向父节点遍历  
  52.                 for( parent = node->parent; parent && parent->right == node;  
  53.                     node = parent, parent = parent->parent )  
  54.                     ;  
  55.   
  56.                 if( !parent )    //到达了根节点，则退出for死循环  
  57.                     break;  
  58.   
  59.                 node = parent->right;    //下一个右分支  
  60.             }  
  61.         }  
  62.   
  63.         nactive_vars = cvCountNonZero(mask);    //统计mask中非0元素的数量  
  64.   
  65.         //if ( nactive_vars > 0 )  
  66.         {  
  67.             //定义两个矩阵  
  68.             active_vars = cvCreateMat( 1, nactive_vars, CV_32S );  
  69.             active_vars_abs = cvCreateMat( 1, nactive_vars, CV_32S );  
  70.   
  71.             have_active_cat_vars = false;    //标识赋值  
  72.             //遍历所有特征属性  
  73.             for( i = j = 0; i < data->var_count; i++ )  
  74.             {  
  75.                 if( mask->data.ptr[i] )  
  76.                 {  
  77.                     //赋值为特征属性的索引  
  78.                     active_vars->data.i[j] = i;  
  79.                     active_vars_abs->data.i[j] = data->var_idx ? data->var_idx->data.i[i] : i;  
  80.                     // inv_map存储的形式与active_vars相反，即反映射  
  81.                     inv_map->data.i[i] = j;  
  82.                     //如果这些特征属性中只要有一个特征属性是类的形式，则have_active_cat_vars变量就为true  
  83.                     if( data->var_type->data.i[i] >= 0 )  
  84.                         have_active_cat_vars = true;  
  85.                     j++;    //计数  
  86.                 }  
  87.             }  
  88.   
  89.   
  90.             // second pass: now compute the condensed indices  
  91.             cvStartReadSeq( weak, &reader );  
  92.             for( i = 0; i < weak->total; i++ )    //再次遍历所有的弱分类器  
  93.             {  
  94.                 CV_READ_SEQ_ELEM(wtree, reader);  
  95.                 node = wtree->get_root();  
  96.                 for(;;)    //再次遍历决策树  
  97.                 {  
  98.                     const CvDTreeNode* parent;  
  99.                     for(;;)  
  100.                     {  
  101.                         CvDTreeSplit* split = node->split;  
  102.                         for( ; split != 0; split = split->next )  
  103.                         {  
  104.                             // condensed_idx的值为该分叉属性在active_vars的索引，该索引值也是样本数据中特征属性分布排序的索引  
  105.                             split->condensed_idx = inv_map->data.i[split->var_idx];  
  106.                             assert( split->condensed_idx >= 0 );  
  107.                         }  
  108.   
  109.                         if( !node->left )  
  110.                             break;  
  111.                         node = node->left;  
  112.                     }  
  113.   
  114.                     for( parent = node->parent; parent && parent->right == node;  
  115.                         node = parent, parent = parent->parent )  
  116.                         ;  
  117.   
  118.                     if( !parent )  
  119.                         break;  
  120.   
  121.                     node = parent->right;  
  122.                 }  
  123.             }  
  124.         }  
  125.     }  
  126.     //行参absolute_idx为true，则该函数返回active_vars_abs，否则返回active_vars  
  127.     result = absolute_idx ? active_vars_abs : active_vars;  
  128.   
  129.     __END__;  
  130.   
  131.     cvReleaseMat( &mask );  
  132.     cvReleaseMat( &inv_map );  
  133.   
  134.     return result;  
  135. }  
const CvMat*
CvBoost::get_active_vars( bool absolute_idx )
{
    CvMat* mask = 0;
    CvMat* inv_map = 0;
    CvMat* result = 0;

    CV_FUNCNAME( "CvBoost::get_active_vars" );

    __BEGIN__;

    if( !weak )    //确保已得到分类器
        CV_ERROR( CV_StsError, "The boosted tree ensemble has not been trained yet" );
    //还没有为active_vars和active_vars_abs变量赋值
    if( !active_vars || !active_vars_abs )
    {
        CvSeqReader reader;
        int i, j, nactive_vars;
        CvBoostTree* wtree;
        const CvDTreeNode* node;

        assert(!active_vars && !active_vars_abs);
        mask = cvCreateMat( 1, data->var_count, CV_8U );
        inv_map = cvCreateMat( 1, data->var_count, CV_32S );
        cvZero( mask );    //mask矩阵清零
        cvSet( inv_map, cvScalar(-1) );    //inv_map矩阵赋值为-1

        // first pass: compute the mask of used variables
        //把强分类器序列weak保存到reader变量中
        cvStartReadSeq( weak, &reader );
        //遍历所有的弱分类器
        for( i = 0; i < weak->total; i++ )
        {
            CV_READ_SEQ_ELEM(wtree, reader);    //得到一个弱分类器，即决策树

            node = wtree->get_root();    //得到决策树的根节点
            assert( node != 0 );    //确保根节点不为零，即该决策树存在
            for(;;)    //遍历决策树的各个节点
            {
                const CvDTreeNode* parent;    //定义父节点
                for(;;)    沿着左分子向叶节点遍历
                {
                    CvDTreeSplit* split = node->split;    //分叉属性
                    //遍历该节点的所有分叉属性，包括最佳分叉属性和替代分叉属性
                    for( ; split != 0; split = split->next )
                        mask->data.ptr[split->var_idx] = 1;    //分叉属性相应位置1
                    if( !node->left )    //到达了叶节点，则退出for死循环
                        break;
                    node = node->left;    //下一个左分支
                }
                //从叶节点沿着右分支向父节点遍历
                for( parent = node->parent; parent && parent->right == node;
                    node = parent, parent = parent->parent )
                    ;

                if( !parent )    //到达了根节点，则退出for死循环
                    break;

                node = parent->right;    //下一个右分支
            }
        }

        nactive_vars = cvCountNonZero(mask);    //统计mask中非0元素的数量

        //if ( nactive_vars > 0 )
        {
            //定义两个矩阵
            active_vars = cvCreateMat( 1, nactive_vars, CV_32S );
            active_vars_abs = cvCreateMat( 1, nactive_vars, CV_32S );

            have_active_cat_vars = false;    //标识赋值
            //遍历所有特征属性
            for( i = j = 0; i < data->var_count; i++ )
            {
                if( mask->data.ptr[i] )
                {
                    //赋值为特征属性的索引
                    active_vars->data.i[j] = i;
                    active_vars_abs->data.i[j] = data->var_idx ? data->var_idx->data.i[i] : i;
                    // inv_map存储的形式与active_vars相反，即反映射
                    inv_map->data.i[i] = j;
                    //如果这些特征属性中只要有一个特征属性是类的形式，则have_active_cat_vars变量就为true
                    if( data->var_type->data.i[i] >= 0 )
                        have_active_cat_vars = true;
                    j++;    //计数
                }
            }


            // second pass: now compute the condensed indices
            cvStartReadSeq( weak, &reader );
            for( i = 0; i < weak->total; i++ )    //再次遍历所有的弱分类器
            {
                CV_READ_SEQ_ELEM(wtree, reader);
                node = wtree->get_root();
                for(;;)    //再次遍历决策树
                {
                    const CvDTreeNode* parent;
                    for(;;)
                    {
                        CvDTreeSplit* split = node->split;
                        for( ; split != 0; split = split->next )
                        {
                            // condensed_idx的值为该分叉属性在active_vars的索引，该索引值也是样本数据中特征属性分布排序的索引
                            split->condensed_idx = inv_map->data.i[split->var_idx];
                            assert( split->condensed_idx >= 0 );
                        }

                        if( !node->left )
                            break;
                        node = node->left;
                    }

                    for( parent = node->parent; parent && parent->right == node;
                        node = parent, parent = parent->parent )
                        ;

                    if( !parent )
                        break;

                    node = parent->right;
                }
            }
        }
    }
    //行参absolute_idx为true，则该函数返回active_vars_abs，否则返回active_vars
    result = absolute_idx ? active_vars_abs : active_vars;

    __END__;

    cvReleaseMat( &mask );
    cvReleaseMat( &inv_map );

    return result;
}
CvBoostTree类中的一个train函数：
[cpp] view plain copy print ?
  1. bool  
  2. CvBoostTree::train( CvDTreeTrainData* _train_data,  
  3.                     const CvMat* _subsample_idx, CvBoost* _ensemble )  
  4. {  
  5.     clear();  
  6.     ensemble = _ensemble;  
  7.     data = _train_data;    //样本数据  
  8.     data->shared = true;  
  9.     return do_train( _subsample_idx );  
  10. }  
bool
CvBoostTree::train( CvDTreeTrainData* _train_data,
                    const CvMat* _subsample_idx, CvBoost* _ensemble )
{
    clear();
    ensemble = _ensemble;
    data = _train_data;    //样本数据
    data->shared = true;
    return do_train( _subsample_idx );
}
从上面的train函数可以看出，它主要是调用do_train函数，而CvBoostTree类没有do_train函数，因此train函数是调用CvBoostTree类的父类CvDTree中的do_train函数：
[cpp] view plain copy print ?
  1. bool CvDTree::do_train( const CvMat* _subsample_idx )  
  2. {  
  3.     bool result = false;  
  4.   
  5.     CV_FUNCNAME( "CvDTree::do_train" );  
  6.   
  7.     __BEGIN__;  
  8.     //得到训练样本数据  
  9.     root = data->subsample_data( _subsample_idx );  
  10.   
  11.     CV_CALL( try_split_node(root));  
  12.   
  13.     if( root->split )  
  14.     {  
  15.         CV_Assert( root->left );  
  16.         CV_Assert( root->right );  
  17.         //用于弱分类器的决策树不需要剪枝，所以这里不会调用prune_cv函数  
  18.         if( data->params.cv_folds > 0 )  
  19.             CV_CALL( prune_cv() );  
  20.   
  21.         if( !data->shared )  
  22.             data->free_train_data();  
  23.   
  24.         result = true;  
  25.     }  
  26.   
  27.     __END__;  
  28.   
  29.     return result;  
  30. }  
bool CvDTree::do_train( const CvMat* _subsample_idx )
{
    bool result = false;

    CV_FUNCNAME( "CvDTree::do_train" );

    __BEGIN__;
    //得到训练样本数据
    root = data->subsample_data( _subsample_idx );

    CV_CALL( try_split_node(root));

    if( root->split )
    {
        CV_Assert( root->left );
        CV_Assert( root->right );
        //用于弱分类器的决策树不需要剪枝，所以这里不会调用prune_cv函数
        if( data->params.cv_folds > 0 )
            CV_CALL( prune_cv() );

        if( !data->shared )
            data->free_train_data();

        result = true;
    }

    __END__;

    return result;
}
递归调用try_split_node函数，完成决策树的构造：
[cpp] view plain copy print ?
  1. void  
  2. CvBoostTree::try_split_node( CvDTreeNode* node )  
  3. {  
  4.     //调用CvDTree::try_split_node函数  
  5.     CvDTree::try_split_node( node );  
  6.     //在构建决策树的过程中，一旦某个节点再也不能分叉，则进入下面的if语句，完成该节点内所有样本的弱分类器（即响应值）的赋值  
  7.     if( !node->left )   
  8.     {  
  9.         // if the node has not been split,  
  10.         // store the responses for the corresponding training samples  
  11.         //指向弱分类器的响应值  
  12.         double* weak_eval = ensemble->get_weak_response()->data.db;  
  13.         //开辟一块大小为该节点样本数据长的内存  
  14.         cv::AutoBuffer<int> inn_buf(node->sample_count);  
  15.         //labels表示该节点node内的样本在全体训练样本集中的索引  
  16.         const int* labels = data->get_cv_labels( node, (int*)inn_buf );  
  17.         int i, count = node->sample_count;    //count表示该节点的样本数  
  18.         //该节点的值，当该节点有多个样本是，如果是分类树，节点的值等于拥有最大数量的那个分类的响应值；如果是回归树，节点的值等于所有样本的平均响应值；当该节点只有一个样本时，节点的值就是该样本的响应值  
  19.         double value = node->value;   
  20.         //遍历该节点的所有样本，为该节点内的样本所对应的弱分类器的响应值赋值  
  21.         for( i = 0; i < count; i++ )  
  22.             weak_eval[labels[i]] = value;  
  23.     }  
  24. }  
void
CvBoostTree::try_split_node( CvDTreeNode* node )
{
    //调用CvDTree::try_split_node函数
    CvDTree::try_split_node( node );
    //在构建决策树的过程中，一旦某个节点再也不能分叉，则进入下面的if语句，完成该节点内所有样本的弱分类器（即响应值）的赋值
    if( !node->left ) 
    {
        // if the node has not been split,
        // store the responses for the corresponding training samples
        //指向弱分类器的响应值
        double* weak_eval = ensemble->get_weak_response()->data.db;
        //开辟一块大小为该节点样本数据长的内存
        cv::AutoBuffer inn_buf(node->sample_count);
        //labels表示该节点node内的样本在全体训练样本集中的索引
        const int* labels = data->get_cv_labels( node, (int*)inn_buf );
        int i, count = node->sample_count;    //count表示该节点的样本数
        //该节点的值，当该节点有多个样本是，如果是分类树，节点的值等于拥有最大数量的那个分类的响应值；如果是回归树，节点的值等于所有样本的平均响应值；当该节点只有一个样本时，节点的值就是该样本的响应值
        double value = node->value; 
        //遍历该节点的所有样本，为该节点内的样本所对应的弱分类器的响应值赋值
        for( i = 0; i < count; i++ )
            weak_eval[labels[i]] = value;
    }
}
下面我们介绍预测函数predict：
[cpp] view plain copy print ?
  1. float  
  2. CvBoost::predict( const CvMat* _sample, const CvMat* _missing,  
  3.                   CvMat* weak_responses, CvSlice slice,  
  4.                   bool raw_mode, bool return_sum ) const  
  5. //_sample表示要预测的样本数据  
  6. //_missing表示预测样本中所缺失的特征属性，该变量为掩码的形式  
  7. // weak_responses表示弱分类器所对应的响应，因此它的元素个数必须与弱分类器的数量一致，默认值0，表示不使用该变量  
  8. //slice表示用于预测的弱分类器的连续子集，默认值为CV_WHOLE_SEQ，表示使用所有的弱分类器  
  9. // raw_mode与CvDTree::predict函数的第三个参数的含义相同，默认为false，具体请看上一篇文章  
  10. // return_sum表示该函数返回值的形式，默认为false，表示返回式12或式17的值，如果该值为true，则返回式12或式17中括号内的值，即不进行符号判断  
  11. {  
  12.     float value = -FLT_MAX;    //初始一个很大的负值  
  13.   
  14.     CvSeqReader reader;  
  15.     double sum = 0;  
  16.     int wstep = 0;  
  17.     const float* sample_data;  
  18.   
  19.     if( !weak )    //还没有强分类器  
  20.         CV_Error( CV_StsError, "The boosted tree ensemble has not been trained yet" );  
  21.     //判断输入参数_sample的正确性  
  22.     if( !CV_IS_MAT(_sample) || CV_MAT_TYPE(_sample->type) != CV_32FC1 ||  
  23.         (_sample->cols != 1 && _sample->rows != 1) ||  
  24.         (_sample->cols + _sample->rows - 1 != data->var_all && !raw_mode) ||  
  25.         (active_vars && _sample->cols + _sample->rows - 1 != active_vars->cols && raw_mode) )  
  26.             CV_Error( CV_StsBadArg,  
  27.         "the input sample must be 1d floating-point vector with the same "  
  28.         "number of elements as the total number of variables or "  
  29.         "as the number of variables used for training" );  
  30.   
  31.     if( _missing )    //判断输入参数_missing的正确性  
  32.     {  
  33.         if( !CV_IS_MAT(_missing) || !CV_IS_MASK_ARR(_missing) ||  
  34.             !CV_ARE_SIZES_EQ(_missing, _sample) )  
  35.             CV_Error( CV_StsBadArg,  
  36.             "the missing data mask must be 8-bit vector of the same size as input sample" );  
  37.     }  
  38.     // weak_count为根据输入参数slice而得到的弱分类器的数量  
  39.     int i, weak_count = cvSliceLength( slice, weak );  
  40.     //确保weak_count正确  
  41.     if( weak_count >= weak->total )  
  42.     {  
  43.         weak_count = weak->total;  
  44.         slice.start_index = 0;  
  45.     }  
  46.   
  47.     if( weak_responses )    //确保输入参数weak_responses的正确性  
  48.     {  
  49.         if( !CV_IS_MAT(weak_responses) ||  
  50.             CV_MAT_TYPE(weak_responses->type) != CV_32FC1 ||  
  51.             (weak_responses->cols != 1 && weak_responses->rows != 1) ||  
  52.             weak_responses->cols + weak_responses->rows - 1 != weak_count )  
  53.             CV_Error( CV_StsBadArg,  
  54.             "The output matrix of weak classifier responses must be valid "  
  55.             "floating-point vector of the same number of components as the length of input slice" );  
  56.         wstep = CV_IS_MAT_CONT(weak_responses->type) ? 1 : weak_responses->step/sizeof(float);  
  57.     }  
  58.     //得到active_vars变量的行，即启作用的特征属性的数量  
  59.     int var_count = active_vars->cols;  
  60.     const int* vtype = data->var_type->data.i;    //指向全体特征属性  
  61.     const int* cmap = data->cat_map->data.i;    //指向特征属性为类形式的映射  
  62.     const int* cofs = data->cat_ofs->data.i;    //表示特征属性为类形式的各个属性的偏移量  
  63.   
  64.     cv::Mat sample = _sample;    //预测样本  
  65.     cv::Mat missing;    //缺失特征属性的掩码  
  66.     if(!_missing)  
  67.         missing = _missing;    //赋值  
  68.   
  69.     // if need, preprocess the input vector  
  70.     //对预测样本的特征属性做规范化处理，具体内容请看我的上一篇关于决策树的文章  
  71.     if( !raw_mode )  
  72.     {  
  73.         int sstep, mstep = 0;  
  74.         const float* src_sample;  
  75.         const uchar* src_mask = 0;  
  76.         float* dst_sample;  
  77.         uchar* dst_mask;  
  78.         const int* vidx = active_vars->data.i;  
  79.         const int* vidx_abs = active_vars_abs->data.i;  
  80.         bool have_mask = _missing != 0;  
  81.   
  82.         sample = cv::Mat(1, var_count, CV_32FC1);  
  83.         missing = cv::Mat(1, var_count, CV_8UC1);  
  84.   
  85.         dst_sample = sample.ptr<float>();  
  86.         dst_mask = missing.ptr();  
  87.   
  88.         src_sample = _sample->data.fl;  
  89.         sstep = CV_IS_MAT_CONT(_sample->type) ? 1 : _sample->step/sizeof(src_sample[0]);  
  90.   
  91.         if( _missing )  
  92.         {  
  93.             src_mask = _missing->data.ptr;  
  94.             mstep = CV_IS_MAT_CONT(_missing->type) ? 1 : _missing->step;  
  95.         }  
  96.   
  97.         for( i = 0; i < var_count; i++ )  
  98.         {  
  99.             int idx = vidx[i], idx_abs = vidx_abs[i];  
  100.             float val = src_sample[idx_abs*sstep];  
  101.             int ci = vtype[idx];  
  102.             uchar m = src_mask ? src_mask[idx_abs*mstep] : (uchar)0;  
  103.   
  104.             if( ci >= 0 )  
  105.             {  
  106.                 int a = cofs[ci], b = (ci+1 >= data->cat_ofs->cols) ? data->cat_map->cols : cofs[ci+1],  
  107.                     c = a;  
  108.                 int ival = cvRound(val);  
  109.                 if ( (ival != val) && (!m) )  
  110.                     CV_Error( CV_StsBadArg,  
  111.                         "one of input categorical variable is not an integer" );  
  112.   
  113.                 while( a < b )  
  114.                 {  
  115.                     c = (a + b) >> 1;  
  116.                     if( ival < cmap[c] )  
  117.                         b = c;  
  118.                     else if( ival > cmap[c] )  
  119.                         a = c+1;  
  120.                     else  
  121.                         break;  
  122.                 }  
  123.   
  124.                 if( c < 0 || ival != cmap[c] )  
  125.                 {  
  126.                     m = 1;  
  127.                     have_mask = true;  
  128.                 }  
  129.                 else  
  130.                 {  
  131.                     val = (float)(c - cofs[ci]);  
  132.                 }  
  133.             }  
  134.   
  135.             dst_sample[i] = val;  
  136.             dst_mask[i] = m;  
  137.         }  
  138.   
  139.         if( !have_mask )  
  140.             missing.release();  
  141.     }  
  142.     else  
  143.     {  
  144.         if( !CV_IS_MAT_CONT(_sample->type & (_missing ? _missing->type : -1)) )  
  145.             CV_Error( CV_StsBadArg, "In raw mode the input vectors must be continuous" );  
  146.     }  
  147.   
  148.     cvStartReadSeq( weak, &reader );    //读取各个弱分类器  
  149.     cvSetSeqReaderPos( &reader, slice.start_index );    //指定起始地址  
  150.   
  151.     sample_data = sample.ptr<float>();    //预测样本数据的指针  
  152.     // !have_active_cat_vars表示启作用的特征属性中没有任何一个是类的形式，missing.empty()预测样本没有缺失的特征属性，!weak_responses表示该输入参数不存在  
  153.     if( !have_active_cat_vars && missing.empty() && !weak_responses )  
  154.     {  
  155.         //遍历所有的弱分类器  
  156.         for( i = 0; i < weak_count; i++ )  
  157.         {  
  158.             CvBoostTree* wtree;    //表示代表该弱分类器的决策树  
  159.             const CvDTreeNode* node;  
  160.             CV_READ_SEQ_ELEM( wtree, reader );    //提取当前的决策树  
  161.   
  162.             node = wtree->get_root();    //得到决策树的根节点  
  163.             //遍历该决策树，直到到达了叶节点  
  164.             while( node->left )  
  165.             {  
  166.                 CvDTreeSplit* split = node->split;   //节点分叉  
  167.                 //得到该节点分叉属性在样本中特征属性排序的索引  
  168.                 int vi = split->condensed_idx;  
  169.                 float val = sample_data[vi];    //得到该特征属性所对应的样本值  
  170.                 //与分叉值比较，确定方向信息  
  171.                 int dir = val <= split->ord.c ? -1 : 1;  
  172.                 if( split->inversed )    //方向需要反转的处理  
  173.                     dir = -dir;  
  174.                 //由方向信息确定下一步是向左分支遍历还是向右分支遍历  
  175.                 node = dir < 0 ? node->left : node->right;  
  176.             }  
  177.             //累加各个弱分类器响应值，即式12或式17括号内的部分  
  178.             sum += node->value;   
  179.         }  
  180.     }  
  181.     else    //其他情况的处理  
  182.     {  
  183.         const int* avars = active_vars->data.i;    //指向active_vars变量  
  184.         //如果有缺失的特征属性，则m指向掩码变量missing，否则m为空  
  185.         const uchar* m = !missing.empty() ? missing.ptr() : 0;  
  186.   
  187.         // full-featured version  
  188.         //遍历所有的弱分类器  
  189.         for( i = 0; i < weak_count; i++ )  
  190.         {  
  191.             CvBoostTree* wtree;    //弱分类器，即决策树  
  192.             const CvDTreeNode* node;  
  193.             CV_READ_SEQ_ELEM( wtree, reader );    //提取当前决策树  
  194.   
  195.             node = wtree->get_root();    //根节点  
  196.             //遍历该决策树，直到到达了叶节点  
  197.             while( node->left )  
  198.             {  
  199.                 const CvDTreeSplit* split = node->split;    //得到该节点的分叉  
  200.                 int dir = 0;  
  201.                 //按照从最佳分叉属性到替代分叉属性的顺序遍历分叉属性，直到得到了节点的方向信息为止，  
  202.                 for( ; !dir && split != 0; split = split->next )  
  203.                 {  
  204.                     //得到该节点分叉属性在样本中特征属性排序的索引  
  205.                     int vi = split->condensed_idx;  
  206.                     int ci = vtype[avars[vi]];    //得到分叉属性的特征属性类型  
  207.                     float val = sample_data[vi];    //得到该特征属性所对应的样本值  
  208.                     //如果该特征属性是缺失的特征属性，则进入下次循环  
  209.                     if( m && m[vi] )  
  210.                         continue;  
  211.                     if( ci < 0 ) // ordered 特征属性是数值的形式  
  212.                         //与分叉值比较，确定方向信息  
  213.                         dir = val <= split->ord.c ? -1 : 1;  
  214.                     else // categorical 特征属性是类的形式  
  215.                     {  
  216.                         int c = cvRound(val);    //取整  
  217.                         //对应找到split->subset中所对应的位，从而得到方向信息  
  218.                         dir = CV_DTREE_CAT_DIR(c, split->subset);  
  219.                     }  
  220.                     if( split->inversed )    //方向需要反转的处理  
  221.                         dir = -dir;  
  222.                 }  
  223.   
  224.                 if( !dir )    //如果方向信息还是没有得到  
  225.                 {  
  226.                     //该节点的哪个分支的样本数量多，方向dir就指向哪  
  227.                     int diff = node->right->sample_count - node->left->sample_count;  
  228.                     dir = diff < 0 ? -1 : 1;  
  229.                 }  
  230.                 //由方向信息确定下一步是向左分支遍历还是向右分支遍历  
  231.                 node = dir < 0 ? node->left : node->right;  
  232.             }  
  233.             //如果定义了输入参数weak_responses，则输出弱分类器的值  
  234.             if( weak_responses )  
  235.                 weak_responses->data.fl[i*wstep] = (float)node->value;  
  236.             //累加各个弱分类器响应值，即式12或式17括号内的部分  
  237.             sum += node->value;  
  238.         }  
  239.     }  
  240.   
  241.     if( return_sum )  
  242.         value = (float)sum;    //直接返回式12或式17中括号内的值  
  243.     else  
  244.     {  
  245.         int cls_idx = sum >= 0;    //符号判断，即式12或式17的值  
  246.         if( raw_mode )  
  247.             value = (float)cls_idx;    //得到原始的数据  
  248.         else    //得到其所代表的数据  
  249.             value = (float)cmap[cofs[vtype[data->var_count]] + cls_idx];  
  250.     }  
  251.   
  252.     return value;    //返回  
  253. }  
float
CvBoost::predict( const CvMat* _sample, const CvMat* _missing,
                  CvMat* weak_responses, CvSlice slice,
                  bool raw_mode, bool return_sum ) const
//_sample表示要预测的样本数据
//_missing表示预测样本中所缺失的特征属性，该变量为掩码的形式
// weak_responses表示弱分类器所对应的响应，因此它的元素个数必须与弱分类器的数量一致，默认值0，表示不使用该变量
//slice表示用于预测的弱分类器的连续子集，默认值为CV_WHOLE_SEQ，表示使用所有的弱分类器
// raw_mode与CvDTree::predict函数的第三个参数的含义相同，默认为false，具体请看上一篇文章
// return_sum表示该函数返回值的形式，默认为false，表示返回式12或式17的值，如果该值为true，则返回式12或式17中括号内的值，即不进行符号判断
{
    float value = -FLT_MAX;    //初始一个很大的负值

    CvSeqReader reader;
    double sum = 0;
    int wstep = 0;
    const float* sample_data;

    if( !weak )    //还没有强分类器
        CV_Error( CV_StsError, "The boosted tree ensemble has not been trained yet" );
    //判断输入参数_sample的正确性
    if( !CV_IS_MAT(_sample) || CV_MAT_TYPE(_sample->type) != CV_32FC1 ||
        (_sample->cols != 1 && _sample->rows != 1) ||
        (_sample->cols + _sample->rows - 1 != data->var_all && !raw_mode) ||
        (active_vars && _sample->cols + _sample->rows - 1 != active_vars->cols && raw_mode) )
            CV_Error( CV_StsBadArg,
        "the input sample must be 1d floating-point vector with the same "
        "number of elements as the total number of variables or "
        "as the number of variables used for training" );

    if( _missing )    //判断输入参数_missing的正确性
    {
        if( !CV_IS_MAT(_missing) || !CV_IS_MASK_ARR(_missing) ||
            !CV_ARE_SIZES_EQ(_missing, _sample) )
            CV_Error( CV_StsBadArg,
            "the missing data mask must be 8-bit vector of the same size as input sample" );
    }
    // weak_count为根据输入参数slice而得到的弱分类器的数量
    int i, weak_count = cvSliceLength( slice, weak );
    //确保weak_count正确
    if( weak_count >= weak->total )
    {
        weak_count = weak->total;
        slice.start_index = 0;
    }

    if( weak_responses )    //确保输入参数weak_responses的正确性
    {
        if( !CV_IS_MAT(weak_responses) ||
            CV_MAT_TYPE(weak_responses->type) != CV_32FC1 ||
            (weak_responses->cols != 1 && weak_responses->rows != 1) ||
            weak_responses->cols + weak_responses->rows - 1 != weak_count )
            CV_Error( CV_StsBadArg,
            "The output matrix of weak classifier responses must be valid "
            "floating-point vector of the same number of components as the length of input slice" );
        wstep = CV_IS_MAT_CONT(weak_responses->type) ? 1 : weak_responses->step/sizeof(float);
    }
    //得到active_vars变量的行，即启作用的特征属性的数量
    int var_count = active_vars->cols;
    const int* vtype = data->var_type->data.i;    //指向全体特征属性
    const int* cmap = data->cat_map->data.i;    //指向特征属性为类形式的映射
    const int* cofs = data->cat_ofs->data.i;    //表示特征属性为类形式的各个属性的偏移量

    cv::Mat sample = _sample;    //预测样本
    cv::Mat missing;    //缺失特征属性的掩码
    if(!_missing)
        missing = _missing;    //赋值

    // if need, preprocess the input vector
    //对预测样本的特征属性做规范化处理，具体内容请看我的上一篇关于决策树的文章
    if( !raw_mode )
    {
        int sstep, mstep = 0;
        const float* src_sample;
        const uchar* src_mask = 0;
        float* dst_sample;
        uchar* dst_mask;
        const int* vidx = active_vars->data.i;
        const int* vidx_abs = active_vars_abs->data.i;
        bool have_mask = _missing != 0;

        sample = cv::Mat(1, var_count, CV_32FC1);
        missing = cv::Mat(1, var_count, CV_8UC1);

        dst_sample = sample.ptr();
        dst_mask = missing.ptr();

        src_sample = _sample->data.fl;
        sstep = CV_IS_MAT_CONT(_sample->type) ? 1 : _sample->step/sizeof(src_sample[0]);

        if( _missing )
        {
            src_mask = _missing->data.ptr;
            mstep = CV_IS_MAT_CONT(_missing->type) ? 1 : _missing->step;
        }

        for( i = 0; i < var_count; i++ )
        {
            int idx = vidx[i], idx_abs = vidx_abs[i];
            float val = src_sample[idx_abs*sstep];
            int ci = vtype[idx];
            uchar m = src_mask ? src_mask[idx_abs*mstep] : (uchar)0;

            if( ci >= 0 )
            {
                int a = cofs[ci], b = (ci+1 >= data->cat_ofs->cols) ? data->cat_map->cols : cofs[ci+1],
                    c = a;
                int ival = cvRound(val);
                if ( (ival != val) && (!m) )
                    CV_Error( CV_StsBadArg,
                        "one of input categorical variable is not an integer" );

                while( a < b )
                {
                    c = (a + b) >> 1;
                    if( ival < cmap[c] )
                        b = c;
                    else if( ival > cmap[c] )
                        a = c+1;
                    else
                        break;
                }

                if( c < 0 || ival != cmap[c] )
                {
                    m = 1;
                    have_mask = true;
                }
                else
                {
                    val = (float)(c - cofs[ci]);
                }
            }

            dst_sample[i] = val;
            dst_mask[i] = m;
        }

        if( !have_mask )
            missing.release();
    }
    else
    {
        if( !CV_IS_MAT_CONT(_sample->type & (_missing ? _missing->type : -1)) )
            CV_Error( CV_StsBadArg, "In raw mode the input vectors must be continuous" );
    }

    cvStartReadSeq( weak, &reader );    //读取各个弱分类器
    cvSetSeqReaderPos( &reader, slice.start_index );    //指定起始地址

    sample_data = sample.ptr();    //预测样本数据的指针
    // !have_active_cat_vars表示启作用的特征属性中没有任何一个是类的形式，missing.empty()预测样本没有缺失的特征属性，!weak_responses表示该输入参数不存在
    if( !have_active_cat_vars && missing.empty() && !weak_responses )
    {
        //遍历所有的弱分类器
        for( i = 0; i < weak_count; i++ )
        {
            CvBoostTree* wtree;    //表示代表该弱分类器的决策树
            const CvDTreeNode* node;
            CV_READ_SEQ_ELEM( wtree, reader );    //提取当前的决策树

            node = wtree->get_root();    //得到决策树的根节点
            //遍历该决策树，直到到达了叶节点
            while( node->left )
            {
                CvDTreeSplit* split = node->split;   //节点分叉
                //得到该节点分叉属性在样本中特征属性排序的索引
                int vi = split->condensed_idx;
                float val = sample_data[vi];    //得到该特征属性所对应的样本值
                //与分叉值比较，确定方向信息
                int dir = val <= split->ord.c ? -1 : 1;
                if( split->inversed )    //方向需要反转的处理
                    dir = -dir;
                //由方向信息确定下一步是向左分支遍历还是向右分支遍历
                node = dir < 0 ? node->left : node->right;
            }
            //累加各个弱分类器响应值，即式12或式17括号内的部分
            sum += node->value; 
        }
    }
    else    //其他情况的处理
    {
        const int* avars = active_vars->data.i;    //指向active_vars变量
        //如果有缺失的特征属性，则m指向掩码变量missing，否则m为空
        const uchar* m = !missing.empty() ? missing.ptr() : 0;

        // full-featured version
        //遍历所有的弱分类器
        for( i = 0; i < weak_count; i++ )
        {
            CvBoostTree* wtree;    //弱分类器，即决策树
            const CvDTreeNode* node;
            CV_READ_SEQ_ELEM( wtree, reader );    //提取当前决策树

            node = wtree->get_root();    //根节点
            //遍历该决策树，直到到达了叶节点
            while( node->left )
            {
                const CvDTreeSplit* split = node->split;    //得到该节点的分叉
                int dir = 0;
                //按照从最佳分叉属性到替代分叉属性的顺序遍历分叉属性，直到得到了节点的方向信息为止，
                for( ; !dir && split != 0; split = split->next )
                {
                    //得到该节点分叉属性在样本中特征属性排序的索引
                    int vi = split->condensed_idx;
                    int ci = vtype[avars[vi]];    //得到分叉属性的特征属性类型
                    float val = sample_data[vi];    //得到该特征属性所对应的样本值
                    //如果该特征属性是缺失的特征属性，则进入下次循环
                    if( m && m[vi] )
                        continue;
                    if( ci < 0 ) // ordered 特征属性是数值的形式
                        //与分叉值比较，确定方向信息
                        dir = val <= split->ord.c ? -1 : 1;
                    else // categorical 特征属性是类的形式
                    {
                        int c = cvRound(val);    //取整
                        //对应找到split->subset中所对应的位，从而得到方向信息
                        dir = CV_DTREE_CAT_DIR(c, split->subset);
                    }
                    if( split->inversed )    //方向需要反转的处理
                        dir = -dir;
                }

                if( !dir )    //如果方向信息还是没有得到
                {
                    //该节点的哪个分支的样本数量多，方向dir就指向哪
                    int diff = node->right->sample_count - node->left->sample_count;
                    dir = diff < 0 ? -1 : 1;
                }
                //由方向信息确定下一步是向左分支遍历还是向右分支遍历
                node = dir < 0 ? node->left : node->right;
            }
            //如果定义了输入参数weak_responses，则输出弱分类器的值
            if( weak_responses )
                weak_responses->data.fl[i*wstep] = (float)node->value;
            //累加各个弱分类器响应值，即式12或式17括号内的部分
            sum += node->value;
        }
    }

    if( return_sum )
        value = (float)sum;    //直接返回式12或式17中括号内的值
    else
    {
        int cls_idx = sum >= 0;    //符号判断，即式12或式17的值
        if( raw_mode )
            value = (float)cls_idx;    //得到原始的数据
        else    //得到其所代表的数据
            value = (float)cmap[cofs[vtype[data->var_count]] + cls_idx];
    }

    return value;    //返回
}

OpenCV是用决策树来得到弱分类器的，因此实现弱分类器的类CvBoostTree继承于构建决策树的类CvDTree，前面介绍过的CvBoostTree类内的train函数和try_split_node函数都是虚函数，它们是针对用于弱分类器设计的决策树的特殊性而重写的函数，这样的虚函数还有许多，如find_surrogate_split_ord、find_split_ord_class、calc_node_value等。对这些函数就不再详细阐述，这里主要把与CvDTree类的不同的地方说明一下，关于CvDTree类的介绍请看我的上一篇关于决策树的介绍。

1、构建弱分类器的每个样本都有权值，即wi(m)，在决策树中被称为是先验概率；

2、用于衡量分类树纯度的不仅有基尼指数，还有错误分类率这种方法；

3、弱分类器只是一个用于研究两类问题的决策树，所有要相对简单一点；

4、不同的弱分类器所应用的训练样本的数量可能会不同。

 

三、应用实例

下面我们就给出一个具体的应用实例。

如上图所示，红色“+”的采样点的坐标为：(40,55)，(35,35)，(55,15)，(45,25)，(10,10)，(15,15)，(40,10)，(30,15)，(30,50)，(100,20)，(45,65)，(20,35)，(80,20)，(90,5)，(95,35)，(80,65)，(15,55)，(25,65)，(85,35)，(85,55)，(95,70)，(105,50)，(115,65)，(110,25)，(120,45)，(15,45)；蓝色“×”的采样点的坐标为：(55,30)，(60,65)，(95,60)，(25,40)，(75,45)，(105,35)，(65,10)，(50,50)，(40,35)，(70,55)，(80,30)，(95,45)，(60,20)，(70,30)，(65,45)，(85,40)。则我们用AdaBoost算法判断新的坐标(55,25)是属于红色标注的区域还是蓝色标注的区域，程序为：
[cpp] view plain copy print ?
  1. #include "opencv2/core/core.hpp"  
  2. #include "opencv2/highgui/highgui.hpp"  
  3. #include "opencv2/imgproc/imgproc.hpp"  
  4. #include "opencv2/ml/ml.hpp"  
  5.   
  6. #include   
  7. using namespace cv;  
  8. using namespace std;  
  9.   
  10. int main( int argc, char** argv )  
  11. {     
  12.     //训练样本  
  13.     float trainingData[42][2]={ {40, 55},{35, 35},{55, 15},{45, 25},{10, 10},{15, 15},{40, 10},  
  14.                             {30, 15},{30, 50},{100, 20},{45, 65},{20, 35},{80, 20},{90, 5},  
  15.                             {95, 35},{80, 65},{15, 55},{25, 65},{85, 35},{85, 55},{95, 70},  
  16.                             {105, 50},{115, 65},{110, 25},{120, 45},{15, 45},  
  17.                             {55, 30},{60, 65},{95, 60},{25, 40},{75, 45},{105, 35},{65, 10},  
  18.                             {50, 50},{40, 35},{70, 55},{80, 30},{95, 45},{60, 20},{70, 30},  
  19.                             {65, 45},{85, 40}   };  
  20.     Mat trainingDataMat(42, 2, CV_32FC1, trainingData);   
  21.     //训练样本的响应值  
  22.     float responses[42] = {'R','R','R','R','R','R','R','R','R','R','R','R','R','R','R','R',  
  23.                             'R','R','R','R','R','R','R','R','R','R',  
  24.                         'B','B','B','B','B','B','B','B','B','B','B','B','B','B','B','B' };  
  25.     Mat responsesMat(42, 1, CV_32FC1, responses);  
  26.   
  27.     float priors[2] = {1, 1};    //先验概率  
  28.   
  29.     CvBoostParams params( CvBoost::REAL, // boost_type    
  30.                           10, // weak_count    
  31.                           0.95, // weight_trim_rate    
  32.                           15, // max_depth    
  33.                           false, // use_surrogates    
  34.                           priors // priors   
  35.                           );    
  36.   
  37.     CvBoost boost;  
  38.     boost.train (   trainingDataMat,   
  39.                     CV_ROW_SAMPLE,   
  40.                     responsesMat,  
  41.                     Mat(),    
  42.                     Mat(),  
  43.                     Mat(),  
  44.                     Mat(),    
  45.                     params  
  46.                     );    
  47.     //预测样本  
  48.     float myData[2] = {55, 25};  
  49.     Mat myDataMat(2, 1, CV_32FC1, myData);  
  50.     double r = boost.predict( myDataMat );  
  51.   
  52.     cout<"result:  "<<(char)r<
  53.   
  54.     return 0;  
  55.  }  
#include "opencv2/core/core.hpp"
#include "opencv2/highgui/highgui.hpp"
#include "opencv2/imgproc/imgproc.hpp"
#include "opencv2/ml/ml.hpp"

#include 
using namespace cv;
using namespace std;

int main( int argc, char** argv )
{	
	//训练样本
	float trainingData[42][2]={	{40, 55},{35, 35},{55, 15},{45, 25},{10, 10},{15, 15},{40, 10},
							{30, 15},{30, 50},{100, 20},{45, 65},{20, 35},{80, 20},{90, 5},
							{95, 35},{80, 65},{15, 55},{25, 65},{85, 35},{85, 55},{95, 70},
							{105, 50},{115, 65},{110, 25},{120, 45},{15, 45},
							{55, 30},{60, 65},{95, 60},{25, 40},{75, 45},{105, 35},{65, 10},
							{50, 50},{40, 35},{70, 55},{80, 30},{95, 45},{60, 20},{70, 30},
							{65, 45},{85, 40}	};
	Mat trainingDataMat(42, 2, CV_32FC1, trainingData); 
	//训练样本的响应值
	float responses[42] = {'R','R','R','R','R','R','R','R','R','R','R','R','R','R','R','R',
							'R','R','R','R','R','R','R','R','R','R',
						'B','B','B','B','B','B','B','B','B','B','B','B','B','B','B','B'	};
	Mat responsesMat(42, 1, CV_32FC1, responses);

	float priors[2] = {1, 1};    //先验概率

	CvBoostParams params( CvBoost::REAL, // boost_type  
                          10, // weak_count  
                          0.95, // weight_trim_rate  
                          15, // max_depth  
                          false, // use_surrogates  
                          priors // priors 
                          );  

	CvBoost boost;
	boost.train (	trainingDataMat, 
					CV_ROW_SAMPLE, 
					responsesMat,
					Mat(),  
					Mat(),
					Mat(),
					Mat(),  
					params
				    );  
	//预测样本
	float myData[2] = {55, 25};
	Mat myDataMat(2, 1, CV_32FC1, myData);
	double r = boost.predict( myDataMat );

	cout<

输出的结果为：

result:  R

你可能感兴趣的:(图像识别算法)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • 基于社交网络算法优化的二维最大熵图像分割 智能算法研学社（Jack旭） 智能优化算法应用图像分割算法php开发语言
    智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
  • 121. 买卖股票的最佳时机 薄荷糖的味道_fb40
    给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
  • 每日算法&面试题，大厂特训二十八天——第二十天（树） 肥学 ⚡算法题⚡面试题每日精进java算法数据结构
    目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
  • 回溯算法-重新安排行程 chirou_ 算法数据结构图论c++图搜索
    leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
  • Faiss：高效相似性搜索与聚类的利器 网络·魚 大数据faiss
    Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
  • insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insertintoselect主键自增mybatisdelete返回值mybatisinsert返回主键mybatisinsert返回对象mybatisplusinsert返回主键mybatisplus插入生成id
    前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
  • k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
    ?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • 推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
    importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
  • K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习K近邻
    importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
  • 数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列C语言
    文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
  • [Python] 数据结构 详解及代码 AIAdvocate 算法python数据结构链表
    今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
  • Python算法L5：贪心算法 小熊同学哦 Python算法算法python贪心算法
    Python贪心算法简介目录Python贪心算法简介贪心算法的基本步骤贪心算法的适用场景经典贪心算法问题1.**零钱兑换问题**2.**区间调度问题**3.**背包问题**贪心算法的优缺点优点：缺点：结语贪心算法（GreedyAlgorithm）是一种在每一步选择中都采取当前最优或最优解的算法。它的核心思想是，在保证每一步局部最优的情况下，希望通过贪心选择达到全局最优解。虽然贪心算法并不总能得到全
  • 【RabbitMQ 项目】服务端：数据管理模块之绑定管理 月夜星辉雪 rabbitmq分布式
    文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
  • 非对称加密算法原理与应用2——RSA私钥加密文件 私语茶馆 云部署与开发架构及产品灵感记录RSA2048私钥加密
    作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
  • 粒子群优化 (PSO) 在三维正弦波函数中的应用 subject625Ruben 机器学习人工智能matlab算法
    在这篇博客中，我们将展示如何使用粒子群优化（PSO）算法求解三维正弦波函数，并通过增加正弦波扰动，使优化过程更加复杂和有趣。本文将介绍目标函数的定义、PSO参数设置以及算法执行的详细过程，并展示搜索空间中的动态过程和收敛曲线。1.目标函数定义我们使用的目标函数是一个三维正弦波函数，定义如下：objectiveFunc=@(x)sin(sqrt(x(1).^2+x(2).^2))+0.5*sin(5
  • 非对称加密算法————RSA理论及详情 hu19930613
    转自：https://www.kancloud.cn/kancloud/rsa_algorithm/48484一、一点历史1976年以前，所有的加密方法都是同一种模式：（1）甲方选择某一种加密规则，对信息进行加密；（2）乙方使用同一种规则，对信息进行解密。由于加密和解密使用同样规则（简称"密钥"），这被称为"对称加密算法"（Symmetric-keyalgorithm）。这种加密模式有一个最大弱点
  • ai绘画工具midjourney怎么下载？附作品管理教程 设计师早上好
    Midjourney是一款功能强大的AI绘画工具，它使用机器学习技术和深度神经网络等算法，可以生成各种艺术风格的绘画作品。在创意设计、广告宣传等方面有着广泛的应用前景。那么，ai绘画工具midjourney怎么下载？本文将为您介绍Midjourney的下载以及作品的相关管理。一、Midjourney下载Midjourney的下载非常简单，只需打开Midjourney官网（点击“GetMidjour
  • 【加密算法基础——对称加密和非对称加密】 XWWW668899 网络安全服务器笔记
    对称加密与非对称加密对称加密和非对称加密是两种基本的加密方法，各自有不同的特点和用途。以下是详细比较：1.对称加密特点密钥:使用相同的密钥进行加密和解密。发送方和接收方必须共享这个密钥。速度:通常速度较快，适合处理大量数据。实现:算法相对简单，计算效率高。常见算法AES(高级加密标准)DES(数据加密标准)3DES(三重数据加密标准)RC4(流密码)应用场景文件加密磁盘加密传输大量数据时的加密2.
  • 【算法练习】IDEA集成leetcode插件实现快速刷 2401_84102892 2024年程序员学习算法intellij-idealeetcode
    ============点击右侧边leetcode->设置->配置地址、用户名、密码、存放目录、文件模板用户名要登录后在账号信息里看模板代码1.codefilename!velocityTool.camelC
  • 【加密算法基础——RSA 加密】 XWWW668899 网络服务器笔记python
    RSA加密RSA（Rivest-Shamir-Adleman）加密是非对称加密，一种广泛使用的公钥加密算法，主要用于安全数据传输。公钥用于加密，私钥用于解密。RSA加密算法的名称来源于其三位发明者的姓氏：R:RonRivestS:AdiShamirA:LeonardAdleman这三位计算机科学家在1977年共同提出了这一算法，并发表了相关论文。他们的工作为公钥加密的基础奠定了重要基础，使得安全通
  • 机器学习-聚类算法 不良人龍木木 机器学习机器学习算法聚类
    机器学习-聚类算法1.AHC2.K-means3.SC4.MCL仅个人笔记，感谢点赞关注！1.AHC2.K-means3.SC传统谱聚类：个人对谱聚类算法的理解以及改进4.MCL目前仅专注于NLP的技术学习和分享感谢大家的关注与支持！
  • 生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
    生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
  • 高性能javascript--算法和流程控制 海淀萌狗
    -for,while和do-while性能相当-避免使用for-in循环，==除非遍历一个属性量未知的对象==es5:for-in遍历的对象便不局限于数组，还可以遍历对象。原因：for-in每次迭代操作会同时搜索实例或者原型属性，for-in循环的每次迭代都会产生更多开销，因此要比其他循环类型慢，一般速度为其他类型循环的1/7。因此，除非明确需要迭代一个属性数量未知的对象，否则应避免使用for-i
  • 深度 Qlearning：在直播推荐系统中的应用 AGI通用人工智能之禅 程序员提升自我硅基计算碳基计算认知计算生物计算深度学习神经网络大数据AIGCAGILLMJavaPython架构设计Agent程序员实现财富自由
    深度Q-learning：在直播推荐系统中的应用关键词：深度Q-learning,强化学习,直播推荐系统,个性化推荐1.背景介绍1.1问题的由来随着互联网技术的飞速发展,直播平台如雨后春笋般涌现。面对海量的直播内容,用户很难快速找到自己感兴趣的内容。因此,个性化推荐系统在直播平台中扮演着越来越重要的角色。1.2研究现状目前,主流的个性化推荐算法包括协同过滤、基于内容的推荐等。这些方法在一定程度上缓
  • JVM源码分析之堆外内存完全解读 HeapDump性能社区
    概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
  • 《算法》四学习——1.1节 进阶的Farmer 算法算法笔记
    前言买了一本算法4，每天看一点，对每个小结来个学习总结，输出驱动输入。本篇笔记针对第一章基础1.1基础编程模型1.1节总结了相关的语法、语言特性和书中将会用到的库。笔记自己在编码中容易遗漏的点&&优先级比||高在开发中习惯了加括号，所以没注意到这点，教材上也有但是忘记了二分查找中计算mid=left+(right-left)/2这样计算可以有效避免(left+right)/2溢出答疑java无穷大
  • 轻量级模型解读——轻量transformer系列 lishanlu136 #图像分类轻量级模型transformer图像分类
    先占坑，持续更新。。。文章目录1、DeiT2、ConViT3、Mobile-Former4、MobileViTTransformer是2017谷歌提出的一篇论文，最早应用于NLP领域的机器翻译工作，Transformer解读，但随着2020年DETR和ViT的出现(DETR解读，ViT解读)，其在视觉领域的应用也如雨后春笋般渐渐出现，其特有的全局注意力机制给图像识别领域带来了重要参考。但是tran
  • jsonp 常用util方法 hw1287789687 jsonpjsonp常用方法jsonp callback
    jsonp 常用java方法 (1)以jsonp的形式返回:函数名(json字符串) /*** * 用于jsonp调用 * @param map : 用于构造json数据 * @param callback : 回调的javascript方法名 * @param filters : <code>SimpleBeanPropertyFilter theFilt
  • 多线程场景 alafqq 多线程
    0 能不能简单描述一下你在java web开发中需要用到多线程编程的场景？0 对多线程有些了解，但是不太清楚具体的应用场景，能简单说一下你遇到的多线程编程的场景吗？ Java多线程 2012年11月23日 15:41 Young9007 Young9007 4 0 0 4 Comment添加评论关注(2) 3个答案 按时间排序 按投票排序 0 0 最典型的如： 1、
  • Maven学习——修改Maven的本地仓库路径 Kai_Ge maven
          安装Maven后我们会在用户目录下发现.m2 文件夹。默认情况下，该文件夹下放置了Maven本地仓库.m2/repository。所有的Maven构件(artifact)都被存储到该仓库中，以方便重用。但是windows用户的操作系统都安装在C盘，把Maven仓库放到C盘是很危险的，为此我们需要修改Maven的本地仓库路径。    
  • placeholder的浏览器兼容 120153216 placeholder
    【前言】 自从html5引入placeholder后，问题就来了， 不支持html5的浏览器也先有这样的效果， 各种兼容，之前考虑，今天测试人员逮住不放， 想了个解决办法，看样子还行，记录一下。   【原理】 不使用placeholder，而是模拟placeholder的效果， 大概就是用focus和focusout效果。   【代码】 <scrip
  • debian_用iso文件创建本地apt源 2002wmj Debian
    1.将N个debian-506-amd64-DVD-N.iso存放于本地或其他媒介内，本例是放在本机/iso/目录下 2.创建N个挂载点目录 如下： debian:~#mkdir –r /media/dvd1 debian:~#mkdir –r /media/dvd2 debian:~#mkdir –r /media/dvd3 …. debian:~#mkdir –r /media
  • SQLSERVER耗时最长的SQL 357029540 SQL Server
    对于DBA来说，经常要知道存储过程的某些信息： 1.   执行了多少次 2.   执行的执行计划如何 3.   执行的平均读写如何 4.   执行平均需要多少时间 列名          &
  • com/genuitec/eclipse/j2eedt/core/J2EEProjectUtil 7454103 eclipse
    今天eclipse突然报了com/genuitec/eclipse/j2eedt/core/J2EEProjectUtil 错误，并且工程文件打不开了，在网上找了一下资料，然后按照方法操作了一遍，好了，解决方法如下： 错误提示信息： An error has occurred.See error log for more details. Reason: com/genuitec/
  • 用正则删除文本中的html标签 adminjun javahtml正则表达式去掉html标签
    使用文本编辑器录入文章存入数据中的文本是HTML标签格式，由于业务需要对HTML标签进行去除只保留纯净的文本内容，于是乎Java实现自动过滤。 如下： public static String Html2Text(String inputString) { String htmlStr = inputString; // 含html标签的字符串 String textSt
  • 嵌入式系统设计中常用总线和接口 aijuans linux 基础
                   嵌入式系统设计中常用总线和接口         任何一个微处理器都要与一定数量的部件和外围设备连接，但如果将各部件和每一种外围设备都分别用一组线路与CPU直接连接，那么连线
  • Java函数调用方式——按值传递 ayaoxinchao java按值传递对象基础数据类型
    Java使用按值传递的函数调用方式，这往往使我感到迷惑。因为在基础数据类型和对象的传递上，我就会纠结于到底是按值传递，还是按引用传递。其实经过学习，Java在任何地方，都一直发挥着按值传递的本色。   首先，让我们看一看基础数据类型是如何按值传递的。   public static void main(String[] args) { int a = 2;
  • ios音量线性下降 bewithme ios音量
    直接上代码吧   //second 几秒内下降为0 - (void)reduceVolume:(int)second { KGVoicePlayer *player = [KGVoicePlayer defaultPlayer]; if (!_flag) { _tempVolume = player.volume;
  • 与其怨它不如爱它 bijian1013 选择理想职业规划
            抱怨工作是年轻人的常态，但爱工作才是积极的心态，与其怨它不如爱它。         一般来说，在公司干了一两年后，不少年轻人容易产生怨言，除了具体的埋怨公司“扭门”，埋怨上司无能以外，也有许多人是因为根本不爱自已的那份工作，工作完全成了谋生的手段，跟自已的性格、专业、爱好都相差甚远。  
  • 一边时间不够用一边浪费时间 bingyingao 工作时间浪费
    一方面感觉时间严重不够用，另一方面又在不停的浪费时间。 每一个周末，晚上熬夜看电影到凌晨一点，早上起不来一直睡到10点钟，10点钟起床，吃饭后玩手机到下午一点。 精神还是很差，下午像一直野鬼在城市里晃荡。 为何不尝试晚上10点钟就睡，早上7点就起，时间完全是一样的，把看电影的时间换到早上，精神好，气色好，一天好状态。 控制让自己周末早睡早起，你就成功了一半。 有多少个工作
  • 【Scala八】Scala核心二：隐式转换 bit1129 scala
    Implicits work like this: if you call a method on a Scala object, and the Scala compiler does not see a definition for that method in the class definition for that object, the compiler will try to con
  • sudoku slover in Haskell (2) bookjovi haskellsudoku
    继续精简haskell版的sudoku程序，稍微改了一下，这次用了8行，同时性能也提高了很多，对每个空格的所有解不是通过尝试算出来的，而是直接得出。   board = [0,3,4,1,7,0,5,0,0, 0,6,0,0,0,8,3,0,1, 7,0,0,3,0,0,0,0,6, 5,0,0,6,4,0,8,0,7,
  • Java-Collections Framework学习与总结-HashSet和LinkedHashSet BrokenDreams linkedhashset
            本篇总结一下两个常用的集合类HashSet和LinkedHashSet。         它们都实现了相同接口java.util.Set。Set表示一种元素无序且不可重复的集合；之前总结过的java.util.List表示一种元素可重复且有序
  • 读《研磨设计模式》-代码笔记-备忘录模式-Memento bylijinnan java设计模式
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ import java.util.ArrayList; import java.util.List; /* * 备忘录模式的功能是，在不破坏封装性的前提下，捕获一个对象的内部状态，并在对象之外保存这个状态，为以后的状态恢复作“备忘”
  • 《RAW格式照片处理专业技法》笔记 cherishLC PS
    注意，这不是教程！仅记录楼主之前不太了解的 一、色彩（空间）管理 作者建议采用ProRGB（色域最广），但camera raw中设为ProRGB，而PS中则在ProRGB的基础上，将gamma值设为了1.8（更符合人眼） 注意：bridge、camera raw怎么设置显示、输出的颜色都是正确的（会读取文件内的颜色配置文件），但用PS输出jpg文件时，必须先用Edit->conv
  • 使用 Git 下载 Spring 源码 编译 for Eclipse crabdave eclipse
    使用 Git 下载 Spring 源码 编译 for Eclipse   1、安装gradle，下载 http://www.gradle.org/downloads 配置环境变量GRADLE_HOME，配置PATH  %GRADLE_HOME%/bin，cmd，gradle -v   2、spring4 用jdk8 下载 https://jdk8.java.
  • mysql连接拒绝问题 daizj mysql登录权限
    mysql中在其它机器连接mysql服务器时报错问题汇总 一、[running][email protected]:~$mysql -uroot -h 192.168.9.108 -p   //带-p参数，在下一步进行密码输入 Enter password:    //无字符串输入 ERROR 1045 (28000): Access
  • Google Chrome 为何打压 H.264 dsjt applehtml5chromeGoogle
    Google 今天在 Chromium 官方博客宣布由于 H.264 编解码器并非开放标准，Chrome 将在几个月后正式停止对 H.264 视频解码的支持，全面采用开放的 WebM 和 Theora 格式。 Google 在博客上表示，自从 WebM 视频编解码器推出以后，在性能、厂商支持以及独立性方面已经取得了很大的进步，为了与 Chromium 现有支持的編解码器保持一致，Chrome
  • yii 获取控制器名 和方法名 dcj3sjt126com yiiframework
    1. 获取控制器名 在控制器中获取控制器名:  $name = $this->getId(); 在视图中获取控制器名:    $name = Yii::app()->controller->id;    2. 获取动作名  在控制器beforeAction()回调函数中获取动作名:  $name =
  • Android知识总结（二） come_for_dream android
    明天要考试了，速速总结如下   1、Activity的启动模式        standard：每次调用Activity的时候都创建一个（可以有多个相同的实例，也允许多个相同Activity叠加。）        singleTop：可以有多个实例，但是不允许多个相同Activity叠加。即，如果Ac
  • 高洛峰收徒第二期：寻找未来的“技术大牛” ——折腾一年，奖励20万元 gcq511120594 工作项目管理
    高洛峰，兄弟连IT教育合伙人、猿代码创始人、PHP培训第一人、《细说PHP》作者、软件开发工程师、《IT峰播》主创人、PHP讲师的鼻祖！ 首期现在的进程刚刚过半，徒弟们真的很棒，人品都没的说，团结互助，学习刻苦，工作认真积极，灵活上进。我几乎会把他们全部留下来，现在已有一多半安排了实际的工作，并取得了很好的成绩。等他们出徒之日，凭他们的能力一定能够拿到高薪，而且我还承诺过一个徒弟，当他拿到大学毕
  • linux expect heipark expect
    1. 创建、编辑文件go.sh   #!/usr/bin/expect spawn sudo su admin expect "*password*" { send "13456\r\n" } interact    2. 设置权限   chmod u+x go.sh  3.
  • Spring4.1新特性——静态资源处理增强 jinnianshilongnian spring 4.1
    目录 Spring4.1新特性——综述 Spring4.1新特性——Spring核心部分及其他 Spring4.1新特性——Spring缓存框架增强 Spring4.1新特性——异步调用和事件机制的异常处理 Spring4.1新特性——数据库集成测试脚本初始化 Spring4.1新特性——Spring MVC增强 Spring4.1新特性——页面自动化测试框架Spring MVC T
  • idea ubuntuxia 乱码 liyonghui160com
      1.首先需要在windows字体目录下或者其它地方找到simsun.ttf 这个 字体文件。 2.在ubuntu 下可以执行下面操作安装该字体： sudo mkdir /usr/share/fonts/truetype/simsun sudo cp simsun.ttf /usr/share/fonts/truetype/simsun fc-cache -f -v
  • 改良程序的11技巧 pda158 技巧
    有很多理由都能说明为什么我们应该写出清晰、可读性好的程序。最重要的一点，程序你只写一次，但以后会无数次的阅读。当你第二天回头来看你的代码 时，你就要开始阅读它了。当你把代码拿给其他人看时，他必须阅读你的代码。因此，在编写时多花一点时间，你会在阅读它时节省大量的时间。   让我们看一些基本的编程技巧：   尽量保持方法简短 永远永远不要把同一个变量用于多个不同的
  • 300个涵盖IT各方面的免费资源（下）——工作与学习篇 shoothao 创业免费资源学习课程远程工作
    工作与生产效率:   A. 背景声音 Noisli:背景噪音与颜色生成器。 Noizio:环境声均衡器。 Defonic:世界上任何的声响都可混合成美丽的旋律。 Designers.mx:设计者为设计者所准备的播放列表。 Coffitivity:这里的声音就像咖啡馆里放的一样。 B. 避免注意力分散 Self Co
  • 深入浅出RPC uule rpc
    深入浅出RPC-浅出篇 深入浅出RPC-深入篇   RPC Remote Procedure Call Protocol 远程过程调用协议   它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。RPC协议假定某些传输协议的存在，如TCP或UDP，为通信程序之间携带信息数据。在OSI网络通信模型中，RPC跨越了传输层和应用层。RPC使得开发
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他