def resolve(self):
t0 = time()
self.time = 0
while not self.balanced() and not self.force_end():
for a_id in permutation(self.nb_ants):
if self.ants[a_id].action(self.time):
continue
self.time += 1
if self.time % 100000 == 0:
self.verbose(1, 'Time: %d' % self.time)
self.verbose(1, 'Nb of uncontrolled sites: %d' %
self.uncontrolled)
sizes = [str(a.area_size) for a in self.ants]
self.verbose(1, 'Territories: %s' % ','.join(sizes))
if self.uncontrolled > 0:
delta_t = time() - self.tmark
duration = format_duration(delta_t)
delta_site = self.prev_uncontrolled - self.uncontrolled
self.verbose(1, '%d sites taken in %s'
% (delta_site, duration))
self.total_time += delta_t
speed = (self.nb_sites - self.uncontrolled) / \
self.total_time
expected_duration = self.uncontrolled / speed
self.verbose(1, '%s expected for complete control'
% (format_duration(expected_duration)))
self.prev_uncontrolled = self.uncontrolled
self.tmark = time()
self.verbose(1, 'Balloon partitioning done, took %s, %d iterations'
% (format_duration(time() - t0), self.time))
def resolve(self):
t0 = time()
self.time = 0
while not self.balanced() and not self.force_end():
for a_id in permutation(self.nb_ants):
if self.ants[a_id].action(self.time):
continue
self.time += 1
if self.time % 100000 == 0:
self.verbose(1, 'Time: %d' % self.time)
self.verbose(1, 'Nb of uncontrolled sites: %d' %
self.uncontrolled)
sizes = [str(a.area_size) for a in self.ants]
self.verbose(1, 'Territories: %s' % ','.join(sizes))
if self.uncontrolled > 0:
delta_t = time() - self.tmark
duration = format_duration(delta_t)
delta_site = self.prev_uncontrolled - self.uncontrolled
self.verbose(1, '%d sites taken in %s'
% (delta_site, duration))
self.total_time += delta_t
speed = (self.nb_sites - self.uncontrolled) / \
self.total_time
expected_duration = self.uncontrolled / speed
self.verbose(1, '%s expected for complete control'
% (format_duration(expected_duration)))
self.prev_uncontrolled = self.uncontrolled
self.tmark = time()
self.verbose(1, 'Balloon partitioning done, took %s, %d iterations'
% (format_duration(time() - t0), self.time))
def execute(self):
if self.data is None:
self.data = self.data_ui.get_fmri_data()
if self.analyser is None:
self.analyser = self.analyser_ui.get_analyser()
lg = pyhrf.verbose.verbosity >= 2
pyhrf.verbose(2, self.data.get_summary(long=lg))
pyhrf.verbose(1,'All data loaded !')
pyhrf.verbose(1,'running estimation ...')
#TODO : print summary of analyser setup.
pyhrf.verbose(1,'Estimation start date is : %s'
%time.strftime('%c'))
tIni = time.time()
result = self.analyser.analyse(self.data)
pyhrf.verbose(1,'Estimation done, total time : %s'
%format_duration(time.time()-tIni))
pyhrf.verbose(1,'End date is : '+time.strftime('%c'))
return result
def make_parcellation_from_files(betaFiles,
maskFile,
outFile,
nparcels,
method,
dry=False,
spatial_weight=10.):
if not op.exists(maskFile):
print 'Error, file %s not found' % maskFile
return
betaFiles = sorted(betaFiles)
for b in betaFiles:
if not op.exists(b):
raise Exception('Error, file %s not found' % b)
logger.info('Mask image: %s', op.basename(maskFile))
logger.info('Betas: %s ... %s', op.basename(betaFiles[0]),
op.basename(betaFiles[-1]))
logger.info("Method: %s, nb parcels: %d", method, nparcels)
logger.info('Spatial weight: %f', spatial_weight)
if not dry:
logger.info('Running parcellation ... ')
logger.info('Start date is: %s', strftime('%c', localtime()))
t0 = time()
v = logger.getEffectiveLevel() <= logging.INFO
lpa = fixed_parcellation(maskFile,
betaFiles,
nparcels,
nn=6,
method=method,
fullpath=outFile,
verbose=v,
mu=spatial_weight)
from pyhrf.ndarray import xndarray
c = xndarray.load(outFile)
if c.min() == -1:
c.data += 1
for i in np.unique(c.data):
# remove parcel with size < 2:
if i != 0 and len(c.data == 1) < 2:
c.data[np.where(c.data == i)] = 0
c.save(outFile)
logger.info('Parcellation complete, took %s',
format_duration(time() - t0))
return lpa
else:
logger.info('Dry run.')
def execute(self):
logger.debug('Input data description:')
logger.debug(self.data.getSummary(long=True))
logger.info('All data loaded !')
logger.info('running estimation ...')
# TODO : print summary of analyser setup.
logger.info('Estimation start date is : %s', time.strftime('%c'))
tIni = time.time()
result = self.analyser.analyse(self.data, self.output_dir)
logger.info('Estimation done, total time : %s',
format_duration(time.time() - tIni))
logger.info('End date is : %s', time.strftime('%c'))
return result
def execute(self):
logger.debug('Input data description:')
logger.debug(self.data.getSummary(long=True))
logger.info('All data loaded !')
logger.info('running estimation ...')
# TODO : print summary of analyser setup.
logger.info('Estimation start date is : %s', time.strftime('%c'))
tIni = time.time()
result = self.analyser.analyse(self.data, self.output_dir)
logger.info('Estimation done, total time : %s',
format_duration(time.time() - tIni))
logger.info('End date is : %s', time.strftime('%c'))
return result
def output(self, result, dump_result=True, outputs=True):
if dump_result and self.result_dump_file is not None:
self.pickle_result(result)
if outputs:
logger.info('Output of results to %s ...', self.output_dir)
try:
tIni = time.time()
r = self.analyser.outputResults(result, self.output_dir)
logger.info('Creation of outputs took : %s',
format_duration(time.time() - tIni))
return r
except NotImplementedError:
logger.error('No output function defined')
def output(self, result, dump_result=True, outputs=True):
if dump_result and self.result_dump_file is not None:
self.pickle_result(result)
if outputs:
pyhrf.verbose(1, 'Output of results to %s ...' %self.output_dir)
try:
tIni = time.time()
r = self.analyser.outputResults(result, self.output_dir)
pyhrf.verbose(1,'Creation of outputs took : %s'
%format_duration(time.time()-tIni))
return r
except NotImplementedError :
pyhrf.verbose(1,'No output function defined')
def run(self):
"""
function to launch the analysis
"""
logger.info('Starting voxel-wise HRF estimation ...')
logger.info('nvox=%d, ncond=%d, nscans=%d', self.nbVoxels, self.M,
self.ImagesNb)
# initialization of the matrices that will store all voxel resuls
logger.info("Init storage ...")
self.InitStorageMat()
logger.info("Compute onset matrix ...")
self.Compute_onset_matrix3()
self.stop_iterations = np.zeros(self.bold.shape[1], dtype=int)
# voxelwise analysis. This loop handles the currently analyzed voxels.
for POI in xrange(self.bold.shape[1]): # POI = point of interest
t0 = time()
logger.info("Point %s / %s", str(POI), str(self.nbVoxels))
self.ReadPointOfInterestData(POI)
# initialize with zeros or ones all matrix and vector used in
# the class
logger.info("Init matrix and vectors ...")
self.InitMatrixAndVectors(POI)
# compute onset matrix
# compute low frequency basis
logger.info('build low freq mat ...')
self.buildLowFreqMat()
# precompute usefull data
logger.info('Compute inv R ...')
self.Compute_INV_R_and_R_and_DET_R()
# solve find response functions and hyperparameters
logger.info('EM solver ...')
self.EM_solver(POI)
# store current results in matrices initialized in 'InitStoringMat'
logger.info('Store res ...')
self.StoreRes(POI)
logger.info("Done in %s", format_duration(time() - t0))
self.clean_memory()
logger.info('Nb of iterations to reach stop crit: %s',
array_summary(self.stop_iterations))
def run(self):
"""
function to launch the analysis
"""
logger.info('Starting voxel-wise HRF estimation ...')
logger.info('nvox=%d, ncond=%d, nscans=%d', self.nbVoxels, self.M,
self.ImagesNb)
# initialization of the matrices that will store all voxel resuls
logger.info("Init storage ...")
self.InitStorageMat()
logger.info("Compute onset matrix ...")
self.Compute_onset_matrix3()
self.stop_iterations = np.zeros(self.bold.shape[1], dtype=int)
# voxelwise analysis. This loop handles the currently analyzed voxels.
for POI in xrange(self.bold.shape[1]): # POI = point of interest
t0 = time()
logger.info("Point %s / %s", str(POI), str(self.nbVoxels))
self.ReadPointOfInterestData(POI)
# initialize with zeros or ones all matrix and vector used in
# the class
logger.info("Init matrix and vectors ...")
self.InitMatrixAndVectors(POI)
# compute onset matrix
# compute low frequency basis
logger.info('build low freq mat ...')
self.buildLowFreqMat()
# precompute usefull data
logger.info('Compute inv R ...')
self.Compute_INV_R_and_R_and_DET_R()
# solve find response functions and hyperparameters
logger.info('EM solver ...')
self.EM_solver(POI)
# store current results in matrices initialized in 'InitStoringMat'
logger.info('Store res ...')
self.StoreRes(POI)
logger.info("Done in %s", format_duration(time() - t0))
self.clean_memory()
logger.info('Nb of iterations to reach stop crit: %s',
array_summary(self.stop_iterations))
def make_parcellation_from_files(betaFiles, maskFile, outFile, nparcels,
method, dry=False, spatial_weight=10.):
if not op.exists(maskFile):
print 'Error, file %s not found' %maskFile
return
betaFiles = sorted(betaFiles)
for b in betaFiles:
if not op.exists(b):
print 'Error, file %s not found' %b
return
pyhrf.verbose(1, 'Mask image: ' + op.basename(maskFile))
pyhrf.verbose(1, 'Betas: ' + op.basename(betaFiles[0]) + ' ... ' + \
op.basename(betaFiles[-1]))
pyhrf.verbose(1, "Method: %s, nb parcels: %d" %(method, nparcels))
pyhrf.verbose(1, 'Spatial weight: %f' %spatial_weight)
if not dry:
pyhrf.verbose(1, 'Running parcellation ... ')
pyhrf.verbose(1, 'Start date is: %s' %strftime('%c',localtime()))
t0 = time()
#lpa = one_subj_parcellation(maskFile, betaFiles, nparcels, 6,
# method, 10, 1, fullpath=outFile)
v = pyhrf.verbose.verbosity
lpa = fixed_parcellation(maskFile, betaFiles, nparcels, nn=6,
method=method, fullpath=outFile, verbose=v,
mu=spatial_weight)
from pyhrf.ndarray import xndarray
c = xndarray.load(outFile)
if c.min() == -1:
c.data += 1
for i in np.unique(c.data):
# remove parcel with size < 2:
if i!=0 and len(c.data==1) < 2:
c.data[np.where(c.data==i)] = 0
c.save(outFile)
pyhrf.verbose(1, 'Parcellation complete, took %s' \
%format_duration(time() - t0))
return lpa
else:
pyhrf.verbose(1, 'Dry run.')
def make_parcellation_from_files(betaFiles, maskFile, outFile, nparcels,
method, dry=False, spatial_weight=10.):
if not op.exists(maskFile):
print 'Error, file %s not found' % maskFile
return
betaFiles = sorted(betaFiles)
for b in betaFiles:
if not op.exists(b):
raise Exception('Error, file %s not found' % b)
logger.info('Mask image: %s', op.basename(maskFile))
logger.info('Betas: %s ... %s', op.basename(betaFiles[0]),
op.basename(betaFiles[-1]))
logger.info("Method: %s, nb parcels: %d", method, nparcels)
logger.info('Spatial weight: %f', spatial_weight)
if not dry:
logger.info('Running parcellation ... ')
logger.info('Start date is: %s', strftime('%c', localtime()))
t0 = time()
v = logger.getEffectiveLevel() <= logging.INFO
lpa = fixed_parcellation(maskFile, betaFiles, nparcels, nn=6,
method=method, fullpath=outFile, verbose=v,
mu=spatial_weight)
from pyhrf.ndarray import xndarray
c = xndarray.load(outFile)
if c.min() == -1:
c.data += 1
for i in np.unique(c.data):
# remove parcel with size < 2:
if i != 0 and len(c.data == 1) < 2:
c.data[np.where(c.data == i)] = 0
c.save(outFile)
logger.info(
'Parcellation complete, took %s', format_duration(time() - t0))
return lpa
else:
logger.info('Dry run.')
def execute(self):
if pyhrf.verbose.verbosity >= 2:
pyhrf.verbose(2, 'Input data description:')
pyhrf.verbose(2, self.data.getSummary(long=True))
else:
pyhrf.verbose(1, 'Input data description:')
pyhrf.verbose(1, self.data.getSummary(long=False))
pyhrf.verbose(1,'All data loaded !')
pyhrf.verbose(1,'running estimation ...')
#TODO : print summary of analyser setup.
pyhrf.verbose(1,'Estimation start date is : %s'
%time.strftime('%c'))
tIni = time.time()
result = self.analyser.analyse(self.data, self.output_dir)
pyhrf.verbose(1,'Estimation done, total time : %s'
%format_duration(time.time()-tIni))
pyhrf.verbose(1,'End date is : '+time.strftime('%c'))
return result
def run_pyhrf_cmd_treatment(cfg_cmd, exec_cmd, default_cfg_file,
default_profile_file, label_for_cluster):
usage = 'usage: %%prog [options]'
description = 'Manage a joint detection-estimation treatment of fMRI data.' \
'This command runs the treatment defined in an xml '\
'parameter file. See pyhrf_jde_buildcfg command to build a'\
'template of such a file. If no xml file found, then runs a '\
'default example analysis.'
parser = OptionParser(usage=usage, description=description)
parser.add_option('-c','--input-cfg-file', metavar='XMLFILE', dest='cfgFile',
default=default_cfg_file,
help='Configuration file: XML file containing parameters'\
' defining input data and analysis to perform.')
parser.add_option('-r','--roi-data', metavar='PICKLEFILE', dest='roidata',
default=None, help='Input fMRI ROI data. The data '\
'definition part in the config file is ignored.')
parser.add_option('-t','--treatment_pck',
metavar='PICKLEFILE', dest='treatment_pck',
default=None, help='Input treatment as a pickle dump.' \
'The XML cfg file is ignored')
parser.add_option('-s','--stop-on-error', dest='stop_on_error',
action='store_true',
default=False, help='For debug: do not continue if error' \
' during one ROI analysis')
parser.add_option('-v','--verbose',dest='verbose',metavar='INTEGER',
type='int',default=0,
help=dictToString(pyhrf.verboseLevels))
parser.add_option('-p','--profile',action='store_true', default=False,
help='Enable profiling of treatment. Store profile data in '\
'%s. NOTE: not avalaible in parallel mode.'\
%default_profile_file)
parallel_choices = ['LAN','local','cluster']
parser.add_option('-x','--parallel', choices=parallel_choices,
help='Parallel processing. Choices are %s'\
%string.join(parallel_choices,', '))
(options,args) = parser.parse_args()
pyhrf.verbose.set_verbosity(options.verbose)
t0 = time.time()
if options.treatment_pck is not None:
f = open(options.treatment_pck)
treatment = cPickle.load(f)
f.close()
else:
if not os.path.exists(options.cfgFile):
print 'Error: could not find default configuration file "%s"\n'\
'Consider running "%s" to generate it.' \
%(options.cfgFile, cfg_cmd)
sys.exit(1)
else:
pyhrf.verbose(1, 'Loading configuration from: "%s" ...' \
%options.cfgFile)
f = open(options.cfgFile, 'r')
sXml = string.join(f.readlines())
f.close()
treatment = xmlio.from_xml(sXml)
if 0:
sXml = xmlio.to_xml(treatment)
f = './treatment_cmd.xml'
fOut = open(f,'w')
fOut.write(sXml)
fOut.close()
#f = open(fOut, 'w')
#cPickle.dump(treatment, f)
#f.close()
treatment.analyser.set_pass_errors(not options.stop_on_error)
if options.parallel is not None:
# tmpDir = tempfile.mkdtemp(prefix='pyhrf',
# dir=pyhrf.cfg['global']['tmp_path'])
# pyhrf.verbose(1, 'Tmpdir: %s' %tmpDir)
treatment.run(parallel=options.parallel)
else:
if options.roidata is not None:
#treatment.set_roidata(options.roidata)
pyhrf.verbose(1, 'Loading ROI data from: "%s" ...' \
%options.roidata)
roidata = cPickle.load(open(options.roidata))
roidata.verbosity = pyhrf.verbose.verbosity
if pyhrf.verbose > 1:
print roidata.getSummary()
#TODO: enable profiling
pyhrf.verbose(1, 'Launching analysis ...')
if options.profile:
cProfile.runctx("result = treatment.analyser(roidata)",
globals(),
{'treatment':treatment,'roidata': roidata},
default_profile_file)
else:
result = treatment.analyser(roidata)
outPath = op.dirname(op.abspath(options.roidata))
fOut = op.join(outPath,"result_%04d.pck" %roidata.get_roi_id())
pyhrf.verbose(1, 'Dumping results to %s ...' %fOut)
f = open(fOut, 'w')
cPickle.dump(result, f)
f.close()
else:
pyhrf.verbose(1, 'ROI data is none')
if options.profile:
cProfile.runctx("treatment.run()", globals(),
{'treatment':treatment}, default_profile_file)
else:
#print 'treatment:', treatment
treatment.run()
pyhrf.verbose(1, 'Estimation done, took %s' %format_duration(time.time() - t0))
def run(self):
"""
function to launch the analysis
"""
pyhrf.verbose(1, 'Starting voxel-wise HRF estimation ...')
pyhrf.verbose(1, 'nvox=%d, ncond=%d, nscans=%d' \
%(self.nbVoxels,self.M,self.ImagesNb))
#initialization of the matrices that will store all voxel resuls
pyhrf.verbose(3,"Init storage ...")
self.InitStorageMat()
pyhrf.verbose(3,"Compute onset matrix ...")
self.Compute_onset_matrix3()
self.stop_iterations = np.zeros(self.bold.shape[1], dtype=int)
#voxelwise analysis. This loop handles the currently analyzed voxels.
for POI in xrange(self.bold.shape[1]): # POI = point of interest
t0 = time()
pyhrf.verbose(3,"Point "+str(POI)+" / "+str(self.nbVoxels))
self.ReadPointOfInterestData(POI)
#print "Signal in point " , POI , "read"
# if hasattr(self, 'X'):
# prevX = copyModule.deepcopy(self.X)
# else:
# prevX = None
#initialize with zeros or ones all matrix and vector used in
#the class
pyhrf.verbose(4, "Init matrix and vectors ...")
self.InitMatrixAndVectors(POI)
#print "Matrix and vectors initialized"
#compute onset matrix
# print "Onset matrix computed"
# if prevX is not None:
# for i,x in enumerate(self.X):
# print 'sess %d ->' %i, (prevX[i]!=x).any()
# if 0:
# for m in xrange(prevX[i].shape[0]):
# for n in xrange(prevX[i].shape[1]):
# for k in xrange(prevX[i].shape[2]):
# print int(prevX[i][m,n,k]),'',
# print ''
# print ''
# print ''
# for m in xrange(x.shape[0]):
# for n in xrange(x.shape[1]):
# for k in xrange(x.shape[2]):
# print int(x[m,n,k]),
# print ''
# print ''
# print ''
#compute low frequency basis
pyhrf.verbose(4, 'build low freq mat ...')
self.buildLowFreqMat()
#print "Low frequency matrix generated"
#precompute usefull data
pyhrf.verbose(4, 'Compute inv R ...')
self.Compute_INV_R_and_R_and_DET_R()
#print "R^{-1} and det(R) precomputed"
#solve find response functions and hyperparameters
pyhrf.verbose(4, 'EM solver ...')
self.EM_solver(POI)
#store current results in matrices initialized in 'InitStoringMat'
pyhrf.verbose(4, 'Store res ...')
self.StoreRes(POI)
pyhrf.verbose(3,"Done in %s" %format_duration(time() - t0) )
self.clean_memory()
pyhrf.verbose(1, 'Nb of iterations to reach stop crit: %s' \
%array_summary(self.stop_iterations))
def analyse_roi(self, roiData):
# roiData is of type FmriRoiData, see pyhrf.core.FmriRoiData
# roiData.bold : numpy array of shape
# BOLD has shape (nscans, nvoxels)
# roiData.graph #list of neighbours
n_scan_allsession, nvox = roiData.bold.shape
n_scan = n_scan_allsession / self.n_session
data0 = roiData.bold.reshape(self.n_session, n_scan, nvox)
data = np.zeros_like(data0)
for s in xrange(self.n_session):
data_mean = np.mean(data0[s, :, :])
data_range = (np.max(data0[s, :, :]) - np.min(data0[s, :, :]))
data[s, :, :] = (data0[s, :, :] - data_mean) * 100 / data_range
Onsets = roiData.paradigm.get_joined_onsets_dim()
durations = roiData.paradigm.get_joined_durations_dim()
TR = roiData.tr
beta = self.beta
scale = 1 # roiData.nbVoxels
#nvox = roiData.get_nb_vox_in_mask()
if self.scale:
scale = nvox
rid = roiData.get_roi_id()
logger.info("JDE VEM - roi %d, nvox=%d, nconds=%d, nItMax=%d", rid,
nvox, len(Onsets), self.nItMax)
#self.contrasts.pop('dummy_example', None)
cNames = roiData.paradigm.get_stimulus_names()
graph = roiData.get_graph()
idx_tag1 = roiData.get_extra_data('asl_first_tag_scan_idx', 0)
t_start = time()
logger.info("fast VEM with drift estimation and a constraint")
try:
simu = roiData.simulation[0]
except:
try:
simu = roiData.simulation
except:
simu = None
if self.physio:
NbIter, brls, estimated_brf, prls, estimated_prf, labels, \
noiseVar, mu_Ma, sigma_Ma, mu_Mc, sigma_Mc, Beta, L, PL, alpha,\
Sigma_brls, Sigma_prls, Sigma_brf, Sigma_prf, rerror, \
CONTRAST_A, CONTRASTVAR_A, CONTRAST_C, CONTRASTVAR_C, \
cA, cH, cC, cG, cZ, cAH, cCG, cTime, FE = Main_vbjde_physio(
graph, data, Onsets, durations, self.hrfDuration,
self.nbClasses, TR, beta, self.dt, scale=scale,
estimateSigmaG=self.estimateSigmaG,
sigmaH=self.sigmaH, sigmaG=self.sigmaG,
gamma_h=self.gammaH, gamma_g=self.gammaG,
NitMax=self.nItMax, NitMin=self.nItMin,
estimateSigmaH=self.estimateSigmaH,
estimateBeta=self.estimateBeta, PLOT=self.PLOT,
contrasts=self.contrasts,
computeContrast=self.computeContrast,
idx_first_tag=idx_tag1,
simulation=simu, sigmaMu=self.sigmaMu,
estimateH=self.estimateH,
estimateG=self.estimateG,
estimateA=self.estimateA,
estimateC=self.estimateC,
estimateNoise=self.estimateNoise,
estimateMP=self.estimateMixtParam,
estimateZ=self.estimateLabels,
estimateLA=self.estimateLA,
constraint=self.constrained,
positivity=self.positivity,
use_hyperprior=self.use_hyperprior,
phy_params=self.phy_params,
prior=self.prior, zc=self.zc)
# Plot analysis duration
self.analysis_duration = time() - t_start
logger.info('JDE VEM analysis took: %s',
format_duration(self.analysis_duration))
# OUTPUTS: Pack all outputs within a dict
logger.info("Preparing outputs... ")
outputs = {}
brf_time = np.arange(len(estimated_brf)) * self.dt
outputs['brf'] = xndarray(estimated_brf,
axes_names=['time'],
axes_domains={'time': brf_time},
value_label="BRF")
#logger.info("BRF prepared ")
domCondition = {'condition': cNames}
outputs['brls'] = xndarray(brls.T,
value_label="BRLs",
axes_names=['condition', 'voxel'],
axes_domains=domCondition)
#logger.info("BRLs prepared ")
prf_time = np.arange(len(estimated_prf)) * self.dt
outputs['prf'] = xndarray(estimated_prf,
axes_names=['time'],
axes_domains={'time': prf_time},
value_label="PRF")
#logger.info("PRF prepared ")
outputs['prls'] = xndarray(prls.T,
value_label="PRLs",
axes_names=['condition', 'voxel'],
axes_domains=domCondition)
#logger.info("PRLs prepared ")
outputs['Sigma_brf'] = xndarray(Sigma_brf, value_label="Sigma_BRF")
#logger.info("Sigma_BRF prepared ")
outputs['Sigma_prf'] = xndarray(Sigma_prf, value_label="Sigma_PRF")
#logger.info("Sigma_PRF prepared ")
ad = {'condition': cNames, 'condition2': Onsets.keys()}
outputs['Sigma_brls'] = xndarray(
Sigma_brls,
value_label="Sigma_BRLs",
axes_names=['condition', 'condition2', 'voxel'],
axes_domains=ad)
#logger.info("Sigma_a prepared ")
outputs['Sigma_prls'] = xndarray(
Sigma_prls,
value_label="Sigma_PRLs",
axes_names=['condition', 'condition2', 'voxel'],
axes_domains=ad)
#logger.info("Sigma_c prepared ")
outputs['NbIter'] = xndarray(np.array([NbIter]), value_label="NbIter")
outputs['beta'] = xndarray(Beta,
value_label="beta",
axes_names=['condition'],
axes_domains=domCondition)
#logger.info("perfusion baseline prepared ")
outputs['alpha'] = xndarray(alpha,
value_label="Perf_baseline",
axes_names=['voxel'])
#logger.info("Beta prepared ")
nbc, nbv = len(cNames), brls.shape[0]
repeatedBeta = np.repeat(Beta, nbv).reshape(nbc, nbv)
outputs['beta_mapped'] = xndarray(repeatedBeta,
value_label="beta",
axes_names=['condition', 'voxel'],
axes_domains=domCondition)
repeated_brf = np.repeat(estimated_brf, nbv).reshape(-1, nbv)
outputs["brf_mapped"] = xndarray(repeated_brf,
value_label="BRFs",
axes_names=["time", "voxel"],
axes_domains={"time": brf_time})
repeated_prf = np.repeat(estimated_prf, nbv).reshape(-1, nbv)
outputs["prf_mapped"] = xndarray(repeated_prf,
value_label="PRFs",
axes_names=["time", "voxel"],
axes_domains={"time": prf_time})
#logger.info("beta mapped prepared ")
outputs['roi_mask'] = xndarray(np.zeros(nbv) + roiData.get_roi_id(),
value_label="ROI",
axes_names=['voxel'])
#logger.info("ROI mask prepared ")
mixtpB = np.zeros((roiData.nbConditions, self.nbClasses, 2))
mixtpB[:, :, 0] = mu_Ma
mixtpB[:, :, 1] = sigma_Ma**2
mixtpP = np.zeros((roiData.nbConditions, self.nbClasses, 2))
mixtpP[:, :, 0] = mu_Mc
mixtpP[:, :, 1] = sigma_Mc**2
an = ['condition', 'Act_class', 'component']
ad = {
'Act_class': ['inactiv', 'activ'],
'condition': cNames,
'component': ['mean', 'var']
}
outputs['mixt_pB'] = xndarray(mixtpB, axes_names=an, axes_domains=ad)
outputs['mixt_pP'] = xndarray(mixtpP, axes_names=an, axes_domains=ad)
#logger.info("Mixture parameters prepared ")
an = ['condition', 'Act_class', 'voxel']
ad = {'Act_class': ['inactiv', 'activ'], 'condition': cNames}
#logger.info("mixt params prepared ")
outputs['labels'] = xndarray(labels,
value_label="Labels",
axes_names=an,
axes_domains=ad)
#logger.info("labels prepared ")
outputs['noiseVar'] = xndarray(noiseVar,
value_label="noiseVar",
axes_names=['voxel'])
#logger.info("noise variance prepared ")
if self.estimateLA:
outputs['drift_coeff'] = xndarray(L,
value_label="Drift",
axes_names=['coeff', 'voxel'])
outputs['drift'] = xndarray(PL,
value_label="Delta BOLD",
axes_names=['time', 'voxel'])
logger.info("drift prepared ")
logger.info("outputs prepared ")
if (len(self.contrasts) > 0) and self.computeContrast:
#keys = list((self.contrasts[nc]) for nc in self.contrasts)
domContrast = {'contrast': self.contrasts.keys()}
outputs['contrastsA'] = xndarray(CONTRAST_A,
value_label="Contrast_A",
axes_names=['voxel', 'contrast'],
axes_domains=domContrast)
outputs['contrastsC'] = xndarray(CONTRAST_C,
value_label="Contrast_C",
axes_names=['voxel', 'contrast'],
axes_domains=domContrast)
c = xndarray(CONTRASTVAR_A,
value_label="Contrasts_Variance_A",
axes_names=['voxel', 'contrast'],
axes_domains=domContrast)
outputs['contrasts_variance_a'] = c
outputs['ncontrasts_a'] = xndarray(
CONTRAST_A / CONTRASTVAR_A**.5,
value_label="Normalized Contrast A",
axes_names=['voxel', 'contrast'],
axes_domains=domContrast)
c = xndarray(CONTRASTVAR_C,
value_label="Contrasts_Variance_C",
axes_names=['voxel', 'contrast'],
axes_domains=domContrast)
outputs['contrasts_variance_c'] = c
outputs['ncontrasts_c'] = xndarray(
CONTRAST_C / CONTRASTVAR_C**.5,
value_label="Normalized Contrast C",
axes_names=['voxel', 'contrast'],
axes_domains=domContrast)
#######################################################################
# CONVERGENCE
if 1:
cTimeMean = cTime[-1] / np.float(NbIter)
logger.info("Saving convergence... ")
axes_names = ['duration']
ax = (np.arange(self.nItMax) + 1) * cTimeMean
ax[:len(cTime)] = cTime
ad = {'duration': ax}
outName = 'convergence_Labels'
c = np.zeros(self.nItMax) # -.001 #
c[:len(cZ)] = cZ
outputs[outName] = xndarray(c,
axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_Z')
outName = 'convergence_BRF'
#ad = {'Conv_Criterion':np.arange(len(cH))}
c = np.zeros(self.nItMax) # -.001 #
c[:len(cH)] = cH
outputs[outName] = xndarray(c,
axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_H')
outName = 'convergence_BRL'
c = np.zeros(self.nItMax) # -.001 #
c[:len(cA)] = cA
#ad = {'Conv_Criterion':np.arange(len(cA))}
outputs[outName] = xndarray(c,
axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_A')
outName = 'convergence_PRF'
#ad = {'Conv_Criterion':np.arange(len(cH))}
c = np.zeros(self.nItMax) # -.001 #
c[:len(cG)] = cG
outputs[outName] = xndarray(c,
axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_G')
outName = 'convergence_PRL'
c = np.zeros(self.nItMax) # -.001 #
c[:len(cC)] = cC
#ad = {'Conv_Criterion':np.arange(len(cA))}
outputs[outName] = xndarray(c,
axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_C')
outName = 'convergence_FE'
c = np.zeros(self.nItMax) # -.001 #
c[:len(FE)] = FE
outputs[outName] = xndarray(c,
axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_FE')
logger.info("Convergence saved ")
#######################################################################
# SIMULATION
if self.simulation is not None and 0:
logger.info("Prepare parameters to compare if simulation")
M = labels.shape[0]
K = labels.shape[1]
J = labels.shape[2]
true_labels = np.zeros((M, J))
for m in xrange(0, M):
true_labels[
m, :] = roiData.simulation[0]['labels'][m].flatten()
newlabels = np.reshape(labels[:, 1, :], (M, J))
#true_labels = roiData.simulation[0]['labels']
#newlabels = labels
se = []
sp = []
size = np.prod(labels.shape)
for i in xrange(0, 2): # (0, M):
se0, sp0, auc = roc_curve(newlabels[i, :].tolist(),
true_labels[i, :].tolist())
se.append(se0)
sp.append(sp0)
size = min(size, len(sp0))
SE = np.zeros((M, size), dtype=float)
SP = np.zeros((M, size), dtype=float)
for i in xrange(0, 2): # M):
tmp = np.array(se[i])
SE[i, :] = tmp[0:size]
tmp = np.array(sp[i])
SP[i, :] = tmp[0:size]
sensData, specData = SE, SP
axes_names = ['1-specificity', 'condition']
outName = 'ROC_audio'
#ad = {'1-specificity': specData[0], 'condition': cNames}
outputs[outName] = xndarray(
sensData,
axes_names=axes_names,
#axes_domains=ad,
value_label='sensitivity')
m = specData[0].min()
import matplotlib.font_manager as fm
import matplotlib.pyplot as plt
plt.figure(200)
plt.plot(sensData[0],
specData[0],
'--',
color='k',
linewidth=2.0,
label='m=1')
plt.hold(True)
plt.plot(sensData[1],
specData[1],
color='k',
linewidth=2.0,
label='m=2')
# legend(('audio','video'))
plt.xticks(color='k', size=14, fontweight='bold')
plt.yticks(color='k', size=14, fontweight='bold')
#xlabel('1 - Specificity',fontsize=16,fontweight='bold')
# ylabel('Sensitivity',fontsize=16,fontweight='bold')
prop = fm.FontProperties(size=14, weight='bold')
plt.legend(loc=1, prop=prop)
plt.axis([0., 1., m, 1.02])
true_labels = roiData.simulation[0]['labels']
true_brls = roiData.simulation[0]['nrls']
true_prls = roiData.simulation[0]['prls']
true_brf = roiData.simulation[0]['hrf'][:, 0]
true_prf = roiData.simulation[0]['prf'][:, 0]
true_drift = roiData.simulation[0]['drift']
true_noise = roiData.simulation[0]['noise']
if simu is not None:
logger.info("Check parameters errors")
self.finalizeEstimation(true_labels, newlabels, nvox, true_brf,
estimated_brf, true_prf, estimated_prf,
true_brls, brls.T, true_prls, prls.T,
true_drift, PL, L, true_noise,
noiseVar)
# END SIMULATION
#######################################################################
d = {'parcel_size': np.array([nvox])}
outputs['analysis_duration'] = xndarray(np.array(
[self.analysis_duration]),
axes_names=['parcel_size'],
axes_domains=d)
"""outputs['rerror'] = xndarray(np.array( rerror),
axes_names=['parcel_size'])"""
return outputs
def main():
"""Run when calling the script"""
start_time = time.time()
if not os.path.isdir(config["output_dir"]):
try:
os.makedirs(config["output_dir"])
except OSError as e:
print("Ouput directory could not be created.\n"
"Error was: {}".format(e.strerror))
sys.exit(1)
bold_data = FmriData.from_vol_files(
mask_file=config["parcels_file"], paradigm_csv_file=config["onsets_file"],
bold_files=config["bold_data_file"], tr=config["tr"]
)
compute_contrasts, contrasts_def = load_contrasts_definitions(config["def_contrasts_file"])
jde_vem_analyser = JDEVEMAnalyser(
hrfDuration=config["hrf_duration"], sigmaH=config["sigma_h"], fast=True,
computeContrast=compute_contrasts, nbClasses=2, PLOT=False,
nItMax=config["nb_iter_max"], nItMin=config["nb_iter_min"], scale=False,
beta=config["beta"], estimateSigmaH=True, estimateHRF=config["estimate_hrf"],
TrueHrfFlag=False, HrfFilename='hrf.nii', estimateDrifts=True,
hyper_prior_sigma_H=config["hrf_hyperprior"], dt=config["dt"], estimateBeta=True,
contrasts=contrasts_def, simulation=False, estimateLabels=True,
LabelsFilename=None, MFapprox=False, estimateMixtParam=True,
constrained=False, InitVar=0.5, InitMean=2.0, MiniVemFlag=False, NbItMiniVem=5,
zero_constraint=config["zero_constraint"], drifts_type=config["drifts_type"]
)
processing_jde_vem = FMRITreatment(
fmri_data=bold_data, analyser=jde_vem_analyser,
output_dir=config["output_dir"], make_outputs=True
)
if not config["parallel"]:
processing_jde_vem.run()
else:
processing_jde_vem.run(parallel="local")
if config["save_processing_config"]:
# Let's canonicalize all paths
config_save = dict(config)
for file_nb, bold_file in enumerate(config_save["bold_data_file"]):
config_save["bold_data_file"][file_nb] = os.path.abspath(bold_file)
config_save["parcels_file"] = os.path.abspath(config_save["parcels_file"])
config_save["onsets_file"] = os.path.abspath(config_save["onsets_file"])
if config_save["def_contrasts_file"]:
config_save["def_contrasts_file"] = os.path.abspath(config_save["def_contrasts_file"])
config_save["output_dir"] = os.path.abspath(config_save["output_dir"])
config_save_filename = "{}_processing.json".format(
datetime.datetime.today()
).replace(" ", "_")
config_save_path = os.path.join(config["output_dir"], config_save_filename)
with open(config_save_path, 'w') as json_file:
json.dump(config_save, json_file, sort_keys=True, indent=4)
print("")
print("Total computation took: {} seconds".format(format_duration(time.time() - start_time)))
def analyse_roi(self, roiData):
#roiData is of type FmriRoiData, see pyhrf.core.FmriRoiData
# roiData.bold : numpy array of shape
## BOLD has shape (nscans, nvoxels)
#roiData.graph #list of neighbours
data = roiData.bold
Onsets = roiData.get_joined_onsets()
TR = roiData.tr
#K = 2 #number of classes
beta = self.beta
scale = 1#roiData.nbVoxels
nvox = roiData.get_nb_vox_in_mask()
if self.scale:
scale = nvox
rid = roiData.get_roi_id()
logger.info("JDE VEM - roi %d, nvox=%d, nconds=%d, nItMax=%d", rid,
nvox, len(Onsets), self.nItMax)
self.contrasts.pop('dummy_example', None)
cNames = roiData.paradigm.get_stimulus_names()
graph = roiData.get_graph()
t_start = time()
if self.fast:
if not self.constrained:
logger.info("fast VEM with drift estimation")
NbIter, nrls, estimated_hrf, \
labels, noiseVar, mu_k, sigma_k, \
Beta, L, PL, CONTRAST, CONTRASTVAR, \
cA,cH,cZ,cAH,cTime,cTimeMean, Sigma_nrls, \
StimuIndSignal = Main_vbjde_Extension_stable(graph,data,Onsets, \
self.hrfDuration, self.nbClasses,TR,
beta,self.dt,scale,self.estimateSigmaH,
self.sigmaH,self.nItMax, self.nItMin,
self.estimateBeta,self.PLOT,
self.contrasts,self.computeContrast,
self.hyper_prior_sigma_H,self.estimateHRF,
self.TrueHrfFlag, self.HrfFilename,
self.estimateLabels,self.LabelsFilename,
self.MFapprox,self.InitVar,self.InitMean,
self.MiniVemFlag,self.NbItMiniVem)
else:
logger.info("fast VEM with drift estimation and a constraint")
NbIter, nrls, estimated_hrf, \
labels, noiseVar, mu_k, sigma_k, \
Beta, L, PL, CONTRAST, CONTRASTVAR, \
cA,cH,cZ,cAH,cTime,cTimeMean, \
Sigma_nrls, StimuIndSignal,\
FreeEnergy = Main_vbjde_Extension_constrained(graph,data,Onsets, \
self.hrfDuration, self.nbClasses,TR,
beta,self.dt,scale,self.estimateSigmaH,
self.sigmaH,self.nItMax, self.nItMin,
self.estimateBeta,self.PLOT,
self.contrasts,self.computeContrast,
self.hyper_prior_sigma_H,self.estimateHRF,
self.TrueHrfFlag, self.HrfFilename,
self.estimateLabels,self.LabelsFilename,
self.MFapprox,self.InitVar,self.InitMean,
self.MiniVemFlag,self.NbItMiniVem)
else:
# if not self.fast
if self.estimateDrifts:
logger.info("not fast VEM")
logger.info("NOT WORKING")
nrls, estimated_hrf, \
labels, noiseVar, mu_k, \
sigma_k, Beta, L, \
PL = Main_vbjde_Python_constrained(graph,data,Onsets,
self.hrfDuration,self.nbClasses,
TR,beta,self.dt,scale,
self.estimateSigmaH,self.sigmaH,
self.nItMax,self.nItMin,
self.estimateBeta,self.PLOT)
# Plot analysis duration
self.analysis_duration = time() - t_start
logger.info('JDE VEM analysis took: %s',
format_duration(self.analysis_duration))
if self.fast:
### OUTPUTS: Pack all outputs within a dict
outputs = {}
hrf_time = np.arange(len(estimated_hrf)) * self.dt
axes_names = ['iteration']
"""axes_domains = {'iteration':np.arange(FreeEnergy.shape[0])}
outputs['FreeEnergy'] = xndarray(FreeEnergy,
axes_names=axes_names,
axes_domains=axes_domains)
"""
outputs['hrf'] = xndarray(estimated_hrf, axes_names=['time'],
axes_domains={'time':hrf_time},
value_label="HRF")
domCondition = {'condition':cNames}
outputs['nrls'] = xndarray(nrls.transpose(),value_label="NRLs",
axes_names=['condition','voxel'],
axes_domains=domCondition)
ad = {'condition':cNames,'condition2':Onsets.keys()}
outputs['Sigma_nrls'] = xndarray(Sigma_nrls,value_label="Sigma_NRLs",
axes_names=['condition','condition2','voxel'],
axes_domains=ad)
outputs['NbIter'] = xndarray(np.array([NbIter]),value_label="NbIter")
outputs['beta'] = xndarray(Beta,value_label="beta",
axes_names=['condition'],
axes_domains=domCondition)
nbc, nbv = len(cNames), nrls.shape[0]
repeatedBeta = np.repeat(Beta, nbv).reshape(nbc, nbv)
outputs['beta_mapped'] = xndarray(repeatedBeta,value_label="beta",
axes_names=['condition','voxel'],
axes_domains=domCondition)
outputs['roi_mask'] = xndarray(np.zeros(nbv)+roiData.get_roi_id(),
value_label="ROI",
axes_names=['voxel'])
h = estimated_hrf
nrls = nrls.transpose()
nvox = nrls.shape[1]
nbconds = nrls.shape[0]
ah = np.zeros((h.shape[0], nvox, nbconds))
mixtp = np.zeros((roiData.nbConditions, self.nbClasses, 2))
mixtp[:, :, 0] = mu_k
mixtp[:, :, 1] = sigma_k**2
an = ['condition','Act_class','component']
ad = {'Act_class':['inactiv','activ'],
'condition': cNames,
'component':['mean','var']}
outputs['mixt_p'] = xndarray(mixtp, axes_names=an, axes_domains=ad)
ad = {'class' : ['inactiv','activ'],
'condition': cNames,
}
outputs['labels'] = xndarray(labels,value_label="Labels",
axes_names=['condition','class','voxel'],
axes_domains=ad)
outputs['noiseVar'] = xndarray(noiseVar,value_label="noiseVar",
axes_names=['voxel'])
if self.estimateDrifts:
outputs['drift_coeff'] = xndarray(L,value_label="Drift",
axes_names=['coeff','voxel'])
outputs['drift'] = xndarray(PL,value_label="Delta BOLD",
axes_names=['time','voxel'])
if (len(self.contrasts) >0) and self.computeContrast:
#keys = list((self.contrasts[nc]) for nc in self.contrasts)
domContrast = {'contrast':self.contrasts.keys()}
outputs['contrasts'] = xndarray(CONTRAST, value_label="Contrast",
axes_names=['voxel','contrast'],
axes_domains=domContrast)
#print 'contrast output:'
#print outputs['contrasts'].descrip()
c = xndarray(CONTRASTVAR, value_label="Contrasts_Variance",
axes_names=['voxel','contrast'],
axes_domains=domContrast)
outputs['contrasts_variance'] = c
outputs['ncontrasts'] = xndarray(CONTRAST/CONTRASTVAR**.5,
value_label="Normalized Contrast",
axes_names=['voxel','contrast'],
axes_domains=domContrast)
################################################################################
# CONVERGENCE
axes_names = ['duration']
outName = 'Convergence_Labels'
ax = np.arange(self.nItMax)*cTimeMean
ax[:len(cTime)] = cTime
ad = {'duration':ax}
c = np.zeros(self.nItMax) #-.001 #
c[:len(cZ)] = cZ
outputs[outName] = xndarray(c, axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_Z')
outName = 'Convergence_HRF'
#ad = {'Conv_Criterion':np.arange(len(cH))}
c = np.zeros(self.nItMax) #-.001 #
c[:len(cH)] = cH
outputs[outName] = xndarray(c, axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_H')
outName = 'Convergence_NRL'
c = np.zeros(self.nItMax)# -.001 #
c[:len(cA)] = cA
#ad = {'Conv_Criterion':np.arange(len(cA))}
outputs[outName] = xndarray(c, axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_A')
################################################################################
# SIMULATION
if self.simulation and self.fast:
from pyhrf.stats import compute_roc_labels
labels_vem_audio = roiData.simulation['labels'][0]
labels_vem_video = roiData.simulation['labels'][1]
M = labels.shape[0]
K = labels.shape[1]
J = labels.shape[2]
true_labels = np.zeros((K,J))
true_labels[0,:] = reshape(labels_vem_audio,(J))
true_labels[1,:] = reshape(labels_vem_video,(J))
newlabels = np.reshape(labels[:,1,:],(M,J))
se = []
sp = []
size = prod(labels.shape)
for i in xrange(0,M):
se0,sp0, auc = roc_curve(newlabels[i,:].tolist(),
true_labels[i,:].tolist())
se.append(se0)
sp.append(sp0)
size = min(size,len(sp0))
SE = np.zeros((M,size),dtype=float)
SP = np.zeros((M,size),dtype=float)
for i in xrange(0,M):
tmp = np.array(se[i])
SE[i,:] = tmp[0:size]
tmp = np.array(sp[i])
SP[i,:] = tmp[0:size]
sensData, specData = SE, SP
axes_names = ['condition','1-specificity']
outName = 'ROC_audio'
ad = {'1-specificity':specData[0],'condition':cNames}
outputs[outName] = xndarray(sensData, axes_names=axes_names,
axes_domains=ad,
value_label='sensitivity')
m = specData[0].min()
import matplotlib.font_manager as fm
figure(200)
plot(sensData[0],specData[0],'--',color='k',linewidth=2.0,label='m=1')
hold(True)
plot(sensData[1],specData[1],color='k',linewidth=2.0,label='m=2')
#legend(('audio','video'))
xticks(color = 'k', size = 14,fontweight='bold')
yticks(color = 'k', size = 14,fontweight='bold')
#xlabel('1 - Specificity',fontsize=16,fontweight='bold')
#ylabel('Sensitivity',fontsize=16,fontweight='bold')
prop = fm.FontProperties(size=14,weight='bold')
legend(loc=1,prop=prop)
axis([0., 1., m, 1.02])
from pyhrf.stats import compute_roc_labels
if hasattr(roiData.simulation, 'nrls'):
true_labels = roiData.simulation.nrls.labels
true_nrls = roiData.simulation.nrls.data
elif isinstance(roiData.simulation, dict) and \
roiData.simulation.has_key('labels') and \
roiData.simulation.has_key('nrls') :
true_labels = roiData.simulation['labels']
true_nrls = roiData.simulation['nrls']
else:
raise Exception('Simulation can not be retrieved from %s' \
%str(roiData.simulation))
domCondition = {'condition':cNames}
outputs['Truenrls'] = xndarray(true_nrls,value_label="True_nrls",
axes_names=['condition','voxel'],
axes_domains=domCondition)
M = labels.shape[0]
K = labels.shape[1]
J = labels.shape[2]
newlabels = np.reshape(labels[:,1,:],(M,J))
for i in xrange(0,M):
se0,sp0, auc = roc_curve(newlabels[i,:].tolist(),
true_labels[i,:].tolist())
se.append(se0)
sp.append(sp0)
size = min(size,len(sp0))
SE = np.zeros((M,size),dtype=float)
SP = np.zeros((M,size),dtype=float)
for i in xrange(0,M):
tmp = np.array(se[i])
SE[i,:] = tmp[0:size]
tmp = np.array(sp[i])
SP[i,:] = tmp[0:size]
# END SIMULATION
##########################################################################
if self.fast:
d = {'parcel_size':np.array([nvox])}
outputs['analysis_duration'] = xndarray(np.array([self.analysis_duration]),
axes_names=['parcel_size'],
axes_domains=d)
return #outputs
def analyse_roi(self, roiData):
# roiData is of type FmriRoiData, see pyhrf.core.FmriRoiData
# roiData.bold : numpy array of shape
# BOLD has shape (nscans, nvoxels)
# roiData.graph #list of neighbours
n_scan_allsession, nvox = roiData.bold.shape
n_scan = n_scan_allsession / self.n_session
data0 = roiData.bold.reshape(self.n_session, n_scan, nvox)
data = np.zeros_like(data0)
for s in xrange(self.n_session):
data_mean = np.mean(data0[s, :, :])
data_range = (np.max(data0[s, :, :]) - np.min(data0[s, :, :]))
data[s, :, :] = (data0[s, :, :] - data_mean) * 100 / data_range
Onsets = roiData.paradigm.get_joined_onsets_dim()
durations = roiData.paradigm.get_joined_durations_dim()
TR = roiData.tr
beta = self.beta
scale = 1 # roiData.nbVoxels
#nvox = roiData.get_nb_vox_in_mask()
if self.scale:
scale = nvox
rid = roiData.get_roi_id()
logger.info("JDE VEM - roi %d, nvox=%d, nconds=%d, nItMax=%d", rid,
nvox, len(Onsets), self.nItMax)
#self.contrasts.pop('dummy_example', None)
cNames = roiData.paradigm.get_stimulus_names()
graph = roiData.get_graph()
idx_tag1 = roiData.get_extra_data('asl_first_tag_scan_idx', 0)
t_start = time()
logger.info("fast VEM with drift estimation and a constraint")
try:
simu = roiData.simulation[0]
except:
try:
simu = roiData.simulation
except:
simu = None
if self.physio:
NbIter, brls, estimated_brf, prls, estimated_prf, labels, \
noiseVar, mu_Ma, sigma_Ma, mu_Mc, sigma_Mc, Beta, L, PL, alpha,\
Sigma_brls, Sigma_prls, Sigma_brf, Sigma_prf, rerror, \
CONTRAST_A, CONTRASTVAR_A, CONTRAST_C, CONTRASTVAR_C, \
cA, cH, cC, cG, cZ, cAH, cCG, cTime, FE = Main_vbjde_physio(
graph, data, Onsets, durations, self.hrfDuration,
self.nbClasses, TR, beta, self.dt, scale=scale,
estimateSigmaG=self.estimateSigmaG,
sigmaH=self.sigmaH, sigmaG=self.sigmaG,
gamma_h=self.gammaH, gamma_g=self.gammaG,
NitMax=self.nItMax, NitMin=self.nItMin,
estimateSigmaH=self.estimateSigmaH,
estimateBeta=self.estimateBeta, PLOT=self.PLOT,
contrasts=self.contrasts,
computeContrast=self.computeContrast,
idx_first_tag=idx_tag1,
simulation=simu, sigmaMu=self.sigmaMu,
estimateH=self.estimateH,
estimateG=self.estimateG,
estimateA=self.estimateA,
estimateC=self.estimateC,
estimateNoise=self.estimateNoise,
estimateMP=self.estimateMixtParam,
estimateZ=self.estimateLabels,
estimateLA=self.estimateLA,
constraint=self.constrained,
positivity=self.positivity,
use_hyperprior=self.use_hyperprior,
phy_params=self.phy_params,
prior=self.prior, zc=self.zc)
# Plot analysis duration
self.analysis_duration = time() - t_start
logger.info('JDE VEM analysis took: %s',
format_duration(self.analysis_duration))
# OUTPUTS: Pack all outputs within a dict
logger.info("Preparing outputs... ")
outputs = {}
brf_time = np.arange(len(estimated_brf)) * self.dt
outputs['brf'] = xndarray(estimated_brf, axes_names=['time'],
axes_domains={'time': brf_time},
value_label="BRF")
#logger.info("BRF prepared ")
domCondition = {'condition': cNames}
outputs['brls'] = xndarray(brls.T, value_label="BRLs",
axes_names=['condition', 'voxel'],
axes_domains=domCondition)
#logger.info("BRLs prepared ")
prf_time = np.arange(len(estimated_prf)) * self.dt
outputs['prf'] = xndarray(estimated_prf, axes_names=['time'],
axes_domains={'time': prf_time},
value_label="PRF")
#logger.info("PRF prepared ")
outputs['prls'] = xndarray(prls.T, value_label="PRLs",
axes_names=['condition', 'voxel'],
axes_domains=domCondition)
#logger.info("PRLs prepared ")
outputs['Sigma_brf'] = xndarray(Sigma_brf, value_label="Sigma_BRF")
#logger.info("Sigma_BRF prepared ")
outputs['Sigma_prf'] = xndarray(Sigma_prf, value_label="Sigma_PRF")
#logger.info("Sigma_PRF prepared ")
ad = {'condition': cNames, 'condition2': Onsets.keys()}
outputs['Sigma_brls'] = xndarray(Sigma_brls, value_label="Sigma_BRLs",
axes_names=['condition', 'condition2',
'voxel'],
axes_domains=ad)
#logger.info("Sigma_a prepared ")
outputs['Sigma_prls'] = xndarray(Sigma_prls, value_label="Sigma_PRLs",
axes_names=['condition', 'condition2',
'voxel'],
axes_domains=ad)
#logger.info("Sigma_c prepared ")
outputs['NbIter'] = xndarray(np.array([NbIter]), value_label="NbIter")
outputs['beta'] = xndarray(Beta, value_label="beta",
axes_names=['condition'],
axes_domains=domCondition)
#logger.info("perfusion baseline prepared ")
outputs['alpha'] = xndarray(alpha, value_label="Perf_baseline",
axes_names=['voxel'])
#logger.info("Beta prepared ")
nbc, nbv = len(cNames), brls.shape[0]
repeatedBeta = np.repeat(Beta, nbv).reshape(nbc, nbv)
outputs['beta_mapped'] = xndarray(repeatedBeta, value_label="beta",
axes_names=['condition', 'voxel'],
axes_domains=domCondition)
repeated_brf = np.repeat(estimated_brf, nbv).reshape(-1, nbv)
outputs["brf_mapped"] = xndarray(repeated_brf, value_label="BRFs",
axes_names=["time", "voxel"],
axes_domains={"time": brf_time})
repeated_prf = np.repeat(estimated_prf, nbv).reshape(-1, nbv)
outputs["prf_mapped"] = xndarray(repeated_prf, value_label="PRFs",
axes_names=["time", "voxel"],
axes_domains={"time": prf_time})
#logger.info("beta mapped prepared ")
outputs['roi_mask'] = xndarray(np.zeros(nbv) + roiData.get_roi_id(),
value_label="ROI",
axes_names=['voxel'])
#logger.info("ROI mask prepared ")
mixtpB = np.zeros((roiData.nbConditions, self.nbClasses, 2))
mixtpB[:, :, 0] = mu_Ma
mixtpB[:, :, 1] = sigma_Ma ** 2
mixtpP = np.zeros((roiData.nbConditions, self.nbClasses, 2))
mixtpP[:, :, 0] = mu_Mc
mixtpP[:, :, 1] = sigma_Mc ** 2
an = ['condition', 'Act_class', 'component']
ad = {'Act_class': ['inactiv', 'activ'],
'condition': cNames,
'component': ['mean', 'var']}
outputs['mixt_pB'] = xndarray(mixtpB, axes_names=an, axes_domains=ad)
outputs['mixt_pP'] = xndarray(mixtpP, axes_names=an, axes_domains=ad)
#logger.info("Mixture parameters prepared ")
an = ['condition', 'Act_class', 'voxel']
ad = {'Act_class': ['inactiv', 'activ'],
'condition': cNames}
#logger.info("mixt params prepared ")
outputs['labels'] = xndarray(labels, value_label="Labels",
axes_names=an, axes_domains=ad)
#logger.info("labels prepared ")
outputs['noiseVar'] = xndarray(noiseVar, value_label="noiseVar",
axes_names=['voxel'])
#logger.info("noise variance prepared ")
if self.estimateLA:
outputs['drift_coeff'] = xndarray(L, value_label="Drift",
axes_names=['coeff', 'voxel'])
outputs['drift'] = xndarray(PL, value_label="Delta BOLD",
axes_names=['time', 'voxel'])
logger.info("drift prepared ")
logger.info("outputs prepared ")
if (len(self.contrasts) >0) and self.computeContrast:
#keys = list((self.contrasts[nc]) for nc in self.contrasts)
domContrast = {'contrast':self.contrasts.keys()}
outputs['contrastsA'] = xndarray(CONTRAST_A, value_label="Contrast_A",
axes_names=['voxel','contrast'],
axes_domains=domContrast)
outputs['contrastsC'] = xndarray(CONTRAST_C, value_label="Contrast_C",
axes_names=['voxel','contrast'],
axes_domains=domContrast)
c = xndarray(CONTRASTVAR_A, value_label="Contrasts_Variance_A",
axes_names=['voxel','contrast'],
axes_domains=domContrast)
outputs['contrasts_variance_a'] = c
outputs['ncontrasts_a'] = xndarray(CONTRAST_A/CONTRASTVAR_A**.5,
value_label="Normalized Contrast A",
axes_names=['voxel','contrast'],
axes_domains=domContrast)
c = xndarray(CONTRASTVAR_C, value_label="Contrasts_Variance_C",
axes_names=['voxel','contrast'],
axes_domains=domContrast)
outputs['contrasts_variance_c'] = c
outputs['ncontrasts_c'] = xndarray(CONTRAST_C/CONTRASTVAR_C**.5,
value_label="Normalized Contrast C",
axes_names=['voxel','contrast'],
axes_domains=domContrast)
#######################################################################
# CONVERGENCE
if 1:
cTimeMean = cTime[-1] / np.float(NbIter)
logger.info("Saving convergence... ")
axes_names = ['duration']
ax = (np.arange(self.nItMax) + 1) * cTimeMean
ax[:len(cTime)] = cTime
ad = {'duration': ax}
outName = 'convergence_Labels'
c = np.zeros(self.nItMax) # -.001 #
c[:len(cZ)] = cZ
outputs[outName] = xndarray(c, axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_Z')
outName = 'convergence_BRF'
#ad = {'Conv_Criterion':np.arange(len(cH))}
c = np.zeros(self.nItMax) # -.001 #
c[:len(cH)] = cH
outputs[outName] = xndarray(c, axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_H')
outName = 'convergence_BRL'
c = np.zeros(self.nItMax) # -.001 #
c[:len(cA)] = cA
#ad = {'Conv_Criterion':np.arange(len(cA))}
outputs[outName] = xndarray(c, axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_A')
outName = 'convergence_PRF'
#ad = {'Conv_Criterion':np.arange(len(cH))}
c = np.zeros(self.nItMax) # -.001 #
c[:len(cG)] = cG
outputs[outName] = xndarray(c, axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_G')
outName = 'convergence_PRL'
c = np.zeros(self.nItMax) # -.001 #
c[:len(cC)] = cC
#ad = {'Conv_Criterion':np.arange(len(cA))}
outputs[outName] = xndarray(c, axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_C')
outName = 'convergence_FE'
c = np.zeros(self.nItMax) # -.001 #
c[:len(FE)] = FE
outputs[outName] = xndarray(c, axes_names=axes_names,
axes_domains=ad,
value_label='Conv_Criterion_FE')
logger.info("Convergence saved ")
#######################################################################
# SIMULATION
if self.simulation is not None and 0:
logger.info("Prepare parameters to compare if simulation")
M = labels.shape[0]
K = labels.shape[1]
J = labels.shape[2]
true_labels = np.zeros((M, J))
for m in xrange(0,M):
true_labels[m, :] = roiData.simulation[0]['labels'][m].flatten()
newlabels = np.reshape(labels[:, 1, :], (M, J))
#true_labels = roiData.simulation[0]['labels']
#newlabels = labels
se = []
sp = []
size = np.prod(labels.shape)
for i in xrange(0, 2): # (0, M):
se0, sp0, auc = roc_curve(newlabels[i, :].tolist(),
true_labels[i, :].tolist())
se.append(se0)
sp.append(sp0)
size = min(size, len(sp0))
SE = np.zeros((M, size), dtype=float)
SP = np.zeros((M, size), dtype=float)
for i in xrange(0, 2): # M):
tmp = np.array(se[i])
SE[i, :] = tmp[0:size]
tmp = np.array(sp[i])
SP[i, :] = tmp[0:size]
sensData, specData = SE, SP
axes_names = ['1-specificity', 'condition']
outName = 'ROC_audio'
#ad = {'1-specificity': specData[0], 'condition': cNames}
outputs[outName] = xndarray(sensData, axes_names=axes_names,
#axes_domains=ad,
value_label='sensitivity')
m = specData[0].min()
import matplotlib.font_manager as fm
import matplotlib.pyplot as plt
plt.figure(200)
plt.plot(sensData[0], specData[0], '--', color='k', linewidth=2.0,
label='m=1')
plt.hold(True)
plt.plot(sensData[1], specData[1], color='k', linewidth=2.0,
label='m=2')
# legend(('audio','video'))
plt.xticks(color='k', size=14, fontweight='bold')
plt.yticks(color='k', size=14, fontweight='bold')
#xlabel('1 - Specificity',fontsize=16,fontweight='bold')
# ylabel('Sensitivity',fontsize=16,fontweight='bold')
prop = fm.FontProperties(size=14, weight='bold')
plt.legend(loc=1, prop=prop)
plt.axis([0., 1., m, 1.02])
true_labels = roiData.simulation[0]['labels']
true_brls = roiData.simulation[0]['nrls']
true_prls = roiData.simulation[0]['prls']
true_brf = roiData.simulation[0]['hrf'][:, 0]
true_prf = roiData.simulation[0]['prf'][:, 0]
true_drift = roiData.simulation[0]['drift']
true_noise = roiData.simulation[0]['noise']
if simu is not None:
logger.info("Check parameters errors")
self.finalizeEstimation(true_labels, newlabels, nvox,
true_brf, estimated_brf,
true_prf, estimated_prf,
true_brls, brls.T,
true_prls, prls.T,
true_drift, PL, L,
true_noise, noiseVar)
# END SIMULATION
#######################################################################
d = {'parcel_size': np.array([nvox])}
outputs['analysis_duration'] = xndarray(np.array(
[self.analysis_duration]),
axes_names=['parcel_size'],
axes_domains=d)
"""outputs['rerror'] = xndarray(np.array( rerror),
axes_names=['parcel_size'])"""
return outputs
def analyse_roi(self, roiData):
#roiData is of type FmriRoiData, see pyhrf.core.FmriRoiData
# roiData.bold : numpy array of shape
## BOLD has shape (nscans, nvoxels)
#roiData.graph #list of neighbours
data = roiData.bold
Onsets = roiData.get_joined_onsets()
durations = roiData.get_joined_durations()
TR = roiData.tr
#K = 2 #number of classes
scale = 1#roiData.nbVoxels
nvox = roiData.get_nb_vox_in_mask()
if self.scale:
scale = nvox
rid = roiData.get_roi_id()
logger.info("JDE VEM - roi %d, nvox=%d, nconds=%d, nItMax=%d", rid,
nvox, len(Onsets), self.nItMax)
self.contrasts.pop('dummy_example', None)
cNames = roiData.paradigm.get_stimulus_names()
graph = roiData.get_graph()
t_start = time()
if self.fast:
logger.info("fast VEM with drift estimation"+
("and a constraint"*self.constrained))
(nb_iter, nrls_mean, hrf_mean, hrf_covar, labels_proba, noise_var,
nrls_class_mean, nrls_class_var, beta, drift_coeffs, drift,
contrasts_mean, contrasts_var, _, _, nrls_covar, _, density_ratio,
density_ratio_cano, density_ratio_diff, density_ratio_prod,
ppm_a_nrl, ppm_g_nrl, ppm_a_contrasts, ppm_g_contrasts,
variation_coeff, free_energy, free_energy_crit, beta_list,
delay_of_response, delay_of_undershoot, dispersion_of_response,
dispersion_of_undershoot, ratio_resp_under, delay) = jde_vem_bold(
graph, data, Onsets, durations, self.hrfDuration, self.nbClasses,
TR, self.beta, self.dt, self.estimateSigmaH, self.sigmaH, self.nItMax,
self.nItMin, self.estimateBeta, self.contrasts,
self.computeContrast, self.hyper_prior_sigma_H, self.estimateHRF,
constrained=self.constrained, zero_constraint=self.zero_constraint,
drifts_type=self.drifts_type
)
else:
# if not self.fast
if self.estimateDrifts:
logger.info("not fast VEM")
logger.info("NOT WORKING")
nrls_mean, hrf_mean, \
labels_proba, noise_var, nrls_class_mean, \
nrls_class_var, beta, drift_coeffs, \
drift = Main_vbjde_Python_constrained(graph,data,Onsets,
self.hrfDuration,self.nbClasses,
TR,beta,self.dt,scale,
self.estimateSigmaH,self.sigmaH,
self.nItMax,self.nItMin,
self.estimateBeta,self.PLOT)
# Plot analysis duration
self.analysis_duration = time() - t_start
logger.info('JDE VEM analysis took: %s',
format_duration(self.analysis_duration))
if self.fast:
### OUTPUTS: Pack all outputs within a dict
outputs = {}
hrf_time = np.arange(len(hrf_mean)) * self.dt
axes_names = ['iteration']
"""axes_domains = {'iteration':np.arange(FreeEnergy.shape[0])}
outputs['FreeEnergy'] = xndarray(FreeEnergy,
axes_names=axes_names,
axes_domains=axes_domains)
"""
outputs['hrf'] = xndarray(hrf_mean, axes_names=['time'],
axes_domains={'time':hrf_time},
value_label="HRF")
domCondition = {'condition': cNames}
outputs['nrls'] = xndarray(nrls_mean.transpose(), value_label="nrls",
axes_names=['condition','voxel'],
axes_domains=domCondition)
ad = {'condition': cNames,'condition2': Onsets.keys()}
outputs['Sigma_nrls'] = xndarray(nrls_covar, value_label="Sigma_NRLs",
axes_names=['condition', 'condition2', 'voxel'],
axes_domains=ad)
outputs['nb_iter'] = xndarray(np.array([nb_iter]), value_label="nb_iter")
outputs['beta'] = xndarray(beta, value_label="beta",
axes_names=['condition'],
axes_domains=domCondition)
nbc, nbv = len(cNames), nrls_mean.shape[0]
repeatedBeta = np.repeat(beta, nbv).reshape(nbc, nbv)
outputs['beta_mapped'] = xndarray(repeatedBeta, value_label="beta",
axes_names=['condition', 'voxel'],
axes_domains=domCondition)
repeated_hrf = np.repeat(hrf_mean, nbv).reshape(-1, nbv)
outputs["hrf_mapped"] = xndarray(repeated_hrf, value_label="HRFs",
axes_names=["time", "voxel"],
axes_domains={"time": hrf_time})
repeated_hrf_covar = np.repeat(np.diag(hrf_covar), nbv).reshape(-1, nbv)
outputs["hrf_variance_mapped"] = xndarray(repeated_hrf_covar,
value_label="HRFs covariance",
axes_names=["time", "voxel"],
axes_domains={"time": hrf_time})
outputs['roi_mask'] = xndarray(np.zeros(nbv)+roiData.get_roi_id(),
value_label="ROI",
axes_names=['voxel'])
outputs["density_ratio"] = xndarray(np.zeros(nbv)+density_ratio,
value_label="Density Ratio to zero",
axes_names=["voxel"])
outputs["density_ratio_cano"] = xndarray(np.zeros(nbv)+density_ratio_cano,
value_label="Density Ratio to canonical",
axes_names=["voxel"])
outputs["density_ratio_diff"] = xndarray(np.zeros(nbv)+density_ratio_diff,
value_label="Density Ratio to canonical",
axes_names=["voxel"])
outputs["density_ratio_prod"] = xndarray(np.zeros(nbv)+density_ratio_prod,
value_label="Density Ratio to canonical",
axes_names=["voxel"])
outputs["variation_coeff"] = xndarray(np.zeros(nbv)+variation_coeff,
value_label="Coefficient of variation of the HRF",
axes_names=["voxel"])
free_energy = np.concatenate((np.asarray(free_energy), np.zeros((self.nItMax - len(free_energy)))))
free_energy[free_energy == 0.] = np.nan
free_energy = np.repeat(free_energy, nbv).reshape(-1, nbv)
outputs["free_energy"] = xndarray(free_energy,
value_label="free energy",
axes_names=["time", "voxel"])
if self.estimateHRF:
fitting_parameters = {
"hrf_fit_delay_of_response": delay_of_response,
"hrf_fit_delay_of_undershoot": delay_of_undershoot,
"hrf_fit_dispersion_of_response": dispersion_of_response,
"hrf_fit_dispersion_of_undershoot": dispersion_of_undershoot,
"hrf_fit_ratio_response_undershoot": ratio_resp_under,
"hrf_fit_delay": delay,
}
affine = np.eye(4)
for param_name in fitting_parameters:
header = nibabel.Nifti1Header()
description = param_name[8:].replace("_", " ").capitalize()
outputs[param_name] = xndarray(
np.zeros(nbv)+fitting_parameters[param_name],
value_label=description + " of the fitted estimated HRF",
axes_names=["voxel"], meta_data=(affine, header)
)
outputs[param_name].meta_data[1]["descrip"] = description
h = hrf_mean
nrls_mean = nrls_mean.transpose()
nvox = nrls_mean.shape[1]
nbconds = nrls_mean.shape[0]
ah = np.zeros((h.shape[0], nvox, nbconds))
mixtp = np.zeros((roiData.nbConditions, self.nbClasses, 2))
mixtp[:, :, 0] = nrls_class_mean
mixtp[:, :, 1] = np.sqrt(nrls_class_var)
an = ['condition', 'Act_class', 'component']
ad = {'Act_class': ['inactiv', 'activ'],
'condition': cNames,
'component': ['mean', 'var']}
outputs['mixt_p'] = xndarray(mixtp, axes_names=an, axes_domains=ad)
ad = {'class': ['inactiv', 'activ'],
'condition': cNames}
outputs['labels'] = xndarray(labels_proba, value_label="Labels",
axes_names=['condition', 'class', 'voxel'],
axes_domains=ad)
outputs['noise_var'] = xndarray(noise_var,value_label="noise_var",
axes_names=['voxel'])
if self.estimateDrifts and self.output_drifts:
outputs['drift_coeff'] = xndarray(drift_coeffs, value_label="Drift",
axes_names=['coeff', 'voxel'])
outputs['drift'] = xndarray(drift, value_label="Delta BOLD",
axes_names=['time', 'voxel'])
affine = np.eye(4)
for condition_nb, condition_name in enumerate(cNames):
header = nibabel.Nifti1Header()
outputs["ppm_a_nrl_"+condition_name] = xndarray(ppm_a_nrl[:, condition_nb],
value_label="PPM NRL alpha fixed",
axes_names=["voxel"],
meta_data=(affine, header))
outputs["ppm_a_nrl_"+condition_name].meta_data[1]["descrip"] = condition_name
outputs["ppm_g_nrl_"+condition_name] = xndarray(ppm_g_nrl[:, condition_nb],
value_label="PPM NRL gamma fixed",
axes_names=["voxel"],
meta_data=(affine, header))
outputs["ppm_g_nrl_"+condition_name].meta_data[1]["descrip"] = condition_name
if (len(self.contrasts) > 0) and self.computeContrast:
#keys = list((self.contrasts[nc]) for nc in self.contrasts)
domContrast = {'contrast': self.contrasts.keys()}
outputs['contrasts'] = xndarray(contrasts_mean, value_label="Contrast",
axes_names=['voxel', 'contrast'],
axes_domains=domContrast)
#print 'contrast output:'
#print outputs['contrasts'].descrip()
c = xndarray(contrasts_var, value_label="Contrasts_Variance",
axes_names=['voxel', 'contrast'],
axes_domains=domContrast)
outputs['contrasts_variance'] = c
outputs['ncontrasts'] = xndarray(contrasts_mean/contrasts_var**.5,
value_label="Normalized Contrast",
axes_names=['voxel', 'contrast'],
axes_domains=domContrast)
for i, contrast in enumerate(self.contrasts.keys()):
header = nibabel.Nifti1Header()
outputs["ppm_a_"+contrast] = xndarray(ppm_a_contrasts[:, i],
value_label="PPM Contrasts alpha fixed",
axes_names=["voxel"],
meta_data=(affine, header))
outputs["ppm_a_"+contrast].meta_data[1]["descrip"] = contrast
outputs["ppm_g_"+contrast] = xndarray(ppm_g_contrasts[:, i],
value_label="PPM Contrasts gamma fixed",
axes_names=["voxel"],
meta_data=(affine, header))
outputs["ppm_g_"+contrast].meta_data[1]["descrip"] = contrast
################################################################################
# SIMULATION
if self.simulation and self.fast:
labels_vem_audio = roiData.simulation[0]['labels'][0]
labels_vem_video = roiData.simulation[0]['labels'][1]
M = labels_proba.shape[0]
K = labels_proba.shape[1]
J = labels_proba.shape[2]
true_labels = np.zeros((K,J))
true_labels[0,:] = np.reshape(labels_vem_audio,(J))
true_labels[1,:] = np.reshape(labels_vem_video,(J))
newlabels = np.reshape(labels_proba[:,1,:],(M,J))
se = []
sp = []
size = np.prod(labels_proba.shape)
for i in xrange(0,M):
se0,sp0, auc = roc_curve(newlabels[i,:].tolist(),
true_labels[i,:].tolist())
se.append(se0)
sp.append(sp0)
size = min(size,len(sp0))
SE = np.zeros((M,size),dtype=float)
SP = np.zeros((M,size),dtype=float)
for i in xrange(0,M):
tmp = np.array(se[i])
SE[i,:] = tmp[0:size]
tmp = np.array(sp[i])
SP[i,:] = tmp[0:size]
sensData, specData = SE, SP
axes_names = ['condition','1-specificity']
outName = 'ROC_audio'
ad = {'1-specificity':specData[0],'condition':cNames}
outputs[outName] = xndarray(sensData, axes_names=axes_names,
axes_domains=ad,
value_label='sensitivity')
m = specData[0].min()
import matplotlib.font_manager as fm
figure(200)
plot(sensData[0],specData[0],'--',color='k',linewidth=2.0,label='m=1')
hold(True)
plot(sensData[1],specData[1],color='k',linewidth=2.0,label='m=2')
#legend(('audio','video'))
xticks(color = 'k', size = 14,fontweight='bold')
yticks(color = 'k', size = 14,fontweight='bold')
#xlabel('1 - Specificity',fontsize=16,fontweight='bold')
#ylabel('Sensitivity',fontsize=16,fontweight='bold')
prop = fm.FontProperties(size=14,weight='bold')
legend(loc=1,prop=prop)
axis([0., 1., m, 1.02])
if hasattr(roiData.simulation, 'nrls'):
true_labels = roiData.simulation.nrls.labels
true_nrls = roiData.simulation.nrls.data
elif isinstance(roiData.simulation, dict) and \
roiData.simulation.has_key('labels') and \
roiData.simulation.has_key('nrls') :
true_labels = roiData.simulation['labels']
true_nrls = roiData.simulation['nrls']
else:
raise Exception('Simulation can not be retrieved from %s' \
%str(roiData.simulation))
domCondition = {'condition':cNames}
outputs['Truenrls'] = xndarray(true_nrls,value_label="True_nrls",
axes_names=['condition','voxel'],
axes_domains=domCondition)
M = labels_proba.shape[0]
K = labels_proba.shape[1]
J = labels_proba.shape[2]
newlabels = np.reshape(labels_proba[:,1,:],(M,J))
for i in xrange(0,M):
se0,sp0, auc = roc_curve(newlabels[i,:].tolist(),
true_labels[i,:].tolist())
se.append(se0)
sp.append(sp0)
size = min(size,len(sp0))
SE = np.zeros((M,size),dtype=float)
SP = np.zeros((M,size),dtype=float)
for i in xrange(0,M):
tmp = np.array(se[i])
SE[i,:] = tmp[0:size]
tmp = np.array(sp[i])
SP[i,:] = tmp[0:size]
# END SIMULATION
##########################################################################
if self.fast:
d = {'parcel_size': np.array([nvox])}
outputs['analysis_duration'] = xndarray(np.array([self.analysis_duration]),
axes_names=['parcel_size'],
axes_domains=d)
return outputs
def MiniVEM_CompMod(Thrf, TR, dt, beta, Y, K, gamma, gradientStep, MaxItGrad, D, M, N, J, S, maxNeighbours, neighboursIndexes, XX, X, R, Det_invR, Gamma, Det_Gamma, p_Wtilde, scale, Q_barnCond, XGamma, tau1, tau2, Nit, sigmaH, estimateHRF):
# print 'InitVar =',InitVar,', InitMean =',InitMean,', gamma_h
# =',gamma_h
Init_sigmaH = sigmaH
IM_val = np.array([-5., 5.])
IV_val = np.array([0.008, 0.016, 0.032, 0.064, 0.128, 0.256, 0.512])
#IV_val = np.array([0.01,0.05,0.1,0.5])
gammah_val = np.array([1000])
MiniVemStep = IM_val.shape[0] * IV_val.shape[0] * gammah_val.shape[0]
Init_mixt_p_gammah = []
logger.info("Number of tested initialisation is %s", MiniVemStep)
t1_MiniVEM = time.time()
FE = []
for Gh in gammah_val:
for InitVar in IV_val:
for InitMean in IM_val:
Init_mixt_p_gammah += [[InitVar, InitMean, Gh]]
sigmaH = Init_sigmaH
sigma_epsilone = np.ones(J)
if 0:
logger.info(
"Labels are initialized by setting active probabilities to zeros ...")
q_Z = np.ones((M, K, J), dtype=np.float64)
q_Z[:, 1, :] = 0
if 0:
logger.info("Labels are initialized randomly ...")
q_Z = np.zeros((M, K, J), dtype=np.float64)
nbVoxInClass = J / K
for j in xrange(M):
if J % 2 == 0:
l = []
else:
l = [0]
for c in xrange(K):
l += [c] * nbVoxInClass
q_Z[j, 0, :] = np.random.permutation(l)
q_Z[j, 1, :] = 1. - q_Z[j, 0, :]
if 1:
logger.info(
"Labels are initialized by setting active probabilities to ones ...")
q_Z = np.zeros((M, K, J), dtype=np.float64)
q_Z[:, 1, :] = 1
# TT,m_h = getCanoHRF(Thrf-dt,dt) #TODO: check
TT, m_h = getCanoHRF(Thrf, dt) # TODO: check
m_h = m_h[:D]
m_H = np.array(m_h).astype(np.float64)
if estimateHRF:
Sigma_H = np.ones((D, D), dtype=np.float64)
else:
Sigma_H = np.zeros((D, D), dtype=np.float64)
Beta = beta * np.ones((M), dtype=np.float64)
P = PolyMat(N, 4, TR)
L = polyFit(Y, TR, 4, P)
PL = np.dot(P, L)
y_tilde = Y - PL
Ndrift = L.shape[0]
gamma_h = Gh
sigma_M = np.ones((M, K), dtype=np.float64)
sigma_M[:, 0] = 0.1
sigma_M[:, 1] = 1.0
mu_M = np.zeros((M, K), dtype=np.float64)
for k in xrange(1, K):
mu_M[:, k] = InitMean
Sigma_A = np.zeros((M, M, J), np.float64)
for j in xrange(0, J):
Sigma_A[:, :, j] = 0.01 * np.identity(M)
m_A = np.zeros((J, M), dtype=np.float64)
for j in xrange(0, J):
for m in xrange(0, M):
for k in xrange(0, K):
m_A[j, m] += np.random.normal(
mu_M[m, k], np.sqrt(sigma_M[m, k])) * q_Z[m, k, j]
for ni in xrange(0, Nit + 1):
logger.info("------------------------------ Iteration n° " +
str(ni + 1) + " ------------------------------")
UtilsC.expectation_A(q_Z, mu_M, sigma_M, PL, sigma_epsilone, Gamma,
Sigma_H, Y, y_tilde, m_A, m_H, Sigma_A, XX.astype(int32), J, D, M, N, K)
val = np.reshape(m_A, (M * J))
val[np.where((val <= 1e-50) & (val > 0.0))] = 0.0
val[np.where((val >= -1e-50) & (val < 0.0))] = 0.0
m_A = np.reshape(val, (J, M))
if estimateHRF:
UtilsC.expectation_H(XGamma, Q_barnCond, sigma_epsilone, Gamma, R, Sigma_H, Y, y_tilde, m_A, m_H, Sigma_A, XX.astype(
int32), J, D, M, N, scale, sigmaH)
m_H[0] = 0
m_H[-1] = 0
UtilsC.expectation_Z_ParsiMod_3(
Sigma_A, m_A, sigma_M, Beta, p_Wtilde, mu_M, q_Z, neighboursIndexes.astype(int32), M, J, K, maxNeighbours)
val = np.reshape(q_Z, (M * K * J))
val[np.where((val <= 1e-50) & (val > 0.0))] = 0.0
q_Z = np.reshape(val, (M, K, J))
if estimateHRF:
if gamma_h > 0:
sigmaH = maximization_sigmaH_prior(
D, Sigma_H, R, m_H, gamma_h)
else:
sigmaH = maximization_sigmaH(D, Sigma_H, R, m_H)
mu_M, sigma_M = maximization_mu_sigma(
mu_M, sigma_M, q_Z, m_A, K, M, Sigma_A)
UtilsC.maximization_L(
Y, m_A, m_H, L, P, XX.astype(int32), J, D, M, Ndrift, N)
PL = np.dot(P, L)
y_tilde = Y - PL
for m in xrange(0, M):
Beta[m] = UtilsC.maximization_beta(beta, q_Z[m, :, :].astype(float64), q_Z[m, :, :].astype(
float64), J, K, neighboursIndexes.astype(int32), gamma, maxNeighbours, MaxItGrad, gradientStep)
UtilsC.maximization_sigma_noise(
Gamma, PL, sigma_epsilone, Sigma_H, Y, m_A, m_H, Sigma_A, XX.astype(int32), J, D, M, N)
FreeEnergy = Compute_FreeEnergy(y_tilde, m_A, Sigma_A, mu_M, sigma_M, m_H, Sigma_H, R, Det_invR, sigmaH, p_Wtilde, tau1,
tau2, q_Z, neighboursIndexes, maxNeighbours, Beta, sigma_epsilone, XX, Gamma, Det_Gamma, XGamma, J, D, M, N, K, S, "CompMod")
FE += [FreeEnergy]
max_FE, max_FE_ind = maximum(FE)
InitVar = Init_mixt_p_gammah[max_FE_ind][0]
InitMean = Init_mixt_p_gammah[max_FE_ind][1]
Initgamma_h = Init_mixt_p_gammah[max_FE_ind][2]
t2_MiniVEM = time.time()
logger.info(
"MiniVEM duration is %s", format_duration(t2_MiniVEM - t1_MiniVEM))
logger.info("Choosed initialisation is : var = %s, mean = %s, gamma_h = %s",
InitVar, InitMean, Initgamma_h)
return InitVar, InitMean, Initgamma_h
def run_pyhrf_cmd_treatment(cfg_cmd, exec_cmd, default_cfg_file,
default_profile_file, label_for_cluster):
usage = 'usage: %%prog [options]'
description = 'Manage a joint detection-estimation treatment of fMRI data.' \
'This command runs the treatment defined in an xml '\
'parameter file. See pyhrf_jde_buildcfg command to build a'\
'template of such a file. If no xml file found, then runs a '\
'default example analysis.'
parser = OptionParser(usage=usage, description=description)
parser.add_option('-c',
'--input-cfg-file',
metavar='XMLFILE',
dest='cfgFile',
default=default_cfg_file,
help='Configuration file: XML file containing parameters'
' defining input data and analysis to perform.')
parser.add_option('-r',
'--roi-data',
metavar='PICKLEFILE',
dest='roidata',
default=None,
help='Input fMRI ROI data. The data '
'definition part in the config file is ignored.')
parser.add_option('-t',
'--treatment_pck',
metavar='PICKLEFILE',
dest='treatment_pck',
default=None,
help='Input treatment as a pickle dump.'
'The XML cfg file is ignored')
parser.add_option('-s',
'--stop-on-error',
dest='stop_on_error',
action='store_true',
default=False,
help='For debug: do not continue if error'
' during one ROI analysis')
parser.add_option('-v',
'--verbose',
dest='verbose',
metavar='INTEGER',
type='int',
default=0,
help=pformat(pyhrf.verbose_levels))
parser.add_option(
'-p',
'--profile',
action='store_true',
default=False,
help='Enable profiling of treatment. Store profile data in '
'%s. NOTE: not avalaible in parallel mode.' % default_profile_file)
parallel_choices = ['LAN', 'local', 'cluster']
parser.add_option('-x',
'--parallel',
choices=parallel_choices,
help='Parallel processing. Choices are %s' %
string.join(parallel_choices, ', '))
(options, args) = parser.parse_args()
# pyhrf.verbose.set_verbosity(options.verbose)
pyhrf.logger.setLevel(options.verbose)
t0 = time.time()
if options.treatment_pck is not None:
f = open(options.treatment_pck)
treatment = cPickle.load(f)
f.close()
else:
if not os.path.exists(options.cfgFile):
print 'Error: could not find default configuration file "%s"\n'\
'Consider running "%s" to generate it.' \
% (options.cfgFile, cfg_cmd)
sys.exit(1)
else:
logger.info('Loading configuration from: "%s" ...',
options.cfgFile)
f = open(options.cfgFile, 'r')
sXml = string.join(f.readlines())
f.close()
treatment = xmlio.from_xml(sXml)
if 0:
sXml = xmlio.to_xml(treatment)
f = './treatment_cmd.xml'
fOut = open(f, 'w')
fOut.write(sXml)
fOut.close()
treatment.analyser.set_pass_errors(not options.stop_on_error)
if options.parallel is not None:
treatment.run(parallel=options.parallel)
else:
if options.roidata is not None:
logger.info('Loading ROI data from: "%s" ...', options.roidata)
roidata = cPickle.load(open(options.roidata))
roidata.verbosity = logger.getEffectiveLevel()
if logger.getEffectiveLevel() <= logging.INFO:
print roidata.getSummary()
# TODO: enable profiling
logger.info('Launching analysis ...')
if options.profile:
cProfile.runctx("result = treatment.analyser(roidata)",
globals(), {
'treatment': treatment,
'roidata': roidata
}, default_profile_file)
else:
result = treatment.analyser(roidata)
outPath = op.dirname(op.abspath(options.roidata))
fOut = op.join(outPath, "result_%04d.pck" % roidata.get_roi_id())
logger.info('Dumping results to %s ...', fOut)
f = open(fOut, 'w')
cPickle.dump(result, f)
f.close()
else:
logger.info('ROI data is none')
if options.profile:
cProfile.runctx("treatment.run()", globals(),
{'treatment': treatment}, default_profile_file)
else:
treatment.run()
logger.info('Estimation done, took %s', format_duration(time.time() - t0))
