原文链接：点击打开链接
文档整理：陈伟 chenweishaoxing#163.com
下载libsvm
方法：google libsvm找到官网下载：
http://www.csie.ntu.edu.tw/~cjlin/libsvm/，其中图片中椭圆的
解压文档
下载下来libsvm工具包有几个版本的，其中python的最经典，用的人比较多，还支持matlab，C++等等。我们用的java版的，就到解压开的java文件夹中！
java文件夹
导入到eclipse工程中
创建一个java工程，把上图的源码复制到eclipse中，如同所示
在工程下创建一个文件夹，里面存放训练测试用的数据
首次调用的Demo举例
在java的工程中创建一个属于自己的包，然后写一个mian类。如图
ComMain.java
package com.endual.paper.main;
importjava.io.IOException;
importservice.svm_predict;
importservice.svm_train;
public classComMain {
public static void main(String[] args)throws IOException {
String []arg ={ "trainfile\\train1.txt", //存放SVM训练模型用的数据的路径
"trainfile\\model_r.txt"}; //存放SVM通过训练数据训/ //练出来的模型的路径
String []parg={"trainfile\\train2.txt", //这个是存放测试数据
"trainfile\\model_r.txt", //调用的是训练以后的模型
"trainfile\\out_r.txt"}; //生成的结果的文件的路径
System.out.println("........SVM运行开始..........");
//创建一个训练对象
svm_train t = new svm_train();
//创建一个预测或者分类的对象
svm_predict p= new svm_predict();
t.main(arg); //调用
p.main(parg); //调用
}
}
6.运行工程就可以看到了结果了
Libsvm二次开发的首先要熟悉调用接口的源码
你一定会有疑问：SVM的参数怎么设置，cross-validation怎么用。那么我们首先来说明一个问题，交叉验证在一般情况下要自己开发自己写。Libsvm内置了交叉验证，但是如果我希望用同交叉验证的数据用决策树来做，怎么办，显然Libsvm并没有保存交叉验证的数据。
============================================================
我已经将注释写在了源码中。
Svm_train类的文档说明
package service;
import libsvm.*;
import java.io.*;
import java.util.*;
public class svm_train {
privatesvm_parameter param; // set byparse_command_line
privatesvm_problem prob; // set byread_problem
privatesvm_model model;
privateString input_file_name; // set byparse_command_line
privateString model_file_name; // set byparse_command_line
privateString error_msg;
privateint cross_validation;
privateint nr_fold;
privatestatic svm_print_interface svm_print_null = new svm_print_interface()
{
publicvoid print(String s) {}
};
privatestatic void exit_with_help()
{
System.out.print(
"Usage: svm_train [options]training_set_file [model_file]\n"
+"options:\n"
+"-ssvm_type : set type of SVM (default 0)\n"
+" 0 -- C-SVC\n"
+" 1 -- nu-SVC\n"
+" 2 -- one-class SVM\n"
+" 3 -- epsilon-SVR\n"
+" 4 -- nu-SVR\n"
+"-tkernel_type : set type of kernel function (default 2)\n"
+" 0 -- linear: u'*v\n"
+" 1 -- polynomial: (gamma*u'*v +coef0)^degree\n"
+" 2 -- radial basis function:exp(-gamma*|u-v|^2)\n"
+" 3 -- sigmoid: tanh(gamma*u'*v +coef0)\n"
+" 4 -- precomputed kernel (kernel values intraining_set_file)\n"
+"-ddegree : set degree in kernel function (default 3)\n"
+"-ggamma : set gamma in kernel function (default 1/num_features)\n"
+"-rcoef0 : set coef0 in kernel function (default 0)\n"
+"-ccost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default1)\n"
+"-nnu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default0.5)\n"
+"-pepsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)\n"
+"-mcachesize : set cache memory size in MB (default 100)\n"
+"-eepsilon : set tolerance of termination criterion (default 0.001)\n"
+"-hshrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)\n"
+"-bprobability_estimates : whether to train a SVC or SVR model for probabilityestimates, 0 or 1 (default 0)\n"
+"-wiweight : set the parameter C of class i to weight*C, for C-SVC (default1)\n"
+"-vn : n-fold cross validation mode\n"
+"-q: quiet mode (no outputs)\n"
);
System.exit(1);
}
privatevoid do_cross_validation()
{
inti;
inttotal_correct = 0;
doubletotal_error = 0;
doublesumv = 0, sumy= 0, sumvv = 0, sumyy = 0, sumvy = 0;
double[]target = new double[prob.l];
svm.svm_cross_validation(prob,param,nr_fold,target);
if(param.svm_type== svm_parameter.EPSILON_SVR ||
param.svm_type == svm_parameter.NU_SVR)
{
for(i=0;i<prob.l;i++)
{
doubley = prob.y[i];
doublev = target[i];
total_error+= (v-y)*(v-y);
sumv+= v;
sumy += y;
sumvv+= v*v;
sumyy+= y*y;
sumvy+= v*y;
}
System.out.print("CrossValidation Mean squared error = "+total_error/prob.l+"\n");
System.out.print("CrossValidation Squared correlation coefficient = "+
((prob.l*sumvy-sumv*sumy)*(prob.l*sumvy-sumv*sumy))/
((prob.l*sumvv-sumv*sumv)*(prob.l*sumyy-sumy*sumy))+"\n"
);
}
else
{
for(i=0;i<prob.l;i++)
if(target[i]== prob.y[i])
++total_correct;
System.out.print("CrossValidation Accuracy = "+100.0*total_correct/prob.l+"%\n");
}
}
privatevoid run(String argv[]) throws IOException
{
System.out.println("我的数组的长度是："+ argv.length) ;
parse_command_line(argv);//解析svm参数的配置，我们去这个方法看看，你可以按住crlt，然后鼠标点击这个方法
read_problem();
error_msg= svm.svm_check_parameter(prob,param);
if(error_msg!= null)
{
System.err.print("ERROR:"+error_msg+"\n");
System.exit(1);
}
if(cross_validation!= 0)
{
do_cross_validation();
}
else
{
model= svm.svm_train(prob,param);
svm.svm_save_model(model_file_name,model);
}
}
publicstatic void main(String argv[]) throws IOException
{
svm_traint = new svm_train();
t.run(argv);
}
privatestatic double atof(String s)
{
doubled = Double.valueOf(s).doubleValue();
if(Double.isNaN(d) || Double.isInfinite(d))
{
System.err.print("NaN or Infinity in input\n");
System.exit(1);
}
return(d);
}
//解析控制台输入的string类型的值，因为svm的参数是由整数来代表的，
//那么通过这个方法将控制台输入的字符串解析成为整数的
privatestatic int atoi(String s)
{
returnInteger.parseInt(s);
}
//欢迎来到解析svm参数的方法
privatevoid parse_command_line(String argv[])
{
inti; //设置了一个方法域的一个i变量，用于遍历argv这个字符串数组的的哦
svm_print_interfaceprint_func = null; // default printingto stdout，这个是一个接口
//创建一个SVM的参数对象，SVM的参数都在这个对象中。
//具体的参数对象可以看svm_parameter这个类
param= new svm_parameter();
// 默认的SVM设置的值，如果需要修改，那么要从控制台输入，然后下面的for循环会解析svm的参数设置
//我还没用全部搞懂这些参数的意思，但是这些参数的作用完全可以在帮助信息中看到。
param.svm_type= svm_parameter.C_SVC; //默认的支持向量
//param.svm_type= svm_parameter.NU_SVC;
param.kernel_type= svm_parameter.RBF; //默认的核函数高斯核函数
param.degree= 3;
param.gamma= 0; // 1/num_features
param.coef0= 0;
param.nu= 0.01;
param.cache_size= 100;
param.C= 1;
param.eps= 1e-3;
param.p= 0.1;
param.shrinking= 1;
param.probability= 0;
param.nr_weight= 0;
param.weight_label= new int[0];
param.weight= new double[0];
cross_validation= 0; //表示关闭交叉验证，1表示开启交叉验证（这里不能设置1，因为你设置了也没用）
// 解析选项SVM参数的选项，如果控制台没有输入对于的字符串，那么SVM将使用的是默认的SVM的参数设置
for(i=0;i<argv.length;i++)//初始化i
{
//返回的是argv这个数组第i个字符串第一个字符，这里说明控制台要输入的时候首先要写一个'-'号.(比如i=4,argv.length=10,argv[4])
//如果不写，那么将break本次的循环，跳出的是整个for循环，所以让文件保存的路径在数组中写到最后
if(argv[i].charAt(0)!= '-') break; //如果一遇到不是这个跳出的是整个for循环
//如果查询到了'-'字符，那么会执行这一步了。
//判断这个i的值是不是大于或者等于argv的长度了，如果是数组的长度了，那么就打印出帮助信息。并且会中断虚拟机了
//++i>= argv.length这个应该是先用i再加1，那么下面的操作的时候就是i= i + 1了(i=5)
if(++i>=argv.length)
exit_with_help();
//如果执行了第二个if，那么会执行到这里了。这里的i= 5
switch(argv[i-1].charAt(1))//用到的字符串仍然是argv[5-1]=argv[4],解析的是第2个字符。
{
case's': //设置svm的类型
param.svm_type= atoi(argv[i]); //这个赋值就是将argv[5],赋值过去了
break;
case't': //设置svm的核函数类型
param.kernel_type= atoi(argv[i]);
break;
case'd': //设置svm参数d的大小，用于多项式核函数
param.degree = atoi(argv[i]);
break;
case'g': //赋值gamma的
param.gamma= atof(argv[i]);
break;
case'r': //赋值coef0的值
param.coef0= atof(argv[i]);
break;
case'n': //赋值n的值
param.nu= atof(argv[i]);
break;
case'm': //赋值缓存的值
param.cache_size= atof(argv[i]);
break;
case'c': //赋值的是惩罚因子的大小
param.C= atof(argv[i]);
break;
case'e': //赋值的eps的值
param.eps= atof(argv[i]);
break;
case'p': //赋值******我不想写下去了，因为在实际的应用中，我还没用用到下面的参数。抱歉。
param.p= atof(argv[i]);
break;
case'h': //
param.shrinking= atoi(argv[i]);
break;
case'b': //要不要打印出分类的准确率的值
param.probability= atoi(argv[i]);
break;
case'q':
print_func= svm_print_null;
i--;
break;
case'v': //设置的交叉验证的值
cross_validation= 1; //开启交叉验证
nr_fold= atoi(argv[i]);
if(nr_fold< 2) //交叉验证的值不能小于1
{
System.err.print("n-foldcross validation: n must >= 2\n");
exit_with_help();
}
break;
case'w':
++param.nr_weight;
{
int[]old = param.weight_label;
param.weight_label= new int[param.nr_weight];
System.arraycopy(old,0,param.weight_label,0,param.nr_weight-1);
}
{
double[]old = param.weight;
param.weight= new double[param.nr_weight];
System.arraycopy(old,0,param.weight,0,param.nr_weight-1);
}
param.weight_label[param.nr_weight-1]= atoi(argv[i-1].substring(2));
param.weight[param.nr_weight-1]= atof(argv[i]);
break;
default:
//如果一个字符都匹配不到，很遗憾要中断JVM了，并且会打印出那个位子的字符出现了错误，然后打印出帮助信息
System.err.print("Unknownoption: " + argv[i-1] + "\n");
exit_with_help();
}//endswitch
}//end for
svm.svm_set_print_string_function(print_func);//打印出是不是静音模式
//determine filenames决定文件名
/**
* 我必须中断下操作来说明控制台应该怎么输入的
* argv={"-s","1","-t","3","-w","5","我是训练用的文件路径","我是训练完以后保存模型的路径"}
* 具体的1,3,5参数要参考官方说明文档，或者查看设置参数那个类的参数。
* 看到这，你可以继续看下去了
*/
if(i>=argv.length)//这里是了防止没有输入存放文件的路径，或者存放文件的路径不够
exit_with_help();
//到这里，i的应该是字符串数组的倒数第二个了
//其实我一直搞不清楚，为什么for循环完毕了，这个i不是argv数组的长度呢 ？不是的i的值是数组长度-1也就是数组中倒数第二个位子
input_file_name= argv[i]; //将训练的文件路径赋值
System.out.println("POSITION="+(i+1)+"我的训练用的数据存放的路径是："+ input_file_name) ;
if(i<argv.length-1)//如果i的值比数组长度-1还小，那么将argv[i]下一个字符串赋值给存放模型的路径
model_file_name= argv[i+1]; //将训练以后的模型路径赋值
else
{
intp = argv[i].lastIndexOf('/');
++p; // whew...
model_file_name= argv[i].substring(p)+".model";
}
System.out.println("我的训练用的数据存放的路径是："+ model_file_name) ;
} // endrun function
// read ina problem (in svmlight format)
privatevoid read_problem() throws IOException
{
BufferedReaderfp = new BufferedReader(new FileReader(input_file_name));
Vector<Double>vy = new Vector<Double>();
Vector<svm_node[]>vx = new Vector<svm_node[]>();
intmax_index = 0;
while(true)
{
Stringline = fp.readLine();
if(line== null) break;
StringTokenizerst = new StringTokenizer(line," \t\n\r\f:");
vy.addElement(atof(st.nextToken()));
intm = st.countTokens()/2;
svm_node[]x = new svm_node[m];
for(intj=0;j<m;j++)
{
x[j]= new svm_node();
x[j].index= atoi(st.nextToken());
x[j].value= atof(st.nextToken());
}
if(m>0)max_index = Math.max(max_index, x[m-1].index);
vx.addElement(x);
}
prob= new svm_problem();
prob.l= vy.size();
prob.x= new svm_node[prob.l][];
for(inti=0;i<prob.l;i++)
prob.x[i]= vx.elementAt(i);
prob.y= new double[prob.l];
for(inti=0;i<prob.l;i++)
prob.y[i]= vy.elementAt(i);
if(param.gamma== 0 && max_index > 0)
param.gamma= 1.0/max_index;
if(param.kernel_type== svm_parameter.PRECOMPUTED)
for(inti=0;i<prob.l;i++)
{
if(prob.x[i][0].index != 0)
{
System.err.print("Wrongkernel matrix: first column must be 0:sample_serial_number\n");
System.exit(1);
}
if((int)prob.x[i][0].value <= 0 || (int)prob.x[i][0].value > max_index)
{
System.err.print("Wronginput format: sample_serial_number out of range\n");
System.exit(1);
}
}
fp.close();
}
}
Svm_predict类的文档说明
package service;
import libsvm.*;
import java.io.*;
import java.util.*;
public class svm_predict {
privatestatic double atof(String s)
{
returnDouble.valueOf(s).doubleValue();
}
privatestatic int atoi(String s)
{
returnInteger.parseInt(s);
}
privatestatic void predict(BufferedReader input, DataOutputStream output, svm_modelmodel, int predict_probability) throws IOException
{
//欢迎来到这个预测方法，下面开始分析
//设置方法内局部变量
//这个是预测正确的个数的
intcorrect = 0;
//这个是预测的个数一共有几个
inttotal = 0;
//分类或者预测的准确率，所以用double error = correct/ total ;
doubleerror = 0;
//几个中间变量的参数
doublesumv = 0, sumy= 0, sumvv = 0, sumyy = 0, sumvy = 0;
intsvm_type=svm.svm_get_svm_type(model);
intnr_class=svm.svm_get_nr_class(model);
double[]prob_estimates=null;
//如果传入进来的1（默认是0） ,那么从这里开始执行
//这个是不能用回归svm的
if(predict_probability== 1)
{
if(svm_type== svm_parameter.EPSILON_SVR || //回归SVM
svm_type == svm_parameter.NU_SVR) //回归SVM
{
//打印出出错误了，svm数据不匹配
System.out.print("Prob.model for test data: target value = predicted value + z,\nz: Laplacedistributione^(-|z|/sigma)/(2sigma),sigma="+svm.svm_get_svr_probability(model)+"\n");
}
//用于分类的话就执行这个了
else
{
int[]labels=new int[nr_class]; //取得标签。分类用的标签
svm.svm_get_labels(model,labels);
prob_estimates= new double[nr_class];
output.writeBytes("labels");//写入到文件中去
for(intj=0;j<nr_class;j++)
output.writeBytes(""+labels[j]);
output.writeBytes("\n");
}
}//end if
//这个一定会执行的
while(true)
{
Stringline = input.readLine(); //一行一行的读取
if(line== null) break;//如果出现空行，那么就停止，所以在文件中中间不能有空行
StringTokenizerst = new StringTokenizer(line," \t\n\r\f:");
doubletarget = atof(st.nextToken());
intm = st.countTokens()/2;
svm_node[]x = new svm_node[m];
for(intj=0;j<m;j++)
{
x[j]= new svm_node();
x[j].index= atoi(st.nextToken());
x[j].value= atof(st.nextToken());
}
doublev;
//如果是分类svm就执行这个
if(predict_probability==1 && (svm_type==svm_parameter.C_SVC ||svm_type==svm_parameter.NU_SVC))
{
v= svm.svm_predict_probability(model,x,prob_estimates);
output.writeBytes(v+"");
for(intj=0;j<nr_class;j++)
output.writeBytes(prob_estimates[j]+"");
output.writeBytes("\n");
}//end id
else
{
v= svm.svm_predict(model,x);
output.writeBytes(v+"\n");
}
/**
* 做二次开发，这里可动手脚，你可以输入要具体预测对的类在这里显示出来等等
*/
if(v== target) //如果预测正确，那么分类的正确就加一
++correct;
error+= (v-target)*(v-target);
sumv+= v;
sumy += target;
sumvv+= v*v;
sumyy+= target*target;
sumvy+= v*target;
++total;
}//end while
//如果是回归的svm就用这个
if(svm_type== svm_parameter.EPSILON_SVR ||
svm_type == svm_parameter.NU_SVR)
{
/**
* 这里打印出来的是用于回归问题的信息regression
*/
System.out.print("Meansquared error = "+error/total+" (regression)\n");
System.out.print("Squaredcorrelation coefficient = "+
((total*sumvy-sumv*sumy)*(total*sumvy-sumv*sumy))/
((total*sumvv-sumv*sumv)*(total*sumyy-sumy*sumy))+
" (regression)\n");
}
else//这里打印出来的是用于分类问题的信息classification
System.out.print("Accuracy= "+(double)correct/total*100+
"%("+correct+"/"+total+") (classification)\n");
}//endfunction
privatestatic void exit_with_help()
{
System.err.print("usage:svm_predict [options] test_file model_file output_file\n"
+"options:\n"
+"-bprobability_estimates: whether to predict probability estimates, 0 or 1(default 0); one-class SVM not supported yet\n");
System.exit(1);
}
//首先从这里读
publicstatic void main(String argv[]) throws IOException
{
inti, predict_probability=0; //设置两个值，后面一个0表示不开启
//parse options解析选项，解析和train类类似不做说明
for(i=0;i<argv.length;i++)
{
if(argv[i].charAt(0)!= '-') break;
++i;
switch(argv[i-1].charAt(1))
{
case'b':
predict_probability= atoi(argv[i]);
break;
default:
System.err.print("Unknownoption: " + argv[i-1] + "\n");
exit_with_help();
}
}
if(i>=argv.length-2)
exit_with_help();
try
{
BufferedReaderinput = new BufferedReader(new FileReader(argv[i]));
DataOutputStreamoutput = new DataOutputStream(new BufferedOutputStream(newFileOutputStream(argv[i+2])));
svm_modelmodel = svm.svm_load_model(argv[i+1]);
if(predict_probability== 1)
{
if(svm.svm_check_probability_model(model)==0)
{
System.err.print("Modeldoes not support probabiliy estimates\n");
System.exit(1);
}
}
else
{
if(svm.svm_check_probability_model(model)!=0)
{
System.out.print("Modelsupports probability estimates, but disabled in prediction.\n");
}
}
/**
* 重点来看这个，我们要预测或者分类，中想返回一个预测正确或者分类正确的类别的
* 你可以按住ctrl,然后用鼠标点击这个类
* 三个个参数:
* 一个是模型，已经训练出来的模型
* 一个是输入的测试数据
* 一个是是不是要打印出信息（我没用过，默认是0）
*/
predict(input,output,model,predict_probability);
input.close();//涉及到文件的操作有关闭的一些操作
output.close();
}
catch(FileNotFoundExceptione)
{
exit_with_help();
}
catch(ArrayIndexOutOfBoundsExceptione)
{
exit_with_help();
}
}
}
下面是一些二次开发的介绍
隔点搜索的代码怎么写？
1. 我们在寻找最佳svm的参数组合的时候不可能自己去手动的去设置.比如高斯核函数有两个参数要设置，c和gamma.我们要改写train的代码，将c和gama的参数设置到man方法中去，直接通过调用main就可以改变c和gamma的
打圈的是自己改的。
如果你能看懂上面的意思，那么我想你的java基础完全可以想出来怎么讲correct正确的作为返回值返回到主main中，你又可以利用这个来写出属于自己的交叉验证
你可以参考一下的调用代码
package com.endual.paper.main_RBF;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import service.svm_predict;
import service.svm_train;
public class ComMain_data_dea {
/*
* @param args
* @throws IOException
*/
public void main(int ix) throws IOException {
//TODO Auto-generated method stub
// String []arg={"file_train\\train1.txt","file_model\\train1_model.txt"};
// String[]parg={"file_test\\test1.txt","file_model\\train1_model.txt","file_out\\train1_out.txt"};
// System.out.println("........SVM运行开始..........");
// svm_train t = new svm_train();
// svm_predict p= new svm_predict();
// t.main(arg);
// p.main(parg);
// System.out.println("........SVM运行结束..........");
File f_accurate = newFile("file_data_accurate\\acc_data_ccr.txt");
if(f_accurate== null){
f_accurate.createNewFile();
}else{
//f_accurate.
}
FileWriterfw = new FileWriter(f_accurate);
BufferedWriterbw = new BufferedWriter(fw);
bw.write("c表示惩罚因子，gamama表示核函数变量， temp表示交叉验证准确验证的个数，accor表示准确率");
bw.newLine();
doubletemp = 0;
doublec = 0;
doubleval_c = 0 ;
doubleval_gamma = 0 ;
doubleaccor = 0;
doublemaxaccor = 0;
doublemax_c = 0;
doublemax_gamama = 0;
doublemax_temp = 0;
StringtempStr_c ="";
StringtempStr_g ="";
StringtempStr_ac ="";
for(inti1=0;i1<100;i1++){
val_gamma = 0;
val_c = val_c + 0.1 ;
for(inti2=0;i2<200;i2++){
val_gamma= val_gamma + 0.01 ;
for(inti=1;i<6;i++){
String []arg={"file_data_ccr\\train\\train"+i+".txt","file_data_ccr\\model\\train"+i+"_model.txt"};
String[]parg={"file_data_ccr\\test\\test"+i+".txt","file_data_ccr\\model\\train"+i+"_model.txt","file_data_ccr\\out\\train"+i+"_out.txt"};
System.out.println("........SVM运行开始.........."+i);
svm_train t = new svm_train();
svm_predict p= new svm_predict();
t.main(arg,val_c,val_gamma,ix,0);
c = p.main(parg);
temp = temp + c;
}//end for
accor= (double)temp/23;
tempStr_c= (val_c+"0000000").substring(0, 3);
tempStr_g= (val_gamma+"0000000").substring(0, 4);
tempStr_ac= (accor+"000000").substring(0, 5);
//bw.write("c="+val_c+",gamama="+val_gamma+",temp="+temp+",accor="+accor);
bw.write("c="+tempStr_c+" ,gamama="+tempStr_g+" ,temp="+temp+" ,accor="+tempStr_ac);
bw.newLine();
if(accor>maxaccor){
maxaccor= accor ;
max_c= val_c;
max_gamama= val_gamma;
max_temp= temp;
// break;
}
c= 0;
temp= 0;
}//endfor
if(accor>maxaccor){
maxaccor= accor ;
// break;
}
}//endfor
bw.write("max_c="+max_c+",max_gamama="+max_gamama+",max_temp="+max_temp+",max_accor="+maxaccor);
bw.newLine();
bw.close();
fw.close();
//double accor = (double)temp/23;
System.out.println("........accor.........."+maxaccor);
System.out.println("**********max_c************" + max_c);
System.out.println("**********max_gamama************" +max_gamama);
System.out.println("**********max_temp************" +max_temp);
// for(int i=1;i<6;i++){
//
// String []arg={"file_train\\train"+i+".txt","file_model\\train"+i+"_model.txt"};
// String[]parg={"file_test\\test"+i+".txt","file_model\\train"+i+"_model.txt","file_out\\train"+i+"_out.txt"};
// System.out.println("........SVM运行开始.........."+i);
// svm_train t = new svm_train();
// svm_predict p= new svm_predict();
// t.main(arg,val_c,val_gamma);
// c = p.main(parg);
// temp = temp + c;
// System.out.println("........C.........."+c);
//
// }//end for
// double accor = (double)temp/23;
//System.out.println("........accor.........."+accor);
}//endmain
}//end class
说明：
你可以在csdn下载到包括demo的说明文档
扫一扫
6564
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
