rowan.a.tl/propeller
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

single output PSB2 problems

Browse Source
This commit is contained in:
Shuzo Katayama 2021-07-15 11:37:43 -04:00
parent b92fa49125
commit 105e8faf4e
18 changed files with 333 additions and 115 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
src/propeller/problems/PSB2/basement.cljc
View File

@ -68,14 +68,14 @@
:error-function error-function :error-function error-function
:training-data (:train train-and-test-data) :training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data) :testing-data (:test train-and-test-data)
:max-generations 500 :max-generations 300
:population-size 500 :population-size 1000
:max-initial-plushy-size 100 :max-initial-plushy-size 250
:step-limit 200 :step-limit 2000
:parent-selection :lexicase :parent-selection :lexicase
:tournament-size 5 :tournament-size 5
:umad-rate 0.1 :umad-rate 0.1
:variation {:umad 0.5 :crossover 0.5} :variation {:umad 1.0 :crossover 0.0}
:elitism false} :elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args))))) (apply hash-map (map #(if (string? %) (read-string %) %) args)))))

10
src/propeller/problems/PSB2/bouncing_balls.cljc
View File

@ -80,13 +80,13 @@
:error-function error-function :error-function error-function
:training-data (:train train-and-test-data) :training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data) :testing-data (:test train-and-test-data)
:max-generations 500 :max-generations 300
:population-size 500 :population-size 1000
:max-initial-plushy-size 100 :max-initial-plushy-size 250
:step-limit 200 :step-limit 2000
:parent-selection :lexicase :parent-selection :lexicase
:tournament-size 5 :tournament-size 5
:umad-rate 0.1 :umad-rate 0.1
:variation {:umad 0.5 :crossover 0.5} :variation {:umad 1.0 :crossover 0.0}
:elitism false} :elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args))))) (apply hash-map (map #(if (string? %) (read-string %) %) args)))))

11
src/propeller/problems/PSB2/bowling.cljc
View File

@ -5,7 +5,6 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[clojure.pprint :as pprint]
[propeller.tools.math :as math] [propeller.tools.math :as math]
[propeller.gp :as gp])) [propeller.gp :as gp]))
@ -68,13 +67,13 @@
:error-function error-function :error-function error-function
:training-data (:train train-and-test-data) :training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data) :testing-data (:test train-and-test-data)
:max-generations 500 :max-generations 300
:population-size 500 :population-size 1000
:max-initial-plushy-size 100 :max-initial-plushy-size 250
:step-limit 200 :step-limit 2000
:parent-selection :lexicase :parent-selection :lexicase
:tournament-size 5 :tournament-size 5
:umad-rate 0.1 :umad-rate 0.1
:variation {:umad 0.5 :crossover 0.5} :variation {:umad 1.0 :crossover 0.0}
:elitism false} :elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args))))) (apply hash-map (map #(if (string? %) (read-string %) %) args)))))

11
src/propeller/problems/PSB2/camel_case.cljc
View File

@ -5,7 +5,6 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[propeller.tools.math :as math]
[propeller.tools.metrics :as metrics] [propeller.tools.metrics :as metrics]
[propeller.gp :as gp])) [propeller.gp :as gp]))
@ -104,13 +103,13 @@
:error-function error-function :error-function error-function
:training-data (:train train-and-test-data) :training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data) :testing-data (:test train-and-test-data)
:max-generations 500 :max-generations 300
:population-size 500 :population-size 1000
:max-initial-plushy-size 100 :max-initial-plushy-size 250
:step-limit 200 :step-limit 2000
:parent-selection :lexicase :parent-selection :lexicase
:tournament-size 5 :tournament-size 5
:umad-rate 0.1 :umad-rate 0.1
:variation {:umad 0.5 :crossover 0.5} :variation {:umad 1.0 :crossover 0.0}
:elitism false} :elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args))))) (apply hash-map (map #(if (string? %) (read-string %) %) args)))))

15
src/propeller/problems/PSB2/dice_game.cljc
View File

@ -5,7 +5,6 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[clojure.pprint :as pprint]
[propeller.tools.math :as math] [propeller.tools.math :as math]
[propeller.gp :as gp])) [propeller.gp :as gp]))
@ -21,12 +20,12 @@
(def train-and-test-data (psb2/fetch-examples "data" "dice-game" 200 2000)) (def train-and-test-data (psb2/fetch-examples "data" "dice-game" 200 2000))
(defn map-vals-input (defn map-vals-input
"Returns all the input values of a map (specific helper method for bouncing-balls)" "Returns all the input values of a map"
[i] [i]
(vals (select-keys i [:input1 :input2]))) (vals (select-keys i [:input1 :input2])))
(defn map-vals-output (defn map-vals-output
"Returns the output values of a map (specific helper method for bouncing-balls)" "Returns the output values of a map"
[i] [i]
(get i :output1)) (get i :output1))
@ -77,13 +76,13 @@
:error-function error-function :error-function error-function
:training-data (:train train-and-test-data) :training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data) :testing-data (:test train-and-test-data)
:max-generations 500 :max-generations 300
:population-size 500 :population-size 1000
:max-initial-plushy-size 100 :max-initial-plushy-size 250
:step-limit 200 :step-limit 2000
:parent-selection :lexicase :parent-selection :lexicase
:tournament-size 5 :tournament-size 5
:umad-rate 0.1 :umad-rate 0.1
:variation {:umad 0.5 :crossover 0.5} :variation {:umad 1.0 :crossover 0.0}
:elitism false} :elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args))))) (apply hash-map (map #(if (string? %) (read-string %) %) args)))))

27
src/propeller/problems/PSB2/fizz_buzz.cljc
View File

@ -5,7 +5,8 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[propeller.tools.metrics :as metrics])) [propeller.tools.metrics :as metrics]
[propeller.gp :as gp]))
; =========== PROBLEM DESCRIPTION ========================= ; =========== PROBLEM DESCRIPTION =========================
; FIZZ BUZZ from PSB2 ; FIZZ BUZZ from PSB2
@ -62,9 +63,23 @@
:cljs (apply + errors))))) :cljs (apply + errors)))))
(def arglist (defn -main
{:instructions instructions "Runs propel-gp, giving it a map of arguments."
:error-function error-function [& args]
:training-data (:train train-and-test-data) (gp/gp
:testing-data (:test train-and-test-data)}) (merge
{:instructions instructions
:error-function error-function
:training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data)
:max-generations 300
:population-size 1000
:max-initial-plushy-size 250
:step-limit 2000
:parent-selection :lexicase
:tournament-size 5
:umad-rate 0.1
:variation {:umad 1.0 :crossover 0.0}
:elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args)))))

11
src/propeller/problems/PSB2/fuel_cost.cljc
View File

@ -5,7 +5,6 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[clojure.pprint :as pprint]
[propeller.tools.math :as math] [propeller.tools.math :as math]
[propeller.gp :as gp])) [propeller.gp :as gp]))
@ -70,14 +69,14 @@
:error-function error-function :error-function error-function
:training-data (:train train-and-test-data) :training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data) :testing-data (:test train-and-test-data)
:max-generations 500 :max-generations 300
:population-size 500 :population-size 1000
:max-initial-plushy-size 100 :max-initial-plushy-size 250
:step-limit 200 :step-limit 2000
:parent-selection :lexicase :parent-selection :lexicase
:tournament-size 5 :tournament-size 5
:umad-rate 0.1 :umad-rate 0.1
:variation {:umad 0.5 :crossover 0.5} :variation {:umad 1.0 :crossover 0.0}
:elitism false} :elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args))))) (apply hash-map (map #(if (string? %) (read-string %) %) args)))))

32
src/propeller/problems/PSB2/gcd.cljc
View File

@ -5,7 +5,8 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[propeller.tools.math :as math])) [propeller.tools.math :as math]
[propeller.gp :as gp]))
; =========== PROBLEM DESCRIPTION =============================== ; =========== PROBLEM DESCRIPTION ===============================
; GCD [GREATEST COMMON DIVISOR] from PSB2 ; GCD [GREATEST COMMON DIVISOR] from PSB2
@ -20,12 +21,12 @@
(defn random-int [] (- (rand-int 201) 100)) (defn random-int [] (- (rand-int 201) 100))
(defn map-vals-input (defn map-vals-input
"Returns all the input values of a map (specific helper method for bouncing-balls)" "Returns all the input values of a map"
[i] [i]
(vals (select-keys i [:input1 :input2]))) (vals (select-keys i [:input1 :input2])))
(defn map-vals-output (defn map-vals-output
"Returns the output values of a map (specific helper method for bouncing-balls)" "Returns the output values of a map"
[i] [i]
(get i :output1)) (get i :output1))
@ -67,9 +68,22 @@
:total-error #?(:clj (apply +' errors) :total-error #?(:clj (apply +' errors)
:cljs (apply + errors))))) :cljs (apply + errors)))))
(def arglist (defn -main
{:instructions instructions "Runs propel-gp, giving it a map of arguments."
:error-function error-function [& args]
:training-data (:train train-and-test-data) (gp/gp
:testing-data (:test train-and-test-data)}) (merge
{:instructions instructions
:error-function error-function
:training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data)
:max-generations 300
:population-size 1000
:max-initial-plushy-size 250
:step-limit 2000
:parent-selection :lexicase
:tournament-size 5
:umad-rate 0.1
:variation {:umad 1.0 :crossover 0.0}
:elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args)))))

27
src/propeller/problems/PSB2/luhn.cljc
View File

@ -5,7 +5,8 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[propeller.tools.math :as math])) [propeller.tools.math :as math]
[propeller.gp :as gp]))
; =========== PROBLEM DESCRIPTION ============================ ; =========== PROBLEM DESCRIPTION ============================
; LUHN from PSB2 ; LUHN from PSB2
@ -60,10 +61,24 @@
:total-error #?(:clj (apply +' errors) :total-error #?(:clj (apply +' errors)
:cljs (apply + errors))))) :cljs (apply + errors)))))
(def arglist (defn -main
{:instructions instructions "Runs propel-gp, giving it a map of arguments."
:error-function error-function [& args]
:training-data (:train train-and-test-data) (gp/gp
:testing-data (:test train-and-test-data)}) (merge
{:instructions instructions
:error-function error-function
:training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data)
:max-generations 300
:population-size 1000
:max-initial-plushy-size 250
:step-limit 2000
:parent-selection :lexicase
:tournament-size 5
:umad-rate 0.1
:variation {:umad 1.0 :crossover 0.0}
:elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args)))))

11
src/propeller/problems/PSB2/middle_character.cljc
View File

@ -5,7 +5,6 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[propeller.tools.math :as math]
[propeller.tools.metrics :as metrics] [propeller.tools.metrics :as metrics]
[propeller.gp :as gp])) [propeller.gp :as gp]))
@ -73,13 +72,13 @@
:error-function error-function :error-function error-function
:training-data (:train train-and-test-data) :training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data) :testing-data (:test train-and-test-data)
:max-generations 500 :max-generations 300
:population-size 500 :population-size 1000
:max-initial-plushy-size 100 :max-initial-plushy-size 250
:step-limit 200 :step-limit 2000
:parent-selection :lexicase :parent-selection :lexicase
:tournament-size 5 :tournament-size 5
:umad-rate 0.1 :umad-rate 0.1
:variation {:umad 0.5 :crossover 0.5} :variation {:umad 1.0 :crossover 0.0}
:elitism false} :elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args))))) (apply hash-map (map #(if (string? %) (read-string %) %) args)))))

27
src/propeller/problems/PSB2/paired_digits.cljc
View File

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

31
src/propeller/problems/PSB2/shopping_list.cljc
View File

@ -5,7 +5,8 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[propeller.tools.math :as math])) [propeller.tools.math :as math]
[propeller.gp :as gp]))
; =========== PROBLEM DESCRIPTION =============================== ; =========== PROBLEM DESCRIPTION ===============================
; DICE GAME from PSB2 ; DICE GAME from PSB2
@ -21,12 +22,12 @@
(defn random-float [] (- (rand 201) 100)) (defn random-float [] (- (rand 201) 100))
(defn map-vals-input (defn map-vals-input
"Returns all the input values of a map (specific helper method for bouncing-balls)" "Returns all the input values of a map"
[i] [i]
(vals (select-keys i [:input1 :input2]))) (vals (select-keys i [:input1 :input2])))
(defn map-vals-output (defn map-vals-output
"Returns the output values of a map (specific helper method for bouncing-balls)" "Returns the output values of a map "
[i] [i]
(get i :output1)) (get i :output1))
@ -68,8 +69,22 @@
:total-error #?(:clj (apply +' errors) :total-error #?(:clj (apply +' errors)
:cljs (apply + errors))))) :cljs (apply + errors)))))
(def arglist (defn -main
{:instructions instructions "Runs propel-gp, giving it a map of arguments."
:error-function error-function [& args]
:training-data (:train train-and-test-data) (gp/gp
:testing-data (:test train-and-test-data)}) (merge
{:instructions instructions
:error-function error-function
:training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data)
:max-generations 300
:population-size 1000
:max-initial-plushy-size 250
:step-limit 2000
:parent-selection :lexicase
:tournament-size 5
:umad-rate 0.1
:variation {:umad 1.0 :crossover 0.0}
:elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args)))))

31
src/propeller/problems/PSB2/snow_day.cljc
View File

@ -5,7 +5,8 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[propeller.tools.math :as math])) [propeller.tools.math :as math]
[propeller.gp :as gp]))
; =========== PROBLEM DESCRIPTION =============================== ; =========== PROBLEM DESCRIPTION ===============================
; SNOW DAY from PSB2 ; SNOW DAY from PSB2
@ -23,12 +24,12 @@
(def train-and-test-data (psb2/fetch-examples "data" "snow-day" 200 2000)) (def train-and-test-data (psb2/fetch-examples "data" "snow-day" 200 2000))
(defn map-vals-input (defn map-vals-input
"Returns all the input values of a map (specific helper method for bouncing-balls)" "Returns all the input values of a map"
[i] [i]
(vals (select-keys i [:input1 :input2 :input3 :input4]))) (vals (select-keys i [:input1 :input2 :input3 :input4])))
(defn map-vals-output (defn map-vals-output
"Returns the output values of a map (specific helper method for bouncing-balls)" "Returns the output values of a map"
[i] [i]
(get i :output1)) (get i :output1))
@ -72,8 +73,22 @@
:total-error #?(:clj (apply +' errors) :total-error #?(:clj (apply +' errors)
:cljs (apply + errors))))) :cljs (apply + errors)))))
(def arglist (defn -main
{:instructions instructions "Runs propel-gp, giving it a map of arguments."
:error-function error-function [& args]
:training-data (:train train-and-test-data) (gp/gp
:testing-data (:test train-and-test-data)}) (merge
{:instructions instructions
:error-function error-function
:training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data)
:max-generations 300
:population-size 1000
:max-initial-plushy-size 250
:step-limit 2000
:parent-selection :lexicase
:tournament-size 5
:umad-rate 0.1
:variation {:umad 1.0 :crossover 0.0}
:elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args)))))

27
src/propeller/problems/PSB2/solve_boolean.cljc
View File

@ -5,7 +5,7 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[propeller.tools.metrics :as metrics])) [propeller.gp :as gp]))
; =========== PROBLEM DESCRIPTION ================================ ; =========== PROBLEM DESCRIPTION ================================
; SOLVE BOOLEAN from PSB2 ; SOLVE BOOLEAN from PSB2
@ -62,9 +62,22 @@
:total-error #?(:clj (apply +' errors) :total-error #?(:clj (apply +' errors)
:cljs (apply + errors))))) :cljs (apply + errors)))))
(def arglist (defn -main
{:instructions instructions "Runs propel-gp, giving it a map of arguments."
:error-function error-function [& args]
:training-data (:train train-and-test-data) (gp/gp
:testing-data (:test train-and-test-data)}) (merge
{:instructions instructions
:error-function error-function
:training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data)
:max-generations 300
:population-size 1000
:max-initial-plushy-size 250
:step-limit 2000
:parent-selection :lexicase
:tournament-size 5
:umad-rate 0.1
:variation {:umad 1.0 :crossover 0.0}
:elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args)))))

55
src/propeller/problems/PSB2/spin_words.cljc
View File

@ -5,7 +5,8 @@
[propeller.utils :as utils] [propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]] [propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state] [propeller.push.state :as state]
[propeller.tools.metrics :as metrics])) [propeller.tools.metrics :as metrics]
[propeller.gp :as gp]))
; =========== PROBLEM DESCRIPTION ============================== ; =========== PROBLEM DESCRIPTION ==============================
; SPIN WORDS from PSB2 ; SPIN WORDS from PSB2
@ -23,8 +24,29 @@
[] []
(rand-nth (map char (range 97 122)))) (rand-nth (map char (range 97 122))))
;; WORK ON THIS TOMORROW; ; random word generator for ERC
;; SPIN WORDS STRING ERC; ; from https://github.com/thelmuth/Clojush/blob/psb2/src/clojush/problems/psb2/spin_words.clj
(defn word-generator
[]
(let [word-len (inc (rand-int (if (< (rand) 0.8)
8
16)))]
(apply str (repeatedly word-len #(random-char)))))
; String ERC; random word
; from https://github.com/thelmuth/Clojush/blob/psb2/src/clojush/problems/psb2/spin_words.clj
(defn random-input
"Makes a Spin Words input of length len, which is just a string of words, where the
words that are length 5 or greater are reversed"
[len]
(let [words (apply str
(take len ; This looks weird because str isn't lazy, so you
(apply str ; need to take len twice here.
(take len
(interpose " " (repeatedly word-generator))))))]
(if (not= (last words) \space)
words
(apply str (butlast words)))))
(def instructions (def instructions
(utils/not-lazy (utils/not-lazy
@ -36,8 +58,7 @@
;;; close ;;; close
(list 'close) (list 'close)
;;; ERCs (constants) ;;; ERCs (constants)
(list 4 5 \space random-char )))) (list 4 5 \space random-char (fn [] (random-input (rand-int 21)))))))
(defn error-function (defn error-function
[argmap data individual] [argmap data individual]
@ -69,9 +90,23 @@
:total-error #?(:clj (apply +' errors) :total-error #?(:clj (apply +' errors)
:cljs (apply + errors))))) :cljs (apply + errors)))))
(def arglist (defn -main
{:instructions instructions "Runs propel-gp, giving it a map of arguments."
:error-function error-function [& args]
:training-data (:train train-and-test-data) (gp/gp
:testing-data (:test train-and-test-data)}) (merge
{:instructions instructions
:error-function error-function
:training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data)
:max-generations 300
:population-size 1000
:max-initial-plushy-size 250
:step-limit 2000
:parent-selection :lexicase
:tournament-size 5
:umad-rate 0.1
:variation {:umad 1.0 :crossover 0.0}
:elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args)))))

86
src/propeller/problems/PSB2/square_digits.cljc Normal file
View File

@ -0,0 +1,86 @@
(ns propeller.problems.PSB2.square-digits
(:require [psb2.core :as psb2]
[propeller.genome :as genome]
[propeller.push.interpreter :as interpreter]
[propeller.utils :as utils]
[propeller.push.utils.helpers :refer [get-stack-instructions]]
[propeller.push.state :as state]
[propeller.tools.metrics :as metrics]
[propeller.gp :as gp]))
; =========== PROBLEM DESCRIPTION =========================
; SQUARE DIGITS from PSB2
; Given a positive integer, square each
; digit and concatenate the squares into a returned string.
;
; Source: https://arxiv.org/pdf/2106.06086.pdf
; ============================================================
(def train-and-test-data (psb2/fetch-examples "data" "square-digits" 200 2000))
(defn random-int [] (- (rand-int 201) 100))
(def instructions
(utils/not-lazy
(concat
;;; stack-specific instructions
(get-stack-instructions #{:exec :integer :boolean :char :string :print})
;;; input instructions
(list :in1)
;;; close
(list 'close)
;;; ERCs (constants)
(list "" 0 1 2 random-int))))
(defn error-function
[argmap data individual]
(let [program (genome/plushy->push (:plushy individual) argmap)
inputs (map (fn [i] (get i :input1)) data)
correct-outputs (map (fn [i] (get i :output1)) data)
outputs (map (fn [input]
(state/peek-stack
(interpreter/interpret-program
program
(assoc state/empty-state :input {:in1 input})
(:step-limit argmap))
:string))
inputs)
parsed-outputs (map (fn [output]
(try (read-string output)
#?(:clj (catch Exception e 1000.0)
:cljs (catch js/Error. e 1000.0))))
outputs)
errors (map (fn [correct-output output]
(if (= output :no-stack-item)
10000
(metrics/levenshtein-distance (str correct-output) (str output))))
correct-outputs
parsed-outputs)]
(assoc individual
:behaviors parsed-outputs
:errors errors
:total-error #?(:clj (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 300
:population-size 1000
:max-initial-plushy-size 250
:step-limit 2000
:parent-selection :lexicase
:tournament-size 5
:umad-rate 0.1
:variation {:umad 1.0 :crossover 0.0}
:elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args)))))

14
src/propeller/problems/PSB2/substitution_cipher.cljc
View File

@ -23,12 +23,12 @@
(def train-and-test-data (psb2/fetch-examples "data" "substitution-cipher" 200 2000)) (def train-and-test-data (psb2/fetch-examples "data" "substitution-cipher" 200 2000))
(defn map-vals-input (defn map-vals-input
"Returns all the input values of a map (specific helper method for substitution-cipher)" "Returns all the input values of a map"
[i] [i]
(vals (select-keys i [:input1 :input2 :input3]))) (vals (select-keys i [:input1 :input2 :input3])))
(defn map-vals-output (defn map-vals-output
"Returns the output values of a map (specific helper method for substitution-cipher)" "Returns the output values of a map"
[i] [i]
(vals (select-keys i [:output1]))) (vals (select-keys i [:output1])))
@ -85,13 +85,13 @@
:error-function error-function :error-function error-function
:training-data (:train train-and-test-data) :training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data) :testing-data (:test train-and-test-data)
:max-generations 500 :max-generations 300
:population-size 500 :population-size 1000
:max-initial-plushy-size 100 :max-initial-plushy-size 250
:step-limit 200 :step-limit 2000
:parent-selection :lexicase :parent-selection :lexicase
:tournament-size 5 :tournament-size 5
:umad-rate 0.1 :umad-rate 0.1
:variation {:umad 0.5 :crossover 0.5} :variation {:umad 1.0 :crossover 0.0}
:elitism false} :elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args))))) (apply hash-map (map #(if (string? %) (read-string %) %) args)))))

10
src/propeller/problems/PSB2/twitter.cljc
View File

@ -76,13 +76,13 @@
:error-function error-function :error-function error-function
:training-data (:train train-and-test-data) :training-data (:train train-and-test-data)
:testing-data (:test train-and-test-data) :testing-data (:test train-and-test-data)
:max-generations 500 :max-generations 300
:population-size 500 :population-size 1000
:max-initial-plushy-size 100 :max-initial-plushy-size 250
:step-limit 200 :step-limit 2000
:parent-selection :lexicase :parent-selection :lexicase
:tournament-size 5 :tournament-size 5
:umad-rate 0.1 :umad-rate 0.1
:variation {:umad 0.5 :crossover 0.5} :variation {:umad 1.0 :crossover 0.0}
:elitism false} :elitism false}
(apply hash-map (map #(if (string? %) (read-string %) %) args))))) (apply hash-map (map #(if (string? %) (read-string %) %) args)))))