Allow numpy arrays to be passed

README.md

@@ -21,7 +21,8 @@ usage: eureqa.py [-h] [--threads THREADS] [--parsimony PARSIMONY]
                  [--fractionReplaced FRACTIONREPLACED] [--migration MIGRATION]
                  [--hofMigration HOFMIGRATION]
                  [--shouldOptimizeConstants SHOULDOPTIMIZECONSTANTS]
-                 [--annealing ANNEALING]
+                 [--annealing ANNEALING] [--equation_file EQUATION_FILE]
+                 [--test TEST]
                  [--binary-operators BINARY_OPERATORS [BINARY_OPERATORS ...]]
                  [--unary-operators UNARY_OPERATORS]
 
@@ -56,6 +57,10 @@ optional arguments:
                         that much) (default: True)
   --annealing ANNEALING
                         Whether to use simulated annealing (default: True)
+  --equation_file EQUATION_FILE
+                        File to dump best equations to (default:
+                        hall_of_fame.csv)
+  --test TEST           Which test to run (default: simple1)
   --binary-operators BINARY_OPERATORS [BINARY_OPERATORS ...]
                         Binary operators. Make sure they are defined in
                         operators.jl (default: ['plus', 'mul'])

eureqa.jl

@@ -557,7 +557,6 @@ function fullRun(niterations::Integer;
                 verbosity::Integer=0,
                 topn::Integer=10
                )
-    debug(verbosity, "Lets try to learn (x2^2 + cos(x3)) using regularized evolution from scratch")
     debug(verbosity, "Running with $nthreads threads")
     # Generate random initial populations
     allPops = [Population(npop, 3) for j=1:nthreads]

eureqa.py

@@ -2,9 +2,11 @@ import os
 from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
 from collections import namedtuple
 import pathlib
+import numpy as np
+import pandas as pd
 
 
-def eureqa(threads=4, parsimony=1e-3, alpha=10,
+def eureqa(X=None, y=None, threads=4, parsimony=1e-3, alpha=10,
         maxsize=20, migration=True,
         hofMigration=True, fractionReplacedHof=0.1,
         shouldOptimizeConstants=True,
@@ -12,8 +14,64 @@ def eureqa(threads=4, parsimony=1e-3, alpha=10,
         unary_operators=["cos", "exp", "sin"],
         niterations=20, npop=100, annealing=True,
         ncyclesperiteration=5000, fractionReplaced=0.1,
-        topn=10, equation_file='hall_of_fame.csv'
+        topn=10, equation_file='hall_of_fame.csv',
+        test='simple1'
         ):
+    """Either provide a 2D numpy array for X, 1D array for y, or declare a test to run.
+
+     --threads THREADS     Number of threads (default: 4)
+     --parsimony PARSIMONY
+                           How much to punish complexity (default: 0.001)
+     --alpha ALPHA         Scaling of temperature (default: 10)
+     --maxsize MAXSIZE     Max size of equation (default: 20)
+     --niterations NITERATIONS
+                           Number of total migration periods (default: 20)
+     --npop NPOP           Number of members per population (default: 100)
+     --ncyclesperiteration NCYCLESPERITERATION
+                           Number of evolutionary cycles per migration (default:
+                           5000)
+     --topn TOPN           How many best species to distribute from each
+                           population (default: 10)
+     --fractionReplacedHof FRACTIONREPLACEDHOF
+                           Fraction of population to replace with hall of fame
+                           (default: 0.1)
+     --fractionReplaced FRACTIONREPLACED
+                           Fraction of population to replace with best from other
+                           populations (default: 0.1)
+     --migration MIGRATION
+                           Whether to migrate (default: True)
+     --hofMigration HOFMIGRATION
+                           Whether to have hall of fame migration (default: True)
+     --shouldOptimizeConstants SHOULDOPTIMIZECONSTANTS
+                           Whether to use classical optimization on constants
+                           before every migration (doesn't impact performance
+                           that much) (default: True)
+     --annealing ANNEALING
+                           Whether to use simulated annealing (default: True)
+     --equation_file EQUATION_FILE
+                           File to dump best equations to (default:
+                           hall_of_fame.csv)
+     --test TEST           Which test to run (default: simple1)
+     --binary-operators BINARY_OPERATORS [BINARY_OPERATORS ...]
+                           Binary operators. Make sure they are defined in
+                           operators.jl (default: ['plus', 'mul'])
+     --unary-operators UNARY_OPERATORS
+                           Unary operators. Make sure they are defined in
+                           operators.jl (default: ['exp', 'sin', 'cos'])
+    """
+
+    if isinstance(binary_operators, str): binary_operators = [binary_operators]
+    if isinstance(unary_operators, str): unary_operators = [unary_operators]
+
+    if X is None:
+        if test == 'simple1':
+            eval_str = "X[:, 2]**2 + np.cos(X[:, 3]) - 5"
+        elif test == 'simple2':
+            eval_str = "X[:, 2]**3.5 + 1/abs(X[:, 0])"
+
+        X = np.random.randn(100, 5)*3
+        y = eval(eval_str)
+        print("Runing on", eval_str)
 
     def_hyperparams = f"""
     include("operators.jl")
@@ -48,12 +106,18 @@ def eureqa(threads=4, parsimony=1e-3, alpha=10,
     ##################
     """
 
+    assert len(X.shape) == 2
+    assert len(y.shape) == 1
+
+    X_str = str(X.tolist()).replace('],', '];').replace(',', '')
+    y_str = str(y.tolist())
+
     def_datasets = """
     # 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)
+    const X = convert(Array{Float32, 2}, """f"{X_str})""""
+    const y = convert(Array{Float32, 1}, """f"{y_str})""""
     ##########################
     """
 
@@ -63,18 +127,24 @@ def eureqa(threads=4, parsimony=1e-3, alpha=10,
     with open('.dataset.jl', 'w') as f:
         print(def_datasets, file=f)
 
-    command = ' '.join([
+    command = [
         f'cd {pathlib.Path(__file__).parent.absolute()}', #Move to filepath of code
         '&&',
         'julia -O3',
         f'--threads {threads}',
         '-e',
-        f'\'include("eureqa.jl"); fullRun({niterations:d}, npop={npop:d}, annealing={"true" if annealing else "false"}, ncyclesperiteration={ncyclesperiteration:d}, fractionReplaced={fractionReplaced:f}f0, verbosity=round(Int32, 1e9), topn={topn:d})\''
+        f'\'include("eureqa.jl"); fullRun({niterations:d}, npop={npop:d}, annealing={"true" if annealing else "false"}, ncyclesperiteration={ncyclesperiteration:d}, fractionReplaced={fractionReplaced:f}f0, verbosity=round(Int32, 1e9), topn={topn:d})\'',
         '&&',
         f'cd {pathlib.Path().absolute()}',
-        ])
+        ]
     import os
-    os.system(command)
+    cur_cmd = ' '.join(command[:-2])
+    print("Running on", cur_cmd)
+    os.system(cur_cmd)
+    output = pd.read_csv(equation_file, sep="|")
+    os.system(command[-1])
+    return output
+
 
 
 
@@ -97,6 +167,7 @@ if __name__ == "__main__":
     parser.add_argument("--shouldOptimizeConstants", type=bool, default=True, help="Whether to use classical optimization on constants before every migration (doesn't impact performance that much)")
     parser.add_argument("--annealing", type=bool, default=True, help="Whether to use simulated annealing")
     parser.add_argument("--equation_file", type=str, default='hall_of_fame.csv', help="File to dump best equations to")
+    parser.add_argument("--test", type=str, default='simple1', help="Which test to run")
 
     parser.add_argument(
             "--binary-operators", type=str, nargs="+", default=["plus", "mul"],

operators.jl

@@ -2,3 +2,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;