def run():
env = gym.make('CartPole-v0')
env._max_episode_steps = None
state_size = env.observation_space.shape[0]
action_size = env.action_space.n
agent = HRL(state_size, action_size)
horizon = 20
for e in range(agent.episodes):
state = torch.tensor(env.reset(), dtype=torch.float)
goal = torch.tensor([0.0, 0.0, 0.0, 0.0], dtype=torch.float)
score = 0
# Rollout
for t in range(horizon):
score += 1
env.render()
action = agent.act(state, goal,
torch.tensor([horizon - t], dtype=torch.float))
next_state, _, done, _ = env.step(action)
agent.remember(state, action, next_state, None, None, done)
agent.augment_goals(state, action, next_state, done)
state = next_state
if done:
print("episode: {}/{}, score: {}, e: {:.2}".format(
e, agent.episodes, score, agent.epsilon))
break
# Perform optimization
for _ in range(agent.n):
agent.replay()
def main():
hrl = HRL(graphics='datapixx',
inputs='responsepixx',
photometer=None,
wdth=WIDTH,
hght=HEIGHT,
bg=0.27,
scrn=1,
lut='lut.csv',
db=False,
fs=True)
# loop over design
# ================
for trl in np.arange(start_trl, end_trl):
run_trial(hrl, trl, start_trl,
end_trl) # function that executes the experiment
hrl.close()
print "Session complete"
rfl.close()
bfl = open('results/%s/mlds/%s_blocks_done.txt' %(vp_id, vp_id), 'a')
if blocksdone == None:
block_headers = ['number', 'block']
bfl.write('\t'.join(block_headers)+'\n')
bfl.flush()
# Pass this to HRL if we want to use gamma correction.
lut = 'lut.csv'
if inlab:
## create HRL object
hrl = HRL(graphics='datapixx',
inputs='responsepixx',
photometer=None,
wdth=WIDTH,
hght=HEIGHT,
bg=0.27,
scrn=1,
lut=lut,
db = False,
fs=True)
else:
hrl = HRL(graphics='gpu',
inputs='keyboard',
photometer=None,
wdth=WIDTH,
hght=HEIGHT,
bg=0.27,
scrn=1,
lut=lut,
db = True,
def main():
debug = 0
#print debug
if debug:
### HRL Parameters for DESKTOP ###
graphics = 'gpu'
inputs = 'keyboard'
# Screen GPU
wdth = 800
hght = 600
fs = False # fullscreen mode off
scrn = 0 # screen number
else:
### HRL Parameters for DATAPIXX ###
graphics = 'datapixx'
inputs = 'responsepixx' # or 'responsepixx'
wdth = 1024
hght = 768
#wdth = 1600
#hght = 1200
#wdth = 2048
#hght = 1536
fs = True # fullscreen mode
scrn = 1 # screen number
#############################################
hrl = HRL(graphics=graphics,
inputs=inputs,
lut=lut,
photometer=None,
wdth=wdth,
hght=hght,
bg=background,
fs=fs,
scrn=scrn)
whlf = wdth / 2.0
hhlf = hght / 2.0
weht = wdth / 8.0
heht = hght / 8.0
# texture creation in buffer, input is numpy array [0-1]
white = hrl.graphics.newTexture(np.array([[1]]))
black = hrl.graphics.newTexture(np.array([[0]]))
s = 150
white.draw((whlf - s, hhlf - s), (s, s))
black.draw((whlf, hhlf - s), (s, s))
white.draw((whlf, hhlf), (s, s))
black.draw((whlf - s, hhlf), (s, s))
hrl.graphics.flip(clr=False)
#######################################
while True:
#hrl.graphics.flip(clr=True) # clr= True to clear buffer
(btn, t1) = hrl.inputs.readButton()
#print btn
if btn == 'Space':
break
# closing window
hrl.close()
def main():
# determine design and result file name
try:
(design_fn, result_fn, completed_trials, total_trials,
check_fn) = prepare_files()
except EndExperiment:
return 0
result_headers = [
'Trial', 'adaptor_type', 'coaxial_lum', 'test_lum', 'match_lum',
'flank_lum', 'test_loc', 'grating_ori', 'response_time',
'match_initial', 'adaptor_shift'
]
global hrl
hrl = HRL(graphics='datapixx',
inputs='responsepixx',
photometer=None,
wdth=1024,
hght=768,
bg=0.5,
dfl=design_fn,
rfl=result_fn,
rhds=result_headers,
scrn=1,
lut='lut0to88.csv',
db=False,
fs=True)
# monkey patch to use non-blocking readButton function
# should be removed once hrl.inputs.readButton is fixed
hrl.inputs.readButton = lambda to: waitButton(hrl.datapixx, to)
# set the bar width of the grating. this value determines all positions
global bar_width
bar_width = 38
y_border = 768 // 2 - int(6 * bar_width)
x_border = (1024 - 6 * bar_width) // 2
# the coordinates of the four possible test check positions
# test coordinates are (y,x) position within the grating array
global test_coords
test_coords = ((bar_width * 3, bar_width * 2), (bar_width * 3,
bar_width * 3),
(bar_width * 4, bar_width * 2), (bar_width * 4,
bar_width * 3))
# match coordinates are (x,y) screen positions
global match_coords
match_coords = ((x_border + bar_width * 2, 384 + int(bar_width * 2)),
(x_border + bar_width * 3, 384 + int(bar_width * 2)),
(x_border + bar_width * 2, 384 + int(bar_width * 1)),
(x_border + bar_width * 3, 384 + int(bar_width * 1)))
global match_bg_loc
match_bg_loc = (x_border, 384)
global stim_loc
stim_loc = (x_border, y_border)
# prepare fixation mark textures
global fix_inner
fix_inner = hrl.graphics.newTexture(np.ones((1, 1)) * .5, 'circle')
global fix_outer
fix_outer = hrl.graphics.newTexture(np.zeros((1, 1)), 'circle')
# prepare confirmation texture
global confirmation
confirmation = hrl.graphics.newTexture(draw_text('Weiter?', bg=.5))
# show instruction screen
if completed_trials == 0:
for i in range(6):
instructions = plt.imread('instructions%d.png' % (i + 1))[..., 0]
instructions = hrl.graphics.newTexture(instructions)
instructions.draw((0, 0))
hrl.graphics.flip(clr=True)
btn = None
while btn != 'Space':
btn, _ = hrl.inputs.readButton(to=3600)
# show test trials
test_dsgn = [{
'adaptor_type': 'none',
'grating_ori': 'horizontal',
'grating_vals': '0.45,0.55',
'test_loc': '0',
'test_lum': '0.5'
}, {
'adaptor_type': 'vertical',
'grating_ori': 'horizontal',
'grating_vals': '0.55,0.45',
'test_loc': '1',
'test_lum': '0.5'
}, {
'adaptor_type': 'horizontal',
'grating_ori': 'horizontal',
'grating_vals': '0.45,0.55',
'test_loc': '2',
'test_lum': '0.5'
}, {
'adaptor_type': 'vertical',
'grating_ori': 'vertical',
'grating_vals': '0.55,0.45',
'test_loc': '2',
'test_lum': '0.5'
}, {
'adaptor_type': 'none',
'grating_ori': 'vertical',
'grating_vals': '0.45,0.45',
'test_loc': '1',
'test_lum': '0.5'
}, {
'adaptor_type': 'vertical_shifted',
'grating_ori': 'vertical',
'grating_vals': '0.55,0.45',
'test_loc': '2',
'test_lum': '0.5'
}, {
'adaptor_type': 'none',
'grating_ori': 'vertical',
'grating_vals': '0.55,0.55',
'test_loc': '1',
'test_lum': '0.5'
}, {
'adaptor_type': 'horizontal_shifted',
'grating_ori': 'vertical',
'grating_vals': '0.45,0.55',
'test_loc': '1',
'test_lum': '0.5'
}, {
'adaptor_type': 'horizontal',
'grating_ori': 'vertical',
'grating_vals': '0.45,0.55',
'test_loc': '3',
'test_lum': '0.5'
}]
for dsgn in test_dsgn:
run_trial(dsgn)
# show experiment start confirmation
hrl.graphics.flip(clr=True)
lines = [
u'Die Probedurchgänge sind fertig.',
u'Wenn du bereit bist, drücke die mittlere Taste.', u' ',
u'Wenn du noch Fragen hast, oder mehr Probedurchgänge',
u'machen willst, wende dich an den Versuchsleiter.'
]
for line_nr, line in enumerate(lines):
textline = hrl.graphics.newTexture(draw_text(line, fontsize=36))
textline.draw(((1024 - textline.wdth) / 2,
(768 / 2 - (3 - line_nr) * (textline.hght + 10))))
hrl.graphics.flip(clr=True)
btn = None
while btn != 'Space':
btn, _ = hrl.inputs.readButton(to=3600)
### Core Loop ###
# hrl.designs is an iterator over all the lines in the specified design
# matrix, which was loaded at the creation of the hrl object. Looping over
# it in a for statement provides a nice way to run each line in a design
# matrix. The fields of each design line (dsgn) are drawn from the design
# matrix in the design file (design.csv).
start_time = time.time()
try:
for trial, dsgn in enumerate(hrl.designs):
# skip trials that we already had data for
if trial < completed_trials:
continue
# check if we should take a break (every 15 minutes)
if time.time() - start_time > (60 * 15):
show_break(trial, total_trials)
start_time = time.time()
match_lum, t, bg_values = run_trial(dsgn)
# convert adaptor type name to convention more useful for analysis
adaptor_ori = dsgn['adaptor_type'].replace('_shifted', '')
if adaptor_ori == 'none':
adaptor_type = 'none'
elif dsgn['grating_ori'] == adaptor_ori:
adaptor_type = 'parallel'
else:
adaptor_type = 'orthogonal'
# determine flank and coaxial luminance based on test patch position
grating_vals = [float(v) for v in dsgn['grating_vals'].split(',')]
loc = int(dsgn['test_loc'])
go = dsgn['grating_ori']
if (go == 'horizontal' and loc in [2, 3]) or \
(go == 'vertical' and loc in [0, 2]):
coaxial_lum, flank_lum = grating_vals
else:
flank_lum, coaxial_lum = grating_vals
# Once a value has been chosen by the subject, we save all relevant
# variables to the result file by loading it all into the hrl.results
# dictionary, and then finally running hrl.writeResultLine().
hrl.results['Trial'] = trial
hrl.results['test_lum'] = dsgn['test_lum']
hrl.results['adaptor_type'] = adaptor_type
hrl.results['test_loc'] = dsgn['test_loc']
hrl.results['grating_ori'] = dsgn['grating_ori']
hrl.results['coaxial_lum'] = coaxial_lum
hrl.results['flank_lum'] = flank_lum
hrl.results['response_time'] = time.time() - t
hrl.results['match_lum'] = float(match_lum)
hrl.writeResultLine()
# write match bg values to file
with open(check_fn, 'a') as f:
f.write('%s\n' % ','.join('%0.4f' % x for x in bg_values))
# We print the trial number simply to keep track during an experiment
print hrl.results['Trial']
# catch EndExperiment exception raised by pressing escp for clean exit
except EndExperiment:
print "Experiment aborted"
# And the experiment is over!
hrl.close()
print "Session complete"
def main(files):
debug = 0
#print debug
if debug:
### HRL Parameters for DESKTOP ###
graphics = 'gpu'
inputs = 'keyboard'
# Screen GPU
wdth = 800
hght = 600
fs = False # fullscreen mode off
scrn = 0 # screen number
else:
### HRL Parameters for DATAPIXX ###
graphics = 'datapixx'
inputs = 'responsepixx' # or 'responsepixx'
wdth = 1024
hght = 768
fs = True # fullscreen mode
scrn = 1 # screen number
#############################################
hrl = HRL(graphics=graphics,
inputs=inputs,
lut=lut,
photometer=None,
wdth=wdth,
hght=hght,
bg=background,
fs=fs,
scrn=scrn)
whlf = wdth / 2.0
hhlf = hght / 2.0
#qh = hght/4.0
#qw = wdth/4.0
#ws = wdth/6.0
# reading PNGs and converting to grayscale
textures = []
for fname in files:
print "loading... %s " % fname
## the image is loaded using PIL module and converted to a
## numpy array ranging from 0 to 1.
image = Image.open(fname).convert("L")
im = np.asarray(image) / 255.
# texture creation in buffer, input is numpy array [0-1]
tex = hrl.graphics.newTexture(im)
textures.append(tex)
# generating text for filenames to be displayed
texts = []
for fname in files:
im = draw_text(fname, bg=0.27, text_color=0, fontsize=20)
tex = hrl.graphics.newTexture(im)
texts.append(tex)
#######
i = 0
#######################################
while True:
tex = textures[i]
tex.draw((whlf - tex.wdth / 2, hhlf - tex.hght / 2))
tex = texts[i]
tex.draw((100, 100))
hrl.graphics.flip(clr=True) # clr= True to clear buffer
print "currently showing: %s" % files[i]
(btn, t1) = hrl.inputs.readButton()
#print btn
if btn == 'Space':
break
elif btn == 'Right':
i += 1
elif btn == 'Left':
i -= 1
if i < 0:
i = len(textures) - 1
if i == len(textures):
i = 0
# closing window
hrl.close()
