Got Distributed.jl working

julia/loop.jl

@@ -0,0 +1,117 @@
+using Distributed
+const nprocs = 4
+addprocs(4)
+@everywhere include(".dataset_28330894764081783777.jl")
+@everywhere include(".hyperparams_28330894764081783777.jl")
+@everywhere include("sr.jl")
+
+
+# 1. Start a population on every process
+allPops = Future[]
+bestSubPops = [Population(1) for j=1:nprocs]
+hallOfFame = HallOfFame()
+
+for i=1:nprocs
+    npop=300
+    future = @spawnat :any Population(npop, 3)
+    push!(allPops, future)
+end
+
+npop=300
+ncyclesperiteration=3000
+fractionReplaced=0.1f0
+verbosity=convert(Int, 1e9)
+topn=10
+niterations=10
+
+
+# # 2. Start the cycle on every process:
+for i=1:nprocs
+    allPops[i] = @spawnat :any run(fetch(allPops[i]), ncyclesperiteration, verbosity=verbosity)
+end
+println("Started!")
+cycles_complete = nprocs * 10
+while cycles_complete > 0
+    for i=1:nprocs
+        if isready(allPops[i])
+            cur_pop = fetch(allPops[i])
+            bestSubPops[i] = bestSubPop(cur_pop, topn=topn)
+
+            #Try normal copy...
+            bestPops = Population([member for pop in bestSubPops for member in pop.members])
+
+            for member in cur_pop.members
+                size = countNodes(member.tree)
+                if member.score < hallOfFame.members[size].score
+                    hallOfFame.members[size] = deepcopy(member)
+                    hallOfFame.exists[size] = true
+                end
+            end
+
+            # Dominating pareto curve - must be better than all simpler equations
+            dominating = PopMember[]
+            open(hofFile, "w") do io
+                debug(verbosity, "\n")
+                debug(verbosity, "Hall of Fame:")
+                debug(verbosity, "-----------------------------------------")
+                debug(verbosity, "Complexity \t MSE \t Equation")
+                println(io,"Complexity|MSE|Equation")
+                for size=1:actualMaxsize
+                    if hallOfFame.exists[size]
+                        member = hallOfFame.members[size]
+                        curMSE = MSE(evalTreeArray(member.tree), y)
+                        numberSmallerAndBetter = sum([curMSE > MSE(evalTreeArray(hallOfFame.members[i].tree), y) for i=1:(size-1)])
+                        betterThanAllSmaller = (numberSmallerAndBetter == 0)
+                        if betterThanAllSmaller
+                            debug(verbosity, "$size \t $(curMSE) \t $(stringTree(member.tree))")
+                            println(io, "$size|$(curMSE)|$(stringTree(member.tree))")
+                            push!(dominating, member)
+                        end
+                    end
+                end
+                debug(verbosity, "")
+            end
+
+            # Try normal copy otherwise.
+            if migration
+                for k in rand(1:npop, round(Integer, npop*fractionReplaced))
+                    to_copy = rand(1:size(bestPops.members)[1])
+                    cur_pop.members[k] = PopMember(
+                        copyNode(bestPops.members[to_copy].tree),
+                        bestPops.members[to_copy].score)
+                end
+            end
+
+            if hofMigration && size(dominating)[1] > 0
+                for k in rand(1:npop, round(Integer, npop*fractionReplacedHof))
+                    # Copy in case one gets used twice
+                    to_copy = rand(1:size(dominating)[1])
+                    cur_pop.members[k] = PopMember(
+                       copyNode(dominating[to_copy].tree)
+                    )
+                end
+            end
+
+            allPops[i] = @spawnat :any let
+                tmp_pop = run(cur_pop, ncyclesperiteration, verbosity=verbosity)
+                for j=1:tmp_pop.n
+                    if rand() < 0.1
+                        tmp_pop.members[j].tree = simplifyTree(tmp_pop.members[j].tree)
+                        tmp_pop.members[j].tree = combineOperators(tmp_pop.members[j].tree)
+                        if shouldOptimizeConstants
+                            tmp_pop.members[j] = optimizeConstants(tmp_pop.members[j])
+                        end
+                    end
+                end
+                tmp_pop
+            end
+
+            global cycles_complete -= 1
+        end
+    end
+    sleep(1e-3)
+end
+
+rmprocs(nprocs)
+
+

julia/sr.jl

@@ -738,104 +738,3 @@ mutable struct HallOfFame
 end
 
 
-function fullRun(niterations::Integer;
-                npop::Integer=300,
-                ncyclesperiteration::Integer=3000,
-                fractionReplaced::Float32=0.1f0,
-                verbosity::Integer=0,
-                topn::Integer=10
-               )
-    debug(verbosity, "Running with $nthreads threads")
-    # Generate random initial populations
-    allPops = [Population(npop, 3) for j=1:nthreads]
-    bestSubPops = [Population(1) 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
-        start_time = time()
-        @inbounds Threads.@threads for i=1:nthreads
-            allPops[i] = run(allPops[i], ncyclesperiteration, verbosity=verbosity)
-            for j=1:allPops[i].n
-                if rand() < 0.1
-                    allPops[i].members[j].tree = simplifyTree(allPops[i].members[j].tree)
-                    allPops[i].members[j].tree = combineOperators(allPops[i].members[j].tree)
-                    if shouldOptimizeConstants
-                        allPops[i].members[j] = optimizeConstants(allPops[i].members[j])
-                    end
-                end
-            end
-            bestSubPops[i] = bestSubPop(allPops[i], topn=topn)
-        end
-        total_time = time() - start_time
-
-        number_equations_created = ncyclesperiteration * nthreads * npop / ns
-        equations_created_per_second = number_equations_created / total_time
-
-        # 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]))
-        bestPops = deepcopy(Population([member for pop in bestSubPops for member in pop.members]))
-
-        #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 pareto curve - must be better than all simpler equations
-        dominating = PopMember[]
-        open(hofFile, "w") do io
-            debug(verbosity, "\n")
-            if k == 1
-                debug(verbosity, "Total cycles per second (first round is slower due to compilation): $(round(equations_created_per_second, sigdigits=3))\n")
-            else
-                debug(verbosity, "Total cycles per second: $(round(equations_created_per_second, sigdigits=3))\n")
-            end
-            debug(verbosity, "Hall of Fame:")
-            debug(verbosity, "-----------------------------------------")
-            debug(verbosity, "Complexity \t MSE \t Equation")
-            println(io,"Complexity|MSE|Equation")
-            for size=1:actualMaxsize
-                if hallOfFame.exists[size]
-                    member = hallOfFame.members[size]
-                    curMSE = MSE(evalTreeArray(member.tree), y)
-                    numberSmallerAndBetter = sum([curMSE > MSE(evalTreeArray(hallOfFame.members[i].tree), y) for i=1:(size-1)])
-                    betterThanAllSmaller = (numberSmallerAndBetter == 0)
-                    if betterThanAllSmaller
-                        debug(verbosity, "$size \t $(curMSE) \t $(stringTree(member.tree))")
-                        println(io, "$size|$(curMSE)|$(stringTree(member.tree))")
-                        push!(dominating, member)
-                    end
-                end
-            end
-            debug(verbosity, "")
-        end
-
-        # Migration
-        if migration
-            for j=1:nthreads
-                for k in rand(1:npop, round(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 && size(dominating)[1] > 0
-            for j=1:nthreads
-                for k in rand(1:npop, round(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