程序博客网 > 淘宝销量怎么刷上去的

封装Libsvm与Liblinear（重要概念之返回预测类别的概率分数）

来源：互联网 发布：淘宝销量怎么刷上去的 编辑：程序博客网 时间：2024/05/19 19:55

封装Libsvm与Liblinear


开篇我们基于以下场景：

       假设我们已经用libsvm或者是Liblinear训练了一个模型，现在需要读入该模型并基于该模型对一个样本进行预测，返回预测的类标签以及相应的隶属度分数。

 从封装的角度我们需要考虑一下几个问题：

  1.  如何规范输入，使得读入的数据在Libsvm与Liblinear上都可以直接运行
  2. 系统如何识别读入的模型的类别，并根据模型类别，选择Libsvm或者是Liblinear中合适的函数进行预测
  3. 如何预测该样本对应的标签以及得分

系统输入

因为我们对单个样本进行预测，所以这里直接定义单个节点的格式即可。对于多个样本，则可以循环调用。
在上一篇文章中，我们看到虽然Libsvm与Liblinear在向量节点的定义上有所差别，但是其中的成员变量还是一致的，因此为了统一，我们只需要重新定义一个新的类。
[java] view plaincopy
  1. public class SvmNode {  
  2.     /** 封装的Libsvm与Liblinear的节点格式**/  
  3.     private final int index;  
  4.     private double value;  
  5.   
  6.     public SvmNode( final int index, final double value ) {  
  7.         if (index < 0) throw new IllegalArgumentException("index must be >= 0");  
  8.         this.index = index;  
  9.         this.value = value;  
  10.     }  
  11.       
  12.     /**以下Getter和Setter、hashCode、equals函数省略**/  
  13.           
  14. }  

模型读入

我们首先来剖析一下Libsvm与Liblinear生成的模型的文件格式


从上述文件中，我们看到两者的模型文件存在很大的差异，因此我们只需要写一个解析函数直接读取模型的格式来判断到底属于那种模型。

最简单的形式就是直接通过第一行来判断，因为其模型的文件都是固定的，所以这种最简单的方式也是很有效的。

[java] view plaincopy
  1. /** 
  2.  * 读入模型文件。通过文件中的格式来判断到底属于Libsvm还是liblinear 
  3.  * @param model_filename 模型文件保存的路径及名称 
  4.  */  
  5. public void load_model(String model_filename){  
  6.     BufferedReader fp;  
  7.     try {  
  8.         InputStream in = new FileInputStream(model_filename);                 
  9.         fp = new BufferedReader(new InputStreamReader(in,"UTF-8"));  
  10.   
  11.         String line = null;  
  12.         try {  
  13.             while((line = fp.readLine())!=null){              
  14.                 String[] arg = whitespace.split(line);  
  15.                 //通过判断文件中每行第一个字符是否包含"svm_type"或者是"solver_type"  
  16.                 //来判断是Libsvm还是Liblinear  
  17.                 if(arg[0].equals("svm_type")){  
  18.                     svm_type = "libsvm";  
  19.                     svmModel = svm.svm_load_model(model_filename);  
  20.                     nr_class = svmModel.nr_class;  
  21.                     linearModel = null;  
  22.                     break;  
  23.                 }  
  24.                 if(arg[0].equals("solver_type")){  
  25.                     svm_type="liblinear";  
  26.                     svmModel = null;  
  27.                     linearModel = Linear.loadModel(new File(model_filename));  
  28.                     nr_class = linearModel.getNrClass();  
  29.                     break;  
  30.                 }  
  31.             }  
  32.         } catch (IOException e) {  
  33.             // TODO Auto-generated catch block  
  34.             e.printStackTrace();  
  35.         }  
  36.     } catch (UnsupportedEncodingException e1) {  
  37.         // TODO Auto-generated catch block  
  38.         e1.printStackTrace();  
  39.     } catch (FileNotFoundException e) {  
  40.         // TODO Auto-generated catch block  
  41.         e.printStackTrace();  
  42.     }  
  43. }  

多分类策略

这里我们研究一下Libsvm与Liblinear的多分类策略，虽然为多分类，但其实也适用于二分类。
对于Libsvm来说，采用为One-against-one的策略，而Liblinear则采用为One-against-rest的策略，关于这两类分类策略的解释，可以看下图：


我们接下来通过源代码具体分析一下：

首先来看一下Libsvm的模型训练部分：

[java] view plaincopy
  1. /** 
  2.  * Libsvm的模型训练函数 
  3.  * @param prob 输入的问题 
  4.  * @param param 输入的参数 
  5.  * @return 训练好的模型 
  6.  */  
  7. public static svm_model svm_train(svm_problem prob, svm_parameter param)  
  8. {  
  9.     /**为了代码的简洁性，此处删除了部分**/  
  10.       
  11.     /** 
  12.      * 此处省略了部分代码：这里的代码主要做： 
  13.      * 1、统计类别总数,同时记录类别的标号，统计每个类的样本数目 
  14.      * 2、计算权重C 
  15.      * 3、初始化nozero数组，便于统计SV 
  16.      * 4、初始化概率数组 
  17.     */  
  18.     svm_model model = new svm_model();  
  19.     model.param = param;  
  20.   
  21.     // 将属于同一个类别的数据组织起来  
  22.     svm_group_classes(prob,tmp_nr_class,tmp_label,tmp_start,tmp_count,perm);  
  23.       
  24.     //采用one-against-one进行分类  
  25.     int p = 0;  
  26.     //定义决策函数数组，将每一个而分类存储起来  
  27.     decision_function[] f = new decision_function[nr_class*(nr_class-1)/2];  
  28.     for(i=0;i<nr_class;i++)  
  29.         for(int j=i+1;j<nr_class;j++)  
  30.             svm_problem sub_prob = new svm_problem();  
  31.       
  32.     //计算第i个类与第j个类的起始位置与数目。  
  33.             int si = start[i], sj = start[j];  
  34.             int ci = count[i], cj = count[j];  
  35.             sub_prob.l = ci+cj;  
  36.     //将第i个类的标签定义为+1，第j个类的标签定义为-1  
  37.             for(k=0;k<ci;k++)  
  38.             {  
  39.                 sub_prob.x[k] = x[si+k];  
  40.                 sub_prob.y[k] = +1;  
  41.             }  
  42.             for(k=0;k<cj;k++)  
  43.             {  
  44.                 sub_prob.x[ci+k] = x[sj+k];  
  45.                 sub_prob.y[ci+k] = -1;  
  46.             }  
  47.     //对第i个类与第j个类采用二分类策略，训练模型  
  48.             f[p] = svm_train_one(sub_prob,param,weighted_C[i],weighted_C[j]);  
  49.             ++p;  
  50.         }  
  51.     /** 
  52.      * 此处省略了部分代码：这里的代码主要做： 
  53.      * 1、统计一下nozero,如果nozero已经是真，就不变，如果为假，则改为真 
  54.      * 2、输出模型,主要是填充svm_model 
  55.     */  
  56.     return model;  
  57. }  

然后再来看一下其模型预测部分：

[java] view plaincopy
  1. /** 
  2.  * Libsvm模型预测部分，预测该样本的类标签以及属于该类的分值。 
  3.  * 这里采用的方法为投票策略 
  4.  * @param model 已训练好的Libsvm模型 
  5.  * @param x 一个待预测的样本向量 
  6.  * @param dec_values 保存预测结果的向量，其维度为k*(k-1)/2 
  7.  * @return 
  8.  */  
  9. public static double svm_predict_values(svm_model model, svm_node[] x, double[] dec_values)  
  10. {  
  11.       
  12.     //对一些变量进行初始化  
  13.     int i;  
  14.     int nr_class = model.nr_class;  
  15.     int l = model.l;  
  16.   
  17.     double[] kvalue = new double[l];  
  18.     //根据模型中的支持向量以及内核函数计算数值  
  19.     for(i=0;i<l;i++)  
  20.         kvalue[i] = Kernel.k_function(x,model.SV[i],model.param);  
  21.   
  22.     int[] start = new int[nr_class];  
  23.     start[0] = 0;  
  24.     for(i=1;i<nr_class;i++)  
  25.         start[i] = start[i-1]+model.nSV[i-1];  
  26.       
  27.     //初始化vote向量  
  28.     int[] vote = new int[nr_class];  
  29.     for(i=0;i<nr_class;i++)  
  30.         vote[i] = 0;  
  31.   
  32.     //依次计算k*(k-1)/2个二分类模型的预测值  
  33.     int p=0;  
  34.     for(i=0;i<nr_class;i++)  
  35.         for(int j=i+1;j<nr_class;j++)  
  36.         {  
  37.             double sum = 0;  
  38.             int si = start[i];  
  39.             int sj = start[j];  
  40.             int ci = model.nSV[i];  
  41.             int cj = model.nSV[j];  
  42.           
  43.         //根据决策函数计算每一个二分类对样本预测的分值  
  44.             int k;  
  45.             double[] coef1 = model.sv_coef[j-1];  
  46.             double[] coef2 = model.sv_coef[i];  
  47.             for(k=0;k<ci;k++)  
  48.                 sum += coef1[si+k] * kvalue[si+k];  
  49.             for(k=0;k<cj;k++)  
  50.                 sum += coef2[sj+k] * kvalue[sj+k];  
  51.             sum -= model.rho[p];  
  52.             //dec_values存储的就是第p个二分类模型对样本的预测值  
  53.             dec_values[p] = sum;                      
  54.   
  55.         //根据dec_values  值的正负决定给那个类别投票  
  56.             if(dec_values[p] > 0)  
  57.                 ++vote[i];  
  58.             else  
  59.                 ++vote[j];  
  60.             p++;  
  61.         }  
  62.       
  63.     //遍历vote向量，找出具有最大投票数的所对应类别即为所预测的类标签。  
  64.     //而dec_values则存储了k*(k-1)/2个二分类模型的预测值  
  65.     int vote_max_idx = 0;  
  66.     for(i=1;i<nr_class;i++)  
  67.         if(vote[i] > vote[vote_max_idx])  
  68.             vote_max_idx = i;  
  69.   
  70.     return model.label[vote_max_idx];  
  71.   
  72. }  

接下来我们分析一下Liblinear的模型训练与模型预测部分

模型训练部分：
[java] view plaincopy
  1. /** 
  2.  * Liblinear模型训练部分 
  3.  * @param prob 输入的问题 
  4.  * @param param 输入的参数 
  5.  * @return 返回训练好的模型 
  6.  */public static Model train(Problem prob, Parameter param) {  
  7.   
  8.     /** 
  9.      * 此处省略了部分代码：这里的代码主要做： 
  10.      * 1、统计类别总数,同时记录类别的标号，统计每个类的样本数目 
  11.      * 2、将属于相同类的样本分组，连续存放 
  12.      * 3、计算权重C 
  13.      * 4、初始化nozero数组，便于统计SV 
  14.      * 5、初始化概率数组 
  15.     */  
  16.       
  17.     //此处可以看出需要寻k个模型  
  18.     for (int i = 0; i < nr_class; i++) {  
  19.         int si = start[i];  
  20.         int ei = si + count[i];  
  21.           
  22.         //重建子数据集，样本的特征不变，但样本的类别要改为+1/-1  
  23.         int k = 0;  
  24.         for (; k < si; k++)  
  25.             sub_prob.y[k] = -1;  
  26.         for (; k < ei; k++)  
  27.             sub_prob.y[k] = +1;  
  28.         for (; k < sub_prob.l; k++)  
  29.             sub_prob.y[k] = -1;  
  30.         //训练子数据集svm_train_one  
  31.         train_one(sub_prob, param, w, weighted_C[i], param.C);  
  32.   
  33.         for (int j = 0; j < n; j++)  
  34.             model.w[j * nr_class + i] = w[j];  
  35.     }  
  36.   
  37.   
  38.     /** 
  39.      * 此处省略了部分代码：这里的代码主要做： 
  40.      * 1、统计一下nozero,如果nozero已经是真，就不变，如果为假，则改为真 
  41.      * 2、输出模型,主要是填充svm_model 
  42.     */  
  43.       
  44.     return model;  
  45. }  

模型预测部分：

[java] view plaincopy
  1. /** 
  2.  * 模型预测部分，根据训练好的模型对样本进行预测。 
  3.  * @param model 已训练好的模型 
  4.  * @param x 样本的向量 
  5.  * @param dec_values 每个模型预测分值 
  6.  * @return 预测的类标签 
  7.  */  
  8. public static int predictValues(Model model, Feature[] x, double[] dec_values) {  
  9.       
  10.     //变量的初始化  
  11.     int n;  
  12.     if (model.bias >= 0)  
  13.         n = model.nr_feature + 1;  
  14.     else  
  15.         n = model.nr_feature;  
  16.   
  17.     double[] w = model.w;  
  18.   
  19.     int nr_w;  
  20.     if (model.nr_class == 2 && model.solverType != SolverType.MCSVM_CS)  
  21.         nr_w = 1;  
  22.     else  
  23.         nr_w = model.nr_class;  
  24.       
  25.     for (int i = 0; i < nr_w; i++)  
  26.         dec_values[i] = 0;  
  27.       
  28.     //计算每个模型预测分值  
  29.     for (Feature lx : x) {  
  30.         int idx = lx.getIndex();  
  31.         // the dimension of testing data may exceed that of training  
  32.         if (idx <= n) {  
  33.             for (int i = 0; i < nr_w; i++) {  
  34.                 dec_values[i] += w[(idx - 1) * nr_w + i] * lx.getValue();  
  35.             }  
  36.         }  
  37.     }  
  38.     //根据预测的分值来计算所属的标签，和Libsvm所不同的是：  
  39.     //这里采用的方式是比较那个模型预测分值大。  
  40.     if (model.nr_class == 2)  
  41.         return (dec_values[0] > 0) ? model.label[0] : model.label[1];  
  42.     else {  
  43.         int dec_max_idx = 0;  
  44.         for (int i = 1; i < model.nr_class; i++) {  
  45.             if (dec_values[i] > dec_values[dec_max_idx]) dec_max_idx = i;  
  46.         }  
  47.         return model.label[dec_max_idx];  
  48.     }  
  49. }  

综上所述，Libsvm采用的为One-against-one策略，Liblinear采用的One-against-rest策略。最后都能返回预测的类标签。但是对于由于他们采用的策略不同，导致其在预测的分值上不同。所以接下来我们将会对预测的分值进行归一化处理。

模型结果

模型会返回两个结果：label和score，其中label即其预测的标签。而score是该样本属于该类的隶属度，分值越大，代表属于该类的置信度越大。具体的计算方式则是根据：

其中k为所有支持判别类得个数，n为所有类别个数，si 为所有支持判别类的分数。这样就相当于把两个软件计算出来的分数进行了统一，而且经过公式的计算，会将分数的映射到[0,1]区间内，这样方便进行阈值控制。

代码为 

[java] view plaincopy
  1. /** 
  2.  * 返回具有最大投票数的标签所获得分数的总和 
  3.  * @param des_values 
  4.  */  
  5. public double sumPreValue(double[] des_values){  
  6.     int size=1;  
  7.     double init_score=0.0;  
  8.     int k=1;  
  9.     //对于Libsvm的类型，对其k*(k-1)/2个值进行计算  
  10.     if (this.svm_type.equals("libsvm")){  
  11.         int n = 1+(int)Math.sqrt(2.0*des_values.length+1);  
  12.         size = n-1;  
  13.         int [] vote = new int[n];  
  14.         double[] score = new double[n];  
  15.         int p =0;  
  16.         for(int i =0;i<n-1;i++){  
  17.             for(int j =i+1;j<n;j++){  
  18.                 if(des_values[p]>0){  
  19.                     vote[i]+=1;  
  20.                     score[i]+=Math.abs(des_values[p]);  
  21.                 }else{  
  22.                     vote[j]+=1;  
  23.                     score[j]+=Math.abs(des_values[p]);  
  24.                 }  
  25.                 p+=1;  
  26.             }  
  27.         }  
  28.         int max = 0;  
  29.         for(int i =1;i<n;i++)  
  30.             if(vote[i]>vote[max])  
  31.                 max = i;  
  32.         k = vote[max];  
  33.         init_score = score[max];  
  34.     }  
  35.     //对于Liblinear的类型，对其k个值进行计算  
  36.     if (this.svm_type.equals("liblinear")){  
  37.         int n =des_values.length;  
  38.         int max = 0;  
  39.         for(int i =1;i<n-1;i++){  
  40.             if(des_values[i]>des_values[max]){  
  41.                 max = i;  
  42.             }  
  43.         }  
  44.         size =1;  
  45.         k=1;  
  46.         init_score = des_values[max];  
  47.            
  48.     }  
  49.     return init_score/(2.0*k)+k/(2.0*size) ;  
  50.   
  51. }  


以Libsvm为例，说明一下分数的计算


总结

这样我们通过输入一个样本，根据读入的模型，就可以真正的对样本进行预测了。而且通过归一化两者的分值，可以很好的对结果进行阈值控制。更多详细的代码请见 https://code.google.com/p/tmsvm/

0 0
淘宝销量怎么刷上去的 淘宝销量怎么刷上去的
原创粉丝点击
热门IT博客
关于网络诈骗案件关于网络诈骗案件
德邦证券软件德邦证券软件
无人机 人工智能 军事
宝宝唱歌软件
淘宝的手机充值平台
如何学习数据挖掘
电商html模板 仿淘宝
win10 开机慢 mac
美国租房网站 知乎
网络教育本科
域名已被注册了怎么办
行知职高有什么专业
芬兰 网络
元首的愤怒 知乎
产品图片展示软件
搞笑哈哈镜软件
web关联数据库
美图秀秀网络字体下载
知乎政治垃圾
每月经济数据公布时间
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 易方达基金管理有限公司 博实基金 050201 050001基金净值 050001基金今天净值 诺安价值增长 基金050001 基金净值查询050001 博士价值增长 慱时价值增长净值 博士增长 景顺内需 嘉实沪港深精选股票基金 基金净值查询博时价值增长 博昱画室 博朗剃须刀 博朗d32 博朗榨汁机 博朗9系 博朗7840s 博朗5030s 博朗 飞利浦 吉列和博朗 博朗和吉列 吉列 博朗 博朗 梳 博朗6520耳温枪温度对照表 博朗剃须刀哪个型号好 博朗6520华氏改摄氏图文 博朗好还是飞利浦好 博朗6520怎么转换摄氏度 博朗和飞利浦剃须刀哪个好 博朗5系剃须刀 博朗剃须刀配件 博朗 电动剃须刀 博朗剃须刀价格表 飞利浦 博朗 剃须刀 博朗剃须刀清洗液 博朗剃须刀190s 博朗剃须刀怎么样 博朗剃须刀推荐

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里