From d3a81759c311a9ccfc4d17d2cb9347b9367cb7d1 Mon Sep 17 00:00:00 2001
From: "Dobbertin, Niclas" <niclas.dobbertin@mailbox.org>
Date: Wed, 31 Jul 2024 00:00:03 +0200
Subject: env progr
---
modeling/frensch_procedures.py | 155 ++++++++++++++++++++++++++++++++++++++
modeling/model_env.py | 117 +++++++++++++++++------------
modeling/model_init.py | 17 +++++
modeling/productions_math.py | 165 ++++++++++++++++++-----------------------
4 files changed, 314 insertions(+), 140 deletions(-)
create mode 100644 modeling/frensch_procedures.py
(limited to 'modeling')
diff --git a/modeling/frensch_procedures.py b/modeling/frensch_procedures.py
new file mode 100644
index 0000000..9dcbf36
--- /dev/null
+++ b/modeling/frensch_procedures.py
@@ -0,0 +1,155 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+import random
+
+
+class WaterSample:
+ def __init__(
+ self,
+ solid: int,
+ algae: int,
+ lime: tuple[int, int, int, int],
+ toxin: tuple[int, int, int, int],
+ ):
+ self.solid = solid
+ self.algae = algae
+ self.lime = lime
+ self.toxin = toxin
+
+ def procedure_dict(self):
+ procedures = {
+ "1": (self.index1(), self.index1_str()),
+ "2": (self.index2(), self.index2_str()),
+ "3": (self.index3(), self.index3_str()),
+ "4": (self.index4(), self.index4_str()),
+ "5": (self.index5(), self.index5_str()),
+ "6": (self.index6(), self.index6_str()),
+ "overall": (self.overall(), self.overall_str()),
+ }
+
+ return procedures
+
+ def water_sample_dict(self):
+ sample = {
+ "1": (self.index1(), self.index1_str()),
+ "2": (self.index2(), self.index2_str()),
+ "3": (self.index3(), self.index3_str()),
+ "4": (self.index4(), self.index4_str()),
+ "5": (self.index5(), self.index5_str()),
+ "6": (self.index6(), self.index6_str()),
+ "overall": (self.overall(), self.overall_str()),
+ "solid": self.solid,
+ "algae": self.algae,
+ "lime": self.lime,
+ "toxin": self.toxin,
+ }
+ return sample
+
+ def select_procedures(self):
+ procedures = [
+ (self.index1, self.index1_str),
+ (self.index2, self.index2_str),
+ (self.index3, self.index3_str),
+ (self.index4, self.index4_str),
+ (self.index5, self.index5_str),
+ (self.index6, self.index6_str),
+ ]
+ random.shuffle(procedures)
+ training_procedures = procedures[:-1]
+ training_procedures.append((self.overall, self.overall_str))
+
+ return training_procedures, procedures[-1]
+
+ def index1(self):
+ return (self.lime[3] - self.lime[1]) * self.solid
+
+ def index1_str(self):
+ return "(Sandstein_4 - Sandstein_2) * Mineralien"
+
+ def index2(self):
+ return (2 * self.algae) + min(self.lime)
+
+ def index2_str(self):
+ return "(2 * Algen) + Sandstein_min"
+
+ def index3(self):
+ return max(self.toxin) + min(self.toxin)
+
+ def index3_str(self):
+ return "Gifte_max + Gifte_min"
+
+ def index4(self):
+ return (self.solid * 2) - self.toxin[3]
+
+ def index4_str(self):
+ return "(Mineralien * 2) - Gifte_4"
+
+ def index5(self):
+ return max(self.lime[2], (self.toxin[2] - self.toxin[1]))
+
+ def index5_str(self):
+ return "Das Höhere von (Gifte_3 - Gifte_2), (Sandstein_3)"
+
+ def index6(self):
+ return min(self.algae, (self.lime[0] + self.toxin[0]))
+
+ def index6_str(self):
+ return "Das Kleinere von (Sandstein_1 + Gifte_1), (Algen)"
+
+ def overall(self):
+ return 100 - max(
+ self.index1(), self.index2(), self.index3(), self.index4(), self.index5()
+ )
+
+ def overall_str(self):
+ return "100 - dem Höchstem aller Ergebnisse"
+
+ def print_all(self):
+ print(f"Solid: {self.solid}")
+ print(f"Algae: {self.algae}")
+ print(f"Lime: {self.lime}")
+ print(f"Toxin: {self.toxin}")
+ print(f"Index 1: {self.index1_str()} = {self.index1()}")
+ print(f"Index 2: {self.index2_str()} = {self.index2()}")
+ print(f"Index 3: {self.index3_str()} = {self.index3()}")
+ print(f"Index 4: {self.index4_str()} = {self.index4()}")
+ print(f"Index 5: {self.index5_str()} = {self.index5()}")
+ print(f"Index 6: {self.index6_str()} = {self.index6()}")
+ print(f"Overall Quality: {self.overall_str()} = {self.overall()}")
+
+
+# No step should produce a negative number, greater/lesser of comparisons should not
+# use equal numbers
+def constrained_WaterSample():
+ water_sample = random_WaterSample()
+ resample = True
+ while resample:
+ water_sample = random_WaterSample()
+ resample = False
+ # check for negative results
+ for proc in water_sample.procedure_dict().keys():
+ if water_sample.procedure_dict()[proc][0] < 0:
+ resample = True
+ # check for negative intermediate result
+ if (water_sample.lime[3] - water_sample.lime[1]) < 0:
+ resample = True
+ if (water_sample.toxin[2] - water_sample.toxin[1]) < 0:
+ resample = True
+ # check for greater/lesser equality
+ # procedure 5
+ if (water_sample.toxin[2] - water_sample.toxin[1]) == water_sample.lime[2]:
+ resample = True
+ # procedure 6
+ if (water_sample.lime[0] + water_sample.toxin[0]) == water_sample.algae:
+ resample = True
+ return water_sample
+
+
+def random_WaterSample():
+ solid = random.randint(1, 9)
+ algae = random.randint(1, 9)
+ lime = tuple(random.randint(1, 9) for _ in range(4))
+ toxin = tuple(random.randint(1, 9) for _ in range(4))
+
+ return WaterSample(solid, algae, lime, toxin)
diff --git a/modeling/model_env.py b/modeling/model_env.py
index 7dcad3e..1ad9495 100644
--- a/modeling/model_env.py
+++ b/modeling/model_env.py
@@ -1,54 +1,79 @@
#!/usr/bin/env python3
+import random
-def generate_environments():
- envs = []
+from modeling import frensch_procedures
+
+
+class Stimuli:
+ current_stimulus_id = 0
+
+ def __init__(self, condition, training_N=75, test_N=50):
+ self.condition = condition
+ self.training_N = training_N
+ self.test_N = test_N
+
+ def generate_stimuli(self):
+ self.training_stimuli = frensch_procedures.constrained_WaterSample()
+ self.test_stimuli = frensch_procedures.constrained_WaterSample()
+
+ def next_stimulus(self):
+ self.current_stimulus_id += 1
+ if self.current_stimulus_id < self.training_N:
+ return self.training_stimuli[self.current_stimulus_id]
+ else:
+ return self.test_stimuli[self.current_stimulus_id - self.training_N]
+
+
+ def update_current_stimulus(self, ):
+ pass
+
+ def generate_environments(self):
+ envs = []
- for i in range(3):
screen = {}
- screen["id"] = {"text": i, "position":(0,0)}
- generate_variables(screen)
- generate_procedures(screen)
+ self.generate_variables(screen)
+ self.generate_procedures(screen)
envs.append(screen)
- return envs
-
-
-def generate_procedures(screen):
- procs = ["procs1", "procs2", "procs3", "procs4", "procs5", "procs6"]
- screen["Procedure1"] = {"text": procs[0], "position": (0, 100)}
- screen["Procedure2"] = {"text": procs[1], "position": (0, 200)}
- screen["Procedure3"] = {"text": procs[2], "position": (0, 300)}
- screen["Procedure4"] = {"text": procs[3], "position": (0, 400)}
- screen["Procedure5"] = {"text": procs[4], "position": (0, 500)}
-
- screen["ProcedureOverall"] = {"text": "proc_overall", "position": (0, 600)}
-
- screen["Answers"] = {"text": "Answers", "position": (100, 100)}
- screen["Answer1"] = {"text": 1, "position": (100, 200)}
- screen["Answer2"] = {"text": 2, "position": (100, 300)}
- screen["Answer3"] = {"text": 3, "position": (100, 400)}
- screen["Answer4"] = {"text": 4, "position": (100, 500)}
- screen["Answer5"] = {"text": 5, "position": (100, 600)}
-
- screen["AnswerOverall"] = {"text": "proc_overall", "position": (100, 700)}
-
-def generate_variables(screen):
- # Variables
- screen["Algen"] = {"text": "Algen", "position": (400, 100)}
- screen["AlgenVar"] = {"text": "3", "position": (400, 200)}
- screen["Mineralien"] = {"text": "Mineralien", "position": (500, 100)}
- screen["MineralienVar"] = {"text": "9", "position": (500, 200)}
-
- screen["Gifte"] = {"text": "Gifte", "position": (600, 100)}
- screen["GifteVar1"] = {"text": "3", "position": (600, 200)}
- screen["GifteVar2"] = {"text": "1", "position": (600, 300)}
- screen["GifteVar3"] = {"text": "8", "position": (600, 400)}
- screen["GifteVar4"] = {"text": "6", "position": (600, 500)}
-
- screen["Sandstein"] = {"text": "Sandstein", "position": (700, 100)}
- screen["SandsteinVar1"] = {"text": "3", "position": (700, 200)}
- screen["SandsteinVar2"] = {"text": "4", "position": (700, 300)}
- screen["SandsteinVar3"] = {"text": "5", "position": (700, 400)}
- screen["SandsteinVar4"] = {"text": "6", "position": (700, 500)}
+ return envs
+
+ def generate_procedures(self, screen):
+ procs = ["procs1", "procs2", "procs3", "procs4", "procs5", "procs6"]
+ screen["Procedure1"] = {"text": procs[0], "position": (0, 100)}
+ screen["Procedure2"] = {"text": procs[1], "position": (0, 200)}
+ screen["Procedure3"] = {"text": procs[2], "position": (0, 300)}
+ screen["Procedure4"] = {"text": procs[3], "position": (0, 400)}
+ screen["Procedure5"] = {"text": procs[4], "position": (0, 500)}
+
+ screen["ProcedureOverall"] = {"text": "proc_overall", "position": (0, 600)}
+
+ screen["Answers"] = {"text": "Answers", "position": (100, 100)}
+ screen["Answer1"] = {"text": 1, "position": (100, 200)}
+ screen["Answer2"] = {"text": 2, "position": (100, 300)}
+ screen["Answer3"] = {"text": 3, "position": (100, 400)}
+ screen["Answer4"] = {"text": 4, "position": (100, 500)}
+ screen["Answer5"] = {"text": 5, "position": (100, 600)}
+
+ screen["AnswerOverall"] = {"text": "proc_overall", "position": (100, 700)}
+
+ def generate_variables(self, screen):
+ # Variables
+ screen["Algen"] = {"text": "Algen", "position": (400, 100)}
+ screen["AlgenVar"] = {"text": "3", "position": (400, 200)}
+ screen["Mineralien"] = {"text": "Mineralien", "position": (500, 100)}
+ screen["MineralienVar"] = {"text": "9", "position": (500, 200)}
+
+ screen["Gifte"] = {"text": "Gifte", "position": (600, 100)}
+ screen["GifteVar1"] = {"text": "3", "position": (600, 200)}
+ screen["GifteVar2"] = {"text": "1", "position": (600, 300)}
+ screen["GifteVar3"] = {"text": "8", "position": (600, 400)}
+ screen["GifteVar4"] = {"text": "6", "position": (600, 500)}
+
+ screen["Sandstein"] = {"text": "Sandstein", "position": (700, 100)}
+ screen["SandsteinVar1"] = {"text": "3", "position": (700, 200)}
+ screen["SandsteinVar2"] = {"text": "4", "position": (700, 300)}
+ screen["SandsteinVar3"] = {"text": "5", "position": (700, 400)}
+ screen["SandsteinVar4"] = {"text": "6", "position": (700, 500)}
+
diff --git a/modeling/model_init.py b/modeling/model_init.py
index a6ca3ac..7fb1c84 100644
--- a/modeling/model_init.py
+++ b/modeling/model_init.py
@@ -241,4 +241,21 @@ def init():
f"plus{i}{j}", "math_op", op="add", arg1=i, arg2=j, result=i + j
)
)
+
+ Model.productionstring(
+ name="continue_with_next_op",
+ string="""
+ =g>
+ isa math_goal
+ op done
+ nextop ~None
+ nextop =nextop
+ ==>
+ =g>
+ isa math_goal
+ op =nextop
+ nextop None
+ """,
+ )
+
return Model, DM, goal, imaginal, env
diff --git a/modeling/productions_math.py b/modeling/productions_math.py
index 7ac1257..f824466 100644
--- a/modeling/productions_math.py
+++ b/modeling/productions_math.py
@@ -20,23 +20,6 @@ def add_goal(goal, op, arg1, arg2):
goal.add(actr.makechunk("", "math_goal", op=op, task=op, arg1=arg1, arg2=arg2))
-def general_prod(Model):
-
- Model.productionstring(
- name="continue_with_next_op",
- string="""
- =g>
- isa math_goal
- op done
- nextop ~None
- nextop =nextop
- ==>
- =g>
- isa math_goal
- op =nextop
- nextop None
- """,
- )
def wait_input():
@@ -48,88 +31,82 @@ def wait_input():
def add_proc(goal, proc):
# input()
- goal.add(actr.makechunk("", "math_goal", proc=proc, ones_carry="hello"))
+ goal.add(actr.makechunk("", "math_goal", proc=proc, ones_carry=""))
def start():
- loop = True
- while loop:
- loop = False
- # op, arg1, arg2 = wait_input()
- Model, DM, goal, imaginal, env = init()
- # add_goal(goal, op, arg1, arg2)
- add_proc(goal, "proc1")
- envs = model_env.generate_environments()
-
- general_prod(Model)
- prod_procedure.procedures(Model)
- number_prods = prod_numbers.number(Model)
- add_prods = prod_addition.addition(Model)
- sub_prods = prod_subtraction.subtraction(Model)
- greater_prods = prod_comp.greater_than(Model)
- less_prods = prod_comp.lesser_than(Model)
- multi_prods = prod_multi.multiplication(Model)
- motor_prods = prod_motor.procedures(Model)
- visual_prods = prod_vis.procedures(Model)
-
- # for prod in multi_prods:
- # print(prod)
- # print("\n")
-
- print("goal: ", goal)
- # print("imaginal: ", imaginal)
- sim = Model.simulation(
- gui=False,
- environment_process=env.environment_process,
- stimuli=envs,
- # triggers="space",
- triggers="b",
- )
- i = 1
- userinput = ""
- while True:
- sim.step()
- if sim.current_event.time >= 50:
- print(sim.current_event)
- break
- if "KEY PRESSED" in sim.current_event.action:
- userinput = userinput + sim.current_event.action.split(":")[1]
- # if sim.current_event.action == "NO RULE FOUND":
- # print(goal)
- if sim.current_event.action == "KEY PRESSED: SPACE":
- sim._Simulation__env.stimulus["Answer5"]["text"] = "99"
- i += 1
- print(userinput)
- print("NEW PROC")
- if i <= 6:
- goal.add(
- actr.makechunk(
- "", "math_goal", proc=f"proc{i}", ones_carry="hello"
- )
+ condition = "fixed"
+
+ # op, arg1, arg2 = wait_input()
+ Model, DM, goal, imaginal, env = init()
+ # add_goal(goal, op, arg1, arg2)
+ add_proc(goal, "proc1")
+ envs = model_env.generate_environments()
+
+ prod_procedure.procedures(Model)
+ number_prods = prod_numbers.number(Model)
+ add_prods = prod_addition.addition(Model)
+ sub_prods = prod_subtraction.subtraction(Model)
+ greater_prods = prod_comp.greater_than(Model)
+ less_prods = prod_comp.lesser_than(Model)
+ multi_prods = prod_multi.multiplication(Model)
+ motor_prods = prod_motor.procedures(Model)
+ visual_prods = prod_vis.procedures(Model)
+
+ print("goal: ", goal)
+ # print("imaginal: ", imaginal)
+ sim = Model.simulation(
+ gui=False,
+ environment_process=env.environment_process,
+ stimuli=envs,
+ # triggers="space",
+ triggers="b",
+ )
+ i = 1
+ userinput = ""
+ while True:
+ sim.step()
+ if sim.current_event.time >= 50:
+ print(sim.current_event)
+ break
+ if "KEY PRESSED" in sim.current_event.action:
+ userinput = userinput + sim.current_event.action.split(":")[1]
+ # if sim.current_event.action == "NO RULE FOUND":
+ # print(goal)
+ if sim.current_event.action == "KEY PRESSED: SPACE":
+ sim._Simulation__env.stimulus["Answer5"]["text"] = "99"
+ i += 1
+ print(userinput)
+ print("NEW PROC")
+ if i <= 6:
+ goal.add(
+ actr.makechunk(
+ "", "math_goal", proc=f"proc{i}", ones_carry="hello"
)
- elif i == 7:
- goal.add(
- actr.makechunk(
- "", "math_goal", proc="proc_overall", ones_carry="hello"
- )
+ )
+ elif i == 7:
+ goal.add(
+ actr.makechunk(
+ "", "math_goal", proc="proc_overall", ones_carry="hello"
)
- elif i > 7:
- print("DONE")
- break
-
- # sim.run(max_time=25)
- print(userinput)
- print("Simulation time: ", sim.show_time())
- print("goal: ", goal)
- print(sim.current_event)
- pprint(vars(sim))
- pprint(vars(sim._Simulation__env))
- # print(sim.__env)
- # sim.__printenv__()
- # print(envs.stimulus)
- # print("imaginal: ", imaginal)
- math_goals = [sim for sim in list(DM) if sim.typename == "procedure"]
- # print(math_goals)
+ )
+ elif i > 7:
+ print("DONE")
+ break
+
+ # sim.run(max_time=25)
+ print(userinput)
+ print("Simulation time: ", sim.show_time())
+ print("goal: ", goal)
+ print(sim.current_event)
+ pprint(vars(sim))
+ pprint(vars(sim._Simulation__env))
+ # print(sim.__env)
+ # sim.__printenv__()
+ # print(envs.stimulus)
+ # print("imaginal: ", imaginal)
+ math_goals = [sim for sim in list(DM) if sim.typename == "procedure"]
+ # print(math_goals)
if __name__ == "__main__":
--
cgit v1.2.3