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 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 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 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 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 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 person(): global response window = actr.open_exp_window("Choice Experiment", visible=True) actr.add_command("choice-response", respond_to_key_press, "Choice task key response") actr.monitor_command("output-key", "choice-response") actr.add_text_to_exp_window(window, 'choose', x=50, y=100) response = '' while response == '': actr.process_events() actr.clear_exp_window(window) if actr.random(1.0) < .9: answer = 'heads' else: answer = 'tails' actr.add_text_to_exp_window(window, answer, x=50, y=100) start = actr.get_time(False) while (actr.get_time(False) - start) < 1000: actr.process_events() actr.remove_command_monitor("output-key", "choice-response") actr.remove_command("choice-response") return response
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 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
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 trials(n,cont=False,v=False): global report,word_list,reward_check actr.add_command("reward-check",verify_reward, "Past tense code check for a reward each trial.") actr.monitor_command("trigger-reward","reward-check") if not(cont) or not(word_list): actr.reset() word_list = make_word_freq_list(verbs) new = [] for x in word_list: for y in x[1:]: if y not in new: new.append(y) for x in new: if not(actr.chunk_p(x)): actr.define_chunks([x]) print_header() report = [] actr.set_parameter_value(":v",v) start = 100 * math.floor(len(report) / 100) count = len(report) % 100 for i in range(n): add_past_tense_to_memory() add_past_tense_to_memory() reward_check = False target = make_one_goal() duration = actr.run(100)[0] add_to_report(target,actr.buffer_read('imaginal')) actr.clear_buffer('imaginal') count += 1 if count == 100: rep_f_i(start, start + 100, 100) count = 0 start += 100 if not(reward_check): actr.print_warning("Model did not receive a reward when given %s."% target[0]) actr.run_full_time(200 - duration) if duration == 100: actr.print_warning("Model spent 100 seconds generating a past tense for %s."% target[0]) rep_f_i(start,start+count,100) actr.remove_command_monitor("trigger-reward","reward-check") actr.remove_command("reward-check")
def play(player1, player2): global p1, p2, p1_position, p2_position, game_over, current_player, next_move # make sure that both names are valid model names 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.add_command('make-move', make_move, "Model action function in simple capture game.") # create the goal chunks actr.set_current_model(player1) actr.define_chunks([ 'goal', 'isa', 'play', 'my-pos', 'p1', 'p1', 0, 'p2', 5, 'state', 'move' ]) actr.goal_focus('goal') actr.set_current_model(player2) actr.define_chunks([ 'goal', 'isa', 'play', 'my-pos', 'p1', 'p2', 0, 'p2', 5, 'state', 'move' ]) actr.goal_focus('goal') # initialize the game information p1 = player1 p2 = player2 p1_position = 0 p2_position = 5 game_over = False current_player = player1 next_move = None while not (game_over): # until a move is made which breaks the run # or 1000 simulated seconds pass which is a forfeit actr.run(1000) process_move(next_move) # Give them a chance to process results actr.run_full_time(3) actr.remove_command('make-move') return game_over
def experiment_initialization(self, vis=False): # actr.reset() # actr.reload() actr.add_command("unit2-key-press", self.respond_to_key_press, "Assignment 2 task output-key monitor") actr.add_command("my-event-hook", self.post_event_hook, "called after an event") actr.monitor_command("output-key", "unit2-key-press") actr.call_command("add-post-event-hook", "my-event-hook") self.window = actr.open_exp_window("Leter difference task", visible=vis)
def add_key_monitor(): global key_monitor_installed if key_monitor_installed == False: actr.add_command("1hit-bj-key-press", respond_to_keypress, "1-hit blackjack task key output monitor") actr.monitor_command("output-key", "1hit-bj-key-press") key_monitor_installed = True return True else: return False
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 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 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 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") return result
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 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 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 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 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 task(trials): """ This function present task and monitor response from model :param size: number of trials to present :param trials: the trial list :return: """ # monitor the output-key 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(trials) actr.remove_command_monitor("output-key", "paired-response") actr.remove_command("paired-response") return result
def collect_responses(count): global results results = [] actr.add_command("zbrodoff-response", respond_to_key_press, "Zbrodoff task key press response monitor") actr.monitor_command("output-key", "zbrodoff-response") present_trial(trials[0]) if run_model: actr.run(10 * count) else: while len(results) < count: actr.process_events() actr.remove_command_monitor("output-key", "zbrodoff-response") actr.remove_command("zbrodoff-response")
def arbitrary (): actr.reset() feature = actr.add_visicon_features(['screen-x',15,'screen-y',20,'value',"'x'"])[0] x = 15 # 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("arbitrary-move-it",move_feat) actr.schedule_event_relative (1, "arbitrary-move-it",params=[feature,x],maintenance=True) # run the model in real time since it's a visible window actr.run(3,True) actr.remove_command("arbitrary-move-it")
def example (): actr.reset() """ We will create two items in the display and have the model find them and move the mouse to them to see the difference in timing based on the width function setting. One feature will use the normal visual-location and object chunk-types and the other will use a custom visual-location type defined like this which replaces screen-x, screen-y, and distance with slots named x, y, and z instead. (chunk-type custom-location x y z height width size) The feature with using the standard visual-location slots will include a custom width function to make it act like a circle with twice its given height. """ actr.add_command("custom-width", custom_width, "Return twice the height of a visual feature.") actr.add_visicon_features(['screen-x', 50, 'screen-y', 500, 'height', 20, 'width', 20, ':width-fn', "'custom-width'"], ['isa', 'custom-location', 'x', 150, 'y', 500, 'height', 20, 'width', 20, ':x-slot', 'x', ':y-slot', 'y', ':z-slot', 'z']) # 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 move the cursor to 100,0 as a starting point. # and from there move to the left location, back to the start, and then # the right location. actr.run(10) actr.remove_command('custom-width')
def present_trial(given_letter = None, train_epochs = 1, new_window = True, open_window = True, delay_time = 10, display = False): global window, window_reading, clickList, chunk_names, chunk_defs if (given_letter == None): letterList = actr.permute_list(list(string.ascii_uppercase)) chosen_letter = letterList[0] else: chosen_letter = given_letter if display: train_n(10, chosen_letter) clickList = [] actr.clear_exp_window(window_reading) actr.clear_exp_window(window) actr.add_text_to_exp_window(window_reading, chosen_letter, 125, 150) actr.add_command('process-click',process_click) actr.monitor_command('click-mouse','process-click') actr.run(1000, open_window) # for actr time or real time correct = correct_drawing(chosen_letter, clickList) if (correct): train_once(chosen_letter) actr.run_full_time(delay_time) else: train_n(train_epochs, chosen_letter) actr.run_full_time(delay_time) actr.remove_command_monitor('click-mouse', 'process-click') actr.remove_command('process-click') return (clickList, correct)
def test2(syntax, syntax_corr): actr.reset() prime_template = ['isa', 'sentence', 'string', '...', 'noun1', 'n1', 'noun2', 'n2', 'verb', 'v', 'syntax', syntax, 'syntax-corr', syntax_corr] actr.add_command("model1-key-press", respond_to_speech, "model1 task output-key monitor") actr.monitor_command("output-speech", "model1-key-press") # spreading activation # if syntax_corr == 'no': # print('disable both') # actr.pdisable("step5-1") # actr.pdisable("step5-2") # else: # actr.pdisable('step5-3') # if syntax == 'DO': # print('disable5-2') # actr.pdisable("step5-2") # else: # print('disable5-1') # actr.pdisable("step5-1") global response response = False task1(prime_template) task2() actr.remove_command_monitor("output-speech", "model1-key-press") actr.remove_command("model1-key-press") return response