Added feature to optimize generated code by adding a bonus for the least number of instructions executed.

Author: primaryobjects

Diff for: AIProgrammer.GA/GA.cs

@@ -45,6 +45,7 @@ namespace AIProgrammer.GeneticAlgorithm
 	public class GA
 	{
         public GAParams GAParams { get; set; }
+        public bool Stop = false;
 
 		/// <summary>
 		/// Default constructor sets mutation rate to 5%, crossover to 80%, population to 100,
@@ -114,7 +115,7 @@ public void Go(bool resume = false)
                 RankPopulation();
             }
 
-            while (GAParams.CurrentGeneration < GAParams.Generations)
+            while (GAParams.CurrentGeneration < GAParams.Generations && !Stop)
             {
                 CreateNextGeneration();
                 double fitness = RankPopulation();

Diff for: AIProgrammer.Interpreter/Interpreter.cs

@@ -66,6 +66,11 @@ public class Interpreter
         /// </summary>
         private bool m_ExitLoop;
 
+        /// <summary>
+        /// Count of number of instructions executed.
+        /// </summary>
+        public int m_Ticks;
+
         /// <summary>
         /// Constructor
         /// </summary>
@@ -74,6 +79,9 @@ public class Interpreter
         /// <param name="output"></param>
         public Interpreter(string programCode, Func<byte> input, Action<byte> output)
         {
+            // Initialize tick counter (number of instructions executed).
+            this.m_Ticks = 0;
+
             // Save the program code
             this.m_Source = programCode.ToCharArray();
 
@@ -127,7 +135,7 @@ public Interpreter(string programCode, Func<byte> input, Action<byte> output)
         /// <summary>
         /// Run the program
         /// </summary>
-        public void Run(int maxInstructions = 0)
+        public void Run(int maxInstructions)
         {
             if (maxInstructions > 0)
             {
@@ -145,8 +153,6 @@ public void Run(int maxInstructions = 0)
         /// <param name="maxInstructions">Max number of instructions to execute</param>
         private void RunLimited(int maxInstructions)
         {
-            int instructionCount = 0;
-
             // Iterate through the whole program source
             while (this.m_InstructionPointer < this.m_Source.Length)
             {
@@ -165,10 +171,13 @@ private void RunLimited(int maxInstructions)
                 this.m_InstructionPointer++;
 
                 // Have we exceeded the max instruction count?
-                if (maxInstructions > 0 && instructionCount++ > maxInstructions)
+                if (maxInstructions > 0 && m_Ticks >= maxInstructions)
                 {
-                    throw new StackOverflowException();
+                    break;
                 }
+
+                // Increment number of instructions executed.
+                m_Ticks++;
             }
         }
 
@@ -193,6 +202,9 @@ private void RunUnlimited()
 
                 // Next instruction
                 this.m_InstructionPointer++;
+
+                // Increment number of instructions executed.
+                m_Ticks++;
             }
         }
     }

Diff for: AIProgrammer/AIProgrammer.csproj

@@ -32,10 +32,6 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="NeuronDotNet.Core, Version=3.0.0.0, Culture=neutral, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>lib\NeuronDotNet.Core.dll</HintPath>
-    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Xml.Linq" />
@@ -45,7 +41,6 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Cleaner.cs" />
     <Compile Include="Program.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>

Diff for: AIProgrammer/Cleaner.cs

@@ -21,23 +21,26 @@ class Program
     {
         private static GA _ga = null; // Our genetic algorithm instance.
         private static double _bestFitness = 0; // Best fitness so far.
+        private static double _bestTrueFitness = 0; // Best fitness so far, without optimization bonus.
         private static string _bestProgram = ""; // Best program so far.
         private static string _bestOutput = ""; // Best program output so far.
-        private static int _besIiteration = 0; // Current iteration (generation) count.
+        private static int _bestIteration = 0; // Current iteration (generation) count.
+        private static int _bestTotalInstructions = 0; // Number of instructions executed by the best program.
         private static bool _bestNoErrors = false; // Indicator if the program had errors or not.
         private static DateTime _bestLastChangeDate = DateTime.Now; // Time of last improved evolution.
         private static int _maxIterationCount = 2000; // Max iterations a program may run before being killed (prevents infinite loops).
-        private static string _targetString = "hello"; // Target string to generate a program to print.
+        private static string _targetString = "reddit"; // Target string to generate a program to print.
+        private static int _targetFitness = _targetString.Length * 256;
 
         /// <summary>
         /// Event handler that is called upon each generation. We use this opportunity to display some status info and save the current genetic algorithm in case of crashes etc.
         /// </summary>
         private static void OnGeneration(GA ga)
         {
-            if (_besIiteration++ > 1000)
+            if (_bestIteration++ > 1000)
             {
-                _besIiteration = 0;
-                Console.WriteLine("Best Fitness: " + _bestFitness + "/" + ga.GAParams.TargetFitness + " " + Math.Round(_bestFitness / ga.GAParams.TargetFitness * 100) + "%, Best Output: " + _bestOutput + ", Changed: " + _bestLastChangeDate.ToString() + ", Program: " + _bestProgram);
+                _bestIteration = 0;
+                Console.WriteLine("Best Fitness: " + _bestTrueFitness + "/" + _targetFitness + " " + Math.Round(_bestTrueFitness / _targetFitness * 100) + "%, Ticks: " + _bestTotalInstructions + ", Output: " + _bestOutput + ", Changed: " + _bestLastChangeDate.ToString() + ", Program: " + _bestProgram);
 
                 ga.Save("my-genetic-algorithm.dat");
             }
@@ -50,7 +53,9 @@ private static void OnGeneration(GA ga)
         /// <returns>double, indicating the score</returns>
         private static double fitnessFunction(double[] weights)
         {
+            Interpreter bf = null;
             double fitness = 0;
+            double trueFitness = 0; // fitness without secondary bonuses (ie., optimization, etc)
             string console = "";
             bool noErrors = false;
 
@@ -60,7 +65,7 @@ private static double fitnessFunction(double[] weights)
             try
             {
                 // Run the program.
-                Interpreter bf = new Interpreter(program, null, (b) =>
+                bf = new Interpreter(program, null, (b) =>
                 {
                     console += (char)b;
                 });
@@ -78,18 +83,34 @@ private static double fitnessFunction(double[] weights)
             {
                 if (console.Length > i)
                 {
-                    fitness += 256 - Math.Abs(console[i] - _targetString[i]);
+                    trueFitness += 256 - Math.Abs(console[i] - _targetString[i]);
                 }
             }
 
+            fitness += trueFitness;
+
+            // Did we find a perfect fitness?
+            if (trueFitness >= _targetFitness)
+            {
+                // We're done! Stop the GA algorithm.
+                // Note, you can alternatively use the _ga.GAParams.TargetFitness to set a specific fitness to achieve.
+                // In our case, the number of ticks (instructions executed) is a variable part of the fitness, so we don't know the exact perfect fitness value once this part is added.
+                _ga.Stop = true;
+            }
+
+            // Bonus for less operations to optimize the code.
+            fitness += ((_maxIterationCount - bf.m_Ticks) / 10);
+
             // Is this a new best fitness?
             if (fitness > _bestFitness)
             {
                 _bestFitness = fitness;
+                _bestTrueFitness = trueFitness;
                 _bestOutput = console;
                 _bestNoErrors = noErrors;
                 _bestLastChangeDate = DateTime.Now;
                 _bestProgram = program;
+                _bestTotalInstructions = bf.m_Ticks;
             }
 
             return fitness;
@@ -130,7 +151,7 @@ private static double[] Setup()
 
             // Start a new genetic algorithm.
             _ga.GAParams.Elitism = true;
-            _ga.GAParams.TargetFitness = _targetString.Length * 256;
+            //_ga.GAParams.TargetFitness = _targetFitness;
             _ga.GAParams.HistoryPath = System.IO.Directory.GetCurrentDirectory() + "\\history.txt";
             _ga.FitnessFunction = new GAFunction(fitnessFunction);
             _ga.OnGenerationFunction = new OnGeneration(OnGeneration);