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