Change 'NeuralNetwork.Step' to only use the current step's cached outputs and an option to always reevaluate self-referencing nodes

ME-MarvinE · ME-MarvinE · commit 12f036e5d953 · 2022-10-18T07:45:25.000+01:00
diff --git a/MaceEvolve/Controls/GameHost.cs b/MaceEvolve/Controls/GameHost.cs
@@ -53,11 +53,11 @@ public int TargetTPS
         public Rectangle WorldBounds { get; set; }
         public Rectangle SuccessBounds { get; set; }
         public int MinCreatureConnections { get; set; } = 4;
-        public int MaxCreatureConnections { get; set; } = 64;
+        public int MaxCreatureConnections { get; set; } = 128;
         public double CreatureSpeed { get; set; }
         public double NewGenerationInterval { get; set; } = 12;
         public double SecondsUntilNewGeneration { get; set; } = 12;
-        public int MaxCreatureProcessNodes { get; set; } = 3;
+        public int MaxCreatureProcessNodes { get; set; } = 5;
         public double MutationChance { get; set; } = 0.1;
         public double MutationAttempts { get; set; } = 10;
         public double ConnectionWeightBound { get; set; } = 4;
diff --git a/MaceEvolve/Models/Creature.cs b/MaceEvolve/Models/Creature.cs
@@ -104,7 +104,7 @@ public void Live()
             UpdateCurrentStepInfo();
             UpdateInputValues();
 
-            Dictionary<int, double> NodeIdToOutputDict = Brain.LoggedStep(true, false);
+            Dictionary<int, double> NodeIdToOutputDict = Brain.LoggedStep(true, true);
             Dictionary<Node, double> NodeOutputsDict = NodeIdToOutputDict.OrderBy(x => x.Value).ToDictionary(x => Brain.Nodes[x.Key], x => x.Value);
             Node HighestOutputNode = NodeOutputsDict.Keys.LastOrDefault(x => x.NodeType == NodeType.Output);
 
diff --git a/MaceEvolve/Models/NeuralNetwork.cs b/MaceEvolve/Models/NeuralNetwork.cs
@@ -21,8 +21,6 @@ public class NeuralNetwork
         [JsonIgnore]
         public List<Node> Nodes { get; } = new List<Node>();
         public List<Connection> Connections { get; set; } = new List<Connection>();
-
-        public Dictionary<Node, double> PreviousNodeOutputs { get; set; } = new Dictionary<Node, double>();
         public List<NeuralNetworkStepInfo> PreviousStepInfo { get; set; } = new List<NeuralNetworkStepInfo>();
         #endregion
 
@@ -414,7 +412,7 @@ public static IEnumerable<Node> GetPossibleTargetNodes(IEnumerable<Node> Nodes)
         {
             return Nodes.Where(x => x.NodeType == NodeType.Process || x.NodeType == NodeType.Output);
         }
-        public Dictionary<int, double> Step(bool OutputNodesOnly, bool CacheSelfReferencingConnections)
+        public Dictionary<int, double> Step(bool OutputNodesOnly, bool AlwaysReevaluateNodesWithSelfReferencingConnections)
         {
             if (OutputNodesOnly)
             {
@@ -477,52 +475,43 @@ public Dictionary<int, double> Step(bool OutputNodesOnly, bool CacheSelfReferenc
                                 double SourceNodeOutput;
                                 Node ConnectionSourceNode = IdToNodeDict[Connection.SourceId];
 
-                                if (NodesBeingEvaluated.Contains(Connection.SourceId) || (CurrentNodeHasSelfReferencingConnections && !CacheSelfReferencingConnections))
+                                //If the source node is already being evaluated, meaning either the current connection is a circular reference or the source node is present earlier in the queue and is a circular reference,
+                                //The cached output of the source node must be used. If there is no cached value, initialise one with a value of 0.
+                                //OR
+                                //Whether the node is evaluated or not, if there is a self referencing connection, use the specified parameter to determine whether it should be evaluated again or not.
+                                //This is important because after a self referencing node's output is calculated, it is cached. When getting the value of that node again, something needs to decided whether to use the original output
+                                //or to calculate a new output using the cached output to resolve the circular reference instead of the initial value of 0.
+                                if (NodesBeingEvaluated.Contains(Connection.SourceId) || !(CurrentNodeHasSelfReferencingConnections && !AlwaysReevaluateNodesWithSelfReferencingConnections))
                                 {
-                                    if (PreviousNodeOutputs.TryGetValue(ConnectionSourceNode, out double PreviousSourceNodeOutput))
+                                    if (CachedNodeOutputs.TryGetValue(Connection.SourceId, out double CachedSourceNodeOutput))
                                     {
-                                        SourceNodeOutput = PreviousSourceNodeOutput;
+                                        SourceNodeOutput = CachedSourceNodeOutput;
                                     }
                                     else
                                     {
-                                        PreviousNodeOutputs[ConnectionSourceNode] = 0;
-                                        SourceNodeOutput = PreviousNodeOutputs[ConnectionSourceNode];
+                                        CachedNodeOutputs[Connection.SourceId] = 0;
+                                        SourceNodeOutput = CachedNodeOutputs[Connection.SourceId];
                                     }
                                 }
                                 else
                                 {
-                                    if (CachedNodeOutputs.TryGetValue(Connection.SourceId, out double CachedSourceNodeOutput))
-                                    {
-                                        SourceNodeOutput = CachedSourceNodeOutput;
-                                    }
-                                    else
-                                    {
-                                        NodeQueue.Add(Connection.SourceId);
-                                        CurrentNodeWeightedSum = null;
-                                        break;
-                                    }
+                                    NodeQueue.Add(Connection.SourceId);
+                                    CurrentNodeWeightedSum = null;
+                                    break;
                                 }
 
-                                //CurrentNodeWeightedSum ??= 0;
-
                                 CurrentNodeWeightedSum += SourceNodeOutput * Connection.Weight;
                             }
                         }
                     }
 
                     if (CurrentNodeWeightedSum != null)
                     {
-                        double CurrentNodeOutput = Globals.ReLU(CurrentNodeWeightedSum.Value + CurrentNode.Bias);
-
-                        if (CurrentNodeOutput > 10000)
-                        {
-                            var thing = 2;
-                        }
+                        double CurrentNodeOutput = CurrentNode.NodeType == NodeType.Input ? CurrentNodeWeightedSum.Value : Globals.ReLU(CurrentNodeWeightedSum.Value + CurrentNode.Bias);
 
                         NodesBeingEvaluated.Remove(CurrentNodeId);
 
                         CachedNodeOutputs[CurrentNodeId] = CurrentNodeOutput;
-                        PreviousNodeOutputs[CurrentNode] = CurrentNodeOutput;
 
                         NodeQueue.Remove(CurrentNodeId);
                     }
@@ -535,7 +524,7 @@ public Dictionary<int, double> Step(bool OutputNodesOnly, bool CacheSelfReferenc
                 throw new NotImplementedException();
             }
         }
-        public Dictionary<int, double> LoggedStep(bool OutputNodesOnly, bool CacheSelfReferencingConnections)
+        public Dictionary<int, double> LoggedStep(bool OutputNodesOnly, bool AlwaysReevaluateNodesWithSelfReferencingConnections)
         {
             Dictionary<Node, int> NodeToIdDict = Nodes.ToDictionary(x => x, x => GetNodeId(x));
 
@@ -631,34 +620,31 @@ public Dictionary<int, double> LoggedStep(bool OutputNodesOnly, bool CacheSelfRe
                                 double SourceNodeOutput;
                                 Node ConnectionSourceNode = IdToNodeDict[Connection.SourceId];
 
-                                if (NodesBeingEvaluated.Contains(Connection.SourceId) || (CurrentNodeHasSelfReferencingConnections && !CacheSelfReferencingConnections))
+                                //If the source node is already being evaluated, meaning either the current connection is a circular reference or the source node is present earlier in the queue and is a circular reference,
+                                //The cached output of the source node must be used. If there is no cached value, initialise one with a value of 0.
+                                //OR
+                                //Whether the node is evaluated or not, if there is a self referencing connection, use the specified parameter to determine whether it should be evaluated again or not.
+                                //This is important because after a self referencing node's output is calculated, it is cached. When getting the value of that node again, something needs to decided whether to use the original output
+                                //or to calculate a new output using the cached output to resolve the circular reference instead of the initial value of 0.
+                                if (NodesBeingEvaluated.Contains(Connection.SourceId) || !(CurrentNodeHasSelfReferencingConnections && !AlwaysReevaluateNodesWithSelfReferencingConnections))
                                 {
-                                    if (PreviousNodeOutputs.TryGetValue(ConnectionSourceNode, out double PreviousSourceNodeOutput))
+                                    if (CachedNodeOutputs.TryGetValue(Connection.SourceId, out double CachedSourceNodeOutput))
                                     {
-                                        SourceNodeOutput = PreviousSourceNodeOutput;
+                                        SourceNodeOutput = CachedSourceNodeOutput;
                                     }
                                     else
                                     {
-                                        PreviousNodeOutputs[ConnectionSourceNode] = 0;
-                                        SourceNodeOutput = PreviousNodeOutputs[ConnectionSourceNode];
+                                        CachedNodeOutputs[Connection.SourceId] = 0;
+                                        SourceNodeOutput = CachedNodeOutputs[Connection.SourceId];
                                     }
                                 }
                                 else
                                 {
-                                    if (CachedNodeOutputs.TryGetValue(Connection.SourceId, out double CachedSourceNodeOutput))
-                                    {
-                                        SourceNodeOutput = CachedSourceNodeOutput;
-                                    }
-                                    else
-                                    {
-                                        NodeQueue.Add(Connection.SourceId);
-                                        CurrentNodeWeightedSum = null;
-                                        break;
-                                    }
+                                    NodeQueue.Add(Connection.SourceId);
+                                    CurrentNodeWeightedSum = null;
+                                    break;
                                 }
 
-                                //CurrentNodeWeightedSum ??= 0;
-
                                 CurrentNodeWeightedSum += SourceNodeOutput * Connection.Weight;
                             }
                         }
@@ -668,15 +654,9 @@ public Dictionary<int, double> LoggedStep(bool OutputNodesOnly, bool CacheSelfRe
                     {
                         double CurrentNodeOutput = CurrentNode.NodeType == NodeType.Input ? CurrentNodeWeightedSum.Value : Globals.ReLU(CurrentNodeWeightedSum.Value + CurrentNode.Bias);
 
-                        if (CurrentNodeOutput > 10000)
-                        {
-                            var thing = 2;
-                        }
-
                         NodesBeingEvaluated.Remove(CurrentNodeId);
 
                         CachedNodeOutputs[CurrentNodeId] = CurrentNodeOutput;
-                        PreviousNodeOutputs[CurrentNode] = CurrentNodeOutput;
                         CurrentNodeStepInfo.PreviousOutput = CurrentNodeOutput;
 
                         NodeQueue.Remove(CurrentNodeId);

Original file line number	Diff line number	Diff line change
`@@ -21,8 +21,6 @@ public class NeuralNetwork`
`21`	`21`	`[JsonIgnore]`
`22`	`22`	`public List<Node> Nodes { get; } = new List<Node>();`
`23`	`23`	`public List<Connection> Connections { get; set; } = new List<Connection>();`
`24`		`-`
`25`		`- public Dictionary<Node, double> PreviousNodeOutputs { get; set; } = new Dictionary<Node, double>();`
`26`	`24`	`public List<NeuralNetworkStepInfo> PreviousStepInfo { get; set; } = new List<NeuralNetworkStepInfo>();`
`27`	`25`	`#endregion`
`28`	`26`
`@@ -414,7 +412,7 @@ public static IEnumerable<Node> GetPossibleTargetNodes(IEnumerable<Node> Nodes)`
`414`	`412`	`{`
`415`	`413`	`return Nodes.Where(x => x.NodeType == NodeType.Process \|\| x.NodeType == NodeType.Output);`
`416`	`414`	`}`
`417`		`- public Dictionary<int, double> Step(bool OutputNodesOnly, bool CacheSelfReferencingConnections)`
	`415`	`+ public Dictionary<int, double> Step(bool OutputNodesOnly, bool AlwaysReevaluateNodesWithSelfReferencingConnections)`
`418`	`416`	`{`
`419`	`417`	`if (OutputNodesOnly)`
`420`	`418`	`{`
`@@ -477,52 +475,43 @@ public Dictionary<int, double> Step(bool OutputNodesOnly, bool CacheSelfReferenc`
`477`	`475`	`double SourceNodeOutput;`
`478`	`476`	`Node ConnectionSourceNode = IdToNodeDict[Connection.SourceId];`
`479`	`477`
`480`		`- if (NodesBeingEvaluated.Contains(Connection.SourceId) \|\| (CurrentNodeHasSelfReferencingConnections && !CacheSelfReferencingConnections))`
	`478`	`+ //If the source node is already being evaluated, meaning either the current connection is a circular reference or the source node is present earlier in the queue and is a circular reference,`
	`479`	`+ //The cached output of the source node must be used. If there is no cached value, initialise one with a value of 0.`
	`480`	`+ //OR`
	`481`	`+ //Whether the node is evaluated or not, if there is a self referencing connection, use the specified parameter to determine whether it should be evaluated again or not.`
	`482`	`+ //This is important because after a self referencing node's output is calculated, it is cached. When getting the value of that node again, something needs to decided whether to use the original output`
	`483`	`+ //or to calculate a new output using the cached output to resolve the circular reference instead of the initial value of 0.`
	`484`	`+ if (NodesBeingEvaluated.Contains(Connection.SourceId) \|\| !(CurrentNodeHasSelfReferencingConnections && !AlwaysReevaluateNodesWithSelfReferencingConnections))`
`481`	`485`	`{`
`482`		`- if (PreviousNodeOutputs.TryGetValue(ConnectionSourceNode, out double PreviousSourceNodeOutput))`
	`486`	`+ if (CachedNodeOutputs.TryGetValue(Connection.SourceId, out double CachedSourceNodeOutput))`
`483`	`487`	`{`
`484`		`- SourceNodeOutput = PreviousSourceNodeOutput;`
	`488`	`+ SourceNodeOutput = CachedSourceNodeOutput;`
`485`	`489`	`}`
`486`	`490`	`else`
`487`	`491`	`{`
`488`		`- PreviousNodeOutputs[ConnectionSourceNode] = 0;`
`489`		`- SourceNodeOutput = PreviousNodeOutputs[ConnectionSourceNode];`
	`492`	`+ CachedNodeOutputs[Connection.SourceId] = 0;`
	`493`	`+ SourceNodeOutput = CachedNodeOutputs[Connection.SourceId];`
`490`	`494`	`}`
`491`	`495`	`}`
`492`	`496`	`else`
`493`	`497`	`{`
`494`		`- if (CachedNodeOutputs.TryGetValue(Connection.SourceId, out double CachedSourceNodeOutput))`
`495`		`- {`
`496`		`- SourceNodeOutput = CachedSourceNodeOutput;`
`497`		`- }`
`498`		`- else`
`499`		`- {`
`500`		`- NodeQueue.Add(Connection.SourceId);`
`501`		`- CurrentNodeWeightedSum = null;`
`502`		`- break;`
`503`		`- }`
	`498`	`+ NodeQueue.Add(Connection.SourceId);`
	`499`	`+ CurrentNodeWeightedSum = null;`
	`500`	`+ break;`
`504`	`501`	`}`
`505`	`502`
`506`		`- //CurrentNodeWeightedSum ??= 0;`
`507`		`-`
`508`	`503`	`CurrentNodeWeightedSum += SourceNodeOutput * Connection.Weight;`
`509`	`504`	`}`
`510`	`505`	`}`
`511`	`506`	`}`
`512`	`507`
`513`	`508`	`if (CurrentNodeWeightedSum != null)`
`514`	`509`	`{`
`515`		`- double CurrentNodeOutput = Globals.ReLU(CurrentNodeWeightedSum.Value + CurrentNode.Bias);`
`516`		`-`
`517`		`- if (CurrentNodeOutput > 10000)`
`518`		`- {`
`519`		`- var thing = 2;`
`520`		`- }`
	`510`	`+ double CurrentNodeOutput = CurrentNode.NodeType == NodeType.Input ? CurrentNodeWeightedSum.Value : Globals.ReLU(CurrentNodeWeightedSum.Value + CurrentNode.Bias);`
`521`	`511`
`522`	`512`	`NodesBeingEvaluated.Remove(CurrentNodeId);`
`523`	`513`
`524`	`514`	`CachedNodeOutputs[CurrentNodeId] = CurrentNodeOutput;`
`525`		`- PreviousNodeOutputs[CurrentNode] = CurrentNodeOutput;`
`526`	`515`
`527`	`516`	`NodeQueue.Remove(CurrentNodeId);`
`528`	`517`	`}`
`@@ -535,7 +524,7 @@ public Dictionary<int, double> Step(bool OutputNodesOnly, bool CacheSelfReferenc`
`535`	`524`	`throw new NotImplementedException();`
`536`	`525`	`}`
`537`	`526`	`}`
`538`		`- public Dictionary<int, double> LoggedStep(bool OutputNodesOnly, bool CacheSelfReferencingConnections)`
	`527`	`+ public Dictionary<int, double> LoggedStep(bool OutputNodesOnly, bool AlwaysReevaluateNodesWithSelfReferencingConnections)`
`539`	`528`	`{`
`540`	`529`	`Dictionary<Node, int> NodeToIdDict = Nodes.ToDictionary(x => x, x => GetNodeId(x));`
`541`	`530`
`@@ -631,34 +620,31 @@ public Dictionary<int, double> LoggedStep(bool OutputNodesOnly, bool CacheSelfRe`
`631`	`620`	`double SourceNodeOutput;`
`632`	`621`	`Node ConnectionSourceNode = IdToNodeDict[Connection.SourceId];`
`633`	`622`
`634`		`- if (NodesBeingEvaluated.Contains(Connection.SourceId) \|\| (CurrentNodeHasSelfReferencingConnections && !CacheSelfReferencingConnections))`
	`623`	`+ //If the source node is already being evaluated, meaning either the current connection is a circular reference or the source node is present earlier in the queue and is a circular reference,`
	`624`	`+ //The cached output of the source node must be used. If there is no cached value, initialise one with a value of 0.`
	`625`	`+ //OR`
	`626`	`+ //Whether the node is evaluated or not, if there is a self referencing connection, use the specified parameter to determine whether it should be evaluated again or not.`
	`627`	`+ //This is important because after a self referencing node's output is calculated, it is cached. When getting the value of that node again, something needs to decided whether to use the original output`
	`628`	`+ //or to calculate a new output using the cached output to resolve the circular reference instead of the initial value of 0.`
	`629`	`+ if (NodesBeingEvaluated.Contains(Connection.SourceId) \|\| !(CurrentNodeHasSelfReferencingConnections && !AlwaysReevaluateNodesWithSelfReferencingConnections))`
`635`	`630`	`{`
`636`		`- if (PreviousNodeOutputs.TryGetValue(ConnectionSourceNode, out double PreviousSourceNodeOutput))`
	`631`	`+ if (CachedNodeOutputs.TryGetValue(Connection.SourceId, out double CachedSourceNodeOutput))`
`637`	`632`	`{`
`638`		`- SourceNodeOutput = PreviousSourceNodeOutput;`
	`633`	`+ SourceNodeOutput = CachedSourceNodeOutput;`
`639`	`634`	`}`
`640`	`635`	`else`
`641`	`636`	`{`
`642`		`- PreviousNodeOutputs[ConnectionSourceNode] = 0;`
`643`		`- SourceNodeOutput = PreviousNodeOutputs[ConnectionSourceNode];`
	`637`	`+ CachedNodeOutputs[Connection.SourceId] = 0;`
	`638`	`+ SourceNodeOutput = CachedNodeOutputs[Connection.SourceId];`
`644`	`639`	`}`
`645`	`640`	`}`
`646`	`641`	`else`
`647`	`642`	`{`
`648`		`- if (CachedNodeOutputs.TryGetValue(Connection.SourceId, out double CachedSourceNodeOutput))`
`649`		`- {`
`650`		`- SourceNodeOutput = CachedSourceNodeOutput;`
`651`		`- }`
`652`		`- else`
`653`		`- {`
`654`		`- NodeQueue.Add(Connection.SourceId);`
`655`		`- CurrentNodeWeightedSum = null;`
`656`		`- break;`
`657`		`- }`
	`643`	`+ NodeQueue.Add(Connection.SourceId);`
	`644`	`+ CurrentNodeWeightedSum = null;`
	`645`	`+ break;`
`658`	`646`	`}`
`659`	`647`
`660`		`- //CurrentNodeWeightedSum ??= 0;`
`661`		`-`
`662`	`648`	`CurrentNodeWeightedSum += SourceNodeOutput * Connection.Weight;`
`663`	`649`	`}`
`664`	`650`	`}`
`@@ -668,15 +654,9 @@ public Dictionary<int, double> LoggedStep(bool OutputNodesOnly, bool CacheSelfRe`
`668`	`654`	`{`
`669`	`655`	`double CurrentNodeOutput = CurrentNode.NodeType == NodeType.Input ? CurrentNodeWeightedSum.Value : Globals.ReLU(CurrentNodeWeightedSum.Value + CurrentNode.Bias);`
`670`	`656`
`671`		`- if (CurrentNodeOutput > 10000)`
`672`		`- {`
`673`		`- var thing = 2;`
`674`		`- }`
`675`		`-`
`676`	`657`	`NodesBeingEvaluated.Remove(CurrentNodeId);`
`677`	`658`
`678`	`659`	`CachedNodeOutputs[CurrentNodeId] = CurrentNodeOutput;`
`679`		`- PreviousNodeOutputs[CurrentNode] = CurrentNodeOutput;`
`680`	`660`	`CurrentNodeStepInfo.PreviousOutput = CurrentNodeOutput;`
`681`	`661`
`682`	`662`	`NodeQueue.Remove(CurrentNodeId);`