add ordered names

Author: asm-jaime

MLTests/SimplestNeuralTests.cs renamed to MLTests/1-1_SingleNeuronTest.cs

@@ -3,6 +3,15 @@
 
 namespace MLTests
 {
+    public class SimpiestNeural
+    {
+        public double Weight { set; get; } = 0;
+
+        public double Prediction(double input) {
+            return Weight * input;
+        }
+    }
+
     public class SimplestNeuralTests
     {
         [Test]
@@ -15,7 +24,6 @@ public void ShouldSimplePredict()
             // 10 * 0.5 = 5
             SimpiestNeural neuron = new SimpiestNeural() { Weight = 0.1 };
             neuron.Prediction(8.5).Should().BeInRange(0.84, 0.86);
-            //gameData.GetGameState()
         }
 
     }

MLTests/SingleInMulOutTests.cs renamed to MLTests/1-2_SingleInMulOutTest.cs

@@ -3,7 +3,20 @@
 
 namespace MLTests
 {
-    public class SingleInMulOutTests
+    public class SingleInMulOut
+    {
+        double[] _weights;
+        public SingleInMulOut(double[] weights)
+        {
+            _weights = weights;
+        }
+        public double[] GetPredict(double input)
+        {
+            return VectorMath.ElementMul(input, _weights);
+        }
+    }
+
+    public class SingleInMulOutTest
     {
         [Test]
         public void ShouldReturnInjureWinSad()

MLTests/MultipleInputNeuralTests.cs renamed to MLTests/1-3_MultipleInputNeuralTest.cs

@@ -4,7 +4,17 @@
 
 namespace MLTests
 {
-    public class MultipleInputNeuralTests
+    public class MultipleWeightsNeural
+    {
+        public NDarray Weights { get; set; }
+
+        public NDarray Prediction(NDarray inputs)
+        {
+            return inputs.dot(Weights);
+        }
+    }
+
+    public class MultipleInputNeuralTest
     {
         [Test]
         public void ShouldMultiplePredict()

MLTests/MulInMulOutTests.cs renamed to MLTests/1-4_MulInMulOutTest.cs

@@ -4,7 +4,20 @@
 
 namespace MLTests
 {
-    public class MulInMulOutTests
+    public class MulInMulOut
+    {
+        double[][] _weights;
+        public MulInMulOut(double[][] weights)
+        {
+            _weights = weights;
+        }
+        public double[] GetPrediction(double[] vec)
+        {
+            return VectorMath.VectMatMul(vec, _weights);
+        }
+    }
+
+    public class MulInMulOutTest
     {
         [Test]
         public void ShouldMulPredict()

MLTests/NDigitalRecognizer.cs renamed to MLTests/1-5_NDigitalRecognizerTest.cs

@@ -1,5 +1,53 @@
-namespace MLTests
+using FluentAssertions;
+using Keras.PreProcessing.Image;
+using Numpy;
+using NUnit.Framework;
+
+namespace MLTests
 {
+    public interface IImageToVector
+    {
+        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 float[] GetVectorOnPath(string path)
+        {
+            var image = ImageUtil.LoadImg(path, DefaultImageType, target_size: DefaultSize);
+            NDarray imageArray = ImageUtil.ImageToArray(image);
+            return GetNormalizedVector(imageArray.GetData<float>());
+        }
+    }
+
+    public class ImageToVectorTest
+    {
+        [Test]
+        public void LoadImageTest()
+        {
+            var projectPath = "D:/projects.active/LearnML";
+            var path = Path.GetFullPath(@$"{projectPath}/data/0/1.jpg");
+            IImageToVector imgToVector = new ImageToVector();
+            var vector = imgToVector.GetVectorOnPath(path);
+            vector.Sum().Should().NotBe(0.0f);
+        }
+    }
+
     public class NDigitalRecognizer
     {
         private ImageToVector _vectorReader;
@@ -135,4 +183,48 @@ public void Learn(int iterations)
             return (result.Index, result.Element);
         }
     }
+
+    public class NDigitalRecognizerTest
+    {
+        [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", "55.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", "55.jpg");
+
+            var inputSize = 28 * 28;
+            var outputSize = 10;
+
+            var alpha = 0.001f;
+            var iterations = 100;
+
+            var recognizer = new NDigitalRecognizer(new ImageToVector(), inputSize, outputSize, trainDataPath, alpha);
+
+            recognizer.Learn(iterations);
+
+            {
+                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/PredictionCompareLearnTest.cs renamed to MLTests/1_PredictionCompareLearnTest.cs

@@ -1,14 +1,10 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
+using FluentAssertions;
+using NUnit.Framework;
 
 namespace MLTests
 {
     public static class VectorMath
     {
-
         public static double[] ElementwiseMultiplication(double[] vecA, double[] vecB)
         {
             return vecA.Select((elementA, index) => elementA * vecB[index]).ToArray();
@@ -40,4 +36,20 @@ public static double ElementwiseAverage(double[] vecA)
             return vecA.Sum() / vecA.Length;
         }
     }
+
+    public class VectorMathTest
+    {
+        [Test]
+        public void TestElementWiseMultiplication()
+        {
+            var A = new double[] { 0, 1, 0, 1 };
+            var B = new double[] { 1, 0, 1, 0 };
+            var C = new double[] { 0, 1, 1, 0 };
+            var D = new double[] { 0.5, 0, 0.5, 0 };
+            var E = new double[] { 0, 1, -1, 0 };
+
+            VectorMath.ElementwiseSum(VectorMath.ElementwiseMultiplication(C, E)).Should().Be(0.0);
+            VectorMath.ElementwiseSum(VectorMath.ElementwiseMultiplication(C, C)).Should().Be(2);
+        }
+    }
 }

MLTests/VectorMath.cs renamed to MLTests/1_VectorMathTest.cs

@@ -5,7 +5,7 @@
 
 namespace MLTests
 {
-    public class GradientLearnTests
+    public class GradientLearnTest
     {
         private double LearnWeightByGradient(double weight, double input, double predictionGoal, int iterations)
         {

MLTests/GradientLearnTests.cs renamed to MLTests/2-1_GradientLearnTest.cs

@@ -2,7 +2,7 @@
 
 namespace MLTests
 {
-    public class GradientMulInMulOutTests
+    public class GradientMulInMulOutTest
     {
         private double[] MulVV(double[] vecA, double[] vecB)
         {

MLTests/GradientOneInMulOutTests.cs renamed to MLTests/2-2_GradientOneInMulOutTest.cs

@@ -3,7 +3,7 @@
 
 namespace MLTests
 {
-    public class GradientLearnWithAlphaTests
+    public class GradientLearnWithAlphaTest
     {
         private double LearnWeightByGradientAlpha(double weight, double input, double predictionGoal, double alpha, int iterations)
         {

MLTests/GradientMulInOneOutTests.cs renamed to MLTests/2-3_GradientMulInOneOutTest.cs

@@ -4,7 +4,7 @@
 
 namespace MLTests
 {
-    public class NSteerLightReluTests
+    public class NSteerLightReluTest
     {
         private NDarray Relu(NDarray layer)
         {

MLTests/GradientMulInMulOutTests.cs renamed to MLTests/2-4_GradientMulInMulOutTest.cs

@@ -1,5 +1,7 @@
-using Keras.Datasets;
+using FluentAssertions;
+using Keras.Datasets;
 using Numpy;
+using NUnit.Framework;
 
 namespace MLTests
 {
@@ -41,7 +43,7 @@ public void TrainOnMNISTDataWhithTath()
 
             np.random.seed(1);
 
-            var (alpha, iterations, hidden_size)  = (2.0f, 30, 100);
+            var (alpha, iterations, hidden_size) = (2.0f, 30, 100);
             var (pixels_per_image, num_labels) = (784, 10);
             var batch_size = 100;
 
@@ -50,7 +52,7 @@ public void TrainOnMNISTDataWhithTath()
 
             for (var i = 0; i < iterations; i++)
             {
-                for (var imageId = 0; imageId < images.len/batch_size; ++imageId)
+                for (var imageId = 0; imageId < images.len / batch_size; ++imageId)
                 {
                     var (batch_start, batch_end) = (imageId * batch_size, (imageId + 1) * batch_size);
                     var layer_0 = images[$"{batch_start}:{batch_end}"];
@@ -90,4 +92,17 @@ public int PredictNumber(int testId)
             return result.Select((e, index) => new { e, index }).OrderBy(e => e.e).Last().index;
         }
     }
+
+    public class NDLActivationTathDigitalRecTest
+    {
+        [Test]
+        public void ShouldPredictByUsingTathActivationFunc()
+        {
+            var recognizer = new NDLActivationTathDigitalRec(Path.GetFullPath(@"D:/projects.active/LearnML/data/mnist.npz"));
+            recognizer.TrainOnMNISTDataWhithTath();
+            var result = recognizer.PredictNumber(0);
+            result.Should().Be(7);
+        }
+
+    }
 }

MLTests/GradientLearnWithAlphaTests.cs renamed to MLTests/2-5_GradientLearnWithAlphaTest.cs

@@ -4,7 +4,7 @@
 
 namespace MLTests
 {
-    public class MatrixTests
+    public class MatrixTest
     {
         [Test]
         public void ShouldMatrixBe()