/** Process the training and test files provided in the parameters file to the constructor. */
public void process() {
double[] outputs;
double[] outputs2;
Instance neighbor;
double dist, mean;
int actual;
int[] N = new int[nneigh];
double[] Ndist = new double[nneigh];
boolean allNull;
svm_problem SVMp = null;
svm_parameter SVMparam = new svm_parameter();
svm_model svr = null;
svm_node SVMn[];
double[] outputsCandidate = null;
boolean same = true;
Vector instancesSelected = new Vector();
Vector instancesSelected2 = new Vector();
// SVM PARAMETERS
SVMparam.C = C;
SVMparam.cache_size = 10; // 10MB of cache
SVMparam.degree = degree;
SVMparam.eps = eps;
SVMparam.gamma = gamma;
SVMparam.nr_weight = 0;
SVMparam.nu = nu;
SVMparam.p = p;
SVMparam.shrinking = shrinking;
SVMparam.probability = 0;
if (kernelType.compareTo("LINEAR") == 0) {
SVMparam.kernel_type = svm_parameter.LINEAR;
} else if (kernelType.compareTo("POLY") == 0) {
SVMparam.kernel_type = svm_parameter.POLY;
} else if (kernelType.compareTo("RBF") == 0) {
SVMparam.kernel_type = svm_parameter.RBF;
} else if (kernelType.compareTo("SIGMOID") == 0) {
SVMparam.kernel_type = svm_parameter.SIGMOID;
}
SVMparam.svm_type = svm_parameter.EPSILON_SVR;
try {
// Load in memory a dataset that contains a classification problem
IS.readSet(input_train_name, true);
int in = 0;
int out = 0;
ndatos = IS.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
X = new String[ndatos][2]; // matrix with transformed data
mostCommon = new String[nvariables];
SVMp = new svm_problem();
SVMp.l = ndatos;
SVMp.y = new double[SVMp.l];
SVMp.x = new svm_node[SVMp.l][nentradas + 1];
for (int l = 0; l < SVMp.l; l++) {
for (int n = 0; n < Attributes.getInputNumAttributes() + 1; n++) {
SVMp.x[l][n] = new svm_node();
}
}
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
SVMp.y[i] = inst.getAllOutputValues()[0];
for (int n = 0; n < Attributes.getInputNumAttributes(); n++) {
SVMp.x[i][n].index = n;
SVMp.x[i][n].value = inst.getAllInputValues()[n];
SVMp.y[i] = inst.getAllOutputValues()[0];
}
// end of instance
SVMp.x[i][nentradas].index = -1;
}
if (svm.svm_check_parameter(SVMp, SVMparam) != null) {
System.out.println("SVM parameter error in training:");
System.out.println(svm.svm_check_parameter(SVMp, SVMparam));
System.exit(-1);
}
// train the SVM
if (ndatos > 0) {
svr = svm.svm_train(SVMp, SVMparam);
}
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
X[i][0] = new String(String.valueOf(inst.getAllOutputValues()[0]));
// the values used for regression
SVMn = new svm_node[Attributes.getInputNumAttributes() + 1];
for (int n = 0; n < Attributes.getInputNumAttributes(); n++) {
SVMn[n] = new svm_node();
SVMn[n].index = n;
SVMn[n].value = inst.getAllInputValues()[n];
}
SVMn[nentradas] = new svm_node();
SVMn[nentradas].index = -1;
// pedict the class
X[i][1] = new String(String.valueOf((svm.svm_predict(svr, SVMn))));
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
write_results(output_train_name);
/** ************************************************************************************ */
try {
// Load in memory a dataset that contains a classification
// problem
IS.readSet(input_test_name, false);
int in = 0;
int out = 0;
ndatos = IS.getNumInstances();
nvariables = Attributes.getNumAttributes();
nentradas = Attributes.getInputNumAttributes();
nsalidas = Attributes.getOutputNumAttributes();
X = new String[ndatos][2]; // matrix with transformed data
// data
mostCommon = new String[nvariables];
for (int i = 0; i < ndatos; i++) {
Instance inst = IS.getInstance(i);
X[i][0] = new String(String.valueOf(inst.getAllOutputValues()[0]));
SVMn = new svm_node[Attributes.getInputNumAttributes() + 1];
for (int n = 0; n < Attributes.getInputNumAttributes(); n++) {
SVMn[n] = new svm_node();
SVMn[n].index = n;
SVMn[n].value = inst.getAllInputValues()[n];
}
SVMn[nentradas] = new svm_node();
SVMn[nentradas].index = -1;
// pedict the class
X[i][1] = new String(String.valueOf(svm.svm_predict(svr, SVMn)));
}
} catch (Exception e) {
System.out.println("Dataset exception = " + e);
e.printStackTrace();
System.exit(-1);
}
System.out.println("escribiendo test");
write_results(output_test_name);
}
public svm_problem do_sample(svm_problem svmProblem) {
logger.debug("Creating " + sample + " sample");
Map<Double, List<Integer>> label2index = new HashMap<Double, List<Integer>>();
for (int i = 0; i < svmProblem.l; ++i) {
double label = svmProblem.y[i];
if (label2index.containsKey(label)) {
label2index.get(label).add(i);
} else {
List<Integer> indeces = new LinkedList<Integer>();
indeces.add(i);
label2index.put(label, indeces);
}
}
for (List<Integer> indeces : label2index.values()) {
Collections.shuffle(indeces);
}
int newSize = (int) (svmProblem.l * sample);
logger.debug("Original size: " + svmProblem.l);
logger.debug("Sample size: " + newSize);
double[] newlabels = new double[newSize];
svm_node[][] newdata = new svm_node[newSize][];
int i = 0;
for (List<Integer> indeces : label2index.values()) {
int catSize = (int) (indeces.size() * sample);
for (int j = 0; j < catSize; ++j) {
int index = indeces.remove(0);
newlabels[i] = svmProblem.y[index];
newdata[i] = svmProblem.x[index];
if (++i >= newSize) {
break;
}
}
if (i >= newSize) {
break;
}
}
// fill any remaining empty items caused due to rounding
if (i < newSize) {
for (List<Integer> indeces : label2index.values()) {
if (indeces.isEmpty()) {
continue;
}
int index = indeces.remove(0);
newlabels[i] = svmProblem.y[index];
newdata[i] = svmProblem.x[index];
if (++i >= newSize) {
break;
}
}
}
svm_problem newProblem = new svm_problem();
newProblem.l = newSize;
newProblem.x = newdata;
newProblem.y = newlabels;
return newProblem;
}
//
// Interface functions
//
public static svm_model svm_train(svm_problem prob, svm_parameter param)
{
svm_model model = new svm_model();
model.param = param;
if(param.svm_type == svm_parameter.ONE_CLASS ||
param.svm_type == svm_parameter.EPSILON_SVR ||
param.svm_type == svm_parameter.NU_SVR)
{
// regression or one-class-svm
model.nr_class = 2;
model.label = null;
model.nSV = null;
model.sv_coef = new double[1][];
decision_function f = svm_train_one(prob,param,0,0);
model.rho = new double[1];
model.rho[0] = f.rho;
int nSV = 0;
int i;
for(i=0;i<prob.l;i++)
if(Math.abs(f.alpha[i]) > 0) ++nSV;
model.l = nSV;
model.SV = new svm_node[nSV][];
model.sv_coef[0] = new double[nSV];
int j = 0;
for(i=0;i<prob.l;i++)
if(Math.abs(f.alpha[i]) > 0)
{
model.SV[j] = prob.x[i];
model.sv_coef[0][j] = f.alpha[i];
++j;
}
}
else
{
// classification
// find out the number of classes
int l = prob.l;
int max_nr_class = 16;
int nr_class = 0;
int[] label = new int[max_nr_class];
int[] count = new int[max_nr_class];
int[] index = new int[l];
int i;
for(i=0;i<l;i++)
{
int this_label = (int)prob.y[i];
int j;
for(j=0;j<nr_class;j++)
if(this_label == label[j])
{
++count[j];
break;
}
index[i] = j;
if(j == nr_class)
{
if(nr_class == max_nr_class)
{
max_nr_class *= 2;
int[] new_data = new int[max_nr_class];
System.arraycopy(label,0,new_data,0,label.length);
label = new_data;
new_data = new int[max_nr_class];
System.arraycopy(count,0,new_data,0,count.length);
count = new_data;
}
label[nr_class] = this_label;
count[nr_class] = 1;
++nr_class;
}
}
// group training data of the same class
int[] start = new int[nr_class];
start[0] = 0;
for(i=1;i<nr_class;i++)
start[i] = start[i-1]+count[i-1];
svm_node[][] x = new svm_node[l][];
for(i=0;i<l;i++)
{
x[start[index[i]]] = prob.x[i];
++start[index[i]];
}
start[0] = 0;
for(i=1;i<nr_class;i++)
start[i] = start[i-1]+count[i-1];
// calculate weighted C
double[] weighted_C = new double[nr_class];
for(i=0;i<nr_class;i++)
weighted_C[i] = param.C;
for(i=0;i<param.nr_weight;i++)
{
int j;
for(j=0;j<nr_class;j++)
if(param.weight_label[i] == label[j])
break;
if(j == nr_class)
System.err.print("warning: class label "+param.weight_label[i]+" specified in weight is not found\n");
else
weighted_C[j] *= param.weight[i];
}
// train n*(n-1)/2 models
boolean[] nonzero = new boolean[l];
for(i=0;i<l;i++)
nonzero[i] = false;
decision_function[] f = new decision_function[nr_class*(nr_class-1)/2];
int p = 0;
for(i=0;i<nr_class;i++)
for(int j=i+1;j<nr_class;j++)
{
svm_problem sub_prob = new svm_problem();
int si = start[i], sj = start[j];
int ci = count[i], cj = count[j];
sub_prob.l = ci+cj;
sub_prob.x = new svm_node[sub_prob.l][];
sub_prob.y = new double[sub_prob.l];
int k;
for(k=0;k<ci;k++)
{
sub_prob.x[k] = x[si+k];
sub_prob.y[k] = +1;
}
for(k=0;k<cj;k++)
{
sub_prob.x[ci+k] = x[sj+k];
sub_prob.y[ci+k] = -1;
}
f[p] = svm_train_one(sub_prob,param,weighted_C[i],weighted_C[j]);
for(k=0;k<ci;k++)
if(!nonzero[si+k] && Math.abs(f[p].alpha[k]) > 0)
nonzero[si+k] = true;
for(k=0;k<cj;k++)
if(!nonzero[sj+k] && Math.abs(f[p].alpha[ci+k]) > 0)
nonzero[sj+k] = true;
++p;
}
// build output
model.nr_class = nr_class;
model.label = new int[nr_class];
for(i=0;i<nr_class;i++)
model.label[i] = label[i];
model.rho = new double[nr_class*(nr_class-1)/2];
for(i=0;i<nr_class*(nr_class-1)/2;i++)
model.rho[i] = f[i].rho;
int nnz = 0;
int[] nz_count = new int[nr_class];
model.nSV = new int[nr_class];
for(i=0;i<nr_class;i++)
{
int nSV = 0;
for(int j=0;j<count[i];j++)
if(nonzero[start[i]+j])
{
++nSV;
++nnz;
}
model.nSV[i] = nSV;
nz_count[i] = nSV;
}
System.out.print("Total nSV = "+nnz+"\n");
model.l = nnz;
model.SV = new svm_node[nnz][];
p = 0;
for(i=0;i<l;i++)
if(nonzero[i]) model.SV[p++] = x[i];
int[] nz_start = new int[nr_class];
nz_start[0] = 0;
for(i=1;i<nr_class;i++)
nz_start[i] = nz_start[i-1]+nz_count[i-1];
model.sv_coef = new double[nr_class-1][];
for(i=0;i<nr_class-1;i++)
model.sv_coef[i] = new double[nnz];
p = 0;
for(i=0;i<nr_class;i++)
for(int j=i+1;j<nr_class;j++)
{
// classifier (i,j): coefficients with
// i are in sv_coef[j-1][nz_start[i]...],
// j are in sv_coef[i][nz_start[j]...]
int si = start[i];
int sj = start[j];
int ci = count[i];
int cj = count[j];
int q = nz_start[i];
int k;
for(k=0;k<ci;k++)
if(nonzero[si+k])
model.sv_coef[j-1][q++] = f[p].alpha[k];
q = nz_start[j];
for(k=0;k<cj;k++)
if(nonzero[sj+k])
model.sv_coef[i][q++] = f[p].alpha[ci+k];
++p;
}
}
return model;
}
public svm_problem loadData(CollectionReader cr) {
logger.debug("Loading " + cr.getSize() + " documents.");
List<svm_node[]> data = new LinkedList<svm_node[]>();
List<Set<String>> labels = new LinkedList<Set<String>>();
Set<String> allLabels = new HashSet<String>();
for (Analyzable a : cr) {
CategorizedTextContent ctc = (CategorizedTextContent) a;
Set<String> categories;
if (targetClass == null) {
categories = ctc.getCategories();
} else {
categories = new HashSet<String>();
if (ctc.getCategories().contains(targetClass)) {
// Not adding any other categories if item belongs to targetClass as well as some other
// category.
categories.add(targetClass);
} else {
categories.add("other");
}
}
labels.add(categories);
allLabels.addAll(categories);
data.add(representer.represent(ctc.getText()).toSvmNodes());
}
representer.shutdown();
labelList = new ArrayList<String>(allLabels);
Collections.sort(labelList);
logger.debug("Total labels: " + labelList.size());
logger.trace("Labels: " + labelList);
int numberOfExpandedData = 0;
for (Set<String> ls : labels) {
numberOfExpandedData += ls.size();
}
// Scale data
logger.debug("Scaling data.");
scaler = new ValueScaler(0, 1, data.toArray(new svm_node[0][]));
svm_node[][] scaledData = scaler.getScaledData();
// For every label, generate a copy of the data item.
logger.debug("Generating " + numberOfExpandedData + " records.");
svm_node[][] expandedData = new svm_node[numberOfExpandedData][];
double[] expandedLabels = new double[numberOfExpandedData];
int i = 0;
int xi = 0;
for (svm_node[] dataItem : scaledData) {
Set<String> trueLabels = labels.get(i++);
for (String label : trueLabels) {
double labelIndex = labelList.indexOf(label);
expandedData[xi] = dataItem.clone();
expandedLabels[xi++] = labelIndex;
}
}
svm_problem svmProblem = new svm_problem();
svmProblem.l = numberOfExpandedData;
svmProblem.x = expandedData;
svmProblem.y = expandedLabels;
return svmProblem;
}
