Add hall of fame and nicer printing

eureqa.jl

@@ -27,6 +27,8 @@ const parsimony = 1f-3
 # How much to scale temperature by (T between 0 and 1)
 const alpha = 10.0f0
 const maxsize = 20
+const maxdegree = 2
+const actualMaxsize = maxsize + maxdegree
 ##################
 
 id = (x,) -> x
@@ -388,8 +390,9 @@ mutable struct PopMember
     score::Float32
     birth::Int32
 
-    PopMember(t) = new(t, scoreFunc(t, X, y, parsimony=parsimony), round(Int32, 1e3*(time()-1.6e9))
-)
+    PopMember(t::Node) = new(t, scoreFunc(t, X, y, parsimony=parsimony), round(Int32, 1e3*(time()-1.6e9)))
+    PopMember(t::Node, score::Float32) = new(t, score, round(Int32, 1e3*(time()-1.6e9)))
+
 end
 
 # A list of members of the population, with easy constructors,

paralleleureqa.jl

@@ -1,6 +1,19 @@
 include("eureqa.jl")
 
 const nthreads = Threads.nthreads()
+const migration = true
+const hofMigration = true
+const fractionReplacedHof = 0.05f0
+
+# List of the best members seen all time
+mutable struct HallOfFame
+    members::Array{PopMember, 1}
+    exists::Array{Bool, 1}
+
+    # Arranged by complexity - store one at each.
+    HallOfFame() = new([PopMember(Node(1f0), 1f9) for i=1:actualMaxsize], [false for i=1:actualMaxsize])
+end
+
 
 function fullRun(niterations::Integer;
                 npop::Integer=300,
@@ -15,6 +28,8 @@ function fullRun(niterations::Integer;
     allPops = [Population(npop, 3) for j=1:nthreads]
     # Repeat this many evolutions; we collect and migrate the best
     # each time.
+    hallOfFame = HallOfFame()
+
     for k=1:niterations
         # Spawn threads to run indepdent evolutions, then gather them
         @inbounds Threads.@threads for i=1:nthreads
@@ -23,16 +38,54 @@ function fullRun(niterations::Integer;
 
         # Get best 10 models from each evolution. Copy because we re-assign later.
         bestPops = deepcopy(Population([member for pop in allPops for member in bestSubPop(pop).members]))
-        bestCurScoreIdx = argmin([bestPops.members[member].score for member=1:bestPops.n])
-        bestCurScore = bestPops.members[bestCurScoreIdx].score
-        debug(verbosity, bestCurScore, " is the score for ", stringTree(bestPops.members[bestCurScoreIdx].tree))
+
+        #Update hall of fame
+        for pop in allPops
+            for member in pop.members
+                size = countNodes(member.tree)
+                if member.score < hallOfFame.members[size].score
+                    hallOfFame.members[size] = deepcopy(member)
+                    hallOfFame.exists[size] = true
+                end
+            end
+        end
+
+        dominating = PopMember[]
+        debug(verbosity, "Hall of Fame:")
+        debug(verbosity, "-----------------------------------------")
+        debug(verbosity, "Complexity \t Score \t Equation")
+        for size=1:maxsize
+            if hallOfFame.exists[size]
+                member = hallOfFame.members[size]
+                numberSmallerAndBetter = sum([member.score > hallOfFame.members[i].score for i=1:(size-1)])
+                betterThanAllSmaller = (numberSmallerAndBetter == 0)
+                if betterThanAllSmaller
+                    debug(verbosity, "$size \t $(member.score) \t $(stringTree(member.tree))")
+                    push!(dominating, member)
+                end
+            end
+        end
+        debug(verbosity, "")
 
         # Migration
-        for j=1:nthreads
-            for k in rand(1:npop, Integer(npop*fractionReplaced))
-                # Copy in case one gets used twice
-                allPops[j].members[k] = deepcopy(bestPops.members[rand(1:size(bestPops.members)[1])])
+        if migration
+            for j=1:nthreads
+                for k in rand(1:npop, Integer(npop*fractionReplaced))
+                    # Copy in case one gets used twice
+                    allPops[j].members[k] = deepcopy(bestPops.members[rand(1:size(bestPops.members)[1])])
+                end
             end
         end
+
+        # Hall of fame migration
+        if hofMigration
+            for j=1:nthreads
+                for k in rand(1:npop, Integer(npop*fractionReplacedHof))
+                    # Copy in case one gets used twice
+                    allPops[j].members[k] = deepcopy(dominating[rand(1:size(dominating)[1])])
+                end
+            end
+        end
+
     end
 end