Split into multiple files

README.md

@@ -2,15 +2,14 @@
 
 You can run the performance benchmark with `./benchmark.sh`.
 
-Modify the search code in `paralleleureqa.jl` and `eureqa.jl` to your liking
+Modify the hyperparameters in `hyperparams.jl` and the dataset in `dataset.jl`
 (see below for options). Then, in a new Julia file called
-`myfile.jl`, you can write:
+`myfile.jl`, or the interpreter, you can write:
 
 ```julia
 include("paralleleureqa.jl")
 fullRun(10,
     npop=100,
-    annealing=true,
     ncyclesperiteration=1000,
     fractionReplaced=0.1f0,
     verbosity=100)
@@ -29,7 +28,7 @@ Run it with threading turned on using:
 
 ## Modification
 
-You can change the binary and unary operators in `eureqa.jl` here:
+You can change the binary and unary operators in `hyperparams.jl` here:
 ```julia
 const binops = [plus, mult]
 const unaops = [sin, cos, exp];
@@ -78,7 +77,10 @@ weights = [8, 1, 1, 1, 0.1, 2]
 
 # TODO
 
-- [ ] Explicit constant operation on hall-of-fame
+- [ ] Explicit constant optimization on hall-of-fame
+    - Create method to find and return all constants, from left to right
+    - Create method to find and set all constants, in same order
+    - Pull up some optimization algorithm and add it. No need for gradients; that's a headache. Keep the package small!
 - [ ] Hyperparameter tune
 - [ ] Create a Python interface
 - [ ] Create a benchmark for accuracy

dataset.jl

@@ -0,0 +1,7 @@
+# Here is the function we want to learn (x2^2 + cos(x3) + 5)
+
+##########################
+# # Dataset to learn
+const X = convert(Array{Float32, 2}, randn(100, 5)*2)
+const y = convert(Array{Float32, 1}, ((cx,)->cx^2).(X[:, 2]) + cos.(X[:, 3]) .- 5)
+##########################

eureqa.jl

@@ -1,35 +1,8 @@
-# Define allowed operators
-plus(x::Float32, y::Float32)::Float32 = x+y
-mult(x::Float32, y::Float32)::Float32 = x*y;
-
-##########################
-# # Allowed operators
-# (Apparently using const for globals helps speed)
-const binops = [plus, mult]
-const unaops = [sin, cos, exp]
-##########################
-
-# How many equations to search when replacing
-const ns=10;
-
-# Here is the function we want to learn (x2^2 + cos(x3) + 5)
-#
-##########################
-# # Dataset to learn
-const X = convert(Array{Float32, 2}, randn(100, 5)*2)
-const y = convert(Array{Float32, 1}, ((cx,)->cx^2).(X[:, 2]) + cos.(X[:, 3]) .- 5)
-##########################
-
-##################
-# Hyperparameters
-# How much to punish complexity
-const parsimony = 1f-3
-# How much to scale temperature by (T between 0 and 1)
-const alpha = 10.0f0
-const maxsize = 20
+include("hyperparams.jl")
+include("dataset.jl")
+
 const maxdegree = 2
 const actualMaxsize = maxsize + maxdegree
-##################
 
 id = (x,) -> x
 const nuna = size(unaops)[1]

hyperparams.jl

@@ -0,0 +1,31 @@
+# Define allowed operators
+plus(x::Float32, y::Float32)::Float32 = x+y
+mult(x::Float32, y::Float32)::Float32 = x*y;
+
+##########################
+# # Allowed operators
+# (Apparently using const for globals helps speed)
+const binops = [plus, mult]
+const unaops = [sin, cos, exp]
+##########################
+
+# How many equations to search when replacing
+const ns=10;
+
+##################
+# Hyperparameters
+# How much to punish complexity
+const parsimony = 1f-3
+# How much to scale temperature by (T between 0 and 1)
+const alpha = 10.0f0
+# Max size of an equation (too large will slow program down)
+const maxsize = 20
+# Whether to migrate between threads (you should)
+const migration = true
+# Whether to re-introduce best examples seen (helps a lot)
+const hofMigration = true
+# Fraction of population to replace with hall of fame
+const fractionReplacedHof = 0.1f0
+##################
+
+

paralleleureqa.jl

@@ -1,9 +1,6 @@
 include("eureqa.jl")
 
 const nthreads = Threads.nthreads()
-const migration = true
-const hofMigration = true
-const fractionReplacedHof = 0.1f0
 
 # List of the best members seen all time
 mutable struct HallOfFame