public svm_model initial(List <Dictionary <string, double> > docWordDicList, Dictionary <string, int> dictionary, List <int> trainingAnswer, double c, double gamma)
{
Console.WriteLine("==> Starting training...");
svm_problem prob = gen_svm_training_data(docWordDicList, dictionary, trainingAnswer);
svm_parameter param = new svm_parameter();
// set the default setting value
param.svm_type = svm_parameter.C_SVC;
param.kernel_type = svm_parameter.RBF;
param.degree = 3;
param.gamma = gamma;
param.coef0 = 0;
param.nu = 0.5;
param.cache_size = 100;
param.C = c;
param.eps = 1e-3;
param.p = 0.1;
param.shrinking = 1;
param.probability = 0;
param.nr_weight = 0;
svm_model model = svm.svm_train(prob, param);
svm.svm_save_model(SVM_MODEL_FILE_NAME, model);
Console.WriteLine("==> Training done!!");
return(model);
}
public static SVMParameter Convert(svm_parameter x)
{
SVMParameter y = new SVMParameter();
y.Type = (SVMType)x.svm_type;
y.Kernel = (SVMKernelType)x.kernel_type;
y.Degree = x.degree;
y.Gamma = x.gamma;
y.Coef0 = x.coef0;
y.CacheSize = x.cache_size;
y.Eps = x.eps;
y.C = x.C;
y.Nu = x.nu;
y.P = x.p;
y.Shrinking = x.shrinking != 0;
y.Probability = x.probability != 0;
int length = x.nr_weight;
y.WeightLabels = new int[length];
if (length > 0)
{
Marshal.Copy(x.weight_label, y.WeightLabels, 0, length);
}
y.Weights = new double[length];
if (length > 0)
{
Marshal.Copy(x.weight, y.Weights, 0, length);
}
return(y);
}
/// <summary>
/// Evaluate the error for the specified model.
/// </summary>
///
/// <param name="param">The params for the SVN.</param>
/// <param name="prob">The problem to evaluate.</param>
/// <param name="target">The output values from the SVN.</param>
/// <returns>The calculated error.</returns>
private static double Evaluate(svm_parameter param, svm_problem prob,
double[] target)
{
int totalCorrect = 0;
var error = new ErrorCalculation();
if ((param.svm_type == svm_parameter.EPSILON_SVR) ||
(param.svm_type == svm_parameter.NU_SVR))
{
for (int i = 0; i < prob.l; i++)
{
double ideal = prob.y[i];
double actual = target[i];
error.UpdateError(actual, ideal);
}
return(error.Calculate());
}
for (int i = 0; i < prob.l; i++)
{
if (target[i] == prob.y[i])
{
++totalCorrect;
}
}
return(Format.HundredPercent * totalCorrect / prob.l);
}
public static void Run(IRegressionProblemData problemData, IEnumerable <string> allowedInputVariables,
string svmType, string kernelType, double cost, double nu, double gamma, double epsilon, int degree,
out ISupportVectorMachineModel model, out int nSv)
{
var dataset = problemData.Dataset;
string targetVariable = problemData.TargetVariable;
IEnumerable <int> rows = problemData.TrainingIndices;
svm_parameter parameter = new svm_parameter {
svm_type = GetSvmType(svmType),
kernel_type = GetKernelType(kernelType),
C = cost,
nu = nu,
gamma = gamma,
p = epsilon,
cache_size = 500,
probability = 0,
eps = 0.001,
degree = degree,
shrinking = 1,
coef0 = 0
};
svm_problem problem = SupportVectorMachineUtil.CreateSvmProblem(dataset, targetVariable, allowedInputVariables, rows);
RangeTransform rangeTransform = RangeTransform.Compute(problem);
svm_problem scaledProblem = rangeTransform.Scale(problem);
var svmModel = svm.svm_train(scaledProblem, parameter);
nSv = svmModel.SV.Length;
model = new SupportVectorMachineModel(svmModel, rangeTransform, targetVariable, allowedInputVariables);
}
/// <summary>
/// Evaluate the error for the specified model.
/// </summary>
/// <param name="param">The params for the SVN.</param>
/// <param name="prob">The problem to evaluate.</param>
/// <param name="target">The output values from the SVN.</param>
/// <returns>The calculated error.</returns>
private double Evaluate(svm_parameter param, svm_problem prob,
double[] target)
{
int total_correct = 0;
ErrorCalculation error = new ErrorCalculation();
if (param.svm_type == svm_parameter.EPSILON_SVR ||
param.svm_type == svm_parameter.NU_SVR)
{
for (int i = 0; i < prob.l; i++)
{
double ideal = prob.y[i];
double actual = target[i];
error.UpdateError(actual, ideal);
}
return(error.Calculate());
}
else
{
for (int i = 0; i < prob.l; i++)
{
if (target[i] == prob.y[i])
{
++total_correct;
}
}
return(100.0 * total_correct / prob.l);
}
}
public static void Free(svm_parameter x)
{
Marshal.FreeHGlobal(x.weight);
x.weight = IntPtr.Zero;
Marshal.FreeHGlobal(x.weight_label);
x.weight_label = IntPtr.Zero;
}
public static SVMParameter Convert(IntPtr ptr)
{
if (ptr == IntPtr.Zero)
{
return(null);
}
svm_parameter x = (svm_parameter)Marshal.PtrToStructure(ptr, typeof(svm_parameter));
return(SVMParameter.Convert(x));
}
public static void Run(IClassificationProblemData problemData, IEnumerable <string> allowedInputVariables,
int svmType, int kernelType, double cost, double nu, double gamma, int degree,
out ISupportVectorMachineModel model, out int nSv)
{
var dataset = problemData.Dataset;
string targetVariable = problemData.TargetVariable;
IEnumerable <int> rows = problemData.TrainingIndices;
svm_parameter parameter = new svm_parameter {
svm_type = svmType,
kernel_type = kernelType,
C = cost,
nu = nu,
gamma = gamma,
cache_size = 500,
probability = 0,
eps = 0.001,
degree = degree,
shrinking = 1,
coef0 = 0
};
var weightLabels = new List <int>();
var weights = new List <double>();
foreach (double c in problemData.ClassValues)
{
double wSum = 0.0;
foreach (double otherClass in problemData.ClassValues)
{
if (!c.IsAlmost(otherClass))
{
wSum += problemData.GetClassificationPenalty(c, otherClass);
}
}
weightLabels.Add((int)c);
weights.Add(wSum);
}
parameter.weight_label = weightLabels.ToArray();
parameter.weight = weights.ToArray();
svm_problem problem = SupportVectorMachineUtil.CreateSvmProblem(dataset, targetVariable, allowedInputVariables, rows);
RangeTransform rangeTransform = RangeTransform.Compute(problem);
svm_problem scaledProblem = rangeTransform.Scale(problem);
var svmModel = svm.svm_train(scaledProblem, parameter);
nSv = svmModel.SV.Length;
model = new SupportVectorMachineModel(svmModel, rangeTransform, targetVariable, allowedInputVariables, problemData.ClassValues);
}
public static void Free(IntPtr ptr)
{
if (ptr == IntPtr.Zero)
{
return;
}
svm_parameter x = (svm_parameter)Marshal.PtrToStructure(ptr, typeof(svm_parameter));
SVMParameter.Free(x);
Marshal.DestroyStructure(ptr, typeof(svm_parameter));
Marshal.FreeHGlobal(ptr);
ptr = IntPtr.Zero;
}
/// <summary>
/// Construct a SVM from a model.
/// </summary>
///
/// <param name="theModel">The model.</param>
public SupportVectorMachine(svm_model theModel)
{
_model = theModel;
_paras = _model.param;
_inputCount = 0;
// determine the input count
foreach (var element in _model.SV)
{
foreach (svm_node t in element)
{
_inputCount = Math.Max(t.index, _inputCount);
}
}
//
}
public MaltLibsvmModel(svm_model model, svm_problem problem)
{
param = model.param;
nr_class = model.nr_class;
l = model.l;
SV = model.SV;
sv_coef = model.sv_coef;
rho = model.rho;
label = model.label;
nSV = model.nSV;
start = new int[nr_class];
start[0] = 0;
for (int i = 1; i < nr_class; i++)
{
start[i] = start[i - 1] + nSV[i - 1];
}
}
public bool LoadFromFile(string fileName)
{
if (File.Exists(fileName))
{
FileStream fs = new FileStream(fileName, FileMode.Open);
using (BinaryReader r = new BinaryReader(fs))
{
this.model = new svm_model();
svm_parameter p = new svm_parameter();
p.C = r.ReadDouble();
p.cache_size = r.ReadDouble();
p.coef0 = r.ReadDouble();
p.degree = r.ReadDouble();
p.eps = r.ReadDouble();
p.gamma = r.ReadDouble();
p.kernel_type = r.ReadInt32();
p.nr_weight = r.ReadInt32();
p.nu = r.ReadDouble();
p.p = r.ReadDouble();
p.probability = r.ReadInt32();
p.shrinking = r.ReadInt32();
p.svm_type = r.ReadInt32();
p.weight = ReadDoubleArray(r);
p.weight_label = ReadIntArray(r);
this.model.param = p;
this.model.nr_class = r.ReadInt32();
this.model.l = r.ReadInt32();
this.model.SV = ReadSvmNodeArray(r);
this.model.sv_coef = ReadDouble2DArray(r);
this.model.rho = ReadDoubleArray(r);
this.model.probA = ReadDoubleArray(r);
this.model.probB = ReadDoubleArray(r);
this.model.label = ReadIntArray(r);
this.model.nSV = ReadIntArray(r);
return(true);
}
}
this.model = null;
return(false);
}
public static IntPtr Allocate(SVMParameter x)
{
if (x == null)
{
return(IntPtr.Zero);
}
svm_parameter y = new svm_parameter();
y.svm_type = (int)x.Type;
y.kernel_type = (int)x.Kernel;
y.degree = x.Degree;
y.gamma = x.Gamma;
y.coef0 = x.Coef0;
y.cache_size = x.CacheSize;
y.eps = x.Eps;
y.C = x.C;
y.nu = x.Nu;
y.p = x.P;
y.shrinking = x.Shrinking ? 1 : 0;
y.probability = x.Probability ? 1 : 0;
y.nr_weight = x.WeightLabels.Length;
y.weight_label = IntPtr.Zero;
if (y.nr_weight > 0)
{
y.weight_label = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(int)) * x.WeightLabels.Length);
Marshal.Copy(x.WeightLabels, 0, y.weight_label, x.WeightLabels.Length);
}
y.weight = IntPtr.Zero;
if (y.nr_weight > 0)
{
y.weight = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(double)) * x.Weights.Length);
Marshal.Copy(x.Weights, 0, y.weight, x.Weights.Length);
}
int size = Marshal.SizeOf(y);
IntPtr ptr = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(y, ptr, true);
return(ptr);
}
public void TrainModel(double[] labels, double[][] mlArray)
{
SvmProblemBuilder builder = new SvmProblemBuilder(labels, mlArray);
svm_problem problem = builder.CreateProblem();
svm_parameter param = new svm_parameter()
{
svm_type = 0,
kernel_type = 0,
cache_size = 512,
eps = 0.1,
C = 10,
nr_weight = 0,
weight_label = null,
weight = null
};
this.model = svm.svm_train(problem, param);
}
/// <summary>
/// Instantiate and return a svm_parameter object with default values.
/// </summary>
/// <returns>A svm_parameter object with default values</returns>
public static svm_parameter DefaultParameters()
{
svm_parameter parameter = new svm_parameter();
parameter.svm_type = svm_parameter.NU_SVR;
parameter.kernel_type = svm_parameter.RBF;
parameter.C = 1;
parameter.nu = 0.5;
parameter.gamma = 1;
parameter.p = 1;
parameter.cache_size = 500;
parameter.probability = 0;
parameter.eps = 0.001;
parameter.degree = 3;
parameter.shrinking = 1;
parameter.coef0 = 0;
return(parameter);
}
static double CrossValidate(long randomSeed, double C)
{
var training = Create1vs1Problem(trainingData, 1, 5);
var config = new svm_parameter()
{
svm_type = (int)SvmType.C_SVC,
kernel_type = (int)KernelType.POLY,
C = C,
degree = 2,
coef0 = 1,
gamma = 1,
eps = 0.001
};
double[] result = new double[training.l];
svm.rand.setSeed(randomSeed);
svm.svm_cross_validation(training, config, 10, result);
return((result.Zip(training.y, (v, u) => Math.Sign(v) != Math.Sign(u) ? 1 : 0).Sum() + 0.0) / result.Length);
}
/// <summary>
/// Load the models.
/// </summary>
/// <param name="xmlin">Where to read the models from.</param>
/// <param name="network">Where the models are read into.</param>
private void HandleModels(ReadXML xmlin, SVMNetwork network)
{
int index = 0;
while (xmlin.ReadToTag())
{
if (xmlin.IsIt(SVMNetworkPersistor.TAG_MODEL, true))
{
svm_parameter param = new svm_parameter();
svm_model model = new svm_model();
model.param = param;
network.Models[index] = model;
HandleModel(xmlin, network.Models[index]);
index++;
}
else if (xmlin.IsIt(SVMNetworkPersistor.TAG_MODELS, false))
{
break;
}
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private libsvm.svm_parameter getLibSvmParameters(java.util.LinkedHashMap<String, String> libOptions) throws org.maltparser.core.exception.MaltChainedException
private svm_parameter getLibSvmParameters(LinkedHashMap <string, string> libOptions)
{
svm_parameter param = new svm_parameter();
param.svm_type = int.Parse(libOptions.get("s"));
param.kernel_type = int.Parse(libOptions.get("t"));
param.degree = int.Parse(libOptions.get("d"));
param.gamma = Convert.ToDouble(libOptions.get("g"));
param.coef0 = Convert.ToDouble(libOptions.get("r"));
param.nu = Convert.ToDouble(libOptions.get("n"));
param.cache_size = Convert.ToDouble(libOptions.get("m"));
param.C = Convert.ToDouble(libOptions.get("c"));
param.eps = Convert.ToDouble(libOptions.get("e"));
param.p = Convert.ToDouble(libOptions.get("p"));
param.shrinking = int.Parse(libOptions.get("h"));
param.probability = int.Parse(libOptions.get("b"));
param.nr_weight = 0;
param.weight_label = new int[0];
param.weight = new double[0];
return(param);
}
public void SaveModel(string fileName)
{
FileStream fs = new FileStream(fileName, FileMode.Create);
using (BinaryWriter w = new BinaryWriter(fs))
{
svm_parameter p = model.param;
w.Write(p.C);
w.Write(p.cache_size);
w.Write(p.coef0);
w.Write(p.degree);
w.Write(p.eps);
w.Write(p.gamma);
w.Write(p.kernel_type);
w.Write(p.nr_weight);
w.Write(p.nu);
w.Write(p.p);
w.Write(p.probability);
w.Write(p.shrinking);
w.Write(p.svm_type);
WriteArray(w, p.weight);
WriteArray(w, p.weight_label);
w.Write(model.nr_class);
w.Write(model.l);
WriteArray(w, model.SV);
WriteArray(w, model.sv_coef);
WriteArray(w, model.rho);
WriteArray(w, model.probA);
WriteArray(w, model.probB);
WriteArray(w, model.label);
WriteArray(w, model.nSV);
}
fs.Close();
}
/// <summary>
/// Construct the SVM.
/// </summary>
///
public SupportVectorMachine()
{
_paras = new svm_parameter();
}
private static SupportVectorRegressionSolution SvmGridSearch(IRegressionProblemData 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 = SupportVectorRegression.CreateSupportVectorRegressionSolution(problemData, problemData.AllowedInputVariables, svmType, kernelType,
bestParameters.C, bestParameters.nu, bestParameters.gamma, bestParameters.eps, bestParameters.degree, out trainingError, out testError, out nSv);
return(svm_solution);
}
internal static double k_function(MaltFeatureNode[] 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
}
}
/// <summary>
/// Save a model.
/// </summary>
/// <param name="xmlout">Where to save a model to.</param>
/// <param name="model">The model to save to.</param>
public static void SaveModel(WriteXML xmlout, svm_model model)
{
if (model != null)
{
xmlout.BeginTag(SVMNetworkPersistor.TAG_MODEL);
svm_parameter param = model.param;
xmlout.AddProperty(SVMNetworkPersistor.TAG_TYPE_SVM,
svm_type_table[param.svm_type]);
xmlout.AddProperty(SVMNetworkPersistor.TAG_TYPE_KERNEL,
kernel_type_table[param.kernel_type]);
if (param.kernel_type == svm_parameter.POLY)
{
xmlout.AddProperty(SVMNetworkPersistor.TAG_DEGREE, param.degree);
}
if (param.kernel_type == svm_parameter.POLY ||
param.kernel_type == svm_parameter.RBF ||
param.kernel_type == svm_parameter.SIGMOID)
{
xmlout.AddProperty(SVMNetworkPersistor.TAG_GAMMA, param.gamma);
}
if (param.kernel_type == svm_parameter.POLY ||
param.kernel_type == svm_parameter.SIGMOID)
{
xmlout.AddProperty(SVMNetworkPersistor.TAG_COEF0, param.coef0);
}
int nr_class = model.nr_class;
int l = model.l;
xmlout.AddProperty(SVMNetworkPersistor.TAG_NUMCLASS, nr_class);
xmlout.AddProperty(SVMNetworkPersistor.TAG_TOTALSV, l);
xmlout.AddProperty(SVMNetworkPersistor.TAG_RHO, model.rho, nr_class
* (nr_class - 1) / 2);
xmlout.AddProperty(SVMNetworkPersistor.TAG_LABEL, model.label,
nr_class);
xmlout.AddProperty(SVMNetworkPersistor.TAG_PROB_A, model.probA,
nr_class * (nr_class - 1) / 2);
xmlout.AddProperty(SVMNetworkPersistor.TAG_PROB_B, model.probB,
nr_class * (nr_class - 1) / 2);
xmlout.AddProperty(SVMNetworkPersistor.TAG_NSV, model.nSV, nr_class);
xmlout.BeginTag(SVMNetworkPersistor.TAG_DATA);
double[][] sv_coef = model.sv_coef;
svm_node[][] SV = model.SV;
StringBuilder line = new StringBuilder();
for (int i = 0; i < l; i++)
{
line.Length = 0;
for (int j = 0; j < nr_class - 1; j++)
{
line.Append(sv_coef[j][i] + " ");
}
svm_node[] p = SV[i];
//if (param.kernel_type == svm_parameter.PRECOMPUTED)
//{
// line.Append("0:" + (int) (p[0].value));
//}
//else
for (int j = 0; j < p.Length; j++)
{
line.Append(p[j].index + ":" + p[j].value_Renamed + " ");
}
xmlout.AddProperty(SVMNetworkPersistor.TAG_ROW, line.ToString());
}
xmlout.EndTag();
xmlout.EndTag();
}
}
private void parse_command_line(System.String[] argv)
{
int i;
param = new svm_parameter();
// default values
param.svm_type = svm_parameter.C_SVC;
param.kernel_type = svm_parameter.RBF;
param.degree = 3;
param.gamma = 0; // 1/k
param.coef0 = 0;
param.nu = 0.5;
param.cache_size = 40;
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];
// parse options
for (i = 0; i < argv.Length; i++)
{
if (argv[i][0] != '-')
{
break;
}
++i;
switch (argv[i - 1][1])
{
case 's':
param.svm_type = atoi(argv[i]);
break;
case 't':
param.kernel_type = atoi(argv[i]);
break;
case 'd':
param.degree = atof(argv[i]);
break;
case 'g':
param.gamma = atof(argv[i]);
break;
case 'r':
param.coef0 = atof(argv[i]);
break;
case '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':
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 'v':
cross_validation = 1;
nr_fold = atoi(argv[i]);
if (nr_fold < 2)
{
System.Console.Error.Write("n-fold cross 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];
Array.Copy(old, 0, param.weight_label, 0, param.nr_weight - 1);
}
{
double[] old = param.weight;
param.weight = new double[param.nr_weight];
Array.Copy(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:
System.Console.Error.Write("unknown option\n");
exit_with_help();
break;
}
}
// determine filenames
if (i >= argv.Length)
{
exit_with_help();
}
input_file_name = argv[i];
if (i < argv.Length - 1)
{
model_file_name = argv[i + 1];
}
else
{
int p = argv[i].LastIndexOf((System.Char) '/');
++p; // whew...
model_file_name = argv[i].Substring(p) + ".model";
}
}
/// <summary>
/// Construct a SVM network.
/// </summary>
///
/// <param name="theInputCount">The input count.</param>
/// <param name="svmType">The type of SVM.</param>
/// <param name="kernelType">The SVM kernal type.</param>
public SupportVectorMachine(int theInputCount, SVMType svmType,
KernelType kernelType)
{
_inputCount = theInputCount;
_paras = new svm_parameter();
switch (svmType)
{
case SVMType.SupportVectorClassification:
_paras.svm_type = svm_parameter.C_SVC;
break;
case SVMType.NewSupportVectorClassification:
_paras.svm_type = svm_parameter.NU_SVC;
break;
case SVMType.SupportVectorOneClass:
_paras.svm_type = svm_parameter.ONE_CLASS;
break;
case SVMType.EpsilonSupportVectorRegression:
_paras.svm_type = svm_parameter.EPSILON_SVR;
break;
case SVMType.NewSupportVectorRegression:
_paras.svm_type = svm_parameter.NU_SVR;
break;
default:
throw new NeuralNetworkError("Invalid svm type");
}
switch (kernelType)
{
case KernelType.Linear:
_paras.kernel_type = svm_parameter.LINEAR;
break;
case KernelType.Poly:
_paras.kernel_type = svm_parameter.POLY;
break;
case KernelType.RadialBasisFunction:
_paras.kernel_type = svm_parameter.RBF;
break;
case KernelType.Sigmoid:
_paras.kernel_type = svm_parameter.SIGMOID;
break;
/*case Encog.ML.SVM.KernelType.Precomputed:
* this.paras.kernel_type = Encog.MathUtil.LIBSVM.svm_parameter.PRECOMPUTED;
* break;*/
default:
throw new NeuralNetworkError("Invalid kernel type");
}
// params[i].kernel_type = svm_parameter.RBF;
_paras.degree = DefaultDegree;
_paras.coef0 = 0;
_paras.nu = DefaultNu;
_paras.cache_size = DefaultCacheSize;
_paras.C = 1;
_paras.eps = DefaultEps;
_paras.p = DefaultP;
_paras.shrinking = 1;
_paras.probability = 0;
_paras.nr_weight = 0;
_paras.weight_label = new int[0];
_paras.weight = new double[0];
_paras.gamma = 1.0d / _inputCount;
}
/// <summary>
/// Construct a SVM network.
/// </summary>
/// <param name="inputCount">The input count.</param>
/// <param name="outputCount">The output count.</param>
/// <param name="svmType">The type of SVM.</param>
/// <param name="kernelType">The SVM kernal type.</param>
public SVMNetwork(int inputCount, int outputCount, SVMType svmType,
KernelType kernelType)
{
this.inputCount = inputCount;
this.outputCount = outputCount;
this.kernelType = kernelType;
this.svmType = svmType;
models = new svm_model[outputCount];
parameters = new svm_parameter[outputCount];
for (int i = 0; i < outputCount; i++)
{
parameters[i] = new svm_parameter();
switch (svmType)
{
case SVMType.SupportVectorClassification:
parameters[i].svm_type = svm_parameter.C_SVC;
break;
case SVMType.NewSupportVectorClassification:
parameters[i].svm_type = svm_parameter.NU_SVC;
break;
case SVMType.SupportVectorOneClass:
parameters[i].svm_type = svm_parameter.ONE_CLASS;
break;
case SVMType.EpsilonSupportVectorRegression:
parameters[i].svm_type = svm_parameter.EPSILON_SVR;
break;
case SVMType.NewSupportVectorRegression:
parameters[i].svm_type = svm_parameter.NU_SVR;
break;
}
switch (kernelType)
{
case KernelType.Linear:
parameters[i].kernel_type = svm_parameter.LINEAR;
break;
case KernelType.Poly:
parameters[i].kernel_type = svm_parameter.POLY;
break;
case KernelType.RadialBasisFunction:
parameters[i].kernel_type = svm_parameter.RBF;
break;
case KernelType.Sigmoid:
parameters[i].kernel_type = svm_parameter.SIGMOID;
break;
}
parameters[i].kernel_type = svm_parameter.RBF;
parameters[i].degree = 3;
parameters[i].coef0 = 0;
parameters[i].nu = 0.5;
parameters[i].cache_size = 100;
parameters[i].C = 1;
parameters[i].eps = 1e-3;
parameters[i].p = 0.1;
parameters[i].shrinking = 1;
parameters[i].probability = 0;
parameters[i].nr_weight = 0;
parameters[i].weight_label = new int[0];
parameters[i].weight = new double[0];
parameters[i].gamma = 1.0 / inputCount;
}
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: protected void trainInternal(java.util.LinkedHashMap<String, String> libOptions) throws org.maltparser.core.exception.MaltChainedException
protected internal override void trainInternal(LinkedHashMap <string, string> libOptions)
{
try
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final libsvm.svm_problem prob = readProblem(getInstanceInputStreamReader(".ins"), libOptions);
svm_problem prob = readProblem(getInstanceInputStreamReader(".ins"), libOptions);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final libsvm.svm_parameter param = getLibSvmParameters(libOptions);
svm_parameter param = getLibSvmParameters(libOptions);
if (svm.svm_check_parameter(prob, param) != null)
{
throw new LibException(svm.svm_check_parameter(prob, param));
}
Configuration config = Configuration;
if (config.LoggerInfoEnabled)
{
config.logInfoMessage("Creating LIBSVM model " + getFile(".moo").Name + "\n");
}
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.PrintStream out = System.out;
PrintStream @out = System.out;
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.PrintStream err = System.err;
PrintStream err = System.err;
System.Out = NoPrintStream.NO_PRINTSTREAM;
System.Err = NoPrintStream.NO_PRINTSTREAM;
svm_model model = svm.svm_train(prob, param);
System.Out = err;
System.Out = @out;
ObjectOutputStream output = new ObjectOutputStream(new BufferedOutputStream(new FileStream(getFile(".moo").AbsolutePath, FileMode.Create, FileAccess.Write)));
try
{
output.writeObject(new MaltLibsvmModel(model, prob));
}
finally
{
output.close();
}
bool saveInstanceFiles = ((bool?)Configuration.getOptionValue("lib", "save_instance_files")).Value;
if (!saveInstanceFiles)
{
getFile(".ins").delete();
}
}
catch (OutOfMemoryException e)
{
throw new LibException("Out of memory. Please increase the Java heap size (-Xmx<size>). ", e);
}
catch (ArgumentException e)
{
throw new LibException("The LIBSVM learner was not able to redirect Standard Error stream. ", e);
}
catch (SecurityException e)
{
throw new LibException("The LIBSVM learner cannot remove the instance file. ", e);
}
catch (IOException e)
{
throw new LibException("The LIBSVM learner cannot save the model file '" + getFile(".mod").AbsolutePath + "'. ", e);
}
}
public static double CrossValidate(IDataAnalysisProblemData problemData, svm_parameter parameters, int numberOfFolds, bool shuffleFolds = true)
{
var partitions = GenerateSvmPartitions(problemData, numberOfFolds, shuffleFolds);
return(CalculateCrossValidationPartitions(partitions, parameters));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET:
//ORIGINAL LINE: private libsvm.svm_problem readProblem(java.io.InputStreamReader isr, java.util.LinkedHashMap<String, String> libOptions) throws org.maltparser.core.exception.MaltChainedException
private svm_problem readProblem(StreamReader isr, LinkedHashMap <string, string> libOptions)
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final libsvm.svm_problem problem = new libsvm.svm_problem();
svm_problem problem = new svm_problem();
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final libsvm.svm_parameter param = getLibSvmParameters(libOptions);
svm_parameter param = getLibSvmParameters(libOptions);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.maltparser.ml.lib.FeatureList featureList = new org.maltparser.ml.lib.FeatureList();
FeatureList featureList = new FeatureList();
try
{
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final java.io.BufferedReader fp = new java.io.BufferedReader(isr);
StreamReader fp = new StreamReader(isr);
problem.l = NumberOfInstances;
problem.x = new svm_node[problem.l][];
problem.y = new double[problem.l];
int i = 0;
while (true)
{
string line = fp.ReadLine();
if (ReferenceEquals(line, null))
{
break;
}
int y = binariesInstance(line, featureList);
if (y == -1)
{
continue;
}
try
{
problem.y[i] = y;
problem.x[i] = new svm_node[featureList.size()];
int p = 0;
for (int k = 0; k < featureList.size(); k++)
{
MaltFeatureNode x = featureList.get(k);
problem.x[i][p] = new svm_node();
problem.x[i][p].value = x.Value;
problem.x[i][p].index = x.Index;
p++;
}
i++;
}
catch (IndexOutOfRangeException e)
{
throw new LibException("Couldn't read libsvm problem from the instance file. ", e);
}
}
fp.Close();
if (param.gamma == 0)
{
param.gamma = 1.0 / featureMap.FeatureCounter;
}
}
catch (IOException e)
{
throw new LibException("Couldn't read libsvm problem from the instance file. ", e);
}
return(problem);
}
private static double CalculateCrossValidationPartitions(Tuple <svm_problem, svm_problem>[] partitions, svm_parameter parameters)
{
double avgTestMse = 0;
var calc = new OnlineMeanSquaredErrorCalculator();
foreach (Tuple <svm_problem, svm_problem> tuple in partitions)
{
var trainingSvmProblem = tuple.Item1;
var testSvmProblem = tuple.Item2;
var model = svm.svm_train(trainingSvmProblem, parameters);
calc.Reset();
for (int i = 0; i < testSvmProblem.l; ++i)
{
calc.Add(testSvmProblem.y[i], svm.svm_predict(model, testSvmProblem.x[i]));
}
double mse = calc.ErrorState == OnlineCalculatorError.None ? calc.MeanSquaredError : double.NaN;
avgTestMse += mse;
}
avgTestMse /= partitions.Length;
return(avgTestMse);
}
