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);
}
public override void Train(IForecastingDataSets datasets)
{
Parameter svmpara = mParameter as Parameter;
OnStartRunning(new ComponentRunEventArgs(datasets));
double[] yvalue = null;
int maxIndex = 0;
Node[][] nodes = CreateNodes(datasets, out yvalue, out maxIndex);
Problem problem = new Problem(nodes.Length, yvalue, nodes, maxIndex);
mRange = Scaling.DetermineRange(problem);
problem = Scaling.Scale(mRange, problem);
TrainedModel = Training.Train(problem, svmpara as Parameter);
datasets.ForecastedData = new double[datasets.InputData.Length][];
for (int i = 0; i < datasets.InputData.Length; i++)
{
datasets.ForecastedData[i] = new double[1];
datasets.ForecastedData[i][0] = Forecast(datasets.InputData[i]);
OnRunningEpoch(new ComponentRunEpochEventArgs(i));
}
svmpara.Count = TrainedModel.SupportVectorCount;
svmpara.Percentage = TrainedModel.SupportVectorCount / (double)problem.Count;
OnFinishRunning(new ComponentRunEventArgs(datasets));
}
public IProblemFactory WithRangeScaling()
{
var original = new ProblemSource(baseDataSet).GetProblem();
transform = RangeTransform.Compute(original);
return(this);
}
private double testMulticlassModel(int numberOfClasses, int count, SvmType svm, KernelType kernel, bool probability = false, string outputFile = null)
{
Problem train = SVMUtilities.CreateMulticlassProblem(numberOfClasses, count);
Parameter param = new Parameter();
RangeTransform transform = RangeTransform.Compute(train);
Problem scaled = transform.Scale(train);
param.Gamma = 1.0 / 3;
param.SvmType = svm;
param.KernelType = kernel;
param.Probability = probability;
if (svm == SvmType.C_SVC)
{
for (int i = 0; i < numberOfClasses; i++)
{
param.Weights[i] = 1;
}
}
Model model = Training.Train(scaled, param);
Problem test = SVMUtilities.CreateMulticlassProblem(numberOfClasses, count, false);
scaled = transform.Scale(test);
return(Prediction.Predict(scaled, outputFile, model, false));
}
private void UpdateTextBox()
{
using (MemoryStream s = new MemoryStream()) {
StreamWriter writer = new StreamWriter(s);
writer.WriteLine("RangeTransform:");
writer.Flush();
using (MemoryStream memStream = new MemoryStream()) {
RangeTransform.Write(memStream, Content.RangeTransform);
memStream.Seek(0, SeekOrigin.Begin);
memStream.WriteTo(s);
}
writer.WriteLine("Model:");
writer.Flush();
using (MemoryStream memStream = new MemoryStream()) {
svm.svm_save_model(new StreamWriter(memStream), Content.Model);
memStream.Seek(0, SeekOrigin.Begin);
memStream.WriteTo(s);
}
s.Flush();
s.Seek(0, SeekOrigin.Begin);
StreamReader reader = new StreamReader(s);
textBox.Text = reader.ReadToEnd();
}
}
public void Compute()
{
var dataSet = ArffDataSet.LoadSimple(Path.Combine(TestContext.CurrentContext.TestDirectory, "Data", @"problem.arff"));
var problem = new ProblemSource(dataSet).GetProblem();
var transform = RangeTransform.Compute(problem);
var result = transform.Scale(problem);
Assert.IsNotNull(result);
}
public SupportVectorMachineModel(svm_model model, RangeTransform rangeTransform, string targetVariable, IEnumerable <string> allowedInputVariables)
: base(targetVariable)
{
this.name = ItemName;
this.description = ItemDescription;
this.model = model;
this.rangeTransform = rangeTransform;
this.allowedInputVariables = allowedInputVariables.ToArray();
}
private SupportVectorMachineModel(SupportVectorMachineModel original, Cloner cloner)
: base(original, cloner)
{
// only using a shallow copy here! (gkronber)
this.model = original.model;
this.rangeTransform = original.rangeTransform;
this.allowedInputVariables = (string[])original.allowedInputVariables.Clone();
if (original.classValues != null)
{
this.classValues = (double[])original.classValues.Clone();
}
}
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 void ReadModel()
{
Problem train = SVMUtilities.CreateTwoClassProblem(100);
Parameter param = new Parameter();
RangeTransform transform = RangeTransform.Compute(train);
Problem scaled = transform.Scale(train);
param.KernelType = KernelType.LINEAR;
Training.SetRandomSeed(SVMUtilities.TRAINING_SEED);
Model expected = Training.Train(scaled, param);
Model actual = Model.Read("svm0.model");
Assert.AreEqual(expected, actual);
}
public double[][] Predict(FeaturesWithLabel featureSet, ClassifyOptions options)
{
Problem predict = new Problem();
List <FeaturesWithLabel> featureSets = new List <FeaturesWithLabel>();
featureSets.Add(featureSet);
predict.X = GetData(featureSets).ToArray();
predict.Y = new double[1];
predict.Count = predict.X.Count();
predict.MaxIndex = 300;
RangeTransform transform = options.Transform;
Problem scaled = transform.Scale(predict);
return(Prediction.PredictLabelsProbability(options.Model, scaled));
}
public double[][] Predict(Sentence sentence, ClassifyOptions options)
{
Problem predict = new Problem();
predict.X = GetData(new List <Sentence> {
sentence
}).ToArray();
predict.Y = new double[1];
predict.Count = predict.X.Count();
predict.MaxIndex = features.Count;
transform = options.Transform;
Problem scaled = transform.Scale(predict);
return(Prediction.PredictLabelsProbability(model, scaled));
}
/// <summary>
/// Начать процес обучения
/// </summary>
public void DoWork()
{
Problem problem = new Problem(VectorList.Count, TypeElementVectorList.ToArray(), VectorList.ToArray(), VectorList[0].Length);
range = RangeTransform.Compute(problem);
problem = range.Scale(problem);
// константы подобраны методом тыка. работают оптимально
Parameter param = new Parameter();
param.C = 2;
param.Gamma = .5;
model = Training.Train(problem, param);
}
public void SVMClassifierTrain(List <Sentence> sentences, ClassifyOptions options, SvmType svm = SvmType.C_SVC, KernelType kernel = KernelType.RBF, bool probability = true, string outputFile = null)
{
var tfidf = new TfIdfFeatureExtractor();
tfidf.Dimension = options.Dimension;
tfidf.Sentences = sentences;
tfidf.CalBasedOnCategory();
featuresInTfIdf = tfidf.Keywords();
// copy test multiclass Model
Problem train = new Problem();
train.X = GetData(sentences, options).ToArray();
train.Y = GetLabels(sentences).ToArray();
train.Count = train.X.Count();
train.MaxIndex = train.X[0].Count();//int.MaxValue;
Parameter param = new Parameter();
transform = RangeTransform.Compute(train);
Problem scaled = transform.Scale(train);
param.Gamma = 1.0 / 3;
param.SvmType = svm;
param.KernelType = kernel;
param.Probability = probability;
int numberOfClasses = train.Y.OrderBy(x => x).Distinct().Count();
if (numberOfClasses == 1)
{
Console.Write("Number of classes must greater than one!");
}
if (svm == SvmType.C_SVC)
{
for (int i = 0; i < numberOfClasses; i++)
{
param.Weights[i] = 1;
}
}
model = Training.Train(scaled, param);
Console.Write("Training finished!");
}
internal static async Task <double> GetQualityScoreAsync(IList <double> brisqueFeatures)
{
var problem = new Problem(1, new double[1] {
1
}, ToNodes(brisqueFeatures), brisqueFeatures.Count);
if (Transform == null)
{
Transform = GetRangeTransform();
}
if (_model == null)
{
_model = SVM.Model.Read(MyStreamReader.GetMemoryStream(SvmModelPath));
}
var scaled = Transform.Scale(problem);
return(Math.Round(Math.Abs(_model.Predict(scaled.X[0])), 2));
}
private static Tuple <svm_problem, svm_problem>[] GenerateSvmPartitions(IDataAnalysisProblemData problemData, int numberOfFolds, bool shuffleFolds = true)
{
var folds = GenerateFolds(problemData, numberOfFolds, shuffleFolds).ToList();
var targetVariable = GetTargetVariableName(problemData);
var partitions = new Tuple <svm_problem, svm_problem> [numberOfFolds];
for (int i = 0; i < numberOfFolds; ++i)
{
int p = i; // avoid "access to modified closure" warning below
var trainingRows = folds.SelectMany((par, j) => j != p ? par : Enumerable.Empty <int>());
var testRows = folds[i];
var trainingSvmProblem = CreateSvmProblem(problemData.Dataset, targetVariable, problemData.AllowedInputVariables, trainingRows);
var rangeTransform = RangeTransform.Compute(trainingSvmProblem);
var testSvmProblem = rangeTransform.Scale(CreateSvmProblem(problemData.Dataset, targetVariable, problemData.AllowedInputVariables, testRows));
partitions[i] = new Tuple <svm_problem, svm_problem>(rangeTransform.Scale(trainingSvmProblem), testSvmProblem);
}
return(partitions);
}
public string SaveModel(ClassifyOptions options)
{
options.TransformFilePath = Path.Combine(options.ModelDir, "transform");
options.FeaturesFileName = Path.Combine(options.ModelDir, "features");
options.DictionaryFileName = Path.Combine(options.ModelDir, "dictionary");
options.CategoriesFileName = Path.Combine(options.ModelDir, "categories");
File.WriteAllText(options.FeaturesFileName, JsonConvert.SerializeObject(features));
File.WriteAllText(options.DictionaryFileName, JsonConvert.SerializeObject(dictionary));
File.WriteAllText(options.CategoriesFileName, JsonConvert.SerializeObject(categories));
RangeTransform.Write(options.TransformFilePath, transform);
Bigtree.Algorithm.SVM.Model.Write(options.ModelFilePath, model);
return(options.ModelFilePath);
}
private double testRegressionModel(int count, SvmType svm, KernelType kernel, string outputFile = null)
{
Problem train = SVMUtilities.CreateRegressionProblem(count);
Parameter param = new Parameter();
RangeTransform transform = RangeTransform.Compute(train);
Problem scaled = transform.Scale(train);
param.Gamma = 1.0 / 2;
param.SvmType = svm;
param.KernelType = kernel;
param.Degree = 2;
Model model = Training.Train(scaled, param);
Problem test = SVMUtilities.CreateRegressionProblem(count, false);
scaled = transform.Scale(test);
return(Prediction.Predict(scaled, outputFile, model, false));
}
object IClassifier.LoadModel(ClassifyOptions options)
{
options.FeaturesFileName = Path.Combine(options.ModelDir, "features");
options.DictionaryFileName = Path.Combine(options.ModelDir, "dictionary");
options.ModelFilePath = Path.Combine(options.ModelDir, options.ModelName);
options.TransformFilePath = Path.Combine(options.ModelDir, "transform");
options.CategoriesFileName = Path.Combine(options.ModelDir, "categories");
features = JsonConvert.DeserializeObject <List <String> >(File.ReadAllText(options.FeaturesFileName));
dictionary = JsonConvert.DeserializeObject <List <Tuple <string, int> > >(File.ReadAllText(options.DictionaryFileName));
categories = JsonConvert.DeserializeObject <List <String> >(File.ReadAllText(options.CategoriesFileName));
model = Bigtree.Algorithm.SVM.Model.Read(options.ModelFilePath);
options.Transform = RangeTransform.Read(options.TransformFilePath);
return(model);
}
public void WriteModel()
{
Problem train = SVMUtilities.CreateTwoClassProblem(100);
Parameter param = new Parameter();
RangeTransform transform = RangeTransform.Compute(train);
Problem scaled = transform.Scale(train);
param.KernelType = KernelType.LINEAR;
Training.SetRandomSeed(SVMUtilities.TRAINING_SEED);
Model model = Training.Train(scaled, param);
using (MemoryStream stream = new MemoryStream())
using (StreamReader input = new StreamReader("svm0.model"))
{
Model.Write(stream, model);
string expected = input.ReadToEnd().Replace("\r\n", "\n");
string actual = Encoding.ASCII.GetString(stream.ToArray());
Assert.AreEqual(expected, actual);
}
}
public void SVMClassifierTrain(List <Sentence> sentences, ClassifyOptions options, SvmType svm = SvmType.C_SVC, KernelType kernel = KernelType.RBF, bool probability = true, string outputFile = null)
{
// copy test multiclass Model
Problem train = new Problem();
train.X = GetData(sentences).ToArray();
train.Y = GetLabels(sentences).ToArray();
train.Count = train.X.Count();
train.MaxIndex = train.X[0].Count();//int.MaxValue;
Parameter param = new Parameter();
transform = RangeTransform.Compute(train);
Problem scaled = transform.Scale(train);
param.Gamma = 1.0 / 3;
param.SvmType = svm;
param.KernelType = kernel;
param.Probability = probability;
int numberOfClasses = train.Y.OrderBy(x => x).Distinct().Count();
if (numberOfClasses == 1)
{
throw new ArgumentException("Number of classes can't be one!");
}
if (svm == SvmType.C_SVC)
{
for (int i = 0; i < numberOfClasses; i++)
{
param.Weights[i] = 1;
}
}
model = Training.Train(scaled, param);
Console.Write("Training finished!");
}
public void SVMClassifierTrain(List <FeaturesWithLabel> featureSets, ClassifyOptions options, SvmType svm = SvmType.C_SVC, KernelType kernel = KernelType.RBF, bool probability = true, string outputFile = null)
{
// copy test multiclass Model
Problem train = new Problem();
train.X = GetData(featureSets).ToArray();
train.Y = GetLabels(featureSets).ToArray();
train.Count = train.X.Count();
train.MaxIndex = 300;//int.MaxValue;
Parameter param = new Parameter();
RangeTransform transform = RangeTransform.Compute(train);
Problem scaled = transform.Scale(train);
param.Gamma = 1.0 / 3;
param.SvmType = svm;
param.KernelType = kernel;
param.Probability = probability;
int numberOfClasses = train.Y.Distinct().Count();
if (numberOfClasses == 1)
{
throw new ArgumentException("Number of classes can't be one!");
}
if (svm == SvmType.C_SVC)
{
for (int i = 0; i < numberOfClasses; i++)
{
param.Weights[i] = 1;
}
}
var model = Training.Train(scaled, param);
RangeTransform.Write(options.TransformFilePath, transform);
SVM.BotSharp.MachineLearning.Model.Write(options.ModelFilePath, model);
Console.Write("Training finished!");
}
/// <summary>
/// Scales a problem using the provided range. This will not affect the parameter.
/// </summary>
/// <param name="prob">The problem to scale</param>
/// <param name="range">The Range transform to use in scaling</param>
/// <returns>The Scaled problem</returns>
public static svm_problem Scale(this RangeTransform range, svm_problem prob)
{
svm_problem scaledProblem = new svm_problem()
{
l = prob.l, y = new double[prob.l], x = new svm_node[prob.l][]
};
for (int i = 0; i < scaledProblem.l; i++)
{
scaledProblem.x[i] = new svm_node[prob.x[i].Length];
for (int j = 0; j < scaledProblem.x[i].Length; j++)
{
scaledProblem.x[i][j] = new svm_node()
{
index = prob.x[i][j].index, value = range.Transform(prob.x[i][j].value, prob.x[i][j].index)
}
}
;
scaledProblem.y[i] = prob.y[i];
}
return(scaledProblem);
}
}
private double testTwoClassModel(int count, SvmType svm, KernelType kernel, bool probability = false, string outputFile = null)
{
Problem train = SVMUtilities.CreateTwoClassProblem(count);
Parameter param = new Parameter();
RangeTransform transform = RangeTransform.Compute(train);
Problem scaled = transform.Scale(train);
param.Gamma = .5;
param.SvmType = svm;
param.KernelType = kernel;
param.Probability = probability;
if (svm == SvmType.C_SVC)
{
param.Weights[-1] = 1;
param.Weights[1] = 1;
}
Model model = Training.Train(scaled, param);
Problem test = SVMUtilities.CreateTwoClassProblem(count, false);
scaled = transform.Scale(test);
return(Prediction.Predict(scaled, outputFile, model, false));
}
void classify(object args)
{
Problem train = new Problem
{
X = _data.Select(o => new Node[] { new Node(1, o.Position.X), new Node(2, o.Position.Y) }).ToArray(),
Y = _data.Select(o => o.Label).ToArray(),
Count = _data.Count,
MaxIndex = 2
};
Parameter param = args as Parameter;
RangeTransform transform = RangeTransform.Compute(train);
train = transform.Scale(train);
Model model = Training.Train(train, param);
int width = (int)plot.ActualWidth;
int height = (int)plot.ActualHeight;
byte[] pixels = new byte[width * height * 3];
int cWidth = (width >> SCALE) + 1;
int cHeight = (height >> SCALE) + 1;
int[,] labels = new int[cHeight, cWidth];
for (int r = 0, i = 0; r < cHeight; r++)
{
for (int c = 0; c < cWidth; c++, i++)
{
int rr = r << SCALE;
int cc = c << SCALE;
Node[] datum = new Node[] { new Node(1, cc), new Node(2, rr) };
datum = transform.Transform(datum);
labels[r, c] = (int)model.Predict(datum);
classifyPB.Dispatcher.Invoke(() => classifyPB.Value = (i * 100) / (cHeight * cWidth));
}
}
PixelFormat format = PixelFormats.Rgb24;
for (int i = 0, r = 0; r < height; r++)
{
for (int c = 0; c < width; c++)
{
int label = labels[r >> SCALE, c >> SCALE];
Color color = _colors[label];
pixels[i++] = color.R;
pixels[i++] = color.G;
pixels[i++] = color.B;
}
}
plot.Dispatcher.Invoke(() =>
{
ImageBrush brush = new ImageBrush(BitmapSource.Create(width, height, 96, 96, format, null, pixels, width * 3));
brush.Stretch = Stretch.None;
brush.AlignmentX = 0;
brush.AlignmentY = 0;
plot.Background = brush;
});
classifyPB.Dispatcher.Invoke(() => classifyPB.Value = 0);
}
public SupportVectorMachineModel(svm_model model, RangeTransform rangeTransform, string targetVariable, IEnumerable <string> allowedInputVariables, IEnumerable <double> classValues)
: this(model, rangeTransform, targetVariable, allowedInputVariables)
{
this.classValues = classValues.ToArray();
}
