private static SupportVectorClassificationSolution SvmGridSearch(IClassificationProblemData problemData, out svm_parameter bestParameters, out int nSv, out double cvMse) {
bestParameters = SupportVectorMachineUtil.GridSearch(out cvMse, problemData, svmParameterRanges, numberOfFolds, shuffleFolds, maximumDegreeOfParallelism);
double trainingError, testError;
string svmType = svmTypes[bestParameters.svm_type];
string kernelType = kernelTypes[bestParameters.kernel_type];
var svm_solution = SupportVectorClassification.CreateSupportVectorClassificationSolution(problemData, problemData.AllowedInputVariables, svmType, kernelType,
bestParameters.C, bestParameters.nu, bestParameters.gamma, bestParameters.degree, out trainingError, out testError, out nSv);
return svm_solution;
}
public Kernel(int l, svm_node[][] x_, svm_parameter param) {
this.kernel_type = param.kernel_type;
this.degree = param.degree;
this.gamma = param.gamma;
this.coef0 = param.coef0;
x = (svm_node[][])x_.Clone();
if (kernel_type == svm_parameter.RBF) {
x_square = new double[l];
for (int i = 0; i < l; i++)
x_square[i] = dot(x[i], x[i]);
} else x_square = null;
}
// Stratified cross validation
public static void svm_cross_validation(svm_problem prob, svm_parameter param, int nr_fold, double[] target) {
int i;
int[] fold_start = new int[nr_fold + 1];
int l = prob.l;
int[] perm = new int[l];
// stratified cv may not give leave-one-out rate
// Each class to l folds -> some folds may have zero elements
if ((param.svm_type == svm_parameter.C_SVC ||
param.svm_type == svm_parameter.NU_SVC) && nr_fold < l) {
int[] tmp_nr_class = new int[1];
int[][] tmp_label = new int[1][];
int[][] tmp_start = new int[1][];
int[][] tmp_count = new int[1][];
svm_group_classes(prob, tmp_nr_class, tmp_label, tmp_start, tmp_count, perm);
int nr_class = tmp_nr_class[0];
int[] start = tmp_start[0];
int[] count = tmp_count[0];
// random shuffle and then data grouped by fold using the array perm
int[] fold_count = new int[nr_fold];
int c;
int[] index = new int[l];
for (i = 0; i < l; i++)
index[i] = perm[i];
for (c = 0; c < nr_class; c++)
for (i = 0; i < count[c]; i++) {
int j = i + rand.Next(count[c] - i);
{
int _ = index[start[c] + j];
index[start[c] + j] = index[start[c] + i];
index[start[c] + i] = _;
}
}
for (i = 0; i < nr_fold; i++) {
fold_count[i] = 0;
for (c = 0; c < nr_class; c++)
fold_count[i] += (i + 1) * count[c] / nr_fold - i * count[c] / nr_fold;
}
fold_start[0] = 0;
for (i = 1; i <= nr_fold; i++)
fold_start[i] = fold_start[i - 1] + fold_count[i - 1];
for (c = 0; c < nr_class; c++)
for (i = 0; i < nr_fold; i++) {
int begin = start[c] + i * count[c] / nr_fold;
int end = start[c] + (i + 1) * count[c] / nr_fold;
for (int j = begin; j < end; j++) {
perm[fold_start[i]] = index[j];
fold_start[i]++;
}
}
fold_start[0] = 0;
for (i = 1; i <= nr_fold; i++)
fold_start[i] = fold_start[i - 1] + fold_count[i - 1];
} else {
for (i = 0; i < l; i++) perm[i] = i;
for (i = 0; i < l; i++) {
int j = i + rand.Next(l - i);
{
int _ = perm[i];
perm[i] = perm[j];
perm[j] = _;
}
}
for (i = 0; i <= nr_fold; i++)
fold_start[i] = i * l / nr_fold;
}
for (i = 0; i < nr_fold; i++) {
int begin = fold_start[i];
int end = fold_start[i + 1];
int j, k;
svm_problem subprob = new svm_problem();
subprob.l = l - (end - begin);
subprob.x = new svm_node[subprob.l][];
subprob.y = new double[subprob.l];
k = 0;
for (j = 0; j < begin; j++) {
subprob.x[k] = prob.x[perm[j]];
subprob.y[k] = prob.y[perm[j]];
++k;
}
for (j = end; j < l; j++) {
subprob.x[k] = prob.x[perm[j]];
subprob.y[k] = prob.y[perm[j]];
++k;
}
svm_model submodel = svm_train(subprob, param);
if (param.probability == 1 &&
(param.svm_type == svm_parameter.C_SVC ||
param.svm_type == svm_parameter.NU_SVC)) {
double[] prob_estimates = new double[svm_get_nr_class(submodel)];
for (j = begin; j < end; j++)
target[perm[j]] = svm_predict_probability(submodel, prob.x[perm[j]], prob_estimates);
} else
for (j = begin; j < end; j++)
target[perm[j]] = svm_predict(submodel, prob.x[perm[j]]);
}
}
//
// 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.probA = null;
model.probB = null;
model.sv_coef = new double[1][];
if (param.probability == 1 &&
(param.svm_type == svm_parameter.EPSILON_SVR ||
param.svm_type == svm_parameter.NU_SVR)) {
model.probA = new double[1];
model.probA[0] = svm_svr_probability(prob, param);
}
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
int l = prob.l;
int[] tmp_nr_class = new int[1];
int[][] tmp_label = new int[1][];
int[][] tmp_start = new int[1][];
int[][] tmp_count = new int[1][];
int[] perm = new int[l];
// group training data of the same class
svm_group_classes(prob, tmp_nr_class, tmp_label, tmp_start, tmp_count, perm);
int nr_class = tmp_nr_class[0];
int[] label = tmp_label[0];
int[] start = tmp_start[0];
int[] count = tmp_count[0];
if (nr_class == 1)
svm.info("WARNING: training data in only one class. See README for details." + Environment.NewLine);
svm_node[][] x = new svm_node[l][];
int i;
for (i = 0; i < l; i++)
x[i] = prob.x[perm[i]];
// 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)
Console.Error.WriteLine("WARNING: class label " + param.weight_label[i] +
" specified in weight is not found");
else
weighted_C[j] *= param.weight[i];
}
// train k*(k-1)/2 models
bool[] nonzero = new bool[l];
for (i = 0; i < l; i++)
nonzero[i] = false;
decision_function[] f = new decision_function[nr_class * (nr_class - 1) / 2];
double[] probA = null, probB = null;
if (param.probability == 1) {
probA = new double[nr_class * (nr_class - 1) / 2];
probB = new double[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;
}
if (param.probability == 1) {
double[] probAB = new double[2];
svm_binary_svc_probability(sub_prob, param, weighted_C[i], weighted_C[j], probAB);
probA[p] = probAB[0];
probB[p] = probAB[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;
if (param.probability == 1) {
model.probA = new double[nr_class * (nr_class - 1) / 2];
model.probB = new double[nr_class * (nr_class - 1) / 2];
for (i = 0; i < nr_class * (nr_class - 1) / 2; i++) {
model.probA[i] = probA[i];
model.probB[i] = probB[i];
}
} else {
model.probA = null;
model.probB = null;
}
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;
}
svm.info("Total nSV = " + nnz + Environment.NewLine);
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;
}
// Return parameter of a Laplace distribution
private static double svm_svr_probability(svm_problem prob, svm_parameter param) {
int i;
int nr_fold = 5;
double[] ymv = new double[prob.l];
double mae = 0;
svm_parameter newparam = (svm_parameter)param.Clone();
newparam.probability = 0;
svm_cross_validation(prob, newparam, nr_fold, ymv);
for (i = 0; i < prob.l; i++) {
ymv[i] = prob.y[i] - ymv[i];
mae += Math.Abs(ymv[i]);
}
mae /= prob.l;
double std = Math.Sqrt(2 * mae * mae);
int count = 0;
mae = 0;
for (i = 0; i < prob.l; i++)
if (Math.Abs(ymv[i]) > 5 * std)
count = count + 1;
else
mae += Math.Abs(ymv[i]);
mae /= (prob.l - count);
svm.info("Prob. model for test data: target value = predicted value + z, " + Environment.NewLine
+ "z: Laplace distribution e^(-|z|/sigma)/(2sigma),sigma=" + mae + Environment.NewLine);
return mae;
}
// Cross-validation decision values for probability estimates
private static void svm_binary_svc_probability(svm_problem prob, svm_parameter param, double Cp, double Cn,
double[] probAB) {
int i;
int nr_fold = 5;
int[] perm = new int[prob.l];
double[] dec_values = new double[prob.l];
// random shuffle
for (i = 0; i < prob.l; i++) perm[i] = i;
for (i = 0; i < prob.l; i++) {
int j = i + rand.Next(prob.l - i);
{
int _ = perm[i];
perm[i] = perm[j];
perm[j] = _;
}
}
for (i = 0; i < nr_fold; i++) {
int begin = i * prob.l / nr_fold;
int end = (i + 1) * prob.l / nr_fold;
int j, k;
svm_problem subprob = new svm_problem();
subprob.l = prob.l - (end - begin);
subprob.x = new svm_node[subprob.l][];
subprob.y = new double[subprob.l];
k = 0;
for (j = 0; j < begin; j++) {
subprob.x[k] = prob.x[perm[j]];
subprob.y[k] = prob.y[perm[j]];
++k;
}
for (j = end; j < prob.l; j++) {
subprob.x[k] = prob.x[perm[j]];
subprob.y[k] = prob.y[perm[j]];
++k;
}
int p_count = 0, n_count = 0;
for (j = 0; j < k; j++)
if (subprob.y[j] > 0)
p_count++;
else
n_count++;
if (p_count == 0 && n_count == 0)
for (j = begin; j < end; j++)
dec_values[perm[j]] = 0;
else if (p_count > 0 && n_count == 0)
for (j = begin; j < end; j++)
dec_values[perm[j]] = 1;
else if (p_count == 0 && n_count > 0)
for (j = begin; j < end; j++)
dec_values[perm[j]] = -1;
else {
svm_parameter subparam = (svm_parameter)param.Clone();
subparam.probability = 0;
subparam.C = 1.0;
subparam.nr_weight = 2;
subparam.weight_label = new int[2];
subparam.weight = new double[2];
subparam.weight_label[0] = +1;
subparam.weight_label[1] = -1;
subparam.weight[0] = Cp;
subparam.weight[1] = Cn;
svm_model submodel = svm_train(subprob, subparam);
for (j = begin; j < end; j++) {
double[] dec_value = new double[1];
svm_predict_values(submodel, prob.x[perm[j]], dec_value);
dec_values[perm[j]] = dec_value[0];
// ensure +1 -1 order; reason not using CV subroutine
dec_values[perm[j]] *= submodel.label[0];
}
}
}
sigmoid_train(prob.l, dec_values, prob.y, probAB);
}
public SVC_Q(svm_problem prob, svm_parameter param, short[] y_)
: base(prob.l, prob.x, param) {
y = (short[])y_.Clone();
cache = new Cache(prob.l, (long)(param.cache_size * (1 << 20)));
QD = new double[prob.l];
for (int i = 0; i < prob.l; i++)
QD[i] = kernel_function(i, i);
}
public static string svm_check_parameter(svm_problem prob, svm_parameter param) {
// svm_type
int svm_type = param.svm_type;
if (svm_type != svm_parameter.C_SVC &&
svm_type != svm_parameter.NU_SVC &&
svm_type != svm_parameter.ONE_CLASS &&
svm_type != svm_parameter.EPSILON_SVR &&
svm_type != svm_parameter.NU_SVR)
return "unknown svm type";
// kernel_type, degree
int kernel_type = param.kernel_type;
if (kernel_type != svm_parameter.LINEAR &&
kernel_type != svm_parameter.POLY &&
kernel_type != svm_parameter.RBF &&
kernel_type != svm_parameter.SIGMOID &&
kernel_type != svm_parameter.PRECOMPUTED)
return "unknown kernel type";
if (param.gamma < 0)
return "gamma < 0";
if (param.degree < 0)
return "degree of polynomial kernel < 0";
// cache_size,eps,C,nu,p,shrinking
if (param.cache_size <= 0)
return "cache_size <= 0";
if (param.eps <= 0)
return "eps <= 0";
if (svm_type == svm_parameter.C_SVC ||
svm_type == svm_parameter.EPSILON_SVR ||
svm_type == svm_parameter.NU_SVR)
if (param.C <= 0)
return "C <= 0";
if (svm_type == svm_parameter.NU_SVC ||
svm_type == svm_parameter.ONE_CLASS ||
svm_type == svm_parameter.NU_SVR)
if (param.nu <= 0 || param.nu > 1)
return "nu <= 0 or nu > 1";
if (svm_type == svm_parameter.EPSILON_SVR)
if (param.p < 0)
return "p < 0";
if (param.shrinking != 0 &&
param.shrinking != 1)
return "shrinking != 0 and shrinking != 1";
if (param.probability != 0 &&
param.probability != 1)
return "probability != 0 and probability != 1";
if (param.probability == 1 &&
svm_type == svm_parameter.ONE_CLASS)
return "one-class SVM probability output not supported yet";
// check whether nu-svc is feasible
if (svm_type == svm_parameter.NU_SVC) {
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 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;
}
if (j == nr_class) {
if (nr_class == max_nr_class) {
max_nr_class *= 2;
int[] new_data = new int[max_nr_class];
Array.Copy(label, 0, new_data, 0, label.Length);
label = new_data;
new_data = new int[max_nr_class];
Array.Copy(count, 0, new_data, 0, count.Length);
count = new_data;
}
label[nr_class] = this_label;
count[nr_class] = 1;
++nr_class;
}
}
for (i = 0; i < nr_class; i++) {
int n1 = count[i];
for (int j = i + 1; j < nr_class; j++) {
int n2 = count[j];
if (param.nu * (n1 + n2) / 2 > Math.Min(n1, n2))
return "specified nu is infeasible";
}
}
}
return null;
}
private static void solve_epsilon_svr(svm_problem prob, svm_parameter param,
double[] alpha, Solver.SolutionInfo si) {
int l = prob.l;
double[] alpha2 = new double[2 * l];
double[] linear_term = new double[2 * l];
short[] y = new short[2 * l];
int i;
for (i = 0; i < l; i++) {
alpha2[i] = 0;
linear_term[i] = param.p - prob.y[i];
y[i] = 1;
alpha2[i + l] = 0;
linear_term[i + l] = param.p + prob.y[i];
y[i + l] = -1;
}
Solver s = new Solver();
s.Solve(2 * l, new SVR_Q(prob, param), linear_term, y,
alpha2, param.C, param.C, param.eps, si, param.shrinking);
double sum_alpha = 0;
for (i = 0; i < l; i++) {
alpha[i] = alpha2[i] - alpha2[i + l];
sum_alpha += Math.Abs(alpha[i]);
}
svm.info("nu = " + sum_alpha / (param.C * l) + Environment.NewLine);
}
private static void solve_one_class(svm_problem prob, svm_parameter param,
double[] alpha, Solver.SolutionInfo si) {
int l = prob.l;
double[] zeros = new double[l];
short[] ones = new short[l];
int i;
int n = (int)(param.nu * prob.l); // # of alpha's at upper bound
for (i = 0; i < n; i++)
alpha[i] = 1;
if (n < prob.l)
alpha[n] = param.nu * prob.l - n;
for (i = n + 1; i < l; i++)
alpha[i] = 0;
for (i = 0; i < l; i++) {
zeros[i] = 0;
ones[i] = 1;
}
Solver s = new Solver();
s.Solve(l, new ONE_CLASS_Q(prob, param), zeros, ones,
alpha, 1.0, 1.0, param.eps, si, param.shrinking);
}
private static void solve_nu_svc(svm_problem prob, svm_parameter param,
double[] alpha, Solver.SolutionInfo si) {
int i;
int l = prob.l;
double nu = param.nu;
short[] y = new short[l];
for (i = 0; i < l; i++)
if (prob.y[i] > 0)
y[i] = +1;
else
y[i] = -1;
double sum_pos = nu * l / 2;
double sum_neg = nu * l / 2;
for (i = 0; i < l; i++)
if (y[i] == +1) {
alpha[i] = Math.Min(1.0, sum_pos);
sum_pos -= alpha[i];
} else {
alpha[i] = Math.Min(1.0, sum_neg);
sum_neg -= alpha[i];
}
double[] zeros = new double[l];
for (i = 0; i < l; i++)
zeros[i] = 0;
Solver_NU s = new Solver_NU();
s.Solve(l, new SVC_Q(prob, param, y), zeros, y,
alpha, 1.0, 1.0, param.eps, si, param.shrinking);
double r = si.r;
svm.info("C = " + 1 / r + Environment.NewLine);
for (i = 0; i < l; i++)
alpha[i] *= y[i] / r;
si.rho /= r;
si.obj /= (r * r);
si.upper_bound_p = 1 / r;
si.upper_bound_n = 1 / r;
}
private static void solve_c_svc(svm_problem prob, svm_parameter param,
double[] alpha, Solver.SolutionInfo si,
double Cp, double Cn) {
int l = prob.l;
double[] minus_ones = new double[l];
short[] y = new short[l];
int i;
for (i = 0; i < l; i++) {
alpha[i] = 0;
minus_ones[i] = -1;
if (prob.y[i] > 0) y[i] = +1;
else y[i] = -1;
}
Solver s = new Solver();
s.Solve(l, new SVC_Q(prob, param, y), minus_ones, y,
alpha, Cp, Cn, param.eps, si, param.shrinking);
double sum_alpha = 0;
for (i = 0; i < l; i++)
sum_alpha += alpha[i];
if (Cp == Cn)
svm.info("nu = " + sum_alpha / (Cp * prob.l) + Environment.NewLine);
for (i = 0; i < l; i++)
alpha[i] *= y[i];
}
public SVR_Q(svm_problem prob, svm_parameter param)
: base(prob.l, prob.x, param) {
l = prob.l;
cache = new Cache(l, (long)(param.cache_size * (1 << 20)));
QD = new double[2 * l];
sign = new short[2 * l];
index = new int[2 * l];
for (int k = 0; k < l; k++) {
sign[k] = 1;
sign[k + l] = -1;
index[k] = k;
index[k + l] = k;
QD[k] = kernel_function(k, k);
QD[k + l] = QD[k];
}
buffer = new float[2][];
buffer[0] = new float[2 * l];
buffer[1] = new float[2 * l];
next_buffer = 0;
}
public ONE_CLASS_Q(svm_problem prob, svm_parameter param)
: base(prob.l, prob.x, param) {
cache = new Cache(prob.l, (long)(param.cache_size * (1 << 20)));
QD = new double[prob.l];
for (int i = 0; i < prob.l; i++)
QD[i] = kernel_function(i, i);
}
public static svm_model svm_load_model(StreamReader reader) {
var savedCulture = Thread.CurrentThread.CurrentCulture;
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
// read parameters
svm_model model = new svm_model();
svm_parameter param = new svm_parameter();
model.param = param;
model.rho = null;
model.probA = null;
model.probB = null;
model.label = null;
model.nSV = null;
while (true) {
String cmd = reader.ReadLine();
String arg = cmd.Substring(cmd.IndexOf(' ') + 1);
if (cmd.StartsWith("svm_type")) {
int i;
for (i = 0; i < svm_type_table.Length; i++) {
if (arg.IndexOf(svm_type_table[i], StringComparison.InvariantCultureIgnoreCase) != -1) {
param.svm_type = i;
break;
}
}
if (i == svm_type_table.Length) {
Console.Error.WriteLine("unknown svm type.");
return null;
}
} else if (cmd.StartsWith("kernel_type")) {
int i;
for (i = 0; i < kernel_type_table.Length; i++) {
if (arg.IndexOf(kernel_type_table[i], StringComparison.InvariantCultureIgnoreCase) != -1) {
param.kernel_type = i;
break;
}
}
if (i == kernel_type_table.Length) {
Console.Error.WriteLine("unknown kernel function.");
return null;
}
} else if (cmd.StartsWith("degree"))
param.degree = atoi(arg);
else if (cmd.StartsWith("gamma"))
param.gamma = atof(arg);
else if (cmd.StartsWith("coef0"))
param.coef0 = atof(arg);
else if (cmd.StartsWith("nr_class"))
model.nr_class = atoi(arg);
else if (cmd.StartsWith("total_sv"))
model.l = atoi(arg);
else if (cmd.StartsWith("rho")) {
int n = model.nr_class * (model.nr_class - 1) / 2;
model.rho = new double[n];
var st = arg.Split(' ', '\t', '\n', '\r', '\f');
for (int i = 0; i < n; i++)
model.rho[i] = atof(st[i]);
} else if (cmd.StartsWith("label")) {
int n = model.nr_class;
model.label = new int[n];
var st = arg.Split(' ', '\t', '\n', '\r', '\f');
for (int i = 0; i < n; i++)
model.label[i] = atoi(st[i]);
} else if (cmd.StartsWith("probA")) {
int n = model.nr_class * (model.nr_class - 1) / 2;
model.probA = new double[n];
var st = arg.Split(' ', '\t', '\n', '\r', '\f');
for (int i = 0; i < n; i++)
model.probA[i] = atof(st[i]);
} else if (cmd.StartsWith("probB")) {
int n = model.nr_class * (model.nr_class - 1) / 2;
model.probB = new double[n];
var st = arg.Split(' ', '\t', '\n', '\r', '\f');
for (int i = 0; i < n; i++)
model.probB[i] = atof(st[i]);
} else if (cmd.StartsWith("nr_sv")) {
int n = model.nr_class;
model.nSV = new int[n];
var st = arg.Split(' ', '\t', '\n', '\r', '\f');
for (int i = 0; i < n; i++)
model.nSV[i] = atoi(st[i]);
} else if (cmd.StartsWith("SV")) {
break;
} else {
Console.Error.WriteLine("unknown text in model file: [" + cmd + "]");
return null;
}
}
// read sv_coef and SV
int m = model.nr_class - 1;
int l = model.l;
model.sv_coef = new double[m][];
for (int k = 0; k < m; k++)
model.sv_coef[k] = new double[l];
model.SV = new svm_node[l][];
for (int i = 0; i < l; i++) {
String line = reader.ReadLine();
var st = line.Split(' ', '\t', '\n', '\r', '\f', ':');
for (int k = 0; k < m; k++) {
model.sv_coef[k][i] = atof(st[k]);
}
// skip y value
st = st.Skip(1).ToArray();
int n = st.Length / 2;
model.SV[i] = new svm_node[n];
for (int j = 0; j < n; j++) {
model.SV[i][j] = new svm_node();
model.SV[i][j].index = atoi(st[2 * j]);
model.SV[i][j].value = atof(st[2 * j + 1]);
}
}
Thread.CurrentThread.CurrentCulture = savedCulture;
return model;
}
public static double k_function(svm_node[] x, svm_node[] y,
svm_parameter param) {
switch (param.kernel_type) {
case svm_parameter.LINEAR:
return dot(x, y);
case svm_parameter.POLY:
return powi(param.gamma * dot(x, y) + param.coef0, param.degree);
case svm_parameter.RBF: {
double sum = 0;
int xlen = x.Length;
int ylen = y.Length;
int i = 0;
int j = 0;
while (i < xlen && j < ylen) {
if (x[i].index == y[j].index) {
double d = x[i++].value - y[j++].value;
sum += d * d;
} else if (x[i].index > y[j].index) {
sum += y[j].value * y[j].value;
++j;
} else {
sum += x[i].value * x[i].value;
++i;
}
}
while (i < xlen) {
sum += x[i].value * x[i].value;
++i;
}
while (j < ylen) {
sum += y[j].value * y[j].value;
++j;
}
return Math.Exp(-param.gamma * sum);
}
case svm_parameter.SIGMOID:
return Math.Tanh(param.gamma * dot(x, y) + param.coef0);
case svm_parameter.PRECOMPUTED:
return x[(int)(y[0].value)].value;
default:
return 0; // java
}
}
private static void solve_nu_svr(svm_problem prob, svm_parameter param,
double[] alpha, Solver.SolutionInfo si) {
int l = prob.l;
double C = param.C;
double[] alpha2 = new double[2 * l];
double[] linear_term = new double[2 * l];
short[] y = new short[2 * l];
int i;
double sum = C * param.nu * l / 2;
for (i = 0; i < l; i++) {
alpha2[i] = alpha2[i + l] = Math.Min(sum, C);
sum -= alpha2[i];
linear_term[i] = -prob.y[i];
y[i] = 1;
linear_term[i + l] = prob.y[i];
y[i + l] = -1;
}
Solver_NU s = new Solver_NU();
s.Solve(2 * l, new SVR_Q(prob, param), linear_term, y,
alpha2, C, C, param.eps, si, param.shrinking);
svm.info("epsilon = " + (-si.r) + Environment.NewLine);
for (i = 0; i < l; i++)
alpha[i] = alpha2[i] - alpha2[i + l];
}
public int probability; // do probability estimates
public virtual object Clone() {
var clone = new svm_parameter();
clone.svm_type = svm_type;
clone.kernel_type = kernel_type;
clone.degree = degree;
clone.gamma = gamma;
clone.coef0 = coef0;
clone.cache_size = cache_size;
clone.eps = eps;
clone.C = C;
clone.nr_weight = nr_weight;
if (weight_label != null) {
clone.weight_label = new int[weight_label.Length];
Array.Copy(weight_label, clone.weight_label, weight_label.Length);
}
if (weight != null) {
clone.weight = new double[weight.Length];
Array.Copy(weight, clone.weight, weight.Length);
}
clone.nu = nu;
clone.p = p;
clone.shrinking = shrinking;
clone.probability = probability;
return clone;
}
private static decision_function svm_train_one(
svm_problem prob, svm_parameter param,
double Cp, double Cn) {
double[] alpha = new double[prob.l];
Solver.SolutionInfo si = new Solver.SolutionInfo();
switch (param.svm_type) {
case svm_parameter.C_SVC:
solve_c_svc(prob, param, alpha, si, Cp, Cn);
break;
case svm_parameter.NU_SVC:
solve_nu_svc(prob, param, alpha, si);
break;
case svm_parameter.ONE_CLASS:
solve_one_class(prob, param, alpha, si);
break;
case svm_parameter.EPSILON_SVR:
solve_epsilon_svr(prob, param, alpha, si);
break;
case svm_parameter.NU_SVR:
solve_nu_svr(prob, param, alpha, si);
break;
}
svm.info("obj = " + si.obj + ", rho = " + si.rho + Environment.NewLine);
// output SVs
int nSV = 0;
int nBSV = 0;
for (int i = 0; i < prob.l; i++) {
if (Math.Abs(alpha[i]) > 0) {
++nSV;
if (prob.y[i] > 0) {
if (Math.Abs(alpha[i]) >= si.upper_bound_p)
++nBSV;
} else {
if (Math.Abs(alpha[i]) >= si.upper_bound_n)
++nBSV;
}
}
}
svm.info("nSV = " + nSV + ", nBSV = " + nBSV + Environment.NewLine);
decision_function f = new decision_function();
f.alpha = alpha;
f.rho = si.rho;
return f;
}
