def test_roi_to_brain(): s1 = create_sphere([15, 10, -8], radius=10) s2 = create_sphere([-15, 10, -8], radius=10) s3 = create_sphere([0, -15, -8], radius=10) masks = Brain_Data([s1, s2, s3]) d = [1, 2, 3] m = roi_to_brain(d, masks) assert np.all([np.any(m.data == x) for x in d]) d = pd.Series([1.1, 2.1, 3.1]) m = roi_to_brain(d, masks) assert np.all([np.any(m.data == x) for x in d]) d = np.array([1, 2, 3]) m = roi_to_brain(d, masks) assert np.all([np.any(m.data == x) for x in d]) d = pd.DataFrame([np.ones(10) * x for x in [1, 2, 3]]) m = roi_to_brain(d, masks) assert len(m) == d.shape[1] assert np.all([np.any(m[0].data == x) for x in d[0]]) d = np.array([np.ones(10) * x for x in [1, 2, 3]]) m = roi_to_brain(d, masks) assert len(m) == d.shape[1] assert np.all([np.any(m[0].data == x) for x in d[0]])
def test_create_sphere(): # Test values update to reflect the fact that standard Brain_Data mask has few voxels because ventricles are 0'd out a = create_sphere(radius=10, coordinates=[0, 0, 0]) assert np.sum(a.get_data()) >= 497 # 515 a = create_sphere(radius=[10, 5], coordinates=[[0, 0, 0], [15, 0, 25]]) assert np.sum(a.get_data()) >= 553 # 571 a = create_sphere(radius=10, coordinates=[[0, 0, 0], [15, 0, 25]]) assert np.sum(a.get_data()) >= 1013 # 1051
def test_groupby_aggregate(sim_brain_data): s1 = create_sphere([12, 10, -8], radius=10) s2 = create_sphere([22, -2, -22], radius=10) mask = Brain_Data([s1, s2]) d = sim_brain_data.groupby(mask) assert isinstance(d, Groupby) mn = sim_brain_data.aggregate(mask, "mean") assert isinstance(mn, Brain_Data) assert len(mn.shape()) == 1
def test_bootstrap(sim_brain_data): masked = sim_brain_data.apply_mask( create_sphere(radius=10, coordinates=[0, 0, 0])) n_samples = 3 b = masked.bootstrap("mean", n_samples=n_samples) assert isinstance(b["Z"], Brain_Data) b = masked.bootstrap("std", n_samples=n_samples) assert isinstance(b["Z"], Brain_Data) b = masked.bootstrap("predict", n_samples=n_samples, plot=False) assert isinstance(b["Z"], Brain_Data) b = masked.bootstrap( "predict", n_samples=n_samples, plot=False, cv_dict={ "type": "kfolds", "n_folds": 3 }, ) assert isinstance(b["Z"], Brain_Data) b = masked.bootstrap("predict", n_samples=n_samples, save_weights=True, plot=False) assert len(b["samples"]) == n_samples
def test_apply_mask(sim_brain_data): s1 = create_sphere([12, 10, -8], radius=10) assert isinstance(s1, nb.Nifti1Image) masked_dat = sim_brain_data.apply_mask(s1) assert masked_dat.shape()[1] == np.sum(s1.get_fdata() != 0) masked_dat = sim_brain_data.apply_mask(s1, resample_mask_to_brain=True) assert masked_dat.shape()[1] == np.sum(s1.get_fdata() != 0)
def test_check_brain_data(sim_brain_data): mask = Brain_Data(create_sphere([15, 10, -8], radius=10)) a = check_brain_data(sim_brain_data) assert isinstance(a, Brain_Data) b = check_brain_data(sim_brain_data, mask=mask) assert isinstance(b, Brain_Data) assert b.shape()[1] == np.sum(mask.data==1)
def test_groupby(tmpdir): # Simulate Brain Data sim = Simulator() r = 10 sigma = 1 y = [0, 1] n_reps = 3 output_dir = str(tmpdir) sim.create_data(y, sigma, reps=n_reps, output_dir=output_dir) s1 = create_sphere([12, 10, -8], radius=r) s2 = create_sphere([22, -2, -22], radius=r) mask = Brain_Data([s1, s2]) y = pd.read_csv(os.path.join(str(tmpdir.join('y.csv'))), header=None, index_col=None) data = Brain_Data(glob.glob(str(tmpdir.join('data.nii.gz'))), Y=y) data.X = pd.DataFrame( { 'Intercept': np.ones(len(data.Y)), 'X1': np.array(data.Y).flatten() }, index=None) dat = Groupby(data, mask) # Test length assert len(dat) == len(mask) # Test Index assert isinstance(dat[1], Brain_Data) # Test apply mn = dat.apply('mean') assert len(dat) == len(mn) # assert mn[0].mean() > mn[1].mean() #JC edit: it seems this check relies on chance from simulated data assert mn[1].shape() == np.sum(mask[1].data == 1) reg = dat.apply('regress') assert len(dat) == len(mn) # r = dict([(x,reg[x]['beta'][1]) for x in reg.iterkeys()]) # Test combine combine_mn = dat.combine(mn) assert len(combine_mn.shape()) == 1
def test_extract_roi(sim_brain_data): mask = create_sphere([12, 10, -8], radius=10) assert len(sim_brain_data.extract_roi(mask, metric="mean")) == shape_2d[0] assert len(sim_brain_data.extract_roi(mask, metric="median")) == shape_2d[0] n_components = 2 assert sim_brain_data.extract_roi( mask, metric="pca", n_components=n_components).shape == (n_components, shape_2d[0]) with pytest.raises(NotImplementedError): sim_brain_data.extract_roi(mask, metric="p") assert isinstance(sim_brain_data[0].extract_roi(mask, metric="mean"), (float, np.floating)) assert isinstance(sim_brain_data[0].extract_roi(mask, metric="median"), (float, np.floating)) with pytest.raises(ValueError): sim_brain_data[0].extract_roi(mask, metric="pca") with pytest.raises(NotImplementedError): sim_brain_data[0].extract_roi(mask, metric="p") s1 = create_sphere([15, 10, -8], radius=10) s2 = create_sphere([-15, 10, -8], radius=10) s3 = create_sphere([0, -15, -8], radius=10) masks = Brain_Data([s1, s2, s3]) mask = roi_to_brain([1, 2, 3], masks) assert len(sim_brain_data[0].extract_roi(mask, metric="mean")) == len(masks) assert len(sim_brain_data[0].extract_roi(mask, metric="median")) == len(masks) assert sim_brain_data.extract_roi(mask, metric="mean").shape == ( len(masks), shape_2d[0], ) assert sim_brain_data.extract_roi(mask, metric="median").shape == ( len(masks), shape_2d[0], ) assert len( sim_brain_data.extract_roi(mask, metric="pca", n_components=n_components)) == len(masks)
def test_find_spikes(): sim = Simulator() y = [0, 1] n_reps = 50 s1 = create_sphere([0, 0, 0], radius=3) d1 = sim.create_data(y, 1, reps=n_reps, output_dir=None).apply_mask(s1) spikes = find_spikes(d1) assert isinstance(spikes, pd.DataFrame) assert spikes.shape[0] == len(d1) spikes = find_spikes(d1.to_nifti()) assert isinstance(spikes, pd.DataFrame) assert spikes.shape[0] == len(d1)
def test_threshold(): s1 = create_sphere([12, 10, -8], radius=10) s2 = create_sphere([22, -2, -22], radius=10) mask = Brain_Data(s1) * 5 mask = mask + Brain_Data(s2) m1 = mask.threshold(upper=0.5) m2 = mask.threshold(upper=3) m3 = mask.threshold(upper="98%") m4 = Brain_Data(s1) * 5 + Brain_Data(s2) * -0.5 m4 = mask.threshold(upper=0.5, lower=-0.3) assert np.sum(m1.data > 0) > np.sum(m2.data > 0) assert np.sum(m1.data > 0) == np.sum(m3.data > 0) assert np.sum(m4.data[(m4.data > -0.3) & (m4.data < 0.5)]) == 0 assert np.sum(m4.data[(m4.data < -0.3) | (m4.data > 0.5)]) > 0 # Test Regions r = mask.regions(min_region_size=10) m1 = Brain_Data(s1) m2 = r.threshold(1, binarize=True) assert len(np.unique(r.to_nifti().get_fdata())) == 2 diff = m2 - m1 assert np.sum(diff.data) == 0
def test_bootstrap(sim_brain_data): masked = sim_brain_data.apply_mask(create_sphere(radius=10, coordinates=[0, 0, 0])) n_samples = 3 b = masked.bootstrap('mean', n_samples=n_samples) assert isinstance(b['Z'], Brain_Data) b = masked.bootstrap('std', n_samples=n_samples) assert isinstance(b['Z'], Brain_Data) b = masked.bootstrap('predict', n_samples=n_samples, plot=False) assert isinstance(b['Z'], Brain_Data) b = masked.bootstrap('predict', n_samples=n_samples, plot=False, cv_dict={'type': 'kfolds', 'n_folds': 3}) assert isinstance(b['Z'], Brain_Data) b = masked.bootstrap('predict', n_samples=n_samples, save_weights=True, plot=False) assert len(b['samples']) == n_samples
def test_hyperalignment(): sim = Simulator() y = [0, 1] n_reps = 10 s1 = create_sphere([0, 0, 0], radius=3) d1 = sim.create_data(y, 1, reps=n_reps, output_dir=None).apply_mask(s1) d2 = sim.create_data(y, 2, reps=n_reps, output_dir=None).apply_mask(s1) d3 = sim.create_data(y, 3, reps=n_reps, output_dir=None).apply_mask(s1) data = [d1, d2, d3] # Test deterministic brain_data out = align(data, method="deterministic_srm") bout = d1.align(out["common_model"], method="deterministic_srm") assert d1.shape() == bout["transformed"].shape assert d1.shape() == bout["common_model"].shape assert d1.shape()[1] == bout["transformation_matrix"].shape()[0] btransformed = np.dot(d1.data, bout["transformation_matrix"].data.T) np.testing.assert_almost_equal( 0, np.sum(bout["transformed"].data - btransformed)) # Test probabilistic brain_data bout = d1.align(out["common_model"], method="probabilistic_srm") assert d1.shape() == bout["transformed"].shape assert d1.shape() == bout["common_model"].shape assert d1.shape()[1] == bout["transformation_matrix"].shape()[0] btransformed = np.dot(d1.data, bout["transformation_matrix"].data.T) np.testing.assert_almost_equal( 0, np.sum(bout["transformed"].data - btransformed)) # Test procrustes brain_data out = align(data, method="procrustes") centered = data[0].data - np.mean(data[0].data, 0) transformed = (np.dot(centered / np.linalg.norm(centered), out["transformation_matrix"][0].data) * out["scale"][0]) bout = d1.align(out["common_model"], method="procrustes") assert d1.shape() == bout["transformed"].shape() assert d1.shape() == bout["common_model"].shape() assert d1.shape()[1] == bout["transformation_matrix"].shape()[0] centered = d1.data - np.mean(d1.data, 0) btransformed = (np.dot(centered / np.linalg.norm(centered), bout["transformation_matrix"].data) * bout["scale"]) np.testing.assert_almost_equal(0, np.sum(bout["transformed"].data - btransformed), decimal=5) np.testing.assert_almost_equal( 0, np.sum(out["transformed"][0].data - bout["transformed"].data)) # Test over time sim = Simulator() y = [0, 1] n_reps = 10 s1 = create_sphere([0, 0, 0], radius=5) d1 = sim.create_data(y, 1, reps=n_reps, output_dir=None).apply_mask(s1) d2 = sim.create_data(y, 2, reps=n_reps, output_dir=None).apply_mask(s1) d3 = sim.create_data(y, 3, reps=n_reps, output_dir=None).apply_mask(s1) data = [d1, d2, d3] out = align(data, method="deterministic_srm", axis=1) bout = d1.align(out["common_model"], method="deterministic_srm", axis=1) assert d1.shape() == bout["transformed"].shape assert d1.shape() == bout["common_model"].shape assert d1.shape()[0] == bout["transformation_matrix"].shape()[0] btransformed = np.dot(d1.data.T, bout["transformation_matrix"].data.T) np.testing.assert_almost_equal( 0, np.sum(bout["transformed"].data - btransformed.T)) out = align(data, method="probabilistic_srm", axis=1) bout = d1.align(out["common_model"], method="probabilistic_srm", axis=1) assert d1.shape() == bout["transformed"].shape assert d1.shape() == bout["common_model"].shape assert d1.shape()[0] == bout["transformation_matrix"].shape()[0] btransformed = np.dot(d1.data.T, bout["transformation_matrix"].data.T) np.testing.assert_almost_equal( 0, np.sum(bout["transformed"].data - btransformed.T)) out = align(data, method="procrustes", axis=1) bout = d1.align(out["common_model"], method="procrustes", axis=1) assert d1.shape() == bout["transformed"].shape() assert d1.shape() == bout["common_model"].shape() assert d1.shape()[0] == bout["transformation_matrix"].shape()[0] centered = d1.data.T - np.mean(d1.data.T, 0) btransformed = (np.dot(centered / np.linalg.norm(centered), bout["transformation_matrix"].data) * bout["scale"]) np.testing.assert_almost_equal(0, np.sum(bout["transformed"].data - btransformed.T), decimal=5) np.testing.assert_almost_equal( 0, np.sum(out["transformed"][0].data - bout["transformed"].data))
plt.legend(loc="best") return plt import nibabel as nib import glob for wrarun in list(glob.glob('D:/FaceData/func_img/wrarun*.nii')): func_img = nib.load(wrarun) from nilearn.image import index_img func_img = index_img(func_img, slice(10, 490, 8)) from nltools.mask import create_sphere mask_img = create_sphere([40, -62, -20], radius=5) # Transform dimensional form 4D to 2D from nilearn.input_data import NiftiMasker masker = NiftiMasker(mask_img=mask_img, standardize=True, memory_level=1) X = masker.fit_transform(func_img) import numpy as np for run in list(glob.glob('D:/FaceData/label/run*.txt')): behavioral = np.recfromcsv(run, delimiter='') y = behavioral['name'] condition_mask = np.logical_or(y == b'Male', y == b'Female')
import nibabel as nib anat_img = nib.load('D:/FaceData/wmT1.nii') from nltools.mask import create_sphere mask = create_sphere([42, -58, -17], radius=30) mask_data = anat_img.apply_mask(mask)
Returns: data: (list) of Brain_Data objects ''' dat = Brain_Data(mask).apply_mask(mask) new_data = np.zeros((dat.shape()[0], n_observations)) for i in np.where(dat.data == 1)[0]: if np.random.randint(0, high=10) < p: new_data[i, :] = y noise = np.random.randn(new_data.shape[0], n_observations) * sigma dat.data = (new_data + noise).T return dat mask = create_sphere([0, 45, 0], radius=8) data = [simulate_data(n_observations, y, p, sigma, mask) for x in range(n_sub)] plt.figure(figsize=(10, 3)) plt.plot(y) plt.title('Simulated Signal', fontsize=20) plt.xlabel('Time', fontsize=18) plt.ylabel('Signal', fontsize=18) plot_glass_brain(data[0].mean().to_nifti()) ######################################################################### # Hyperalign Data # --------------- # # We will now align voxels with the same signal across participants. We will # start using hyperalignment with the procrustes transform. The align function
draw_cross=False, title='threshold image with intensity' 'value', colorbar=False) from scipy import ndimage dil_mask = ndimage.binary_dilation(threshold_value_img) from nilearn.plotting import plot_roi, show plot_roi(anat_img, dil_mask, cut_coords=cut_coords, annotate=False, title='Dilated mask') from nltools.mask import create_sphere mask_second = create_sphere([30, -72, -6], radius=5) mask_combined = np.logical_and(threshold_value_img, mask_second) from nilearn.plotting import plot_roi, show plot_roi(anat_img, mask_combined, title='Intersect mask', display_mode='ortho', cmap='hot') show()
def sim_groupby(sim_brain_data): r = 10 s1 = create_sphere([12, 10, -8], radius=r) s2 = create_sphere([22, -2, -22], radius=r) mask = Brain_Data([s1, s2]) return Groupby(sim_brain_data, mask)
def roi_mask(x, y, z, label, size): mask = create_sphere([x, y, z], radius=size) # mask.to_filename("_".join([label, str(size), "mm.nii"])) return mask
import nitime.timeseries as ts import nitime.analysis as nta import nitime.viz as viz try: from nibabel import load except ImportError: raise ImportError( 'You need nibabel (http:/nipy.org/nibabel/) in order to run this example' ) data_path = test_dir_path = os.path.join('D:/FaceData/', 'func_img') func_img = os.path.join(data_path, 'wrarun1.nii') func_img = load(func_img) from nltools.mask import create_sphere mask_img = create_sphere([-58, -41, 4], radius=3) from nilearn.input_data import NiftiMasker masker = NiftiMasker(mask_img=mask_img, standardize=True, memory_level=1) func_img = masker.fit_transform(func_img) behavioral = np.recfromcsv('D:/FaceData/label/run1.txt', delimiter='') condition = behavioral['name'] onset = behavioral['onset'] import pandas as pd events = pd.DataFrame({'onset': onset, 'trial_type': condition}) # from nilearn.image import index_img # func_img=index_img(func_img, onset) # data=func_img.get_data() #------------------------------------------------------------------------
def test_align(): # Test hyperalignment matrix sim = Simulator() y = [0, 1] n_reps = 10 s1 = create_sphere([0, 0, 0], radius=3) d1 = sim.create_data(y, 1, reps=n_reps, output_dir=None).apply_mask(s1) d2 = sim.create_data(y, 2, reps=n_reps, output_dir=None).apply_mask(s1) d3 = sim.create_data(y, 3, reps=n_reps, output_dir=None).apply_mask(s1) data = [d1.data, d2.data, d3.data] out = align(data, method="deterministic_srm") assert len(data) == len(out["transformed"]) assert len(data) == len(out["transformation_matrix"]) assert data[0].shape == out["common_model"].shape transformed = np.dot(data[0], out["transformation_matrix"][0]) np.testing.assert_almost_equal(np.sum(out["transformed"][0] - transformed.T), 0, decimal=3) assert len(out["isc"]) == out["transformed"][0].shape[0] out = align(data, method="probabilistic_srm") assert len(data) == len(out["transformed"]) assert len(data) == len(out["transformation_matrix"]) assert data[0].shape == out["common_model"].shape transformed = np.dot(data[0], out["transformation_matrix"][0]) np.testing.assert_almost_equal(np.sum(out["transformed"][0] - transformed.T), 0, decimal=3) assert len(out["isc"]) == out["transformed"][0].shape[0] out2 = align(data, method="procrustes") assert len(data) == len(out2["transformed"]) assert data[0].shape == out2["common_model"].shape assert len(data) == len(out2["transformation_matrix"]) assert len(data) == len(out2["disparity"]) centered = data[0] - np.mean(data[0], 0) transformed = (np.dot(centered / np.linalg.norm(centered), out2["transformation_matrix"][0]) * out2["scale"][0]) np.testing.assert_almost_equal(np.sum(out2["transformed"][0] - transformed.T), 0, decimal=3) assert out2["transformed"][0].shape == out2["transformed"][0].shape assert (out2["transformation_matrix"][0].shape == out2["transformation_matrix"][0].shape) assert len(out2["isc"]) == out["transformed"][0].shape[0] # Test hyperalignment on Brain_Data data = [d1, d2, d3] out = align(data, method="deterministic_srm") assert len(data) == len(out["transformed"]) assert len(data) == len(out["transformation_matrix"]) assert data[0].shape() == out["common_model"].shape transformed = np.dot(d1.data, out["transformation_matrix"][0].data.T) np.testing.assert_almost_equal(np.sum(out["transformed"][0].data - transformed), 0, decimal=3) assert len(out["isc"]) == out["transformed"][0].shape[1] out = align(data, method="probabilistic_srm") assert len(data) == len(out["transformed"]) assert len(data) == len(out["transformation_matrix"]) assert data[0].shape() == out["common_model"].shape transformed = np.dot(d1.data, out["transformation_matrix"][0].data.T) np.testing.assert_almost_equal(np.sum(out["transformed"][0].data - transformed), 0, decimal=3) assert len(out["isc"]) == out["transformed"][0].shape[1] out2 = align(data, method="procrustes") assert len(data) == len(out2["transformed"]) assert data[0].shape() == out2["common_model"].shape() assert len(data) == len(out2["transformation_matrix"]) assert len(data) == len(out2["disparity"]) centered = data[0].data - np.mean(data[0].data, 0) transformed = (np.dot(centered / np.linalg.norm(centered), out2["transformation_matrix"][0].data) * out2["scale"][0]) np.testing.assert_almost_equal(np.sum(out2["transformed"][0].data - transformed), 0, decimal=3) assert out2["transformed"][0].shape() == out2["transformed"][0].shape() assert (out2["transformation_matrix"][0].shape == out2["transformation_matrix"][0].shape) assert len(out2["isc"]) == out2["transformed"][0].shape()[1] # Test hyperalignment on matrix over time (axis=1) sim = Simulator() y = [0, 1] n_reps = 10 s1 = create_sphere([0, 0, 0], radius=5) d1 = sim.create_data(y, 1, reps=n_reps, output_dir=None).apply_mask(s1) d2 = sim.create_data(y, 2, reps=n_reps, output_dir=None).apply_mask(s1) d3 = sim.create_data(y, 3, reps=n_reps, output_dir=None).apply_mask(s1) data = [d1.data, d2.data, d3.data] out = align(data, method="deterministic_srm", axis=1) assert len(data) == len(out["transformed"]) assert len(data) == len(out["transformation_matrix"]) assert data[0].shape == out["common_model"].shape transformed = np.dot(data[0].T, out["transformation_matrix"][0].data) np.testing.assert_almost_equal(np.sum(out["transformed"][0] - transformed), 0, decimal=3) assert len(out["isc"]) == out["transformed"][0].shape[1] out = align(data, method="probabilistic_srm", axis=1) assert len(data) == len(out["transformed"]) assert len(data) == len(out["transformation_matrix"]) assert data[0].shape == out["common_model"].shape transformed = np.dot(data[0].T, out["transformation_matrix"][0]) np.testing.assert_almost_equal(np.sum(out["transformed"][0] - transformed), 0, decimal=3) assert len(out["isc"]) == out["transformed"][0].shape[1] out2 = align(data, method="procrustes", axis=1) assert len(data) == len(out2["transformed"]) assert data[0].shape == out2["common_model"].shape assert len(data) == len(out2["transformation_matrix"]) assert len(data) == len(out2["disparity"]) centered = data[0] - np.mean(data[0], 0) transformed = (np.dot( (centered / np.linalg.norm(centered)).T, out2["transformation_matrix"][0].data, ) * out2["scale"][0]) np.testing.assert_almost_equal(np.sum(out2["transformed"][0] - transformed), 0, decimal=3) assert out2["transformed"][0].shape == out2["transformed"][0].shape assert (out2["transformation_matrix"][0].shape == out2["transformation_matrix"][0].shape) assert len(out2["isc"]) == out2["transformed"][0].shape[0] # Test hyperalignment on Brain_Data over time (axis=1) data = [d1, d2, d3] out = align(data, method="deterministic_srm", axis=1) assert len(data) == len(out["transformed"]) assert len(data) == len(out["transformation_matrix"]) assert data[0].shape() == out["common_model"].shape transformed = np.dot(d1.data.T, out["transformation_matrix"][0].data).T np.testing.assert_almost_equal(np.sum(out["transformed"][0].data - transformed), 0, decimal=5) assert len(out["isc"]) == out["transformed"][0].shape[0] out = align(data, method="probabilistic_srm", axis=1) assert len(data) == len(out["transformed"]) assert len(data) == len(out["transformation_matrix"]) assert data[0].shape() == out["common_model"].shape transformed = np.dot(d1.data.T, out["transformation_matrix"][0].data).T np.testing.assert_almost_equal(np.sum(out["transformed"][0].data - transformed), 0, decimal=5) assert len(out["isc"]) == out["transformed"][0].shape[0] out2 = align(data, method="procrustes", axis=1) assert len(data) == len(out2["transformed"]) assert data[0].shape() == out2["common_model"].shape() assert len(data) == len(out2["transformation_matrix"]) assert len(data) == len(out2["disparity"]) centered = data[0].data.T - np.mean(data[0].data.T, 0) transformed = (np.dot(centered / np.linalg.norm(centered), out2["transformation_matrix"][0].data) * out2["scale"][0]).T np.testing.assert_almost_equal(np.sum(out2["transformed"][0].data - transformed), 0, decimal=5) assert out2["transformed"][0].shape() == out2["transformed"][0].shape() assert (out2["transformation_matrix"][0].shape == out2["transformation_matrix"][0].shape) assert len(out2["isc"]) == out2["transformed"][0].shape()[1]
'model_200topics_2015Filtered2_10000iters.pklz') model = Model.load(model_file) model.display_model_summary() # Create mask image mask_data = (model.dataset.mask_img.get_data() != 0).astype(int) affine = model.dataset.mask_img.affine mask = nib.Nifti1Image(mask_data, affine) ############################################################################### # Temporoparietal seed # -------------------------------------- coords = [[-52, -56, 18]] radii = [6] * len(coords) roi_img = create_sphere(coords, radius=radii, mask=mask) fig = plotting.plot_roi(roi_img, display_mode='ortho', cut_coords=[-52, -56, 18], draw_cross=False) df, _ = decode_roi(model, roi_img) df = df.sort_values(by='Weight', ascending=False) print(df.head(10)) ############################################################################### # Temporoparietal, medial parietal, and dorsomedial prefrontal seeds # ------------------------------------------------------------------ coords = [[-56, -52, 18], [0, -58, 38], [4, 54, 26]] radii = [6] * len(coords)
def test_brain_data(tmpdir): sim = Simulator() r = 10 sigma = 1 y = [0, 1] n_reps = 3 output_dir = str(tmpdir) sim.create_data(y, sigma, reps=n_reps, output_dir=output_dir) shape_3d = (91, 109, 91) shape_2d = (6, 238955) y=pd.read_csv(os.path.join(str(tmpdir.join('y.csv'))), header=None,index_col=None).T holdout=pd.read_csv(os.path.join(str(tmpdir.join('rep_id.csv'))),header=None,index_col=None).T flist = glob.glob(str(tmpdir.join('centered*.nii.gz'))) # Test load list dat = Brain_Data(data=flist,Y=y) # Test load file assert Brain_Data(flist[0]) # Test to_nifti d = dat.to_nifti() assert d.shape[0:3] == shape_3d # Test load nibabel assert Brain_Data(d) # Test shape assert dat.shape() == shape_2d # Test Mean assert dat.mean().shape()[0] == shape_2d[1] # Test Std assert dat.std().shape()[0] == shape_2d[1] # Test add new = dat + dat assert new.shape() == shape_2d # Test subtract new = dat - dat assert new.shape() == shape_2d # Test multiply new = dat * dat assert new.shape() == shape_2d # Test Iterator x = [x for x in dat] assert len(x) == len(dat) assert len(x[0].data.shape) == 1 # # Test T-test out = dat.ttest() assert out['t'].shape()[0] == shape_2d[1] # # # Test T-test - permutation method # out = dat.ttest(threshold_dict={'permutation':'tfce','n_permutations':50,'n_jobs':1}) # assert out['t'].shape()[0]==shape_2d[1] # Test Regress dat.X = pd.DataFrame({'Intercept':np.ones(len(dat.Y)), 'X1':np.array(dat.Y).flatten()},index=None) out = dat.regress() assert out['beta'].shape() == (2,shape_2d[1]) # Test indexing assert out['t'][1].shape()[0] == shape_2d[1] # Test threshold i=1 tt = threshold(out['t'][i], out['p'][i], .05) assert isinstance(tt,Brain_Data) # Test write dat.write(os.path.join(str(tmpdir.join('test_write.nii')))) assert Brain_Data(os.path.join(str(tmpdir.join('test_write.nii')))) # Test append assert dat.append(dat).shape()[0]==shape_2d[0]*2 # Test distance distance = dat.distance(method='euclidean') assert isinstance(distance,Adjacency) assert distance.square_shape()[0]==shape_2d[0] # Test predict stats = dat.predict(algorithm='svm', cv_dict={'type': 'kfolds','n_folds': 2}, plot=False,**{'kernel':"linear"}) # Support Vector Regression, with 5 fold cross-validation with Platt Scaling # This will output probabilities of each class stats = dat.predict(algorithm='svm', cv_dict=None, plot=False,**{'kernel':'linear', 'probability':True}) assert isinstance(stats['weight_map'],Brain_Data) # Logistic classificiation, with 2 fold cross-validation. stats = dat.predict(algorithm='logistic', cv_dict={'type': 'kfolds', 'n_folds': 2}, plot=False) assert isinstance(stats['weight_map'],Brain_Data) # Ridge classificiation, stats = dat.predict(algorithm='ridgeClassifier', cv_dict=None,plot=False) assert isinstance(stats['weight_map'],Brain_Data) # Ridge stats = dat.predict(algorithm='ridge', cv_dict={'type': 'kfolds', 'n_folds': 2,'subject_id':holdout}, plot=False,**{'alpha':.1}) # Lasso stats = dat.predict(algorithm='lasso', cv_dict={'type': 'kfolds', 'n_folds': 2,'stratified':dat.Y}, plot=False,**{'alpha':.1}) # PCR stats = dat.predict(algorithm='pcr', cv_dict=None, plot=False) # Test Similarity r = dat.similarity(stats['weight_map']) assert len(r) == shape_2d[0] r2 = dat.similarity(stats['weight_map'].to_nifti()) assert len(r2) == shape_2d[0] # Test apply_mask - might move part of this to test mask suite s1 = create_sphere([12, 10, -8], radius=10) assert isinstance(s1, nb.Nifti1Image) s2 = Brain_Data(s1) masked_dat = dat.apply_mask(s1) assert masked_dat.shape()[1] == np.sum(s2.data != 0) # Test extract_roi mask = create_sphere([12, 10, -8], radius=10) assert len(dat.extract_roi(mask)) == shape_2d[0] # Test r_to_z z = dat.r_to_z() assert z.shape() == dat.shape() # Test copy d_copy = dat.copy() assert d_copy.shape() == dat.shape() # Test detrend detrend = dat.detrend() assert detrend.shape() == dat.shape() # Test standardize s = dat.standardize() assert s.shape() == dat.shape() assert np.isclose(np.sum(s.mean().data), 0, atol=.1) s = dat.standardize(method='zscore') assert s.shape() == dat.shape() assert np.isclose(np.sum(s.mean().data), 0, atol=.1) # Test Sum s = dat.sum() assert s.shape() == dat[1].shape() # Test Groupby s1 = create_sphere([12, 10, -8], radius=10) s2 = create_sphere([22, -2, -22], radius=10) mask = Brain_Data([s1, s2]) d = dat.groupby(mask) assert isinstance(d, Groupby) # Test Aggregate mn = dat.aggregate(mask, 'mean') assert isinstance(mn, Brain_Data) assert len(mn.shape()) == 1 # Test Threshold s1 = create_sphere([12, 10, -8], radius=10) s2 = create_sphere([22, -2, -22], radius=10) mask = Brain_Data(s1)*5 mask = mask + Brain_Data(s2) m1 = mask.threshold(thresh=.5) m2 = mask.threshold(thresh=3) m3 = mask.threshold(thresh='98%') assert np.sum(m1.data > 0) > np.sum(m2.data > 0) assert np.sum(m1.data > 0) == np.sum(m3.data > 0) # Test Regions r = mask.regions(min_region_size=10) m1 = Brain_Data(s1) m2 = r.threshold(1, binarize=True) # assert len(r)==2 assert len(np.unique(r.to_nifti().get_data())) == 2 # JC edit: I think this is what you were trying to do diff = m2-m1 assert np.sum(diff.data) == 0
def test_align(): # Test hyperalignment matrix sim = Simulator() y = [0, 1] n_reps = 10 s1 = create_sphere([0, 0, 0], radius=3) d1 = sim.create_data(y, 1, reps=n_reps, output_dir=None).apply_mask(s1) d2 = sim.create_data(y, 2, reps=n_reps, output_dir=None).apply_mask(s1) d3 = sim.create_data(y, 3, reps=n_reps, output_dir=None).apply_mask(s1) data = [d1.data.T, d2.data.T, d3.data.T] out = align(data, method='deterministic_srm') assert len(data) == len(out['transformed']) assert len(data) == len(out['transformation_matrix']) assert data[0].shape == out['common_model'].shape transformed = np.dot(data[0].T, out['transformation_matrix'][0]) np.testing.assert_almost_equal( 0, np.sum(out['transformed'][0] - transformed.T)) out = align(data, method='probabilistic_srm') assert len(data) == len(out['transformed']) assert len(data) == len(out['transformation_matrix']) assert data[0].shape == out['common_model'].shape transformed = np.dot(data[0].T, out['transformation_matrix'][0]) np.testing.assert_almost_equal( 0, np.sum(out['transformed'][0] - transformed.T)) out2 = align(data, method='procrustes') assert len(data) == len(out2['transformed']) assert data[0].shape == out2['common_model'].shape assert len(data) == len(out2['transformation_matrix']) assert len(data) == len(out2['disparity']) centered = data[0].T - np.mean(data[0].T, 0) transformed = (np.dot(centered / np.linalg.norm(centered), out2['transformation_matrix'][0]) * out2['scale'][0]) np.testing.assert_almost_equal( 0, np.sum(out2['transformed'][0] - transformed.T)) assert out['transformed'][0].shape == out2['transformed'][0].shape assert out['transformation_matrix'][0].shape == out2[ 'transformation_matrix'][0].shape # Test hyperalignment on Brain_Data data = [d1, d2, d3] out = align(data, method='deterministic_srm') assert len(data) == len(out['transformed']) assert len(data) == len(out['transformation_matrix']) assert data[0].shape() == out['common_model'].shape() transformed = np.dot(d1.data, out['transformation_matrix'][0]) np.testing.assert_almost_equal( 0, np.sum(out['transformed'][0].data - transformed)) out = align(data, method='probabilistic_srm') assert len(data) == len(out['transformed']) assert len(data) == len(out['transformation_matrix']) assert data[0].shape() == out['common_model'].shape() transformed = np.dot(d1.data, out['transformation_matrix'][0]) np.testing.assert_almost_equal( 0, np.sum(out['transformed'][0].data - transformed)) out2 = align(data, method='procrustes') assert len(data) == len(out2['transformed']) assert data[0].shape() == out2['common_model'].shape() assert len(data) == len(out2['transformation_matrix']) assert len(data) == len(out2['disparity']) centered = data[0].data - np.mean(data[0].data, 0) transformed = (np.dot(centered / np.linalg.norm(centered), out2['transformation_matrix'][0]) * out2['scale'][0]) np.testing.assert_almost_equal( 0, np.sum(out2['transformed'][0].data - transformed)) assert out['transformed'][0].shape() == out2['transformed'][0].shape() assert out['transformation_matrix'][0].shape == out2[ 'transformation_matrix'][0].shape # Test hyperalignment on matrix over time (axis=1) sim = Simulator() y = [0, 1] n_reps = 10 s1 = create_sphere([0, 0, 0], radius=5) d1 = sim.create_data(y, 1, reps=n_reps, output_dir=None).apply_mask(s1) d2 = sim.create_data(y, 2, reps=n_reps, output_dir=None).apply_mask(s1) d3 = sim.create_data(y, 3, reps=n_reps, output_dir=None).apply_mask(s1) data = [d1.data.T, d2.data.T, d3.data.T] out = align(data, method='deterministic_srm', axis=1) assert len(data) == len(out['transformed']) assert len(data) == len(out['transformation_matrix']) assert data[0].shape == out['common_model'].shape transformed = np.dot(data[0], out['transformation_matrix'][0]) np.testing.assert_almost_equal(0, np.sum(out['transformed'][0] - transformed)) out = align(data, method='probabilistic_srm', axis=1) assert len(data) == len(out['transformed']) assert len(data) == len(out['transformation_matrix']) assert data[0].shape == out['common_model'].shape transformed = np.dot(data[0], out['transformation_matrix'][0]) np.testing.assert_almost_equal(0, np.sum(out['transformed'][0] - transformed)) out2 = align(data, method='procrustes', axis=1) assert len(data) == len(out2['transformed']) assert data[0].shape == out2['common_model'].shape assert len(data) == len(out2['transformation_matrix']) assert len(data) == len(out2['disparity']) centered = data[0] - np.mean(data[0], 0) transformed = (np.dot(centered / np.linalg.norm(centered), out2['transformation_matrix'][0]) * out2['scale'][0]) np.testing.assert_almost_equal( 0, np.sum(out2['transformed'][0] - transformed)) assert out['transformed'][0].shape == out2['transformed'][0].shape assert out['transformation_matrix'][0].shape == out2[ 'transformation_matrix'][0].shape # Test hyperalignment on Brain_Data over time (axis=1) data = [d1, d2, d3] out = align(data, method='deterministic_srm', axis=1) assert len(data) == len(out['transformed']) assert len(data) == len(out['transformation_matrix']) assert data[0].shape() == out['common_model'].shape() transformed = np.dot(d1.data.T, out['transformation_matrix'][0]) np.testing.assert_almost_equal( 0, np.sum(out['transformed'][0].data - transformed.T)) out = align(data, method='probabilistic_srm', axis=1) assert len(data) == len(out['transformed']) assert len(data) == len(out['transformation_matrix']) assert data[0].shape() == out['common_model'].shape() transformed = np.dot(d1.data.T, out['transformation_matrix'][0]) np.testing.assert_almost_equal( 0, np.sum(out['transformed'][0].data - transformed.T)) out2 = align(data, method='procrustes', axis=1) assert len(data) == len(out2['transformed']) assert data[0].shape() == out2['common_model'].shape() assert len(data) == len(out2['transformation_matrix']) assert len(data) == len(out2['disparity']) centered = data[0].data.T - np.mean(data[0].data.T, 0) transformed = (np.dot(centered / np.linalg.norm(centered), out2['transformation_matrix'][0]) * out2['scale'][0]) np.testing.assert_almost_equal( 0, np.sum(out2['transformed'][0].data - transformed.T)) assert out['transformed'][0].shape() == out2['transformed'][0].shape() assert out['transformation_matrix'][0].shape == out2[ 'transformation_matrix'][0].shape
# First, let's load the pain data for this example. from nltools.datasets import fetch_pain data = fetch_pain() ######################################################################### # Apply_Mask # ---------- # # Spherical masks can be created using the create_sphere function. # It requires specifying a center voxel and the radius of the sphere. from nltools.mask import create_sphere mask = create_sphere([0, 0, 0], radius=30) masked_data = data.apply_mask(mask) masked_data.mean().plot() ######################################################################### # Extract Mean Within ROI # ----------------------- # # We can easily calculate the mean within an ROI for each image within a # Brain_Data() instance using the extract_roi() method. import matplotlib.pyplot as plt mean = data.extract_roi(mask) plt.plot(mean)
def test_brain_data(tmpdir): # Add 3mm to list to test that resolution as well for resolution in ['2mm']: MNI_Template["resolution"] = resolution sim = Simulator() r = 10 sigma = 1 y = [0, 1] n_reps = 3 output_dir = str(tmpdir) dat = sim.create_data(y, sigma, reps=n_reps, output_dir=output_dir) if MNI_Template["resolution"] == '2mm': shape_3d = (91, 109, 91) shape_2d = (6, 238955) elif MNI_Template["resolution"] == '3mm': shape_3d = (60, 72, 60) shape_2d = (6, 71020) y = pd.read_csv(os.path.join(str(tmpdir.join('y.csv'))),header=None, index_col=None) holdout = pd.read_csv(os.path.join(str(tmpdir.join('rep_id.csv'))),header=None,index_col=None) # Test load list of 4D images file_list = [str(tmpdir.join('data.nii.gz')), str(tmpdir.join('data.nii.gz'))] dat = Brain_Data(file_list) dat = Brain_Data([nb.load(x) for x in file_list]) # Test load list dat = Brain_Data(data=str(tmpdir.join('data.nii.gz')), Y=y) # Test concatenate out = Brain_Data([x for x in dat]) assert isinstance(out, Brain_Data) assert len(out)==len(dat) # Test to_nifti d = dat.to_nifti() assert d.shape[0:3] == shape_3d # Test load nibabel assert Brain_Data(d) # Test shape assert dat.shape() == shape_2d # Test Mean assert dat.mean().shape()[0] == shape_2d[1] # Test Std assert dat.std().shape()[0] == shape_2d[1] # Test add new = dat + dat assert new.shape() == shape_2d # Test subtract new = dat - dat assert new.shape() == shape_2d # Test multiply new = dat * dat assert new.shape() == shape_2d # Test Indexing index = [0, 3, 1] assert len(dat[index]) == len(index) index = range(4) assert len(dat[index]) == len(index) index = dat.Y == 1 assert len(dat[index.values.flatten()]) == index.values.sum() assert len(dat[index]) == index.values.sum() assert len(dat[:3]) == 3 # Test Iterator x = [x for x in dat] assert len(x) == len(dat) assert len(x[0].data.shape) == 1 # # Test T-test out = dat.ttest() assert out['t'].shape()[0] == shape_2d[1] # # # Test T-test - permutation method # out = dat.ttest(threshold_dict={'permutation':'tfce','n_permutations':50,'n_jobs':1}) # assert out['t'].shape()[0]==shape_2d[1] # Test Regress dat.X = pd.DataFrame({'Intercept':np.ones(len(dat.Y)), 'X1':np.array(dat.Y).flatten()}, index=None) # Standard OLS out = dat.regress() assert type(out['beta'].data) == np.ndarray assert type(out['t'].data) == np.ndarray assert type(out['p'].data) == np.ndarray assert type(out['residual'].data) == np.ndarray assert type(out['df'].data) == np.ndarray assert out['beta'].shape() == (2, shape_2d[1]) assert out['t'][1].shape()[0] == shape_2d[1] # Robust OLS out = dat.regress(mode='robust') assert type(out['beta'].data) == np.ndarray assert type(out['t'].data) == np.ndarray assert type(out['p'].data) == np.ndarray assert type(out['residual'].data) == np.ndarray assert type(out['df'].data) == np.ndarray assert out['beta'].shape() == (2, shape_2d[1]) assert out['t'][1].shape()[0] == shape_2d[1] # Test threshold i=1 tt = threshold(out['t'][i], out['p'][i], .05) assert isinstance(tt, Brain_Data) # Test write dat.write(os.path.join(str(tmpdir.join('test_write.nii')))) assert Brain_Data(os.path.join(str(tmpdir.join('test_write.nii')))) # Test append assert dat.append(dat).shape()[0] == shape_2d[0]*2 # Test distance distance = dat.distance(method='euclidean') assert isinstance(distance, Adjacency) assert distance.square_shape()[0] == shape_2d[0] # Test predict stats = dat.predict(algorithm='svm', cv_dict={'type': 'kfolds', 'n_folds': 2}, plot=False, **{'kernel':"linear"}) # Support Vector Regression, with 5 fold cross-validation with Platt Scaling # This will output probabilities of each class stats = dat.predict(algorithm='svm', cv_dict=None, plot=False, **{'kernel':'linear', 'probability':True}) assert isinstance(stats['weight_map'], Brain_Data) # Logistic classificiation, with 2 fold cross-validation. stats = dat.predict(algorithm='logistic', cv_dict={'type': 'kfolds', 'n_folds': 2}, plot=False) assert isinstance(stats['weight_map'], Brain_Data) # Ridge classificiation, stats = dat.predict(algorithm='ridgeClassifier', cv_dict=None, plot=False) assert isinstance(stats['weight_map'], Brain_Data) # Ridge stats = dat.predict(algorithm='ridge', cv_dict={'type': 'kfolds', 'n_folds': 2, 'subject_id':holdout}, plot=False, **{'alpha':.1}) # Lasso stats = dat.predict(algorithm='lasso', cv_dict={'type': 'kfolds', 'n_folds': 2, 'stratified':dat.Y}, plot=False, **{'alpha':.1}) # PCR stats = dat.predict(algorithm='pcr', cv_dict=None, plot=False) # Test Similarity r = dat.similarity(stats['weight_map']) assert len(r) == shape_2d[0] r2 = dat.similarity(stats['weight_map'].to_nifti()) assert len(r2) == shape_2d[0] r = dat.similarity(stats['weight_map'], method='dot_product') assert len(r) == shape_2d[0] r = dat.similarity(stats['weight_map'], method='cosine') assert len(r) == shape_2d[0] r = dat.similarity(dat, method='correlation') assert r.shape == (dat.shape()[0],dat.shape()[0]) r = dat.similarity(dat, method='dot_product') assert r.shape == (dat.shape()[0],dat.shape()[0]) r = dat.similarity(dat, method='cosine') assert r.shape == (dat.shape()[0],dat.shape()[0]) # Test apply_mask - might move part of this to test mask suite s1 = create_sphere([12, 10, -8], radius=10) assert isinstance(s1, nb.Nifti1Image) masked_dat = dat.apply_mask(s1) assert masked_dat.shape()[1] == np.sum(s1.get_data() != 0) # Test extract_roi mask = create_sphere([12, 10, -8], radius=10) assert len(dat.extract_roi(mask)) == shape_2d[0] # Test r_to_z z = dat.r_to_z() assert z.shape() == dat.shape() # Test copy d_copy = dat.copy() assert d_copy.shape() == dat.shape() # Test detrend detrend = dat.detrend() assert detrend.shape() == dat.shape() # Test standardize s = dat.standardize() assert s.shape() == dat.shape() assert np.isclose(np.sum(s.mean().data), 0, atol=.1) s = dat.standardize(method='zscore') assert s.shape() == dat.shape() assert np.isclose(np.sum(s.mean().data), 0, atol=.1) # Test Sum s = dat.sum() assert s.shape() == dat[1].shape() # Test Groupby s1 = create_sphere([12, 10, -8], radius=10) s2 = create_sphere([22, -2, -22], radius=10) mask = Brain_Data([s1, s2]) d = dat.groupby(mask) assert isinstance(d, Groupby) # Test Aggregate mn = dat.aggregate(mask, 'mean') assert isinstance(mn, Brain_Data) assert len(mn.shape()) == 1 # Test Threshold s1 = create_sphere([12, 10, -8], radius=10) s2 = create_sphere([22, -2, -22], radius=10) mask = Brain_Data(s1)*5 mask = mask + Brain_Data(s2) m1 = mask.threshold(upper=.5) m2 = mask.threshold(upper=3) m3 = mask.threshold(upper='98%') m4 = Brain_Data(s1)*5 + Brain_Data(s2)*-.5 m4 = mask.threshold(upper=.5,lower=-.3) assert np.sum(m1.data > 0) > np.sum(m2.data > 0) assert np.sum(m1.data > 0) == np.sum(m3.data > 0) assert np.sum(m4.data[(m4.data > -.3) & (m4.data <.5)]) == 0 assert np.sum(m4.data[(m4.data < -.3) | (m4.data >.5)]) > 0 # Test Regions r = mask.regions(min_region_size=10) m1 = Brain_Data(s1) m2 = r.threshold(1, binarize=True) # assert len(r)==2 assert len(np.unique(r.to_nifti().get_data())) == 2 diff = m2-m1 assert np.sum(diff.data) == 0 # Test Bootstrap masked = dat.apply_mask(create_sphere(radius=10, coordinates=[0, 0, 0])) n_samples = 3 b = masked.bootstrap('mean', n_samples=n_samples) assert isinstance(b['Z'], Brain_Data) b = masked.bootstrap('std', n_samples=n_samples) assert isinstance(b['Z'], Brain_Data) b = masked.bootstrap('predict', n_samples=n_samples, plot=False) assert isinstance(b['Z'], Brain_Data) b = masked.bootstrap('predict', n_samples=n_samples, plot=False, cv_dict={'type':'kfolds','n_folds':3}) assert isinstance(b['Z'], Brain_Data) b = masked.bootstrap('predict', n_samples=n_samples, save_weights=True, plot=False) assert len(b['samples'])==n_samples # Test decompose n_components = 3 stats = dat.decompose(algorithm='pca', axis='voxels', n_components=n_components) assert n_components == len(stats['components']) assert stats['weights'].shape == (len(dat), n_components) stats = dat.decompose(algorithm='ica', axis='voxels', n_components=n_components) assert n_components == len(stats['components']) assert stats['weights'].shape == (len(dat), n_components) dat.data = dat.data + 2 dat.data[dat.data<0] = 0 stats = dat.decompose(algorithm='nnmf', axis='voxels', n_components=n_components) assert n_components == len(stats['components']) assert stats['weights'].shape == (len(dat), n_components) stats = dat.decompose(algorithm='fa', axis='voxels', n_components=n_components) assert n_components == len(stats['components']) assert stats['weights'].shape == (len(dat), n_components) stats = dat.decompose(algorithm='pca', axis='images', n_components=n_components) assert n_components == len(stats['components']) assert stats['weights'].shape == (len(dat), n_components) stats = dat.decompose(algorithm='ica', axis='images', n_components=n_components) assert n_components == len(stats['components']) assert stats['weights'].shape == (len(dat), n_components) dat.data = dat.data + 2 dat.data[dat.data<0] = 0 stats = dat.decompose(algorithm='nnmf', axis='images', n_components=n_components) assert n_components == len(stats['components']) assert stats['weights'].shape == (len(dat), n_components) stats = dat.decompose(algorithm='fa', axis='images', n_components=n_components) assert n_components == len(stats['components']) assert stats['weights'].shape == (len(dat), n_components) # Test Hyperalignment Method sim = Simulator() y = [0, 1] n_reps = 10 s1 = create_sphere([0, 0, 0], radius=3) d1 = sim.create_data(y, 1, reps=n_reps, output_dir=None).apply_mask(s1) d2 = sim.create_data(y, 2, reps=n_reps, output_dir=None).apply_mask(s1) d3 = sim.create_data(y, 3, reps=n_reps, output_dir=None).apply_mask(s1) # Test procrustes using align data = [d1, d2, d3] out = align(data, method='procrustes') assert len(data) == len(out['transformed']) assert len(data) == len(out['transformation_matrix']) assert data[0].shape() == out['common_model'].shape() transformed = np.dot(d1.data, out['transformation_matrix'][0]) centered = d1.data - np.mean(d1.data, 0) transformed = (np.dot(centered/np.linalg.norm(centered), out['transformation_matrix'][0])*out['scale'][0]) np.testing.assert_almost_equal(0, np.sum(out['transformed'][0].data - transformed), decimal=5) # Test deterministic brain_data bout = d1.align(out['common_model'], method='deterministic_srm') assert d1.shape() == bout['transformed'].shape() assert d1.shape() == bout['common_model'].shape() assert d1.shape()[1] == bout['transformation_matrix'].shape[0] btransformed = np.dot(d1.data, bout['transformation_matrix']) np.testing.assert_almost_equal(0, np.sum(bout['transformed'].data - btransformed)) # Test deterministic brain_data bout = d1.align(out['common_model'], method='probabilistic_srm') assert d1.shape() == bout['transformed'].shape() assert d1.shape() == bout['common_model'].shape() assert d1.shape()[1] == bout['transformation_matrix'].shape[0] btransformed = np.dot(d1.data, bout['transformation_matrix']) np.testing.assert_almost_equal(0, np.sum(bout['transformed'].data-btransformed)) # Test procrustes brain_data bout = d1.align(out['common_model'], method='procrustes') assert d1.shape() == bout['transformed'].shape() assert d1.shape() == bout['common_model'].shape() assert d1.shape()[1] == bout['transformation_matrix'].shape[0] centered = d1.data - np.mean(d1.data, 0) btransformed = (np.dot(centered/np.linalg.norm(centered), bout['transformation_matrix'])*bout['scale']) np.testing.assert_almost_equal(0, np.sum(bout['transformed'].data-btransformed), decimal=5) np.testing.assert_almost_equal(0, np.sum(out['transformed'][0].data - bout['transformed'].data)) # Test hyperalignment on Brain_Data over time (axis=1) sim = Simulator() y = [0, 1] n_reps = 10 s1 = create_sphere([0, 0, 0], radius=5) d1 = sim.create_data(y, 1, reps=n_reps, output_dir=None).apply_mask(s1) d2 = sim.create_data(y, 2, reps=n_reps, output_dir=None).apply_mask(s1) d3 = sim.create_data(y, 3, reps=n_reps, output_dir=None).apply_mask(s1) data = [d1, d2, d3] out = align(data, method='procrustes', axis=1) assert len(data) == len(out['transformed']) assert len(data) == len(out['transformation_matrix']) assert data[0].shape() == out['common_model'].shape() centered = data[0].data.T-np.mean(data[0].data.T, 0) transformed = (np.dot(centered/np.linalg.norm(centered), out['transformation_matrix'][0])*out['scale'][0]) np.testing.assert_almost_equal(0,np.sum(out['transformed'][0].data-transformed.T), decimal=5) bout = d1.align(out['common_model'], method='deterministic_srm', axis=1) assert d1.shape() == bout['transformed'].shape() assert d1.shape() == bout['common_model'].shape() assert d1.shape()[0] == bout['transformation_matrix'].shape[0] btransformed = np.dot(d1.data.T, bout['transformation_matrix']) np.testing.assert_almost_equal(0, np.sum(bout['transformed'].data-btransformed.T)) bout = d1.align(out['common_model'], method='probabilistic_srm', axis=1) assert d1.shape() == bout['transformed'].shape() assert d1.shape() == bout['common_model'].shape() assert d1.shape()[0] == bout['transformation_matrix'].shape[0] btransformed = np.dot(d1.data.T, bout['transformation_matrix']) np.testing.assert_almost_equal(0, np.sum(bout['transformed'].data-btransformed.T)) bout = d1.align(out['common_model'], method='procrustes', axis=1) assert d1.shape() == bout['transformed'].shape() assert d1.shape() == bout['common_model'].shape() assert d1.shape()[0] == bout['transformation_matrix'].shape[0] centered = d1.data.T-np.mean(d1.data.T, 0) btransformed = (np.dot(centered/np.linalg.norm(centered), bout['transformation_matrix'])*bout['scale']) np.testing.assert_almost_equal(0, np.sum(bout['transformed'].data-btransformed.T), decimal=5) np.testing.assert_almost_equal(0, np.sum(out['transformed'][0].data-bout['transformed'].data))
def test_extract_roi(sim_brain_data): mask = create_sphere([12, 10, -8], radius=10) assert len(sim_brain_data.extract_roi(mask)) == shape_2d[0]
from gclda.utils import get_resource_path ############################################################################### # Load model and initialize decoder # ---------------------------------- model_file = join(get_resource_path(), 'models/Neurosynth2015Filtered2', 'model_200topics_2015Filtered2_10000iters.pklz') model = Model.load(model_file) ############################################################################### # Create region of interest (ROI) image # -------------------------------------- coords = [[-40, -52, -20]] radii = [6] * len(coords) roi_img = create_sphere(coords, radius=radii, mask=model.dataset.mask_img) fig = plotting.plot_roi(roi_img, display_mode='ortho', cut_coords=[-40, -52, -20], draw_cross=False) ############################################################################### # Decode ROI # ----------- df, topic_weights = decode_roi(model, roi_img) ############################################################################### # Get associated terms # --------------------- df = df.sort_values(by='Weight', ascending=False) print(df.head(10))
plt.legend(loc="best") return plt for i in list(glob.glob('D:/FaceData/func_img/wrarun*.nii')): func_img=nib.load(i) from nilearn.image import index_img func_img=index_img(func_img,slice(10,490,8)) anat_img=nib.load('D:/FaceData/anat_img/anat.nii') # Create the mask image from nltools.mask import create_sphere mask_img= create_sphere([-29,-71,-4],radius=5) # from nilearn.masking import compute_epi_mask # mask_img=compute_epi_mask(func_icamcg) # Transform dimensional form 4D to 2D from nilearn.input_data import NiftiMasker masker = NiftiMasker(mask_img=mask_img, standardize=True, memory_level=1) fmri_masked = masker.fit_transform(func_img) # Load behavioral data for j in list(glob.glob('D:/FaceData/label/run*.txt')): behavioral=np.recfromcsv(j,delimiter='') conditions = behavioral['name']
def test_data(tmpdir): sim = Simulator() r = 10 sigma = 1 y = [0, 1] n_reps = 3 output_dir = str(tmpdir) sim.create_data(y, sigma, reps=n_reps, output_dir=output_dir) shape_3d = (91, 109, 91) shape_2d = (6, 238955) y = pd.read_csv(os.path.join(str(tmpdir.join('y.csv'))), header=None, index_col=None).T flist = glob.glob(str(tmpdir.join('centered*.nii.gz'))) # Test load list dat = Brain_Data(data=flist, Y=y) # Test load file assert Brain_Data(flist[0]) # Test to_nifti d = dat.to_nifti() assert d.shape[0:3] == shape_3d # Test load nibabel assert Brain_Data(d) # Test shape assert dat.shape() == shape_2d # Test Mean assert dat.mean().shape()[0] == shape_2d[1] # Test Std assert dat.std().shape()[0] == shape_2d[1] # Test add new = dat + dat assert new.shape() == shape_2d # Test subtract new = dat - dat assert new.shape() == shape_2d # Test multiply new = dat * dat assert new.shape() == shape_2d # Test Iterator x = [x for x in dat] assert len(x) == len(dat) assert len(x[0].data.shape) == 1 # # Test T-test out = dat.ttest() assert out['t'].shape()[0] == shape_2d[1] # # # Test T-test - permutation method # out = dat.ttest(threshold_dict={'permutation':'tfce','n_permutations':50,'n_jobs':1}) # assert out['t'].shape()[0]==shape_2d[1] # Test Regress dat.X = pd.DataFrame( { 'Intercept': np.ones(len(dat.Y)), 'X1': np.array(dat.Y).flatten() }, index=None) out = dat.regress() assert out['beta'].shape() == (2, shape_2d[1]) # Test indexing assert out['t'][1].shape()[0] == shape_2d[1] # Test threshold i = 1 tt = threshold(out['t'][i], out['p'][i], .05) assert isinstance(tt, Brain_Data) # Test write dat.write(os.path.join(str(tmpdir.join('test_write.nii')))) assert Brain_Data(os.path.join(str(tmpdir.join('test_write.nii')))) # Test append assert dat.append(dat).shape()[0] == shape_2d[0] * 2 # Test distance distance = dat.distance(method='euclidean') assert distance.shape == (shape_2d[0], shape_2d[0]) # Test predict stats = dat.predict(algorithm='svm', cv_dict={ 'type': 'kfolds', 'n_folds': 2, 'n': len(dat.Y) }, plot=False, **{'kernel': "linear"}) # Support Vector Regression, with 5 fold cross-validation with Platt Scaling # This will output probabilities of each class stats = dat.predict(algorithm='svm', cv_dict=None, plot=False, **{ 'kernel': 'linear', 'probability': True }) assert isinstance(stats['weight_map'], Brain_Data) # Logistic classificiation, with 5 fold stratified cross-validation. stats = dat.predict(algorithm='logistic', cv_dict={ 'type': 'kfolds', 'n_folds': 5, 'n': len(dat.Y) }, plot=False) assert isinstance(stats['weight_map'], Brain_Data) # Ridge classificiation, with 5 fold between-subject cross-validation, where data for each subject is held out together. stats = dat.predict(algorithm='ridgeClassifier', cv_dict=None, plot=False) assert isinstance(stats['weight_map'], Brain_Data) # Test Similarity r = dat.similarity(stats['weight_map']) assert len(r) == shape_2d[0] r2 = dat.similarity(stats['weight_map'].to_nifti()) assert len(r2) == shape_2d[0] # Test apply_mask - might move part of this to test mask suite s1 = create_sphere([41, 64, 55], radius=10) assert isinstance(s1, nb.Nifti1Image) s2 = Brain_Data(s1) masked_dat = dat.apply_mask(s1) assert masked_dat.shape()[1] == np.sum(s2.data != 0) # Test extract_roi mask = create_sphere([41, 64, 55], radius=10) assert len(dat.extract_roi(mask)) == shape_2d[0] # Test r_to_z z = dat.r_to_z() assert z.shape() == dat.shape() # Test copy d_copy = dat.copy() assert d_copy.shape() == dat.shape() # Test detrend detrend = dat.detrend() assert detrend.shape() == dat.shape()
tmp_dir = os.path.join(tempfile.gettempdir(), str(os.times()[-1])) ############################################################################### # Create data tic = time() #Start Timer sim = Simulator() r = 10 sigma = .5 cor = .8 cov = .6 n_trials = 10 n_subs = 5 s1 = create_sphere([41, 64, 55], radius=r) sim.create_cov_data(cor, cov, sigma, mask=s1, reps=n_trials, n_sub=n_subs, output_dir=tmp_dir) print 'Simulate Data: Elapsed: %.2f seconds' % (time() - tic) #Stop timer ############################################################################### # Load data tic = time() #Start Timer y = pd.read_csv(os.path.join(tmp_dir, 'y.csv'), header=None, index_col=None).T