add basic digital recognizer

Author: asm-jaime

MLTests/DigitalRecognizer.cs

@@ -0,0 +1,122 @@
+namespace MLTests
+{
+    public class DigitalRecognizer
+    {
+        private ImageToVector _vectorReader;
+        private string _trainDataPath;
+        private float[][] _weights;
+        private int _sampleSize;
+        private int _iterations;
+        private float _alpha;
+        private const int DigitsLength = 10;
+        private const float DefaultAlpha = 0.1f;
+        private const int DefaultIterations = 10;
+        private const int DefaultSampleSize = 100;
+
+        public DigitalRecognizer(ImageToVector vectorReader, int inputSize, int outputSize, string trainDataPath, int sampleSize = DefaultSampleSize, float alpha = DefaultAlpha, int iterations = DefaultIterations)
+        {
+            _sampleSize = sampleSize;
+            _iterations = iterations;
+            _alpha = alpha;
+
+            _vectorReader = vectorReader;
+            _trainDataPath = trainDataPath;
+
+            _weights = new float[outputSize].Select(element => new float[inputSize]).ToArray();
+        }
+
+        private float MulSVV(float[] vecA, float[] vecB)
+        {
+            float result = 0;
+            for (int i = 0; i < vecA.Length; i++)
+            {
+                result = result + vecA[i] * vecB[i];
+            }
+            return result;
+        }
+
+        private float[] MulVM(float[] vec, float[][] matrix)
+        {
+            var result = new float[matrix.Length];
+            for (var index = 0; index < result.Length; ++index)
+            {
+                result[index] = MulSVV(vec, matrix[index]);
+            }
+            return result;
+        }
+
+        private float[] SubVE(float[] vec, float element)
+        {
+            var result = new float[vec.Length];
+            for (int i = 0; i < vec.Length; i++)
+            {
+                result[i] = vec[i] - element;
+            }
+            return result;
+
+        }
+
+        private float[] MulVV(float[] vecA, float[] vecB)
+        {
+            var result = new float[vecA.Length];
+            for (int i = 0; i < vecA.Length; i++)
+            {
+                result[i] = vecA[i] * vecB[i];
+            }
+            return result;
+        }
+
+        private float[] SubVV(float[] vecA, float[] vecB)
+        {
+            var result = new float[vecA.Length];
+            for (int i = 0; i < vecA.Length; i++)
+            {
+                result[i] = vecA[i] - vecB[i];
+            }
+            return result;
+        }
+
+        private float[][] GradientLearn(float[] input, float[][] weights, float[] predictionGoal, float alpha, int iterations)
+        {
+            var result = weights.Select(row => row.ToArray()).ToArray();
+            for (int i = 0; i < iterations; i++)
+            {
+                var prediction = MulVM(input, result);
+                var deltas = SubVV(prediction, predictionGoal);
+                var derivatives = MulVV(deltas, input);
+                for (var row = 0; row < result.Length; ++row)
+                {
+                    result[row] = SubVE(result[row], derivatives[row] * alpha);
+                }
+            }
+            return result;
+        }
+
+        private float[] GetPredictionGoalVector(int digit)
+        {
+            var result = new float[DigitsLength];
+            return result.Select((e, index) => digit.Equals(index) ? 1.0f : 0.0f).ToArray();
+        }
+
+        public void Learn(int digit)
+        {
+            for (var sample = 1; sample <= _sampleSize; ++sample)
+            {
+                var predictionGoal = GetPredictionGoalVector(digit);
+                var dataPath = Path.Combine(_trainDataPath, $"{digit}", $"{sample}.jpg");
+                var input = _vectorReader.GetVectorOnPath(dataPath);
+                _weights = GradientLearn(input, _weights, predictionGoal, _alpha, _iterations);
+            }
+        }
+
+        public (int, float) Predict(string dataPath)
+        {
+            var input = _vectorReader.GetVectorOnPath(dataPath);
+            var resultVector =  MulVM(input, _weights);
+            var result = resultVector
+                .Select((e, i) => new { Element = e, Index = i })
+                .OrderBy(element => element.Element).Last();
+            return (result.Index, result.Element);
+        }
+    }
+}

MLTests/DigitalRecognizerTests.cs

@@ -0,0 +1,47 @@
+using FluentAssertions;
+using NUnit.Framework;
+
+namespace MLTests
+{
+    public class DigitalRecognizerTests
+    {
+        [Test]
+        public void ShouldRecognizeDigit()
+        {
+            var projectPath = "D:/projects.active/LearnML";
+            var trainDataPath  = Path.GetFullPath(@$"{projectPath}/data");
+            var digitZeroPath  = Path.Combine(trainDataPath, "0", "155.jpg");
+            var digitOnePath   = Path.Combine(trainDataPath, "1", "1055.jpg");
+            var digitTwoPath   = Path.Combine(trainDataPath, "2", "1055.jpg");
+            var digitThreePath = Path.Combine(trainDataPath, "3", "1055.jpg");
+            var digitFourPath  = Path.Combine(trainDataPath, "4", "1055.jpg");
+            var digitFivePath  = Path.Combine(trainDataPath, "5", "1055.jpg");
+            var digitSixPath   = Path.Combine(trainDataPath, "6", "1055.jpg");
+            var digitSevenPath = Path.Combine(trainDataPath, "7", "1055.jpg");
+            var digitEightPath = Path.Combine(trainDataPath, "8", "1055.jpg");
+            var digitNinePath  = Path.Combine(trainDataPath, "9", "1055.jpg");
+
+            var inputSize = 28 * 28;
+            var outputSize = 10;
+
+            var alpha = 0.1f;
+            var iterations = 5;
+            var sampleSize = 5;
+
+            var vectorReader = new ImageToVector();
+            var recognizer = new DigitalRecognizer(vectorReader, inputSize, outputSize, trainDataPath, sampleSize, alpha, iterations);
+
+            for (int learnDigit = 0; learnDigit < 10; learnDigit++)
+            {
+                recognizer.Learn(learnDigit);
+            }
+
+            var (digit, value) = recognizer.Predict(digitOnePath);
+            Assert.That(digit, Is.EqualTo(1));
+            Assert.That(value, Is.AtLeast(0.5f));
+
+            //recognizer.Predict(digitOnePath)[zero].Should().BeInRange(0.0f, 0.6f);
+            //recognizer.Predict(digitZeroPath)[zero].Should().BeInRange(0.8f, 1.2f);
+        }
+    }
+}

MLTests/ImageToVector.cs

@@ -3,34 +3,33 @@
 
 namespace MLTests
 {
-    public static class ImageToVector
+    public interface IImageToVector
     {
-        private static float[] GetNormalizedVector(float[] vector)
+        float[] GetVectorOnPath(string path);
+    }
+
+    public class ImageToVector : IImageToVector
+    {
+        private const string DefaultImageType = "grayscale";
+        private static readonly (int, int) DefaultSize = (28, 28);
+
+        public ImageToVector()
+        {
+
+        }
+        float[] GetNormalizedVector(float[] vector)
         {
             var max = vector.Max();
             var min = vector.Min();
             for(var i = 0; i < vector.Length; i++) vector[i] /= max;
             return vector;
         }
 
-        public static float[] GetVectorOnPath(string path)
+        public float[] GetVectorOnPath(string path)
         {
-            var image = ImageUtil.LoadImg(path, "grayscale", target_size: (28, 28));
-            NDarray x = ImageUtil.ImageToArray(image);
-            var shape = x.shape; // (28, 28, 3)
-            //var norm = new Keras.Layers.BatchNormalization();
-            
-            //x = x.reshape(1, x.shape[0], x.shape[1], x.shape[2]);
-            float[] data = x.GetData<float>();
-            /*
-            var array1 = ImageUtil.ImageToArray(image);
-
-            var array2 = np.expand_dims(array1, axis: 0);
-            var array3 = (NDarray)array2;
-            float[] data = array3.GetData<float>();
-            */
-            return GetNormalizedVector(data);
-            //return new float[] { };
+            var image = ImageUtil.LoadImg(path, DefaultImageType, target_size: DefaultSize);
+            NDarray imageArray = ImageUtil.ImageToArray(image);
+            return GetNormalizedVector(imageArray.GetData<float>());
         }
     }
 }

MLTests/ImageToVectorTest.cs

@@ -6,11 +6,12 @@ namespace MLTests
     public class ImageToVectorTest
     {
         [Test]
-        public void LoadImage()
+        public void LoadImageTest()
         {
             var projectPath = "D:/projects.active/LearnML";
             var path = Path.GetFullPath(@$"{projectPath}/data/0/1.jpg");
-            var vector = ImageToVector.GetVectorOnPath(path);
+            IImageToVector imgToVector = new ImageToVector();
+            var vector = imgToVector.GetVectorOnPath(path);
             vector.Sum().Should().NotBe(0.0f);
         }
     }

MLTests/Program.cs

@@ -1,4 +1,4 @@
 using MLTests;
 
-var vector = ImageToVector.GetVectorOnPath(@"./data/0/1.jpg");
-Console.WriteLine(vector);
+//var vector = ImageToVector.GetVectorOnPath(@"./data/0/1.jpg");
+Console.WriteLine("ML");