public frmEnsembleClassifier(EnsembleClassifier classifier, frmMain frmMain) { InitializeComponent(); _frmMain = frmMain; _classifier = classifier; FillWithConfiguration(); }
public static void Test1() { AccuracyMeasure accuracyMeasure = new AccuracyMeasure(); IEnsembleClassificationStrategy majorityVote = new MajorityVoteStrategy(); IEnsembleClassificationStrategy weightedVote = new WeightedVoteStrategy(); DataMining.Data.Dataset[] tables = BatchTest2.LoadTrainingAndTestingData("audiology", 0); DataMining.Data.Dataset trainingSet = tables[0]; DataMining.Data.Dataset testingSet = tables[1]; //EnsembleClassifier ensemble = SingleTest.CreateGKAntIBMinerClassifier_ClassBaseWeights_Ensemble(trainingSet); EnsembleClassifier ensemble = SingleTest.CreateNCCAntIBMinerClassifier_ClassBasedWeights_Ensemble(trainingSet); //EnsembleClassifier ensemble = SingleTest.CreateKNNAntIBMinerClassifier_ClassBasedWeights_Ensemble(trainingSet,false); double quality1 = 0; double quality2 = 0; double quality3 = 0; quality1 += SingleTest.TestClassifier(ensemble[0], testingSet, accuracyMeasure); ensemble.Stratgy = majorityVote; quality2 += SingleTest.TestClassifier(ensemble, testingSet, accuracyMeasure); ensemble.Stratgy = weightedVote; quality3 += SingleTest.TestClassifier(ensemble, testingSet, accuracyMeasure); quality1 = Math.Round((quality1 / 1) * 100, 2); quality2 = Math.Round((quality2 / 1) * 100, 2); quality3 = Math.Round((quality3 / 1) * 100, 2); //------------------------------------------------------------------ Console.WriteLine("ACO-GKC-CB-CB: Accuracy=" + quality1); Console.WriteLine("ACO-GKC-CB-ens-MV: Accuracy=" + quality2); Console.WriteLine("ACO-GKC-CB-ens-WV: Accuracy=" + quality3); //Console.WriteLine(((KNearestNeighbours)ensemble[0]).KNeighbours.ToString()); Console.WriteLine("-------------------------------------------"); Console.WriteLine("-------------------------------------------"); Console.WriteLine("-------------------------------------------"); }
public static EnsembleClassifier CreateNCCAntIBMinerClassifier_Ensemble(Dataset trainingSet) { int classCount = trainingSet.Metadata.Target.Values.Length; int attributesCount = trainingSet.Metadata.Attributes.Length; int problemSize = attributesCount + 1; AccuracyMeasure measure = new AccuracyMeasure(); DefaultDistanceMeasure distanceMeasure = new DefaultDistanceMeasure(2); NearestClassClassifier ncc = new NearestClassClassifier(distanceMeasure, trainingSet); IBClassificationQualityEvaluator evaluator = new ContinuousACO.ProblemSpecifics.IBClassificationQualityEvaluator(ncc, measure); evaluator.LearningSet = trainingSet; evaluator.ValidationSet = trainingSet; Problem <double> problem = new Problem <double>(null, null, evaluator, null); AntIBMiner antminer = new AntIBMiner(maxIterations, colonySize, convergenceIterations, problem, problemSize, archive, q, segma, trainingSet); EnsembleClassifier aconcc = antminer.CreateEnsembleClassifier(); return(aconcc); }
public static EnsembleClassifier CreateGKPSOIBMinerClassifier_ClassBaseWeights_Ensemble(Dataset trainingSet) { int classCount = trainingSet.Metadata.Target.Values.Length; int attributesCount = trainingSet.Metadata.Attributes.Length; int problemSize = (attributesCount * classCount) + 1; AccuracyMeasure measure = new AccuracyMeasure(); DefaultDistanceMeasure distanceMeasure = new DefaultDistanceMeasure(1); GaussianKernelEstimator gke = new GaussianKernelEstimator(1, distanceMeasure, trainingSet); IBClassificationQualityEvaluator evaluator = new ContinuousACO.ProblemSpecifics.IBClassificationQualityEvaluator(gke, measure); evaluator.LearningSet = trainingSet; evaluator.ValidationSet = trainingSet; PSOIB psoIB = new PSOIB(problemSize, archive, maxIterations / archive, convergenceIterations, evaluator); psoIB.OnPostSwarmIteration += OnPostColonyIteration; EnsembleClassifier psogke = psoIB.CreateEnsembleClassifier(); return(psogke); }
public static EnsembleClassifier CreateNCCPSOIBMinerClassifier_Ensemble(Dataset trainingSet) { int classCount = trainingSet.Metadata.Target.Values.Length; int attributesCount = trainingSet.Metadata.Attributes.Length; int problemSize = attributesCount + 1; AccuracyMeasure measure = new AccuracyMeasure(); DefaultDistanceMeasure distanceMeasure = new DefaultDistanceMeasure(2); NearestClassClassifier ncc = new NearestClassClassifier(distanceMeasure, trainingSet); IBClassificationQualityEvaluator evaluator = new ContinuousACO.ProblemSpecifics.IBClassificationQualityEvaluator(ncc, measure); evaluator.LearningSet = trainingSet; evaluator.ValidationSet = trainingSet; PSOIB psoIB = new PSOIB(problemSize, archive, maxIterations / archive, convergenceIterations, evaluator); psoIB.OnPostSwarmIteration += OnPostColonyIteration; EnsembleClassifier psoncc = psoIB.CreateEnsembleClassifier(); return(psoncc); }
public static EnsembleClassifier CreateKNNPSOIBMinerClassifier_ClassBasedWeights_Ensemble(Dataset trainingSet, bool useWeightedVote) { int classCount = trainingSet.Metadata.Target.Values.Length; int attributesCount = trainingSet.Metadata.Attributes.Length; int problemSize = (attributesCount * classCount) + 1; AccuracyMeasure measure = new AccuracyMeasure(); DefaultDistanceMeasure distanceMeasure = new DefaultDistanceMeasure(2); KNearestNeighbours knn = new KNearestNeighbours(distanceMeasure, trainingSet, useWeightedVote); IBClassificationQualityEvaluator evaluator = new ContinuousACO.ProblemSpecifics.IBClassificationQualityEvaluator(knn, measure); evaluator.LearningSet = trainingSet; evaluator.ValidationSet = trainingSet; PSOIB psoIB = new PSOIB(problemSize, archive, maxIterations / archive, convergenceIterations, evaluator); psoIB.OnPostSwarmIteration += OnPostColonyIteration; EnsembleClassifier psoknn = psoIB.CreateEnsembleClassifier(); return(psoknn); }
private static IDetector LoadDetector(IObjectModel objectModel) { // scanning window generator IScanningWindowGenerator scanningWindowGenerator = new ScanningWindowGenerator ( 1.2f, 0.1f, 0.1f, 100 ); // cascaded classifier // variance classifier IClassifier varianceClassifier = new VarianceClassifier(scanningWindowGenerator, 0.5); // ensemble classifier int width = objectModel.PatchSize.Width; int height = objectModel.PatchSize.Height; IPixelComparisonScheduler pcs = new PixelComparisonScheduler(12, 3, width, height); IClassifier ensembleClassifier = new EnsembleClassifier(scanningWindowGenerator, pcs, 2); // nn classifier NnClassifier nnClassifier = new NnClassifier(scanningWindowGenerator, objectModel, 0.75f, 0.55f); // instantiate cascaded classifier IClassifier cascadedClassifier = new CascadedClassifier(varianceClassifier, ensembleClassifier, nnClassifier); IDetector detector = new Detector ( scanningWindowGenerator, cascadedClassifier, Service.NonMaximalBoundingBoxSuppress ); return(detector); }
public Learner( IObjectModel objectModel, IDetector detector, PositivePatchSynthesisInfo initPositivePatchSysthesisInfo, NegativePatchPickingInfo initNegativePatchPickingInfo, PositivePatchSynthesisInfo runtimePositivePatchSysthesisInfo, NegativePatchPickingInfo runtimeNegativePatchPickingInfo, float sameSimilarityThreshold, float validConservativeSimilarityThreshold ) { _objectModel = objectModel; _detector = detector; _initPositivePatchSynthesisInfo = initPositivePatchSysthesisInfo; _initNegativePatchPickingInfo = initNegativePatchPickingInfo; _runtimePosPatchSynthesisInfo = runtimePositivePatchSysthesisInfo; _runtimeNegativePatchPickingInfo = runtimeNegativePatchPickingInfo; _sameSimilarityThreshold = sameSimilarityThreshold; _validConservativeSimilarityThreshold = validConservativeSimilarityThreshold; _varianceClassifier = ((_detector as Detector).CascadedClassifier as CascadedClassifier).VarianceClassifier as VarianceClassifier; _ensembleClassifier = ((_detector as Detector).CascadedClassifier as CascadedClassifier).EnsembleClassifier as EnsembleClassifier; _nnClassifier = ((_detector as Detector).CascadedClassifier as CascadedClassifier).NnClassifier as NnClassifier; }
public static EnsembleClassifier CreateGKAntIBMinerClassifier_ClassBaseWeights_Ensemble(Dataset trainingSet) { int classCount = trainingSet.Metadata.Target.Values.Length; int attributesCount = trainingSet.Metadata.Attributes.Length; int problemSize = (attributesCount * classCount) + 1; AccuracyMeasure measure = new AccuracyMeasure(); DefaultDistanceMeasure distanceMeasure = new DefaultDistanceMeasure(1); GaussianKernelEstimator gke = new GaussianKernelEstimator(0.5, distanceMeasure, trainingSet); IBClassificationQualityEvaluator evaluator = new ContinuousACO.ProblemSpecifics.IBClassificationQualityEvaluator(gke, measure); evaluator.LearningSet = trainingSet; evaluator.ValidationSet = trainingSet; Problem <double> problem = new Problem <double>(null, null, evaluator, null); AntIBMiner antminer = new AntIBMiner(maxIterations, colonySize, convergenceIterations, problem, problemSize, archive, q, segma, trainingSet); antminer.OnPostColonyIteration += OnPostColonyIteration; EnsembleClassifier acogke = antminer.CreateEnsembleClassifier(); return(acogke); }
public static EnsembleClassifier CreateKNNAntIBMinerClassifier_ClassBasedWeights_Ensemble(Dataset trainingSet, bool useWeightedVote) { int classCount = trainingSet.Metadata.Target.Values.Length; int attributesCount = trainingSet.Metadata.Attributes.Length; int problemSize = (attributesCount * classCount) + 1; AccuracyMeasure measure = new AccuracyMeasure(); DefaultDistanceMeasure distanceMeasure = new DefaultDistanceMeasure(2); KNearestNeighbours knn = new KNearestNeighbours(distanceMeasure, trainingSet, useWeightedVote); IBClassificationQualityEvaluator evaluator = new ContinuousACO.ProblemSpecifics.IBClassificationQualityEvaluator(knn, measure); evaluator.LearningSet = trainingSet; evaluator.ValidationSet = trainingSet; Problem <double> problem = new Problem <double>(null, null, evaluator, null); AntIBMiner antminer = new AntIBMiner(maxIterations, colonySize, convergenceIterations, problem, problemSize, archive, q, segma, trainingSet); antminer.OnPostColonyIteration += OnPostColonyIteration; EnsembleClassifier acoknn = antminer.CreateEnsembleClassifier(); return(acoknn); }
public void GetPosteriors_InitializationAndOneMethodCall() { // arrange - generate pixel comparisons PixelComparisonGroupF pcg1 = new PixelComparisonGroupF(); pcg1.Value = new PixelComparisonF[] { new PixelComparisonF(new PointF(0, 0.5f), new PointF(0.5f, 0.5f)), new PixelComparisonF(new PointF(0.5f, 0), new PointF(0.5f, 0.5f)), new PixelComparisonF(new PointF(1, 0.5f), new PointF(0.5f, 0.5f)), new PixelComparisonF(new PointF(0.5f, 1), new PointF(0.5f, 0.5f)) }; PixelComparisonGroupF pcg2 = new PixelComparisonGroupF(); pcg2.Value = new PixelComparisonF[] { new PixelComparisonF(new PointF(0, 0.5f), new PointF(0.5f, 0.5f)), new PixelComparisonF(new PointF(0.5f, 0), new PointF(0.5f, 0.5f)), new PixelComparisonF(new PointF(1, 0.5f), new PointF(0.5f, 0.5f)), new PixelComparisonF(new PointF(0.5f, 1), new PointF(0.5f, 0.5f)) }; IPixelComparisonScheduler pxs = new PixelComparisonSchedulerStub( new PixelComparisonGroupF[] { pcg1, pcg2 } ); // arrange - instantiate ensamble classifier ScanningWindowGeneratorStub swgEnsemble = new ScanningWindowGeneratorStub(); IBoundingBox positiveScanningWindow = new BoundingBox(new PointF(480, 364), new SizeF(277, 217)); swgEnsemble.ScanningWindows = new IBoundingBox[] { new BoundingBox(new PointF(163, 132), new SizeF(288, 220)), new BoundingBox(new PointF(478, 127), new SizeF(300, 199)), new BoundingBox(new PointF(150, 355), new SizeF(290, 214)), positiveScanningWindow, }; foreach (IBoundingBox bb in swgEnsemble.ScanningWindows) { bb.ScanningWindow = bb.CreateScanningWindow(); } EnsembleClassifier classifier = new EnsembleClassifier(swgEnsemble, pxs, 1.5); classifier.PostInstantiation(); // arrange - define initialization frame and bb Image <Gray, byte> initFrame = new Image <Gray, byte>(Path.Combine(_resourceDir, "LP_up_left.jpg")); IBoundingBox initBb = new BoundingBox(new PointF(170, 150), new SizeF(269, 189)); // arrange - initialize ensemble classifier classifier.Initialize(initFrame, initBb); // arrange - generate positive and negative patches // -> positive patches List <Image <Gray, byte> > positivePatches = new List <Image <Gray, byte> >(); int positiveCount = 100; for (int i = 0; i < positiveCount; i++) { Image <Gray, byte> patch = Service.GenerateSimilarPatch(initFrame, initBb, 0, 0, 0); CvInvoke.cvSmooth(patch, patch, SMOOTH_TYPE.CV_GAUSSIAN, 0, 0, 1.5, 1.5); positivePatches.Add(patch); } // -> negative patches IScanningWindowGenerator swg = new ScanningWindowGenerator(1.5f, 0.7f, 0.7f, 30); List <IBoundingBox> scanningWindows = swg.Generate(initFrame.Size, initBb).ToList(); List <IBoundingBox> sortedScanningWindows = Service.SortScanningWindowsByOverlap(scanningWindows, initBb); List <IBoundingBox> negativeScanningWindows = Service.GetScanningWindowsWithOverlapLessThan(0.2f, initBb, sortedScanningWindows); List <Image <Gray, byte> > negativePatches = new List <Image <Gray, byte> >(); int negativeCount = 100; int step = negativeScanningWindows.Count / negativeCount; for (int i = 0; i < negativeCount; i++) { IBoundingBox bb = negativeScanningWindows[i * step]; negativePatches.Add(initFrame.GetPatch(bb.Center, Size.Round(bb.Size))); } // update classifier with new positive and negative patches classifier.Update(positivePatches, negativePatches); // arrange - define current frame Image <Gray, byte> currentFrame = new Image <Gray, byte>(Path.Combine(_resourceDir, "LP_down_right.jpg")); // define expected List <int> expected = new List <int>() { 3 }; // get actual List <int> actual = classifier.AcceptedWindows(currentFrame, new List <int> { 0, 1, 2, 3 }); // assert CollectionAssert.AreEqual(expected, actual); }
public static void RunPSOIBL() { AccuracyMeasure accuracyMeasure = new AccuracyMeasure(); IEnsembleClassificationStrategy majorityVote = new MajorityVoteStrategy(); IEnsembleClassificationStrategy weightedVote = new WeightedVoteStrategy(); foreach (string dataset in GetDatasetFolds(DatasetNamesFile)) { //---------------------------------------- Console.WriteLine("Data Table:" + dataset); //---------------------------------------- #region PSO-KNN-CB try { double quality1 = 0; //double quality2 = 0; double quality3 = 0; for (_currentFold = 0; _currentFold < _folds; _currentFold++) { //---------------------------------------- Console.WriteLine("Fold:" + _currentFold.ToString()); //---------------------------------------- DataMining.Data.Dataset[] tables = LoadTrainingAndTestingData(dataset, _currentFold); DataMining.Data.Dataset trainingSet = tables[0]; DataMining.Data.Dataset testingSet = tables[1]; EnsembleClassifier ensemble = SingleTest.CreateKNNPSOIBMinerClassifier_ClassBasedWeights_Ensemble(trainingSet, false); quality1 += SingleTest.TestClassifier(ensemble[0], testingSet, accuracyMeasure); ensemble.Stratgy = majorityVote; //quality2 += SingleTest.TestClassifier(ensemble, testingSet, accuracyMeasure); ensemble.Stratgy = weightedVote; quality3 += SingleTest.TestClassifier(ensemble, testingSet, accuracyMeasure); } quality1 = Math.Round((quality1 / _folds) * 100, 2); // quality2 = Math.Round((quality2 / _folds) * 100, 2); quality3 = Math.Round((quality3 / _folds) * 100, 2); //------------------------------------------------------------------ Console.WriteLine("PSO-KNN-CB: " + dataset + " - Accuracy=" + quality1); SaveResults(dataset, "PSO-KNN-CB", quality1.ToString()); //Console.WriteLine("PSO-KNN-CB-ens-MV: " + dataset + " - Accuracy=" + quality2); //SaveResults(dataset, "PSO-KNN-CB-ens-MV",quality2.ToString()); Console.WriteLine("PSO-KNN-CB-ens-WV: " + dataset + " - Accuracy=" + quality3); SaveResults(dataset, "PSO-KNN-CB-ens-WV", quality3.ToString()); Console.WriteLine("-------------------------------------------"); Console.WriteLine("-------------------------------------------"); Console.WriteLine("-------------------------------------------"); } catch (Exception ex) { // LogError(ex); // Console.WriteLine(ex.Message); } #endregion #region PSO-KNN-CB-WV //try //{ // double quality1 = 0; // double quality2 = 0; // double quality3 = 0; // for (_currentFold = 0; _currentFold < _folds; _currentFold++) // { // //---------------------------------------- // Console.WriteLine("Fold:" + _currentFold.ToString()); // //---------------------------------------- // DataMining.Data.Dataset[] tables = LoadTrainingAndTestingData(dataset, _currentFold); // DataMining.Data.Dataset trainingSet = tables[0]; // DataMining.Data.Dataset testingSet = tables[1]; // EnsembleClassifier ensemble = SingleTest.CreateKNNPSOIBMinerClassifier_ClassBasedWeights_Ensemble(trainingSet, true); // quality1 += SingleTest.TestClassifier(ensemble[0], testingSet, accuracyMeasure); // ensemble.Stratgy = majorityVote; // quality2 += SingleTest.TestClassifier(ensemble, testingSet, accuracyMeasure); // ensemble.Stratgy = weightedVote; // quality3 += SingleTest.TestClassifier(ensemble, testingSet, accuracyMeasure); // } // quality1 = Math.Round((quality1 / _folds) * 100, 2); // quality2 = Math.Round((quality2 / _folds) * 100, 2); // quality3 = Math.Round((quality3 / _folds) * 100, 2); // //------------------------------------------------------------------ // Console.WriteLine("PSO-KNN-CB-WV: " + dataset + " - Accuracy=" + quality1); // SaveResults(dataset, "PSO-KNN-CB-WV", k.ToString(), quality1.ToString()); // Console.WriteLine("PSO-KNN-CB-WV-ens-MV: " + dataset + " - Accuracy=" + quality2); // SaveResults(dataset, "PSO-KNN-CB-WV-ens-MV", k.ToString(), quality2.ToString()); // Console.WriteLine("PSO-KNN-CB-WV-ens-WV: " + dataset + " - Accuracy=" + quality3); // SaveResults(dataset, "PSO-KNN-CB-WV-ens-WV", k.ToString(), quality3.ToString()); // Console.WriteLine("-------------------------------------------"); // Console.WriteLine("-------------------------------------------"); // Console.WriteLine("-------------------------------------------"); //} //catch (Exception ex) //{ // LogError(ex); // // Console.WriteLine(ex.Message); //} #endregion #region PSO-NCC-CB try { double quality1 = 0; //double quality2 = 0; double quality3 = 0; for (_currentFold = 0; _currentFold < _folds; _currentFold++) { //---------------------------------------- Console.WriteLine("Fold:" + _currentFold.ToString()); //---------------------------------------- DataMining.Data.Dataset[] tables = LoadTrainingAndTestingData(dataset, _currentFold); DataMining.Data.Dataset trainingSet = tables[0]; DataMining.Data.Dataset testingSet = tables[1]; EnsembleClassifier ensemble = SingleTest.CreateNCCPSOIBMinerClassifier_ClassBasedWeights_Ensemble(trainingSet); quality1 += SingleTest.TestClassifier(ensemble[0], testingSet, accuracyMeasure); //ensemble.Stratgy = majorityVote; //quality2 += SingleTest.TestClassifier(ensemble, testingSet, accuracyMeasure); ensemble.Stratgy = weightedVote; quality3 += SingleTest.TestClassifier(ensemble, testingSet, accuracyMeasure); } quality1 = Math.Round((quality1 / _folds) * 100, 2); //quality2 = Math.Round((quality2 / _folds) * 100, 2); quality3 = Math.Round((quality3 / _folds) * 100, 2); //------------------------------------------------------------------ Console.WriteLine("PSO-NCC-CB: " + dataset + " - Accuracy=" + quality1); SaveResults(dataset, "PSO-NNC-CB", quality1.ToString()); //Console.WriteLine("PSO-NNC-CB-ens-MV: " + dataset + " - Accuracy=" + quality2); //SaveResults(dataset, "PSO-NNC-CB-ens-MV", quality2.ToString()); Console.WriteLine("PSO-NNC-CB-ens-WV: " + dataset + " - Accuracy=" + quality3); SaveResults(dataset, "PSO-NNC-CB-ens-WV", quality3.ToString()); Console.WriteLine("-------------------------------------------"); Console.WriteLine("-------------------------------------------"); Console.WriteLine("-------------------------------------------"); } catch (Exception ex) { LogError(ex); // Console.WriteLine(ex.Message); } #endregion #region PSO-GKC-CB try { double quality1 = 0; //double quality2 = 0; double quality3 = 0; for (_currentFold = 0; _currentFold < _folds; _currentFold++) { //---------------------------------------- Console.WriteLine("Fold:" + _currentFold.ToString()); //---------------------------------------- DataMining.Data.Dataset[] tables = LoadTrainingAndTestingData(dataset, _currentFold); DataMining.Data.Dataset trainingSet = tables[0]; DataMining.Data.Dataset testingSet = tables[1]; EnsembleClassifier ensemble = SingleTest.CreateGKPSOIBMinerClassifier_ClassBaseWeights_Ensemble(trainingSet); quality1 += SingleTest.TestClassifier(ensemble[0], testingSet, accuracyMeasure); //ensemble.Stratgy = majorityVote; //quality2 += SingleTest.TestClassifier(ensemble, testingSet, accuracyMeasure); ensemble.Stratgy = weightedVote; quality3 += SingleTest.TestClassifier(ensemble, testingSet, accuracyMeasure); } quality1 = Math.Round((quality1 / _folds) * 100, 2); //quality2 = Math.Round((quality2 / _folds) * 100, 2); quality3 = Math.Round((quality3 / _folds) * 100, 2); //------------------------------------------------------------------ Console.WriteLine("PSO-GKC-CB-CB: " + dataset + " - Accuracy=" + quality1); SaveResults(dataset, "PSO-GKC-CB", quality1.ToString()); //Console.WriteLine("PSO-GKC-CB-ens-MV: " + dataset + " - Accuracy=" + quality2); //SaveResults(dataset, "PSO-GKC-CB-ens-MV", quality2.ToString()); Console.WriteLine("PSO-GKC-CB-ens-WV: " + dataset + " - Accuracy=" + quality3); SaveResults(dataset, "PSO-GKC-CB-ens-WV", quality3.ToString()); Console.WriteLine("-------------------------------------------"); Console.WriteLine("-------------------------------------------"); Console.WriteLine("-------------------------------------------"); } catch (Exception ex) { LogError(ex); // Console.WriteLine(ex.Message); } #endregion } }