Propagation of neural networks now happens with Tasks

Author: BotMaster3000

NeuralBotMasterFramework/NeuralBotMasterFramework/Logic/Algorithms/GeneticAlgorithm.cs

@@ -66,18 +66,29 @@ public void PropagateAllNetworks()
             ResetAllFitnesses();
             for (int inputIndex = 0; inputIndex < CurrentInput.Length; inputIndex++)
             {
+                Task[] tasks = new Task[NetworksAndFitness.Count];
+                int listIndex = 0;
                 foreach (KeyValuePair<IWeightedNetwork, double> networkAndFitness in NetworksAndFitness)
                 {
-                    networkAndFitness.Key.SetInput(CurrentInput[inputIndex]);
-                    networkAndFitness.Key.Propagate();
+                    tasks[listIndex] = Task.Factory.StartNew(()
+                        => PropagateNetworkTask(networkAndFitness, inputIndex));
+
+                    ++listIndex;
                 }
+                Task.WaitAll(tasks);
                 if (CurrentExpectedIsSet())
                 {
                     CalculateFitnesses(CurrentExpected[inputIndex]);
                 }
             }
         }
 
+        private void PropagateNetworkTask(KeyValuePair<IWeightedNetwork, double> networkAndFitness, int inputIndex)
+        {
+            networkAndFitness.Key.SetInput(CurrentInput[inputIndex]);
+            networkAndFitness.Key.Propagate();
+        }
+
         private bool CurrentExpectedIsSet()
         {
             return CurrentExpected?.Length >= 0;

NeuralBotMasterFramework/TestConsole/Program.cs

@@ -14,46 +14,75 @@ class Program
         private static double[][] inputData;
         private static double[][] expectedData;
 
-        const int TOTAL_BITS = 2;
+        private static int dataSetsPerPropagation = 1000;
+        private static double[][] currentInputData;
+        private static double[][] currentExpectedData;
+
+        const int TOTAL_BITS = 12;
         private static int totalNumberLength = Math.Pow(2, TOTAL_BITS).ToString().Length;
 
         static void Main(string[] args)
         {
-            int totalNetworks = 100;
+            int totalNetworks = 1000;
             int inputNodes = TOTAL_BITS;
             int hiddenNodes = 10;
             int hiddenLayers = 2;
             int outputNodes = totalNumberLength;
 
             int networksToKeep = 10;
             int totalRandomNetworks = 10;
-            double mutationRate = 0.1;
-            double mutationChance = 0.0011;
+            double mutationRate = 0.01;
+            double mutationChance = 0.01;
 
             SetupBinaryData();
 
             GeneticAlgorithm algorithm = new GeneticAlgorithm(totalNetworks, inputNodes, hiddenNodes, hiddenLayers, outputNodes)
             {
-                PoolGenerator = new IndexBasedPoolGenerator()
+                PoolGenerator = new FitnessBasedPoolGenerator()
             };
 
-            algorithm.SetupTest(inputData, expectedData);
-
             algorithm.NetworksToKeep = networksToKeep;
             algorithm.MutationRate = mutationRate;
             algorithm.MutationChance = mutationChance;
             algorithm.RandomNetworkAmount = totalRandomNetworks;
 
             Console.WriteLine("Initialization complete");
 
+            int generation = 0;
             while (true)
             {
+                Console.WriteLine($"Generation {generation}");
+                SetCurrentDataSets();
+                algorithm.SetupTest(currentInputData, currentExpectedData);
                 Console.WriteLine("Propagating");
                 algorithm.PropagateAllNetworks();
                 Console.WriteLine("Breeding");
                 algorithm.BreedBestNetworks();
-                PrintData(algorithm);
-                Console.ReadLine();
+                if (generation % 20 == 0)
+                {
+                    PrintData(algorithm);
+                }
+                ++generation;
+            }
+        }
+
+        private static void SetCurrentDataSets()
+        {
+            int totalDataSets = inputData.Length < dataSetsPerPropagation ? inputData.Length : dataSetsPerPropagation;
+            currentInputData = new double[totalDataSets][];
+            currentExpectedData = new double[totalDataSets][];
+
+            List<int> indexedDataSets = new List<int>();
+            for (int i = 0; i < totalDataSets;)
+            {
+                int index = NeuralBotMasterFramework.Helper.RandomNumberGenerator.GetNextNumber(0, inputData.Length - 1);
+                if (!indexedDataSets.Contains(index))
+                {
+                    currentInputData[i] = inputData[index];
+                    currentExpectedData[i] = expectedData[index];
+                    indexedDataSets.Add(index);
+                    ++i;
+                }
             }
         }