def test_fmridataset(): # full-blown fmri dataset testing import nibabel maskimg = nibabel.load(os.path.join(pymvpa_dataroot, 'mask.nii.gz')) data = maskimg.get_data().copy() data[data > 0] = np.arange(1, np.sum(data) + 1) maskimg = nibabel.Nifti1Image(data, None, maskimg.get_header()) attr = SampleAttributes(os.path.join(pymvpa_dataroot, 'attributes.txt')) ds = fmri_dataset(samples=os.path.join(pymvpa_dataroot, 'bold.nii.gz'), targets=attr.targets, chunks=attr.chunks, mask=maskimg, sprefix='subj1', add_fa={'myintmask': maskimg}) # content assert_equal(len(ds), 1452) assert_true(ds.nfeatures, 530) assert_array_equal(sorted(ds.sa.keys()), ['chunks', 'targets', 'time_coords', 'time_indices']) assert_array_equal(sorted(ds.fa.keys()), ['myintmask', 'subj1_indices']) assert_array_equal( sorted(ds.a.keys()), ['imghdr', 'imgtype', 'mapper', 'subj1_dim', 'subj1_eldim']) # vol extent assert_equal(ds.a.subj1_dim, (40, 20, 1)) # check time assert_equal(ds.sa.time_coords[-1], 3627.5) # non-zero mask values assert_array_equal(ds.fa.myintmask, np.arange(1, ds.nfeatures + 1)) # we know that imgtype must be: ok_(ds.a.imgtype is nibabel.Nifti1Image)
def load_eeg_dataset(path, filename, attrib, TR, eliminated_vols = None, **kwargs): """ **kwargs: - type: * 'psd': Power Spectrum Density using matplotlib.specgram additional parameters to be included NFFT and noverlap * 'fft': Power Spectrum and Phase using scipy.fft * 'time': EEG timecourse in every TR. """ type = 'time' for arg in kwargs: if (arg == 'type'): type = kwargs[arg] print 'type = ' + type #load eeg data [data, eeg_info] = load_eeg_data(path, filename, TR, eliminatedVols = eliminated_vols) channel_ids = eeg_info['channel_ids'] dt = eeg_info['dt'] kwargs['dt'] = dt if (type == 'psd') or (type == 'fft'): [samples, freq] = spectrum_eeg(data, **kwargs) data = samples.reshape(samples.shape[0], samples.shape[1], -1) #mvpa analysis: attributes and dataset attr = SampleAttributes(attrib) print 'Building dataset...' ds = Dataset.from_channeltimeseries(data, channelids = channel_ids, targets = attr.targets, chunks = attr.chunks) if (type == 'psd') or (type == 'fft'): ds.a['frequiencies'] = freq ds.a['shape'] = samples.shape ds.a['timepoints'] = np.arange(0, TR, dt) del data if 'samples' in locals(): del samples return ds
def process_common_dsattr_opts(ds, args): """Goes through an argument namespace and processes attribute options""" # legacy support if not args.add_sa_attr is None: from mvpa2.misc.io.base import SampleAttributes smpl_attrs = SampleAttributes(args.add_sa_attr) for a in ('targets', 'chunks'): verbose( 2, "Add sample attribute '%s' from sample attributes file" % a) ds.sa[a] = getattr(smpl_attrs, a) # loop over all attribute configurations that we know attr_cfgs = ( # var, dst_collection, loader ('--add-sa', args.add_sa, ds.sa, _load_from_cmdline), ('--add-fa', args.add_fa, ds.fa, _load_from_cmdline), ('--add-sa-txt', args.add_sa_txt, ds.sa, _load_from_txt), ('--add-fa-txt', args.add_fa_txt, ds.fa, _load_from_txt), ('--add-sa-npy', args.add_sa_npy, ds.sa, _load_from_npy), ('--add-fa-npy', args.add_fa_npy, ds.fa, _load_from_npy), ) for varid, srcvar, dst_collection, loader in attr_cfgs: if not srcvar is None: for spec in srcvar: attr_name = spec[0] if not len(spec) > 1: raise argparse.ArgumentTypeError( "%s option need at least two values " % varid + "(attribute name and source filename (got: %s)" % spec) if dst_collection is ds.sa: verbose( 2, "Add sample attribute '%s' from '%s'" % (attr_name, spec[1])) else: verbose( 2, "Add feature attribute '%s' from '%s'" % (attr_name, spec[1])) attr = loader(spec[1:]) try: dst_collection[attr_name] = attr except ValueError, e: # try making the exception more readable e_str = str(e) if e_str.startswith('Collectable'): raise ValueError('attribute %s' % e_str[12:]) else: raise e
def test_openfmri_dataset(): skip_if_no_external('nibabel') of = ofm.OpenFMRIDataset(pathjoin(pymvpa_dataroot, 'haxby2001')) assert_equal(of.get_model_descriptions(), {1: 'visual object categories'}) sub_ids = of.get_subj_ids() assert_equal(sub_ids, [1, 'phantom']) assert_equal(of.get_scan_properties(), {'TR': '2.5'}) tasks = of.get_task_descriptions() assert_equal(tasks, {1: 'object viewing'}) task = tasks.keys()[0] run_ids = of.get_bold_run_ids(sub_ids[0], task) assert_equal(run_ids, range(1, 13)) task_runs = of.get_task_bold_run_ids(task) assert_equal(task_runs, {1: range(1, 13)}) # test access anatomy image assert_equal( of.get_anatomy_image(1, fname='lowres001.nii.gz').shape, (6, 10, 10)) # try to get an image that isn't there assert_raises(IOError, of.get_bold_run_image, 1, 1, 1) # defined model contrasts contrast_spec = of.get_model_contrasts(1) # one dict per task assert_equal(len(contrast_spec), 1) assert_true(1 in contrast_spec) # six defined contrasts assert_equal(len(contrast_spec[1]), 1) # check one assert_array_equal(contrast_spec[1]['face_v_house'], [-1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0]) orig_attrs = SampleAttributes( pathjoin(pymvpa_dataroot, 'attributes_literal.txt')) for subj, runs in task_runs.iteritems(): for run in runs: # load single run ds = of.get_bold_run_dataset(subj, task, run, flavor='1slice', mask=pathjoin(pymvpa_dataroot, 'mask.nii.gz'), add_sa='bold_moest.txt') # basic shape assert_equal(len(ds), 121) assert_equal(ds.nfeatures, 530) # functional mapper assert_equal(ds.O.shape, (121, 40, 20, 1)) # additional attributes present moest = of.get_bold_run_motion_estimates(subj, task, run) for i in range(6): moest_attr = 'bold_moest.txt_%i' % (i, ) assert_true(moest_attr in ds.sa) assert_array_equal(moest[:, i], ds.sa[moest_attr].value) # check conversion of model into sample attribute events = of.get_bold_run_model(subj, task, run) for i, ev in enumerate(events): # we only have one trial per condition in the demo dataset assert_equal(ev['conset_idx'], 0) # proper enumeration and events sorted by time assert_equal(ev['onset_idx'], i) onsets = [e['onset'] for e in events] sorted_onsets = sorted(onsets) assert_array_equal(sorted_onsets, onsets) targets = events2sample_attr(events, ds.sa.time_coords, noinfolabel='rest') assert_array_equal( orig_attrs['targets'][(run - 1) * 121:run * len(ds)], targets) assert_equal(ds.sa['subj'][0], subj) # check that we can get the same result from the model dataset # (make it exercise the preproc interface too) def preproc_img(img): return img modelds = of.get_model_bold_dataset(1, subj, flavor='1slice', preproc_img=preproc_img, modelfx=assign_conditionlabels, mask=pathjoin( pymvpa_dataroot, 'mask.nii.gz'), add_sa='bold_moest.txt') modelds = modelds[modelds.sa.run == run] targets = np.array(targets, dtype='object') targets[targets == 'rest'] = None assert_array_equal(targets, modelds.sa.targets) # more basic access motion = of.get_task_bold_attributes(1, 'bold_moest.txt', np.loadtxt) assert_equal(len(motion), 12) # one per run # one per subject, per volume, 6 estimates assert_equal([(len(m), ) + m[1].shape for m in motion], [(1, 121, 6)] * 12)
sbfs = fs.base.SensitivityBasedFeatureSelection(fsel, fselector, enable_ca=['sensitivities']) from mvpa2.clfs.meta import FeatureSelectionClassifier, MappedClassifier fclf = FeatureSelectionClassifier(clf, sbfs) from mvpa2.measures.base import CrossValidation from mvpa2.misc import errorfx from mvpa2.generators.partition import NFoldPartitioner cv = CrossValidation(fclf, NFoldPartitioner(attr='chunks'), errorfx=errorfx.mean_match_accuracy) import numpy as np from mvpa2.misc.io.base import SampleAttributes cv_attr = SampleAttributes(os.path.join(paths[3], (con + "_attribute_labels.txt"))) from mvpa2.measures import rsa dsm = rsa.PDist(square=True) # searchlight # import searchlightutils as sl # from mvpa2.measures.searchlight import sphere_searchlight # cvSL = sphere_searchlight(cv, radius=r) # lres = sl.run_cv_sl(cvSL, fds[lidx].copy(deep=False)) lresults = [] presults = [] l2presults = [] p2lresults = [] rsaresults = [] for sub in subList.keys():
def test_voxel_selection(self): '''Compare surface and volume based searchlight''' ''' Tests to see whether results are identical for surface-based searchlight (just one plane; Euclidean distnace) and volume-based searchlight. Note that the current value is a float; if it were int, it would specify the number of voxels in each searchlight''' radius = 10. '''Define input filenames''' epi_fn = os.path.join(pymvpa_dataroot, 'bold.nii.gz') maskfn = os.path.join(pymvpa_dataroot, 'mask.nii.gz') ''' Use the EPI datafile to define a surface. The surface has as many nodes as there are voxels and is parallel to the volume 'slice' ''' vg = volgeom.from_any(maskfn, mask_volume=True) aff = vg.affine nx, ny, nz = vg.shape[:3] '''Plane goes in x and y direction, so we take these vectors from the affine transformation matrix of the volume''' plane = surf.generate_plane(aff[:3, 3], aff[:3, 0], aff[:3, 1], nx, ny) ''' Simulate pial and white matter as just above and below the central plane ''' normal_vec = aff[:3, 2] outer = plane + normal_vec inner = plane + -normal_vec ''' Combine volume and surface information ''' vsm = volsurf.VolSurfMaximalMapping(vg, outer, inner) ''' Run voxel selection with specified radius (in mm), using Euclidean distance measure ''' surf_voxsel = surf_voxel_selection.voxel_selection(vsm, radius, distance_metric='e') '''Define the measure''' # run_slow=True would give an actual cross-validation with meaningful # accuracies. Because this is a unit-test only the number of voxels # in each searchlight is tested. run_slow = False if run_slow: meas = CrossValidation(GNB(), OddEvenPartitioner(), errorfx=lambda p, t: np.mean(p == t)) postproc = mean_sample else: meas = _Voxel_Count_Measure() postproc = lambda x: x ''' Surface analysis: define the query engine, cross validation, and searchlight ''' surf_qe = SurfaceVerticesQueryEngine(surf_voxsel) surf_sl = Searchlight(meas, queryengine=surf_qe, postproc=postproc) ''' new (Sep 2012): also test 'simple' queryengine wrapper function ''' surf_qe2 = disc_surface_queryengine(radius, maskfn, inner, outer, plane, volume_mask=True, distance_metric='euclidean') surf_sl2 = Searchlight(meas, queryengine=surf_qe2, postproc=postproc) ''' Same for the volume analysis ''' element_sizes = tuple(map(abs, (aff[0, 0], aff[1, 1], aff[2, 2]))) sph = Sphere(radius, element_sizes=element_sizes) kwa = {'voxel_indices': sph} vol_qe = IndexQueryEngine(**kwa) vol_sl = Searchlight(meas, queryengine=vol_qe, postproc=postproc) '''The following steps are similar to start_easy.py''' attr = SampleAttributes( os.path.join(pymvpa_dataroot, 'attributes_literal.txt')) mask = surf_voxsel.get_mask() dataset = fmri_dataset(samples=os.path.join(pymvpa_dataroot, 'bold.nii.gz'), targets=attr.targets, chunks=attr.chunks, mask=mask) if run_slow: # do chunkswise linear detrending on dataset poly_detrend(dataset, polyord=1, chunks_attr='chunks') # zscore dataset relative to baseline ('rest') mean zscore(dataset, chunks_attr='chunks', param_est=('targets', ['rest'])) # select class face and house for this demo analysis # would work with full datasets (just a little slower) dataset = dataset[np.array( [l in ['face', 'house'] for l in dataset.sa.targets], dtype='bool')] '''Apply searchlight to datasets''' surf_dset = surf_sl(dataset) surf_dset2 = surf_sl2(dataset) vol_dset = vol_sl(dataset) surf_data = surf_dset.samples surf_data2 = surf_dset2.samples vol_data = vol_dset.samples assert_array_equal(surf_data, surf_data2) assert_array_equal(surf_data, vol_data)
#!/usr/bin/env python import numpy as np from mvpa2.misc.io.base import SampleAttributes from mvpa2.datasets.mri import fmri_dataset from mvpa2.mappers.detrend import poly_detrend from mvpa2.mappers.zscore import zscore from mvpa2.clfs.svm import LinearCSVMC from mvpa2.generators.partition import NFoldPartitioner from mvpa2.measures.base import CrossValidation sa = SampleAttributes('attributes.txt') ds = fmri_dataset(samples='func.feat/filtered_func_data.nii.gz', targets=sa.targets, chunks=sa.chunks) poly_detrend(ds, polyord=1, chunks_attr='chunks') zscore(ds, param_est=('targets',[0]) ds = ds[ds.sa.targets != 0] clf = LinearCSVMC() cvte = CrossValidation(clf, NFoldPartitioner(), enable_ca=['stats']) cv_results = cvte(ds) sl = sphere_searchlight(cvte, readius=3, postproc=mean_sample()) sl_results = sl(ds)