Added the possibility to Save and Load networks (WeightedNetwork especially). Its being saved to a JSON-String

Author: BotMaster3000

NeuralBotMasterFramework/NeuralBotMasterFramework/Helper/ConcreteTypeConverter.cs

@@ -0,0 +1,29 @@
+using Newtonsoft.Json;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NeuralBotMasterFramework.Helper
+{
+    // Class taken from source:
+    // https://blog.greatrexpectations.com/2012/08/30/deserializing-interface-properties-using-json-net
+    public class ConcreteTypeConverter<TConcrete> : JsonConverter
+    {
+        public override bool CanConvert(Type objectType)
+        {
+            return true;
+        }
+
+        public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
+        {
+            return serializer.Deserialize<TConcrete>(reader);
+        }
+
+        public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
+        {
+            serializer.Serialize(writer, value);
+        }
+    }
+}

NeuralBotMasterFramework/NeuralBotMasterFramework/Interfaces/ISaveableNetwork.cs

@@ -0,0 +1,14 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace NeuralBotMasterFramework.Interfaces
+{
+    public interface ISaveableNetwork
+    {
+        string SaveNetwork();
+        ISaveableNetwork LoadNetwork(string networkString);
+    }
+}

NeuralBotMasterFramework/NeuralBotMasterFramework/Logic/Networks/WeightedNetwork.cs

@@ -5,17 +5,27 @@
 using System.Threading.Tasks;
 using NeuralBotMasterFramework.Interfaces;
 using NeuralBotMasterFramework.Models;
+using Newtonsoft.Json;
+using NeuralBotMasterFramework.Helper;
 
 namespace NeuralBotMasterFramework.Logic.Networks
 {
-    public class WeightedNetwork : IWeightedNetwork
+    public class WeightedNetwork : IWeightedNetwork, ISaveableNetwork
     {
+        [JsonConverter(typeof(ConcreteTypeConverter<Layer>))]
         public ILayer InputLayer { get; set; }
+
+        [JsonConverter(typeof(ConcreteTypeConverter<WeightedLayer[]>))]
         public IWeightedLayer[] HiddenLayers { get; set; }
+
+        [JsonConverter(typeof(ConcreteTypeConverter<WeightedLayer>))]
         public IWeightedLayer OutputLayer { get; set; }
 
         public int ID { get; set; }
 
+        // Required for JSON-Deserialization
+        public WeightedNetwork() { }
+
         public WeightedNetwork(int inputNodes, int hiddenLayers, int hiddenNodesPerLayer, int outputNodes)
         {
             InitializeInputNodes(inputNodes);
@@ -31,7 +41,7 @@ private void InitializeInputNodes(int inputNodes)
         private void InitializeHiddenNodes(int totalHiddenLayers, int totalHiddenNodesPerLayer, int previousNodes)
         {
             HiddenLayers = new IWeightedLayer[totalHiddenLayers];
-            for(int i = 0; i < totalHiddenLayers; ++i)
+            for (int i = 0; i < totalHiddenLayers; ++i)
             {
                 HiddenLayers[i] = new WeightedLayer(totalHiddenNodesPerLayer, previousNodes);
                 previousNodes = HiddenLayers[i].Nodes.Length;
@@ -56,12 +66,22 @@ public double[] GetOutput()
         public void Propagate()
         {
             double[] values = InputLayer.GetValues();
-            for(int i = 0; i < HiddenLayers.Length; ++i)
+            for (int i = 0; i < HiddenLayers.Length; ++i)
             {
                 HiddenLayers[i].SetValues(values);
                 values = HiddenLayers[i].GetValues();
             }
             OutputLayer.SetValues(values);
         }
+
+        public string SaveNetwork()
+        {
+            return JsonConvert.SerializeObject(this);
+        }
+
+        public ISaveableNetwork LoadNetwork(string networkString)
+        {
+            return (ISaveableNetwork)JsonConvert.DeserializeObject(networkString, typeof(WeightedNetwork));
+        }
     }
 }

NeuralBotMasterFramework/NeuralBotMasterFramework/Models/Layer.cs

@@ -5,11 +5,14 @@
 using System.Threading.Tasks;
 using NeuralBotMasterFramework.Interfaces;
 using NeuralBotMasterFramework.Models;
+using Newtonsoft.Json;
+using NeuralBotMasterFramework.Helper;
 
 namespace NeuralBotMasterFramework.Models
 {
     public class Layer : ILayer
     {
+        [JsonConverter(typeof(ConcreteTypeConverter<Node[]>))]
         public INode[] Nodes { get; set; }
 
         public Layer() { }

NeuralBotMasterFramework/NeuralBotMasterFramework/Models/WeightedLayer.cs

@@ -5,11 +5,14 @@
 using System.Threading.Tasks;
 using NeuralBotMasterFramework.Interfaces;
 using NeuralBotMasterFramework.Models;
+using Newtonsoft.Json;
+using NeuralBotMasterFramework.Helper;
 
 namespace NeuralBotMasterFramework.Models
 {
     public class WeightedLayer : IWeightedLayer
     {
+        [JsonConverter(typeof(ConcreteTypeConverter<WeightedNode[]>))]
         public IWeightedNode[] Nodes { get; set; }
 
         public WeightedLayer() { }

NeuralBotMasterFramework/NeuralBotMasterFramework/NeuralBotMasterFramework.csproj

@@ -31,6 +31,9 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Newtonsoft.Json, Version=12.0.0.0, Culture=neutral, PublicKeyToken=30ad4fe6b2a6aeed, processorArchitecture=MSIL">
+      <HintPath>..\packages\Newtonsoft.Json.12.0.2\lib\net45\Newtonsoft.Json.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -41,12 +44,14 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Helper\ConcreteTypeConverter.cs" />
     <Compile Include="Helper\RandomNumberGenerator.cs" />
     <Compile Include="Interfaces\IBaseLayer.cs" />
     <Compile Include="Interfaces\IBreedingPoolGenerator.cs" />
     <Compile Include="Interfaces\IGeneticAlgorithm.cs" />
     <Compile Include="Interfaces\ILayer.cs" />
     <Compile Include="Interfaces\INetwork.cs" />
+    <Compile Include="Interfaces\ISaveableNetwork.cs" />
     <Compile Include="Interfaces\IWeightedLayer.cs" />
     <Compile Include="Interfaces\IWeightedNetwork.cs" />
     <Compile Include="Interfaces\IWeightedNode.cs" />
@@ -61,6 +66,8 @@
     <Compile Include="Models\WeightedNode.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <None Include="packages.config" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
 </Project>

NeuralBotMasterFramework/NeuralBotMasterFramework/packages.config

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+  <package id="Newtonsoft.Json" version="12.0.2" targetFramework="net461" />
+</packages>

NeuralBotMasterFramework/NeuralBotMasterFrameworkTests/Logic/WeightedNetworkTests.cs

@@ -1,4 +1,5 @@
-using Microsoft.VisualStudio.TestTools.UnitTesting;
+using NeuralBotMasterFramework.Logic.Networks;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
 using NeuralBotMasterFramework.Logic;
 using System;
 using System.Collections.Generic;
@@ -71,10 +72,43 @@ public void PropagateTest()
             network.SetInput(input);
             network.Propagate();
 
-            foreach(double result in network.GetOutput())
+            foreach (double result in network.GetOutput())
             {
                 Assert.AreNotEqual(0, result);
             }
         }
+
+        [TestMethod]
+        public void SaveNetworkTest()
+        {
+            WeightedNetwork network = new WeightedNetwork(5, 3, 200, 9);
+            string savedNetwork = network.SaveNetwork();
+
+            WeightedNetwork loadedNetwork = (WeightedNetwork)network.LoadNetwork(savedNetwork);
+            Assert.AreEqual(network.InputLayer?.Nodes.Length, loadedNetwork.InputLayer?.Nodes.Length);
+            Assert.AreEqual(network.HiddenLayers?.Length, loadedNetwork.HiddenLayers?.Length);
+            Assert.AreEqual(network.OutputLayer?.Nodes.Length, loadedNetwork.OutputLayer?.Nodes.Length);
+
+            for (int hiddenLayerIndex = 0; hiddenLayerIndex < network.HiddenLayers.Length; hiddenLayerIndex++)
+            {
+                IWeightedLayer firstNetworkHiddenLayer = network.HiddenLayers[hiddenLayerIndex];
+                IWeightedLayer loadedNetworkHiddenLayer = loadedNetwork.HiddenLayers[hiddenLayerIndex];
+                Assert.AreEqual(firstNetworkHiddenLayer?.Nodes?.Length, loadedNetworkHiddenLayer?.Nodes.Length);
+
+                for (int hiddenlayerNodeIndex = 0; hiddenlayerNodeIndex < firstNetworkHiddenLayer.Nodes.Length; hiddenlayerNodeIndex++)
+                {
+                    IWeightedNode firstNetworkHiddenNode = firstNetworkHiddenLayer.Nodes[hiddenlayerNodeIndex];
+                    IWeightedNode loadedNetworkHiddenNode = loadedNetworkHiddenLayer.Nodes[hiddenlayerNodeIndex];
+                    Assert.AreEqual(firstNetworkHiddenNode.Value, loadedNetworkHiddenNode.Value);
+
+                    for(int networkHiddenNodeWeightIndex = 0; networkHiddenNodeWeightIndex < firstNetworkHiddenNode.Weights.Length; ++networkHiddenNodeWeightIndex)
+                    {
+                        double firstNetworkWeight = firstNetworkHiddenNode.Weights[networkHiddenNodeWeightIndex];
+                        double loadedNetworkWeight = loadedNetworkHiddenNode.Weights[networkHiddenNodeWeightIndex];
+                        Assert.AreEqual(firstNetworkWeight, loadedNetworkWeight);
+                    }
+                }
+            }
+        }
     }
 }

NeuralBotMasterFramework/TestConsole/Program.cs

@@ -14,25 +14,25 @@ class Program
         private static double[][] inputData;
         private static double[][] expectedData;
 
-        private static int dataSetsPerPropagation = 1000;
+        private static int dataSetsPerPropagation = 500;
         private static double[][] currentInputData;
         private static double[][] currentExpectedData;
 
-        const int TOTAL_BITS = 12;
+        const int TOTAL_BITS = 2;
         private static int totalNumberLength = Math.Pow(2, TOTAL_BITS).ToString().Length;
 
         static void Main(string[] args)
         {
-            int totalNetworks = 1000;
+            int totalNetworks = 10000;
             int inputNodes = TOTAL_BITS;
             int hiddenNodes = 10;
-            int hiddenLayers = 2;
+            int hiddenLayers = 5;
             int outputNodes = totalNumberLength;
 
-            int networksToKeep = 10;
-            int totalRandomNetworks = 10;
-            double mutationRate = 0.01;
-            double mutationChance = 0.01;
+            int networksToKeep = 100;
+            int totalRandomNetworks = 1000;
+            double mutationRate = 0.5;
+            double mutationChance = 0.5;
 
             SetupBinaryData();
 
@@ -58,7 +58,7 @@ static void Main(string[] args)
                 algorithm.PropagateAllNetworks();
                 Console.WriteLine("Breeding");
                 algorithm.BreedBestNetworks();
-                if (generation % 20 == 0)
+                if (generation % 10 == 0)
                 {
                     PrintData(algorithm);
                 }