add Streetlight recognize simple learn by Numpy data functions

Author: asm-jaime

MLTests/DigitalRecognizerTests.cs

@@ -1,6 +1,6 @@
 namespace MLTests
 {
-    public class DigitalRecognizer
+    public class NDigitalRecognizer
     {
         private ImageToVector _vectorReader;
         private string _trainDataPath;
@@ -13,7 +13,7 @@ public class DigitalRecognizer
         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)
+        public NDigitalRecognizer(ImageToVector vectorReader, int inputSize, int outputSize, string trainDataPath, int sampleSize = DefaultSampleSize, float alpha = DefaultAlpha, int iterations = DefaultIterations)
         {
             _sampleSize = sampleSize;
             _iterations = iterations;

MLTests/DigitalRecognizer.cs renamed to MLTests/NDigitalRecognizer.cs

@@ -0,0 +1,62 @@
+using NUnit.Framework;
+
+namespace MLTests
+{
+    public class NDigitalRecognizerTests
+    {
+        [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.001f;
+            var iterations = 20;
+            var sampleSize = 100;
+
+            var vectorReader = new ImageToVector();
+            var recognizer = new NDigitalRecognizer(vectorReader, inputSize, outputSize, trainDataPath, sampleSize, alpha, iterations);
+
+            for (int learnDigit = 0; learnDigit < 10; learnDigit++)
+            {
+                recognizer.Learn(learnDigit);
+            }
+            for (int learnDigit = 0; learnDigit < 10; learnDigit++)
+            {
+                recognizer.Learn(learnDigit);
+            }
+            for (int learnDigit = 0; learnDigit < 10; learnDigit++)
+            {
+                recognizer.Learn(learnDigit);
+            }
+
+            {
+                var (digit, value) = recognizer.Predict(digitNinePath);
+                Assert.That(digit, Is.EqualTo(9));
+                Assert.That(value, Is.AtLeast(0.5f));
+            }
+            {
+                var (digit, value) = recognizer.Predict(digitFivePath);
+                Assert.That(digit, Is.EqualTo(5));
+                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/NDigitalRecognizerTests.cs

@@ -0,0 +1,49 @@
+using FluentAssertions;
+using Numpy;
+using NUnit.Framework;
+
+namespace MLTests
+{
+    public class NStreetLightRecognizerTests
+    {
+        private NDarray NGradient(NDarray weights, NDarray input, NDarray predictionGoal, float alpha, int iterations)
+        {
+            var resultWeights = weights.copy();
+            for(int i = 0; i < iterations; i++)
+            {
+                var prediction = input.dot(resultWeights);
+                var delta = prediction - predictionGoal ;
+                resultWeights = resultWeights - alpha * (input * delta);
+            }
+            return resultWeights;
+        }
+
+        [Test]
+        public void ShouldPredictWalkOrStayOnDifferentLight()
+        {
+            var stop = 0f;
+            var walk = 1f;
+
+            var streetLights = np.array(new float[,] {
+                {1f, 0f, 1f},
+                {0f, 1f, 1f},
+                {0f, 0f, 1f},
+                {1f, 1f, 1f},
+                {0f, 1f, 1f},
+                {1f, 0f, 1f},
+            });
+            var stayOrWalk = np.array(new float[] { 0f, 1f, 0f, 1f, 1f, 0f });
+            var weights = np.array(new float[] { 0.5f, 0.48f, -0.7f });
+            var alpha = 0.1f;
+
+            var input = streetLights[0];
+            var predictionGoal = stayOrWalk[0];
+
+            var iterations = 100;
+
+            var weightsResult = NGradient(weights, input, predictionGoal, alpha, iterations);
+            var result = (float) input.dot(weightsResult);
+            result.Should().BeInRange(-0.0001f, 0.0001f);
+        }
+    }
+}