Added support for dynamically expanding genome.

Author: primaryobjects

Diff for: AIProgrammer.Fitness/Concrete/XmlToJsonFitness.cs

@@ -12,9 +12,22 @@ namespace AIProgrammer.Fitness.Concrete
 {
     public class XmlToJsonFitness : FitnessBase
     {
-        private static string[] _trainingExamples = { "<a>boy</a>", "<zt>Yaks</zt>", "<you>i</you>" };
+        private static string[] _trainingExamples = { "<b>i</b>", "<i>One</i>", "<a>me</a>" };
+//        private static string[] _trainingExamples = { "<me>i</me>", "<us>You</us>", "<her>it</her>" };
         private static string[] _trainingResults = new string[_trainingExamples.Length];
 
+        /// <summary>
+        /// Previously generated BrainPlus functions for outputting json characters: { } " :
+        /// To use, set _appendCode = XmlToJsonFitness.XmlToJsonFunctions in main program.
+        /// 
+        /// Generated using StrictStringFitness with StringFunction with the following settings:
+        /// TargetString = "{ } \" :"
+        /// private static IFunction _functionGenerator = new StringFunction(() => GetFitnessMethod(), _bestStatus, fitnessFunction, OnGeneration, _crossoverRate, _mutationRate, _genomeSize, _targetParams);
+        /// ...
+        /// return new StringStrictFitness(_ga, _maxIterationCount, _targetParams.TargetString, _appendCode);
+        /// </summary>
+        public static string XmlToJsonFunctions = "8-----.@-[8[[---.@D+2++.@->4------.@";
+
         public XmlToJsonFitness(GA ga, int maxIterationCount, string appendFunctions = null)
             : base(ga, maxIterationCount, appendFunctions)
         {
@@ -38,6 +51,8 @@ protected override double GetFitnessMethod(string program)
         {
             double countBonus = 0;
             double penalty = 0;
+            //HashSet<int> memoryHash = new HashSet<int>();
+            //HashSet<int> printCommandHash = new HashSet<int>();
 
             for (int i = 0; i < _trainingExamples.Length; i++)
             {
@@ -63,6 +78,20 @@ protected override double GetFitnessMethod(string program)
                     (b) =>
                     {
                         _console.Append((char)b);
+
+                        // Record the instruction index being used for this print statement.
+                        /*if (!printCommandHash.Add(_bf.m_CurrentInstructionPointer))
+                        {
+                            // This is kind of cheating, but we need to force diversity by decoupling the cases. Force them to use unique print statements, not used by any other case.
+                            penalty += 200;
+                        }*/
+
+                        /*// Record the memory register being used for this output. Used to support diversity.
+                        if (state >= _trainingExamples[i].Length && _console.Length <= _trainingResults[i].Length)
+                        {
+                            // This is a valid output character to consider. Record the memory register of where its data is stored.
+                            memoryHash.Add(_bf.m_CurrentDataPointer);
+                        }*/
                     });
                     _bf.Run(_maxIterationCount);
                 }
@@ -82,8 +111,11 @@ protected override double GetFitnessMethod(string program)
                     }
                 }
 
+                // Bonus for using functions.
+                //countBonus += _bf.m_ExecutedFunctions.Count * 25;
+
                 // Length bonus (percentage of 100).
-                countBonus += 10 * ((_trainingResults[i].Length - Math.Abs(_console.Length - _trainingResults[i].Length)) / _trainingResults[i].Length);
+                //countBonus += 256 * ((_trainingResults[i].Length - Math.Abs(_console.Length - _trainingResults[i].Length)) / _trainingResults[i].Length);
 
                 // Make the AI wait until a solution is found without the penalty (too many input characters).
                 Fitness -= penalty;
@@ -97,6 +129,12 @@ protected override double GetFitnessMethod(string program)
                 Ticks += _bf.m_Ticks;
             }
 
+            /*// Give a bonus for using multiple memory registers, supporting diversity.
+            if (memoryHash.Count > 1)
+            {
+                countBonus += memoryHash.Count * 10;
+            }*/
+
             if (_fitness != Double.MaxValue)
             {
                 _fitness = Fitness + countBonus;

Diff for: AIProgrammer.GA/GA.cs

@@ -283,6 +283,18 @@ private void CreateNextGeneration()
                     GAParams.NextGeneration.Add(g);
             }
 
+            // Expand genomes.
+            if (GAParams.NextGeneration[0].Length != GAParams.GenomeSize)
+            {
+                Parallel.ForEach(GAParams.NextGeneration, (genome) =>
+                {
+                    if (genome.Length != GAParams.GenomeSize)
+                    {
+                        genome.Expand(GAParams.GenomeSize);
+                    }
+                });
+            }
+
             GAParams.ThisGeneration = new List<Genome>(GAParams.NextGeneration);
             /*GAParams.m_thisGeneration.Clear();
             foreach (Genome ge in GAParams.m_nextGeneration)

Diff for: AIProgrammer.Types/Genome.cs

@@ -203,6 +203,47 @@ public void Mutate()
             }
         }
 
+        public void Expand(int size)
+        {
+            int originalSize = m_genes.Length;
+            int difference = size - originalSize;
+
+            // Resize the genome array.
+            double[] newGenes = new double[size];
+
+            if (difference > 0)
+            {
+                if (m_random.NextDouble() < 0.5)
+                {
+                    // Extend at front.
+                    Array.Copy(m_genes, 0, newGenes, difference, originalSize);
+
+                    for (int i = 0; i < difference; i++)
+                    {
+                        newGenes[i] = m_random.NextDouble();
+                    }
+                }
+                else
+                {
+                    // Extend at back.
+                    Array.Copy(m_genes, 0, newGenes, 0, originalSize);
+
+                    for (int i = originalSize; i < size; i++)
+                    {
+                        newGenes[i] = m_random.NextDouble();
+                    }
+                }
+
+                m_genes = newGenes;
+            }
+            else
+            {
+                Array.Resize(ref m_genes, size);
+            }
+
+            m_length = size;
+        }
+
         public double[] Genes()
         {
             return m_genes;

Diff for: AIProgrammer/App.config

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="utf-8" ?>
 <configuration>
   <appSettings>
-    <add key="BrainfuckVersion" value="1"/> <!-- 1 = Brainfuck Classic, 2 = BrainPlus (Brainfuck Extended Type 3, Functions, Faster) -->
+    <add key="BrainfuckVersion" value="2"/> <!-- 1 = Brainfuck Classic, 2 = BrainPlus (Brainfuck Extended Type 3, Functions, Faster) -->
   </appSettings>
   <startup>
     <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" />

Diff for: AIProgrammer/Program.cs

@@ -30,7 +30,7 @@ class Program
         private static GA _ga = null; // Our genetic algorithm instance.
         private static GAStatus _bestStatus = new GAStatus(); // Holds values for displaying best generation statistics.
         private static DateTime _startTime = DateTime.Now; // Time the program was started.
-        private static string _appendCode = null; // Program code, containing functions, that will be appended to main program code
+        private static string _appendCode = XmlToJsonFitness.XmlToJsonFunctions; // Program code, containing functions, that will be appended to main program code
         private static TargetParams _targetParams = new TargetParams { TargetString = "hi" }; // Used for displaying the target fitness
 
         #endregion
@@ -39,8 +39,11 @@ class Program
 
         private static double _crossoverRate = 0.70; // Percentage chance that a child genome will use crossover of two parents.
         private static double _mutationRate = 0.01; // Percentage chance that a child genome will mutate a gene.
-        private static int _genomeSize = 250; // Number of programming instructions in generated program (size of genome array).
+        private static int _genomeSize = 200; // Number of programming instructions in generated program (size of genome array).
+        private static int _maxGenomeSize = 120; // The max length a genome may grow to (only applicable if _expandAmount > 0).
         private static int _maxIterationCount = 2000; // Max iterations a program may run before being killed (prevents infinite loops).
+        private static int _expandAmount = 0; // The max genome size will expand by this amount, every _expandRate iterations (may help learning). Set to 0 to disable.
+        private static int _expandRate = 10000; // The max genome size will expand by _expandAmount, at this interval of generations.
 
         #endregion
 
@@ -61,7 +64,7 @@ class Program
         /// <returns>IFitness</returns>
         private static IFitness GetFitnessMethod()
         {
-            return new StringStrictFitness(_ga, _maxIterationCount, _targetParams.TargetString, _appendCode);
+            return new XmlToJsonFitness(_ga, _maxIterationCount, _appendCode);
         }
 
         #region Worker Methods
@@ -74,10 +77,18 @@ private static void OnGeneration(GA ga)
             if (_bestStatus.Iteration++ > 1000)
             {
                 _bestStatus.Iteration = 0;
-                Console.WriteLine("Best Fitness: " + _bestStatus.TrueFitness + "/" + _targetParams.TargetFitness + " " + Math.Round(_bestStatus.TrueFitness / _targetParams.TargetFitness * 100, 2) + "%, Ticks: " + _bestStatus.Ticks + ", Running: " + Math.Round((DateTime.Now - _startTime).TotalMinutes) + "m, Best Output: " + _bestStatus.Output + ", Changed: " + _bestStatus.LastChangeDate.ToString() + ", Program: " + _bestStatus.Program);
+                Console.WriteLine("Best Fitness: " + _bestStatus.TrueFitness + "/" + _targetParams.TargetFitness + " " + Math.Round(_bestStatus.TrueFitness / _targetParams.TargetFitness * 100, 2) + "%, Ticks: " + _bestStatus.Ticks + ", Running: " + Math.Round((DateTime.Now - _startTime).TotalMinutes) + "m, Size: " + _genomeSize + ", Best Output: " + _bestStatus.Output + ", Changed: " + _bestStatus.LastChangeDate.ToString() + ", Program: " + _bestStatus.Program);
 
                 ga.Save("my-genetic-algorithm.dat");
             }
+
+            if (_expandAmount > 0 && ga.GAParams.CurrentGeneration > 0 && ga.GAParams.CurrentGeneration % _expandRate == 0 && _genomeSize < _maxGenomeSize)
+            {
+                _genomeSize += _expandAmount;
+                ga.GAParams.GenomeSize = _genomeSize;
+
+                _bestStatus.Fitness = 0; // Update display of best program, since genome has changed and we have a better/worse new best fitness.
+            }
         }
 
         /// <summary>