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); }