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 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 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 GAPI_speech_recognition():
actr.reset()
# obtain audio from the microphone
r = sr.Recognizer()
with sr.Microphone() as source:
r.adjust_for_ambient_noise(source)
print("Say something!")
audio = r.listen(source)
text = r.recognize_google(audio, language="it-IT")
#text = word_tokenize(text)
# recognize speech using Google Speech Recognition
try:
# for testing purposes, we're just using the default API key
# to use another API key, use `r.recognize_google(audio, key="GOOGLE_SPEECH_RECOGNITION_API_KEY")`
# instead of `r.recognize_google(audio)`
print("Google Speech Recognition thinks you said " + str(text))
except sr.UnknownValueError:
print("Google Speech Recognition could not understand audio")
except sr.RequestError as e:
print(
"Could not request results from Google Speech Recognition service; {0}"
.format(e))
#actr.new_word_sound(text)
#for word in text:
# actr.new_word_sound(word)
#actr.run(30)
return text
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 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 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 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 experiment(visible=None, show=True):
actr.reset()
global trials
trials = []
for j in range(3):
for i in range(8):
trials = trials + create_set(j + 1, visible)
collect_responses(576)
return analyze_results(show)
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 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 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 bst_set(human, vis, stims, learn=True):
global visible
result = []
visible = vis
for stim in stims:
if not (learn) and not (human):
actr.reset()
do_experiment(stim, human)
result.append(choice)
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 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 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()
# 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 experiment(n, human=False):
l = len(test_stim)
result = [0] * l
p_values = [["decide-over", 0], ["decide-under", 0], ["force-over", 0],
["force-under", 0]]
for i in range(n):
actr.reset()
d = bst_set(human, vis=True, stims=test_stim)
for j in range(l):
if d[j] == "over":
result[j] += 1
actr.hide_output()
# for p in p_values:
# p[1] += production_u_value(p[0])
actr.unhide_output()
result = list(map(lambda x: 100 * x / n, result))
if len(result) == len(exp_data):
actr.correlation(result, exp_data)
actr.mean_deviation(result, exp_data)
print()
print("Trial ", end="")
for i in range(l):
print("%-8d" % (i + 1), end="")
print()
print(" ", end="")
for i in range(l):
print("%8.2f" % result[i], end="")
print()
print()
for p in p_values:
print("%-12s: %6.4f" % (p[0], p[1] / n))
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 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 trial(*features):
actr.reset()
for slot,value in actr.permute_list(list(zip(slots,features))):
attribute(slot,value)
goal = actr.define_chunks(["state","categorize"])[0]
actr.goal_focus(goal)
actr.run(20)
answer = actr.chunk_slot_value(actr.buffer_read("imaginal"),"category")
if isinstance(answer,numbers.Number):
if answer == 1 or answer == 2:
return((answer,True))
else:
actr.model_output("Model responded with invalid category.")
return((0,False))
else:
actr.model_output("Model did not respond or provided a non-numeric category.")
return((0,False))
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)
