系统学习图像算法Day.28——C++应用——复现机器学习中的Pocket Algorithm，以及发现该算法的细节问题

Pocket Algorithm其实就是针对数据集线性不可分时的PLA改进算法。其思想是在PLA无法使全部数据线性可分时，通过贪心算法保留将数据分割效果最好的直线。

#include <iostream>
#include <fstream>
#include <vector>
#include <algorithm>   //这个头文件用于调用“随机打乱vector中的元素”的函数 random_shuffle

using namespace std;
const int DIMS = 5;    //X的维度，因为PLA算法中令 X0=1，所以 DIMS 是其真实维度+1

char *file = "pocket_train.txt";
char *file1 = "pocket_test.txt";

struct training_unit    //每个X数据结构体
{
    double x[DIMS];
    int y;
};

vector <training_unit> training;   //用来保存训练数据
vector <training_unit> test;       //用来保存test数据

int sign( double signx )    //sign函数，正为1，负为-1
{
    int signy; 
    if (signx > 0) signy = 1;
    else signy = -1;
    return signy;
}

int judge(training_unit xy,double ww[5])    //判决是否需要修正w
{
     double sum = 0;
     for (int k=0; k<5; k++)
        sum += ( xy.x[k] * ww[k] );
     if ( sign(sum) == xy.y ) return 1;
     else return 0;
}

void file_to_vector( char *filename, vector <training_unit>& vectorname )  //将数据文件中的数据读取到vector中去
{
    ifstream inFile;
    inFile.open(filename);
    if (!inFile.is_open())
     {
     	cerr <<"Could not open"<<file<<endl;
        exit(EXIT_FAILURE);
     }

    training_unit x4y1_model;

    while (!inFile.eof())      //把x、y数据读入vector容器
      {
     	  x4y1_model.x[0] = 1; 
          for(int i=1;i<DIMS;i++)
            {
        	  inFile >> x4y1_model.x[i] ;
                  inFile >> x4y1_model.y;
            }
          vectorname.push_back(x4y1_model); 
     }

    inFile.close();
}

void cout_the_result( double w[] )   //打印 w
{
    cout <<"w= { "<<w[0]<<", "<<w[1]<<", "<<w[2]<<", "<<w[3]<< ", }" <<endl;
}

void count_true_nums( int & coutf_true_nums, int coutf_nums, double coutf_w[DIMS], vector <training_unit> coutf_training )   //计算当前w分类能正确分类的个数
{
    int coutf_j = 0;
    for( ;coutf_j<coutf_nums;coutf_j++ ) 
      coutf_true_nums += judge(coutf_training[coutf_j], coutf_w);
}

void swap( double *f_w, double *f_pocket_w )   //将 f_w 复制到 f_pocket_w 中去
{
    for( int i = 0; i < DIMS; i++ )
    f_pocket_w[i] = f_w[i];
}

void max(int &a, double *f_w, int &b, double *f_pocket_w )  //前面两项是新的，后面两项是旧的
{
    if(a>b) 
      {
          b = a;
          swap( f_w, f_pocket_w );
      }
   //  else swap( f_pocket_w , f_w );   //这一句坚决不能要，会增加错误率
}

double PocketPLA( )     //算法核心
{
    int iter = 0;
    int iteration = 50;  //口袋算法的迭代次数
    double w[DIMS] = {0.0};
    double pocket_w[DIMS] = {0.0};
    int nums = training.size();
    int j = 0;
    int big_true_nums = 0;
    int true_nums = 0;    //正确分类的的数据个数
    int true_nums1 = 0;   //将pocket中的w用于test数据中正确分类个数
    double error_rate = 0.0;  // 训练集错误率
    double error_rate1 = 0.0; // 将该 w 用于测试集的错误率

    while(iter < iteration)
      {
          if( !judge(training[j], w) )
            { 
                for(int i=0; i<DIMS; i++)
                w[i] += ( training[j].y * training[j].x[i] );
                count_true_nums( true_nums, nums, w, training );   
                max( true_nums, w, big_true_nums, pocket_w );
                true_nums = 0;
                iter ++;
           }

          j++;
          if ( j == nums ) j = 0;
      }

    cout_the_result( pocket_w );
    count_true_nums( true_nums1, nums, pocket_w, test );  
    cout << "big_true_nums = " << big_true_nums << endl;
    cout << "true_nums1 = " << true_nums1 << endl;      //test

    error_rate = double( nums - big_true_nums ) / double (nums);
    error_rate1 = double( nums - true_nums1 ) / double (nums);

    cout << "error_rate = " << error_rate << endl;
    cout << "error_rate1 = " << error_rate1 << endl;

    return error_rate1;
}

int main()
{
    double errorrate_average = 0.0;
    
    file_to_vector(file,training);
    file_to_vector(file1,test);

    for ( int i = 0; i < 2000; i++ )
      {
          cout << "The " << i <<"th random processing"<< endl;
          random_shuffle( training.begin(), training.end() );
          errorrate_average += PocketPLA( );
      }
    errorrate_average /= 2000;
    cout << "errorrate_average = " << errorrate_average;
    cin.get();
    return 0;
}

在编写这个程序时，发现一个口袋算法的细节，如果忽略这个细节将增加错误率。
下面请听我讲解：

void max(int &a, double *f_w, int &b, double *f_pocket_w )  //前面两项是新的，后面两项是旧的
{
    if(a>b) 
      {
          b = a;
          swap( f_w, f_pocket_w );
      }
//  else swap( f_pocket_w , f_w );   //这一句坚决不能要，会增加错误率
}

就是上面加标注的这一句

之前加上这一句的想法是：如果当前 w 效果不如 pocket_w 那我就继续使用 pocket_w 当做 w 来继续迭代，找到下一个错误点，进行更新w，然后进行与 pocket_w 比较…

其实不能这样，我们要保持 w 更新的连续性，不能因为w没有 pocket_w 效果好就把 pocket_w 赋给 w 去做更新，这样会破坏更新的连续性！！！