def run_model(mypath, model_name, nE, n_samples, burn, thin):
thispath = os.path.join(mypath, 'model_{}'.format(nE))
if not os.path.exists(thispath):
os.mkdir(thispath)
model_filename = os.path.join(mypath, 'model_{}'.format(nE), 'modelfit-{}.model'.format(nE))
print(model_filename)
if model_name == 'stimcoding_base':
# Model without pupil or slow-wave information for comparison
m = hddm.HDDMStimCoding(mydata, stim_col='stim', split_param='z', p_outlier=0.05,
include=('z'), depends_on={'v': ['stim']})
elif model_name == 'stimcoding_z_SW':
m = hddm.HDDMStimCoding(mydata, stim_col='stim', split_param='z', p_outlier=0.05,
include=('z'), depends_on={'v': ['Task', 'stim', nE], 'a': ['Task', nE], 'z' : ['Task', nE], 't': ['Task', nE]})
print("finding starting values")
#m.find_starting_values() # this should help the sampling
print("begin sampling")
m.sample(n_samples, burn=burn, thin=thin, db='pickle', dbname=os.path.join(mypath, 'model_{}'.format(nE), 'modelfit-{}.db'.format(nE)))
m.save(os.path.join(mypath, 'model_{}'.format(nE), 'modelfit-{}.model'.format(nE))) # save the model to disk
# ============================================ #
# save the output values
# ============================================ #
# save the model comparison indices
df = dict()
df['dic_original'] = [m.dic]
df['aic'] = [aic(m)]
df['bic'] = [bic(m)]
df_fit = pd.DataFrame(df)
df_fit.to_csv(os.path.join(mypath, 'model_{}'.format(nE), 'model_comparison_{}.csv'.format(nE)))
# save the stats
results = m.gen_stats()
results.to_csv(os.path.join(mypath, 'model_{}'.format(nE), 'model_stats_{}.csv'.format(nE)))
# save the traces for inspection
params_of_interest = ['a(0.0)', 'a(1.0)', 'v(0.0.0.0)', 'v(1.0.0.0)', 'v(0.0.1.0)', 'v(1.0.1.0)', 't(0.0)', 't(1.0)', 'z(0.0)', 'z(1.0)']
traces = []
for p in range(len(params_of_interest)):
traces.append(m.nodes_db.node[params_of_interest[p]].trace.gettrace())
tracesarray = np.asarray(traces)
tracesFrame= pd.DataFrame(data=tracesarray[0:,0:])
tracesFrame.to_csv(os.path.join(mypath, 'model_{}'.format(nE), 'traces_{}.csv'.format(nE)))
return m
"---------------------------------------------------------------------------------------------"
def test_HDDMStimCoding(self):
params_full, params = hddm.generate.gen_rand_params(cond_dict={
'v': [-1, 1],
'z': [.8, .4]
})
data, params_subj = hddm.generate.gen_rand_data(params=params_full,
size=10)
m = hddm.HDDMStimCoding(data, stim_col='condition', split_param='v')
m.sample(self.iter, burn=self.burn)
self.assertIsInstance(m.nodes_db.loc['wfpt(c1)']['node'].parents['v'],
pm.Normal)
self.assertIsInstance(m.nodes_db.loc['wfpt(c0)']['node'].parents['v'],
pm.PyMCObjects.Deterministic)
self.assertIsInstance(
m.nodes_db.loc['wfpt(c0)']['node'].parents['v'].parents['self'],
pm.Normal)
m = hddm.HDDMStimCoding(data, stim_col='condition', split_param='z')
m.sample(self.iter, burn=self.burn)
self.assertIsInstance(m.nodes_db.loc['wfpt(c1)']['node'].parents['z'],
pm.CommonDeterministics.InvLogit)
self.assertIsInstance(m.nodes_db.loc['wfpt(c0)']['node'].parents['z'],
pm.PyMCObjects.Deterministic)
self.assertIsInstance(
m.nodes_db.loc['wfpt(c0)']['node'].parents['z'].parents['a'], int)
self.assertIsInstance(
m.nodes_db.loc['wfpt(c0)']['node'].parents['z'].parents['b'],
pm.CommonDeterministics.InvLogit)
m = hddm.HDDMStimCoding(data,
stim_col='condition',
split_param='v',
drift_criterion=True)
m.sample(self.iter, burn=self.burn)
self.assertIsInstance(m.nodes_db.loc['wfpt(c1)']['node'].parents['v'],
pm.PyMCObjects.Deterministic)
self.assertEqual(
m.nodes_db.loc['wfpt(c1)']
['node'].parents['v'].parents['a'].__name__, 'v')
self.assertEqual(
m.nodes_db.loc['wfpt(c1)']
['node'].parents['v'].parents['b'].__name__, 'dc')
self.assertIsInstance(m.nodes_db.loc['wfpt(c0)']['node'].parents['v'],
pm.PyMCObjects.Deterministic)
self.assertIsInstance(
m.nodes_db.loc['wfpt(c0)']['node'].parents['v'].parents['a'],
pm.PyMCObjects.Deterministic)
self.assertIsInstance(
m.nodes_db.loc['wfpt(c0)']['node'].parents['v'].parents['b'],
pm.Normal)
self.assertIsInstance(
m.nodes_db.loc['wfpt(c0)']
['node'].parents['v'].parents['a'].parents['self'], pm.Normal)
def test_HDDMStimCoding(self):
params_full, params = hddm.generate.gen_rand_params(cond_dict={'v': [-1, 1], 'z': [.8, .4]})
data, params_subj = hddm.generate.gen_rand_data(params=params_full)
m = hddm.HDDMStimCoding(data, stim_col='condition', split_param='v')
m.sample(self.iter, burn=self.burn)
assert isinstance(m.nodes_db.ix['wfpt(c0)']['node'].parents['v'], pm.Normal)
assert isinstance(m.nodes_db.ix['wfpt(c1)']['node'].parents['v'], pm.PyMCObjects.Deterministic)
assert isinstance(m.nodes_db.ix['wfpt(c1)']['node'].parents['v'].parents['self'], pm.Normal)
m = hddm.HDDMStimCoding(data, stim_col='condition', split_param='z')
m.sample(self.iter, burn=self.burn)
assert isinstance(m.nodes_db.ix['wfpt(c0)']['node'].parents['z'], pm.CommonDeterministics.InvLogit)
assert isinstance(m.nodes_db.ix['wfpt(c1)']['node'].parents['z'], pm.PyMCObjects.Deterministic)
assert isinstance(m.nodes_db.ix['wfpt(c1)']['node'].parents['z'].parents['a'], int)
assert isinstance(m.nodes_db.ix['wfpt(c1)']['node'].parents['z'].parents['b'], pm.CommonDeterministics.InvLogit)
def run_model(trace_id,
data,
model_dir,
model_name,
samples=10000,
accuracy_coding=False):
import hddm
m = hddm.HDDMStimCoding(data,
stim_col='stimulus',
split_param='v',
drift_criterion=True,
bias=True,
include=('sv'),
group_only_nodes=['sv'],
depends_on={
't': ['drug', 'sessionnr'],
'v': ['drug', 'sessionnr'],
'a': ['drug', 'sessionnr'],
'dc': ['drug', 'sessionnr'],
'z': ['drug', 'sessionnr'],
},
p_outlier=.05)
m.find_starting_values()
m.sample(samples,
burn=samples / 10,
thin=3,
dbname=os.path.join(model_dir,
model_name + '_db{}'.format(trace_id)),
db='pickle')
return m
def fit_ddm_subject(df, model_settings, subj_idx, n_runs=5):
# fix depends_on:
depends_on = model_settings['depends_on']
if depends_on is not None:
if 'dc' in depends_on:
depends_on['dc'] = depends_on['b']
depends_on.pop('b', None)
depends_on.pop('u', None)
# fit:
m = hddm.HDDMStimCoding(df, stim_col='stimulus', split_param='v', drift_criterion=True, bias=True,
depends_on=depends_on, include=('sv'), group_only_nodes=['sv'], p_outlier=0)
# # starting values:
# if sum(np.isnan(data.loc[data['response']==0, 'rt'])) == sum(data['response']==0):
# # pass
# print('finding starting values via basic model!')
# basic_m = hddm.HDDMStimCoding(data, stim_col='stimulus', split_param='v', drift_criterion=False, bias=False, p_outlier=0)
# basic_m.approximate_map()
# basic_m.optimize('gsquare', quantiles=analysis_info['quantiles'], n_runs=n_runs)
# values_m = m.values
# # for v in ['v', 'a', 't', 'z', 'z_trans', 'dc']:
# names = []
# best_values = []
# for v in ['v', 'a', 't',]:
# values_to_set = []
# for p in m.values:
# if '{}'.format(v) == p:
# values_to_set.append(p)
# elif '{}('.format(v) in p:
# values_to_set.append(p)
# for p in values_to_set:
# try:
# values_m[p] = basic_m.values['{}'.format(v)]
# names.append(p)
# best_values.append( basic_m.values['{}'.format(v)])
# except:
# pass
# m.set_values(dict(list(zip(names, best_values))))
# print(m.values)
# else:
# print('finding starting values!')
# m.approximate_map()
# print(m.values)
# optimize:
print('fitting model!')
m.optimize('gsquare', quantiles=analysis_info['quantiles'], n_runs=n_runs)
res = pd.concat((pd.DataFrame([m.values], index=[subj_idx]), pd.DataFrame([m.bic_info], index=[subj_idx])), axis=1)
# res['aic'] = m.aic
# res['bic'] = m.bic
return res
def fit_ddm_subject(data, subj_idx, model, model_dir, model_name, n_runs=5):
data = data.loc[data["subj_idx"] == subj_idx, :]
# exec('global m; m = {}'.format(model))
m = hddm.HDDMStimCoding(data,
stim_col='stimulus',
split_param='v',
drift_criterion=True,
bias=True,
p_outlier=0.01)
# optimize:
# m.approximate_map()
m.optimize('gsquare',
quantiles=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9],
n_runs=n_runs)
res = pd.concat((pd.DataFrame([m.values], index=[subj_idx]),
pd.DataFrame([m.bic_info], index=[subj_idx])),
axis=1)
res['aic'] = aic(m)
res['bic'] = bic(m)
return res
#mydata= mydata[mydata.rt < 1]
#mydata.rt[mydata.response == 0] = 999
# Calculate total number of outliers - 3143/82364 = 3.8%
total_outliers = len(data)-len(mydata)
print(total_outliers)
# I fit the baseline and state models to both the digit and faces tasks separately here.
# I save the states, traces and traceplots.
# For the two state models I added in some code for the posterior plots by condition.
# PPC is a little more involved and is better to do when we've decided on a final set of models
#----------------------------------------#
# Faces - Model 2 (state)
model_Pup = hddm.HDDMStimCoding(mydata, include={'z'}, stim_col= 'stim', split_param='z', depends_on={'v': ['stim', 'pcPup'], 'a': 'pcPup', 'z' : 'pcPup', 't': 'pcPup'}, p_outlier=.05)
model_Pup.find_starting_values()
model_Pup.sample(2000, burn=1000, dbname=os.path.join(modelpath,'Both/model_Pup/model_Pup.db'), db='pickle')
model_Pup.save(os.path.join(modelpath,'Both/model_Pup/model_Pup'))
# Extract stats
model_Pup_stats = model_Pup.gen_stats()
model_Pup_stats.to_csv(os.path.join(modelpath,'Both/model_Pup/model_Pup_stats.csv'))
# Extract traceplots
model_Pup.plot_posteriors(save=True, path=os.path.join(modelpath,'Both/model_Pup/Plots/Traceplots'))
# Extract full chains, transform back z and get v bias
model_Pup_traces = model_Pup.get_group_traces()
model_Pup_traces['z(1)'] = np.exp(model_Pup_traces['z_trans(1)'])/(1+np.exp(model_Pup_traces['z_trans(1)']))
model_Pup_traces['z(2)'] = np.exp(model_Pup_traces['z_trans(2)'])/(1+np.exp(model_Pup_traces['z_trans(2)']))
print(total_outliers)
# Create separate datasets for the face (1) and digit (2) tasks
#pdata = mydata[np.logical_or(np.logical_and(mydata.DistProbe > -19,mydata.TrCat ==0),np.logical_and(mydata.DistProbe > -3,mydata.TrCat ==1))]
""" I titled the new sets of models omni short for omnibus as they all include both tasks in the same model"""
# Model 1 - All trials, Stim & Task only
# Model 2 - All trials, Stim, State & Task
# Model 3 - Proximal trials (only 20 trials prior to probe), Stim & Task only
# Model 4 - Proximal trials (only 20 trials prior to probe), Stim, State & Task
#--------------------------------------------------------------------------------------------------------#
# Omni - Model 1 (No State information, just Stim and Task)
model_omni_1 = hddm.HDDMStimCoding(mydata, include={'z'}, stim_col= 'stim', split_param='z', depends_on={'v': ['stim', 'Task'], 'a': 'Task', 'z' : 'Task', 't': 'Task'}, p_outlier=.05)
model_omni_1.find_starting_values()# Create model and start MCMC sampling
model_omni_1.sample(2000, burn=1000, dbname=os.path.join(modelpath,'Omni/Model_1/model_omni_1.db'), db='pickle')
model_omni_1.save(os.path.join(modelpath,'Omni/Model_1/model_omni_1'))
# Extract stats
model_omni_1_stats = model_omni_1.gen_stats()
model_omni_1_stats.to_csv(os.path.join(modelpath,'Omni/Model_1/model_omni_1_stats.csv'))
# Extract traceplots
model_omni_1.plot_posteriors(save=True, path=os.path.join(modelpath,'Omni/Model_1/Plots/Traceplots'))
# Extract full chains, transform back z and get v bias
model_omni_1_traces = model_omni_1.get_group_traces()
model_omni_1_traces['z(1)'] = np.exp(model_omni_1_traces['z_trans(1)'])/(1+np.exp(model_omni_1_traces['z_trans(1)']))
model_omni_1_traces['z(2)'] = np.exp(model_omni_1_traces['z_trans(2)'])/(1+np.exp(model_omni_1_traces['z_trans(2)']))
def run_model(mypath, model_name, trace_id, nr_samples=50000):
import os
import hddm
model_filename = os.path.join(mypath, model_name, 'modelfit-md%d.model'%trace_id)
print model_filename
modelExists = os.path.isfile(model_filename)
if not modelExists:
# get the csv
mydata = hddm.load_csv(os.path.join(mypath, '2ifc_data_hddm.csv'))
# specify the model
if model_name == 'stimcoding':
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v':['sessionnr']},
p_outlier=0.05)
elif model_name == 'prevresp_z':
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v':['sessionnr'], 'z':['prevresp']},
p_outlier=0.05)
elif model_name == 'prevresp_dc':
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v':['sessionnr'], 'dc':['prevresp']},
p_outlier=0.05)
elif model_name == 'prevresp_prevrt_z':
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v':['sessionnr'], 'z':['prevresp', 'prevrt']},
p_outlier=0.05)
elif model_name == 'prevresp_prevrt_dc':
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v':['sessionnr'], 'dc':['prevresp', 'prevrt']},
p_outlier=0.05)
elif model_name == 'prevresp_prevpupil_z':
# take only rows without NaN
m = hddm.HDDMStimCoding(mydata.dropna(), stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v':['sessionnr'], 'z':['prevresp', 'prevpupil']},
p_outlier=0.05)
elif model_name == 'prevresp_prevpupil_dc':
# take only rows without NaN
m = hddm.HDDMStimCoding(mydata.dropna(), stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v':['sessionnr'], 'dc':['prevresp', 'prevpupil']},
p_outlier=0.05)
# ============================================ #
# do the actual sampling
# ============================================ #
m.sample(nr_samples, burn=nr_samples/4, thin=3, db='pickle',
dbname=os.path.join(mypath, model_name, 'modelfit-md%d.db'%trace_id))
m.save(model_filename) # save the model to disk
# ============================================ #
# save the output values
# ============================================ #
results = m.gen_stats() # this seems different from print_stats??
results.to_csv(os.path.join(mypath, model_name, 'results-md%d.csv'%trace_id))
# save the DIC for this model
text_file = open(os.path.join(mypath, model_name, 'DIC-md%d.txt'%trace_id), 'w')
text_file.write("Model {}: {}\n".format(trace_id, m.dic))
text_file.close()
import hddm
import pandas as pd
import os
data = hddm.load_csv('D://brainbnu//haiyang//hddm//hddm_all_StimCoding.csv')
res_dir = 'D://brainbnu//haiyang//hddm//result//all_StimCoding//avtz3'
models = []
dic = []
for i in range(3):
m = hddm.HDDMStimCoding(data,
stim_col='stimulus',
include='z',
split_param='v',
depends_on={
'a': ['condition', 'group'],
'v': ['condition', 'group'],
't': ['condition', 'group']
})
m.find_starting_values()
m.sample(20000, burn=2000, dbname='traces.db', db='pickle')
m.save('model_avtz3_all_StimCoding_' + str(i + 1))
m_stat = m.gen_stats()
m_stat.to_csv(
os.path.join(res_dir,
'stat_avtz3_all_StimCoding_' + str(i + 1) + '.csv'))
dic.append(m.dic)
models.append(m)
#models.save('models_all')
def run_model(mypath, model_version, trace_id, nr_samples=50000):
if model_version == 1:
model_name = 'stimcoding'
elif model_version == 2:
model_name = 'prevresp_z'
elif model_version == 3:
model_name = 'prevresp_dc'
elif model_version == 4:
model_name = 'prevresp_prevrt_z'
elif model_version == 5:
model_name = 'prevresp_prevrt_dc'
elif model_version == 6:
model_name = 'prevresp_prevpupil_z'
elif model_version == 7:
model_name = 'prevresp_prevpupil_dc'
import os
model_filename = os.path.join(mypath, model_name,
'modelfit-md%d.model' % trace_id)
modelExists = os.path.isfile(model_filename)
if modelExists:
print "model already exists, skipping"
else:
import hddm
# get the csv
mydata = hddm.load_csv(os.path.join(mypath, '2ifc_data_hddm.csv'))
# specify the model
m = hddm.HDDMStimCoding(mydata,
stim_col='stimulus',
split_param='v',
drift_criterion=True,
bias=True,
include=('sv'),
group_only_nodes=['sv'],
depends_on={
't': ['sessionnr'],
'v': ['sessionnr'],
'a': ['sessionnr'],
'dc': ['sessionnr'],
'z': ['sessionnr', 'prevresp']
},
p_outlier=.05)
# ============================================ #
# do the actual sampling
# ============================================ #
m.sample(nr_samples,
burn=nr_samples / 4,
thin=3,
db='pickle',
dbname=os.path.join(mypath, model_name,
'modelfit-md%d.db' % trace_id))
m.save(model_filename) # save the model to disk
# ============================================ #
# save the output values
# ============================================ #
results = m.gen_stats() # this seems different from print_stats??
results.to_csv(
os.path.join(mypath, model_name, 'results-md%d.csv' % trace_id))
# save the DIC for this model
text_file = open(
os.path.join(mypath, model_name, 'DIC-md%d.txt' % trace_id), 'w')
text_file.write("Model {}: {}\n".format(trace_id, m.dic))
text_file.close()
# dont return model object, can't be pickled so Parallel will hang
return trace_id
def make_model(mypath, mydata, model_name, trace_id):
model_filename = os.path.join(mypath, model_name, 'modelfit-md%d.model'%trace_id)
print model_filename
# ============================================ #
# NO HISTORY FOR MODEL COMPARISON
# ============================================ #
if model_name == 'stimcoding_nohist':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# for Anke's data, also split by transition probability
if len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'])
if model_name == 'stimcoding_nohist_onlyz':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# for Anke's data, also split by transition probability
if len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'])
elif model_name == 'stimcoding_nohist_onlydc':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# for Anke's data, also split by transition probability
if len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'])
# ============================================ #
# STIMCODING PREVRESP
# ============================================ #
elif model_name == 'stimcoding_dc_prevresp':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# also split by transition probability and include coherence-dependence of drift rate
if 'transitionprob' in mydata.columns:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'dc':['prevresp', 'transitionprob']})
elif len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'dc':['prevresp']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'dc':['prevresp']})
elif model_name == 'stimcoding_z_prevresp':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# for Anke's data, also split by transition probability
if 'transitionprob' in mydata.columns:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'z':['prevresp', 'transitionprob']})
elif len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'z':['prevresp']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'z':['prevresp']})
elif model_name == 'stimcoding_dc_z_prevresp':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# for Anke's data, also split by transition probability
if 'transitionprob' in mydata.columns:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'dc':['prevresp', 'transitionprob'],
'z':['prevresp', 'transitionprob']})
elif len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'dc':['prevresp'], 'z':['prevresp']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'dc':['prevresp'], 'z':['prevresp']})
# ============================================ #
# also estimate across-trial variability in starting point
# ============================================ #
if model_name == 'stimcoding_sz_nohist':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# for Anke's data, also split by transition probability
if len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv', 'sz'), group_only_nodes=['sv', 'sz'],
depends_on={'v': ['coherence']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv', 'sz'), group_only_nodes=['sv', 'sz'])
elif model_name == 'stimcoding_sz_dc_prevresp':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# for Anke's data, also split by transition probability and include coherence-dependence of drift rate
if 'transitionprob' in mydata.columns:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv', 'sz'), group_only_nodes=['sv', 'sz'],
depends_on={'v': ['coherence'], 'dc':['prevresp', 'transitionprob']})
elif len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv', 'sz'), group_only_nodes=['sv', 'sz'],
depends_on={'v': ['coherence'], 'dc':['prevresp']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv', 'sz'), group_only_nodes=['sv', 'sz'],
depends_on={'dc':['prevresp']})
elif model_name == 'stimcoding_sz_z_prevresp':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# for Anke's data, also split by transition probability
if 'transitionprob' in mydata.columns:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv', 'sz'), group_only_nodes=['sv', 'sz'],
depends_on={'v': ['coherence'], 'z':['prevresp', 'transitionprob']})
elif len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv', 'sz'), group_only_nodes=['sv', 'sz'],
depends_on={'v': ['coherence'], 'z':['prevresp']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv', 'sz'), group_only_nodes=['sv', 'sz'],
depends_on={'z':['prevresp']})
elif model_name == 'stimcoding_sz_dc_z_prevresp':
# include across-trial variability in starting point
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# for Anke's data, also split by transition probability
if 'transitionprob' in mydata.columns:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv', 'sz'), group_only_nodes=['sv', 'sz'],
depends_on={'v': ['coherence'], 'dc':['prevresp', 'transitionprob'],
'z':['prevresp', 'transitionprob']})
elif len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv', 'sz'), group_only_nodes=['sv', 'sz'],
depends_on={'v': ['coherence'], 'dc':['prevresp'], 'z':['prevresp']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv', 'sz'), group_only_nodes=['sv', 'sz'],
depends_on={'dc':['prevresp'], 'z':['prevresp']})
# ============================================ #
# PHARMA
# ============================================ #
elif model_name == 'stimcoding_dc_z_prevresp_pharma':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'dc':['prevresp', 'drug'], 'z':['prevresp', 'drug']})
elif model_name == 'stimcoding_dc_prevresp_sessions':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'dc':['prevresp', 'session']})
elif model_name == 'stimcoding_dc_z_prevresp_sessions':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'dc':['prevresp', 'session'], 'z':['prevresp', 'session']})
# ============================================ #
# STIMCODING PREVRESP + PREVCORRECT
# ============================================ #
elif model_name == 'stimcoding_dc_prevcorrect':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# also split by transition probability and include coherence-dependence of drift rate
if 'transitionprob' in mydata.columns:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'dc':['prevresp', 'prevcorrect', 'transitionprob']})
elif len(mydata.coherence.unique()) > 1:
print "splitting by coherence"
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'dc':['prevresp', 'prevcorrect']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'dc':['prevresp', 'prevcorrect']})
elif model_name == 'stimcoding_z_prevcorrect':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# also split by transition probability
if 'transitionprob' in mydata.columns:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'z':['prevresp', 'prevcorrect', 'transitionprob']})
elif len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'z':['prevresp', 'prevcorrect']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'z':['prevresp', 'prevcorrect']})
elif model_name == 'stimcoding_dc_z_prevcorrect':
# get the right variable coding
mydata = recode_4stimcoding(mydata)
# also split by transition probability
if 'transitionprob' in mydata.columns:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'dc':['prevresp', 'prevcorrect', 'transitionprob'],
'z':['prevresp', 'prevcorrect', 'transitionprob']})
elif len(mydata.coherence.unique()) > 1:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'v': ['coherence'], 'dc':['prevresp', 'prevcorrect'], 'z':['prevresp', 'prevcorrect']})
else:
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'],
depends_on={'dc':['prevresp', 'prevcorrect'], 'z':['prevresp', 'prevcorrect']})
# ============================================ #
# REGRESSION MODULATION
# Nienborg @ SfN: ((s*v) + vbias)dt / (s*(v+vbias))dt, does it matter and what are the differential predictions?
# ============================================ #
elif model_name == 'regress_dc_prevresp':
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus + prevresp:C(transitionprob) ', 'link_func': lambda x:x}
else:
v_reg = {'model': 'v ~ 1 + stimulus + prevresp', 'link_func': lambda x:x}
m = hddm.HDDMRegressor(mydata, v_reg,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
elif model_name == 'regress_dc2_prevresp':
v_reg = {'model': 'v ~ (1 + prevresp)*stimulus', 'link_func': lambda x:x}
m = hddm.HDDMRegressor(mydata, v_reg,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
# ============================================ #
# MODULATION BY PUPIL AND RT
# ============================================ #
elif model_name == 'regress_dc_prevresp_prevrt':
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus + C(transitionprob):prevresp + ' \
'C(transitionprob):prevrt + C(transitionprob):prevresp:prevrt', 'link_func': lambda x:x}
else:
v_reg = {'model': 'v ~ 1 + stimulus + prevresp*prevrt', 'link_func': lambda x:x}
m = hddm.HDDMRegressor(mydata, v_reg,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
# ================================================== #
# THE MOST IMPORTANT MODEL FOR THE UNCERTAINTY MODULATION
# ================================================== #
elif model_name == 'regress_dc_z_prevresp_prevrt':
mydata = mydata.dropna(subset=['prevresp','prevrt'])
# subselect data
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus + C(transitionprob):prevresp + ' \
'C(transitionprob):prevrt + C(transitionprob):prevresp:prevrt', 'link_func': lambda x:x}
z_reg = {'model': 'z ~ 1 + prevresp:C(transitionprob) +' \
'prevresp:prevrt:C(transitionprob) + prevrt:C(transitionprob)',
'link_func': z_link_func}
else:
v_reg = {'model': 'v ~ 1 + stimulus + prevresp*prevrt',
'link_func': lambda x:x}
z_reg = {'model': 'z ~ 1 + prevresp*prevrt',
'link_func': z_link_func}
reg_both = [v_reg, z_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
elif model_name == 'regress_dc_z_prevresp_prevstim_prevrt_prevpupil':
# subselect data
mydata = mydata.dropna(subset=['prevpupil'])
if len(mydata.session.unique()) < max(mydata.session.unique()):
mydata["session"] = mydata["session"].map({1:1, 5:2})
mydata = balance_designmatrix(mydata)
# boundary separation and drift rate will change over sessions
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus + ' \
'prevresp:C(transitionprob) + prevstim:C(transitionprob) + ' \
'prevresp:prevpupil:C(transitionprob) + prevstim:prevpupil:C(transitionprob) + ' \
'prevresp:prevrt:C(transitionprob) + prevstim:prevrt:C(transitionprob)',
'link_func': lambda x:x}
z_reg = {'model': 'z ~ 1 + prevresp:C(transitionprob) + prevstim:C(transitionprob) +' \
'prevresp:prevpupil:C(transitionprob) + prevstim:prevpupil:C(transitionprob) +' \
'prevresp:prevrt:C(transitionprob) + prevstim:prevrt:C(transitionprob)',
'link_func': z_link_func}
else:
v_reg = {'model': 'v ~ 1 + stimulus + prevresp + prevstim + ' \
'prevresp:prevrt + prevstim:prevrt + prevresp:prevpupil + prevstim:prevpupil',
'link_func': lambda x:x}
z_reg = {'model': 'z ~ 1 + prevresp + prevstim +' \
'prevresp:prevpupil + prevstim:prevpupil +' \
'prevresp:prevrt + prevstim:prevrt',
'link_func': z_link_func}
reg_both = [v_reg, z_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
# ============================================ #
# MULTIPLE LAGS
# ============================================ #
elif model_name == 'regress_dc_z_prev2resp':
if 'transitionprob' in mydata.columns:
z_reg = {'model': 'z ~ 1 + prevresp:C(transitionprob)+ prev2resp:C(transitionprob)',
'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + prevresp:C(transitionprob) + prev2resp:C(transitionprob)',
'link_func': lambda x:x}
else:
z_reg = {'model': 'z ~ 1 + prevresp + prev2resp ', 'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + prevresp + prev2resp ', 'link_func': lambda x:x}
reg_both = [z_reg, v_reg]
# subselect data
mydata = mydata.dropna(subset=['prev2resp'])
# specify that we want individual parameters for all regressors, see email Gilles 22.02.2017
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
elif model_name == 'regress_dc_z_prev3resp':
if 'transitionprob' in mydata.columns:
z_reg = {'model': 'z ~ 1 + prevresp:C(transitionprob) + prev2resp:C(transitionprob) + prev3resp:C(transitionprob)',
'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + prevresp:C(transitionprob) + prev2resp:C(transitionprob) + prev3resp:C(transitionprob)',
'link_func': lambda x:x}
else:
z_reg = {'model': 'z ~ 1 + prevresp + prev2resp + prev3resp ', 'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + prevresp + prev2resp + prev3resp ', 'link_func': lambda x:x}
reg_both = [z_reg, v_reg]
mydata = mydata.dropna(subset=['prev2resp', 'prev3resp'])
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
# ============================================ #
# RT AND PUPIL MODULATION onto DC
# ============================================ #
elif model_name == 'regress_dc_prevresp_prevstim_prevpupil':
# subselect data
mydata = mydata.dropna(subset=['prevpupil'])
if len(mydata.session.unique()) < max(mydata.session.unique()):
mydata["session"] = mydata["session"].map({1:1, 5:2})
mydata = balance_designmatrix(mydata)
# in Anke's data, vary both dc and z
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus + ' \
'prevresp:C(transitionprob) + prevstim:C(transitionprob) + ' \
'prevresp:prevpupil:C(transitionprob) + prevstim:prevpupil:C(transitionprob)',
'link_func': lambda x:x}
else:
v_reg = {'model': 'v ~ 1 + stimulus + prevresp + prevstim + ' \
'prevresp:prevpupil + prevstim:prevpupil', 'link_func': lambda x:x}
reg_both = [v_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
elif model_name == 'regress_dc_prevresp_prevstim_prevrt':
# subselect data
mydata = balance_designmatrix(mydata)
# boundary separation and drift rate will change over sessions
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus + ' \
'prevresp:C(transitionprob) + prevstim:C(transitionprob) + ' \
'prevresp:prevrt:C(transitionprob) + prevstim:prevrt:C(transitionprob)',
'link_func': lambda x:x}
else:
v_reg = {'model': 'v ~ 1 + stimulus + prevresp + prevstim + prevresp:prevrt + prevstim:prevrt',
'link_func': lambda x:x}
m = hddm.HDDMRegressor(mydata, v_reg,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=True, p_outlier=0.05)
elif model_name == 'regress_dc_prevresp_prevstim_prevrt_prevpupil':
# subselect data
mydata = mydata.dropna(subset=['prevpupil'])
if len(mydata.session.unique()) < max(mydata.session.unique()):
mydata["session"] = mydata["session"].map({1:1, 5:2})
mydata = balance_designmatrix(mydata)
# boundary separation and drift rate will change over sessions
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus + ' \
'prevresp:C(transitionprob) + prevstim:C(transitionprob) + ' \
'prevresp:prevpupil:C(transitionprob) + prevstim:prevpupil:C(transitionprob) + ' \
'prevresp:prevrt:C(transitionprob) + prevstim:prevrt:C(transitionprob)',
'link_func': lambda x:x}
else:
v_reg = {'model': 'v ~ 1 + stimulus + prevresp + prevstim + ' \
'prevresp:prevrt + prevstim:prevrt + prevresp:prevpupil + prevstim:prevpupil',
'link_func': lambda x:x}
m = hddm.HDDMRegressor(mydata, v_reg,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=True, p_outlier=0.05)
# ============================================ #
# LEARNING EFFECTS, V AND A CHANGE WITH SESSION
# ============================================ #
elif model_name == 'regress_dc_z_prevresp_prevstim_prevpupil':
# subselect data
mydata = mydata.dropna(subset=['prevpupil'])
if len(mydata.session.unique()) < max(mydata.session.unique()):
mydata["session"] = mydata["session"].map({1:1, 5:2})
mydata = balance_designmatrix(mydata)
# in Anke's data, vary both dc and z
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus + ' \
'prevresp:C(transitionprob) + prevstim:C(transitionprob) + ' \
'prevresp:prevpupil:C(transitionprob) + prevstim:prevpupil:C(transitionprob)',
'link_func': lambda x:x}
z_reg = {'model': 'z ~ 1 + prevresp:C(transitionprob) + prevstim:C(transitionprob) +' \
'prevresp:prevpupil:C(transitionprob) + prevstim:prevpupil:C(transitionprob)',
'link_func': z_link_func}
else:
v_reg = {'model': 'v ~ 1 + stimulus + prevresp + prevstim + ' \
'prevresp:prevpupil + prevstim:prevpupil',
'link_func': lambda x:x}
z_reg = {'model': 'z ~ 1 + prevresp + prevstim +' \
'prevresp:prevpupil + prevstim:prevpupil',
'link_func': z_link_func}
reg_both = [v_reg, z_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=True, p_outlier=0.05)
# ============================================ #
# SESSION DEPENDENCE
# ============================================ #
elif model_name == 'regress_dc_prevresp_prevstim_vasessions':
# subselect data
mydata = balance_designmatrix(mydata)
# boundary separation and drift rate will change over sessions
a_reg = {'model': 'a ~ 1 + C(session)', 'link_func': lambda x:x} # boundary separation as a function of sessions
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus:C(session) + prevresp:C(transitionprob) + prevstim:C(transitionprob)', 'link_func': lambda x:x}
else:
v_reg = {'model': 'v ~ 1 + stimulus:C(session) + prevresp + prevstim', 'link_func': lambda x:x}
reg_both = [v_reg, a_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=True, p_outlier=0.05)
elif model_name == 'regress_dc_z_prevresp_prevstim_vasessions':
# subselect data
mydata = balance_designmatrix(mydata)
# boundary separation and drift rate will change over sessions
a_reg = {'model': 'a ~ 1 + C(session)', 'link_func': lambda x:x} # boundary separation as a function of sessions
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus:C(session) + prevresp:C(transitionprob) + prevstim:C(transitionprob)', 'link_func': lambda x:x}
z_reg = {'model': 'z ~ 1 + prevresp:C(transitionprob) + prevstim:C(transitionprob)', 'link_func': z_link_func}
reg_both = [v_reg, a_reg, z_reg]
else:
v_reg = {'model': 'v ~ 1 + stimulus:C(session) + prevresp + prevstim', 'link_func': lambda x:x}
z_reg = {'model': 'z ~ 1 + prevresp+ prevstim', 'link_func': z_link_func}
reg_both = [v_reg, a_reg, z_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=True, p_outlier=0.05)
elif model_name == 'regress_dc_prevresp_prevstim_vasessions_prevrespsessions':
# subselect data
mydata = balance_designmatrix(mydata)
# boundary separation and drift rate will change over sessions
if 'transitionprob' in mydata.columns:
raise ValueError('Do not fit session-specific serial bias on Anke''s data')
else:
v_reg = {'model': 'v ~ 1 + stimulus:C(session) + prevresp:C(session) + prevstim:C(session)', 'link_func': lambda x:x}
a_reg = {'model': 'a ~ 1 + C(session)', 'link_func': lambda x:x} # boundary separation as a function of sessions
reg_both = [v_reg, a_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=True, p_outlier=0.05)
elif model_name == 'regress_dc_prevresp_prevstim_vasessions_prevpupil':
# subselect data
mydata = mydata.dropna(subset=['prevpupil'])
if len(mydata.session.unique()) < max(mydata.session.unique()):
mydata["session"] = mydata["session"].map({1:1, 5:2})
mydata = balance_designmatrix(mydata)
# boundary separation and drift rate will change over sessions
a_reg = {'model': 'a ~ 1 + C(session)', 'link_func': lambda x:x}
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus:C(session) + ' \
'prevresp:C(transitionprob) + prevstim:C(transitionprob) + ' \
'prevresp:prevpupil:C(transitionprob) + prevstim:prevpupil:C(transitionprob)',
'link_func': lambda x:x}
else:
v_reg = {'model': 'v ~ 1 + stimulus:C(session) + prevresp + prevstim + ' \
'prevresp:prevpupil + prevstim:prevpupil',
'link_func': lambda x:x}
reg_both = [v_reg, a_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=True, p_outlier=0.05)
elif model_name == 'regress_dc_prevresp_prevstim_vasessions_prevrt':
# subselect data
mydata = balance_designmatrix(mydata)
# boundary separation and drift rate will change over sessions
a_reg = {'model': 'a ~ 1 + C(session)', 'link_func': lambda x:x}
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus:C(session) + ' \
'prevresp:C(transitionprob) + prevstim:C(transitionprob) + ' \
'prevresp:prevrt:C(transitionprob) + prevstim:prevrt:C(transitionprob)',
'link_func': lambda x:x}
else:
v_reg = {'model': 'v ~ 1 + stimulus:C(session) + prevresp + prevstim + prevresp:prevrt + prevstim:prevrt',
'link_func': lambda x:x}
reg_both = [v_reg, a_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=True, p_outlier=0.05)
elif model_name == 'regress_dc_prevresp_prevstim_vasessions_prevrt_prevpupil':
# subselect data
mydata = mydata.dropna(subset=['prevpupil'])
if len(mydata.session.unique()) < max(mydata.session.unique()):
mydata["session"] = mydata["session"].map({1:1, 5:2})
mydata = balance_designmatrix(mydata)
# boundary separation and drift rate will change over sessions
a_reg = {'model': 'a ~ 1 + C(session)', 'link_func': lambda x:x}
if 'transitionprob' in mydata.columns:
v_reg = {'model': 'v ~ 1 + stimulus:C(session) + ' \
'prevresp:C(transitionprob) + prevstim:C(transitionprob) + ' \
'prevresp:prevrt:C(transitionprob) + prevstim:prevrt:C(transitionprob) +' \
'prevresp:prevpupil:C(transitionprob) + prevstim:prevpupil:C(transitionprob)',
'link_func': lambda x:x}
else:
v_reg = {'model': 'v ~ 1 + stimulus:C(session) + prevresp + prevstim + ' \
'prevresp:prevrt + prevstim:prevrt + prevresp:prevpupil + prevstim:prevpupil',
'link_func': lambda x:x}
reg_both = [v_reg, a_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=True, p_outlier=0.05)
# ============================================ #
# MEG DATA
# ============================================ #
elif model_name == 'regress_nohist':
# only stimulus dependence
v_reg = {'model': 'v ~ 1 + stimulus', 'link_func': lambda x:x}
# specify that we want individual parameters for all regressors, see email Gilles 22.02.2017
m = hddm.HDDMRegressor(mydata, v_reg,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
elif model_name == 'regress_dc_z_prevresp':
if 'transitionprob' in mydata.columns:
z_reg = {'model': 'z ~ 1 + C(transitionprob):prevresp', 'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + C(transitionprob):prevresp', 'link_func': lambda x:x}
else:
z_reg = {'model': 'z ~ 1 + prevresp', 'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + prevresp', 'link_func': lambda x:x}
reg_both = [z_reg, v_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
elif model_name == 'regress_dc_z_visualgamma':
z_reg = {'model': 'z ~ 1 + visualgamma', 'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + visualgamma', 'link_func': lambda x:x}
reg_both = [z_reg, v_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
elif model_name == 'regress_dc_z_motorslope':
z_reg = {'model': 'z ~ 1 + motorslope', 'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + motorslope', 'link_func': lambda x:x}
reg_both = [z_reg, v_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
elif model_name == 'regress_dc_z_motorstart':
z_reg = {'model': 'z ~ 1 + motorbeta', 'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + motorbeta', 'link_func': lambda x:x}
reg_both = [z_reg, v_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
elif model_name == 'regress_dc_z_prevresp_visualgamma':
z_reg = {'model': 'z ~ 1 + prevresp + visualgamma', 'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + prevresp + visualgamma', 'link_func': lambda x:x}
reg_both = [z_reg, v_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
elif model_name == 'regress_dc_z_prevresp_motorslope':
z_reg = {'model': 'z ~ 1 + prevresp + motorslope', 'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + prevresp + motorslope', 'link_func': lambda x:x}
reg_both = [z_reg, v_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
elif model_name == 'regress_dc_z_prevresp_motorstart':
z_reg = {'model': 'z ~ 1 + prevresp + motorbeta', 'link_func': z_link_func}
v_reg = {'model': 'v ~ 1 + stimulus + prevresp + motorbeta', 'link_func': lambda x:x}
reg_both = [z_reg, v_reg]
m = hddm.HDDMRegressor(mydata, reg_both,
include=['z', 'sv'], group_only_nodes=['sv'],
group_only_regressors=False, keep_regressor_trace=False, p_outlier=0.05)
# ============================================ #
# END OF FUNCTION THAT CREATES THE MODEL
# ============================================ #
return m
dag = graph
#####################################################
# PLOT A GRAPHICAL REPRESENTATION OF THE HDDM MODEL
#####################################################
mypath = os.path.realpath(os.path.expanduser('~/Data/HDDM/NatComm'))
# get the csv file for this dataset
filename = fnmatch.filter(os.listdir(mypath), '*.csv')
mydata = hddm.load_csv(os.path.join(mypath, filename[0]))
# for stimcoding, the two identities should be 0 and 1
mydata.stimulus = np.sign(mydata.stimulus)
mydata.ix[mydata['stimulus']==-1,'stimulus'] = 0
if len(mydata.stimulus.unique()) != 2:
raise ValueError('Stimcoding needs 2 stimulus types')
# keep only one subject
mydata = mydata[mydata.subj_idx < 3]
print(mydata.head())
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True, p_outlier=0.05,
include=('sv'), group_only_nodes=['sv'])
model = m.mcmc()
# now plot
graph(model, format='png', prog='dot', path=mypath, name='HDDMgraph', consts=False, legend=False,
collapse_deterministics = True, collapse_potentials = True, label_edges=True)
print('done!')
shell()
print(total_outliers)
# Create separate datasets for the face (1) and both (2) tasks
mydata_both = mydata
# I fit the baseline and state models to both the both and faces tasks separately here.
# I save the states, traces and traceplots.
# For the two state models I added in some code for the posterior plots by condition.
# PPC is a little more involved and is better to do when we've decided on a final set of models
#----------------------------------------#
# Digits - Model 1 (baseline)
model_both_1 = hddm.HDDMStimCoding(mydata_both,
include={'z'},
stim_col='stim',
split_param='z',
depends_on={'v': ['Task', 'stim']},
p_outlier=.05)
model_both_1.find_starting_values() # Create model and start MCMC sampling
model_both_1.sample(2000,
burn=1000,
dbname=os.path.join(modelpath,
'Both/Model_1/model_both_1_traces.db'),
db='pickle')
model_both_1.save(os.path.join(modelpath, 'Both/Model_1/model_both_1'))
# Extract stats
model_both_1_stats = model_both_1.gen_stats()
model_both_1_stats.to_csv(
os.path.join(modelpath, 'Both/Model_1/model_both_1_stats.csv'))
xlabel='RT',
ylabel='count',
title='RT distributions')
for i, subj_data in data.groupby('subj_idx'):
subj_data.rt.hist(bins=20, histtype='step', ax=ax)
plt.savefig('fMRI_rt.pdf')
#
#
dmatrix("C(stim,Treatment(1))", data.head(10))
m_stim = hddm.HDDMStimCoding(data,
include='z',
stim_col='stim',
split_param='z',
depends_on={
'v': 'response',
'a': 'response',
't': 'response'
},
p_outlier=0.05)
m_stim.find_starting_values()
m_stim.sample(100, burn=5)
m_stim.plot_posteriors(['a', 't', 'v', 'a_std'])
m_stim.plot_posterior_predictive(figsize=(18, 5))
v_correct, v_incorrect = m_stim.nodes_db.node[['v(0)', 'v(1)']]
hddm.analyze.plot_posterior_nodes([v_correct, v_incorrect])
plt.xlabel('drift-rate')
plt.ylabel('Posterior probability')
plt.title('Posterior of drift-rate group means')
## Extract full chains, transform back z and get v bias
#model_face_1_traces = model_face_1.get_group_traces()
#model_face_1_traces['z'] = np.exp(model_face_1_traces['z_trans'])/(1+np.exp(model_face_1_traces['z_trans']))
#model_face_1_traces['v_bias'] = abs(model_face_1_traces['v(1)'])-abs(model_face_1_traces['v(0)'])
#model_face_1_traces.to_csv(os.path.join(modelpath,'Faces/Model_1/model_face_1_traces.csv'))
#
#----------------------------------------#
# Faces - Model 2 (state)
model_face_2 = hddm.HDDMStimCoding(mydata_face,
include={'z'},
stim_col='stim',
split_param='z',
depends_on={
'v': ['stim', 'State'],
'a': 'State',
'z': 'State',
't': 'State'
},
p_outlier=.05)
model_face_2.find_starting_values()
model_face_2.sample(100,
burn=50,
dbname=os.path.join(modelpath,
'Faces/Model_2/model_face_2.db'),
db='pickle')
#model_face_2.save(os.path.join(modelpath,'Faces/Model_2/model_face_2'))
# Extract stats
model_face_2_stats = model_face_2.gen_stats()
title='RT distributions')
for i, subj_data in data.groupby(['state']):
subj_data.rt.hist(bins=50, histtype='step', ax=ax)
#plt.savefig('hddm_RThists_bysubj.pdf')
dataD = data[data.task == 2]
dataF = data[data.task == 1]
# HDDMStimCoding Model Subclass enables you to specify your bounds as go/no-go, as opposed to correct/incorrect. This allows the estimation of both z bias and v bias.
# Code below fits the full model where session (condition) influences all parameters, tends to have the lowest DIC.
modelD = hddm.HDDMStimCoding(dataD,
include={'z'},
stim_col='stimulus',
split_param='z',
depends_on={
'v': 'cond_v',
'a': 'state',
'z': 'state'
},
p_outlier=.05)
modelD.find_starting_values() # Create model and start MCMC sampling
modelD.sample(5000, burn=200, dbname='hddm_stim.db', db='pickle')
#model.save('hddm_stim')
modelD.print_stats()
modelD.plot_posteriors(save=False)
modelD.plot_posterior_predictive()
modelD.plot_posteriors_conditions()
# HDDMStimCoding Model Subclass enables you to specify your bounds as go/no-go, as opposed to correct/incorrect. This allows the estimation of both z bias and v bias.
# Code below fits the full model where session (condition) influences all parameters, tends to have the lowest DIC.
def run_model(model_name, trace_id, nr_samples=10000):
import hddm, os
import matplotlib.pyplot as plt
# find path depending on local/klimag
usr = os.environ.get('USER')
if usr in ['anne']:
mypath = '/Users/anne/Data/projects/0/neurodec/Data/MEG-PL/Data/HDDM'
if usr in ['aurai']:
mypath = '/home/aurai/Data/MEG-PL/Data/HDDM'
# make a folder for the outputs, combine name and time
thispath = os.path.join(mypath, model_name)
if not os.path.exists(thispath):
os.mkdir(thispath)
# get the csv
mydata = hddm.load_csv(os.path.join(mypath, '2ifc_data_hddm.csv'))
# specify the model
m = hddm.HDDMStimCoding(mydata,
stim_col='stimulus',
split_param='v',
drift_criterion=True,
bias=True,
include=('sv'),
group_only_nodes=['sv'],
depends_on={
't': ['sessionnr'],
'v': ['sessionnr'],
'a': ['sessionnr'],
'dc': ['sessionnr', 'prevresp'],
'z': ['sessionnr']
},
p_outlier=.05)
# ============================================ #
# do the actual sampling
# ============================================ #
model_filename = os.path.join(thispath, 'modelfit-md%d' % trace_id)
m.sample(nr_samples,
burn=nr_samples / 4,
thin=3,
db='pickle',
dbname=model_filename)
m.save(model_filename) # save the model as pickle
# ============================================ #
# save the output values
# ============================================ #
results = m.gen_stats() # this seems different from print_stats??
results.to_csv(os.path.join(thispath, 'results-md%d.csv' % trace_id))
# save the DIC for this model
text_file = open(os.path.join(thispath, 'DIC-md%d.txt' % trace_id), 'w')
text_file.write("Model {}: {}\n".format(trace_id, m.dic))
text_file.close()
return m
def run_model(id):
from patsy import dmatrix
from pandas import Series
import numpy as np
import hddm
dataHDDM = hddm.load_csv('DDM/dataHDDM_pmt.csv')
dataHDDM["subj_idx"] = dataHDDM["participant"]
del dataHDDM["participant"]
dataHDDM["givenResp"] = dataHDDM["response"]
dataHDDM["stim"] = dataHDDM.apply(lambda row: 1
if row['stim'] == 'Right' else 0,
axis=1)
dataHDDM["response"] = dataHDDM.apply(
lambda row: 1 if row['givenResp'] == 'Right' else 0, axis=1)
if id < 4:
############## M1
deps = {
'sz': 'SAT',
'v': 'contrast',
't': ['contrast', 'SAT', 'FC'],
'a': 'SAT'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M1"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 3 and id < 8:
############## M2
deps = {
'sz': 'SAT',
'v': ['contrast', 'SAT'],
't': ['contrast', 'SAT', 'FC'],
'a': 'SAT'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M2"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 7 and id < 12:
############## M3
deps = {
'sz': 'SAT',
'v': ['contrast', 'FC'],
't': ['contrast', 'SAT', 'FC'],
'a': 'SAT'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M3"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 11 and id < 16:
############## M4
deps = {
'sz': 'SAT',
'v': ['contrast', 'SAT', 'FC'],
't': ['contrast', 'SAT', 'FC'],
'a': 'SAT'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M4"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 15 and id < 20:
############## M5
deps = {
'sz': 'SAT',
'v': 'contrast',
't': ['contrast', 'SAT', 'FC'],
'a': ['SAT', 'FC']
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M5"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 19 and id < 24:
############## M6
deps = {
'sz': 'SAT',
'v': ['contrast', 'SAT'],
't': ['contrast', 'SAT', 'FC'],
'a': ['SAT', 'FC']
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M6"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 23 and id < 28:
############## M7
deps = {
'sz': 'SAT',
'v': ['contrast', 'FC'],
't': ['contrast', 'SAT', 'FC'],
'a': ['SAT', 'FC']
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M7"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 27 and id < 32:
############## M8
deps = {
'sz': 'SAT',
'v': ['contrast', 'SAT', 'FC'],
't': ['contrast', 'SAT', 'FC'],
'a': ['SAT', 'FC']
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M8"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 31 and id < 36:
############## M9
deps = {
'sz': 'SAT',
'v': 'contrast',
't': ['contrast', 'SAT', 'FC'],
'a': 'SAT',
'z': 'FC'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M9"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 35 and id < 40:
############## M10
deps = {
'sz': 'SAT',
'v': ['contrast', 'SAT'],
't': ['contrast', 'SAT', 'FC'],
'a': 'SAT',
'z': 'FC'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M10"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 39 and id < 44:
############## M11
deps = {
'sz': 'SAT',
'v': ['contrast', 'FC'],
't': ['contrast', 'SAT', 'FC'],
'a': 'SAT',
'z': 'FC'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M11"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 43 and id < 48:
############## M12
deps = {
'sz': 'SAT',
'v': ['contrast', 'SAT', 'FC'],
't': ['contrast', 'SAT', 'FC'],
'a': 'SAT',
'z': 'FC'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M12"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 47 and id < 52:
############## M13
deps = {
'sz': 'SAT',
'v': 'contrast',
't': ['contrast', 'SAT', 'FC'],
'a': ['SAT', 'FC'],
'z': 'FC'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M13"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 51 and id < 56:
############## M14
deps = {
'sz': 'SAT',
'v': ['contrast', 'SAT'],
't': ['contrast', 'SAT', 'FC'],
'a': ['SAT', 'FC'],
'z': 'FC'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M14"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 55 and id < 60:
############## M15
deps = {
'sz': 'SAT',
'v': ['contrast', 'FC'],
't': ['contrast', 'SAT', 'FC'],
'a': ['SAT', 'FC'],
'z': 'FC'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M15"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
elif id > 59:
############## M16
deps = {
'sz': 'SAT',
'v': ['contrast', 'SAT', 'FC'],
't': ['contrast', 'SAT', 'FC'],
'a': ['SAT', 'FC'],
'z': 'FC'
}
inc = ['z', 'sv', 'sz', 'st']
model_name = "M16"
m = hddm.HDDMStimCoding(dataHDDM,
depends_on=deps,
include=inc,
group_only_nodes=['sv', 'sz', 'st', "sz_SAT"],
split_param='v',
stim_col="stim")
else:
return np.nan()
name = 'light_PMT_%s_%s' % (model_name, str(id))
m.find_starting_values()
m.sample(iter=10000,
burn=8500,
thin=1,
dbname='DDM/traces/db_%s' % name,
db='pickle')
m.save('DDM/Fits/%s' % name)
return m
def fit_ddm(df, model_settings, model_dir, model_name, subj_idx=None, samples=5000, burn=1000, thin=1, model_id=0, n_runs=5):
# fix depends_on:
depends_on = model_settings['depends_on']
if depends_on is not None:
if 'b' in depends_on:
depends_on['dc'] = depends_on['b']
depends_on.pop('b', None)
depends_on.pop('u', None)
depends_on = {k: v for k, v in depends_on.items() if v is not None}
if model_settings['fit'] == 'hddm':
m = hddm.HDDMStimCoding(df, stim_col='stimulus', split_param='v', drift_criterion=True, bias=True,
# depends_on=depends_on, include=('sv'), group_only_nodes=['sv'], p_outlier=0)
depends_on=depends_on, p_outlier=0)
# fit:
m.find_starting_values()
m.sample(samples, burn=burn, thin=thin, dbname=os.path.join(model_dir, '{}_{}.db'.format(model_name, model_id)), db='pickle')
m.save(os.path.join(model_dir, '{}_{}.hddm'.format(model_name, model_id)))
# params:
params = m.gen_stats()['mean'].reset_index()
params.columns = ['variable', 'value']
params = params.loc[['subj' in p for p in params['variable']],:]
params['subj_idx'] = [p.split('.')[-1] for p in params['variable']]
params['subj_idx'] = params['subj_idx'].astype(int)
params['variable'] = [p.replace('_subj', '') for p in params['variable']]
params['variable'] = [p.replace('(', '') for p in params['variable']]
params['variable'] = [p.replace(')', '') for p in params['variable']]
params['variable'] = [p.split('.')[0] for p in params['variable']]
params = params.pivot(index='subj_idx', columns='variable')
params.columns = params.columns.droplevel(level=0)
params.columns.name = None
params = params.reset_index()
params = params.sort_values(by=['subj_idx'])
elif model_settings['fit'] == 'hddm_q':
# quantiles=[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9]
quantiles=[0.1, 0.3, 0.5, 0.7, 0.9]
m = hddm.HDDMStimCoding(df, stim_col='stimulus', split_param='v', drift_criterion=True, bias=True,
# depends_on=depends_on, include=('sv'), group_only_nodes=['sv'], p_outlier=0)
depends_on=depends_on, p_outlier=0)
# starting values:
if sum(np.isnan(df.loc[df['response']==0, 'rt'])) == sum(df['response']==0):
# pass
print('finding starting values via basic model!')
basic_m = hddm.HDDMStimCoding(df, stim_col='stimulus', split_param='v', drift_criterion=True, bias=True, p_outlier=0)
# basic_m = hddm.HDDMStimCoding(df, stim_col='stimulus', split_param='v', drift_criterion=False, bias=False, p_outlier=0)
basic_m.optimize('chisquare', quantiles=quantiles, n_runs=n_runs)
values_m = m.values
names = []
best_values = []
for v in ['v', 'a', 't', 'dc', 'z_trans', 'z',]:
# for v in ['v', 'a', 't', 'z_trans', 'z',]:
# for v in ['v', 'a', 't']:
values_to_set = []
for p in m.values:
if '{}'.format(v) == p:
values_to_set.append(p)
elif '{}('.format(v) in p:
values_to_set.append(p)
for p in values_to_set:
try:
values_m[p] = basic_m.values['{}'.format(v)]
names.append(p)
best_values.append( basic_m.values['{}'.format(v)])
except:
pass
try:
m.set_values(dict(list(zip(names, best_values))))
except:
pass
else:
m.approximate_map()
print(m.values)
# fit:
# m.map()
# print(m.values)
m.optimize('gsquare', quantiles=quantiles, n_runs=n_runs)
# params:
params = pd.concat((pd.DataFrame([m.values]), pd.DataFrame([m.bic_info])), axis=1)
params['subj_idx'] = subj_idx
params.columns = [p.replace('(', '') for p in params.columns]
params.columns = [p.replace(')', '') for p in params.columns]
# fix columns:
params.columns = [p if not 'dc' else p.replace('dc', 'b') for p in params.columns]
params = params.loc[:, [p is not 'z_trans' for p in params.columns]]
# fix values:
params.loc[:, [p[0]=='a' for p in params.columns]] = params.loc[:, [p[0]=='a' for p in params.columns]] / 2
params['noise'] = 1
params['umixturecoef'] = 0
return params
# Create histogram of RTs by subject, looks odd due to dummy coding of nogo response.
data = hddm.utils.flip_errors(data)
fig = plt.figure()
ax = fig.add_subplot(111, xlabel='RT', ylabel='count', title='RT distributions')
for i, subj_data in data.groupby(['session']):
subj_data.rt.hist(bins=20, histtype='step', ax=ax)
plt.savefig('hddm_RThists_bysubj.pdf')
# HDDMStimCoding Model Subclass enables you to specify your bounds as go/no-go, as opposed to correct/incorrect. This allows the estimation of both z bias and v bias.
# Code below fits the full model where session (condition) influences all parameters, tends to have the lowest DIC.
model = hddm.HDDMStimCoding(data, include={'z'}, stim_col= 'stimulus', split_param='z', depends_on={'v': 'cond_v', 'a': 'session', 't': 'session', 'z': 'session'}, p_outlier=.05)
model.find_starting_values()# Create model and start MCMC sampling
model.sample(30000, burn=10000, thin=2, dbname='hddm_stimZ&v_gonogo.db', db='pickle')
model.save('hddm_stimZ&v_gonogo')
model.print_stats()
# Plot posterior distributions and theoretical RT distributions
model.plot_posteriors(save=False)
model.plot_posterior_predictive()
model.plot_posteriors_conditions()
# Plot posterior probabilities for parameters and determine overlap
z_1, z_2 = model.nodes_db.node[['z(1)', 'z(2)']]
hddm.analyze.plot_posterior_nodes([z_1, z_2])
hddm_data = pd.DataFrame(
[
data.RT.values, (data.response + 1) / 2,
(stim + 1) / 2, sub * np.ones(data.shape[0]), data.easy.values
],
index=['rt', 'response', 'stim', 'subj_idx', 'easy']).T
hddm_data = hddm_data.astype(
dict(rt=float, response=int, subj_idx=int, stim=int, easy=bool))
#%% create and sample from model
model = hddm.HDDMStimCoding(hddm_data,
bias=bias,
stim_col='stim',
split_param='v',
depends_on=depends_on,
p_outlier=p_outlier,
is_group_model=False)
# produced error when called with bias=True
#model.find_starting_values()
model.sample(S, burn=B)
samples = model.get_traces()
samples.index = pd.MultiIndex.from_arrays(
[np.full(S - B, sub), samples.index], names=['subject', 'sample'])
with pd.HDFStore(resfile, mode='a', complib='blosc', complevel=7) as store:
store.append('samples', samples)
# # Extract full chains, transform back z and get v bias
# model_W_traces = model_W.get_group_traces()
# model_W_traces['z(0)'] = np.exp(model_W_traces['z_trans(0)'])/(1+np.exp(model_W_traces['z_trans(0)']))
# model_W_traces['z(1)'] = np.exp(model_W_traces['z_trans(1)'])/(1+np.exp(model_W_traces['z_trans(1)']))
# model_W_traces['v_bias(0)'] = abs(model_W_traces['v(0.1)'])-abs(model_W_traces['v(0.0)'])
# model_W_traces['v_bias(1)'] = abs(model_W_traces['v(1.1)'])-abs(model_W_traces['v(1.0)'])
# tracename = 'Both/model_SW/model_' + ColNames[nE] + '_traces.csv'
# model_W_traces.to_csv(os.path.join(modelpath,tracename))
# Face - Model 2 (SW)
model_W = hddm.HDDMStimCoding(mydata_face,
include={'z'},
stim_col='stim',
split_param='z',
depends_on={
'v': ['stim', ColNames[nE]],
'a': ColNames[nE],
'z': ColNames[nE],
't': ColNames[nE]
},
p_outlier=.05)
model_W.find_starting_values()
model_W.sample(200,
burn=100,
dbname=os.path.join(modelpath, 'Faces/model_SW/model_W.db'),
db='pickle')
modelname = 'Faces/model_SW/model_' + ColNames[nE]
#model_W.save(os.path.join(modelpath,modelname))
# Extract stats
model_W_stats = model_W.gen_stats()
statsname = 'Faces/model_SW/model_' + ColNames[nE] + '_stats.csv'
def test_HDDMStimCoding(self):
params_full, params = hddm.generate.gen_rand_params(cond_dict={
"v": [-1, 1],
"z": [0.8, 0.4]
})
data, params_subj = hddm.generate.gen_rand_data(params=params_full,
size=10)
m = hddm.HDDMStimCoding(data, stim_col="condition", split_param="v")
m.sample(self.iter, burn=self.burn)
self.assertIsInstance(m.nodes_db.loc["wfpt(c1)"]["node"].parents["v"],
pm.Normal)
self.assertIsInstance(
m.nodes_db.loc["wfpt(c0)"]["node"].parents["v"],
pm.PyMCObjects.Deterministic,
)
self.assertIsInstance(
m.nodes_db.loc["wfpt(c0)"]["node"].parents["v"].parents["self"],
pm.Normal)
m = hddm.HDDMStimCoding(data, stim_col="condition", split_param="z")
m.sample(self.iter, burn=self.burn)
self.assertIsInstance(
m.nodes_db.loc["wfpt(c1)"]["node"].parents["z"],
pm.CommonDeterministics.InvLogit,
)
self.assertIsInstance(
m.nodes_db.loc["wfpt(c0)"]["node"].parents["z"],
pm.PyMCObjects.Deterministic,
)
self.assertIsInstance(
m.nodes_db.loc["wfpt(c0)"]["node"].parents["z"].parents["a"], int)
self.assertIsInstance(
m.nodes_db.loc["wfpt(c0)"]["node"].parents["z"].parents["b"],
pm.CommonDeterministics.InvLogit,
)
m = hddm.HDDMStimCoding(data,
stim_col="condition",
split_param="v",
drift_criterion=True)
m.sample(self.iter, burn=self.burn)
self.assertIsInstance(
m.nodes_db.loc["wfpt(c1)"]["node"].parents["v"],
pm.PyMCObjects.Deterministic,
)
self.assertEqual(
m.nodes_db.loc["wfpt(c1)"]
["node"].parents["v"].parents["a"].__name__, "v")
self.assertEqual(
m.nodes_db.loc["wfpt(c1)"]
["node"].parents["v"].parents["b"].__name__, "dc")
self.assertIsInstance(
m.nodes_db.loc["wfpt(c0)"]["node"].parents["v"],
pm.PyMCObjects.Deterministic,
)
self.assertIsInstance(
m.nodes_db.loc["wfpt(c0)"]["node"].parents["v"].parents["a"],
pm.PyMCObjects.Deterministic,
)
self.assertIsInstance(
m.nodes_db.loc["wfpt(c0)"]["node"].parents["v"].parents["b"],
pm.Normal)
self.assertIsInstance(
m.nodes_db.loc["wfpt(c0)"]
["node"].parents["v"].parents["a"].parents["self"],
pm.Normal,
)
def run_model(trace_id):
import os, pickle, sys, time, hddm
model_name = 'basic_stimcoding'
nsamples = 10000 # 50.000 for real results?
# find path depending on local/klimag
usr = os.environ.get('USER')
if usr in ['anne']:
mypath = '/Users/anne/Data/projects/0/neurodec/Data/MEG-PL/Data/HDDM'
if usr in ['aurai']:
mypath = '/home/aurai/Data/MEG-PL/Data/HDDM'
# make a folder for the outputs, combine name and time
# currentTime = datetime.now().strftime('%Y-%m-%d-%H-%M-%S')
# thispath = os.path.join(mypath, model_name + '_' + currentTime)
thispath = os.path.join(mypath, model_name)
if not os.path.exists(thispath):
os.mkdir(thispath)
# ============================================ #
# load in data
# ============================================ #
mydata = hddm.load_csv(os.path.join(mypath, '2ifc_data_hddm.csv'))
# specify the model
m = hddm.HDDMStimCoding(mydata, stim_col='stimulus', split_param='v',
drift_criterion=True, bias=True,
include=('sv'), group_only_nodes=['sv'],
depends_on={'t':['sessionnr'], 'v':['sessionnr'],
'a':['sessionnr'], 'dc':['sessionnr'], 'z':['sessionnr']},
p_outlier=.05)
# ============================================ #
# do the actual sampling
# ============================================ #
model_filename = os.path.join(thispath, 'modelfit-md%d'%trace_id)
m.sample(nsamples, burn=nsamples/4, thin=3, db='pickle',
dbname=model_filename)
m.save(model_filename) # save the model, see if this works with pickle
# ============================================ #
# save the output values
# ============================================ #
results = m.gen_stats()
results.to_csv(os.path.join(thispath, 'results-md%d.csv'%trace_id))
# save the DIC for this model
text_file = open(os.path.join(thispath, 'DIC-md%d.txt'%trace_id), 'w')
text_file.write("Model {}: {}\n".format(trace_id, m.dic))
text_file.close()
# plot some output stuff in figures subfolder
figpath = os.path.join(thispath, 'figures-md%d'%trace_id)
if not os.path.exists(figpath):
os.mkdir(figpath)
m.plot_posteriors(save=True, path=figpath, format='pdf')
import warnings # suppress the warnings
warnings.simplefilter('ignore')
nsample = 20000 # number of sampling
nburn = 3000 # number of burn
nchain = 1 # number of chain
dateToday = str(date.today())
#### model 1 for valence based categorization, free v,t,z
dbname = "M_Categ_val_vtz_s_" + dateToday + '_Chain_' + str(i + 2) + '.db'
M_Categ_val_vtz_s = hddm.HDDMStimCoding(dat_M_Categ_val,
include='z',
stim_col='stim',
depends_on={
'v': ['val', 'id'],
't': ['val', 'id'],
'z': ['val', 'id']
},
split_param='v',
drift_criterion=True)
M_Categ_val_vtz_s.find_starting_values()
M_Categ_val_vtz_s.sample(nsample, burn=nburn, dbname=dbname, db='pickle')
# save the model
M_Categ_val_vtz_s.save("M_Categ_val_vtz_s_" + dateToday + '_Chain_' +
str(i + 2))
#M_Categ_val_vtz = hddm.load("M_Categ_val_vtz_s_" + dateToday + '_Chain_' + str(i + 2))
## ppc
ppc_data_val_vtz_s = hddm.utils.post_pred_gen(M_Categ_val_vtz_s)
ppc_compare_val_vtz_s = hddm.utils.post_pred_stats(
