def example(): global ids actr.reset() actr.add_command("custom-object-chunk", custom_object_chunk, "Command to dynamically create visual object") # Here we install our custom function using an object-creator device actr.install_device(["vision", "object-creator", "custom-object-chunk"]) # Now we add two features to the display, the first of which will # have the object created by the custom function and the other by # the default mechanism. ids = actr.add_visicon_features(["screen-x", 10, "screen-y", 20], ["screen-x", 100, "screen-y", 20]) # run to give vision module a chance to # process those features and then print the # visicon. actr.run_n_events(3) actr.print_visicon() # run to have model complete task actr.run(1) actr.remove_command("custom-object-chunk")
def trials(n=200,reset=True,output=True): global responses,task_over,exp_length,window if reset: actr.reset() window = actr.open_exp_window("Compilation task",visible=False) times = [] responses = [] task_over = False exp_length = n present_next_trial() actr.install_device(window) # actr.add_command('compilation-issues-game-over',game_over,"Test for the production compilation issues game being over") actr.add_command('compilation-issues-response',respond_to_key_press,"Compilation issues key press response monitor") actr.monitor_command('output-key','compilation-issues-response') # this is how the original ran: actr.run_until_condition('compilation-issues-game-over') # however performing a remote call for each event to determine the stopping point # takes almost 2 orders of magnitude longer to run! So instead just run # sufficiently long to complete the task and assume the model stops when there's # nothing left to do. actr.run(20000) actr.remove_command_monitor('output-key','compilation-issues-response') actr.remove_command ('compilation-issues-response') # actr.remove_command ('compilation-issues-game-over') return analyze_results(output)
def demo_table(): actr.reset() #init() #...when manually setting the sentence (without syntetizer) text = "give fork" #...when using Aldebran proxy for speech recognition #text = AL_speech_recognition() #...when using Google Api (no Python 2.7) #text = GAPI_speech_recognition() string = tokenize(text) onset = 0 actr.set_parameter_value(":sound-decay-time", 0.2) #actr.set_parameter_value(":save-audicon-history", True) actr.add_command("inner-speech-response", record_model_speech, "Inner speech model response") actr.monitor_command("output-speech", "inner-speech-response") actr.install_device(["speech", "microphone"]) for word in string: if TOK.descr[word.kind] == "WORD": print(str(word.txt)) actr.new_word_sound(str(word.txt), onset) onset = onset + 0.2 actr.run(30) actr.remove_command_monitor("output-speech", "inner-speech-response") actr.remove_command("inner-speech-response")
def do_experiment(trials, test=False): """ This function run the experiment, and return simulated model behavior :param size: :param trials: :param human: :return: """ #TODO: need to comment if seperate to core and body script # actr.reset() result = [] window = actr.open_exp_window("Gambling Experiment", visible=False) actr.install_device(window) for trial in trials: # time = 0 prompt, feedback, block_type = trial # guess response, time = do_guess(prompt, window) # this test is to see if model can learn feedback if test: feedback = test_unit5(response) # encode feedback do_feedback(feedback, window) result.append((feedback, block_type, response, time)) return result
def experiment(subject_num=999, condition=1, data_dir="."): if not os.path.isdir('{}'.format(data_dir)): os.mkdir('{}'.format(data_dir)) t1 = RLWM("data/{}/block_df.csv".format(subject_num), subject_num, condition) t1.start = time.monotonic() t1.experiment_initialization(vis=False) #Initial Transition t1.schedule_initial_stimuli(t1.set_sizes[0], True) logger.info("%s:state %s, experiment():initial transition" % ("{0:.2f}".format(t1.curr_time()), t1.current_state)) actr.install_device(t1.window) # actr.run(10, False) # debugging actr.run(1200, False) #<-- run() blocks t1.write_data(data_dir) t1.experiment_cleanup() actr.remove_device(t1.window) t2 = RLWMTestRandom("data/{}/test_phase_random.csv".format(subject_num), subject_num, condition) t2.start = time.monotonic() t2.experiment_initialization(vis=False) # put up test in 7 minutes t2.schedule_initial_stimuli(7 * 60) # t2.schedule_initial_stimuli(0) # for debugging logger.info("%s:state %s, experiment():test initial transition" % ("{0:.2f}".format(t2.curr_time()), t2.current_state)) actr.install_device(t2.window) # need to run for additional 7 minutes for OSPAN/NBack break actr.run(7 * 60 + 1200, False) #<-- run() blocks # actr.run(20+7*60,False) # debugging t2.write_data(data_dir) t2.experiment_cleanup() actr.remove_device(t2.window)
def agi (): actr.reset() # open a window and add the text window = actr.open_exp_window("Moving X", visible=True) text = actr.add_text_to_exp_window(window, "x", x=10, y=10) y = 10 actr.install_device(window) # schedule an event to move it but don't have the # periodic-event command available at this point so # just use a relative event which schedules itself actr.add_command("agi-move-it",move_text) actr.schedule_event_relative (1, "agi-move-it",params=[text,y],maintenance=True) # run the model in real time since it's a visible window actr.run(3,True) actr.remove_command("agi-move-it")
def single_trial(prime_stimulus, **param_set): """ This function simulates an single trial. At the begining of each trial, the model is reset. The model's response is collected as either DO/PO for a simplified version of full sentence :param prime_stimulus: dict type, the prime stimulus, indicating the condition :return: """ global response response = False while not response: actr.reset() actr.install_device(("speech", "microphone")) if param_set: set_parameters(**param_set) #reset param # actr.record_history('BUFFER-TRACE','production-graph-utility') # actr.record_history('buffer-trace', 'goal') # actr.set_parameter_value(':v', 't') syntax = prime_stimulus[-3] syntax_corr = prime_stimulus[-1] actr.add_command("model1-key-press", respond_to_speech, "model1 task output-key monitor") actr.monitor_command("output-speech", "model1-key-press") task1(prime_stimulus) task2() actr.remove_command_monitor("output-speech", "model1-key-press") actr.remove_command("model1-key-press") return response
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") global response response = False if human == True: while response == False: actr.process_events() else: actr.install_device(window) actr.run(10, True) actr.remove_command_monitor("output-key", "demo2-key-press") actr.remove_command("demo2-key-press") return response
def do_experiment(sticks, human=False): build_display(*sticks) if human: wait_for_human() else: actr.install_device(window) actr.start_hand_at_mouse() actr.run(100, visible)
def task(which=False): global response, response_time actr.reset() alphabet = [ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z" ] letter = actr.permute_list(alphabet)[0] alphabet = ["Z"] + alphabet if which == 'next' or which == 'previous': task = which elif actr.random(2) == 0: task = 'next' else: task = 'previous' time = 1500 + actr.random(1000) window = actr.open_exp_window("Simple task") actr.install_device(window) actr.add_command("pm-issues-response", respond_to_key_press, "Perceptual-motor issues task response") actr.monitor_command("output-key", "pm-issues-response") actr.add_text_to_exp_window(window, letter, x=130, y=150) actr.add_command("pm-issue-display", display_prompt, "Perceptual-motor issues task prompt display") actr.schedule_event_relative(time, "pm-issue-display", params=[window, task], time_in_ms=True) response = [] response_time = False actr.run(10, True) actr.remove_command("pm-issue-display") actr.remove_command_monitor("output-key", "pm-issues-response") actr.remove_command("pm-issues-response") if (len(response) == 2 and response_time > time and response[0] == letter and ((task == 'next' and alphabet.index(response[0]) == (alphabet.index(response[1]) - 1)) or (task == 'previous' and alphabet.index(response[0]) == (alphabet.index(response[1]) + 1)))): result = True else: result = False return [task, result]
def demo_mirror(): init() actr.reset() actr.add_command("inner-speech-response", record_model_speech, "Inner speech model response") actr.monitor_command("output-speech", "inner-speech-response") actr.install_device(["speech", "microphone"]) actr.run(60) actr.remove_command_monitor("output-speech", "inner-speech-response") actr.remove_command("inner-speech-response")
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))) actr.install_device(window) if row == 0: freq = 2000 elif row == 1: freq = 1000 else: freq = 500 actr.new_tone_sound(freq, .5, onset_time) actr.schedule_event_relative(900 + actr.random(200), "clear-exp-window", params=[window], time_in_ms=True) global responses responses = [] actr.add_command("sperling-response", respond_to_key_press, "Sperling task key press response monitor") actr.monitor_command("output-key", "sperling-response") actr.run(30, True) actr.remove_command_monitor("output-key", "sperling-response") actr.remove_command("sperling-response") if show_responses: print("answers: %s" % answers) print("responses: %s" % responses) return (compute_score(answers))
def present_trial(trial, new_window=True): if new_window: w = actr.open_exp_window("Alpha-arithmetic Experiment", visible=trial.visible) if run_model: actr.install_device(w) else: actr.clear_exp_window() actr.add_text_to_exp_window(None, trial.text, x=100, y=150) trial.start = actr.get_time(run_model)
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 do_experiment(size, trials, human): actr.reset() result = [] model = not (human) window = actr.open_exp_window("Paired-Associate Experiment", visible=human) if model: actr.install_device(window) for i in range(trials): score = 0 time = 0 for prompt, associate in actr.permute_list(pairs[20 - size:]): actr.clear_exp_window(window) actr.add_text_to_exp_window(window, prompt, x=150, y=150) global response response = '' start = actr.get_time(model) if model: actr.run_full_time(5) else: while (actr.get_time(False) - start) < 5000: actr.process_events() if response == associate: score += 1 time += response_time - start actr.clear_exp_window(window) actr.add_text_to_exp_window(window, associate, x=150, y=150) start = actr.get_time(model) if model: actr.run_full_time(5) else: while (actr.get_time(False) - start) < 5000: actr.process_events() if score > 0: average_time = time / score / 1000.0 else: average_time = 0 result.append((score / size, average_time)) return result
def trial(arg1,arg2): actr.reset() actr.install_device(["speech","microphone"]) need_to_remove = add_speech_monitor() actr.new_digit_sound(arg1) actr.new_digit_sound(arg2,.75) global response response = False actr.run(30) if need_to_remove: remove_speech_monitor() return response
def init_all(open_window = False): global window, window_reading, chunk_defs, chunk_names, correct_dict actr.reset() window = actr.open_exp_window("Letter Writing", open_window, windowX, windowY, 200, 300) window_reading = actr.open_exp_window("Letter Goal", open_window, windowX, windowY, 800, 300) actr.install_device(window_reading) actr.install_device(window) chunk_defs = define_chunks(defs = True) chunk_names = define_chunks(defs = False) correct_dict = correctDict.make_correct_dict()
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" ]) target = items[0] foil = items[1] window = actr.open_exp_window("Letter difference") text1 = foil text2 = foil text3 = foil index = actr.random(3) if index == 0: text1 = target elif index == 1: text2 = target else: text3 = target actr.add_text_to_exp_window(window, text1, x=125, y=75) actr.add_text_to_exp_window(window, text2, x=75, y=175) actr.add_text_to_exp_window(window, text3, x=175, y=175) actr.add_command("unit2-key-press", respond_to_key_press, "Assignment 2 task output-key monitor") actr.monitor_command("output-key", "unit2-key-press") global response response = '' if human == True: while response == '': actr.process_events() else: actr.install_device(window) actr.run(10, True) actr.remove_command_monitor("output-key", "unit2-key-press") actr.remove_command("unit2-key-press") if response.lower() == target.lower(): return True else: return False
def model_loop(): global win actr.add_command('present_stim', present_stim, 'presents stimulus') actr.add_command('present_feedback', present_feedback, 'presents feedback') actr.add_command('get_response', get_response, 'gets response') #open window for interaction win = actr.open_exp_window("test", visible=False) actr.install_device(win) actr.schedule_event_relative(0, 'present_stim') #waits for a key press? actr.monitor_command("output-key", 'get_response') actr.run(45)
def test_unit3(): """this test unit examines trace""" assert check_load() trial = ('?', 'Punishment', 'MostlyReward') prompt, feedback, block_type = trial window = actr.open_exp_window("Gambling Experiment", visible=False) actr.install_device(window) actr.clear_exp_window(window) actr.add_text_to_exp_window(window, prompt, x=150, y=150) actr.run_full_time(5) actr.clear_exp_window(window) actr.add_text_to_exp_window(window, feedback, x=150, y=150) actr.run_full_time(5)
def test_it (): actr.reset() actr.add_command("relay-speech-output", relay_speech_output, "Handle player speak actions") actr.monitor_command("output-speech","relay-speech-output") for m in actr.mp_models(): actr.set_current_model(m) actr.install_device(["speech","microphone"]) actr.run(10) actr.remove_command_monitor("output-speech", "relay-speech-output") actr.remove_command("relay-speech-output")
def experiment(human=False): global response response = False if human == True: while response == False: actr.process_events() else: actr.install_device(window) actr.start_hand_at_mouse() actr.run(10, True) actr.remove_command_monitor("output-key", "sp-key-press") actr.remove_command("sp-key-press") print(actr.get_time(model_time=True)) actr.run_n_events(2, real_time=False) return response
def sentence(person, location, target, term): actr.reset() window = actr.open_exp_window("Sentence Experiment", visible=False, width=600, height=300) x = 25 actr.install_device(window) actr.add_command("fan-response", respond_to_key_press, "Fan experiment model response") actr.monitor_command("output-key", "fan-response") if term == 'person': actr.pdisable("retrieve-from-location") else: actr.pdisable("retrieve-from-person") actr.add_text_to_exp_window(window, person, x=50, y=150, width=75) actr.add_text_to_exp_window(window, location, x=250, y=150, width=75) global response, response_time response = '' response_time = 0 actr.run(30) actr.remove_command_monitor("output-key", "fan-response") actr.remove_command("fan-response") if response == '': return (30, False) elif target: if response.lower() == 'k'.lower(): return (response_time / 1000, True) else: return (response_time / 1000, False) else: if response.lower() == 'd'.lower(): return (response_time / 1000, True) else: return (response_time / 1000, False)
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 test1(): # only DO trials - 10 trials = [] num_trials = 1 response_list = [] prime_template = ['isa', 'sentence', 'string', '...', 'noun1', 'n1', 'noun2', 'n2', 'verb', 'v', 'syntax', 'DO', 'syntax-corr', 'yes'] for i in range(int(num_trials)): prime_sentence = copy(prime_template) prime_sentence[-3] = 'DO' prime_sentence[-1] = 'yes' trials.append(prime_sentence) actr.reset() # insatll device actr.install_device(("speech", "microphone")) for i in range(num_trials): response = single_trial(trials[i]) syn = trials[i][-3] syn_corr = trials[i][-1] print("prime:",syn, syn_corr, "resp:", response) # if response=='failure': # print("---------------") #actr.sdp('DO-form', 'PO-form') #actr.whynot('step6-1') # actr.whynot_dm('DO-form', 'PO-form') response_list.append(response) print("response count()", "DO:", response_list.count("DO"), "PO:", response_list.count("PO"), "\ntotal: ", num_trials) print("prop_DO", response_list.count("DO")*1.0/(response_list.count("DO")+response_list.count("PO")))
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.start_hand_at_mouse() actr.add_image_to_exp_window(win, "background", "ref-brain.gif", x=0, y=0, width=390, height=390) for x in range(3): for y in range(3): actr.add_visicon_features([ "screen-x", 164 + (x * 130), "screen-y", 164 + (y * 130), "height", 128, "width", 128, "name", ["'brain'", "'brain-%d'" % (x + (y * 3))] ]) # run for the vision module to process the scene actr.run_n_events(2) actr.print_visicon() # run for up to 5 seconds using real-time if the window is visible actr.run(10, visible)
def run_test (visible=False): actr.reset() win = actr.open_exp_window("image test",visible=visible, width=310, height=420) actr.install_device(win) actr.start_hand_at_mouse() actr.add_image_to_exp_window(win, "logo", "smalllogo.gif", x=10, y=10, width=288, height=142) actr.add_items_to_exp_window(win, actr.create_image_for_exp_window(win, "brain", "ref-brain.gif", x=10, y=160, width=128, height=128, action="click-brain-py")) actr.add_image_to_exp_window(win, "brain-2", "ref-brain.gif", x=10, y=290, width=128, height=128, action=["click-brain-2-py","this string"]) # run for the vision module to process the scene actr.run_n_events(2) actr.print_visicon() # run for up to 5 seconds using real-time if the window is visible actr.run(5, visible)
def example(): actr.reset() # The first window is located at x=0 and y=0 which # is fine for virtual windows, but if it were a real # window that window would be behind the menu bar # at the top of the display under OS X which makes # it difficult to interact with. The second window # is located at x=200, y=200. The default mouse # position is x=0, y=0. w1 = actr.open_exp_window("W1", visible=False, width=100, height=100, x=0, y=0) w2 = actr.open_exp_window("W2", visible=False, width=100, height=100, x=200, y=200) # add text to the same local position in each window. actr.add_text_to_exp_window(w1, "a", x=10, y=10, color='red') actr.add_text_to_exp_window(w2, "a", x=10, y=10, color='blue') # Install both windows and the mouse cursor actr.install_device(w1) actr.install_device(w2) actr.install_device(["vision", "cursor", "mouse"]) # Just run the model to have vision module process # things and print the visicon. # The model doesn't do anything. actr.run(1) actr.print_visicon()
def play(player1, player2): global window, p1, p2, p1_position, p2_position, current_player, game_over, safety_stop, p1_text, p2_text if (player1.lower() in (x.lower() for x in actr.mp_models())) and ( player2.lower() in (x.lower() for x in actr.mp_models())): actr.reset() actr.set_current_model(player1) # create a goal chunk with the player's color and name actr.define_chunks([ 'goal', 'isa', 'play', 'my-color', 'red', 'my-name', "'%s'" % player1 ]) actr.goal_focus('goal') actr.set_parameter_value(':show-focus', 'red') actr.set_current_model(player2) # create a goal chunk with the player's color and name actr.define_chunks([ 'goal', 'isa', 'play', 'my-color', 'blue', 'my-name', "'%s'" % player2 ]) actr.goal_focus('goal') actr.set_parameter_value(':show-focus', 'blue') window = actr.open_exp_window("game", visible=True, width=200, height=100) safety_window = actr.open_exp_window('Safety', visible=True, height=100, width=100, x=100, y=100) actr.add_command('stop-a-run', stop_a_run, 'Set the flag to terminate the game.') actr.add_button_to_exp_window(safety_window, text="STOP", x=0, y=0, action='stop-a-run', height=80, width=80, color='red') p1 = player1 p2 = player2 game_over = False safety_stop = False current_player = player1 p1_position = 0 p2_position = 5 for m in actr.mp_models(): actr.set_current_model(m) actr.install_device(window) p1_text = actr.add_text_to_exp_window(window, str(p1_position), x=20, y=10, color='red', height=30, width=30, font_size=20) p2_text = actr.add_text_to_exp_window(window, str(p2_position), x=140, y=10, color='blue', height=30, width=30, font_size=20) actr.add_command("process-moves", process_moves, "Handle player speak actions") actr.monitor_command("output-speech", "process-moves") # speak to all models telling them the name # of the first player. for m in actr.mp_models(): actr.set_current_model(m) actr.new_word_sound(p1, 0, 'start') actr.add_command('is-game-over', is_game_over, 'Test whether game should stop running.') actr.add_command('set_game_over', set_game_over, 'Set the flag to stop the game.') actr.run_until_condition('is-game-over', True) actr.remove_command_monitor("output-speech", "process-moves") actr.remove_command("process-moves") actr.remove_command('stop-a-run') actr.remove_command('is-game-over') actr.remove_command('set_game_over') return game_over