def run(args):
"""Run it"""
verbose(1, "Loading %d result files" % len(args.data))
filetype_in = guess_backend(args.data[0])
if filetype_in == 'nifti':
dss = [fmri_dataset(f) for f in args.data]
elif filetype_in == 'hdf5':
dss = [h5load(f) for f in args.data]
data = np.asarray([d.samples[args.isample] for d in dss])
if args.mask:
filetype_mask = guess_backend(args.mask)
if filetype_mask == 'nifti':
mask = nib.load(args.mask).get_data()
elif filetype_mask == 'hdf5':
mask = h5load(args.mask).samples
out_of_mask = mask == 0
else:
# just take where no voxel had a value
out_of_mask = np.sum(data != 0, axis=0) == 0
t, p = ttest_1samp(data,
popmean=args.chance_level,
axis=0,
alternative=args.alternative)
if args.stat == 'z':
if args.alternative == 'two-sided':
s = stats.norm.isf(p / 2)
else:
s = stats.norm.isf(p)
# take the sign of the original t
s = np.abs(s) * np.sign(t)
elif args.stat == 'p':
s = p
elif args.stat == 't':
s = t
else:
raise ValueError('WTF you gave me? have no clue about %r' %
(args.stat, ))
if s.shape != out_of_mask.shape:
try:
out_of_mask = out_of_mask.reshape(s.shape)
except ValueError:
raise ValueError('Cannot use mask of shape {0} with '
'data of shape {1}'.format(
out_of_mask.shape, s.shape))
s[out_of_mask] = 0
verbose(1, "Saving to %s" % args.output)
filetype_out = guess_backend(args.output)
if filetype_out == 'nifti':
map2nifti(dss[0], data=s).to_filename(args.output)
else: # filetype_out is hdf5
s = Dataset(np.atleast_2d(s), fa=dss[0].fa, a=dss[0].a)
h5save(args.output, s)
return s
def test_nifti_dataset_from3_d():
"""Test NiftiDataset based on 3D volume(s)
"""
tssrc = os.path.join(pymvpa_dataroot, "bold.nii.gz")
masrc = os.path.join(pymvpa_dataroot, "mask.nii.gz")
# Test loading of 3D volumes
# by default we are enforcing 4D, testing here with the demo 3d mask
ds = fmri_dataset(masrc, mask=masrc, targets=1)
assert_equal(len(ds), 1)
import nibabel
plain_data = nibabel.load(masrc).get_data()
# Lets check if mapping back works as well
assert_array_equal(plain_data, map2nifti(ds).get_data().reshape(plain_data.shape))
# test loading from a list of filenames
# for now we should fail if trying to load a mix of 4D and 3D volumes
assert_raises(ValueError, fmri_dataset, (masrc, tssrc), mask=masrc, targets=1)
# Lets prepare some custom NiftiImage
dsfull = fmri_dataset(tssrc, mask=masrc, targets=1)
ds_selected = dsfull[3]
nifti_selected = map2nifti(ds_selected)
# Load dataset from a mix of 3D volumes
# (given by filenames and NiftiImages)
labels = [123, 2, 123]
ds2 = fmri_dataset((masrc, masrc, nifti_selected), mask=masrc, targets=labels)
assert_equal(ds2.nsamples, 3)
assert_array_equal(ds2.samples[0], ds2.samples[1])
assert_array_equal(ds2.samples[2], dsfull.samples[3])
assert_array_equal(ds2.targets, labels)
def test_nifti_mapper(filename):
"""Basic testing of map2Nifti
"""
skip_if_no_external('scipy')
import nibabel
data = fmri_dataset(samples=os.path.join(pymvpa_dataroot,
'example4d.nii.gz'),
targets=[1, 2])
# test mapping of ndarray
vol = map2nifti(data, np.ones((294912, ), dtype='int16'))
if externals.versions['nibabel'] >= '1.2':
vol_shape = vol.shape
else:
vol_shape = vol.get_shape()
assert_equal(vol_shape, (128, 96, 24))
assert_true((vol.get_data() == 1).all())
# test mapping of the dataset
vol = map2nifti(data)
if externals.versions['nibabel'] >= '1.2':
vol_shape = vol.shape
else:
vol_shape = vol.get_shape()
assert_equal(vol_shape, (128, 96, 24, 2))
ok_(isinstance(vol, data.a.imgtype))
# test providing custom imgtypes
vol = map2nifti(data, imgtype=nibabel.Nifti1Pair)
if externals.versions['nibabel'] >= '1.2':
vol_shape = vol.shape
else:
vol_shape = vol.get_shape()
ok_(isinstance(vol, nibabel.Nifti1Pair))
# Lets generate a dataset using an alternative format (MINC)
# and see if type persists
volminc = nibabel.MincImage(vol.get_data(), vol.get_affine(),
vol.get_header())
ok_(isinstance(volminc, nibabel.MincImage))
dsminc = fmri_dataset(volminc, targets=1)
ok_(dsminc.a.imgtype is nibabel.MincImage)
ok_(isinstance(dsminc.a.imghdr, nibabel.minc.MincImage.header_class))
# Lets test if we could save/load now into Analyze volume/dataset
if externals.versions['nibabel'] < '1.1.0':
raise SkipTest(
'nibabel prior 1.1.0 had an issue with types comprehension')
volanal = map2nifti(
dsminc, imgtype=nibabel.AnalyzeImage) # MINC has no 'save' capability
ok_(isinstance(volanal, nibabel.AnalyzeImage))
volanal.to_filename(filename)
dsanal = fmri_dataset(filename, targets=1)
# this one is tricky since it might become Spm2AnalyzeImage
ok_('AnalyzeImage' in str(dsanal.a.imgtype))
ok_('AnalyzeHeader' in str(dsanal.a.imghdr.__class__))
volanal_ = map2nifti(dsanal)
ok_(isinstance(volanal_, dsanal.a.imgtype)) # type got preserved
def test_er_nifti_dataset():
# setup data sources
tssrc = os.path.join(pymvpa_dataroot, u"bold.nii.gz")
evsrc = os.path.join(pymvpa_dataroot, "fslev3.txt")
masrc = os.path.join(pymvpa_dataroot, "mask.nii.gz")
evs = FslEV3(evsrc).to_events()
# load timeseries
ds_orig = fmri_dataset(tssrc)
# segment into events
ds = eventrelated_dataset(ds_orig, evs, time_attr="time_coords")
# we ask for boxcars of 9s length, and the tr in the file header says 2.5s
# hence we should get round(9.0/2.4) * np.prod((1,20,40) == 3200 features
assert_equal(ds.nfeatures, 3200)
assert_equal(len(ds), len(evs))
# the voxel indices are reflattened after boxcaring , but still 3D
assert_equal(ds.fa.voxel_indices.shape, (ds.nfeatures, 3))
# and they have been broadcasted through all boxcars
assert_array_equal(ds.fa.voxel_indices[:800], ds.fa.voxel_indices[800:1600])
# each feature got an event offset value
assert_array_equal(ds.fa.event_offsetidx, np.repeat([0, 1, 2, 3], 800))
# check for all event attributes
assert_true("onset" in ds.sa)
assert_true("duration" in ds.sa)
assert_true("features" in ds.sa)
# check samples
origsamples = _load_anyimg(tssrc)[0]
for i, onset in enumerate([value2idx(e["onset"], ds_orig.sa.time_coords, "floor") for e in evs]):
assert_array_equal(ds.samples[i], origsamples[onset : onset + 4].ravel())
assert_array_equal(ds.sa.time_indices[i], np.arange(onset, onset + 4))
assert_array_equal(ds.sa.time_coords[i], np.arange(onset, onset + 4) * 2.5)
for evattr in [a for a in ds.sa if a.count("event_attrs") and not a.count("event_attrs_event")]:
assert_array_equal(evs[i]["_".join(evattr.split("_")[2:])], ds.sa[evattr].value[i])
# check offset: only the last one exactly matches the tr
assert_array_equal(ds.sa.orig_offset, [1, 1, 0])
# map back into voxel space, should ignore addtional features
nim = map2nifti(ds)
# origsamples has t,x,y,z
assert_equal(nim.get_shape(), origsamples.shape[1:] + (len(ds) * 4,))
# check shape of a single sample
nim = map2nifti(ds, ds.samples[0])
# pynifti image has [t,]z,y,x
assert_equal(nim.get_shape(), (40, 20, 1, 4))
# and now with masking
ds = fmri_dataset(tssrc, mask=masrc)
ds = eventrelated_dataset(ds, evs, time_attr="time_coords")
nnonzero = len(_load_anyimg(masrc)[0].nonzero()[0])
assert_equal(nnonzero, 530)
# we ask for boxcars of 9s length, and the tr in the file header says 2.5s
# hence we should get round(9.0/2.4) * np.prod((1,20,40) == 3200 features
assert_equal(ds.nfeatures, 4 * 530)
assert_equal(len(ds), len(evs))
# and they have been broadcasted through all boxcars
assert_array_equal(ds.fa.voxel_indices[:nnonzero], ds.fa.voxel_indices[nnonzero : 2 * nnonzero])
def test_nifti_mapper(filename):
"""Basic testing of map2Nifti
"""
skip_if_no_external('scipy')
import nibabel
data = fmri_dataset(samples=os.path.join(pymvpa_dataroot,'example4d.nii.gz'),
targets=[1,2])
# test mapping of ndarray
vol = map2nifti(data, np.ones((294912,), dtype='int16'))
if externals.versions['nibabel'] >= '1.2':
vol_shape = vol.shape
else:
vol_shape = vol.get_shape()
assert_equal(vol_shape, (128, 96, 24))
assert_true((vol.get_data() == 1).all())
# test mapping of the dataset
vol = map2nifti(data)
if externals.versions['nibabel'] >= '1.2':
vol_shape = vol.shape
else:
vol_shape = vol.get_shape()
assert_equal(vol_shape, (128, 96, 24, 2))
ok_(isinstance(vol, data.a.imgtype))
# test providing custom imgtypes
vol = map2nifti(data, imgtype=nibabel.Nifti1Pair)
if externals.versions['nibabel'] >= '1.2':
vol_shape = vol.shape
else:
vol_shape = vol.get_shape()
ok_(isinstance(vol, nibabel.Nifti1Pair))
# Lets generate a dataset using an alternative format (MINC)
# and see if type persists
volminc = nibabel.MincImage(vol.get_data(),
vol.get_affine(),
vol.get_header())
ok_(isinstance(volminc, nibabel.MincImage))
dsminc = fmri_dataset(volminc, targets=1)
ok_(dsminc.a.imgtype is nibabel.MincImage)
ok_(isinstance(dsminc.a.imghdr, nibabel.minc.MincImage.header_class))
# Lets test if we could save/load now into Analyze volume/dataset
if externals.versions['nibabel'] < '1.1.0':
raise SkipTest('nibabel prior 1.1.0 had an issue with types comprehension')
volanal = map2nifti(dsminc, imgtype=nibabel.AnalyzeImage) # MINC has no 'save' capability
ok_(isinstance(volanal, nibabel.AnalyzeImage))
volanal.to_filename(filename)
dsanal = fmri_dataset(filename, targets=1)
# this one is tricky since it might become Spm2AnalyzeImage
ok_('AnalyzeImage' in str(dsanal.a.imgtype))
ok_('AnalyzeHeader' in str(dsanal.a.imghdr.__class__))
volanal_ = map2nifti(dsanal)
ok_(isinstance(volanal_, dsanal.a.imgtype)) # type got preserved
def run(args):
"""Run it"""
verbose(1, "Loading %d result files" % len(args.data))
filetype_in = guess_backend(args.data[0])
if filetype_in == 'nifti':
dss = [fmri_dataset(f) for f in args.data]
elif filetype_in == 'hdf5':
dss = [h5load(f) for f in args.data]
data = np.asarray([d.samples[args.isample] for d in dss])
if args.mask:
filetype_mask = guess_backend(args.mask)
if filetype_mask == 'nifti':
mask = nib.load(args.mask).get_data()
elif filetype_mask == 'hdf5':
mask = h5load(args.mask).samples
out_of_mask = mask == 0
else:
# just take where no voxel had a value
out_of_mask = np.sum(data != 0, axis=0)==0
t, p = ttest_1samp(data, popmean=args.chance_level, axis=0,
alternative=args.alternative)
if args.stat == 'z':
if args.alternative == 'two-sided':
s = stats.norm.isf(p/2)
else:
s = stats.norm.isf(p)
# take the sign of the original t
s = np.abs(s) * np.sign(t)
elif args.stat == 'p':
s = p
elif args.stat == 't':
s = t
else:
raise ValueError('WTF you gave me? have no clue about %r' % (args.stat,))
if s.shape != out_of_mask.shape:
try:
out_of_mask = out_of_mask.reshape(s.shape)
except ValueError:
raise ValueError('Cannot use mask of shape {0} with '
'data of shape {1}'.format(out_of_mask.shape, s.shape))
s[out_of_mask] = 0
verbose(1, "Saving to %s" % args.output)
filetype_out = guess_backend(args.output)
if filetype_out == 'nifti':
map2nifti(dss[0], data=s).to_filename(args.output)
else: # filetype_out is hdf5
s = Dataset(np.atleast_2d(s), fa=dss[0].fa, a=dss[0].a)
h5save(args.output, s)
return s
def main(subject, study_dir, mask, stat, res_name, items='ac',
suffix='_stim_fix2', feature_mask=None, radius=3, n_perm=1000,
n_proc=None):
from mvpa2.datasets.mri import map2nifti
from mvpa2.mappers.zscore import zscore
from mvpa2.measures.searchlight import sphere_searchlight
from nireact import mvpa
# lookup subject directory
sp = su.SubjPath(subject, study_dir)
# load task information
vols = task.disp_vols(sp.path('behav', 'log'))
# unpack the items option to get item type code
item_names = 'abc'
item_comp = [item_names.index(name) + 1 for name in items]
# get post runs, A and C items only
include = ((vols.run >= 5) & np.isin(vols.item_type, item_comp) &
vols.correct == 1)
post = vols.loc[include, :]
# load beta series
ds = mvpa.load_disp_beta(sp, suffix, mask, feature_mask, verbose=1)
# define measure and contrasts to write out
contrasts = ['pos', 'block_inter', 'inter_block']
m = mvpa.TriadVector(post, item_comp, stat, contrasts, n_perm)
# zscore
ds.sa['run'] = vols.run.values
zscore(ds, chunks_attr='run')
# searchlight
print('Running searchlight...')
sl = sphere_searchlight(m, radius=radius, nproc=n_proc)
sl_map = sl(ds[include])
# save results
nifti_include = map2nifti(ds, sl_map[-1])
for i, contrast in enumerate(contrasts):
res_dir = sp.path('rsa', f'{res_name}_{contrast}')
if not os.path.exists(res_dir):
os.makedirs(res_dir)
nifti = map2nifti(ds, sl_map[i])
nifti.to_filename(su.impath(res_dir, 'zstat'))
nifti_include.to_filename(su.impath(res_dir, 'included'))
def main(subject,
study_dir,
mask,
feature_mask,
res_dir,
radius=3,
n_proc=None):
from mvpa2.measures.searchlight import sphere_searchlight
from mvpa2.datasets.mri import map2nifti
# load functional data
subject_dir = os.path.join(study_dir, f'tesser_{subject}')
ds = mvpa.load_struct_timeseries(study_dir,
subject,
mask,
feature_mask=feature_mask,
verbose=1,
zscore_run=True)
# load events data, split by object within structure learning block
vols = rsa.load_vol_info(study_dir, subject)
events = vols.query('sequence_type > 0').copy()
n_item = events['trial_type'].nunique()
events['trial_type'] = (events['trial_type'] +
(events['sequence_type'] - 1) * n_item)
# set up BRSA model
model = brsa.GBRSA()
n_ev = 21 * 2
n_vol = ds.shape[0]
mat, nuisance, scan_onsets = rsa.create_brsa_matrix(
subject_dir, events, n_vol)
m = mvpa.ItemBRSA(model, n_ev, mat, nuisance, scan_onsets)
# run searchlight
sl = sphere_searchlight(m, radius=radius, nproc=n_proc)
sl_map = sl(ds)
# save included voxels map
if not os.path.exists(res_dir):
os.makedirs(res_dir)
nifti_include = map2nifti(ds, sl_map[-1])
include_file = os.path.join(res_dir, 'included.nii.gz')
nifti_include.to_filename(include_file)
# save pairwise correlations as a timeseries
filepath = os.path.join(res_dir, 'stat.nii.gz')
nifti = map2nifti(ds, sl_map[:-1])
nifti.to_filename(filepath)
def split_mask(mask_image, workdir):
"""
Split a mask with multiple ROIs into seperate files for each ROI.
Saves them in 'workdir/roi_masks'.
returns a list of paths for each produced mask file.
"""
ms = fmri_dataset(mask_image)
maskpath = os.path.join(workdir, 'roi_masks')
if not os.path.exists(maskpath):
os.makedirs(maskpath)
# list of paths for each roi mask
maskfiles = []
# save seperate mask for each roi to file in workdir
for roivalue in range(1, max(ms.samples[0]) + 1):
msc = ms.copy()
msc.samples[0][msc.samples[0] != roivalue] = False
image = map2nifti(msc)
maskfile = os.path.join(maskpath, 'roi{}_mask.nii.gz'.format(roivalue))
image.to_filename(maskfile)
maskfiles.append(maskfile)
return maskfiles
def test_searchlight_cross_decoding(path, subjects, conf_file, type, **kwargs):
conf = read_configuration(path, conf_file, type)
for arg in kwargs:
conf[arg] = kwargs[arg]
if arg == 'radius':
radius = kwargs[arg]
debug.active += ["SLC"]
ds_merged = get_merged_ds(path, subjects, conf_file, type, **kwargs)
clf = LinearCSVMC(C=1, probability=1, enable_ca=['probabilities'])
cv = CrossValidation(clf, NFoldPartitioner(attr='task'))
maps = []
for ds in ds_merged:
ds.targets[ds.targets == 'point'] = 'face'
ds.targets[ds.targets == 'saccade'] = 'place'
sl = sphere_searchlight(cv, radius, space = 'voxel_indices')
sl_map = sl(ds)
sl_map.samples *= -1
sl_map.samples += 1
nif = map2nifti(sl_map, imghdr=ds.a.imghdr)
maps.append(nif)
datetime = get_time()
analysis = 'cross_searchlight'
mask = conf['mask_area']
task = type
new_dir = datetime+'_'+analysis+'_'+mask+'_'+task
command = 'mkdir '+os.path.join(path, '0_results', new_dir)
os.system(command)
parent_dir = os.path.join(path, '0_results', new_dir)
for s, map in zip(subjects, maps):
name = s
command = 'mkdir '+os.path.join(parent_dir, name)
os.system(command)
results_dir = os.path.join(parent_dir, name)
fname = name+'_radius_'+str(radius)+'_searchlight_map.nii.gz'
map.to_filename(os.path.join(results_dir, fname))
return maps
def test_nifti_dataset_from3_d():
"""Test NiftiDataset based on 3D volume(s)
"""
tssrc = os.path.join(pymvpa_dataroot, 'bold.nii.gz')
masrc = os.path.join(pymvpa_dataroot, 'mask.nii.gz')
# Test loading of 3D volumes
# by default we are enforcing 4D, testing here with the demo 3d mask
ds = fmri_dataset(masrc, mask=masrc, targets=1)
assert_equal(len(ds), 1)
import nibabel
plain_data = nibabel.load(masrc).get_data()
# Lets check if mapping back works as well
assert_array_equal(plain_data,
map2nifti(ds).get_data().reshape(plain_data.shape))
# test loading from a list of filenames
# for now we should fail if trying to load a mix of 4D and 3D volumes
# TODO: nope -- it should work and we should test here if correctly
dsfull_plusone = fmri_dataset((masrc, tssrc), mask=masrc, targets=1)
# Lets prepare some custom NiftiImage
dsfull = fmri_dataset(tssrc, mask=masrc, targets=1)
assert_equal(len(dsfull) + 1, len(dsfull_plusone))
assert_equal(dsfull.nfeatures, dsfull_plusone.nfeatures)
# skip 3d mask in 0th sample
assert_array_equal(dsfull.samples, dsfull_plusone[1:].samples)
ds_selected = dsfull[3]
nifti_selected = map2nifti(ds_selected)
# Load dataset from a mix of 3D volumes
# (given by filenames and NiftiImages)
labels = [123, 2, 123]
ds2 = fmri_dataset((masrc, masrc, nifti_selected),
mask=masrc,
targets=labels)
assert_equal(ds2.nsamples, 3)
assert_array_equal(ds2.samples[0], ds2.samples[1])
assert_array_equal(ds2.samples[2], dsfull.samples[3])
assert_array_equal(ds2.targets, labels)
def perm_hist(subj):
conf = AnalysisConfiguration()
data_dir = os.environ.get('DATA_DIR') or '/home/user/data'
sub_dir = _opj(data_dir,conf.study_name,'sub{:0>3d}'.format(subj))
directory = _opj(data_dir,'LP/sub{:0>3d}/results/'.format(subj))
print conf.dir_name()
for pair in conf.conditions_to_compare:
#print _opj(directory,conf.dir_name(),'{}*{}{}*.p'.format(conf.mask_name,pair[0],pair[1]))
files = sorted(glob(_opj(directory,conf.dir_name(),'{}*{}{}*.p'.format(conf.mask_name,pair[0],pair[1]))))
plt.figure()
plt.subplot(211)
plt.title('sub{:0>3d}-{}{}'.format(subj,pair[0],pair[1]))
print pair, " ", len(files)
all_maps = []
for f in files[:-1]:
f_h = file(f,'r')
m = pickle.load(f_h)
all_maps.append(m)
if 'perm' in f:
color = 'black'
line_width = 1
else:
color = 'crimson'
line_width = 2
plt.hist(np.transpose(m),bins=20,histtype='step',color=[color], lw = line_width)
perms = vstack(all_maps)
real_f = files[-1]
f_h = file(real_f,'r')
real_map = pickle.load(f_h)
color = 'crimson'
line_width = 2
plt.hist(np.transpose(real_map),bins=20,histtype='step',color=[color], lw = line_width)
percentiles = np.zeros((1,len(real_map.samples[0])))
for i,vox in enumerate(real_map.samples[0]):
percentiles[0,i]=percentileofscore(perms[:,i].samples.flat,vox)
plt.subplot(212)
print len(percentiles[0])
plt.hist(percentiles[0],bins=20,histtype='step')
real_map.samples=percentiles
nii = real_f.replace("_sl_map.p", "-acc.nii.gz")
nii_file = nib.load(nii)
perc_results = map2nifti(real_map, imghdr=nii_file.header)
perc_nii_filename =real_f.replace("_sl_map.p", "-percentiles_sub{:0>3d}.nii.gz".format(subj))
perc_results.to_filename(perc_nii_filename)
thr_prc_filename = perc_nii_filename.replace(".nii.gz","_p0.01.nii.gz")
thr = fsl.maths.Threshold(in_file=perc_nii_filename, thresh=100,
out_file=thr_prc_filename)
thr.run()
mni_thr_filename = thr_prc_filename.replace(".nii.gz","_mni.nii.gz")
apply_warp(sub_dir,thr_prc_filename, mni_thr_filename)
plt.show()
#plt.savefig('/tmp/sub{:0>3d}_{}{}'.format(subj,pair[0],pair[1]))
raw_input()
def test_searchlight_cross_decoding(path, subjects, conf_file, type, **kwargs):
conf = read_configuration(path, conf_file, type)
for arg in kwargs:
conf[arg] = kwargs[arg]
if arg == 'radius':
radius = kwargs[arg]
debug.active += ["SLC"]
ds_merged = get_merged_ds(path, subjects, conf_file, type, **kwargs)
clf = LinearCSVMC(C=1, probability=1, enable_ca=['probabilities'])
cv = CrossValidation(clf, NFoldPartitioner(attr='task'))
maps = []
for ds in ds_merged:
ds.targets[ds.targets == 'point'] = 'face'
ds.targets[ds.targets == 'saccade'] = 'place'
sl = sphere_searchlight(cv, radius, space='voxel_indices')
sl_map = sl(ds)
sl_map.samples *= -1
sl_map.samples += 1
nif = map2nifti(sl_map, imghdr=ds.a.imghdr)
maps.append(nif)
datetime = get_time()
analysis = 'cross_searchlight'
mask = conf['mask_area']
task = type
new_dir = datetime + '_' + analysis + '_' + mask + '_' + task
command = 'mkdir ' + os.path.join(path, '0_results', new_dir)
os.system(command)
parent_dir = os.path.join(path, '0_results', new_dir)
for s, map in zip(subjects, maps):
name = s
command = 'mkdir ' + os.path.join(parent_dir, name)
os.system(command)
results_dir = os.path.join(parent_dir, name)
fname = name + '_radius_' + str(radius) + '_searchlight_map.nii.gz'
map.to_filename(os.path.join(results_dir, fname))
return maps
def test_nifti_dataset_from3_d():
"""Test NiftiDataset based on 3D volume(s)
"""
tssrc = pathjoin(pymvpa_dataroot, 'bold.nii.gz')
masrc = pathjoin(pymvpa_dataroot, 'mask.nii.gz')
# Test loading of 3D volumes
# by default we are enforcing 4D, testing here with the demo 3d mask
ds = fmri_dataset(masrc, mask=masrc, targets=1)
assert_equal(len(ds), 1)
import nibabel
plain_data = nibabel.load(masrc).get_data()
# Lets check if mapping back works as well
assert_array_equal(plain_data,
map2nifti(ds).get_data().reshape(plain_data.shape))
# test loading from a list of filenames
# for now we should fail if trying to load a mix of 4D and 3D volumes
# TODO: nope -- it should work and we should test here if correctly
dsfull_plusone = fmri_dataset((masrc, tssrc), mask=masrc, targets=1)
# Lets prepare some custom NiftiImage
dsfull = fmri_dataset(tssrc, mask=masrc, targets=1)
assert_equal(len(dsfull) + 1, len(dsfull_plusone))
assert_equal(dsfull.nfeatures, dsfull_plusone.nfeatures)
# skip 3d mask in 0th sample
assert_array_equal(dsfull.samples, dsfull_plusone[1:].samples)
ds_selected = dsfull[3]
nifti_selected = map2nifti(ds_selected)
# Load dataset from a mix of 3D volumes
# (given by filenames and NiftiImages)
labels = [123, 2, 123]
ds2 = fmri_dataset((masrc, masrc, nifti_selected),
mask=masrc, targets=labels)
assert_equal(ds2.nsamples, 3)
assert_array_equal(ds2.samples[0], ds2.samples[1])
assert_array_equal(ds2.samples[2], dsfull.samples[3])
assert_array_equal(ds2.targets, labels)
def searchlight(self, ds, cvte):
sl = sphere_searchlight(cvte,
radius= self._radius,
space = 'voxel_indices')
sl_map = sl(ds)
sl_map.samples *= -1
sl_map.samples += 1
map_ = map2nifti(sl_map, imghdr=ds.a.imghdr)
map_ = ni.Nifti1Image(map_.get_data(), affine=ds.a.imgaffine)
self.maps.append(map_)
return map_
def _forward_dataset(self,ds):
if self._neighbors is None and ds.samples.max()== ds.samples.min():
raise RuntimeError("The dataset is homogeneity, so the neighbors which offer spatial constrain cannot be null.")
img = map2nifti(ds)
mds = ds.copy(deep = Flase)
mds.samples = ds.samples.copy()
for c in mds.sa[chunks_attr].unique:
slicer = np.where(mds.sa[chunks_attr].value == c)[0]
mds.samples[slicer] = self._graph(mds.samples[slicer],np.shape(img))
mds.a['DsType'] = 'graph'
mds.a['header'] = img.get_header()
mds.a['dims'] = np.shape(img)
return mds
def test_regress_fmri_dataset(tempfile=None, testfile=None):
if not externals.exists('nibabel'):
raise SkipTest("can't test without nibabel")
# verify that we have actual load
if not (exists(testfile) and exists(realpath(testfile))):
raise SkipTest("File %s seems to be missing -- 'git annex get .' "
"to fetch all test files first" % testfile)
# Still might be a direct mode, or windows -- so lets check the size
if os.stat(testfile).st_size < 1000:
raise SkipTest("File %s seems to be small/empty -- 'git annex get .' "
"to fetch all test files first" % testfile)
from mvpa2.datasets.mri import map2nifti
ds = h5load(testfile) # load previously generated dataset
# rudimentary checks that data was loaded correctly
assert_equal(np.sum(ds), 11444)
assert_equal(sorted(ds.sa.keys()),
['chunks', 'targets', 'time_coords', 'time_indices'])
assert_equal(sorted(ds.fa.keys()), ['voxel_indices'])
# verify that map2nifti works whenever version of nibabel on the system
# greater or equal that one it was saved with:
if externals.versions['nibabel'] >= ds.a.versions['nibabel']:
# test that we can get str of the niftihdr:
# to avoid such issues as https://github.com/PyMVPA/PyMVPA/issues/278
hdr_str = str(ds.a.imghdr)
assert(hdr_str != "")
ds_ni = map2nifti(ds)
# verify that we can store generated nifti to a file
ds_ni.to_filename(tempfile)
assert(os.path.exists(tempfile))
else:
raise SkipTest(
"Our version of nibabel %s is older than the one file %s was saved "
"with: %s" % (externals.versions['nibabel'],
testfile,
ds.a.versions['nibabel']))
def test_regress_fmri_dataset(tempfile=None, testfile=None):
if not externals.exists('nibabel'):
raise SkipTest("can't test without nibabel")
# verify that we have actual load
if not (exists(testfile) and exists(realpath(testfile))):
raise SkipTest("File %s seems to be missing -- 'git annex get .' "
"to fetch all test files first" % testfile)
# Still might be a direct mode, or windows -- so lets check the size
if os.stat(testfile).st_size < 1000:
raise SkipTest("File %s seems to be small/empty -- 'git annex get .' "
"to fetch all test files first" % testfile)
from mvpa2.datasets.mri import map2nifti
ds = h5load(testfile) # load previously generated dataset
# rudimentary checks that data was loaded correctly
assert_equal(np.sum(ds), 11444)
assert_equal(sorted(ds.sa.keys()),
['chunks', 'targets', 'time_coords', 'time_indices'])
assert_equal(sorted(ds.fa.keys()), ['voxel_indices'])
# verify that map2nifti works whenever version of nibabel on the system
# greater or equal that one it was saved with:
if externals.versions['nibabel'] >= ds.a.versions['nibabel']:
# test that we can get str of the niftihdr:
# to avoid such issues as https://github.com/PyMVPA/PyMVPA/issues/278
hdr_str = str(ds.a.imghdr)
assert (hdr_str != "")
ds_ni = map2nifti(ds)
# verify that we can store generated nifti to a file
ds_ni.to_filename(tempfile)
assert (os.path.exists(tempfile))
else:
raise SkipTest(
"Our version of nibabel %s is older than the one file %s was saved "
"with: %s" % (externals.versions['nibabel'], testfile,
ds.a.versions['nibabel']))
def do_searchlight(glm_dataset, radius, output_basename, with_null_prob=False, clf=LinearCSVMC(space='condition')):
if(len(glob(output_basename+"*")) > 0):
print "sl already ran"
return
splt = ChainNode([NFoldPartitioner(),Balancer(attr='condition',count=1,limit='partitions',apply_selection=True)],space='partitions')
#splt = NFoldPartitioner()
cv = CrossValidation(clf, splt,
errorfx=mean_match_accuracy,
enable_ca=['stats'], postproc=mean_sample())
distr_est = []
if with_null_prob:
permutator = AttributePermutator('condition', count=100,
limit='chunks')
distr_est = MCNullDist(permutator, tail='left',
enable_ca=['dist_samples'])
"""
repeater = Repeater(count=100)
permutator = AttributePermutator('condition', limit={'partitions': 1}, count=1)
null_cv = CrossValidation(clf, ChainNode([splt, permutator],space=splt.get_space()),
postproc=mean_sample())
null_sl = sphere_searchlight(null_cv, radius=radius, space='voxel_indices',
enable_ca=['roi_sizes'])
distr_est = MCNullDist(repeater,tail='left', measure=null_sl,
enable_ca=['dist_samples'])
sl = sphere_searchlight(cv, radius=radius, space='voxel_indices',
null_dist=distr_est,
enable_ca=['roi_sizes', 'roi_feature_ids']
# ,result_fx = _fill_in_scattered_results # average across all spheres
)
"""
else:
kwa = {'voxel_indices': KNNNeighbourhood(radius, glm_dataset.fa['voxel_indices'])}
qe = IndexQueryEngine(**kwa)
# init the searchlight with the queryengine
sl = Searchlight(cv, queryengine=qe, roi_ids=None,
enable_ca=['roi_sizes', 'roi_feature_ids']
# ,results_fx = _fill_in_scattered_results # average across all spheres
)
#;v sl = sphere_searchlight(cv, radius=radius, space='voxel_indices',
# ,result_fx = _fill_in_scattered_results # average across all spheres
# )
# ds = glm_dataset.copy(deep=False,
# sa=['condition','chunks'],
# fa=['voxel_indices'],
# a=['mapper'])
from datetime import datetime
print "starting sl {}".format(datetime.now())
sl_map = sl(glm_dataset)
print "finished sl {}".format(datetime.now())
import pickle
pickle.dump(sl_map, open("{}_sl_map.p".format(output_basename), "wb"))
# pickle.dump(sl.ca.roi_feature_ids, open("{}_sl_feature_ids.p".format(output_basename), "wb"))
# print len(sl.ca.roi_feature_ids[0])
acc_results = map2nifti(sl_map,
imghdr=glm_dataset.a.imghdr)
acc_nii_filename = '{}-acc.nii.gz'.format(output_basename)
acc_results.to_filename(acc_nii_filename)
sl_map.samples *= -1
sl_map.samples += 1
niftiresults = map2nifti(sl_map,
imghdr=glm_dataset.a.imghdr)
niftiresults.to_filename('{}-err.nii.gz'.format(output_basename))
# TODO: check p value map
if with_null_prob:
nullt_results = map2nifti(sl_map, data=sl.ca.null_t,
imghdr=glm_dataset.a.imghdr)
nullt_results.to_filename('{}-t.nii.gz'.format(output_basename))
nullprob_results = map2nifti(sl_map, data=sl.ca.null_prob,
imghdr=glm_dataset.a.imghdr)
nullprob_results.to_filename('{}-prob.nii.gz'.format(output_basename))
nullprob_results = map2nifti(sl_map, data=distr_est.cdf(sl_map.samples),
imghdr=glm_dataset.a.imghdr)
nullprob_results.to_filename('{}-cdf.nii.gz'.format(output_basename))
return sl_map
perm_count.append(len(sds) - 1)
print 'Merge data', time.asctime()
orig_ds = Dataset(orig, sa=dict(subj=subj_ids), fa=sds.fa, a=sds.a)
perm_ds = Dataset(np.vstack(perms),
sa=dict(subj=np.repeat(subj_ids, perm_count)),
fa=sds.fa,
a=sds.a)
# some magic to drop the memory demand
del orig
del perms
print 'Train thresholder', time.asctime()
thr = GroupClusterThreshold(n_bootstrap=10000,
chunk_attr='subj',
n_blocks=100,
feature_thresh_prob=0.001,
n_proc=1,
fwe_rate=0.05)
thr.train(perm_ds)
print 'Treshold', time.asctime()
res = thr(orig_ds)
h5save('grpavg_stats.hdf5', res, compression=9)
print 'Store results', time.asctime()
nb.save(map2nifti(res, res.samples), 'avg_acc.nii.gz')
nb.save(map2nifti(res, res.fa.clusters_fwe_thresh),
'fwecorrected_clusters.nii.gz')
nb.save(map2nifti(res, res.fa.featurewise_thresh), 'featurewise_thresh.nii.gz')
'background' : os.path.join(sessionPath,'/home/brain/host/pymvpaniifiles/anat.nii.gz'),
'background_mask' : os.path.join(sessionPath,'/home/brain/host/pymvpaniifiles/mask_brain.nii.gz'),
'overlay_mask' : os.path.join(sessionPath,'analyze/structural/lc2ms_deskulled.hdr'),
'do_stretch_colors' : False,
'cmap_bg' : 'gray',
'cmap_overlay' : 'autumn', # pl.cm.autumn
'interactive' : cfg.getboolean('examples', 'interactive', True),
}
for radius in [3]:
# tell which one we are doing
print 'Running searchlight with radius: %i ...' % (radius)
sl = sphere_searchlight(foldwiseCvedAnovaSelectedSMLR, radius=radius, space='voxel_indices',
center_ids=center_ids,
postproc=mean_sample())
ds = dataset.copy(deep=False,
sa=['targets', 'chunks'],
fa=['voxel_indices'],
a=['mapper'])
sl_map = sl(ds)
sl_map.samples *= -1
sl_map.samples += 1
niftiresults = map2nifti(sl_map, imghdr=dataset.a.imghdr)
niftiresults.to_filename(os.path.join(sessionPath,'analyze/functional/%s-grey-searchlight.nii') % classificationName)
print 'Best performing sphere error:', np.min(sl_map.samples)
def runsub(sub, thisContrast, r, dstype="raw", roi="grayMatter", filterLen=49, filterOrd=3, write=False):
if dstype == "raw":
outdir = "PyMVPA"
print "working with raw data"
thisSub = {sub: subList[sub]}
dsdict = lmvpa.loadsubdata(paths, thisSub, m=roi)
thisDS = dsdict[sub]
mc_params = lmvpa.loadmotionparams(paths, thisSub)
beta_events = lmvpa.loadevents(paths, thisSub)
# savitsky golay filtering
sg.sg_filter(thisDS, filterLen, filterOrd)
# gallant group zscores before regression.
# zscore w.r.t. rest trials
# zscore(thisDS, param_est=('targets', ['rest']), chunks_attr='chunks')
# zscore entire set. if done chunk-wise, there is no double-dipping (since we leave a chunk out at a time).
zscore(thisDS, chunks_attr="chunks")
print "beta extraction"
## BETA EXTRACTION ##
rds, events = lmvpa.amendtimings(thisDS.copy(), beta_events[sub])
evds = er.fit_event_hrf_model(
rds,
events,
time_attr="time_coords",
condition_attr=("trial_type", "chunks"),
design_kwargs={"add_regs": mc_params[sub], "hrf_model": "canonical"},
return_model=True,
)
fds = lmvpa.replacetargets(evds, contrasts, thisContrast)
fds = fds[fds.targets != "0"]
else:
outdir = os.path.join("LSS", dstype)
print "loading betas"
fds = lmvpa.loadsubbetas(paths, sub, btype=dstype, m=roi)
fds.sa["targets"] = fds.sa[thisContrast]
zscore(fds, chunks_attr="chunks")
fds = lmvpa.sortds(fds)
print "searchlights"
## initialize classifier
clf = svm.LinearNuSVMC()
cv = CrossValidation(clf, NFoldPartitioner())
from mvpa2.measures.searchlight import sphere_searchlight
cvSL = sphere_searchlight(cv, radius=r)
# now I have betas per chunk. could just correlate the betas, or correlate the predictions for corresponding runs
lidx = fds.chunks < fds.sa["chunks"].unique[len(fds.sa["chunks"].unique) / 2]
pidx = fds.chunks >= fds.sa["chunks"].unique[len(fds.sa["chunks"].unique) / 2]
lres = sl.run_cv_sl(cvSL, fds[lidx].copy(deep=False))
pres = sl.run_cv_sl(cvSL, fds[pidx].copy(deep=False))
if write:
from mvpa2.base import dataset
map2nifti(fds, dataset.vstack([lres, pres])).to_filename(
os.path.join(paths[0], "Maps", outdir, sub + "_" + roi + "_" + thisContrast + "_cvsl.nii.gz")
)
del lres, pres, cvSL
cvSL = sphere_searchlight(cv, radius=r)
crossSet = fds.copy()
crossSet.chunks[lidx] = 1
crossSet.chunks[pidx] = 2
cres = sl.run_cv_sl(cvSL, crossSet.copy(deep=False))
if write:
map2nifti(fds, cres[0]).to_filename(
os.path.join(paths[0], "Maps", outdir, sub + "_" + roi + "_" + (thisContrast) + "_P2L.nii.gz")
)
map2nifti(fds, cres[1]).to_filename(
os.path.join(paths[0], "Maps", outdir, sub + "_" + roi + "_" + (thisContrast) + "_L2P.nii.gz")
)
def runsub(sub,
thisContrast,
filterLen,
filterOrd,
thisContrastStr,
roi='grayMatter'):
thisSub = {sub: subList[sub]}
mc_params = lmvpa.loadmotionparams(paths, thisSub)
beta_events = lmvpa.loadevents(paths, thisSub)
dsdict = lmvpa.loadsubdata(paths, thisSub, m=roi, c='trial_type')
thisDS = dsdict[sub]
# savitsky golay filtering
sg.sg_filter(thisDS, filterLen, filterOrd)
# gallant group zscores before regression.
# zscore w.r.t. rest trials
# zscore(thisDS, param_est=('targets', ['rest']), chunks_attr='chunks')
# zscore entire set. if done chunk-wise, there is no double-dipping (since we leave a chunk out at a time).
zscore(thisDS, chunks_attr='chunks')
# kay method: leave out a model run, use it to fit an HRF for each voxel
# huth method: essentially use FIR
# mumford method: deconvolution with canonical HRF
# refit events and regress...
# get timing data from timing files
rds, events = lmvpa.amendtimings(thisDS.copy(), beta_events[sub],
contrasts) # adding features
# we can model out motion and just not use those betas.
if isinstance(thisContrast, basestring):
thisContrast = [thisContrast]
# instead of binarizing each one, make them parametric
desX, rds = lmvpa.make_designmat(rds,
events,
time_attr='time_coords',
condition_attr=thisContrast,
design_kwargs={
'hrf_model': 'canonical',
'drift_model': 'blank'
},
regr_attrs=None)
# want to collapse ap and cr, but have anim separate
des = lmvpa.make_parammat(desX)
# set chunklen and nchunks
# split by language and pictures
lidx = thisDS.chunks < thisDS.sa['chunks'].unique[len(
thisDS.sa['chunks'].unique) / 2]
pidx = thisDS.chunks >= thisDS.sa['chunks'].unique[len(
thisDS.sa['chunks'].unique) / 2]
ldes = cp.copy(des)
pdes = cp.copy(des)
ldes.matrix = ldes.matrix[lidx]
pdes.matrix = pdes.matrix[pidx]
lwts, lres, lceil = bsr.bootstrap_linear(rds[lidx],
ldes,
part_attr='chunks',
mode='test')
pwts, pres, pceil = bsr.bootstrap_linear(rds[pidx],
pdes,
part_attr='chunks',
mode='test')
# now I have betas per chunk. could just correlate the betas, or correlate the predictions for corresponding runs
print 'language ' + str(np.mean(lres))
# pictures within
print 'pictures: ' + str(np.mean(pres))
from mvpa2.base import dataset
map2nifti(thisDS, dataset.vstack([lres, pres])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_univar_corr.nii.gz'))
map2nifti(thisDS, dataset.vstack([lwts, pwts])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_univar_betas.nii.gz'))
map2nifti(thisDS, dataset.vstack([lceil, pceil])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_univar_ceiling.nii.gz'))
del lres, pres, lwts, pwts, lceil, pceil
crossSet = thisDS.copy()
crossSet.chunks[lidx] = 1
crossSet.chunks[pidx] = 2
cwts, cres, cceil = bsr.bootstrap_linear(crossSet,
des,
part_attr='chunks',
mode='test')
print 'cross: ' + str(np.mean(cres))
map2nifti(thisDS, cres[0]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding',
sub + '_' + roi + '_' + thisContrastStr + '_P2L_univar.nii.gz'))
map2nifti(thisDS, cres[1]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding',
sub + '_' + roi + '_' + thisContrastStr + '_L2P_univar.nii.gz'))
map2nifti(thisDS, cwts[0]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding',
sub + '_' + roi + '_' + thisContrastStr + '_P2L_betas.nii.gz'))
map2nifti(thisDS, cwts[1]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding',
sub + '_' + roi + '_' + thisContrastStr + '_L2P_betas.nii.gz'))
map2nifti(thisDS, cceil[0]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding',
sub + '_' + roi + '_' + thisContrastStr + '_P2L_betas.nii.gz'))
map2nifti(thisDS, cceil[1]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding',
sub + '_' + roi + '_' + thisContrastStr + '_L2P_betas.nii.gz'))
print 'Loading subj %i' % subj
sds = h5load(_opj('grp_results', 'grpspace_sub%.3i.hdf5' % subj))
orig.append(sds.samples[0])
perms.append(sds.samples[1:])
perm_count.append(len(sds) - 1)
print 'Merge data', time.asctime()
orig_ds = Dataset(orig, sa=dict(subj=subj_ids), fa=sds.fa, a=sds.a)
perm_ds = Dataset(np.vstack(perms),
sa=dict(subj=np.repeat(subj_ids, perm_count)),
fa=sds.fa,
a=sds.a)
# some magic to drop the memory demand
del orig
del perms
print 'Train thresholder', time.asctime()
thr = GroupClusterThreshold(
n_bootstrap=10000, chunk_attr='subj', n_blocks=100,
feature_thresh_prob=0.001, n_proc=1, fwe_rate=0.05)
thr.train(perm_ds)
print 'Treshold', time.asctime()
res = thr(orig_ds)
h5save('grpavg_stats.hdf5', res, compression=9)
print 'Store results', time.asctime()
nb.save(map2nifti(res, res.samples), 'avg_acc.nii.gz')
nb.save(map2nifti(res, res.fa.clusters_fwe_thresh), 'fwecorrected_clusters.nii.gz')
nb.save(map2nifti(res, res.fa.featurewise_thresh), 'featurewise_thresh.nii.gz')
# get onsets
spec = get_onsets_famface(
os.path.join(data_basedir, sub, 'model/model001/onsets', run),
amplitudes)
# increment amplitude for unfam
amplitudes[1] += 0.5
# create second specification for contrast that does not increase
# in different roi
straightspec = copy.deepcopy(spec)
straightspec[0]['amplitude'] = 8
straightspec[1]['amplitude'] = 1
for cond in straightspec:
cond['roivalue'] = 24
spec.append(cond)
# transform mask to subject space
mask_subjspace = mask2subjspace_real(maskpath, anat, boldfile,
mni2anat_hd5, affine_matrix,
workdir)
# add signal
with_signal = add_signal_custom(noise, mask_subjspace, spec)
# save data
image = map2nifti(with_signal)
image.to_filename(
os.path.join(data_basedir, sub, 'BOLD', run, 'sim.nii.gz'))
def main(subject,
study_dir,
mask,
feature_mask,
models,
category,
res_name,
suffix='_stim_fix2',
radius=3,
n_perm=1000,
n_proc=None):
from mvpa2.mappers.zscore import zscore
from mvpa2.mappers.fx import mean_group_sample
from mvpa2.measures.searchlight import sphere_searchlight
from mvpa2.datasets.mri import map2nifti
from wikisim import mvpa
# load subject data
sp = su.SubjPath(subject, study_dir)
vols = task.prex_vols(sp.path('behav', 'log'))
# load fmri data
ds = mvpa.load_prex_beta(sp,
suffix,
mask,
feature_mask=feature_mask,
verbose=1)
# zscore
ds.sa['run'] = vols.run.values
zscore(ds, chunks_attr='run')
# average over item presentations
ds.sa['itemno'] = vols.itemno.to_numpy()
m = mean_group_sample(['itemno'])
dsm = ds.get_mapped(m)
# get items of interest
if category == 'face':
cond = [1, 2]
elif category == 'scene':
cond = [3, 4]
else:
ValueError(f'Invalid category code: {category}')
include = vols.groupby('itemno').first()['cond'].isin(cond)
# get models of interest
model_dir = os.path.join(study_dir, 'batch', 'models3')
model_names = models.split('-')
model_rdms_dict = model.load_category_rdms(model_dir, category,
model_names)
model_rdms = [model_rdms_dict[name] for name in model_names]
# set up searchlight
m = mvpa.ItemPartialRSA(model_rdms, n_perm)
sl = sphere_searchlight(m, radius=radius, nproc=n_proc)
sl_map = sl(dsm[include])
nifti_include = map2nifti(ds, sl_map[-1])
for i, name in enumerate(model_names):
# save zstat map
res_dir = sp.path('rsa', f'{res_name}_{name}')
if not os.path.exists(res_dir):
os.makedirs(res_dir)
filepath = os.path.join(res_dir, 'zstat.nii.gz')
nifti = map2nifti(ds, sl_map[i])
nifti.to_filename(filepath)
# save mask of included voxels
include_file = os.path.join(res_dir, 'included.nii.gz')
nifti_include.to_filename(include_file)
if __name__ == "__main__":
# datadir = '../data'
targnii = 'prob-face-object.nii.gz'
masknii = 'prob-face-object.nii.gz'
mask = nib.load(masknii)
mask = mask.get_data()
# ds = bpfmri_dataset(pjoin(datadir,targnii))
ds = bpfmri_dataset(targnii)
nbs = neighbor.volneighbors(mask, 3,26 )
nbs = nbs.compute_offsets()
map = GraphMapper(nbs)
nds = map(ds)
# assert_array_equal(data, map2nifti(nds).get_data()[...,0])
result = map2nifti(nds)
def spectral_seg(hfilename,outf):
'''
Spectral clustering...
'''
tmpset = Dataset([])
#pdb.set_trace()
print "hdf name:",hfilename
st = time.time()
###1.load connectivity profile of seed mask voxels
conn = h5load(hfilename)
tmpset.a = conn.a
print "connection matrix shape:"
print conn.shape
###2.features select
mask = create_mask(conn.samples,5)
conn_m = conn.samples[mask]
map = conn_m.T
print "masked conn matrix:"
print map.shape,map.max(),map.min()
###3.average the connection profile.
temp = np.zeros(map.shape)
voxel = np.array(conn.fa.values())
v = voxel[0]
v = v.tolist()
shape = [256,256,256]
i = 0
for coor in v:
mean_f = map[i]
#print mean_f.shape
#plt.plot(mean_f)
#plt.show()
neigh =get_neighbors(coor,2,shape)
#print "neigh:",neigh
count = 1
for n in neigh:
if n in v:
mean_f = (mean_f*count + map[v.index(n)])/(count+1)
count+=1
temp[i] = mean_f
i+=1
#sys.exit(0)
map = temp
print "average connection matrix"
###4.spacial distance
spacedist = ds.cdist(v,v,'euclidean')
#print spacedist
###5.correlation matrix
corr = np.corrcoef(map)
corr = np.abs(corr)
###6.mix similariry matrix.
corr = 0.7*corr + 0.3/(spacedist+1)
#plt.imshow(corr,interpolation='nearest',cmap=cm.jet)
#cb = plt.colorbar()
#pl.xticks(())
#pl.yticks(())
#pl.show()
print "mix up the corr and spacial matrix"
#sys.exit(0)
###7.spectral segmentation
print "do segmentation"
cnum = 3
near = 100
sc = SpectralClustering(cnum,'arpack',None,100,1,'precomputed',near,None,True)
sc.fit_predict(corr)
tmpset.samples = sc.labels_+1
print "Number of voxels: ", sc.labels_.size
print "Number of clusters: ", np.unique(sc.labels_).size
print "Elapsed time: ", time.time() - st
###8.save the segmentation result.
print "save the result to xxx_parcel.nii.gz"
result = map2nifti(tmpset)
result.to_filename(outf)
print ".....Segment end........"
return True
# orig results
ds = h5load(_opj('results', 'sub%.3i_2.0mm_hrf_sl_orig.hdf5' % subj))
# load permutations and merge with orig results
data = np.vstack([ds.samples[0]] + [
np.load(fname) for fname in sorted(
glob(_opj('results', 'sub%.3i_2.0mm_hrf_sl_perm*.npy' % subj)))
])
#data = ds.samples
# write out as NIfTI
tdir = mkdtemp()
print tdir
orig_fname = _opj(tdir, 'data_in_orig.nii.gz')
group_fname = _opj(tdir, 'data_in_group.nii.gz')
nb.save(map2nifti(ds, data, imghdr=subjtmpl.get_header()), orig_fname)
# project into group space
ref_fname = "BASEDIR/templates/grpbold7Tp1/brain.nii.gz"
warp_fname = "BASEDIR/sub%.3i/templates/bold7Tp1/in_grpbold7Tp1/subj2tmpl_warp.nii.gz" % subj
subprocess.check_call([
"applywarp",
"--in=%s" % orig_fname,
"--out=%s" % group_fname,
"--ref=%s" % ref_fname,
"--warp=%s" % warp_fname
])
# and back into a dataset
# group intersection brain mask
mask_fname = 'BASEDIR/templates/grpbold7Tp1/qa/subjbold7Tp1_to_grpbold7Tp1/brain_mask_intersection.nii.gz'
def do_searchlight(glm_dataset, radius, output_basename, with_null_prob=False):
clf = LinearCSVMC(space='condition')
# clf = RbfCSVMC(C=5.0)
splt = NFoldPartitioner()
cv = CrossValidation(clf,
splt,
errorfx=mean_match_accuracy,
enable_ca=['stats'],
postproc=mean_sample())
distr_est = []
if with_null_prob:
permutator = AttributePermutator('condition',
count=100,
limit='chunks')
distr_est = MCNullDist(permutator,
tail='left',
enable_ca=['dist_samples'])
"""
repeater = Repeater(count=100)
permutator = AttributePermutator('condition', limit={'partitions': 1}, count=1)
null_cv = CrossValidation(clf, ChainNode([splt, permutator],space=splt.get_space()),
postproc=mean_sample())
null_sl = sphere_searchlight(null_cv, radius=radius, space='voxel_indices',
enable_ca=['roi_sizes'])
distr_est = MCNullDist(repeater,tail='left', measure=null_sl,
enable_ca=['dist_samples'])
"""
sl = sphere_searchlight(cv,
radius=radius,
space='voxel_indices',
null_dist=distr_est,
enable_ca=['roi_sizes', 'roi_feature_ids'])
else:
sl = sphere_searchlight(cv,
radius=radius,
space='voxel_indices',
enable_ca=['roi_sizes', 'roi_feature_ids'])
#ds = glm_dataset.copy(deep=False,
# sa=['condition','chunks'],
# fa=['voxel_indices'],
# a=['mapper'])
#debug.active += ["SLC"]
sl_map = sl(glm_dataset)
errresults = map2nifti(sl_map, imghdr=glm_dataset.a.imghdr)
errresults.to_filename('{}-acc.nii.gz'.format(output_basename))
sl_map.samples *= -1
sl_map.samples += 1
niftiresults = map2nifti(sl_map, imghdr=glm_dataset.a.imghdr)
niftiresults.to_filename('{}-err.nii.gz'.format(output_basename))
#TODO: save p value map
if with_null_prob:
nullt_results = map2nifti(sl_map,
data=sl.ca.null_t,
imghdr=glm_dataset.a.imghdr)
nullt_results.to_filename('{}-t.nii.gz'.format(output_basename))
nullprob_results = map2nifti(sl_map,
data=sl.ca.null_prob,
imghdr=glm_dataset.a.imghdr)
nullprob_results.to_filename('{}-prob.nii.gz'.format(output_basename))
nullprob_results = map2nifti(sl_map,
data=distr_est.cdf(sl_map.samples),
imghdr=glm_dataset.a.imghdr)
nullprob_results.to_filename('{}-cdf.nii.gz'.format(output_basename))
def runsub(sub, thisContrast, thisContrastStr, testContrast,
filterLen, filterOrd, write=False, debug=False,
alphas=1, roi='grayMatter'):
thisSub = {sub: subList[sub]}
mc_params = lmvpa.loadmotionparams(paths, thisSub)
beta_events = lmvpa.loadevents(paths, thisSub)
dsdict = lmvpa.loadsubdata(paths, thisSub, m=roi, c='trial_type')
thisDS = dsdict[sub]
# savitsky golay filtering
sg.sg_filter(thisDS, filterLen, filterOrd)
# gallant group zscores before regression.
# zscore w.r.t. rest trials
# zscore(thisDS, param_est=('targets', ['rest']), chunks_attr='chunks')
# zscore entire set. if done chunk-wise, there is no double-dipping (since we leave a chunk out at a time).
zscore(thisDS, chunks_attr='chunks')
# kay method: leave out a model run, use it to fit an HRF for each voxel
# huth method: essentially use FIR
# mumford method: deconvolution with canonical HRF
# get timing data from timing files
rds, events = lmvpa.amendtimings(thisDS.copy(), beta_events[sub], contrasts) # adding features
# we can model out motion and just not use those betas.
# Ridge
if isinstance(thisContrast, basestring):
thisContrast = [thisContrast]
desX, rds = lmvpa.make_designmat(rds, events, time_attr='time_coords', condition_attr=thisContrast,
design_kwargs={'hrf_model': 'canonical', 'drift_model': 'blank'},
regr_attrs=None)
# 'add_regs': mc_params[sub]
desX['motion'] = make_dmtx(rds.sa['time_coords'].value, paradigm=None, add_regs=mc_params[sub], drift_model='blank')
des = lmvpa.make_parammat(desX, hrf='canonical', zscore=True)
# split by language and pictures
lidx = thisDS.chunks < thisDS.sa['chunks'].unique[len(thisDS.sa['chunks'].unique) / 2]
pidx = thisDS.chunks >= thisDS.sa['chunks'].unique[len(thisDS.sa['chunks'].unique) / 2]
ldes = cp.copy(des)
pdes = cp.copy(des)
ldes.matrix = ldes.matrix[lidx]
pdes.matrix = pdes.matrix[pidx]
covarmat = None
mus = None
lwts, _, lres, lceil = bsr.bootstrap_ridge(ds=rds[lidx], des=ldes, chunklen=1, nchunks=1,
cov0=None, mu0=None, part_attr='chunks', mode='test',
alphas=[alphas[0]], single_alpha=True, normalpha=False,
nboots=1, corrmin=.2, singcutoff=1e-10, joined=None,
use_corr=True)
print 'language ' + str(np.mean(lres))
pwts, _, pres, pceil = bsr.bootstrap_ridge(ds=rds[pidx], des=pdes, chunklen=1, nchunks=1,
cov0=None, mu0=None, part_attr='chunks', mode='test',
alphas=[alphas[1]], single_alpha=True, normalpha=False,
nboots=1, corrmin=.2, singcutoff=1e-10, joined=None,
use_corr=True)
# pictures within
print 'pictures: ' + str(np.mean(pres))
if write:
map2nifti(thisDS, dataset.vstack([lres, pres])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_la_' + str(alphas[0]) + '_pa_' + str(alphas[1]) + '_corrs.nii.gz'))
map2nifti(thisDS, dataset.vstack([lwts, pwts])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_la_' + str(alphas[0]) + '_pa_' + str(alphas[1]) + '_wts.nii.gz'))
map2nifti(thisDS, dataset.vstack([lceil, pceil])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_la_' + str(alphas[0]) + '_pa_' + str(alphas[1]) + '_ceiling.nii.gz'))
for t in testContrast:
tstr = '+'.join(t)
lcorr = lmvpa.testmodel(wts=lwts, des=ldes, ds=rds[lidx], tc=cp.copy(t), use_corr=True)
pcorr = lmvpa.testmodel(wts=pwts, des=pdes, ds=rds[pidx], tc=cp.copy(t), use_corr=True)
if write:
map2nifti(thisDS, dataset.vstack([lcorr, pcorr])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + tstr +
'_ridge_la_' + str(alphas[0]) + '_pa_' + str(alphas[1]) + '_test_corrs.nii.gz'))
del lres, pres, lwts, pwts, lceil, pceil
crossSet = thisDS.copy()
crossSet.chunks[lidx] = 1
crossSet.chunks[pidx] = 2
# cwts, cres, cceil = bsr.ridge(rds[pidx], pdes, mu0=mus, cov0=covarmat,
# part_attr='chunks', mode='test', alphas=alphas[0], single_alpha=True,
# normalpha=False, corrmin=.2, singcutoff=1e-10, joined=None,
# use_corr=True)
cwts, _, cres, cceil = bsr.bootstrap_ridge(ds=crossSet, des=des, chunklen=1, nchunks=1,
cov0=None, mu0=None, part_attr='chunks', mode='test',
alphas=[alphas[2]], single_alpha=True, normalpha=False,
nboots=1, corrmin=.2, singcutoff=1e-10, joined=None,
use_corr=True)
for t in testContrast:
tstr = '+'.join(t)
ccorr = lmvpa.testmodel(wts=cwts, des=des, ds=crossSet, tc=cp.copy(t), use_corr=True)
if write:
map2nifti(thisDS, ccorr[0]) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + tstr +
'_P2L_ridge_alpha_' + str(alphas[2]) + '_test_corr.nii.gz'))
map2nifti(thisDS, ccorr[1]) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + tstr +
'_L2P_ridge_alpha_' + str(alphas[2]) + '_test_corr.nii.gz'))
print 'cross: ' + str(np.mean(cres))
if write:
map2nifti(thisDS, cres[0]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_P2L_ridge_alpha_' + str(alphas[2]) + '_corr.nii.gz'))
map2nifti(thisDS, cres[1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_L2P_ridge_alpha_' + str(alphas[2]) + '_corr.nii.gz'))
map2nifti(thisDS, cwts[cwts.chunks==1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_P2L_ridge_alpha_' + str(alphas[2]) + '_wts.nii.gz'))
map2nifti(thisDS, cwts[cwts.chunks==2]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_L2P_ridge_alpha' + str(alphas[2]) + '_wts.nii.gz'))
map2nifti(thisDS, cceil[0]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_P2L_ridge_alpha_' + str(alphas[2]) + '_ceiling.nii.gz'))
map2nifti(thisDS, cceil[1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_L2P_ridge_alpha_' + str(alphas[2]) + '_ceiling.nii.gz'))
del cres, cwts, cceil
# orig results
ds = h5load(_opj('results', 'sub%.3i_2.0mm_hrf_sl_orig.hdf5' % subj))
# load permutations and merge with orig results
data = np.vstack(
[ds.samples[0]] +
[np.load(fname)
for fname in sorted(
glob(_opj('results', 'sub%.3i_2.0mm_hrf_sl_perm*.npy' % subj)))])
#data = ds.samples
# write out as NIfTI
tdir = mkdtemp()
print tdir
orig_fname = _opj(tdir, 'data_in_orig.nii.gz')
group_fname = _opj(tdir, 'data_in_group.nii.gz')
nb.save(map2nifti(ds, data, imghdr=subjtmpl.get_header()), orig_fname)
# project into group space
ref_fname = "BASEDIR/templates/grpbold7Tp1/brain.nii.gz"
warp_fname = "BASEDIR/sub%.3i/templates/bold7Tp1/in_grpbold7Tp1/subj2tmpl_warp.nii.gz" % subj
subprocess.check_call(
["applywarp",
"--in=%s" % orig_fname,
"--out=%s" % group_fname,
"--ref=%s" % ref_fname,
"--warp=%s" % warp_fname])
# and back into a dataset
# group intersection brain mask
mask_fname = 'BASEDIR/templates/grpbold7Tp1/qa/subjbold7Tp1_to_grpbold7Tp1/brain_mask_intersection.nii.gz'
ds = fmri_dataset(group_fname, mask=mask_fname)
def runsub(sub, thisContrast, thisContrastStr, testContrast,
filterLen, filterOrd, write=False, debug=False,
alphas=1, roi='grayMatter'):
thisSub = {sub: subList[sub]}
mc_params = lmvpa.loadmotionparams(paths, thisSub)
beta_events = lmvpa.loadevents(paths, thisSub)
dsdict = lmvpa.loadsubdata(paths, thisSub, m=roi, c='trial_type')
thisDS = dsdict[sub]
# savitsky golay filtering
sg.sg_filter(thisDS, filterLen, filterOrd)
# gallant group zscores before regression.
# zscore w.r.t. rest trials
# zscore(thisDS, param_est=('targets', ['rest']), chunks_attr='chunks')
# zscore entire set. if done chunk-wise, there is no double-dipping (since we leave a chunk out at a time).
zscore(thisDS, chunks_attr='chunks')
# kay method: leave out a model run, use it to fit an HRF for each voxel
# huth method: essentially use FIR
# mumford method: deconvolution with canonical HRF
# get timing data from timing files
rds, events = lmvpa.amendtimings(thisDS.copy(), beta_events[sub], contrasts) # adding features
# we can model out motion and just not use those betas.
# Ridge
if isinstance(thisContrast, basestring):
thisContrast = [thisContrast]
desX, rds = lmvpa.make_designmat(rds, events, time_attr='time_coords', condition_attr=thisContrast,
design_kwargs={'hrf_model': 'canonical', 'drift_model': 'blank'},
regr_attrs=None)
# 'add_regs': mc_params[sub]
desX['motion'] = make_dmtx(rds.sa['time_coords'].value, paradigm=None, add_regs=mc_params[sub], drift_model='blank')
des = lmvpa.make_parammat(desX, hrf='canonical', zscore=True)
# split by language and pictures
lidx = thisDS.chunks < thisDS.sa['chunks'].unique[len(thisDS.sa['chunks'].unique) / 2]
pidx = thisDS.chunks >= thisDS.sa['chunks'].unique[len(thisDS.sa['chunks'].unique) / 2]
ldes = cp.copy(des)
pdes = cp.copy(des)
ldes.matrix = ldes.matrix[lidx]
pdes.matrix = pdes.matrix[pidx]
covarmat = None
mus = None
lwts, _, lres, lceil = bsr.bootstrap_ridge(ds=rds[lidx], des=ldes, chunklen=1, nchunks=1,
cov0=None, mu0=None, part_attr='chunks', mode='test',
alphas=[alphas[0]], single_alpha=True, normalpha=False,
nboots=1, corrmin=.2, singcutoff=1e-10, joined=None,
use_corr=True)
print 'language ' + str(np.mean(lres))
pwts, _, pres, pceil = bsr.bootstrap_ridge(ds=rds[pidx], des=pdes, chunklen=1, nchunks=1,
cov0=None, mu0=None, part_attr='chunks', mode='test',
alphas=[alphas[1]], single_alpha=True, normalpha=False,
nboots=1, corrmin=.2, singcutoff=1e-10, joined=None,
use_corr=True)
# pictures within
print 'pictures: ' + str(np.mean(pres))
if write:
map2nifti(thisDS, dataset.vstack([lres, pres])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_la_' + str(alphas[0]) + '_pa_' + str(alphas[1]) + '_corrs.nii.gz'))
map2nifti(thisDS, dataset.vstack([lwts, pwts])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_la_' + str(alphas[0]) + '_pa_' + str(alphas[1]) + '_wts.nii.gz'))
map2nifti(thisDS, dataset.vstack([lceil, pceil])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_la_' + str(alphas[0]) + '_pa_' + str(alphas[1]) + '_ceiling.nii.gz'))
for t in testContrast:
tstr = '+'.join(t)
lcorr = lmvpa.testmodel(wts=lwts, des=ldes, ds=rds[lidx], tc=cp.copy(t), use_corr=True)
pcorr = lmvpa.testmodel(wts=pwts, des=pdes, ds=rds[pidx], tc=cp.copy(t), use_corr=True)
if write:
map2nifti(thisDS, dataset.vstack([lcorr, pcorr])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + tstr +
'_ridge_la_' + str(alphas[0]) + '_pa_' + str(alphas[1]) + '_test_corrs.nii.gz'))
del lres, pres, lwts, pwts, lceil, pceil
crossSet = thisDS.copy()
crossSet.chunks[lidx] = 1
crossSet.chunks[pidx] = 2
# cwts, cres, cceil = bsr.ridge(rds[pidx], pdes, mu0=mus, cov0=covarmat,
# part_attr='chunks', mode='test', alphas=alphas[0], single_alpha=True,
# normalpha=False, corrmin=.2, singcutoff=1e-10, joined=None,
# use_corr=True)
cwts, _, cres, cceil = bsr.bootstrap_ridge(ds=crossSet, des=des, chunklen=1, nchunks=1,
cov0=None, mu0=None, part_attr='chunks', mode='test',
alphas=[alphas[2]], single_alpha=True, normalpha=False,
nboots=1, corrmin=.2, singcutoff=1e-10, joined=None,
use_corr=True)
for t in testContrast:
tstr = '+'.join(t)
ccorr = lmvpa.testmodel(wts=cwts, des=des, ds=crossSet, tc=cp.copy(t), use_corr=True)
if write:
map2nifti(thisDS, ccorr[0]) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + tstr +
'_P2L_ridge_alpha_' + str(alphas[2]) + '_test_corr.nii.gz'))
map2nifti(thisDS, ccorr[1]) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + tstr +
'_L2P_ridge_alpha_' + str(alphas[2]) + '_test_corr.nii.gz'))
print 'cross: ' + str(np.mean(cres))
if write:
map2nifti(thisDS, cres[0]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_P2L_ridge_alpha_' + str(alphas[2]) + '_corr.nii.gz'))
map2nifti(thisDS, cres[1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_L2P_ridge_alpha_' + str(alphas[2]) + '_corr.nii.gz'))
map2nifti(thisDS, cwts[cwts.chunks==1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_P2L_ridge_alpha_' + str(alphas[2]) + '_wts.nii.gz'))
map2nifti(thisDS, cwts[cwts.chunks==2]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_L2P_ridge_alpha' + str(alphas[2]) + '_wts.nii.gz'))
map2nifti(thisDS, cceil[0]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_P2L_ridge_alpha_' + str(alphas[2]) + '_ceiling.nii.gz'))
map2nifti(thisDS, cceil[1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_L2P_ridge_alpha_' + str(alphas[2]) + '_ceiling.nii.gz'))
del cres, cwts, cceil
group_all = group1 + group2
gp11 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24]
gp12 = [
11, 12, 13, 14, 29, 30, 31, 32, 33, 34, 25, 26, 27, 28, 35, 36, 37, 38, 39,
40
]
gp21 = [
11, 12, 13, 14, 29, 30, 31, 32, 33, 34, 15, 16, 17, 18, 19, 20, 21, 22, 23,
24
]
gp22 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 25, 26, 27, 28, 35, 36, 37, 38, 39, 40]
gptest = range(1, 2)
# modify this line to choose the data to output
output_gp_name = 'gptest'
output_gp = gptest
greeneye_movie_all = np.empty((len(output_gp), 1), dtype=object)
for i, subj in enumerate(output_gp):
datapath = '/jukebox/ramadge/RAW_DATA/green_eye/niftis/'
# getting first run data
bold_fname = os.path.join(
datapath, 'subj{}_trans_filtered_func_data.nii'.format(subj))
data_tmp = fmri_dataset(bold_fname, mask=mask_fname)
nifti = map2nifti(data_tmp)
subj_data = data_tmp.samples.T
subj_data = subj_data[:, start[subj - 1]:end[subj - 1]]
greeneye_movie_all[i, 0] = subj_data
def main():
'''
Spectral clustering...
'''
st = time.time()
tmpset = Dataset([])
# hfilename = "/nfs/j3/userhome/dangxiaobin/workingdir/cutROI/%s/fdt_matrix2_targets_sc.T.hdf5"%(id)
hfilename = 'fdt_matrix2.T.hdf5'
print hfilename
#load connectivity profile of seed mask voxels
conn = open_conn_mat(hfilename)
tmpset.a = conn.a
print conn.shape, conn.a
#remove some features
mask = create_mask(conn.samples, 0.5, 1)
# print mask,mask.shape
conn_m = mask_feature(conn.samples, mask)
# print conn_m
map = conn_m.T
print "map:"
print map.shape, map.max(), map.min()
voxel = np.array(conn.fa.values())
print voxel[0]
v = voxel[0]
spacedist = ds.cdist(v, v, 'euclidean')
print spacedist
"""
similar_mat = create_similarity_mat(map,conn.fa,0.1,2)
X = np.array(similar_mat)
print "similarity matrix: shape:",X.shape
print X
"""
corr = np.corrcoef(map)
corr = np.abs(corr)
corr = 0.1 * corr + 0.9 / (spacedist + 1)
print "Elaspsed time: ", time.time() - st
print corr.shape, corr
plt.imshow(corr, interpolation='nearest', cmap=cm.jet)
cb = plt.colorbar()
pl.xticks(())
pl.yticks(())
pl.show()
cnum = 3
near = 100
sc = SpectralClustering(cnum, 'arpack', None, 100, 1, 'precomputed', near,
None, True)
#sc.fit(map)
sc.fit_predict(corr)
'''
cnum = 3
near = 100
sc = SpectralClustering(cnum,'arpack',None,100,1,'nearest_neighbors',near,None,True)
sc.fit(map)
# sc.fit_predict(X)
# param = sc.get_params(deep=True)
'''
tmpset.samples = sc.labels_ + 1
# print sc.affinity_matrix_
#print list(sc.labels_)
print "Elaspsed time: ", time.time() - st
print "Number of voxels: ", sc.labels_.size
print "Number of clusters: ", np.unique(sc.labels_).size
result = map2nifti(tmpset)
result.to_filename("fg_parcel_S0006.nii.gz")
print ".....The end........"
group1 = range(1,15)+range(29,35)
group2 = range(15,29)+range(35,41)
group_all = group1+group2
gp11 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,15,16,17,18,19,20,21,22,23,24]
gp12 = [11,12,13,14,29,30,31,32,33,34,25,26,27,28,35,36,37,38,39,40]
gp21 = [11,12,13,14,29,30,31,32,33,34,15,16,17,18,19,20,21,22,23,24]
gp22 = [ 1, 2, 3, 4, 5, 6, 7, 8, 9,10,25,26,27,28,35,36,37,38,39,40]
gptest = range(1,2)
# modify this line to choose the data to output
output_gp_name = 'gptest'
output_gp = gptest
greeneye_movie_all = np.empty((len(output_gp),1), dtype=object)
for i,subj in enumerate(output_gp):
datapath = '/jukebox/ramadge/RAW_DATA/green_eye/niftis/'
# getting first run data
bold_fname = os.path.join(datapath, 'subj{}_trans_filtered_func_data.nii'.format(subj))
data_tmp = fmri_dataset(bold_fname,mask = mask_fname)
nifti = map2nifti(data_tmp)
subj_data = data_tmp.samples.T
subj_data = subj_data[:,start[subj-1]:end[subj-1]]
greeneye_movie_all[i,0] = subj_data
def test_er_nifti_dataset():
# setup data sources
tssrc = os.path.join(pymvpa_dataroot, u'bold.nii.gz')
evsrc = os.path.join(pymvpa_dataroot, 'fslev3.txt')
masrc = os.path.join(pymvpa_dataroot, 'mask.nii.gz')
evs = FslEV3(evsrc).to_events()
# load timeseries
ds_orig = fmri_dataset(tssrc)
# segment into events
ds = eventrelated_dataset(ds_orig, evs, time_attr='time_coords')
# we ask for boxcars of 9s length, and the tr in the file header says 2.5s
# hence we should get round(9.0/2.4) * np.prod((1,20,40) == 3200 features
assert_equal(ds.nfeatures, 3200)
assert_equal(len(ds), len(evs))
# the voxel indices are reflattened after boxcaring , but still 3D
assert_equal(ds.fa.voxel_indices.shape, (ds.nfeatures, 3))
# and they have been broadcasted through all boxcars
assert_array_equal(ds.fa.voxel_indices[:800],
ds.fa.voxel_indices[800:1600])
# each feature got an event offset value
assert_array_equal(ds.fa.event_offsetidx, np.repeat([0, 1, 2, 3], 800))
# check for all event attributes
assert_true('onset' in ds.sa)
assert_true('duration' in ds.sa)
assert_true('features' in ds.sa)
# check samples
origsamples = _load_anyimg(tssrc)[0]
for i, onset in \
enumerate([value2idx(e['onset'], ds_orig.sa.time_coords, 'floor')
for e in evs]):
assert_array_equal(ds.samples[i], origsamples[onset:onset + 4].ravel())
assert_array_equal(ds.sa.time_indices[i], np.arange(onset, onset + 4))
assert_array_equal(ds.sa.time_coords[i],
np.arange(onset, onset + 4) * 2.5)
for evattr in [
a for a in ds.sa
if a.count("event_attrs") and not a.count('event_attrs_event')
]:
assert_array_equal(evs[i]['_'.join(evattr.split('_')[2:])],
ds.sa[evattr].value[i])
# check offset: only the last one exactly matches the tr
assert_array_equal(ds.sa.orig_offset, [1, 1, 0])
# map back into voxel space, should ignore addtional features
nim = map2nifti(ds)
# origsamples has t,x,y,z
if externals.versions['nibabel'] >= '1.2':
vol_shape = nim.shape
else:
vol_shape = nim.get_shape()
assert_equal(vol_shape, origsamples.shape[1:] + (len(ds) * 4, ))
# check shape of a single sample
nim = map2nifti(ds, ds.samples[0])
if externals.versions['nibabel'] >= '1.2':
vol_shape = nim.shape
else:
vol_shape = nim.get_shape()
# pynifti image has [t,]z,y,x
assert_equal(vol_shape, (40, 20, 1, 4))
# and now with masking
ds = fmri_dataset(tssrc, mask=masrc)
ds = eventrelated_dataset(ds, evs, time_attr='time_coords')
nnonzero = len(_load_anyimg(masrc)[0].nonzero()[0])
assert_equal(nnonzero, 530)
# we ask for boxcars of 9s length, and the tr in the file header says 2.5s
# hence we should get round(9.0/2.4) * np.prod((1,20,40) == 3200 features
assert_equal(ds.nfeatures, 4 * 530)
assert_equal(len(ds), len(evs))
# and they have been broadcasted through all boxcars
assert_array_equal(ds.fa.voxel_indices[:nnonzero],
ds.fa.voxel_indices[nnonzero:2 * nnonzero])
def runsub(sub,
thisContrast,
thisContrastStr,
filterLen,
filterOrd,
paramEst,
chunklen,
alphas=np.logspace(0, 3, 20),
debug=False,
write=False,
roi='grayMatter'):
thisSub = {sub: subList[sub]}
mc_params = lmvpa.loadmotionparams(paths, thisSub)
beta_events = lmvpa.loadevents(paths, thisSub)
dsdict = lmvpa.loadsubdata(paths, thisSub, m=roi, c='trial_type')
thisDS = dsdict[sub]
# savitsky golay filtering
sg.sg_filter(thisDS, filterLen, filterOrd)
# gallant group zscores before regression.
# zscore w.r.t. rest trials
# zscore(thisDS, param_est=('targets', ['rest']), chunks_attr='chunks')
# zscore entire set. if done chunk-wise, there is no double-dipping (since we leave a chunk out at a time).
zscore(thisDS, chunks_attr='chunks')
# kay method: leave out a model run, use it to fit an HRF for each voxel
# huth method: essentially use FIR
# mumford method: deconvolution with canonical HRF
# refit events and regress...
# get timing data from timing files
# rds, events = lmvpa.amendtimings(thisDS.copy(), beta_events[sub])
rds, events = lmvpa.amendtimings(thisDS.copy(), beta_events[sub],
contrasts) # adding features
# we can model out motion and just not use those betas.
# Ridge
if isinstance(thisContrast, basestring):
thisContrast = [thisContrast]
# instead of binarizing each one, make them parametric
desX, rds = lmvpa.make_designmat(rds,
events,
time_attr='time_coords',
condition_attr=thisContrast,
design_kwargs={
'hrf_model': 'canonical',
'drift_model': 'blank'
},
regr_attrs=None)
# want to collapse ap and cr, but have anim separate
desX['motion'] = make_dmtx(rds.sa['time_coords'].value,
paradigm=None,
add_regs=mc_params[sub],
drift_model='blank')
des = lmvpa.make_parammat(desX, hrf='canonical', zscore=True)
# set chunklen and nchunks
# split by language and pictures
lidx = thisDS.chunks < thisDS.sa['chunks'].unique[len(
thisDS.sa['chunks'].unique) / 2]
pidx = thisDS.chunks >= thisDS.sa['chunks'].unique[len(
thisDS.sa['chunks'].unique) / 2]
ldes = cp.copy(des)
pdes = cp.copy(des)
ldes.matrix = ldes.matrix[lidx]
pdes.matrix = pdes.matrix[pidx]
nchunks = int(len(thisDS) * paramEst / chunklen)
nboots = 50
covarmat = None
mus = None
lwts, lalphas, lres, lceil = bsr.bootstrap_ridge(rds[lidx],
ldes,
chunklen=chunklen,
nchunks=nchunks,
cov0=covarmat,
mu0=mus,
part_attr='chunks',
mode='test',
alphas=alphas,
single_alpha=True,
normalpha=False,
nboots=nboots,
corrmin=.2,
singcutoff=1e-10,
joined=None,
plot=debug,
use_corr=True)
pwts, palphas, pres, pceil = bsr.bootstrap_ridge(rds[pidx],
pdes,
chunklen=chunklen,
nchunks=nchunks,
part_attr='chunks',
mode='test',
alphas=alphas,
single_alpha=True,
normalpha=False,
nboots=nboots,
corrmin=.2,
singcutoff=1e-10,
joined=None,
plot=debug,
use_corr=True)
print 'language ' + str(np.mean(lres))
# pictures within
print 'pictures: ' + str(np.mean(pres))
# need to change outstring
if write:
from mvpa2.base import dataset
map2nifti(thisDS, dataset.vstack([lres, pres])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_corrs.nii.gz'))
map2nifti(thisDS, dataset.vstack([lwts, pwts])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_weights.nii.gz'))
map2nifti(thisDS, dataset.vstack([lalphas, palphas])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_alphas.nii.gz'))
map2nifti(thisDS, dataset.vstack([lceil, pceil])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_ceiling.nii.gz'))
del lres, pres, lwts, pwts, lalphas, palphas, lceil, pceil
crossSet = thisDS.copy()
crossSet.chunks[lidx] = 1
crossSet.chunks[pidx] = 2
cwts, calphas, cres, cceil = bsr.bootstrap_ridge(crossSet,
des,
chunklen=chunklen,
nchunks=nchunks,
part_attr='chunks',
mode='test',
alphas=alphas,
single_alpha=True,
normalpha=False,
nboots=nboots,
corrmin=.2,
singcutoff=1e-10,
joined=None,
use_corr=True)
print 'cross: ' + str(np.mean(cres))
if write:
map2nifti(thisDS, cres[0]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' +
thisContrastStr + '_P2L_ridge_corr.nii.gz'))
map2nifti(thisDS, cres[1]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' +
thisContrastStr + '_L2P_ridge_corr.nii.gz'))
map2nifti(thisDS, cwts[0]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' +
thisContrastStr + '_P2L_ridge_weights.nii.gz'))
map2nifti(thisDS, cwts[1]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' +
thisContrastStr + '_L2P_ridge_weights.nii.gz'))
map2nifti(thisDS, calphas[calphas.chunks == 1]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' +
thisContrastStr + '_P2L_ridge_alphas.nii.gz'))
map2nifti(thisDS, calphas[calphas.chunks == 2]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' +
thisContrastStr + '_L2P_ridge_alphas.nii.gz'))
map2nifti(thisDS, cceil[0]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' +
thisContrastStr + '_P2L_ridge_ceiling.nii.gz'))
map2nifti(thisDS, cceil[1]).to_filename(
os.path.join(
paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' +
thisContrastStr + '_L2P_ridge_ceiling.nii.gz'))
del cres, cwts, calphas, cceil
def to_nifti(dumpy, ds, args):
from mvpa2.datasets.mri import map2nifti
# TODO allow overriding the nifti header
nimg = map2nifti(ds, dumpy)
nimg.to_filename(args.output)
'interactive':
cfg.getboolean('examples', 'interactive', True),
}
for radius in [3]:
# tell which one we are doing
print 'Running searchlight with radius: %i ...' % (radius)
sl = sphere_searchlight(foldwiseCvedAnovaSelectedSMLR,
radius=radius,
space='voxel_indices',
center_ids=center_ids,
postproc=mean_sample())
ds = dataset.copy(deep=False,
sa=['targets', 'chunks'],
fa=['voxel_indices'],
a=['mapper'])
sl_map = sl(ds)
sl_map.samples *= -1
sl_map.samples += 1
niftiresults = map2nifti(sl_map, imghdr=dataset.a.imghdr)
niftiresults.to_filename(
os.path.join(
sessionPath,
'analyze/functional/searchlight/{0}-grey-searchlight{1}-{2}.nii'.
format(classificationName, boldDelay, stimulusWidth)))
print 'Best performing sphere error:', np.min(sl_map.samples)
def pybetaseries(fsfdir,
methods=['lsall', 'lsone'],
time_res=0.1,
modeldir=None,
outdir=None,
designdir=None,
design_fsf_file='design.fsf',
design_mat_file='design.mat',
data_file=None,
mask_file=None,
extract_evs=None,
collapse_other_conditions=True):
"""Compute beta-series regression on a feat directory
Required arguments:
fsfdir: full path of a feat directory
Optional arguments:
method: list of methods to be used, can include:
'lsone': single-trial iterative least squares estimation from Turner & Ashby
'lsall': standard beta-series regression from Rissman et al.
time_res: time resolution of the model used to generate the convolved design matrix
outdir: where to store the results
designdir: location of design_mat_file (e.g. design.mat). if None -- the same as fsfdir
collapse_other_conditions: collapse all other conditions into a single regressor for
the lsone model. Jeanette's analyses suggest that it's better than leaving
them separate.
data_file: allows to override path of the 4D datafile instead of specified in design.fsf
'feat_files(1)'
"""
known_methods = ['lsall', 'lsone']
assert set(methods).issubset(set(known_methods)), \
"Unknown method(s): %s" % (set(methods).difference(set(known_methods)))
if not os.path.exists(fsfdir):
print 'ERROR: %s does not exist!' % fsfdir
#return
if not fsfdir.endswith('/'):
fsfdir = ''.join([fsfdir, '/'])
if modeldir is None:
modeldir = fsfdir
# load design using pymvpa tools
fsffile = pjoin(fsfdir, design_fsf_file)
desmatfile = pjoin(modeldir, design_mat_file)
verbose(1, "Loading design")
design = read_fsl_design(fsffile)
desmat = FslGLMDesign(desmatfile)
ntp, nevs = desmat.mat.shape
TR = design['fmri(tr)']
# yoh: theoretically it should be identical to the one read from
# the nifti file, but in this sample data those manage to differ:
# bold_mcf_brain.nii.gz int16 [ 64, 64, 30, 182] 3.12x3.12x5.00x1.00 sform
# filtered_func_data.nii.gz float32 [ 64, 64, 30, 182] 3.12x3.12x5.00x2.00 sform
#assert(abs(data.a.imghdr.get_zooms()[-1] - TR) < 0.001)
# it is the filtered_func_data.nii.gz which was used for analysis,
# and it differs from bold_mcf_brain.nii.gz ...
# exclude events that occur within two TRs of the end of the run, due to the
# inability to accurately estimate the response to them.
max_evtime = TR*ntp - 2;
# TODO: filter out here the trials jumping outside
good_evs = []
nuisance_evs = []
# yoh: ev_td marks temporal derivatives (of good EVs or of nuisance -- all)
# replacing with deriv_evs for consistency
withderiv_evs = []
# ev_td = N.zeros(design['fmri(evs_real)'])
good_ons = []
if outdir is None:
outdir = pjoin(fsfdir, 'betaseries')
if not os.path.exists(outdir):
os.mkdir(outdir)
# create smoothing kernel for design
cutoff = design['fmri(paradigm_hp)']/TR
verbose(1, "Creating smoothing kernel based on the original analysis cutoff %.2f"
% cutoff)
# yoh: Verify that the kernel is correct since it looks
# quite ...
F = get_smoothing_kernel(cutoff, ntp)
verbose(1, "Determining non-motion conditions")
# loop through and find the good (non-motion) conditions
# NB: this assumes that the name of the motion EV includes "motpar"
# ala the openfmri convention.
# TO DO: add ability to manually specify motion regressors (currently assumes
# that any EV that includes "motpar" in its name is a motion regressor)
evctr = 0
for ev in range(1, design['fmri(evs_orig)']+1):
# filter out motion parameters
evtitle = design['fmri(evtitle%d)' % ev]
verbose(2, "Loading EV %s" % evtitle)
if not evtitle.startswith('mot'):
good_evs.append(evctr)
evctr += 1
if design['fmri(deriv_yn%d)' % ev] == 1:
withderiv_evs.append(evctr-1)
# skip temporal derivative
evctr += 1
ev_events = FslEV3(pjoin(fsfdir, design['fmri(custom%d)' % ev]))
good_ons.append(ev_events)
else:
nuisance_evs.append(evctr)
evctr += 1
if design['fmri(deriv_yn%d)' % ev] == 1:
# skip temporal derivative
withderiv_evs.append(evctr)
nuisance_evs.append(evctr)
evctr += 1
# load data
verbose(1, "Loading data")
maskimg = pjoin(fsfdir, mask_file or 'mask.nii.gz')
# yoh: TODO design['feat_files'] is not the one "of interest" since it is
# the input file, while we would like to operate on pre-processed version
# which is usually stored as filtered_func_data.nii.gz
data_file_fullname = complete_filename(
pjoin(fsfdir, data_file or "filtered_func_data.nii.gz"))
data = fmri_dataset(data_file_fullname, mask=maskimg)
assert(len(data) == ntp)
for method in methods:
verbose(1, 'Estimating %(method)s model...' % locals())
if method == 'lsone':
all_conds, glm_res_full = extract_lsone(
data, TR, time_res,
spm_hrf, F,
good_ons,
good_evs, nuisance_evs, withderiv_evs,
desmat,
extract_evs=extract_evs,
collapse_other_conditions=collapse_other_conditions)
elif method == 'lsall':
all_conds, glm_res_full = extract_lsall(
data, TR, time_res,
spm_hrf, F,
good_ons,
good_evs,
desmat,
extract_evs=extract_evs,
)
else:
raise ValueError(method)
all_conds = N.asanyarray(all_conds) # assure array here
# map the data into images and save to betaseries directory
for e in range(1, len(good_evs)+1):
ni = map2nifti(data, data=glm_res_full[N.where(all_conds==e)[0], :])
ni.to_filename(pjoin(outdir, 'ev%d_%s.nii.gz' % (e, method)))
def to_nifti(dumpy, ds, args):
from mvpa2.datasets.mri import map2nifti
# TODO allow overriding the nifti header
nimg = map2nifti(ds, dumpy)
nimg.to_filename(args.output)
def runsub(sub, thisContrast, filterLen, filterOrd, thisContrastStr, roi='grayMatter'):
thisSub = {sub: subList[sub]}
mc_params = lmvpa.loadmotionparams(paths, thisSub)
beta_events = lmvpa.loadevents(paths, thisSub)
dsdict = lmvpa.loadsubdata(paths, thisSub, m=roi, c='trial_type')
thisDS = dsdict[sub]
# savitsky golay filtering
sg.sg_filter(thisDS, filterLen, filterOrd)
# gallant group zscores before regression.
# zscore w.r.t. rest trials
# zscore(thisDS, param_est=('targets', ['rest']), chunks_attr='chunks')
# zscore entire set. if done chunk-wise, there is no double-dipping (since we leave a chunk out at a time).
zscore(thisDS, chunks_attr='chunks')
# kay method: leave out a model run, use it to fit an HRF for each voxel
# huth method: essentially use FIR
# mumford method: deconvolution with canonical HRF
# refit events and regress...
# get timing data from timing files
rds, events = lmvpa.amendtimings(thisDS.copy(), beta_events[sub], contrasts) # adding features
# we can model out motion and just not use those betas.
if isinstance(thisContrast, basestring):
thisContrast = [thisContrast]
# instead of binarizing each one, make them parametric
desX, rds = lmvpa.make_designmat(rds, events, time_attr='time_coords', condition_attr=thisContrast,
design_kwargs={'hrf_model': 'canonical', 'drift_model': 'blank'},
regr_attrs=None)
# want to collapse ap and cr, but have anim separate
des = lmvpa.make_parammat(desX)
# set chunklen and nchunks
# split by language and pictures
lidx = thisDS.chunks < thisDS.sa['chunks'].unique[len(thisDS.sa['chunks'].unique) / 2]
pidx = thisDS.chunks >= thisDS.sa['chunks'].unique[len(thisDS.sa['chunks'].unique) / 2]
ldes = cp.copy(des)
pdes = cp.copy(des)
ldes.matrix = ldes.matrix[lidx]
pdes.matrix = pdes.matrix[pidx]
lwts, lres, lceil = bsr.bootstrap_linear(rds[lidx], ldes, part_attr='chunks', mode='test')
pwts, pres, pceil = bsr.bootstrap_linear(rds[pidx], pdes, part_attr='chunks', mode='test')
# now I have betas per chunk. could just correlate the betas, or correlate the predictions for corresponding runs
print 'language ' + str(np.mean(lres))
# pictures within
print 'pictures: ' + str(np.mean(pres))
from mvpa2.base import dataset
map2nifti(thisDS, dataset.vstack([lres, pres])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_univar_corr.nii.gz'))
map2nifti(thisDS, dataset.vstack([lwts, pwts])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_univar_betas.nii.gz'))
map2nifti(thisDS, dataset.vstack([lceil, pceil])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_univar_ceiling.nii.gz'))
del lres, pres, lwts, pwts, lceil, pceil
crossSet = thisDS.copy()
crossSet.chunks[lidx] = 1
crossSet.chunks[pidx] = 2
cwts, cres, cceil = bsr.bootstrap_linear(crossSet, des, part_attr='chunks', mode='test')
print 'cross: ' + str(np.mean(cres))
map2nifti(thisDS, cres[0]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_P2L_univar.nii.gz'))
map2nifti(thisDS, cres[1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_L2P_univar.nii.gz'))
map2nifti(thisDS, cwts[0]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_P2L_betas.nii.gz'))
map2nifti(thisDS, cwts[1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_L2P_betas.nii.gz'))
map2nifti(thisDS, cceil[0]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_P2L_betas.nii.gz'))
map2nifti(thisDS, cceil[1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_L2P_betas.nii.gz'))
def main():
'''
Spectral clustering...
'''
st = time.time()
tmpset = Dataset([])
# hfilename = "/nfs/j3/userhome/dangxiaobin/workingdir/cutROI/%s/fdt_matrix2_targets_sc.T.hdf5"%(id)
hfilename = 'fdt_matrix2.T.hdf5'
print hfilename
#load connectivity profile of seed mask voxels
conn = open_conn_mat(hfilename)
tmpset.a = conn.a
print conn.shape,conn.a
#remove some features
mask = create_mask(conn.samples,0.5,1)
# print mask,mask.shape
conn_m = mask_feature(conn.samples,mask)
# print conn_m
map = conn_m.T
print "map:"
print map.shape,map.max(),map.min()
voxel = np.array(conn.fa.values())
print voxel[0]
v = voxel[0]
spacedist = ds.cdist(v,v,'euclidean')
print spacedist
"""
similar_mat = create_similarity_mat(map,conn.fa,0.1,2)
X = np.array(similar_mat)
print "similarity matrix: shape:",X.shape
print X
"""
corr = np.corrcoef(map)
corr = np.abs(corr)
corr = 0.1*corr + 0.9/(spacedist+1)
print "Elaspsed time: ", time.time() - st
print corr.shape,corr
plt.imshow(corr,interpolation='nearest',cmap=cm.jet)
cb = plt.colorbar()
pl.xticks(())
pl.yticks(())
pl.show()
cnum = 3
near = 100
sc = SpectralClustering(cnum,'arpack',None,100,1,'precomputed',near,None,True)
#sc.fit(map)
sc.fit_predict(corr)
'''
cnum = 3
near = 100
sc = SpectralClustering(cnum,'arpack',None,100,1,'nearest_neighbors',near,None,True)
sc.fit(map)
# sc.fit_predict(X)
# param = sc.get_params(deep=True)
'''
tmpset.samples = sc.labels_+1
# print sc.affinity_matrix_
#print list(sc.labels_)
print "Elaspsed time: ", time.time() - st
print "Number of voxels: ", sc.labels_.size
print "Number of clusters: ", np.unique(sc.labels_).size
result = map2nifti(tmpset)
result.to_filename("fg_parcel_S0006.nii.gz")
print ".....The end........"
def runsub(sub, thisContrast, r, dstype='raw', roi='grayMatter', filterLen=49, filterOrd=3, write=False):
if dstype == 'raw':
outdir='PyMVPA'
print "working with raw data"
thisSub = {sub: subList[sub]}
dsdict = lmvpa.loadsubdata(paths, thisSub, m=roi)
thisDS = dsdict[sub]
mc_params = lmvpa.loadmotionparams(paths, thisSub)
beta_events = lmvpa.loadevents(paths, thisSub)
# savitsky golay filtering
sg.sg_filter(thisDS, filterLen, filterOrd)
# gallant group zscores before regression.
# zscore w.r.t. rest trials
# zscore(thisDS, param_est=('targets', ['rest']), chunks_attr='chunks')
# zscore entire set. if done chunk-wise, there is no double-dipping (since we leave a chunk out at a time).
zscore(thisDS, chunks_attr='chunks')
print "beta extraction"
## BETA EXTRACTION ##
rds, events = lmvpa.amendtimings(thisDS.copy(), beta_events[sub])
evds = er.fit_event_hrf_model(rds, events, time_attr='time_coords',
condition_attr=('trial_type', 'chunks'),
design_kwargs={'add_regs': mc_params[sub], 'hrf_model': 'canonical'},
return_model=True)
fds = lmvpa.replacetargets(evds, contrasts, thisContrast)
fds = fds[fds.targets != '0']
else:
outdir=os.path.join('LSS', dstype)
print "loading betas"
fds = lmvpa.loadsubbetas(paths, sub, btype=dstype, m=roi)
fds.sa['targets'] = fds.sa[thisContrast]
zscore(fds, chunks_attr='chunks')
fds = lmvpa.sortds(fds)
print "searchlights"
## initialize classifier
clf = svm.LinearNuSVMC()
cv = CrossValidation(clf, NFoldPartitioner())
from mvpa2.measures.searchlight import sphere_searchlight
cvSL = sphere_searchlight(cv, radius=r)
# now I have betas per chunk. could just correlate the betas, or correlate the predictions for corresponding runs
lidx = fds.chunks < fds.sa['chunks'].unique[len(fds.sa['chunks'].unique)/2]
pidx = fds.chunks >= fds.sa['chunks'].unique[len(fds.sa['chunks'].unique) / 2]
lres = sl.run_cv_sl(cvSL, fds[lidx].copy(deep=False))
pres = sl.run_cv_sl(cvSL, fds[pidx].copy(deep=False))
if write:
from mvpa2.base import dataset
map2nifti(fds, dataset.vstack([lres, pres])).\
to_filename(os.path.join(
paths[0], 'Maps', outdir,
sub + '_' + roi + '_' + thisContrast + '_cvsl.nii.gz'))
del lres, pres, cvSL
cvSL = sphere_searchlight(cv, radius=r)
crossSet = fds.copy()
crossSet.chunks[lidx] = 1
crossSet.chunks[pidx] = 2
cres = sl.run_cv_sl(cvSL, crossSet.copy(deep=False))
if write:
map2nifti(fds, cres[0]).to_filename(
os.path.join(paths[0], 'Maps', outdir,
sub + '_' + roi + '_' + (thisContrast) + '_P2L.nii.gz'))
map2nifti(fds, cres[1]).to_filename(
os.path.join(paths[0], 'Maps', outdir,
sub + '_' + roi + '_' + (thisContrast) + '_L2P.nii.gz'))
def runsub(sub, thisContrast, thisContrastStr,
filterLen, filterOrd,
paramEst, chunklen, alphas=np.logspace(0, 3, 20), debug=False, write=False, roi='grayMatter'):
thisSub = {sub: subList[sub]}
mc_params = lmvpa.loadmotionparams(paths, thisSub)
beta_events = lmvpa.loadevents(paths, thisSub)
dsdict = lmvpa.loadsubdata(paths, thisSub, m=roi, c='trial_type')
thisDS = dsdict[sub]
# savitsky golay filtering
sg.sg_filter(thisDS, filterLen, filterOrd)
# gallant group zscores before regression.
# zscore w.r.t. rest trials
# zscore(thisDS, param_est=('targets', ['rest']), chunks_attr='chunks')
# zscore entire set. if done chunk-wise, there is no double-dipping (since we leave a chunk out at a time).
zscore(thisDS, chunks_attr='chunks')
# kay method: leave out a model run, use it to fit an HRF for each voxel
# huth method: essentially use FIR
# mumford method: deconvolution with canonical HRF
# refit events and regress...
# get timing data from timing files
# rds, events = lmvpa.amendtimings(thisDS.copy(), beta_events[sub])
rds, events = lmvpa.amendtimings(thisDS.copy(), beta_events[sub], contrasts) # adding features
# we can model out motion and just not use those betas.
# Ridge
if isinstance(thisContrast, basestring):
thisContrast = [thisContrast]
# instead of binarizing each one, make them parametric
desX, rds = lmvpa.make_designmat(rds, events, time_attr='time_coords', condition_attr=thisContrast,
design_kwargs={'hrf_model': 'canonical', 'drift_model': 'blank'},
regr_attrs=None)
# want to collapse ap and cr, but have anim separate
desX['motion'] = make_dmtx(rds.sa['time_coords'].value, paradigm=None, add_regs=mc_params[sub], drift_model='blank')
des = lmvpa.make_parammat(desX, hrf='canonical', zscore=True)
# set chunklen and nchunks
# split by language and pictures
lidx = thisDS.chunks < thisDS.sa['chunks'].unique[len(thisDS.sa['chunks'].unique) / 2]
pidx = thisDS.chunks >= thisDS.sa['chunks'].unique[len(thisDS.sa['chunks'].unique) / 2]
ldes = cp.copy(des)
pdes = cp.copy(des)
ldes.matrix = ldes.matrix[lidx]
pdes.matrix = pdes.matrix[pidx]
nchunks = int(len(thisDS)*paramEst / chunklen)
nboots=50
covarmat = None
mus = None
lwts, lalphas, lres, lceil = bsr.bootstrap_ridge(rds[lidx], ldes, chunklen=chunklen, nchunks=nchunks,
cov0=covarmat, mu0=mus, part_attr='chunks', mode='test',
alphas=alphas, single_alpha=True, normalpha=False,
nboots=nboots, corrmin=.2, singcutoff=1e-10, joined=None,
plot=debug, use_corr=True)
pwts, palphas, pres, pceil = bsr.bootstrap_ridge(rds[pidx], pdes, chunklen=chunklen, nchunks=nchunks,
part_attr='chunks', mode='test',
alphas=alphas, single_alpha=True, normalpha=False,
nboots=nboots, corrmin=.2, singcutoff=1e-10, joined=None,
plot=debug, use_corr=True)
print 'language ' + str(np.mean(lres))
# pictures within
print 'pictures: ' + str(np.mean(pres))
# need to change outstring
if write:
from mvpa2.base import dataset
map2nifti(thisDS, dataset.vstack([lres, pres])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_corrs.nii.gz'))
map2nifti(thisDS, dataset.vstack([lwts, pwts])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_weights.nii.gz'))
map2nifti(thisDS, dataset.vstack([lalphas, palphas])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_alphas.nii.gz'))
map2nifti(thisDS, dataset.vstack([lceil, pceil])) \
.to_filename(os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr +
'_ridge_ceiling.nii.gz'))
del lres, pres, lwts, pwts, lalphas, palphas, lceil, pceil
crossSet = thisDS.copy()
crossSet.chunks[lidx] = 1
crossSet.chunks[pidx] = 2
cwts, calphas, cres, cceil = bsr.bootstrap_ridge(crossSet, des, chunklen=chunklen, nchunks=nchunks,
part_attr='chunks', mode='test',
alphas=alphas, single_alpha=True, normalpha=False,
nboots=nboots, corrmin=.2, singcutoff=1e-10, joined=None,
use_corr=True)
print 'cross: ' + str(np.mean(cres))
if write:
map2nifti(thisDS, cres[0]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_P2L_ridge_corr.nii.gz'))
map2nifti(thisDS, cres[1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_L2P_ridge_corr.nii.gz'))
map2nifti(thisDS, cwts[0]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_P2L_ridge_weights.nii.gz'))
map2nifti(thisDS, cwts[1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_L2P_ridge_weights.nii.gz'))
map2nifti(thisDS, calphas[calphas.chunks==1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_P2L_ridge_alphas.nii.gz'))
map2nifti(thisDS, calphas[calphas.chunks==2]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_L2P_ridge_alphas.nii.gz'))
map2nifti(thisDS, cceil[0]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_P2L_ridge_ceiling.nii.gz'))
map2nifti(thisDS, cceil[1]).to_filename(
os.path.join(paths[0], 'Maps', 'Encoding', sub + '_' + roi + '_' + thisContrastStr + '_L2P_ridge_ceiling.nii.gz'))
del cres, cwts, calphas, cceil
