public void Run(Page page, ConfigurationFieldClassifier config, Action <IDictionary <string, double> > pageMatch)
{
// page.Features = m_bow.GetFeatureVector(page.Image);
double output1;
var paths1 = new Tuple <int, int> [3];
var recClassId = m_ksvm.Compute(page.Features.ToArray(), out output1, out paths1);
output1 = System.Math.Abs(output1);
string recClassName;
if (m_classIdClassNameMap.TryGetValue(recClassId, out recClassName) == false)
{
recClassName = string.Format("__Class{0}__", recClassId);
}
if (output1 >= m_pageThreshold) //Current implementation only fills highest graded class as output (output1). Dictionary supports more than 1 class match, assuming sort by match score desc.
{
pageMatch(new Dictionary <string, double>()
{
{ recClassName, output1 }
});
}
else
{
pageMatch(new Dictionary <string, double>());
}
}
public bool LoadTrainData(Stream stream, out ConfigurationFieldClassifier config, out string trainPath)
{
try
{
var model = ModelFieldCLassify.Load(stream);
model.Ksvm.Position = 0;
m_ksvm = MulticlassSupportVectorMachine.Load(model.Ksvm);
model.Bow.Position = 0;
// m_bow = BagOfVisualWords.Load<CornerFeaturePointEx>(model.Bow);
BinaryFormatter f = new BinaryFormatter();
model.TrainImageFeatureVectors.Position = 0;
m_trainImageFeatureVectors = f.Deserialize(model.TrainImageFeatureVectors) as double[][];
model.ClassIdClassNameMap.Position = 0;
m_classIdClassNameMap = f.Deserialize(model.ClassIdClassNameMap) as Dictionary <int, string>;
config = model.Configuration;
trainPath = model.TrainPath;
m_pageThreshold = model.PageThreshold;
}
catch
{
Reset();
config = null;
trainPath = string.Empty;
return(false);
}
return(true);
}
private void SetPagesFeatures(ConfigurationFieldClassifier config, IEnumerable <Page> pages)
{
// Set Page.Features...
/* if (m_bow == null)
* {
* // Calculate bow...
* BinarySplit bs = new BinarySplit(config.FeatureExtraction.NoOfWords);
*
* // Create bag-of-words (BoW) with the given number of words
* m_bow = new BagOfVisualWords<CornerFeaturePointEx>(
* new CornerDetectorWithDiagonalLines(new CornerFeaturesDetector(new HarrisCornersDetector())), bs);
*
* // Compute the BoW codebook using training images only
* var points = m_bow.Compute(pages.Select(x => x.Image).ToArray());
*
* // Update page with
*
* Parallel.ForEach(pages, p =>
* {
* p.Features = m_bow.GetFeatureVector(p.Image);
* });
*
* m_trainImageFeatureVectors = pages.Select(x => x.Features.ToArray()).ToArray();
* }
* else
* {
* for (int i = 0; i < m_trainImageFeatureVectors.Length; i++)
* {
* pages.ElementAt(i).Features = m_trainImageFeatureVectors[i];
* }
* }*/
}
private static void SetConfigurationAccord(ref string newParameterValue, ConfigurationFieldClassifier configuration, string parameterName, double val)
{
switch (parameterName)
{
case "NoOfWords":
configuration.FeatureExtraction.NoOfWords = Convert.ToInt32(val);
newParameterValue += configuration.FeatureExtraction.NoOfWords.ToString();
break;
case "Extended":
configuration.FeatureExtraction.Extended = val.ToString() == "1";
newParameterValue += configuration.FeatureExtraction.Extended.ToString();
break;
case "Classifier":
configuration.AccordConfiguration.Kernel = (KernelTypes)(Convert.ToInt32(val) - 1);
newParameterValue += configuration.AccordConfiguration.Kernel.ToString();
break;
case @"Gaussian/Sigma":
configuration.AccordConfiguration.GaussianKernel.Sigma = Convert.ToDouble(val);
newParameterValue += val.ToString();
break;
case @"Polynomial/Degree":
configuration.AccordConfiguration.PolynominalKernel.Degree = Convert.ToInt32(val);
newParameterValue += val.ToString();
break;
case @"Polynomial/Constant":
configuration.AccordConfiguration.PolynominalKernel.Constant = Convert.ToDouble(val);
newParameterValue += val.ToString();
break;
case "Complexity":
configuration.AccordConfiguration.Complexity = Convert.ToDouble(val);
newParameterValue += val.ToString();
break;
case "Tolerance":
configuration.AccordConfiguration.Tolerance = Convert.ToDouble(val);
newParameterValue += val.ToString();
break;
case "CacheSize":
configuration.AccordConfiguration.CacheSize = Convert.ToInt32(val);
newParameterValue += val.ToString();
break;
case "SelectionStrategy":
configuration.AccordConfiguration.SelectionStrategy = (SelectionStrategies)(Convert.ToInt32(val) - 1);
newParameterValue += configuration.AccordConfiguration.SelectionStrategy.ToString();
break;
}
}
/// <summary>
/// Generate config with one diffrent parameter
/// </summary>
public static ConfigurationFieldClassifier GenerateConfiguration(string parameterName,
double val, ConfigurationFieldClassifier baseConfiguration, out string newParameterValue)
{
var configuration = baseConfiguration.Clone() as ConfigurationFieldClassifier;
newParameterValue = "";
SetConfiguration(ref newParameterValue, configuration, parameterName, val);
return(configuration);
}
public void ReplaceImageWithSvmData(ConfigurationFieldClassifier config, Page page)
{
/* if (m_bow == null)
* {
* // Calculate bow...
* BinarySplit bs = new BinarySplit(config.FeatureExtraction.NoOfWords);
*
* // Create bag-of-words (BoW) with the given number of words
* m_bow = new BagOfVisualWords<CornerFeaturePointEx>(
* new CornerDetectorWithDiagonalLines(new CornerFeaturesDetector(new HarrisCornersDetector())), bs);
* }
*
* page.Image.SvmData = m_bow.GetImageSvmData(page.Image);
* page.Image.DisposeImageData();*/
}
public void Train(IEnumerable <Page> Docs,
ConfigurationFieldClassifier config)
{
Reset();
// SetPagesFeatures(config, pages);
// Create the learning algorithm using the machine and the training data
// m_classIdClassNameMap = GetClassIdClassNameMap(pages);
// var numberOfClasses = m_classIdClassNameMap.Count;
// var outputs = pages.Select(x => x.MatchData.ClassId).ToArray();
// var fv = pages.Select(x => x.Features.ToArray()).ToArray();
//BuildModel(config, numberOfClasses, outputs, fv);
}
public void TrainUnknown(IEnumerable <Page> pages, ConfigurationFieldClassifier config, Func <bool> isAbort)
{
Reset();
// First set each page as different class
for (int i = pages.Count() - 1; i >= 0; i--)
{
pages.ElementAt(i).MatchData.ClassId = i;
}
SetPagesFeatures(config, pages);
// Create the learning algorithm using the machine and the training data
foreach (var page in pages)
{
if (isAbort() == true)
{
return;
}
// Skip page that found the class
if (pages.Where(x => x != page)
.Any(x => x.MatchData.ClassId == page.MatchData.ClassId) == true)
{
continue;
}
var trainPages = pages.Where(x => x != page).ToList();
var numberOfClasses = NormalizeClassNamesUnknown(trainPages);
var outputs = trainPages.Select(x => x.MatchData.ClassId).ToArray();
var fv = trainPages.Select(x => x.Features.ToArray()).ToArray();
// BuildModel(config, numberOfClasses, outputs, fv);
double output1;
var paths1 = new Tuple <int, int> [3];
page.MatchData.ClassId = (m_machine as MulticlassSupportVectorMachine).Compute(page.Features.ToArray(), out output1, out paths1);
page.MatchData.Confidence = output1;
page.MatchData.DecisionPath = paths1;
}
}
// Create bag-of-words (BoW) with the given number of words
// private BagOfVisualWords<CornerFeaturePointEx> m_bow = null;
#endregion
#region Public methods
public void SaveTrainData(Stream stream, ConfigurationFieldClassifier config, string trainPath, double pageThreshold)
{
var model = new ModelFieldCLassify();
model.PageThreshold = pageThreshold;
// m_bow.Save(model.Bow);
m_ksvm.Save(model.Ksvm);
BinaryFormatter f = new BinaryFormatter();
f.Serialize(model.TrainImageFeatureVectors, m_trainImageFeatureVectors);
f.Serialize(model.ClassIdClassNameMap, m_classIdClassNameMap);
model.Configuration = config;
model.TrainPath = trainPath;
ModelFieldCLassify.Save(model, stream);
}
// Create bag-of-words (BoW) with the given number of words
// private BagOfVisualWords<CornerFeaturePointEx> m_bow = null;
#endregion
#region Public methods
public void SaveTrainData(Stream stream, ConfigurationFieldClassifier config, string trainPath, double pageThreshold, IEnumerable <IFieldFeature> features)
{
var model = new ModelFieldCLassify();
model.PageThreshold = pageThreshold;
// m_bow.Save(model.Bow);
(m_machine as MulticlassSupportVectorMachine).Save(model.Ksvm);
//BinaryFormatter f = new BinaryFormatter();
//f.Serialize(model.TrainImageFeatureVectors, m_trainImageFeatureVectors);
//f.Serialize(model.ClassIdClassNameMap, m_classIdClassNameMap);
model.Configuration = config;
model.TrainPath = trainPath;
model.FeaturesScale = features.ToDictionary(x => x.Name, y => y.FieldScale);
ModelFieldCLassify.Save(model, stream);
}
public static ConfigurationFieldClassifier GenerateConfiguration(
Dictionary <string, double> parametersNameVal, ConfigurationFieldClassifier baseConfiguration, out string newParameterValue)
{
var configuration = baseConfiguration.Clone() as ConfigurationFieldClassifier;
newParameterValue = "";
foreach (var parameterNameVal in parametersNameVal)
{
var val = parameterNameVal.Value;
if (newParameterValue.Length > 0)
{
newParameterValue += ":";
}
SetConfiguration(ref newParameterValue, configuration, parameterNameVal.Key, val);
}
return(configuration);
}
public bool LoadTrainData(Stream stream, out ConfigurationFieldClassifier config, out string trainPath, IEnumerable <IFieldFeature> features)
{
try
{
var model = ModelFieldCLassify.Load(stream);
model.Ksvm.Position = 0;
m_machine = MulticlassSupportVectorMachine.Load(model.Ksvm);
// model.Bow.Position = 0;
// m_bow = BagOfVisualWords.Load<CornerFeaturePointEx>(model.Bow);
//BinaryFormatter f = new BinaryFormatter();
//model.TrainImageFeatureVectors.Position = 0;
//m_trainImageFeatureVectors = f.Deserialize(model.TrainImageFeatureVectors) as double[][];
//model.ClassIdClassNameMap.Position = 0;
//m_classIdClassNameMap = f.Deserialize(model.ClassIdClassNameMap) as Dictionary<int, string>;
config = model.Configuration;
trainPath = model.TrainPath;
m_pageThreshold = model.PageThreshold;
if (model.FeaturesScale != null && model.FeaturesScale.Count > 0)
{
foreach (var featue in features)
{
double scale;
if (model.FeaturesScale.TryGetValue(featue.Name, out scale) == true)
{
featue.FieldScale = scale;
}
}
}
}
catch
{
Reset();
config = null;
trainPath = string.Empty;
return(false);
}
return(true);
}
static public ConfigurationFieldClassifier GetDefaultConfiguration()
{
ConfigurationFieldClassifier config = new ConfigurationFieldClassifier();
config.FeatureExtraction.NoOfWords = 30;
config.FeatureExtraction.Extended = false;
config.FeatureExtraction.UseNonGoldenClass = true;
config.AccordConfiguration.Kernel = KernelTypes.ChiSquare;
config.AccordConfiguration.GaussianKernel.Sigma = 6.2;
config.AccordConfiguration.PolynominalKernel.Constant = 1.0;
config.AccordConfiguration.PolynominalKernel.Degree = 1;
config.AccordConfiguration.Complexity = 0.001;
config.AccordConfiguration.Tolerance = 0.0100;
config.AccordConfiguration.CacheSize = 500;
config.AccordConfiguration.SelectionStrategy = SelectionStrategies.WorstPair;
return(config);
}
// IKernel kernel;
public double BuildTheModel(double[][] inputs, int[] outputs, int ClassNum, ConfigurationFieldClassifier config)
{
cpuCounter.CategoryName = "Processor";
cpuCounter.CounterName = "% Processor Time";
cpuCounter.InstanceName = "_Total";
Reset();
_usenongoldenclass = config.FeatureExtraction.UseNonGoldenClass;
// scalers = scalresin;
IKernel kernal = null;
switch (config.AccordConfiguration.Kernel)
{
case KernelTypes.Gaussian:
kernal = new Gaussian(config.AccordConfiguration.GaussianKernel.Sigma);
break;
case KernelTypes.Polynomial:
kernal = new Polynomial(config.AccordConfiguration.PolynominalKernel.Degree, config.AccordConfiguration.PolynominalKernel.Constant);
break;
case KernelTypes.ChiSquare:
kernal = new ChiSquare();
break;
case KernelTypes.HistogramIntersction:
kernal = new HistogramIntersection();
break;
default:
break;
}
if (ClassNum > 2)
{
m_machine = new MulticlassSupportVectorMachine(inputs[0].Length, kernal, ClassNum);
m_teacher = (new MulticlassSupportVectorLearning((MulticlassSupportVectorMachine)m_machine, inputs, outputs));
(m_teacher as MulticlassSupportVectorLearning).Algorithm = (svm, classInputs, classOutputs, i, j) =>
{
var smo = new SequentialMinimalOptimization(svm, classInputs, classOutputs);
smo.Complexity = config.AccordConfiguration.Complexity;
smo.Tolerance = config.AccordConfiguration.Tolerance;
smo.CacheSize = config.AccordConfiguration.CacheSize;
smo.Strategy = (Accord.MachineLearning.VectorMachines.Learning.SelectionStrategy)((int)(config.AccordConfiguration.SelectionStrategy));
// smo.UseComplexityHeuristic = true;
// smo.PositiveWeight = 1;
int k = 0;
while (cpuCounter.NextValue() > 50)
{
Thread.Sleep(50);
k++;
if (k > 30000)
{
break;
}
}
// smo.NegativeWeight = 1;
smo.Run();
var probabilisticOutputLearning = new ProbabilisticOutputLearning(svm, classInputs, classOutputs);
return(probabilisticOutputLearning);
// return smo;
};
}
else
{
// FIX TO BASE TYPES THAN RUN THAN MAKE OTHER 2 CHANGES from LATEST - line ... and CLUSTER AND RUNTEST.. and check again...
m_machine = new SupportVectorMachine(inputs[0].Length);
m_teacher = new SequentialMinimalOptimization((SupportVectorMachine)m_machine, inputs, outputs);
(m_teacher as SequentialMinimalOptimization).Complexity = config.AccordConfiguration.Complexity;;
(m_teacher as SequentialMinimalOptimization).Tolerance = config.AccordConfiguration.Tolerance;
(m_teacher as SequentialMinimalOptimization).CacheSize = config.AccordConfiguration.CacheSize;
(m_teacher as SequentialMinimalOptimization).Strategy = (Accord.MachineLearning.VectorMachines.Learning.SelectionStrategy)((int)(config.AccordConfiguration.SelectionStrategy));
(m_teacher as SequentialMinimalOptimization).Complexity = config.AccordConfiguration.Complexity;;
}
// Configure the learning algorithm
// Train the machines. It should take a while.
// Thread.Sleep(10000);
//#if temp
double error = m_teacher.Run();
//#endif
// return 0;
return(error);
}
private static void SetConfiguration(ref string newParameterValue, ConfigurationFieldClassifier configuration, string parameterName, double val)
{
SetConfigurationAccord(ref newParameterValue, configuration, parameterName, val);
}
internal void AddClassifierConfiguration(ConfigurationFieldClassifier config)
{
this.SetupData.AddClassifierConfiguration(config);
}
public void AddClassifierConfiguration(ConfigurationFieldClassifier configuration)
{
(ClassifierConfigurations as IList).Add(configuration);
}
// IKernel kernel;
public double BuildTheModel(double[][] inputs, int[] outputs, int ClassNum, ConfigurationFieldClassifier config)
{
Reset();
IKernel kernal = null;
switch (config.AccordConfiguration.Kernel)
{
case KernelTypes.Gaussian:
kernal = new Gaussian(config.AccordConfiguration.GaussianKernel.Sigma);
break;
case KernelTypes.Polynomial:
kernal = new Polynomial(config.AccordConfiguration.PolynominalKernel.Degree, config.AccordConfiguration.PolynominalKernel.Constant);
break;
case KernelTypes.ChiSquare:
kernal = new ChiSquare();
break;
case KernelTypes.HistogramIntersction:
kernal = new HistogramIntersection();
break;
default:
break;
}
Tuple <double, double> estimatedComplexity = SequentialMinimalOptimization.EstimateComplexity(kernal, inputs, outputs);
machine = new MulticlassSupportVectorMachine(inputs[0].Length, kernal, ClassNum);
teacher = new MulticlassSupportVectorLearning(machine, inputs, outputs);
// Configure the learning algorithm
teacher.Algorithm = (svm, classInputs, classOutputs, i, j) =>
{
var smo = new SequentialMinimalOptimization(svm, classInputs, classOutputs);
smo.Complexity = config.AccordConfiguration.Complexity;
smo.Tolerance = config.AccordConfiguration.Tolerance;
smo.CacheSize = config.AccordConfiguration.CacheSize;
smo.Strategy = (Accord.MachineLearning.VectorMachines.Learning.SelectionStrategy)((int)(config.AccordConfiguration.SelectionStrategy));
// smo.UseComplexityHeuristic = true;
// smo.PositiveWeight = 1;
// smo.NegativeWeight = 1;
smo.Run();
var probabilisticOutputLearning = new ProbabilisticOutputLearning(svm, classInputs, classOutputs);
return(probabilisticOutputLearning);
// return smo;
};
// Train the machines. It should take a while.
// Thread.Sleep(10000);
//#if temp
double error = teacher.Run();
//#endif
// return 0;
return(error);
}
