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

逃离我推掉我的手 2023-06-13 09:52 4阅读 0赞

#### 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 去做更新，这样会破坏更新的连续性！！！