def searchlight(ds, **kwargs): if __debug__: debug.active += ["SLC"] radius = 3 for arg in kwargs: if (arg == 'radius'): radius = kwargs[arg] """ [fclf, cvte] = setup_classifier(**kwargs) """ clf = LinearCSVMC(C=1, probability=1, enable_ca=['probabilities']) cv = CrossValidation(clf, HalfPartitioner(attr='chunks')) sl = sphere_searchlight(cv, radius, space = 'voxel_indices') #sl = Searchlight(MahalanobisMeasure, queryengine, add_center_fa, results_postproc_fx, results_backend, results_fx, tmp_prefix, nblocks) #sl = sphere_searchlight(MahalanobisMeasure(), 3, space= 'voxel_indices') sl_map = sl(ds) sl_map.samples *= -1 sl_map.samples += 1 nif = map2nifti(sl_map, imghdr=ds.a.imghdr) nif.set_qform(ds.a.imgaffine) #Results packing d_result = dict({'map': nif, 'radius': radius}) return d_result
def searchlight(ds, **kwargs): if __debug__: debug.active += ["SLC"] radius = 3 for arg in kwargs: if (arg == 'radius'): radius = kwargs[arg] """ [fclf, cvte] = setup_classifier(**kwargs) """ clf = LinearCSVMC(C=1, probability=1, enable_ca=['probabilities']) cv = CrossValidation(clf, HalfPartitioner(attr='chunks')) sl = sphere_searchlight(cv, radius, space='voxel_indices') #sl = Searchlight(MahalanobisMeasure, queryengine, add_center_fa, results_postproc_fx, results_backend, results_fx, tmp_prefix, nblocks) #sl = sphere_searchlight(MahalanobisMeasure(), 3, space= 'voxel_indices') sl_map = sl(ds) sl_map.samples *= -1 sl_map.samples += 1 nif = map2nifti(sl_map, imghdr=ds.a.imghdr) nif.set_qform(ds.a.imgaffine) #Results packing d_result = dict({'map': nif, 'radius': radius}) return d_result
def main(): sac_attr = SampleAttributes(TSTATS_DIR + 'sac_attr.txt') nav_attr = SampleAttributes(TSTATS_DIR + 'nav_bin_attr.txt') # labels xtask_run = [ # down/powerless, up/powerful [1, 2], # down/powerless [2, 1], # up/powerful ] intask_run = [ # no comparison within a task [0, 0], [0, 0] ] labels = squareform( np.vstack([np.hstack([intask_run] * 6 + [xtask_run] * 2)] * 6 + [np.hstack([xtask_run] * 6 + [intask_run] * 2)] * 2)) for subj in subject_list: subj_mask = MASK_DIR + '%s_ribbon_rsmp0_dil3mm.nii.gz' % subj dataset = get_nav_sac_data(nav_attr, sac_attr, subj, subj_mask) dataset = remove_invariant_features(dataset) print(dataset.targets, dataset.chunks) # searchlight similarity = CustomDist(labels) searchlight = sphere_searchlight(similarity, SEARCHLIGHT_RADIUS) searchlight_map = searchlight(dataset) # save files nifti = map2nifti(data=searchlight_map, dataset=dataset) nifti.to_filename(OUTDIR + '%s_%s_%dvox_sim.nii.gz' % (subj, DIRCT, SEARCHLIGHT_RADIUS))
def sl2nifti(ds,remap,outfile): ''' No return; converts sl output and saves nifti file to working directory ds=array of sl results remap: dataset to remap to outfile: string outfile name including extension .nii.gz ''' nimg = map2nifti(data=ds,dataset=remap) nimg.to_filename(outfile)
def main(): subject_list = sys.argv[1:] if len(sys.argv) > 1 else EVERYONE print(subject_list) attr = SampleAttributes(TSTATS_DIR + TSTATS_NAME + '_attr.txt') for subj in subject_list: tstats_file = TSTATS_DIR + TSTATS_NAME + '_tstats/%s_%s.nii.gz' % ( subj, TSTATS_NAME) dataset = fmri_dataset(samples=tstats_file, mask=MASK_DIR + '%s_ribbon_rsmp0_dil3mm.nii.gz' % subj) dataset.sa['chunks'] = attr.chunks dataset.sa['targets'] = attr.targets dataset = remove_invariant_features(dataset) similarity = CustomDist(squareform(LABELS_NAV)) searchlight = sphere_searchlight(similarity, SEARCHLIGHT_RADIUS) searchlight_map = searchlight(dataset) # save files nifti = map2nifti(data=searchlight_map, dataset=dataset) nifti.to_filename(OUTDIR + OUTFILE % (subj, SEARCHLIGHT_RADIUS))
def spatial(ds, **kwargs): # gc.enable() # gc.set_debug(gc.DEBUG_LEAK) cvte = None permutations = 0 for arg in kwargs: if arg == 'clf_type': clf_type = kwargs[arg] if arg == 'enable_results': enable_results = kwargs[arg].split(',') if arg == 'permutations': permutations = int(kwargs[arg]) if arg == 'cvte': cvte = kwargs[arg] fclf = cvte.learner # Send crossvalidation object if cvte == None: [fclf, cvte] = setup_classifier(**kwargs) logger.info('Cross validation is performing ...') error_ = cvte(ds) logger.debug(cvte.ca.stats) #print error_.samples #Plot permutations #plot_cv_results(cvte, error_, 'Permutations analysis') if permutations != 0: dist_len = len(cvte.null_dist.dists()) err_arr = np.zeros(dist_len) for i in range(dist_len): err_arr[i] = 1 - cvte.ca.stats.stats['ACC'] total_p_value = np.mean(cvte.null_dist.p(err_arr)) p_value = cvte.ca.null_prob.samples else: p_value = np.array([0, 0]) total_p_value = 0 predictions_ds = fclf.predict(ds) # If classifier didn't have sensitivity try: sensana = fclf.get_sensitivity_analyzer() except Exception as err: allowed_keys = [ 'map', 'sensitivities', 'stats', 'mapper', 'classifier', 'ds_src', 'perm_pvalue', 'p' ] allowed_results = [ None, None, cvte.ca.stats, ds.a.mapper, fclf, ds, p_value, total_p_value ] results_dict = dict(zip(allowed_keys, allowed_results)) results = dict() if not 'enable_results' in locals(): enable_results = allowed_keys[:] for elem in enable_results: if elem in allowed_keys: results[elem] = results_dict[elem] return results res_sens = sensana(ds) sens_comb = res_sens.get_mapped(mean_sample()) mean_map = map2nifti(ds, ds.a.mapper.reverse1(sens_comb)) l_maps = [] for m in res_sens: maps = ds.a.mapper.reverse1(m) nifti = map2nifti(ds, maps) l_maps.append(nifti) l_maps.append(mean_map) # Packing results (to be sobstitute with a function) results = dict() classifier = fclf allowed_keys = [ 'map', 'sensitivities', 'stats', 'mapper', 'classifier', 'ds_src', 'pvalue', 'p' ] allowed_results = [ l_maps, res_sens, cvte.ca.stats, ds.a.mapper, classifier, ds, p_value, total_p_value ] results_dict = dict(zip(allowed_keys, allowed_results)) if not 'enable_results' in locals(): enable_results = allowed_keys[:] for elem in enable_results: if elem in allowed_keys: results[elem] = results_dict[elem] else: logger.error('******** ' + elem + ' result is not allowed! *********') return results
results_dict = dict(zip(allowed_keys, allowed_results)) results = dict() if not 'enable_results' in locals(): enable_results = allowed_keys[:] for elem in enable_results: if elem in allowed_keys: results[elem] = results_dict[elem] return results res_sens = sensana(ds) sens_comb = res_sens.get_mapped(mean_sample()) mean_map = map2nifti(ds, ds.a.mapper.reverse1(sens_comb)) l_maps = [] for m in res_sens: maps = ds.a.mapper.reverse1(m) nifti = map2nifti(ds, maps) l_maps.append(nifti) l_maps.append(mean_map) # Packing results (to be sobstitute with a function) results = dict() classifier = fclf
f.close # display results P.figure() P.title( str(N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1)) + '%, n-fold SMLR with anova FS x 500') foldwiseCvedAnovaSelectedSMLR.ca.stats.plot() P.savefig( os.path.join( sessionPath, 'confMatrixAvTrial{0}-{1}-LanguageThinking-Japanese_English.png'. format(boldDelay, stimulusWidth))) print foldwiseCvedAnovaSelectedSMLR.ca.stats.matrix print 'accuracy', N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1), '%', datetime.datetime.now() # this should give average anova measure over the folds - but in fact would be much the same as taking over single fold sensana = anovaSelectedSMLR.get_sensitivity_analyzer( postproc=M.maxofabs_sample()) cv_sensana = M.RepeatedMeasure(sensana, M.NFoldPartitioner()) sens = cv_sensana(dataset) print sens.shape M.map2nifti(dataset, N.mean(sens, 0)).to_filename( "anovaSensitivity{0}-{1}-LanguageThink-Japanese_English.nii".format( boldDelay, stimulusWidth)) # this looks good, but don't know way to get back from this feature selected space (of 500) to the whole space of 28k or so, for output weights = anovaSelectedSMLR.clf.weights
def buildremapper(ds_type, sub, data, rootdir = '.', anatdir = 'ses-movie/anat', rois=['FFA', 'LOC', 'PPA', 'VIS', 'EBA', 'OFA'], ): """During the hdf5 dataset creation, wrapping information was lost :-( This function attempts to recover this information: For full datasets, we load the brain group template -- for stripped ds, we build a new mask of only ROIs of the participants. Loading this as an fmri_dataset back into the analysis should yield a wrapper, that we can get the dataset lacking a wrapper 'get_wrapped'. """ # TODO: define rootdir, anatdir less hardcoded # Q: do I need to load participants brain warped into groupspace individually or is one general enough? if ds_type == 'full': brain = 'sourcedata/tnt/{}/bold3Tp2/in_grpbold3Tp2/head.nii.gz'.format(sub) mask = 'sourcedata/tnt/{}/bold3Tp2/in_grpbold3Tp2/brain_mask.nii.gz'.format(sub) #maybe take the study-template here. # brain = 'sourcedata/tnt/templates/grpbold3Tp2/brain.nii.gz' # head = 'sourcedata/tnt/templates/grpbold3Tp2/head.nii.gz' dummy = mv.fmri_dataset(brain, mask=mask) # # WIP -- still debating whether this is necessary. # elif ds_type == 'stripped': # # if the dataset is stripped, we have to make a custom mask... yet pondering whether that is worth the work... # # we have to build the masks participant-wise, because each participant has custom masks per run (possibly several)... # # create a dummy outlay: (first dim of hrf estimates should be number of voxel) # all_rois_mask = np.array([['placeholder'] * data.shape[1]]).astype('S10') # for roi in rois: # if roi == 'VIS': # roi_fns = sorted(glob(rootdir + participant + anatdir + \ # '{0}_*_mask_tmpl.nii.gz'.format(roi))) # else: # if bilateral: # # if its bilateralized we don't need to segregate based on hemispheres # # else: # # we need to segregate based on hemispheres # left_roi_fns = sorted(glob(rootdir + participant + anatdir + \ # 'l{0}*mask_tmpl.nii.gz'.format(roi))) # right_roi_fns = sorted(glob(rootdir + participant + anatdir + \ # 'r{0}*mask_tmpl.nii.gz'.format(roi))) # roi_fns = left_roi_fns + right_roi_fns # if len(roi_fns) > 1: # # if there are more than 1 mask, combine them # roi_mask = np.sum([mv.fmri_dataset(roi_fn, mask=mask_fn).samples for roi_fn in roi_fns], axis=0) # # Set any voxels that might exceed 1 to 1 # roi_mask = np.where(roi_mask > 0, 1, 0) # elif len(roi_fns) == 0: # # if there are no masks, we get zeros # print("ROI {0} does not exist for participant {1}; appending all zeros".format(roi, participant)) # roi_mask = np.zeros((1, data_ds.shape[1])) # elif len(roi_fns) == 1: # roi_mask = mv.fmri_dataset(roi_fns[0], mask=mask_fn).samples # ## continue here # now that we have a dummy ds with a wrapper, we can project the betas into a brain --> map2nifti # does that. If we save that, we should be able to load it into FSL. return mv.map2nifti(dummy, data)
f = open("withinPredictionResult.csv", "a") f.write(st) f.close # display results P.figure() P.title( str(N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1)) + '%, n-fold SMLR with anova FS x 500') foldwiseCvedAnovaSelectedSMLR.ca.stats.plot() P.savefig( os.path.join( sessionPath, 'confMatrixAvTrial{0}-{1}-keepswitch.png'.format( boldDelay, stimulusWidth))) print foldwiseCvedAnovaSelectedSMLR.ca.stats.matrix print 'accuracy', N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1), '%', datetime.datetime.now() # this should give average anova measure over the folds - but in fact would be much the same as taking over single fold sensana = anovaSelectedSMLR.get_sensitivity_analyzer( postproc=M.maxofabs_sample()) cv_sensana = M.RepeatedMeasure(sensana, M.NFoldPartitioner()) sens = cv_sensana(dataset) print sens.shape M.map2nifti(dataset, N.mean(sens, 0)).to_filename( "anovaSensitivity{0}-{1}-keepswitch.nii".format(boldDelay, stimulusWidth)) # this looks good, but don't know way to get back from this feature selected space (of 500) to the whole space of 28k or so, for output weights = anovaSelectedSMLR.clf.weights
def make_neurimg(parent_ds,child_ds): parent_ds.samples = child_ds print(parent_ds.shape) nimg = mvpa2.map2nifti(parent_ds) return nimg
level = '/narps_level2' msk = pwd + model_dir + '/narps_level3/interceptAllSubs.gfeat/cope1.feat/intercept_msk.nii.gz' cope_num = 3 #1 intercept, 2 sv, 3 de work_dir = pwd + model_dir + level fldrs = os.listdir(work_dir) fldrs.sort() for fldr in fldrs: print(fldr) sub_fldr = work_dir + '/' + fldr z_stat1 = sub_fldr + '/cope' + str(cope_num) + '.feat/stats/zstat1.nii.gz' #cope3.feat is for entropy ds_tmp = mvpa2.fmri_dataset(z_stat1) ds_tmp.samples = ds_tmp.samples*-1 nimg = mvpa2.map2nifti(ds_tmp) nimg.to_filename(sub_fldr + '/cope' + str(cope_num) + '.feat/stats/zstat2.nii.gz') #compute which var wins w.r.t. absolute value mn_dir = '/second_level_diffs/signed_diffs/flip_DE_sign' #'/second_level_diffs/signed_diffs/zstat1s' # entropies = pwd + model_dir + mn_dir + '/entropies_z.nii.gz' subvals = pwd + model_dir + mn_dir + '/subval_z.nii.gz' ds_DE = mvpa2.fmri_dataset(entropies) ds_SV = mvpa2.fmri_dataset(subvals) ds_DE_mn = np.mean(ds_DE.samples,axis=0) ds_SV_mn = np.mean(ds_SV.samples,axis=0) DE_msk = np.abs(ds_DE_mn)>np.abs(ds_SV_mn) SV_msk = np.abs(ds_DE_mn)<np.abs(ds_SV_mn)
res = 1-sd.pdist(np.hstack((evds[evds.sa.subj==self._subj1].samples,evds[evds.sa.subj==self._subj2].samples)).T,'correlation') return mvpa.Dataset(np.array(res)[np.newaxis]) # Call inter-subject correlation measure cor = Corr(subj1,subj2) # Prepare single voxel Searchlight sl = mvpa.Searchlight(cor, mvpa.IndexQueryEngine( voxel_indices=mvpa.Sphere(0)), nproc=int(nproc)) #Iterate the inter-subject correlation measure over all voxels slmap = sl(evds) # Name the output filename = 'sl_'+subj1+'_'+subj2+dsfile # Mapping of the searchlight results into group template space nimg = mvpa.map2nifti(ds, slmap.samples[:,:ds.nfeatures], imghdr=ds.a.imghdr) #Save result as nifti in maps directory try: os.mkdir(os.path.join(path,'maps')) except: print 'maps directory already exists' # Save result as nifti in maps directory nb.Nifti1Image(nimg.get_data(), nimg.get_header().get_best_affine() ).to_filename(os.path.join(path,'maps',filename + '_univariate.nii.gz'))
conf['label_included'] = ','.join([str(n) for n in np.array([-5,-3,-1,1,3,5])]) ds = preprocess_dataset(ds, task_, **conf) ds.targets = np.float_(ds.targets) ds.targets = (ds.targets - np.mean(ds.targets))/np.std(ds.targets) cv = CrossValidation(slsim.RegressionMeasure(), partitioner, #NFoldPartitioner(cvtype=1), errorfx=None ) kwa = dict(voxel_indices=Sphere(3)) queryengine = IndexQueryEngine(**kwa) sl = Searchlight(cv, queryengine=queryengine) map_ = sl(ds) map_nii = map2nifti(map_, imghdr=ds.a.imghdr) name = "%s_%s_regression_fold_%s" %(subj, task_, str(i)) result_dict['radius'] = 3 result_dict['map'] = map_nii subj_result = rs.SubjectResult(name, result_dict, savers) collection.add(subj_result)
evds[evds.sa.subj == self._subj2].samples)).T, 'correlation') return mvpa.Dataset(np.array(res)[np.newaxis]) # Call inter-subject correlation measure cor = Corr(subj1, subj2) # Prepare single voxel Searchlight sl = mvpa.Searchlight(cor, mvpa.IndexQueryEngine(voxel_indices=mvpa.Sphere(0)), nproc=int(nproc)) #Iterate the inter-subject correlation measure over all voxels slmap = sl(evds) # Name the output filename = 'sl_' + subj1 + '_' + subj2 + dsfile # Mapping of the searchlight results into group template space nimg = mvpa.map2nifti(ds, slmap.samples[:, :ds.nfeatures], imghdr=ds.a.imghdr) #Save result as nifti in maps directory try: os.mkdir(os.path.join(path, 'maps')) except: print 'maps directory already exists' # Save result as nifti in maps directory nb.Nifti1Image(nimg.get_data(), nimg.get_header().get_best_affine()).to_filename( os.path.join(path, 'maps', filename + '_univariate.nii.gz'))
def spatiotemporal(ds, **kwargs): onset = 0 for arg in kwargs: if (arg == 'onset'): onset = kwargs[arg] if (arg == 'duration'): duration = kwargs[arg] if (arg == 'enable_results'): enable_results = kwargs[arg] if (arg == 'permutations'): permutations = int(kwargs[arg]) events = find_events(targets=ds.sa.targets, chunks=ds.sa.chunks) if 'duration' in locals(): events = [e for e in events if e['duration'] >= duration] else: duration = np.min([ev['duration'] for ev in events]) for e in events: e['onset'] += onset e['duration'] = duration evds = eventrelated_dataset(ds, events=events) [fclf, cvte] = setup_classifier(**kwargs) logger.info('Cross validation is performing ...') res = cvte(evds) print(cvte.ca.stats) if permutations != 0: print(cvte.ca.null_prob.samples) dist_len = len(cvte.null_dist.dists()) err_arr = np.zeros(dist_len) for i in range(dist_len): err_arr[i] = 1 - cvte.ca.stats.stats['ACC'] total_p_value = np.mean(cvte.null_dist.p(err_arr)) p_value = cvte.ca.null_prob.samples else: total_p_value = 0. p_value = np.array([0, 0]) try: sensana = fclf.get_sensitivity_analyzer() res_sens = sensana(evds) except Exception as err: allowed_keys = [ 'map', 'sensitivities', 'stats', 'mapper', 'classifier', 'ds', 'perm_pvalue', 'p' ] allowed_results = [ None, None, cvte.ca.stats, evds.a.mapper, fclf, evds, p_value, total_p_value ] results_dict = dict(zip(allowed_keys, allowed_results)) results = dict() if not 'enable_results' in locals(): enable_results = allowed_keys[:] for elem in enable_results: if elem in allowed_keys: results[elem] = results_dict[elem] return results sens_comb = res_sens.get_mapped(mean_sample()) mean_map = map2nifti(evds, evds.a.mapper.reverse1(sens_comb)) l_maps = [] for m in res_sens: maps = ds.a.mapper.reverse1(m) nifti = map2nifti(evds, maps) l_maps.append(nifti) l_maps.append(mean_map) # Packing results (to be sobstitute with a function) results = dict() if not 'enable_results' in locals(): enable_results = [ 'map', 'sensitivities', 'stats', 'mapper', 'classifier', 'ds', 'pvalue', 'p' ] allowed_keys = [ 'map', 'sensitivities', 'stats', 'mapper', 'classifier', 'ds', 'pvalue', 'p' ] allowed_results = [ l_maps, res_sens, cvte.ca.stats, evds.a.mapper, fclf, evds, p_value, total_p_value ] results_dict = dict(zip(allowed_keys, allowed_results)) for elem in enable_results: if elem in allowed_keys: results[elem] = results_dict[elem] else: print('******** ' + elem + ' result is not allowed! *********') return results
st=str(boldDelay) + ',' + str(stimulusWidth) + ',' + str(precision) +'\n' f = open( "withinPredictionResult.csv", "a" ) f.write(st) f.close # display results P.figure() P.title(str(N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1))+'%, n-fold SMLR with anova FS x 500') foldwiseCvedAnovaSelectedSMLR.ca.stats.plot() P.savefig(os.path.join(sessionPath,'confMatrixAvTrial-LanguageSwitch-Japanese_English-GNB.png')) print foldwiseCvedAnovaSelectedSMLR.ca.stats.matrix print 'accuracy',N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1),'%',datetime.datetime.now() # this should give average anova measure over the folds - but in fact would be much the same as taking over single fold sensana = anovaSelectedSMLR.get_sensitivity_analyzer(postproc=M.maxofabs_sample()) cv_sensana = M.RepeatedMeasure(sensana, M.NFoldPartitioner()) sens = cv_sensana(dataset) print sens.shape M.map2nifti(dataset, N.mean(sens,0)).to_filename("anovaSensitivity_"+sessionID+'.nii') # this looks good, but don't know way to get back from this feature selected space (of 500) to the whole space of 28k or so, for output weights = anovaSelectedSMLR.clf.weights
st=str(boldDelay) + ',' + str(stimulusWidth) + ',' + str(precision) +'\n' f = open( "withinPredictionResult.csv", "a" ) f.write(st) f.close # display results P.figure() P.title(str(N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1))+'%, n-fold SMLR with anova FS x 500') foldwiseCvedAnovaSelectedSMLR.ca.stats.plot() P.savefig(os.path.join(sessionPath,'confMatrixAvTrial{0}-{1}-Mammal_Tool.png'.format(boldDelay, stimulusWidth))) print foldwiseCvedAnovaSelectedSMLR.ca.stats.matrix print 'accuracy',N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1),'%',datetime.datetime.now() # this should give average anova measure over the folds - but in fact would be much the same as taking over single fold sensana = anovaSelectedSMLR.get_sensitivity_analyzer(postproc=M.maxofabs_sample()) cv_sensana = M.RepeatedMeasure(sensana, M.NFoldPartitioner()) sens = cv_sensana(dataset) print sens.shape M.map2nifti(dataset, N.mean(sens,0)).to_filename("anovaSensitivity{0}-{1}-mammal_tool.nii".format(boldDelay, stimulusWidth)) # this looks good, but don't know way to get back from this feature selected space (of 500) to the whole space of 28k or so, for output weights = anovaSelectedSMLR.clf.weights
st=str(boldDelay) + ',' + str(stimulusWidth) + ',' + str(precision) +'\n' f = open( "withinPredictionResult.csv", "a" ) f.write(st) f.close # display results P.figure() P.title(str(N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1))+'%, n-fold SMLR with anova FS x 500') foldwiseCvedAnovaSelectedSMLR.ca.stats.plot() P.savefig(os.path.join(sessionPath,'confMatrixAvTrial{0}-{1}-LanguagePresented-Japanese_English.png'.format(boldDelay, stimulusWidth))) print foldwiseCvedAnovaSelectedSMLR.ca.stats.matrix print 'accuracy',N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1),'%',datetime.datetime.now() # this should give average anova measure over the folds - but in fact would be much the same as taking over single fold sensana = anovaSelectedSMLR.get_sensitivity_analyzer(postproc=M.maxofabs_sample()) cv_sensana = M.RepeatedMeasure(sensana, M.NFoldPartitioner()) sens = cv_sensana(dataset) print sens.shape M.map2nifti(dataset, N.mean(sens,0)).to_filename("anovaSensitivity{0}-{1}-LanguagePresented.nii".format(boldDelay, stimulusWidth)) # this looks good, but don't know way to get back from this feature selected space (of 500) to the whole space of 28k or so, for output weights = anovaSelectedSMLR.clf.weights
st=str(boldDelay) + ',' + str(stimulusWidth) + ',' + str(precision) +'\n' f = open( "withinPredictionResult.csv", "a" ) f.write(st) f.close # display results P.figure() P.title(str(N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1))+'%, n-fold SMLR with anova FS x 500') foldwiseCvedAnovaSelectedSMLR.ca.stats.plot() P.savefig(os.path.join(sessionPath,'confMatrixAvTrial{0}-{1}-LanguageSwitch-Japanese_English-SVM.png'.format(boldDelay, stimulusWidth))) print foldwiseCvedAnovaSelectedSMLR.ca.stats.matrix print 'accuracy',N.round(foldwiseCvedAnovaSelectedSMLR.ca.stats.stats['ACC%'], 1),'%',datetime.datetime.now() # this should give average anova measure over the folds - but in fact would be much the same as taking over single fold sensana = anovaSelectedSMLR.get_sensitivity_analyzer(postproc=M.maxofabs_sample()) cv_sensana = M.RepeatedMeasure(sensana, M.NFoldPartitioner()) sens = cv_sensana(dataset) print sens.shape M.map2nifti(dataset, N.mean(sens,0)).to_filename("anovaSensitivity{0}-{1}-LanguageSwitch-Japanese-English-SVM.nii".format(boldDelay, stimulusWidth)) # this looks good, but don't know way to get back from this feature selected space (of 500) to the whole space of 28k or so, for output weights = anovaSelectedSMLR.clf.weights
#k = 11 print(fn) ds = mvpa2.fmri_dataset(fn) RSS = np.sum(np.power(ds.samples, 2), axis=0) k = int(sys.argv[2]) print(k, " PEs") n = ds.shape[0] print(n, " data points") #this was to verify with sigmasquareds.nii.gz #fn2 = '/scratch/scratch/ucjtbob/narps1_only_entropy_model/narps_level1/sub001_run01.feat/stats/sigmasquareds.nii.gz' #ds2 = mvpa2.fmri_dataset(fn2) #RSS2 = ds2.samples * (n-k) BIC = k * np.log(n) + n * np.log(RSS / n) BIC[~np.isfinite(BIC)] = 0 print(np.sum(BIC), ' BIC') print(BIC.shape) ds.samples = BIC print(ds.shape) #print(ds) nimg = mvpa2.map2nifti(ds) nimg.to_filename(sys.argv[1] + 'BIC.nii.gz') #nimg.to_filename(fn + 'BIC.nii.gz')