public void SanFranciscoCrimeSVMClassificationDataSetTest()
{
DataSetLoader dataSetLoader = new DataSetLoader();
Console.WriteLine(" Reading DataSet.. ");
var crimes = dataSetLoader.SelectCrimes();
Kernel kernel = new GaussianKernel(0.9);
SVMClassifier svmClassifier =
new SVMClassifier(crimes, kernel);
svmClassifier.Train();
var crimeTests = dataSetLoader.SelectCrimes();
var trueCounter = 0;
var counter = 0;
foreach (var item in crimeTests)
{
var outputValue = svmClassifier.Classify(item.Item1);
if (outputValue == item.Item2)
{
trueCounter++;
}
Debug.WriteLine(string.Format("Value {0} - Predicted {1} = {2}",
item.Item2, outputValue, (outputValue == item.Item2) ? "true" : "false"));
counter++;
}
Debug.WriteLine(string.Format("Data {0} - True {1} Verhältnis: {2}",
counter.ToString(), trueCounter.ToString(), (Convert.ToDouble(trueCounter) / Convert.ToDouble(counter)).ToString()));
}
public void CreditDataClassifyMethod()
{
DataSetLoader dataSetLoader = new DataSetLoader();
var creditData = dataSetLoader.SelectCreditData();
var data = dataSetLoader.CalculatePercent(100, creditData);
DecisionTreeClassifier decisionTreeClassifier =
new DecisionTreeClassifier(data.Item1, new ShannonEntropySplitter());
NaiveBayesClassifier naiveBayes =
new NaiveBayesClassifier(data.Item1);
var list = new List <NetML.Classification>();
Kernel kernel = new LinearKernel();
SVMClassifier SVMClassifier =
new SVMClassifier(creditData, kernel, 0.001, 10.0);
var neuronalCreditData = dataSetLoader.SelectNeuronalNetworksCreditData();
NeuronalNetworkClassifier neuronalNetworkClassifier =
new NeuronalNetworkClassifier(neuronalCreditData, 20, 2, 20, 5000, 0.1);
list.Add(decisionTreeClassifier);
list.Add(naiveBayes);
list.Add(SVMClassifier);
//list.Add(neuronalNetworkClassifier);
Classifier classifier = new Classifier();
classifier.Classify(list, creditData);
}
public void AnimalClassifyMethod()
{
DataSetLoader dataSetLoader = new DataSetLoader();
var animals = dataSetLoader.SelectAnimals();
var data = dataSetLoader.CalculatePercent(50, animals);
DecisionTreeClassifier decisionTreeClassifier =
new DecisionTreeClassifier(data.Item1, new ShannonEntropySplitter());
NaiveBayesClassifier naiveBayes =
new NaiveBayesClassifier(data.Item1);
var list = new List <NetML.Classification>();
Kernel kernel = new LinearKernel();
SVMClassifier animalSVMClassifier =
new SVMClassifier(animals, kernel, 0.001, 10.0);
var neuronalAnimals = dataSetLoader.SelectNeuronalNetworkAnimals();
NeuronalNetworkClassifier neuronalNetworkClassifier =
new NeuronalNetworkClassifier(neuronalAnimals, 16, 7, 16, 500, 0.1);
list.Add(decisionTreeClassifier);
list.Add(naiveBayes);
list.Add(animalSVMClassifier);
list.Add(neuronalNetworkClassifier);
Classifier classifier = new Classifier();
classifier.Classify(list, data.Item2);
}
public void IrisSupportVectorMachineClassifierTest()
{
DataSetLoader dataSetLoader = new DataSetLoader();
Console.WriteLine(" Reading DataSet.. ");
var irises = dataSetLoader.SelectIrises();
for (double i = 0; i < 1; i = i + 1)
{
Kernel kernel = new LinearKernel();
SVMClassifier animalSVMClassifier = new SVMClassifier(irises, kernel, 0.001, 10.0);
animalSVMClassifier.Train();
var irisesTest = dataSetLoader.SelectIrises();
var trueCounter = 0;
var counter = 0;
foreach (var item in irisesTest)
{
var outputValue = animalSVMClassifier.Classify(item.Item1);
if (outputValue == item.Item2)
{
trueCounter++;
}
Debug.WriteLine(string.Format("Value {0} - Predicted {1} = {2}",
item.Item2, outputValue, (outputValue == item.Item2) ? "true" : "false"));
counter++;
}
Debug.WriteLine(string.Format(" i = {0} Data {1} - True {2} Verhältnis: {3}", i,
counter.ToString(), trueCounter.ToString(), (Convert.ToDouble(trueCounter) / Convert.ToDouble(counter)).ToString()));
}
}
/// <summary>
///
/// </summary>
/// <param name="tomatoSets">
/// The tomato set divided into training and validation.
/// In the training set, the classificator learns the svm params.
/// The classifier predicts label on the validation set.
/// </param>
public Controller(
IDictionary <SetType, List <Tomato> > tomatoSets)
{
this.images = new List <VisualEvent>();
imageExtractor = new LBPExtractor(true);
imageExtractor.VisualEventManager += OnImageComputed;
classifier = new TomatoClassifier(new LBPExtractor(false), SVMClassifier.Linear(0.43f));
this.tomatoSets = tomatoSets;
}
private static void TryNeuralNetwork()
{
Directory.EnumerateFiles(@"D:\dataset\easy\wrong_segmentation").ToList().ForEach(File.Delete);
Directory.EnumerateFiles(@"D:\dataset\easy\wrong_segmentation_whole").ToList().ForEach(File.Delete);
var dictionary = new Dictionary <char, int>();
int counter = 0, failed = 0, failed_letters = 0;
//IClassifier classifier = new NnLetterClassifier("models/experiment-17/model");
//IClassifier classifier = new RNNClassifier("models/seq/model");
IClassifier classifier = new SVMClassifier(@"models\best.yaml");
//classifier.Recognize(new List<ComputeResult> { new ComputeResult("") { Letters = new List<Bitmap> { (Bitmap)Image.FromFile("D:\\test.bmp") } } });
using (var compute = new ParallelCompute(new ImageProcessorOpenCv(), classifier))
{
Console.Clear();
foreach (var computeResult in compute.Compute(Directory.EnumerateFiles(@"C:\grzego\read")))
{
Console.SetCursorPosition(0, 0);
++counter;
string fileName = Path.GetFileNameWithoutExtension(computeResult.ImagePath);
string correctCode = Path.GetFileNameWithoutExtension(computeResult.ImagePath).Replace("-", string.Empty);
if (computeResult.PredictedCodeLetters == null || correctCode != computeResult.PredictedCodeLetters)
{
++failed;
}
if (computeResult.PredictedCodeLetters != null && correctCode != computeResult.PredictedCodeLetters)
{
File.Copy(computeResult.ImagePath, @"D:\dataset\easy\wrong_segmentation_whole\" + fileName + ".jpg", true);
for (int i = 0; i < 25; ++i)
{
if (correctCode[i] != computeResult.PredictedCodeLetters[i])
{
if (!dictionary.ContainsKey(correctCode[i]))
{
dictionary.Add(correctCode[i], 0);
}
computeResult.Letters[i].Save(@"D:\dataset\easy\wrong_segmentation\" +
$"{correctCode[i]}_predicted={computeResult.PredictedCodeLetters[i]}_{fileName}_{dictionary[correctCode[i]]}.bmp", ImageFormat.Bmp);
++failed_letters;
++dictionary[correctCode[i]];
}
}
}
//File.Move(computeResult.ImagePath, Path.Combine(@"D:\SO#138270\SO#138270", computeResult.PredictedCode + ".jpg"));
Console.WriteLine($"Total: {counter} Bad: {failed}/{counter} Failed letters: {failed_letters}/{counter * 25}.");
computeResult.Dispose();
}
}
classifier.Dispose();
}
public void LoadTrainData(string trainDataPath)
{
TrainDataPath = trainDataPath;
if (!Directory.GetFiles(trainDataPath).Any())
{
return;
}
var features = FeatureLoader.GetObservations(trainDataPath);
SvmClassifier = SVMClassifier.Create(features);
}
public static ConfusionMatrix Validate(List <ImageFeatures> train, List <ImageFeatures> validation)
{
var svmClassifier = SVMClassifier.Create(train);
var confusionMatrix = new ConfusionMatrix();
foreach (var validationObservation in validation)
{
var predict = svmClassifier.Predict(validationObservation);
confusionMatrix.AddVote(actual: validationObservation.IsOccupied, predicted: predict);
}
return(confusionMatrix);
}
public override double ExecuteCommand()
{
FeatureVectorFile vectorFile = new FeatureVectorFile(path: vector_file, noOfHeaderColumns: 1, featureDelimiter: ':', isSortRequired: true);
FeatureVectorFile modelFile = new FeatureVectorFile(path: model_file, noOfHeaderColumns: 1, featureDelimiter: ':', isSortRequired: true);
int alphaColumn_i = 0;
TextIdMapper[] headerToHeaderIds_model = new TextIdMapper[modelFile.NoOfHeaderColumns];
headerToHeaderIds_model[alphaColumn_i] = new TextIdMapper();
var accuracy = Program.ReportOnModel(vectorFile, sys_output
, classifierFactory: (classToClassId, featureToFeatureId) =>
{
return(SVMClassifier.LoadModel(modelFile, classToClassId, featureToFeatureId, alphaColumn_i, headerToHeaderIds_model));
}
, getDetailsFunc: GetDetails
);
return(accuracy);
}
static void Main(string[] args)
{
ImageUnderstandingConfig config = ImageUnderstandingConfig.ImportSettings();
Console.WriteLine("Feature Generation: [" + config.featureGeneratorMethod + "]");
Console.WriteLine("Classification: [" + config.classifierMethod + "]\n");
Console.WriteLine("SoftNormalization: [" + config.UseSoftNormalization + "]\n");
// some parameters
string path = config.path;
int foldCount = config.FoldCount;
int testFoldCount = config.TestFoldCount;
string[] restrictTo = config.RestrictTo;
string[] ignoreTags = config.IgnoreTags;
// get all images
List <TaggedImage> images = new List <TaggedImage>();
Dictionary <string, int> tagIndices = new Dictionary <string, int>();
foreach (string folderPath in Directory.GetDirectories(path))
{
foreach (string imagePath in Directory.GetFiles(folderPath))
{
TaggedImage image = new TaggedImage(imagePath);
if (ignoreTags.Contains(image.Tag) || (restrictTo.Length != 0 && !restrictTo.Contains(image.Tag)))
{
continue;
}
images.Add(image);
if (!tagIndices.ContainsKey(image.Tag))
{
tagIndices.Add(image.Tag, tagIndices.Count);
}
}
}
Console.WriteLine("starting feature vector generation [" + config.featureGeneratorMethod + "]\n");
////////////////////////////////////////////////////////////////////////////////////////////////////
// FEATURE GENERATOR //
////////////////////////////////////////////////////////////////////////////////////////////////////
FeatureGenerator <TaggedImage, float> featureGenerator;
switch (config.featureGeneratorMethod)
{
case ImageUnderstandingConfig.FeatureGeneratorMethod.HOG:
featureGenerator = new HOGFeatureGenerator();
break;
case ImageUnderstandingConfig.FeatureGeneratorMethod.SIFT:
featureGenerator = new SIFTFeatureGenerator();
break;
case ImageUnderstandingConfig.FeatureGeneratorMethod.Random:
featureGenerator = new RandomFeatureGenerator();
break;
case ImageUnderstandingConfig.FeatureGeneratorMethod.Unity:
featureGenerator = new UnityFeatureGenerator();
break;
default:
throw new Exception("Unknown Feature Generator Method");
}
featureGenerator.InitializeViaConfig(config);
string tag = "";
foreach (TaggedImage image in images)
{
if (tag != image.Tag)
{
Console.WriteLine("generating feature vector: [" + image.Tag + "]");
tag = image.Tag;
}
image.FeatureVector = featureGenerator.GetFeatureVector(image);
}
featureGenerator.Dispose();
if (config.UseSoftNormalization)
{
SoftNormalizeFeatureVectors(images);
}
////////////////////////////////////////////////////////////////////////////////////////////////////
// FOLD ORGANIZER //
////////////////////////////////////////////////////////////////////////////////////////////////////
FoldOrganizer <TaggedImage, string> foldOrganizer = new FoldOrganizer <TaggedImage, string>(images, foldCount, testFoldCount);
////////////////////////////////////////////////////////////////////////////////////////////////////
// CONFUSION MATRIX //
////////////////////////////////////////////////////////////////////////////////////////////////////
Mat confusionMatrix = new Mat(tagIndices.Count, tagIndices.Count, DepthType.Cv32F, 1);
// initialize with zeros
for (int y = 0; y < confusionMatrix.Rows; ++y)
{
for (int x = 0; x < confusionMatrix.Cols; ++x)
{
confusionMatrix.SetValue(x, y, 0F);
}
}
Console.WriteLine("\nstarting Classification. [" + config.classifierMethod + "]");
for (int iteration = 0; iteration < foldCount; ++iteration)
{
Console.WriteLine("\ncurrent iteration: " + iteration);
Console.WriteLine("train classifier (" + iteration + ")");
////////////////////////////////////////////////////////////////////////////////////////////////////
// CLASSIFIER //
////////////////////////////////////////////////////////////////////////////////////////////////////
Classifier.Classifier <TaggedImage, string, float> classifier;
switch (config.classifierMethod)
{
case ImageUnderstandingConfig.ClassifierMethod.KNearest:
classifier = new KNearestClassifier();
break;
case ImageUnderstandingConfig.ClassifierMethod.Random:
classifier = new RandomClassifier <TaggedImage, string, float>();
break;
case ImageUnderstandingConfig.ClassifierMethod.SingleResult:
classifier = new SingleResultClassifier();
break;
case ImageUnderstandingConfig.ClassifierMethod.SVM:
classifier = new SVMClassifier();
break;
default:
throw new Exception("Unknown Classifier Method");
}
classifier.InitializeViaConfig(config);
classifier.Train(foldOrganizer.GetTrainingData(iteration));
// evaluate Test set
Console.WriteLine("testing (" + iteration + ")");
List <TaggedImage> testSet = foldOrganizer.GetTestData(iteration);
foreach (TaggedImage testDataSample in testSet)
{
string evaluatedTag = classifier.Evaluate(testDataSample);
int indexOfRealTag = tagIndices[testDataSample.Tag];
int indexOfEvaluatedTag = tagIndices[evaluatedTag];
float value = confusionMatrix.GetValue(indexOfRealTag, indexOfEvaluatedTag);
value += 1F / (float)foldOrganizer.GetTotalDataCount(testDataSample.Tag);
confusionMatrix.SetValue(indexOfRealTag, indexOfEvaluatedTag, value);
}
classifier.Dispose();
foreach (KeyValuePair <string, int> tagIndexPair in tagIndices)
{
float accuracy = confusionMatrix.GetValue(tagIndexPair.Value, tagIndexPair.Value);
Console.WriteLine("accuracy = " + string.Format("{0,12:#.0000}%", (accuracy * 100)) + ",\t " + tagIndexPair.Key);
//Console.WriteLine("accuracy = " + accuracy + ",\t " + tagIndexPair.Key);
}
}
float totalAccuracy = 0F;
List <float> accuracies = new List <float>();
foreach (KeyValuePair <string, int> tagIndexPair in tagIndices)
{
accuracies.Add(confusionMatrix.GetValue(tagIndexPair.Value, tagIndexPair.Value));
totalAccuracy += confusionMatrix.GetValue(tagIndexPair.Value, tagIndexPair.Value) / tagIndices.Count;
}
Console.WriteLine("total accuracy = " + string.Format("{0,12:#.0000}%", (totalAccuracy * 100)));
Console.WriteLine("stdDeviation over all total accuracies = " + accuracies.ToArray().StdDeviation());
for (int x = 0; x < tagIndices.Count; ++x)
{
for (int y = 0; y < tagIndices.Count; ++y)
{
confusionMatrix.SetValue(x, y, (float)Math.Sqrt(Math.Sqrt(confusionMatrix.GetValue(x, y))));
}
}
// perform Tests
string s;
Test.Test t = new Test.FoldOrganizer_Test();
t.PerformTest(out s);
Console.WriteLine(s);
//visualize accuracy
{
String win1 = "Confusion Matrix"; //The name of the window
CvInvoke.NamedWindow(win1); //Create the window using the specific name
int confusionMatrixScale = 5;
Mat scaledConfusionMatrix = new Mat(confusionMatrix.Cols * confusionMatrixScale, confusionMatrix.Rows * confusionMatrixScale, confusionMatrix.Depth, confusionMatrix.NumberOfChannels);
for (int y = 0; y < scaledConfusionMatrix.Rows; ++y)
{
for (int x = 0; x < scaledConfusionMatrix.Cols; ++x)
{
scaledConfusionMatrix.SetValue(x, y, (float)confusionMatrix.GetValue(x / confusionMatrixScale, y / confusionMatrixScale));
}
}
CvInvoke.Imshow(win1, scaledConfusionMatrix); //Show the image
CvInvoke.WaitKey(0); //Wait for the key pressing event
CvInvoke.DestroyWindow(win1); //Destroy the window if key is pressed
}
}
static TomatoClassifier standardClassifier()
{
var extractor = new LBPExtractor(false);
return(new TomatoClassifier(extractor, SVMClassifier.Linear(0.43f))); //best performance with 0.43
}
private void detectBtn_Click(object sender, EventArgs e)
{
StringValues sv = new StringValues();
Bitmap bmp = new Bitmap(inputFilePath);
int xmax = bmp.Width;
int ymax = bmp.Height;
Bitmap bwimage = processImage(bmp);
int[] xaxis = new int[xmax];
int[] yline = new int[ymax];
int[] tempx = new int[xmax];
int[] tempy = new int[ymax];
int i = 1, j = 1;
//calculated y axis
yaxis = getYArray(xmax, ymax, bwimage);
//todo- calculate yaxis for each character and store it.
xaxis = getXArray(xmax, ymax, bwimage, yline);
int k;
Bitmap[] croppedImg = new Bitmap[30];
for (i = 1, j = 2, k = 0; k < (xaxis.Length) / 2; k++)
{
try
{
Crop filter = new Crop(new Rectangle(xaxis[i], yaxis[1], (xaxis[j] - xaxis[i]), yaxis[2] - yaxis[1]));
croppedImg[k] = filter.Apply(bwimage);
ResizeBicubic rbc = new ResizeBicubic(60, 90);
croppedImg[k] = rbc.Apply(croppedImg[k]);
croppedImg[k].Save(sv.browseFileBoundaryDetectionPath + "\\img_" + k + ".jpg", System.Drawing.Imaging.ImageFormat.Jpeg);
}
catch
{
break;
}
i = i + 2;
j = j + 2;
}
string loc1 = sv.browseFileBoundaryDetectionPath;
FileStream fs = new FileStream(sv.browseFileFeatureExtractionFile, FileMode.Create, FileAccess.Write);
StreamWriter sr = new StreamWriter(fs);
String[] straimageloc = System.IO.Directory.GetFiles(loc1, "*.jpg*");
List <Bitmap> imageList = new List <Bitmap>();
foreach (var path in straimageloc)
{
Bitmap image = new Bitmap(path);
imageList.Add(image);
}
int label = 0;
string data = label + " ";
for (int n = 0; n < imageList.Count; n++)
{
float norvar = 0;
Bitmap grayimage = processImage(new Bitmap(imageList[n]));
ResizeBicubic filter = new ResizeBicubic(60, 90);
grayimage = filter.Apply(grayimage);
float[,] zone = new float[90, 60];
int index = 1;
for (j = 0; j < 90; j += 10)
{
for (i = 0; i < 60; i += 10)
{
float x = 0;
Bitmap sector = grayimage.Clone(new System.Drawing.Rectangle(i, j, 10, 10), grayimage.PixelFormat);
for (k = 0; k < 10; k++)
{
for (int l = 0; l < 10; l++)
{
if (sector.GetPixel(k, l).Name == "ff000000")
{
x++;
}
}
}
norvar += x;
}
}
for (j = 0; j < 90; j += 10)
{
for (i = 0; i < 60; i += 10)
{
float x = 0;
Bitmap sector = grayimage.Clone(new System.Drawing.Rectangle(i, j, 10, 10), grayimage.PixelFormat);
for (k = 0; k < 10; k++)
{
for (int l = 0; l < 10; l++)
{
if (sector.GetPixel(k, l).Name == "ff000000")
{
x++;
}
}
}
zone[j, i] = x / norvar;
data += index++ + ":" + zone[j, i] + " ";
}
}
index = 0;
sr.WriteLine(data);
data = label + " ";
}
label++;
sr.Flush();
sr.Close();
fs.Close();
SVMClassifier svm = new SVMClassifier();
svm.Classify();
foreach (string line in File.ReadLines(sv.finalOutputFile, Encoding.UTF8))
{
Console.WriteLine(line);
string c = Char.ConvertFromUtf32(Int32.Parse(line) + 64);
outputLabel.Text += c;
}
}
