def matlab_comparison():
from scipy import io as io
from matplotlib import pyplot as plt
import kernels as ke
aux = io.loadmat('mat_py_comp.mat')
model = KnownVarPerfectInference(model_var_t=aux['sigma'][0][0]**2,model_var_d=aux['sigma'][0][0]**2,\
prior_mu_t=aux['pr_mu_t'][0][0],prior_mu_d=aux['pr_mu_d'][0][0],prior_va_t=aux['pr_va_t'][0][0],prior_va_d=aux['pr_va_d'][0][0],\
ISI=aux['ISI'][0][0])
model.set_symmetric_threshold(aux['threshold'][0][0])
target = aux['target']
distractor = aux['distractor']
mat_ret = aux['ret']
#~ def dprime_criteria(post_mu_t,post_mu_d,post_va_t,post_va_d):
#~ return post_mu_t/np.sqrt(post_va_t)-post_mu_d/np.sqrt(post_va_d)
#~
#~ def dprime_var_criteria(post_mu_t,post_mu_d,post_va_t,post_va_d):
#~ return post_mu_t/post_va_t-post_mu_d/post_va_d
#~ model.criteria = dprime_criteria
py_ret,criterium = model.batchInference(target,distractor,returnCriteria=True)
equal = False
if np.all(np.isnan(mat_ret)==np.isnan(py_ret)):
mat_temp = mat_ret[np.logical_not(np.isnan(mat_ret))]
py_temp = py_ret[np.logical_not(np.isnan(py_ret))]
if np.all(np.abs(py_temp-mat_temp)<1e-12):
equal = True
print "Got equal results in python and matlab? ",equal
fluctuations = np.transpose(np.array([aux['tfluct'],aux['dfluct']]),(1,0,2))
selection = 1-py_ret[:,1]
#~ selection[np.isnan(selection)] = 1
py_dk,_,py_dks,_ = ke.kernels(fluctuations,selection,np.ones_like(selection))
print "Got equal kernels in python and matlab? ",True if (np.sum(np.abs(py_dk-aux['dk']))<1e-12 and np.sum(np.abs(py_dks-aux['dks']))<1e-12) else False
plt.figure
plt.subplot(211)
plt.imshow(criterium[:,1:]-aux['dprime'],aspect='auto',interpolation='none')
plt.title("Difference between the criteria for every trial and time step")
plt.colorbar()
plt.subplot(212)
plt.imshow(py_ret-mat_ret,aspect='auto',interpolation='none')
plt.title("Difference between the python and matlab result matrices for every trial")
plt.colorbar()
plt.figure()
plt.subplot(211)
plt.plot(py_dk.T-aux['dk'].T)
plt.title('Decision kernel difference')
plt.subplot(212)
plt.plot(py_dks.T-aux['dks'].T)
plt.title('Decision kernel std difference')
plt.show()
def __init__(self,X,Y,kernel=None,set_type=1):
"""
Gaussian Process
"""
self.N,self.Ydim=Y.shape
self.setX(X,set_type)
self.setY(Y,set_type)
if kernel==None:
self.kernel=kernels(-1,-np.ones(self.Xdim))
#self.kernel=kernels(-1,-np.ones(self.Xdim),-2.3)
else:
self.kernel=kernel
self.parameter_prior_widths = np.ones(self.kernel.nparams+1)
self.beta=0.1
self.update()
self.n2ln2pi = 0.5*self.Ydim*self.N*np.log(2*np.pi)
def __init__(self,basedir=".",mode="initial",kernel=0):
self.basedir = basedir
self.mode = mode
self.cores = multiprocessing.cpu_count()
self.wrapper = wrappers.gromacswrapper()
self.distparser = parser.gdistparser()
self.filesystem = filesystem.filesystem()
self.helper = helpers.helpers()
self.kernels = kernels.kernels(kernel)
self.qsubsystem = qsubsystem.qsubsystem()
#Initialize the logger
if kernel=="head":
self.log = gtpslogging.log("info",basedir,kernel)
else:
self.log = gtpslogging.log("debug",basedir,kernel)
self.log.log.debug("logfile created")
self.log.log.info(str(self.cores) + " CPUs detected")
self.kernels.readKernelOptions(os.path.join(basedir,"options","kerneloptions.txt"))
#read the stables states from a file
self.stablestates.readStates(os.path.join(basedir,"options","stablestates.txt"))
self.log.log.info("Read States : " + str(self.stablestates.states))
"""
This array holds all the information about the paths. Each trajectory consists of a
forward-part and a backward-part. The trajectory can either be a forward trajectory
or a backward trajectory. Forward trajectroies start in A.
"""
self.paths = []
self.npaths = 0
for i in range(self.kernels.ntps):
self.paths.append(pathdata.pathdata(i,basedir,mode,forward=True,forwardpart=True,interface=0))
self.paths.append(pathdata.pathdata(i,basedir,mode,forward=True,forwardpart=False,interface=0))
self.npaths += 1
self.kernels.generateKernelLists(self.npaths)
def analyze(fit_dir='fits/',save=False,savefname='inferences'):
if not fit_dir.endswith('/'):
fit_dir+='/'
files = sorted([f for f in os.listdir(fit_dir) if (f.endswith(".pkl") and f.startswith('Infere_'))])
figs = []
for f in files:
ff = open(fit_dir+f,'r')
(subject,fit_output) = pickle.load(ff)
ff.close()
if subject.id<=1:
print subject.name, subject.id
print subject.data_files
dat,t,d = subject.load_data()
inds = dat[:,1]<1000
dat = dat[inds]
t = np.mean(t[inds],axis=2)
d = np.mean(d[inds],axis=2)
rt_ind = np.floor(dat[:,1]/40)
fluctuations = np.transpose(np.array([t.T-dat[:,0],d.T-50]),(2,0,1))
rdk,rck,rdk_std,rck_std = ke.kernels(fluctuations,1-dat[:,2],dat[:,3]-1,locked_on_onset=False,RT_ind=rt_ind)
centered_ind = np.arange(rdk.shape[1],dtype=float)
rT = (centered_ind-t.shape[1]+1)*0.04
model = pe.KnownVarPerfectInference()
max_logp,ind_max,likelihood,perf = objective(fit_output['xopt'],model,dat[:,2],rt_ind,t,d,return_ind=True,return_likelihood=True,return_performance=True)
performance = perf[0]
performance_std = perf[1]
if not interactive_pyplot:
plt.ioff() # cma overrides original pyplot settings and if interactive mode was off, the plot is never displayed!
figs.append(plt.figure(figsize=(13,10)))
ax = plt.subplot(221)
plt.plot(rT,rdk[0],color='b',label='$D_{S}$')
plt.plot(rT,rdk[1],color='r',label='$D_{N}$')
plt.fill_between(rT,rdk[0]-rdk_std[0],rdk[0]+rdk_std[0],color='b',alpha=0.3,edgecolor=None)
plt.fill_between(rT,rdk[1]-rdk_std[1],rdk[1]+rdk_std[1],color='r',alpha=0.3,edgecolor=None)
plt.plot(rT[ind_max]*np.ones(2),ax.get_ylim(),'--k')
plt.ylabel('Decision kernel')
plt.subplot(223)
plt.plot([-1,1],np.mean(dat[:,2])*np.ones(2),'--k',label='Subject')
plt.errorbar(np.linspace(-1,1,performance.shape[0]), performance, yerr=performance_std,label="$\sigma=%1.2f$"%(fit_output['xopt'][0]))
plt.legend(loc=0)
plt.xlabel('T locked on RT [s]')
plt.ylabel('Performance')
ax = plt.subplot(122)
plt.plot(np.linspace(-1,1,likelihood.shape[0]),likelihood)
ylim = ax.get_ylim()
plt.plot(np.linspace(-1,1,likelihood.shape[0])[ind_max]*np.ones(2),ylim,'--k')
ax.set_ylim(ylim)
plt.xlabel('T locked on RT [s]')
plt.ylabel('Log likelihood')
sname = str(subject.id) if subject.id!=0 else 'all'
plt.suptitle('Subject '+sname)
#~ figs[-1].tight_layout()
if save:
from matplotlib.backends.backend_pdf import PdfPages
with PdfPages('../../figs/'+savefname+'.pdf') as pdf:
for fig in figs:
pdf.savefig(fig)
else:
plt.show()
def __init__(self,basedir=".",mode="initial",kernel=0):
self.basedir = basedir
self.mode = mode
self.cores = multiprocessing.cpu_count()
self.wrapper = wrappers.gromacswrapper()
self.distparser = parser.gdistparser()
self.filesystem = filesystem.filesystem()
self.interfaces = interfaces.interfaces()
self.orderparameters = orderparameters.orderparameters()
self.helper = helpers.helpers()
self.kernels = kernels.kernels(kernel)
self.qsubsystem = qsubsystem.qsubsystem()
#Initialize the logger
if kernel=="head":
self.log = gtpslogging.log("info",basedir,kernel)
elif kernel=="reverse":
self.log = gtpslogging.log("info",basedir,kernel)
else:
self.log = gtpslogging.log("info",basedir,kernel)
self.log.log.debug("logfile created")
self.log.log.info(str(self.cores) + " CPUs detected")
self.interfaces.readInterfaces(os.path.join(basedir,"options","interfaces.txt"))
self.log.log.info("Read Interfaces Forward : " + str(self.interfaces.interfaces[0]))
self.log.log.info("Read Interfaces Backward : " + str(self.interfaces.interfaces[1]))
self.kernels.readKernelOptions(os.path.join(basedir,"options","kerneloptions.txt"))
#read the stables states from a file
self.orderparameters.readOP(os.path.join(basedir,"options","orderparameters.txt"))
self.log.log.info("Read OP : " + str(self.orderparameters.op[0]))
"""
This array holds all the information about the paths. Each trajectory consists of a
forward-part and a backward-part. The trajectory can either be a forward trajectory
or a backward trajectory. Forward trajectroies start in A.
"""
self.paths = []
self.npaths = 0
for i in range(self.interfaces.ninterfaces[0]):
self.paths.append(pathdata.pathdata(i,basedir,mode,forward=True,forwardpart=True,interface=self.interfaces.interfaces[0][i]))
self.paths.append(pathdata.pathdata(i,basedir,mode,forward=True,forwardpart=False,interface=self.interfaces.interfaces[0][i]))
self.npaths += 1
for i in range(self.interfaces.ninterfaces[1]):
n = i + self.interfaces.ninterfaces[0]
self.paths.append(pathdata.pathdata(n,basedir,mode,forward=False,forwardpart=True,interface=self.interfaces.interfaces[1][i]))
self.paths.append(pathdata.pathdata(n,basedir,mode,forward=False,forwardpart=False,interface=self.interfaces.interfaces[1][i]))
self.npaths += 1
self.reversePaths = []
for rp in self.interfaces.reversepaths[0]:
self.reversePaths.append(pathdatareverse.pathdatareverse(0, basedir, mode, forward=True, forwardpart=True, interface=rp, state=0))
for rp in self.interfaces.reversepaths[1]:
self.reversePaths.append(pathdatareverse.pathdatareverse(0, basedir, mode, forward=True, forwardpart=True, interface=rp, state=1))
self.kernels.generateKernelLists(self.npaths)
self.interfacedir = int(float(self.paths[0].options.runoptions["interfacecoordinate"]))
print self.interfacedir
