Viola-Jones人脸检测--AdaptBoost特征选择

矫情吗；* 2022-01-09 15:34 293阅读 0赞

Viola-Jones人脸检测算法的伟大之处不不仅仅在于其算法的实时效果，更重要的是其提出了解决目标检测这一类问题的一种通用思路。该算法有两个亮点，一个是积分图技术，一个是Cascade训练模型，一经提出便引起了极大关注，在很多优秀的论文中都能看到他们的身影。如TLD算法中Detector部分，以及BING objectness训练时的两层SVM模型等，很难说这没有受到Viola-Jones算法的影响。下面就来介绍构成Cascade模型的其中的一个基本元素AdaptBoost吧。

AdaptBoost并不是Viola-Jones的原创算法，它是机器学习领域的产物，属于Ensemble Learning中boosting的类别。Ensemble类的学习算法分为bagging和boosting两个类别，都是基于弱分类器构造强分类器的思想，其中bagging的代表算法是RandomForests，boosting的代表算法是AdaptBoost。这里推荐一篇论文，介绍AdaptBoost算法理论的，《A Brief Introduction to Boosting》。

本着分享交流的目的，下面的内容包括对AdaptBoost算法的理论介绍及给出用标准C++实现AdaptBoost的代码。对于不想依赖特定库的伙伴们来说，标准C++的这个版本是个不错的选择。如果有什么不正确的地方，请多多指教。

**1.AdaptBoost原理**

我们知道对于一个给定窗口大小的图像，其Harr特征的维度是很高的，如果用直接用对训练样本计算出的Harr特征来训练分类器这是不太可行的，我们需要对高维的Harr特征进行选择，选择部分来进行分类器的训练。而AdaptBoost恰好就符合这样的思想，其基本思想是由弱分类器构造强分类器，用弱分类器的联合分类结果作为强分类器的结果。AdaptBoost的弱分类器可以是一个stump，也就是树桩的意思，就是一个弱分类器是一个二分类树。在众多维的Harr特征中进行特征选择的方法是，要求选择一个特征，及选择一个该特征下用于二分类的阈值，如果在该特征和阈值下对训练样本的分类误差最小，就以该特征和其二分类阈值作为一个训练好的弱分类器，算法的具体实现可以参看实现部分的bestStump（）接口。在每一次为弱分类器选择特征完成后，对于用于训练的样本的分布（也就是各样本的权重，初始值一般是相等的，都是1/N，N为样本个数）进行更新，每次的更新是由上一次的弱分类器的分类结果确定的，对于上一次弱分类器判断错误的样本，其权重会增大，判断正确的样本其权重会减小。AdaptBoost与RandomForest的一个区别是，在计算强分类器的结果时，AdaptBoost的弱分类器的权重是不一样的，而RandomForest的弱分类器的权重是相等的。

AdaptBoost算法的伪代码描述如下：

[![wKioL1U7gcji6QY0AAD7nu0zyTE143.jpg][]][wKioL1U7gcji6QY0AAD7nu0zyTE143.jpg]

**2.标准C++实现**

下面的这个接口部分，包含train的接口不包含test的部分，你可以在这个基础上增加test的接口部分。

#ifndef _ADAPTBOOST_H_
    #define _ADAPTBOOST_H_
    #include <vector>
    #include <utility>
    #include <cmath>
    using namespace std;
    
    
    /**
     * @brief decision stump declaration
     *
     * @param featureIndex
     * @param weightedError achieved weighted error
     * @param threshold
     * @param margin achieved margin
     * @param toggle +1 or -1
     */
    struct StumpRule{
    	int featureIndex;
    	long double weightedError;
    	double threshold;
    	float margin;
    	int toggle;
    };
    
    
    /**
    　* @brief what's inside AdaptBoost
    　*
    　* @param nPositives number of positive examples
    　* @param nNegatives number of negative examples
    　* @param initialPositiveWeight how much weight we give to positives at the outset
    　* @param ascendingFeatures for each feature, we have (float feature value, int exampleIndex)
    　*
    　* @param sampleCount nPositives + nNegatives
    　* @param inTrain is this a training set or a validation set
    　* @param exponentialRisk exponential risk for training set
    　* @param positiveTotalWeight total weight received by positive examples currently 
    　* @param negativeTotalWeight total weight received by negative examples currently
    　* @param minWeight minimum weight among all weights currently
    　* @param maxWeight maximum weight among all weights currently
    　* @param weights weight vector for all examples involved
    　* @param labels are they positive or negative examples
    　* @param featureCount how many features are there
    　* @param committee what's the learned committee
    　*/
    class AdaptBoost{
    private:
    	
    	int nPositives;
    	int nNegatives;
    	long double initialPositiveWeight;
    	vector< vector<pair<float, int>> > ascendingFeatures;
    
    	int sampleCount;
    	int featureCount;
    	long double positiveTotalWeight;
    	long double negativeTotalWeight;
    	long double minWeight;
    	long double maxWeight;
    	long double exponentialRisk;
    	vector<double> weights;
    	vector<int> labels;
    	vector<StumpRule> committee;
    
    	/**
    	 * @brief prevent copy and assignment 
    	 */
    	AdaptBoost(const AdaptBoost&);
    	AdaptBoost operator=(const AdaptBoost&);
    
    protected:
    	/**
    	 * @brief return for an element pointed by iterator and featureIndex its exampleIndex
    	 */
    	int getTrainingExampleIndex(int featureIndex, int iterator);
    
    	/**
    	 * @brief return for an element pointed by iterator and featureIndex its example value
    	 */
    	float getTrainingExampleFeature(int featureIndex, int iterator);
    
    	/**
    	 * @brief sort each featrue from different samples
    	 */
    	void sortFeatures(
    		vector< vector<pair<float, int>> >& features
    	);
    
    	/**
    	 * @brief best stump given a feature
    	 */
    	void decisionStump(
    		int featureIndex
    	, 	StumpRule & best
    	);
    
    	/**
    	 * @brief best stump among all features
    	 */
    	StumpRule bestStump();
    
    public:
    	/**
    	 * @brief constructor
    	 * @param nPositives number of positives for training examples
    	 * @param nNegatives number of negatives for training examples
    	 * @param initialPositiveWeight initial weight of positives
    	 * @param data for training examples, positves front and negatives back
    	 */
    	AdaptBoost(
    		int nPositives
    	,	int nNegatives
    	,	long double initialPositiveWeight
    	,	const vector< vector<float> >& data
    	);
    
    	/**
    	 * @brief destructor
    	 */
    	~AdaptBoost();
    
    	/**
    	 * @brief perform one round of adaboost
    	 */
    	void oneRoundOfAdaboostTraining();
    
    	/**
    	 * @brief get committee adaptboost trained
    	 */
    	vector<StumpRule> getCommittee() {
    		return committee;
    	}
    
    	/**
    	 * @brief get committee size
    	 */
    	int getCommitteeSize() {
    		return committee.size();
    	}
    	
    	/**
    	 * @brief given the number of weak classifiers train for a committee
    	 * @param numOfWeakClassifier for number of weak classifiers of adapt boost
    	 */
    	void adaptBoostTraining(int numOfWeakClassifier);
    	
    	/**
    	 * @brief evaluate how the committee fares on a training dataset
    	 *
    	 * @param tweak for predictLableOfTrainingExamples
    	 * @return falsePositive
    	 * @return detectionRate
    	 * @vector<int> return a blackList,if element of balckList is 0, then it means that
    	 *  this sample could be used again otherwise it means not usable
    	 */
    	vector<int> calcEmpiricalErrorInAdaBoostTraining(
    		float tweak
    	,	float & falsePositive
    	,	float & detectionRate
    	);
    	
    	/**
    	 * @brief given a tweak and a committe, what prediction do you make as to the training examples
    	 *
    	 * @param thresholdTweak tweak
    	 * @return prediction
    	 * @param onlyMostRecent use all the committee or its most recent member (a weak learner)
    	 */
    	void predictLabelOfTrainingExamples(
    		float tweakThreshold
    	, 	vector<int> & prediction
    	, 	bool onlyMostRecent=false
    	);
    
    };
    
    
    #endif

#include <cassert>
    #include <algorithm>
    #include <iostream>
    #include <iomanip>
    #include "VJAdaptBoost.h"
    
    using namespace std;
    #define VERBOSE true
    
    //fail and messaging
    static void fail(const char* message){
    	cerr << "Error:" <<  message << endl;
    	exit(EXIT_FAILURE);
    }
    //order definition for this type of pairs
    //compare only the feature values
    static bool myPairOrder(
    	const pair<float, int>& one
    ,	const pair<float, int>& other
    ){
    	return one.first < other.first;
    }
    //why is one stump better than the other
    static bool myStumpOrder(
    	const StumpRule & one
    ,	const StumpRule & other
    ){
    	if(one.weightedError < other.weightedError)
    		return true;
    	if(one.weightedError == other.weightedError && one.margin > other.margin)
    		return true;
    	return false;
    }
    
    int AdaptBoost::getTrainingExampleIndex(int featureIndex, int iterator){
    	assert(ascendingFeatures.size() > 0 && ascendingFeatures[0].size() >0);
    			
    	return ascendingFeatures[featureIndex][iterator].second;
    }
    
    float AdaptBoost::getTrainingExampleFeature(int featureIndex, int iterator){
    	assert(ascendingFeatures.size() > 0 && ascendingFeatures[0].size() >0);
    
    	if(_isnan(ascendingFeatures[featureIndex][iterator].first)){
    		cerr<<"ERROR: nan feature "<<featureIndex<<" detected for example "<<getTrainingExampleIndex(featureIndex, iterator)<<endl;
    		exit(EXIT_FAILURE);
    	}
    	return ascendingFeatures[featureIndex][iterator].first;
    }
    
    //constructor
    AdaptBoost::AdaptBoost(
    	int positives
    ,	int negatives
    ,	long double positiveWeight
    ,	const vector< vector<float> >& data) {
    	assert(positives > 0 && negatives > 0);
    	assert(positiveWeight > 0 && positiveWeight < 1);
    	assert(data.size() > 0 && data[0].size() > 0 );
    	assert(data.size() == (positives + negatives));
    
    	//add number of data info to features
    	vector< vector<pair<float, int>> > features(data.size(), vector<pair<float, int>>(data[0].size(), pair<float, int>(0,0)));
    	for(int i=0; i<features.size(); i++) {
    		for(int j=0; j<features[0].size(); j++) {
    			features[i][j] = pair<float, int>(data[i][j], i);
    		}
    	}
    
    	//initialize the class attributes for the training set
    	nPositives = positives;
    	nNegatives = negatives;
    	initialPositiveWeight = positiveWeight;
    	sortFeatures(features);//initialize ascendingFeatures
    
    	sampleCount = positives + negatives;
    	featureCount = ascendingFeatures.size();
    	positiveTotalWeight = positiveWeight;
    	negativeTotalWeight = 1 - positiveWeight;
    	long double posAverageWeight = positiveTotalWeight/(long double)nPositives;
    	long double negAverageWeight = negativeTotalWeight/(long double)nNegatives;
    	maxWeight = max(posAverageWeight, negAverageWeight);
    	minWeight = min(posAverageWeight, negAverageWeight);
    	exponentialRisk = 1;
    
    	//set weights for each example
    	for(int exampleIndex = 0; exampleIndex < sampleCount; exampleIndex++){
    		weights.push_back(exampleIndex < nPositives ? posAverageWeight : negAverageWeight);
    		labels.push_back(exampleIndex < nPositives ? 1 : -1);
    	}
    
    }
    
    //destructor
    AdaptBoost::~AdaptBoost() {
    
    }
    
    //adaptBoost interface for training
    void AdaptBoost::adaptBoostTraining(int numOfWeakClassifier) {
    	assert(numOfWeakClassifier > 0);
    	for(int i=0; i<numOfWeakClassifier; i++) {
    		oneRoundOfAdaboostTraining();
    	}
    }
    
    //validation procedure using training examples
    vector<int> AdaptBoost::calcEmpiricalErrorInAdaBoostTraining(
    	float tweak
    ,	float & falsePositive
    ,	float & detectionRate
    ){
    	vector<int> blackList;
    	blackList.resize(nPositives, 0);
    	blackList.resize(nPositives+nNegatives, 1);
    
    	int nFalsePositive = 0;
    	int nFalseNegative = 0;
    	
    	//initially let all be positive
    	vector<int> prediction;
    	prediction.resize(sampleCount,0);
    	predictLabelOfTrainingExamples(tweak, prediction, false);
    
    	//evaluate prediction errors
    	vector<int> agree(sampleCount);
    	for(int i=0; i<sampleCount; i++) {
    		agree[i] = labels[i]*prediction[i];
    	}
    	for(int exampleIndex = 0; exampleIndex < sampleCount; exampleIndex++){
    		if(agree[exampleIndex] < 0)     {
    			if(exampleIndex < nPositives){
    				nFalseNegative += 1;
    				blackList[exampleIndex] = 1;
    			}else{
    				nFalsePositive += 1;
    				blackList[exampleIndex] = 0;
    			}
    		}
    	}
    
    	//set the returned values
    	falsePositive = nFalsePositive/(float)nNegatives;
    	detectionRate = 1 - nFalseNegative/(float)nPositives;
    
    	return blackList;
    }
    
    //given a tweak and a committe, what prediction does it make as to the training examples
    void AdaptBoost::predictLabelOfTrainingExamples(
    	float tweakThreshold
    ,	vector<int> & prediction
    ,	bool onlyMostRecent
    ){
    	int committeeSize = committee.size();
    	//no need to weigh a single member's decision
    	onlyMostRecent = committeeSize == 1 ? true : onlyMostRecent;
    	int start = onlyMostRecent ? committeeSize - 1 : 0;
    	//double to be more precise
    	vector<vector<double>> memberVerdict;
    	for(int i=0; i<committeeSize; i++) {//initialize memberVerdict
    		vector<double> row(sampleCount);
    		memberVerdict.push_back(row);
    	}
    	vector<double> memberWeight(committeeSize);
    	//members, go ahead
    	for(int member = start; member < committeeSize; member++){
    		//sanity check
    		if(committee[member].weightedError == 0 && member != 0)
    			fail("Boosting Error Occured!");
    		//0.5 does not count here
    		//if member's weightedError is zero, member weight is nan, but it won't be used anyway
    		memberWeight[member] = log(1./committee[member].weightedError -1);
    		int feature = committee[member].featureIndex;
    		#pragma omp parallel for schedule(static)
    		for(int iterator = 0; iterator < sampleCount; iterator++){
    			int exampleIndex = getTrainingExampleIndex(feature, iterator);
    			memberVerdict[member][exampleIndex] = (getTrainingExampleFeature(feature, iterator) >
    				committee[member].threshold ? 1 : -1)*committee[member].toggle + tweakThreshold;
    		}
    	}
    	//joint session
    	if(!onlyMostRecent){
    		vector<double> finalVerdict(sampleCount);
    		for(int i=0; i<sampleCount; i++) {
    			double predict = 0;
    			for(int j=0; j<committeeSize; j++) {
    				predict += (memberWeight[j] * memberVerdict[j][i]);
    			}
    			finalVerdict[i] = predict;
    		}
    		for(int exampleIndex = 0; exampleIndex < sampleCount; exampleIndex++)
    			prediction[exampleIndex] = finalVerdict[exampleIndex] > 0 ? 1 : -1;
    	}else{
    		for(int exampleIndex = 0; exampleIndex < sampleCount; exampleIndex++)
    			prediction[exampleIndex] = memberVerdict[start][exampleIndex] > 0 ? 1 : -1;
    	}
    }
    
    void AdaptBoost::oneRoundOfAdaboostTraining(){
    	//try to be friendly here
    	static int trainPhase = 0;
    	if(VERBOSE && trainPhase == 0){
    		cout << "\n#############################ADABOOST MESSAGE EXPLAINED####################################################\n\n";
    		cout << "INFO: Adaboost starts. Exponential Risk is expected to go down steadily and strictly," << endl;
    		cout << "INFO: and Exponential Risk should bound the (weighted) Empirical Error from above." << endl;
    		cout << "INFO: Train Phase is the current boosting iteration." << endl;
    		cout << "INFO: Best Feature is the most discriminative feature selected by decision stump at this iteration." << endl;
    		cout << "INFO: Threshold and Toggle are two parameters that define a real valued decision stump.\n" << endl;
    	}
    	trainPhase++;
    
    	//get and store the rule
    	StumpRule rule = bestStump();
    	committee.push_back(rule);
    
    	//how it fares
    	vector<int> prediction(sampleCount);
    	predictLabelOfTrainingExamples(
    		0
    	,	prediction
    	,	/*onlyMostRecent*/ true);
    	vector<bool> agree(sampleCount);
    	for(int i=0; i<sampleCount; i++) {
    		if(prediction[i] == labels[i]) {
    			agree[i] = true;
    		}else {
    			agree[i] = false;
    		}
    	}
    
    	//update weights
    	vector<double> weightUpdate;
    	weightUpdate.resize(sampleCount,1);
    	bool errorFlag = false;
    	for(int exampleIndex = 0; exampleIndex < sampleCount; exampleIndex++){
    		//more weight for a difficult example
    		if(!agree[exampleIndex]){
    			weightUpdate[exampleIndex] = 1/rule.weightedError - 1;
    			errorFlag = true;
    		}
    	}
    
    	//update weights only if there is an error
    	if(errorFlag){
    		double weightSum = 0;
    		for(int i=0; i<sampleCount; i++) {
    			weights[i] *= weightUpdate[i];
    			weightSum += weights[i];
    		}
    		for(int i=0; i<sampleCount; i++) {
    			weights[i] /= weightSum;
    		}
    
    		double posTotalWeight = 0;
    		for(int i=0; i<nPositives; i++) {
    			posTotalWeight += weights[i];
    		}
    		positiveTotalWeight = posTotalWeight;
    		negativeTotalWeight = 1-positiveTotalWeight;
    
    		double min,max;
    		min = max = weights[0];
    		for(int i=0; i<sampleCount; i++) {
    			if(weights[i] < min) {
    				min = weights[i];
    			}else if(weights[i] > max) {
    				max = weights[i];
    			}
    		}
    		minWeight = min;
    		maxWeight = max;
    	}
    
    	//exponentialRisk can be zero at the first boosting
    	exponentialRisk *= 2*sqrt((1-rule.weightedError)*rule.weightedError);
    
    	//print some statistics
    	if(VERBOSE){
    		float tweak = 0;
    		float falsePositive = 0;
    		float detectionRate = 0;
    		calcEmpiricalErrorInAdaBoostTraining(tweak, falsePositive, detectionRate);
    		float empError = static_cast<float>(falsePositive*(1-initialPositiveWeight)+initialPositiveWeight*(1-detectionRate));
    		cout << "Training Performance Explanation (before threshold tweaking): falsePositive " << falsePositive 
    			 << " detectionRate " << detectionRate << endl;
    		cout <<"###########################################################################################################\n";
    		cout << "\nTrain Phase " << trainPhase << endl << endl;
    //		whatFeature(rule.featureIndex);
    		cout << "\tExponential Risk " << setw(12) << exponentialRisk << setw(19) << "Weighted Error " 
    			 << setw(11) << rule.weightedError << setw(14) << "Threshold " << setw(10) << rule.threshold 
    			 << setw(13) <<"Toggle " << setw(12) << rule.toggle <<  endl;
    		cout << "\tPositive Weight" << setw(14) << positiveTotalWeight << setw(14) << "MinWeight " 
    			 << setw(16) << minWeight << setw(14) << "MaxWeight " << setw(10) << maxWeight << setw(22) 
    			 << "Empirical Error " << setw(10) << empError << endl << endl;
    	}
    }
    
    //get a feature from features and put them in ascending order
    //and record at the same time the permuted example order
    void AdaptBoost::sortFeatures(vector< vector<pair<float, int>> >& features) {
    	assert(features.size()!=0 && features[0].size() !=0 );
    
    	for(unsigned int i=0; i<features[0].size(); i++) {
    		vector<pair<float, int>> temp = vector<pair<float, int>>();
    		for(unsigned int j=0; j<features.size(); j++) {
    			temp.push_back(features[j][i]);
    		}
    		//sort
    		sort(temp.begin(), temp.end(), myPairOrder);
    		ascendingFeatures.push_back(temp);
    	}
    
    }
    
    
    //base learner is a stump, a decision tree of depth 1
    //decisionStump has to look at feature and return rule
    void AdaptBoost::decisionStump(
    	int featureIndex
    ,	StumpRule & best
    ){
    	//a stump is determined by threshold and toggle, the other two attributes measures its performance
    	//initialize with some crazy values
    	best.featureIndex = featureIndex;
    	best.weightedError = 2;
    	best.threshold = getTrainingExampleFeature(featureIndex, 0) - 1;
    	best.margin = -1;
    	best.toggle = 0;
    
    	StumpRule current = best;
    
    	//error_p and error_n allow to set the best toggle
    	long double error_p, error_n;
    
    	//initialize: r denotes right hand side and l left hand side
    	//convention: in TrainExamples nPositives positive samples are followed by negatives samples
    	long double rPositiveWeight = positiveTotalWeight;
    	long double rNegativeWeight = negativeTotalWeight;
    	//yes, nothing to the left of the sample with the smallest feature
    	long double lPositiveWeight = 0;
    	long double lNegativeWeight = 0;
    
    	//go through all these observations one after another
    	int iterator = -1;
    
    	//to build a decision stump, you need a toggle and an admissible threshold
    	//which doesn't coincide with any of the observations
    	while(true){
    
    		//We've got a threshold. So determine the best toggle based on two types of error
    		//toggle = 1, positive prediction if and only if the observed feature > the threshold
    		//toggle = -1, positive prediction if and only if the observed feature < the threshold
    
    		//error_p denotes the error introduced by toggle = 1, error_n the error by toggle = -1
    		error_p = rNegativeWeight + lPositiveWeight;
    		error_n = rPositiveWeight + lNegativeWeight;
    		current.toggle = error_p < error_n ? 1 : -1;
    
    		//sometimes shit happens, prevent error from being negative
    		long double smallerError = min(error_p, error_n);
    		//this prevents some spurious nonzero: for currentError must be at least equal to minWeight
    		current.weightedError = smallerError < minWeight * 0.9 ? 0 : smallerError;
    
    		//update if necessary
    		if(myStumpOrder(current, best))
    			best = current;
    
    		//move on
    		iterator++;
    
    		//we don't actually need to look at the sample with the largest feature
    		//because its rule is exactly equivalent to those produced
    		//by the sample with the smallest feature on training observations
    		//but it won't do any harm anyway
    		if(iterator == sampleCount)
    			break;
    
    		//handle duplicates, update lr weights and find a new threshold
    		while(true){
    
    			//take this guy's attributes
    			int exampleIndex = getTrainingExampleIndex(featureIndex, iterator);
    			int label = labels[exampleIndex];
    			long double weight = weights[exampleIndex];
    
    			//update weights
    			if(label < 0){
    				lNegativeWeight += weight;
    				rNegativeWeight -= weight;
    			}else{
    				lPositiveWeight += weight;
    				rPositiveWeight -= weight;
    			}
    
    			//if a new threshold can be found, break
    			//two cases are possible: either it is the last observation
    			if(iterator == sampleCount - 1)
    				break;
    			//or no duplicate. If there is a duplicate, repeat
    			if(getTrainingExampleFeature(featureIndex, iterator) != getTrainingExampleFeature(featureIndex, iterator + 1)){
    				double test = ((double)getTrainingExampleFeature(featureIndex, iterator) 
    					+ (double)getTrainingExampleFeature(featureIndex, iterator + 1))/2;
    				//well that's a bit frustrating: I want to keep float because of memory constraint, but apparently
    				//features are so close, sometimes, numerical precision arises as an unexpected problem, so I decide
    				//to use a double threshold so as to separate float features
    				if(getTrainingExampleFeature(featureIndex, iterator) < test && test < getTrainingExampleFeature(featureIndex, iterator + 1))
    					break;
    				else{
    					#pragma omp critical
    					{
    						cout << "ERROR: numerical precision breached: problem feature values " 
    							 << getTrainingExampleFeature(featureIndex, iterator) 
    							 << " : " << getTrainingExampleFeature(featureIndex, iterator+1) 
    							 << ". Problem feature " << featureIndex << " and problem example " 
    							 << getTrainingExampleIndex(featureIndex, iterator) << " : " 
    							 << getTrainingExampleIndex(featureIndex, iterator+1) << endl;
    					}
    					fail("fail to find a suitable threshold.");
    				}
    			}
    			iterator++;
    		}
    
    		//update threshold
    		if(iterator < sampleCount - 1){
    			current.threshold = ((double)getTrainingExampleFeature(featureIndex, iterator) 
    				+ (double)getTrainingExampleFeature(featureIndex, iterator + 1))/2;
    			current.margin = getTrainingExampleFeature(featureIndex, iterator + 1) - getTrainingExampleFeature(featureIndex, iterator);
    		}else{
    			//slightly to the right of the biggest observation
    			current.threshold = getTrainingExampleFeature(featureIndex, iterator) + 1;
    			current.margin = 0;
    		}
    	}
    
    }
    
    //implement the feature selection's outer loop
    //return the most discriminative feature and its rule
    StumpRule AdaptBoost::bestStump(
    ){
    	vector<StumpRule> candidates;
    	candidates.resize(featureCount);
    	#pragma omp parallel for schedule(static)
    	for(int featureIndex = 0; featureIndex < featureCount; featureIndex++)
    		decisionStump(featureIndex, candidates[featureIndex]);
    
    	//loop over all the features
    	//the best rule has the smallest weighted error and the largest margin
    	StumpRule best = candidates[0];
    	for(int featureIndex = 1; featureIndex < featureCount; featureIndex++){
    		if(myStumpOrder(candidates[featureIndex], best))
    			best = candidates[featureIndex];
    	}
    
    	//if shit happens, tell me
    	if( best.weightedError >= 0.5 )
    		fail("Decision Stump failed: base error >= 0.5");
    
    	//return
    	return best;
    }

reference：

Yi-Qing Wang, An Analysis of the Viola-Jones Face Detection Algorithm, IPOL.

转载于:https://blog.51cto.com/remyspot/1638356

[wKioL1U7gcji6QY0AAD7nu0zyTE143.jpg]: /images/20220109/0ccad80eb2ad454481014097533df2ed.png