# -----------------------------------
operator = 'owa'
model = models['fusion']
devaluation_time = [2, 8, 16]
fig1 = figure()
ind = 1
for d in devaluation_time:
model.startExp()
for s in list(set(p_test[operator].keys()) - set(['S2'])):
# for s in p_test[operator].keys():
# for s in ['S9']:
model.setAllParameters(p_test[operator][s]['fusion'])
for i in xrange(nb_blocs):
cats.reinitialize()
cats.set_devaluation_interval(d)
model.startBloc()
for j in xrange(nb_trials):
# print cats.asso
state = cats.getStimulus(j)
# print state
action = model.chooseAction(state)
# print action, cats.actions.index(action)
reward = cats.getOutcome(state, action)
model.updateValue(reward)
# print reward
#sys.stdin.readline()
states = convertStimulus(np.array(model.state))
nb_blocs = 1 nb_trials = 40 cats = CATS(nb_trials) model = FSelection(cats.states, cats.actions, parameters) Hbs = [] Hfs = [] model.startExp() for i in xrange(nb_blocs): Hbs.append([]) Hfs.append([]) cats.reinitialize() model.startBloc() #cats.set_devaluation_interval(5) for j in xrange(nb_trials): # print cats.asso state = cats.getStimulus(j) # print state action = model.chooseAction(state) Hbs[-1].append(model.Hb) Hfs[-1].append(model.Hf) # print action, cats.actions.index(action) reward = cats.getOutcome(state, action) model.updateValue(reward) # print reward #sys.stdin.readline()
class SamplingPareto():
""" Simple sampling of parameters to
draw pareto front """
def __init__(self, human, model, n = 10000):
self.human = human
self.model = model
self.subject = self.human.keys()
self.n = n
self.nb_repeat = 8
self.nb_blocs = 4
self.nb_trials = 39
self.nb_param = len(self.model.bounds.keys())
self.p_order = self.model.bounds.keys()
self.cats = CATS(self.nb_trials)
self.rt = dict()
self.state = dict()
self.action = dict()
self.responses = dict()
self.indice = dict()
self.hrt = dict()
for s in self.human.keys():
self.rt[s] = np.array([self.human[s][i]['rt'][0:self.nb_trials,0] for i in range(1,self.nb_blocs+1)])
self.rt[s] = np.tile(self.rt[s], (self.nb_repeat,1))
self.state[s] = np.array([self.human[s][i]['sar'][0:self.nb_trials,0] for i in range(1,self.nb_blocs+1)])
self.state[s] = np.tile(self.state[s], (self.nb_repeat,1))
self.action[s] = np.array([self.human[s][i]['sar'][0:self.nb_trials,1] for i in range(1,self.nb_blocs+1)])
self.action[s] = np.tile(self.action[s], (self.nb_repeat,1))
self.responses[s] = np.array([self.human[s][i]['sar'][0:self.nb_trials,2] for i in range(1,self.nb_blocs+1)])
self.responses[s] = np.tile(self.responses[s], (self.nb_repeat,1))
step, indice = getRepresentativeSteps(self.rt[s], self.state[s], self.action[s], self.responses[s])
self.hrt[s] = computeMeanRepresentativeSteps(step)[0]
self.hrt[s] = self.center(self.hrt[s])
def _convertStimulus(self, s):
return (s == 1)*'s1'+(s == 2)*'s2' + (s == 3)*'s3'
def center(self, x):
x = x - np.median(x)
x = x / float(np.percentile(x, 75)-np.percentile(x, 25))
return x
def evaluate(self, s):
p_test = {k:np.random.uniform(self.model.bounds[k][0],self.model.bounds[k][1]) for k in self.model.bounds.keys()}
self.model.setAllParameters(p_test)
self.model.startExp()
for i in xrange(self.nb_repeat):
for j in xrange(self.nb_blocs):
self.cats.reinitialize()
self.cats.stimuli = np.array(map(self._convertStimulus, self.human[s][j+1]['sar'][:,0]))
self.model.startBloc()
for k in xrange(self.nb_trials):
state = self.cats.getStimulus(k)
action = self.model.chooseAction(state)
reward = self.cats.getOutcome(state, action)
self.model.updateValue(reward)
self.model.reaction = np.array(self.model.reaction)
self.model.action = np.array(self.model.action)
self.model.responses = np.array(self.model.responses)
self.model.value = np.array(self.model.value)
step, indice = getRepresentativeSteps(self.model.reaction, self.state[s], self.model.action, self.model.responses)
hrtm = computeMeanRepresentativeSteps(step)[0]
hrtm = self.center(hrtm)
rt = -np.sum(np.power(hrtm-self.hrt[s], 2))
choice = np.sum(np.log(self.model.value))
return np.array([choice, rt])
def multiSampling(self, s):
n = 100
data = np.zeros((n, 3))
pareto = np.array([[-1, -1000., -1000.0]])
p = np.zeros((n,self.nb_param+1))
good = np.zeros((1, self.nb_param+1))
good[0,0] = -1.0
for i in xrange(1,self.n+1):
ind = (i-1)%n
data[ind,0] = i
p[ind,0] = i
data[ind,1:] = self.evaluate(s)
p[ind,1:] = np.array([self.model.parameters[k] for k in self.p_order])
if i%n == 0:
pareto, good = self.constructParetoFrontier(np.vstack((data, pareto)), np.vstack((p, good)))
return dict({s:np.hstack((pareto, good[:,1:]))})
def constructParetoFrontier(self, front, param):
front = front[front[:,1].argsort()][::-1]
pareto_frontier = [front[0]]
for pair in front[1:]:
if pair[2] >= pareto_frontier[-1][2]:
pareto_frontier.append(pair)
pareto_frontier = np.array(pareto_frontier)
good = np.array([param[param[:,0] == i][0] for i in pareto_frontier[:,0]])
return pareto_frontier, good
def run(self):
subject = self.subject
pool = Pool(len(subject))
self.data = pool.map(unwrap_self_multiSampling, zip([self]*len(subject), subject))
tmp = dict()
for i in self.data:
s = i.keys()[0]
tmp[s] = i[s]
self.data = tmp
def save(self, output_file):
output = open(output_file, 'wb')
pickle.dump(self.data, output)
output.close()
nb_trials = 42
nStepEm = 2000
pOutset = 0.2
cats = CATS()
Responses = dict()
# -----------------------------------
#Kalman Learning session
# -----------------------------------
Kdata = []
for i in xrange(200):
answer = []
values = createQValuesDict(cats.states, cats.actions)
covariance = createCovarianceDict(len(cats.states)*len(cats.actions), init_cov, eta)
cats.reinitialize(nb_trials, 'meg')
for j in xrange(nb_trials):
KalmanQlearning(j, values, covariance, False)
Kdata.append(list(answer))
Responses['K'] = np.array(Kdata)
# -----------------------------------
# -----------------------------------
# QLearning session
# -----------------------------------
Qdata = []
for i in xrange(200):
answer = []
values = createQValuesDict(cats.states, cats.actions)
cats.reinitialize(nb_trials, 'meg')
for j in xrange(nb_trials):
nb_trials = 42
nStepEm = 2000
pOutset = 0.2
cats = CATS()
Responses = dict()
# -----------------------------------
#Kalman Learning session
# -----------------------------------
Kdata = []
for i in xrange(200):
answer = []
values = createQValuesDict(cats.states, cats.actions)
covariance = createCovarianceDict(
len(cats.states) * len(cats.actions), init_cov, eta)
cats.reinitialize(nb_trials, 'meg')
for j in xrange(nb_trials):
KalmanQlearning(j, values, covariance, False)
Kdata.append(list(answer))
Responses['K'] = np.array(Kdata)
# -----------------------------------
# -----------------------------------
# QLearning session
# -----------------------------------
Qdata = []
for i in xrange(200):
answer = []
values = createQValuesDict(cats.states, cats.actions)
cats.reinitialize(nb_trials, 'meg')
for j in xrange(nb_trials):
