add numpy sample mul in mul out neural net

Author: asm-jaime

MLTests/MulInMulOut.cs

@@ -9,6 +9,7 @@ public MulInMulOut(double[][] weights)
         }
         public double[] GetPrediction(double[] vec)
         {
+            return VectorMath.VectMatMul(vec, _weights);
         }
     }
 }

MLTests/MulInMulOutTests.cs

@@ -1,4 +1,6 @@
-using NUnit.Framework;
+using FluentAssertions;
+using Numpy;
+using NUnit.Framework;
 
 namespace MLTests
 {
@@ -12,7 +14,65 @@ public void ShouldMulPredict()
                 new double[] {0.1, 0.2, 0.0},
                 new double[] {0.0, 1.3, 0.1},
             });
+            var result = mmInOut.GetPrediction(new double[] { 8.5, 0.65, 1.2 });
+            result.SequenceEqual(new double[] { 0.555, 0.98000000000000009, 0.96500000000000008 }).Should().Be(true);
         }
 
+        [Test]
+        public void ShouldImposeNetworks()
+        {
+            var firstNetwork = new MulInMulOut(new double[][] {
+                new double[] {0.1, 0.2, -0.1},
+                new double[] {-0.1, 0.1, 0.9},
+                new double[] {0.1, 0.4, 0.1},
+            });
+            var secondNetwork = new MulInMulOut(new double[][] {
+                new double[] {0.3, 1.1, -0.3},
+                new double[] {0.1, 0.2, 0.0},
+                new double[] {0.0, 1.3, 0.1},
+            });
+            var input = new double[] { 8.5, 0.65, 1.2 };
+
+            var intermediateResult = firstNetwork.GetPrediction(input);
+            var result = secondNetwork.GetPrediction(intermediateResult);
+
+            result.SequenceEqual(new double[] { 0.21350000000000002, 0.14500000000000002, 0.5065 }).Should().Be(true);
+        }
+
+        [Test]
+        public void ShouldImposeNetworksByNumpy()
+        {
+            /*
+            var weightsA = np.array(new double[,] {
+                {0.1, -0.1, 0.1},
+                {0.2, 0.1, 0.4},
+                {-0.1, 0.9, 0.1},
+            });
+            var weightsB = np.array(new double[,] {
+                {0.3, 0.1, 0.0},
+                {1.1, 0.2, 1.3},
+                {-0.3, 0.0, 0.1},
+            });
+            */
+
+            var weightsA = np.array(new double[,] {
+                {0.1, 0.2, -0.1},
+                {-0.1, 0.1, 0.9},
+                {0.1, 0.4, 0.1},
+            }).T;
+            var weightsB = np.array(new double[,] {
+                {0.3, 1.1, -0.3},
+                {0.1, 0.2, 0.0},
+                {0.0, 1.3, 0.1},
+            }).T;
+
+            var input = np.array(new double[] { 8.5, 0.65, 1.2 });
+
+            var hid = input.dot(weightsA);
+            var result = hid.dot(weightsB);
+            result.GetData<double>().SequenceEqual(new double[] { 0.21350000000000002, 0.14500000000000002, 0.5065 }).Should().Be(true);
+
+            //(double[])result.SequenceEqual(new double[] { 0.21350000000000002, 0.14500000000000002, 0.5065 }).Should().Be(true);
+        }
     }
 }

MLTests/MultipleInputNeuralTests.cs

@@ -1,11 +1,6 @@
 using FluentAssertions;
-using NUnit.Framework;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 using Numpy;
+using NUnit.Framework;
 
 namespace MLTests
 {
@@ -18,9 +13,9 @@ public void ShouldMultiplePredict()
             double[] PlayedWin = new double[] { 0.65, 0.8, 0.8, 0.9 };
             double[] PlayedFanats = new double[] { 1.2, 1.3, 0.5, 1.0 };
 
-            MultipleWeightsNeural neural = new MultipleWeightsNeural() { Weights = np.array(new double[] {0.1, 0.2, 0}) };
+            MultipleWeightsNeural neural = new MultipleWeightsNeural() { Weights = np.array(new double[] { 0.1, 0.2, 0 }) };
 
-            double result = (double) neural.Prediction(np.array(new double[] { PlayedTime[0], PlayedWin[0], PlayedFanats[0] }));
+            double result = (double)neural.Prediction(np.array(new double[] { PlayedTime[0], PlayedWin[0], PlayedFanats[0] }));
             result.Should().BeInRange(0.97, 0.99);
         }
     }

MLTests/SimplestNeuralTests.cs

@@ -1,10 +1,5 @@
 using FluentAssertions;
 using NUnit.Framework;
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
 
 namespace MLTests
 {
@@ -14,11 +9,11 @@ public class SimplestNeuralTests
         public void ShouldSimplePredict()
         {
             // reverse list of number
- 
+
             // {0, 1} принадлежит 0.0000001134
             //[8.5, 9.5, 10, 9]
             // 10 * 0.5 = 5
-            SimpiestNeural neuron = new SimpiestNeural() { Weight = 0.1};
+            SimpiestNeural neuron = new SimpiestNeural() { Weight = 0.1 };
             neuron.Prediction(8.5).Should().BeInRange(0.84, 0.86);
             //gameData.GetGameState()
         }

MLTests/VectorMath.cs

@@ -14,6 +14,11 @@ public static double[] ElementwiseMultiplication(double[] vecA, double[] vecB)
             return vecA.Select((elementA, index) => elementA * vecB[index]).ToArray();
         }
 
+        public static double[] VectMatMul(double[] vecA, double[][] matrix)
+        {
+            return vecA.Select((_, index) => ElementwiseMultiplication(vecA, matrix[index]).Sum()).ToArray();
+        }
+
         public static double[] ElementMul(double element, double[] vec)
         {
             var result = new double[vec.Length];