Parametrize probability weights

README.md

@@ -86,21 +86,9 @@ Then just specify the operator names in your call, as above.
 You can also change the dataset learned on by passing in `X` and `y` as
 numpy arrays to `eureqa(...)`.
 
-One can also adjust the relative probabilities of each operation here,
-inside `eureqa.jl`:
-```julia
-weights = [8, 1, 1, 1, 0.1, 0.5, 2]
-```
-for:
-
-1. Perturb constant
-2. Mutate operator
-3. Append a node
-4. Delete a subtree
-5. Simplify equation
-6. Randomize completely
-7. Do nothing
-
+One can also adjust the relative probabilities of each mutation operation
+with the `weight...` parameters to `eureqa(...).
+inside `eureqa.jl`.
 
 # TODO
 

eureqa.jl

@@ -15,7 +15,7 @@ function debug(verbosity, string...)
     verbosity > 0 ? println(string...) : nothing
 end
 
-function giveBirth()::Int32
+function getTime()::Int32
     return round(Int32, 1e3*(time()-1.6e9))
 end
 
@@ -326,17 +326,17 @@ end
 #  exp(-delta/T) defines probability of accepting a change
 function iterate(
         tree::Node, T::Float32,
-        alpha::Float32=1.0f0;
         annealing::Bool=true
     )::Node
     prev = tree
     tree = deepcopy(tree)
 
     mutationChoice = rand()
-    weight_for_constant = min(8, countConstants(tree))
-    weights = [weight_for_constant, 1, 1, 1, 0.1, 0.5, 2] .* 1.0
-    weights /= sum(weights)
-    cweights = cumsum(weights)
+    weightAdjustmentMutateConstant = min(8, countConstants(tree))/8.0
+    cur_weights = deepcopy(mutationWeights) .* 1.0
+    cur_weights[1] *= weightAdjustmentMutateConstant
+    cur_weights /= sum(cur_weights)
+    cweights = cumsum(cur_weights)
     n = countNodes(tree)
 
     if mutationChoice < cweights[1]
@@ -386,8 +386,8 @@ mutable struct PopMember
     score::Float32
     birth::Int32
 
-    PopMember(t::Node) = new(t, scoreFunc(t), giveBirth())
-    PopMember(t::Node, score::Float32) = new(t, score, giveBirth())
+    PopMember(t::Node) = new(t, scoreFunc(t), getTime())
+    PopMember(t::Node, score::Float32) = new(t, score, getTime())
 
 end
 
@@ -429,10 +429,10 @@ function iterateSample(
     allstar = bestOfSample(pop)
     new = iterate(
         allstar.tree, T,
-        alpha, annealing=annealing)
+        annealing=annealing)
     allstar.tree = new
     allstar.score = scoreFunc(new)
-    allstar.birth = giveBirth()
+    allstar.birth = getTime()
     return allstar
 end
 
@@ -530,7 +530,7 @@ function optimizeConstants(member::PopMember)::PopMember
     if Optim.converged(result)
         setConstants(member.tree, result.minimizer)
         member.score = convert(Float32, result.minimum)
-        member.birth = giveBirth()
+        member.birth = getTime()
     else
         setConstants(member.tree, x0)
     end

eureqa.py

@@ -7,15 +7,22 @@ import pandas as pd
 
 
 def eureqa(X=None, y=None, threads=4, parsimony=1e-3, alpha=10,
-        maxsize=20, migration=True,
-        hofMigration=True, fractionReplacedHof=0.1,
-        shouldOptimizeConstants=True,
-        binary_operators=["plus", "mult"],
-        unary_operators=["cos", "exp", "sin"],
-        niterations=20, npop=100, annealing=True,
-        ncyclesperiteration=5000, fractionReplaced=0.1,
-        topn=10, equation_file='hall_of_fame.csv',
-        test='simple1'
+            maxsize=20, migration=True,
+            hofMigration=True, fractionReplacedHof=0.1,
+            shouldOptimizeConstants=True,
+            binary_operators=["plus", "mult"],
+            unary_operators=["cos", "exp", "sin"],
+            niterations=20, npop=100, annealing=True,
+            ncyclesperiteration=5000, fractionReplaced=0.1,
+            topn=10, equation_file='hall_of_fame.csv',
+            test='simple1',
+            weightMutateConstant=4.0,
+            weightMutateOperator=0.5,
+            weightAddNode=0.5,
+            weightDeleteNode=0.5,
+            weightSimplify=0.05,
+            weightRandomize=0.25,
+            weightDoNothing=1.0,
         ):
     """ Runs symbolic regression in Julia, to fit y given X.
     Either provide a 2D numpy array for X, 1D array for y, or declare a test to run.
@@ -74,6 +81,12 @@ def eureqa(X=None, y=None, threads=4, parsimony=1e-3, alpha=10,
             eval_str = "np.sign(X[:, 2])*np.abs(X[:, 2])**2.5 + 5*np.cos(X[:, 3]) - 5"
         elif test == 'simple2':
             eval_str = "np.sign(X[:, 2])*np.abs(X[:, 2])**3.5 + 1/np.abs(X[:, 0])"
+        elif test == 'simple3':
+            eval_str = "np.exp(X[:, 0]/2) + 12.0 + np.log(np.abs(X[:, 0])*10 + 1)"
+        elif test == 'simple4':
+            eval_str = "1.0 + 3*X[:, 0]**2 - 0.5*X[:, 0]**3 + 0.1*X[:, 0]**4"
+        elif test == 'simple5':
+            eval_str = "(np.exp(X[:, 3]) + 3)/(X[:, 1] + np.cos(X[:, 0]))"
 
         X = np.random.randn(100, 5)*3
         y = eval(eval_str)
@@ -93,6 +106,15 @@ def eureqa(X=None, y=None, threads=4, parsimony=1e-3, alpha=10,
     const shouldOptimizeConstants = {'true' if shouldOptimizeConstants else 'false'}
     const hofFile = "{equation_file}"
     const nthreads = {threads:d}
+    const mutationWeights = [
+        {weightMutateConstant:f},
+        {weightMutateOperator:f},
+        {weightAddNode:f},
+        {weightDeleteNode:f},
+        {weightSimplify:f},
+        {weightRandomize:f},
+        {weightDoNothing:f}
+    ]
     """
 
     assert len(X.shape) == 2

operators.jl

@@ -3,3 +3,4 @@ plus(x::Float32, y::Float32)::Float32 = x+y
 mult(x::Float32, y::Float32)::Float32 = x*y;
 pow(x::Float32, y::Float32)::Float32 = sign(x)*abs(x)^y;
 div(x::Float32, y::Float32)::Float32 = x/y;
+log(x::Float32)::Float32 = log(abs(x) + 1f-9);