def grid_search(): ans_values = [.2, .3, .4, .5, .6, .7, .8] egs_values = [1, 2, 3] lf_values = [.1, .2, .3, .4] mas_values = [3, 4, 5] for ans_val in ans_values: for egs_val in egs_values: for lf_val in lf_values: for mas_val in mas_values: with open("rlwm_model_nomeaning_template.lisp", 'r') as infile: lines = infile.readlines() with open("rlwm_model_nomeaning.lisp", 'w') as outfile: for line in lines: if line == "(bad-command)\n": outfile.write( "(sgp :ans {} :egs {} :lf {} :mas {})\n". format(ans_val, egs_val, lf_val, mas_val)) else: outfile.write(line) actr.load_act_r_model( os.path.abspath("rlwm_model_nomeaning.lisp").replace( '/', ';')[1:]) data_dir = "fit_ans{}_egs{}_lf{}_mas{}_RLWM".format( ans_val, egs_val, lf_val, mas_val) # actr.set_parameter_value(":ans", ans_val) # actr.set_parameter_value(":egs", egs_val) # actr.set_parameter_value(":lf", lf_val) # actr.set_parameter_value(":mas", mas_val) run_subjects(range(101, 121), 1, data_dir)
def setupACTR(): actr.load_act_r_model( "/Users/paulsomers/ddpg-craft/scripts/ddpg_agent.lisp") actr.wait = True #run ACTR for 10 seconds (simulated) chk = actr.define_chunks(['wait', 'false']) actrThread = threading.Thread(target=actr.run, args=[1000]) actrThread.start() actr.schedule_simple_event_now("set-buffer-chunk", ['imaginal', chk[0]]) #once loaded add some functions that will be called by ACT-R actr.add_command("tic", do_tic) actr.add_command('set_response', set_response) #Setup the imaginal for an initial production chunk = ['isa' 'setup'] #Wait until the first production fires # once act-r is running, the tic will be called to set the wait (below) to false while actr.wait: time.sleep(0.001) print("waiting") return 1
def load_model(model="model1", param_set=None): actr.load_act_r_model(os.path.abspath(model + "_core.lisp")) # load new pramsets if param_set: set_parameters(**param_set) reward = 0 # init value actr.load_act_r_model(os.path.abspath(model + "_body.lisp")) print("######### LOADED MODEL " + model + " #########") print(">>", get_parameters(*get_parameters_name()), "<<")
def simulate(self, trace=False, utility_offset=True): """Runs SP simulations using real stimuli""" # Function hook to modify the utility calculation # (will add a mismatch penalty). Need to be defined # before the model is loaded actr.add_command("parser-offset", self.utility_offset, "Calculates a mismatch penalty for AI condition") actr.load_act_r_model(self.model) for condition in self.CONDITIONS: self.current_condition = condition subset = [t for t in self.trials if t.condition == condition] for j in range(self.n): actr.reset() # Make the model silent in case if not trace: actr.set_parameter_value(":V", False) # The model does not really need a visual interface, # but the default AGI provides a virtual mic to record # voice output. win = actr.open_exp_window("SP", width = 80, height = 60, visible=False) actr.install_device(win) # Function hooks to record the model responses. actr.add_command("record-response", self.record_response, "Accepts a response for the SP task") actr.monitor_command("output-speech", "record-response") # Run a single trial in the given condition trial = random.choice(subset) self.run_trial(trial) # Clean up the function hooks actr.remove_command_monitor("output-speech", "record-response") actr.remove_command("record-response") # Removes the offset actr.remove_command("parser-offset")
def run_experiment(model_name="response-monkey.lisp", time=200, verbose=True, visible=True, trace=True, params=[]): """Runs an experiment""" actr.reset() # current directory curr_dir = os.path.dirname(os.path.realpath(__file__)) actr.load_act_r_model(os.path.join(curr_dir, model_name)) # Set then model parameters for name, val in params: actr.set_parameter_value(name, val) win = actr.open_exp_window("* STROOP TASK *", width=800, height=600, visible=visible) actr.install_device(win) task = StroopTask(setup=False) #task.window = win actr.add_command("stroop-next", task.next, "Updates the internal task") actr.add_command("stroop-update-window", task.update_window, "Updates the window") actr.add_command("stroop-accept-response", task.accept_response, "Accepts a response for the Stroop task") actr.monitor_command("output-key", "stroop-accept-response") task.setup(win) if not trace: actr.set_parameter_value(":V", False) actr.run(time) if verbose: print("-" * 80) task.print_stats(task.run_stats()) # Cleans up the interface # (Removes all the links between ACT-R and this object). actr.remove_command_monitor("output-key", "stroop-accept-response") actr.remove_command("stroop-next") actr.remove_command("stroop-update-window") actr.remove_command("stroop-accept-response") # Returns the task as a Python object for further analysis of data return task
def simulate(self): """Runs a single simulation""" # Add commands and hooks actr.add_command("v_offset", self.chunk_v_term, "Extra term in activation") actr.add_command("spreading", self.spreading_activation, "Overrides normal spreading activation algorithm") actr.add_command("monitor_retrievals", self.monitor_retrievals, "Monitors what is being retrieved") actr.add_command("next", self.present_new_situation, "Presents a new situation") actr.add_command("keep_table", self.add_chunk) # Makes sure we are loading the current model from # the current directory curr_dir = os.path.dirname(os.path.realpath(__file__)) actr.load_act_r_model(os.path.join(curr_dir, self.model)) actr.set_parameter_value(":V", False) actr.set_parameter_value(":cmdt", False) # Apply the set of provided parameters for param, value in self.model_params.items(): actr.set_parameter_value(param, value) # Run a life simulation event_time = 0.0 while actr.mp_time() < self.max_time: actr.schedule_event(event_time, "next") event_time += self.event_step actr.run(self.event_step) # No need to run beyond the event step # Clean-up actr.remove_command("next") actr.remove_command("v_offset") actr.remove_command("spreading") actr.remove_command("keep_table") actr.remove_command("monitor_retrievals") # Update counter self.counter += 1
def reset_actr(): model_name = 'egocentric-salience.lisp' model_path = '/Users/paulsomers/COGLE/deep_salience/' chunk_file_name = 'chunks.pkl' chunk_path = os.path.join(model_path, 'data') actr.add_command('similarity_function', similarity) actr.load_act_r_model(os.path.join(model_path, model_name)) actr.record_history("blending-trace") #load all the chunks allchunks = pickle.load( open(os.path.join(chunk_path, chunk_file_name), 'rb')) for chunk in allchunks: actr.add_dm(chunk)
def setup_experiment(human=True): ''' Load the correct ACT-R model, and create a window to display the words ''' if subject == "controls": actr.load_act_r_model( "/Users/chisa/Desktop/masters/first_year_research_project/my_model/csm_free_recall_model.lisp" ) elif subject == "depressed": actr.load_act_r_model( "/Users/chisa/Desktop/masters/first_year_research_project/my_model/csm_free_recall_model_depressed.lisp" ) window = actr.open_exp_window("Free Recall Experiment", width=1024, height=768, visible=human) # 15inch resolution window actr.install_device(window) return window
def test3(): actr.load_act_r_model(os.getcwd() + "/model1.lisp") # load the model ans = [0.2, 0.5, 0.8] bll = [0.2, 0.5, 0.8] mas = [1.3, 1.6, 1.9] ia = [0.5, 1, 1.5] hyper_param = [{'ans':i, 'bll':j, 'mas':k, 'imaginal-activation':l} \ for i in ans for j in bll for k in mas for l in ia] best_corr = -2 best_param = [] for i in tqdm(range(len(hyper_param))): param_set = hyper_param[i] set_parameters(**param_set) corr = simulations(50) if corr > best_corr: best_corr = corr best_param = param_set print(">> best_corr", "best_param\n") print(best_corr, best_param) return (best_corr, best_param)
def test5(): # grid search hyper-parameter tuning alpha = [0.001, 0.01, 0.1, 0.2, 0.3] egs = [0.0, 0.3, 0.6, 0.9, 1.2, 1.5] r2 = [-0.1, -0.5, -1, -5, -10] ppm = [0, 1, 1.5] #hyper_param = [[i, j] for i in alpha for j in egs] hyper_param = [{'alpha':i, 'egs':j, 'r2':k, 'ppm':l} for i in alpha for j in egs for k in r2 for l in ppm] actr.load_act_r_model(os.getcwd() + "/model3.lisp") # load the model best_corr = -2 best_param = [] for i in tqdm(range(len(hyper_param))): param_set=hyper_param[i] set_parameters(**param_set) corr = simulations(50) if corr > best_corr: best_corr = corr best_param = param_set print(">> best_corr", "best_param\n") print(best_corr, best_param) return (best_corr, best_param)
def reset_actr(chunk_file_name): model_name = 'qsalience.lisp' model_path = '/Users/paulsomers/COGLE/qsalience/' #chunk_file_name = 'version1.chunks' chunk_path = os.path.join(model_path, 'data') actr.add_command('similarity_function', similarity) actr.load_act_r_model(os.path.join(model_path, model_name)) actr.record_history("blending-trace") #load all the chunks allchunks = pickle.load( open(os.path.join(chunk_path, chunk_file_name), 'rb')) for chunk in allchunks: actr.add_dm(chunk) #global min_max for chunk in allchunks: for x, y in zip(*[iter(chunk)] * 2): #x, y[1] if not x == 'action': if y[1] not in min_max[x]: min_max[x].append(y[1])
def test4(): print("############# MODEL1 #############") actr.load_act_r_model(os.getcwd() + "/model1.lisp") # load the model simulations(50) print("############# MODEL2 #############") actr.load_act_r_model(os.getcwd() + "/model2.lisp") # load the model simulations(50) print("############# MODEL3 #############") actr.load_act_r_model(os.getcwd() + "/model3.lisp") # load the model simulations(50)
import actr actr.load_act_r_model("ACT-R:tutorial;unit4;zbrodoff-model.lisp") trials = [] results = [] control_data = [1.84, 2.46, 2.82, 1.21, 1.45, 1.42, 1.14, 1.21, 1.17] run_model = True class trial(): def __init__(self, block, addend1, addend2, sum, answer, visible=None): self.block = block self.addend2 = addend2 self.text = addend1 + " + " + addend2 + " = " + sum self.answer = answer.lower() if visible == None: self.visible = not (run_model) else: self.visible = visible self.correct = False def present_trial(trial, new_window=True): if new_window: w = actr.open_exp_window("Alpha-arithmetic Experiment", visible=trial.visible) if run_model:
import actr actr.load_act_r_model("ACT-R:tutorial;unit5;siegler-model.lisp") response = False monitor_installed = False siegler_data = [[0, .05, .86, 0, .02, 0, .02, 0, 0, .06], [0, .04, .07, .75, .04, 0, .02, 0, 0, .09], [0, .02, 0, .10, .75, .05, .01, .03, 0, .06], [.02, 0, .04, .05, .80, .04, 0, .05, 0, 0], [0, 0, .07, .09, .25, .45, .08, .01, .01, .06], [.04, 0, 0, .05, .21, .09, .48, 0, .02, .11]] def record_model_speech (model,string): global response response = string.lower() def add_speech_monitor(): global monitor_installed if monitor_installed == False: actr.add_command("siegler-response",record_model_speech,"Siegler task model response") actr.monitor_command("output-speech","siegler-response") monitor_installed = True return True else: return False
import actr actr.load_act_r_model("ACT-R:tutorial;unit3;sperling-model.lisp") responses = [] show_responses = True exp_data = [3.03, 2.4, 2.03, 1.5] def trial(onset_time): actr.reset() letters = actr.permute_list([ "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z" ]) answers = [] row = actr.random(3) window = actr.open_exp_window("Sperling Experiment", visible=True) for i in range(3): for j in range(4): txt = letters[j + (i * 4)] if i == row: answers.append(txt) actr.add_text_to_exp_window(window, txt, x=(75 + (j * 50)), y=(100 + (i * 50)))
import actr actr.load_act_r_model("ACT-R:tutorial;unit4;paired-model.lisp") response = False response_time = False pairs = list( zip([ 'bank', 'card', 'dart', 'face', 'game', 'hand', 'jack', 'king', 'lamb', 'mask', 'neck', 'pipe', 'quip', 'rope', 'sock', 'tent', 'vent', 'wall', 'xray', 'zinc' ], [ '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9' ])) latencies = [0.0, 2.158, 1.967, 1.762, 1.680, 1.552, 1.467, 1.402] probabilities = [0.0, .526, .667, .798, .887, .924, .958, .954] def task(size, trials, human=False): actr.add_command("paired-response", respond_to_key_press, "Paired associate task key press response monitor") actr.monitor_command("output-key", "paired-response") result = do_experiment(size, trials, human) actr.remove_command_monitor("output-key", "paired-response") actr.remove_command("paired-response")
actr.run(10) # delete all of the visicon features. delete-all-visicon-features # removes all of the features from the visicon. actr.delete_all_visicon_features() # Give the vision module a chance to process the display # before printing the visicon. actr.run_n_events(3) actr.print_visicon() # run the model to show the update actr.run(10) """ The model is very simple in that it just repeatedly finds a location and then attends to the item there printing out the chunks in the visual-location and visual buffers after the corresponding requet completes. The ordering of the modifications are such that it will not automatically updated the attended object chunks since the currently attended item is unchanged in each case. """ actr.load_act_r_model( "ACT-R:examples;vision-module;adjust-visicon-features-model.lisp")
import actr actr.load_act_r_model("ACT-R:tutorial;unit2;demo2-model.lisp") response = False def respond_to_key_press(model, key): global response response = key actr.clear_exp_window() def experiment(human=False): actr.reset() items = actr.permute_list([ "B", "C", "D", "F", "G", "H", "J", "K", "L", "M", "N", "P", "Q", "R", "S", "T", "V", "W", "X", "Y", "Z" ]) text1 = items[0] window = actr.open_exp_window("Letter recognition") actr.add_text_to_exp_window(window, text1, x=125, y=150) actr.add_command("demo2-key-press", respond_to_key_press, "Demo2 task output-key monitor") actr.monitor_command("output-key", "demo2-key-press")
# This is the Python code to run the task that goes along with the # creating-an-image-model. # # It is a simple demonstration of creating and using the # image AGI item, and it assumes that the smalllogo.gif # and ref-brain.gif files are in the GUI/AGI-images directory # if you use a visible window to see the images. # # To run the task call the run_test function. It has one # optional parameter which if provided as True indicates # the window should be visible. The default is to use a virtual # window. import actr actr.load_act_r_model("ACT-R:examples;creating-image-items;creating-an-image-model.lisp") def click_brain (text,pos): actr.model_output('Clicked image %s at %d %d'%(text,pos[0],pos[1])) actr.add_command("click-brain-py",click_brain,"Example function for image click action. Do not call.") def click_brain_2 (value): actr.model_output('Clicked the second brain image given value %s'%value) actr.add_command ("click-brain-2-py",click_brain_2,"Example function for image click action with parameters. Do not call.") def run_test (visible=False): actr.reset()
# background-model. # # It is a demonstration of creating and using an # image AGI item along with custom visicon features. # It assumes that the ref-brain.gif file is in the # GUI/AGI-images directory if you use a visible window # to see the images. # # To run the task call the run-test function. It has one # optional parameter which if provided as any non-nil value # indicates the window should be visible. The default is # to use a virtual window. import actr actr.load_act_r_model( "ACT-R:examples;creating-image-items;background-model.lisp") def run_test(visible=False): actr.reset() win = actr.open_exp_window("background test", visible=visible, width=390, height=390, x=100, y=100) actr.install_device(win)
actr.model_output("Model did not respond or provided a non-numeric category.") return((0,False)) def create_example_memories(): for s in slots: actr.extend_possible_slots(s,False) actr.define_chunks([s,"isa","chunk"]) for c in cat1: chunk = ["isa","example","category",1] for slot,value in list(zip(slots,c)): chunk.append(slot) chunk.append(value) actr.add_dm(chunk) for c in cat2: chunk = ["isa","example","category",2] for slot,value in list(zip(slots,c)): chunk.append(slot) chunk.append(value) actr.add_dm(chunk) actr.add_command("create-example-memories",create_example_memories,"Categorize task function to add the initial example chunks to simulate the training process.") actr.load_act_r_model("ACT-R:tutorial;unit8;categorize-model.lisp")
import actr import math actr.load_act_r_model("ACT-R:tutorial;unit7;past-tense-model.lisp") report = [] total_count = 0 word_list = [] verbs = [['have','i',12458,'had'], ['do','i',4367,'did'], ['make','i',2312,'made'], ['get','i',1486,'got'], ['use','r',1016,'use'], ['look','r',910,'look'], ['seem','r',831,'seem'], ['tell','i',759,'told'], ['show','r',640,'show'], ['want','r',631,'want'], ['call','r',627,'call'], ['ask','r',612,'ask'], ['turn','r',566,'turn'], ['follow','r',540,'follow'], ['work','r',496,'work'], ['live','r',472,'live'], ['try','r',472,'try'], ['stand','i',468,'stood'], ['move','r',447,'move'], ['need','r',413,'need'], ['start','r',386,'start'], ['lose','i',274,'lost']]
import actr actr.load_act_r_model("ACT-R:tutorial;unit5;fan-no-pm-model.lisp") person_location_data = [ 1.11, 1.17, 1.22, 1.17, 1.20, 1.22, 1.15, 1.23, 1.36, 1.20, 1.22, 1.26, 1.25, 1.36, 1.29, 1.26, 1.47, 1.47 ] def sentence(person, location, target, term): actr.reset() if term == 'person': actr.pdisable("retrieve-from-location") else: actr.pdisable("retrieve-from-person") actr.mod_chunk("goal", "arg1", person, "arg2", location, "state", "test") response_time = actr.run(30)[0] response = actr.chunk_slot_value(actr.buffer_read("goal"), "state") if target: if response.lower() == "'k'".lower(): return (response_time, True) else: return (response_time, False) else: if response.lower() == "'d'".lower():
#!/usr/bin/env python # -*- coding: utf-8 -*- # @Time : 2019/11/18 19:32 # @Author : Yulong Sun # @Site : # @File : zbrodoff_improve.py # @Software: PyCharm import actr actr.load_act_r_model( r"C:\Users\syl\Desktop\ACTR_ATO\zbrodoff_improve\zbrodoff_model.lisp") trials = [] results = [] control_data = [1.84, 2.46, 2.82, 1.21, 1.45, 1.42, 1.14, 1.21, 1.17] run_model = True class trial(): def __init__(self, block, addend1, addend2, sum, answer, visible=None): self.block = block self.addend2 = addend2 self.text = addend1 + " + " + addend2 + " = " + sum self.answer = answer.lower() if visible == None: self.visible = not (run_model) else:
#this shuffles both lists, stimuli and associated correct responses, in the same order stims_temp = list( zip( np.repeat(stims_3, 12).tolist(), np.repeat(stims_3_resps, 12).tolist())) rnd.shuffle(stims_temp) #stims, cor_resps = zip(*stims_temp) ##########debug######## stims = ['cup'] # In[3]: #Load model model = actr.load_act_r_model( '/home/master-tedward/RLWM_ACTR/memory_model2.lisp') #variables needed chunks = None current_response = np.repeat('x', nTrials).tolist() accuracy = np.repeat(0, nTrials).tolist() i = 0 win = None #Daisy chained python functions to present stimuli, get response and present feedback def present_stim(): global chunks global stims
# # @Time : 2019/11/22 11:11 # # @Author : Yulong Sun # # @Site : # # @File : actr-parking-bst.py # # @Software: PyCharm """ 假定:优秀驾驶员看到速度和不同制动级位就能判断出大概距离 初始条件:初始距离,初始速度 这个程序的思路使让actr看到距离停车标的初始距离和实际到达精度30m,让actr从不同的制动级位的长度下进行选择,不断缩小距离最后达到实际精度 """ import actr import random import time actr.load_act_r_model( r"C:\Users\syl\Desktop\ACTR_ATO\actr-parking-bst\actr-parking.lisp") target = None current_stick = None current_line = None done = False choice = None window = None visible = False exp_data = [20, 67, 20, 47, 87, 20, 80, 93, 83, 13, 29, 27, 80, 73, 53] exp_stims = [[15, 250, 55, 125], [10, 155, 22, 101], [14, 200, 37, 112], [22, 200, 32, 114], [10, 243, 37, 159], [22, 175, 40, 73], [15, 250, 49, 137], [10, 179, 32, 105], [20, 213, 42, 104], [14, 237, 51, 116], [12, 149, 30, 72], [14, 237, 51, 121], [22, 200, 32, 114], [14, 200, 37, 112], [15, 250, 55, 125]]
import actr actr.load_act_r_model("ACT-R:tutorial;unit5;grouped-model.lisp") response = [] def recall(): actr.add_command( "grouped-response", record_response, "Response recording function for the tutorial grouped model.") global response response = [] actr.reset() actr.run(20) actr.remove_command("grouped-response") return response def record_response(item): global response response.append(item)
actr.schedule_event_relative(5, 'utility-learning-issues-show-result', params=[answer], output='medium') def show_result(choice): actr.mod_chunk('response', 'answer', choice) actr.set_buffer_chunk('imaginal', 'response') actr.schedule_event_relative(2, 'utility-learning-issues-choose', output='medium') actr.add_command( 'utility-learning-issues-choose', present_choose, "Function to change model's goal for utility learning issues model") actr.add_command( 'utility-learning-issues-show-result', show_result, "Function to set the model's imaginal buffer for utility learning issues model" ) def finished(): actr.remove_command('utility-learning-issues-choose') actr.remove_command('utility-learning-issues-show-result') actr.load_act_r_model( "ACT-R:tutorial;unit7;utility-learning-issues-model.lisp")
from geometry_msgs.msg import PoseStamped, Pose import moveit_msgs.msg from moveit_msgs.msg import PlanningScene, ObjectColor from math import pi from std_msgs.msg import String from moveit_commander.conversions import pose_to_list import argparse import time global robot, scene, scene_pub global right_arm_group, head, left_arm_group, both_arms_group #global right_hand_group #global gripper_pose_pub #global eef, eef_link, touch_links actr.load_act_r_model("ACT-R:INNER;DemoiScience;inner_model.lisp") #actr.load_act_r_model("ACT-R:INNER;DemoSpecchio;mirror.lisp") global response, response_time response = "" response_time = False global IP, tts, asr def init(): global robot, scene, scene_pub, gripper_pose_pub global right_arm_group, right_hand_group, head, both_arms_group, left_arm_group #Initialize the move_group API moveit_commander.roscpp_initialize(sys.argv)
import actr actr.load_act_r_model("ACT-R:tutorial;unit7;production-compilation-issues-model.lisp") val1 = '' val2 = '' responses = [] start_time = 0 times = [] exp_length = 0 task_over = True task_state = None window = None result_matrix = [[["win","lose","draw","lose"],["win","lose","draw","lose"],["win","lose","draw","lose"],["lose","draw","win","lose"]], [["win","lose","draw","lose"],["win","lose","draw","lose"],["lose","draw","win","lose"],["lose","draw","win","lose"]], [["win","lose","draw","lose"],["win","lose","draw","lose"],["lose","draw","win","lose"],["lose","draw","win","lose"]], [["win","lose","draw","lose"],["lose","draw","win","lose"],["lose","draw","win","lose"],["lose","draw","win","lose"]]] def convert_key_to_index(key): if key.lower() == 's': return 0 if key.lower() == 'd': return 1 if key.lower() == 'f': return 2 else: return 3