Make all problem files contain -main, gp call, and default argmap

src/propeller/problems/PSB2/basement.cljc

@@ -6,7 +6,8 @@
             [propeller.push.utils.helpers :refer [get-stack-instructions]]
             [propeller.push.state :as state]
             [clojure.pprint :as pprint]
-            [propeller.tools.math :as math]))
+            [propeller.tools.math :as math]
+            [propeller.gp :as gp]))
 
 ; ===========  PROBLEM DESCRIPTION  ============================
 ; BASEMENT from PSB2
@@ -59,9 +60,23 @@
       :total-error #?(:clj  (apply +' errors)
                       :cljs (apply + errors)))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))
 

src/propeller/problems/PSB2/bouncing_balls.cljc

@@ -6,7 +6,8 @@
             [propeller.push.utils.helpers :refer [get-stack-instructions]]
             [propeller.push.state :as state]
             [clojure.pprint :as pprint]
-            [propeller.tools.math :as math]))
+            [propeller.tools.math :as math]
+            [propeller.gp :as gp]))
 
 ; ===========  PROBLEM DESCRIPTION  ===============================
 ; BOUNCING BALLS from PSB2
@@ -70,8 +71,22 @@
       :total-error #?(:clj  (apply +' errors)
                       :cljs (apply + errors)))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))

src/propeller/problems/PSB2/bowling.cljc

@@ -6,7 +6,8 @@
             [propeller.push.utils.helpers :refer [get-stack-instructions]]
             [propeller.push.state :as state]
             [clojure.pprint :as pprint]
-            [propeller.tools.math :as math]))
+            [propeller.tools.math :as math]
+            [propeller.gp :as gp]))
 
 ; ===========  PROBLEM DESCRIPTION  ======================
 ; BOWLING from PSB2
@@ -58,8 +59,22 @@
       :total-error #?(:clj  (apply +' errors)
                       :cljs (apply + errors)))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))

src/propeller/problems/PSB2/camel_case.cljc

@@ -6,7 +6,8 @@
             [propeller.push.utils.helpers :refer [get-stack-instructions]]
             [propeller.push.state :as state]
             [propeller.tools.math :as math]
-            [propeller.tools.metrics :as metrics]))
+            [propeller.tools.metrics :as metrics]
+            [propeller.gp :as gp]))
 
 ; ===========  PROBLEM DESCRIPTION  =====================================
 ; CAMEL CASE from PSB2
@@ -94,8 +95,22 @@
       :total-error #?(:clj  (apply +' errors)
                       :cljs (apply + errors)))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))

src/propeller/problems/PSB2/dice_game.cljc

@@ -6,7 +6,8 @@
             [propeller.push.utils.helpers :refer [get-stack-instructions]]
             [propeller.push.state :as state]
             [clojure.pprint :as pprint]
-            [propeller.tools.math :as math]))
+            [propeller.tools.math :as math]
+            [propeller.gp :as gp]))
 
 ; ===========  PROBLEM DESCRIPTION  ===============================
 ; DICE GAME from PSB2
@@ -67,8 +68,22 @@
       :total-error #?(:clj  (apply +' errors)
                       :cljs (apply + errors)))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))

src/propeller/problems/PSB2/fuel_cost.cljc

@@ -6,7 +6,8 @@
             [propeller.push.utils.helpers :refer [get-stack-instructions]]
             [propeller.push.state :as state]
             [clojure.pprint :as pprint]
-            [propeller.tools.math :as math]))
+            [propeller.tools.math :as math]
+            [propeller.gp :as gp]))
 
 ; ===========  PROBLEM DESCRIPTION  =========================
 ; FUEL COST from PSB2
@@ -60,9 +61,23 @@
       :total-error #?(:clj  (apply +' errors)
                       :cljs (apply + errors)))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))
 

src/propeller/problems/PSB2/middle_character.cljc

@@ -6,7 +6,8 @@
             [propeller.push.utils.helpers :refer [get-stack-instructions]]
             [propeller.push.state :as state]
             [propeller.tools.math :as math]
-            [propeller.tools.metrics :as metrics]))
+            [propeller.tools.metrics :as metrics]
+            [propeller.gp :as gp]))
 
 ; ===========  PROBLEM DESCRIPTION  =============================
 ; MIDDLE CHARACTER from PSB2
@@ -63,8 +64,22 @@
       :total-error #?(:clj  (apply +' errors)
                       :cljs (apply + errors)))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))

src/propeller/problems/PSB2/substitution_cipher.cljc

@@ -6,7 +6,8 @@
             [propeller.push.utils.helpers :refer [get-stack-instructions]]
             [propeller.push.state :as state]
             [propeller.tools.math :as math]
-            [propeller.tools.metrics :as metrics]))
+            [propeller.tools.metrics :as metrics]
+            [propeller.gp :as gp]))
 
 ; ===========  PROBLEM DESCRIPTION  =========================
 ; SUBSTITUTION CIPHER from PSB2
@@ -75,8 +76,22 @@
       :total-error #?(:clj  (apply +' errors)
                       :cljs (apply + errors)))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))

src/propeller/problems/PSB2/twitter.cljc

@@ -6,7 +6,8 @@
             [propeller.push.utils.helpers :refer [get-stack-instructions]]
             [propeller.push.state :as state]
             [propeller.tools.math :as math]
-            [propeller.tools.metrics :as metrics]))
+            [propeller.tools.metrics :as metrics]
+            [propeller.gp :as gp]))
 
 ; ===========  PROBLEM DESCRIPTION  =============================
 ; TWITTER from PSB2
@@ -66,8 +67,22 @@
       :total-error #?(:clj  (apply +' errors)
                       :cljs (apply + errors)))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))

src/propeller/problems/simple_regression.cljc

@@ -2,7 +2,8 @@
   (:require [propeller.genome :as genome]
             [propeller.push.interpreter :as interpreter]
             [propeller.push.state :as state]
-            [propeller.tools.math :as math]))
+            [propeller.tools.math :as math]
+            [propeller.gp :as gp]))
 
 (defn- target-function
   "Target function: f(x) = x^3 + x + 3"
@@ -59,8 +60,22 @@
        :total-error #?(:clj  (apply +' errors)
                        :cljs (apply + errors))))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))

src/propeller/problems/software/number_io.cljc

@@ -6,6 +6,7 @@
             [propeller.utils :as utils]
             [propeller.push.state :as state]
             [propeller.tools.math :as math]
+            [propeller.gp :as gp]
             #?(:cljs [cljs.reader :refer [read-string]])))
 
 ;; =============================================================================
@@ -60,11 +61,8 @@
      :test  test-set}))
 
 (defn error-function
-  ([argmap individual]
+  [argmap data individual]
-   (error-function argmap individual :train))
-  ([argmap individual subset]
   (let [program (genome/plushy->push (:plushy individual) argmap)
-         data (get train-and-test-data subset)
         inputs (:inputs data)
         correct-outputs (:outputs data)
         outputs (map (fn [input]
@@ -90,4 +88,24 @@
       :behaviors parsed-outputs
       :errors errors
       :total-error #?(:clj  (apply +' errors)
-                       :cljs (apply + errors))))))
+                      :cljs (apply + errors)))))
+
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
+      {:instructions            instructions
+       :error-function          error-function
+       :training-data           (:train train-and-test-data)
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))

src/propeller/problems/software/smallest.cljc

@@ -5,6 +5,7 @@
             [propeller.push.utils.helpers :refer [get-stack-instructions]]
             [propeller.utils :as utils]
             [propeller.push.state :as state]
+            [propeller.gp :as gp]
             #?(:cljs [cljs.reader :refer [read-string]])))
 
 ;; =============================================================================
@@ -62,11 +63,8 @@
      :test  test-set}))
 
 (defn error-function
-  ([argmap individual]
+  [argmap data individual]
-   (error-function argmap individual :train))
-  ([argmap individual subset]
   (let [program (genome/plushy->push (:plushy individual) argmap)
-         data (get train-and-test-data subset)
         inputs (:inputs data)
         correct-outputs (:outputs data)
         outputs (map (fn [input]
@@ -92,4 +90,24 @@
       :behaviors outputs
       :errors errors
       :total-error #?(:clj  (apply +' errors)
-                       :cljs (apply + errors))))))
+                      :cljs (apply + errors)))))
+
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
+      {:instructions            instructions
+       :error-function          error-function
+       :training-data           (:train train-and-test-data)
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))

src/propeller/problems/string_classification.cljc

@@ -1,7 +1,8 @@
 (ns propeller.problems.string-classification
   (:require [propeller.genome :as genome]
             [propeller.push.interpreter :as interpreter]
-            [propeller.push.state :as state]))
+            [propeller.push.state :as state]
+            [propeller.gp :as gp]))
 
 ;; =============================================================================
 ;; String classification
@@ -79,8 +80,22 @@
       :total-error #?(:clj  (apply +' errors)
                       :cljs (apply + errors)))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))

src/propeller/problems/valiant.cljc

@@ -1,7 +1,8 @@
 (ns propeller.problems.valiant
   (:require [propeller.genome :as genome]
             [propeller.push.interpreter :as interpreter]
-            [propeller.push.state :as state]))
+            [propeller.push.state :as state]
+            [propeller.gp :as gp]))
 
 (def num-vars 100)                                          ;10) ;100)                                          ;1000)
 (def num-inputs 50)                                         ;5) ; 50)                                         ;500)
@@ -58,8 +59,22 @@
       :total-error #?(:clj  (apply +' errors)
                       :cljs (apply + errors)))))
 
-(def arglist
+(defn -main
+  "Runs propel-gp, giving it a map of arguments."
+  [& args]
+  (gp/gp
+    (merge
       {:instructions            instructions
        :error-function          error-function
        :training-data           (:train train-and-test-data)
-   :testing-data   (:test train-and-test-data)})
+       :testing-data            (:test train-and-test-data)
+       :max-generations         500
+       :population-size         500
+       :max-initial-plushy-size 100
+       :step-limit              200
+       :parent-selection        :lexicase
+       :tournament-size         5
+       :umad-rate               0.1
+       :variation               {:umad 0.5 :crossover 0.5}
+       :elitism                 false}
+      (apply hash-map (map read-string (rest args))))))