def _run_interface(self, runtime): from nltools.data import Brain_Data import os in_file = self.inputs.in_file mask = self.inputs.mask low_pass = self.inputs.low_pass_cutoff high_pass = self.inputs.high_pass_cutoff TR = self.inputs.sampling_rate if low_pass == 0: low_pass = None if high_pass == 0: high_pass = None dat = Brain_Data(in_file, mask=mask) # Handle no filtering if low_pass or high_pass: dat = dat.filter(sampling_rate=TR, low_pass=low_pass, high_pass=high_pass) # Generate output file name out_file = os.path.split(in_file)[-1].split( '.nii.gz')[0] + '_filtered.nii.gz' dat.write(out_file) self._out_file = out_file runtime.returncode = 0 return runtime
def test_roc(tmpdir): sim = simulator.Simulator() r = 10 sigma = .1 y = [0, 1] n_reps = 10 # output_dir = str(tmpdir) sim.create_data(y, sigma, reps=n_reps, output_dir=None) dat = Brain_Data(data=sim.data,Y=pd.DataFrame(sim.y)) algorithm = 'svm' # output_dir = str(tmpdir) # cv = {'type': 'kfolds', 'n_folds': 5, 'subject_id': sim.rep_id} extra = {'kernel': 'linear'} output = dat.predict(algorithm='svm', plot=False, **extra) # Single-Interval roc = analysis.Roc(input_values=output['yfit_all'], binary_outcome=output['Y'] == 1) roc.calculate() roc.summary() assert roc.accuracy == 1 # Forced Choice binary_outcome = output['Y'] == 1 forced_choice = range(len(binary_outcome)/2) + range(len(binary_outcome)/2) forced_choice = forced_choice.sort() roc_fc = analysis.Roc(input_values=output['yfit_all'], binary_outcome=binary_outcome, forced_choice=forced_choice) roc_fc.calculate() assert roc_fc.accuracy == 1 assert roc_fc.accuracy == roc_fc.auc == roc_fc.sensitivity == roc_fc.specificity
def test_roc(tmpdir, sim): r = 10 sigma = .1 y = [0, 1] n_reps = 10 output_dir = str(tmpdir) sim.create_data(y, sigma, reps=n_reps, output_dir=None) dat = Brain_Data(data=sim.data, Y=pd.DataFrame(sim.y)) algorithm = 'svm' output_dir = str(tmpdir) # cv = {'type': 'kfolds', 'n_folds': 5, 'subject_id': sim.rep_id} extra = {'kernel': 'linear'} output = dat.predict(algorithm='svm', **extra) # predict = analysis.Predict(sim.data, sim.y, algorithm=algorithm, # output_dir=output_dir, # cv_dict=cv, # **extra) # predict.predict() # Save_Plot isn't working for SVM analysis, planning on deprecating analysis.Predict at some point, so not a big deal # predict.predict(save_plot=False) # Single-Interval roc = analysis.Roc(input_values=output['yfit_all'], binary_outcome=output['Y'] == 1) # roc = analysis.Roc( # input_values=predict.yfit_xval, binary_outcome=np.array(sim.y) == 1) roc.plot() roc.summary() assert roc.accuracy == 1
def expand_mask(mask, custom_mask=None): """expand a mask with multiple integers into separate binary masks Args: mask: nibabel or Brain_Data instance custom_mask: nibabel instance or string to file path; optional Returns: out: Brain_Data instance of multiple binary masks """ from nltools.data import Brain_Data if isinstance(mask, nib.Nifti1Image): mask = Brain_Data(mask, mask=custom_mask) if not isinstance(mask, Brain_Data): raise ValueError("Make sure mask is a nibabel or Brain_Data instance.") mask.data = np.round(mask.data).astype(int) tmp = [] for i in np.nonzero(np.unique(mask.data))[0]: tmp.append((mask.data == i) * 1) out = mask.empty() out.data = np.array(tmp) return out
def test_roc(tmpdir): sim = simulator.Simulator() r = 10 sigma = .1 y = [0, 1] n_reps = 10 # output_dir = str(tmpdir) sim.create_data(y, sigma, reps=n_reps, output_dir=None) dat = Brain_Data(data=sim.data, Y=pd.DataFrame(sim.y)) algorithm = 'svm' # output_dir = str(tmpdir) # cv = {'type': 'kfolds', 'n_folds': 5, 'subject_id': sim.rep_id} extra = {'kernel': 'linear'} output = dat.predict(algorithm='svm', plot=False, **extra) # Single-Interval roc = analysis.Roc(input_values=output['yfit_all'], binary_outcome=output['Y'] == 1) # roc = analysis.Roc( # input_values=predict.yfit_xval, binary_outcome=np.array(sim.y) == 1) roc.calculate() # roc.plot() roc.summary() assert roc.accuracy == 1
def test_roc(tmpdir, sim): r = 10 sigma = .1 y = [0, 1] n_reps = 10 output_dir = str(tmpdir) sim.create_data(y, sigma, reps=n_reps, output_dir=None) dat = Brain_Data(data=sim.data,Y=pd.DataFrame(sim.y)) algorithm = 'svm' output_dir = str(tmpdir) # cv = {'type': 'kfolds', 'n_folds': 5, 'subject_id': sim.rep_id} extra = {'kernel': 'linear'} output = dat.predict(algorithm='svm',**extra) # predict = analysis.Predict(sim.data, sim.y, algorithm=algorithm, # output_dir=output_dir, # cv_dict=cv, # **extra) # predict.predict() # Save_Plot isn't working for SVM analysis, planning on deprecating analysis.Predict at some point, so not a big deal # predict.predict(save_plot=False) # Single-Interval roc = analysis.Roc(input_values=output['yfit_all'], binary_outcome=output['Y'] == 1) # roc = analysis.Roc( # input_values=predict.yfit_xval, binary_outcome=np.array(sim.y) == 1) roc.plot() roc.summary() assert roc.accuracy == 1
def collapse_mask(mask, auto_label=True, custom_mask=None): """collapse separate masks into one mask with multiple integers overlapping areas are ignored Args: mask: nibabel or Brain_Data instance custom_mask: nibabel instance or string to file path; optional Returns: out: Brain_Data instance of a mask with different integers indicating different masks """ from nltools.data import Brain_Data if not isinstance(mask, Brain_Data): if isinstance(mask, nib.Nifti1Image): mask = Brain_Data(mask, mask=custom_mask) else: raise ValueError("Make sure mask is a nibabel or Brain_Data " "instance.") if len(mask.shape()) > 1: if len(mask) > 1: out = mask.empty() # Create list of masks and find any overlaps m_list = [] for x in range(len(mask)): m_list.append(mask[x].to_nifti()) intersect = intersect_masks(m_list, threshold=1, connected=False) intersect = Brain_Data( nib.Nifti1Image(np.abs(intersect.get_data() - 1), intersect.get_affine()), mask=custom_mask, ) merge = [] if auto_label: # Combine all masks into sequential order # ignoring any areas of overlap for i in range(len(m_list)): merge.append( np.multiply( Brain_Data(m_list[i], mask=custom_mask).data, intersect.data) * (i + 1)) out.data = np.sum(np.array(merge).T, 1).astype(int) else: # Collapse masks using value as label for i in range(len(m_list)): merge.append( np.multiply( Brain_Data(m_list[i], mask=custom_mask).data, intersect.data)) out.data = np.sum(np.array(merge).T, 1) return out else: warnings.warn("Doesn't need to be collapased")
def create_data(self, levels, sigma, radius = 5, center = None, reps = 1, output_dir = None): """ create simulated data with integers Args: levels: vector of intensities or class labels sigma: amount of noise to add radius: vector of radius. Will create multiple spheres if len(radius) > 1 center: center(s) of sphere(s) of the form [px, py, pz] or [[px1, py1, pz1], ..., [pxn, pyn, pzn]] reps: number of data repetitions useful for trials or subjects output_dir: string path of directory to output data. If None, no data will be written **kwargs: Additional keyword arguments to pass to the prediction algorithm """ # Create reps nlevels = len(levels) y = levels rep_id = [1] * len(levels) for i in range(reps - 1): y = y + levels rep_id.extend([i+2] * nlevels) # Initialize Spheres with options for multiple radii and centers of the spheres (or just an int and a 3D list) A = self.n_spheres(radius, center) #for each intensity A_list = [] for i in y: A_list.append(np.multiply(A, i)) #generate a different gaussian noise profile for each mask mu = 0 #values centered around 0 N_list = [] for i in range(len(y)): N_list.append(self.normal_noise(mu, sigma)) #add noise and signal together, then convert to nifti files NF_list = [] for i in range(len(y)): NF_list.append(self.to_nifti(np.add(N_list[i], A_list[i]) )) NF_list = Brain_Data(NF_list) # Assign variables to object self.data = NF_list self.y = pd.DataFrame(data=y) self.rep_id = pd.DataFrame(data=rep_id) dat = self.data dat.Y = self.y # Write Data to files if requested if output_dir is not None and isinstance(output_dir, six.string_types): NF_list.write(os.path.join(output_dir,'data.nii.gz')) self.y.to_csv(os.path.join(output_dir, 'y.csv'), index=None,header=False) self.rep_id.to_csv(os.path.join(output_dir, 'rep_id.csv'), index=None,header=False) return dat
def test_load(tmpdir): sim = Simulator() 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 Write dat.write(os.path.join(str(tmpdir.join('test_write.nii')))) assert Brain_Data(os.path.join(str(tmpdir.join('test_write.nii'))))
def check_brain_data(data, mask=None): """Check if data is a Brain_Data Instance.""" from nltools.data import Brain_Data if not isinstance(data, Brain_Data): if isinstance(data, nib.Nifti1Image): data = Brain_Data(data, mask=mask) else: raise ValueError("Make sure data is a Brain_Data instance.") else: if mask is not None: data = data.apply_mask(mask) return data
def similarity(image_list, weight_map_filename, file_path_key='resampled_file'): tic = time.time() # Start Timer weight_map = nb.load(weight_map_filename) file_path_list = [item[file_path_key] for item in image_list] dat = Brain_Data(data=file_path_list) r = dat.similarity(weight_map) log.info("Elapsed: %.2f seconds", (time.time() - tic)) # Stop timer return {'correlation': set_correlation(r, image_list)}
def similarity(image_list, weight_map_filename, file_path_key='resampled_file'): tic = time.time() # Start Timer weight_map = nb.load(weight_map_filename) file_path_list = [item[file_path_key] for item in image_list] dat = Brain_Data(data=file_path_list) r = dat.similarity(weight_map) log.info("Elapsed: %.2f seconds", (time.time() - tic)) # Stop timer return { 'correlation': set_correlation(r, image_list) }
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 reload(self): self.layout = BIDSLayout(self.root, derivatives=True) self.tr = self.layout.get_tr() with open(self.layout._get_unique(scope=self.name, suffix="pipeline").path) as file: pipeline = json.load(file) sys.path.append(os.path.dirname(self.layout._get_unique( scope=self.name, suffix="pipeline").path)) self.masks = dict() for mask, mask_path in pipeline["Masks"].items(): if not os.path.isabs(mask_path): mask_path = join(self.root, "derivatives", self.name, mask_path) self.masks[mask] = Brain_Data(mask_path) # Set up the process dictionary self.processes = dict() for process in pipeline["Processes"]: if not os.path.isabs(process["Source"]): process["Source"] = join(self.root, "derivatives", self.name, process["Source"]) head, tail = os.path.split(os.path.abspath(process["Source"])) if tail.endswith(".py"): tail = tail[:-3] else: raise TypeError(f"{tail} is not a Python script.") sys.path.append(head) self.processes[process["Name"]] = Process( key=process["Readable"], process=getattr(__import__(tail), process["Name"])) sys.path.remove(head)
def fetch_emotion_ratings(data_dir=None, resume=True, verbose=1): '''Download and loads emotion rating dataset from neurovault Args: data_dir: (string, optional). Path of the data directory. Used to force data storage in a specified location. Default: None n_subjects: (int, optional) Number of subjects, from 1 to 6. NOTE: n_subjects is deprecated from 0.2.6 and will be removed in 0.3 Use `subjects` instead. subjects : (list or int, optional) Either a list of subjects or the number of subjects to load, from 1 to 6. By default, 2nd subject will be loaded. Empty list returns no subject data Returns: ''' collection = 1964 dataset_name = 'chang2015_emotion_ratings' data_dir = _get_dataset_dir(dataset_name, data_dir=data_dir, verbose=verbose) metadata, files = download_collection(collection=collection, data_dir=data_dir, resume=resume, verbose=verbose) return Brain_Data(data=files, X=metadata)
def roi_to_brain(data, mask_x): ''' Args: data: Pandas series or dataframe of ROI by observation mask_x: an expanded binary mask Returns: Brain_Data instance ''' def series_to_brain(data, mask_x): '''Converts a pandas series of ROIs to a Brain_Data instance. Index must correspond to ROI index''' if not isinstance(data, pd.Series): raise ValueError('Data must be a pandas series') if len(mask_x) != len(data): raise ValueError( 'Data must have the same number of rows as mask has ROIs.') return Brain_Data([mask_x[x] * data[x] for x in data.keys()]).sum() if len(mask_x) != data.shape[0]: raise ValueError( 'Data must have the same number of rows as mask has ROIs.') if isinstance(data, pd.Series): return series_to_brain(data, mask_x) elif isinstance(data, pd.DataFrame): return Brain_Data( [series_to_brain(data[x], mask_x) for x in data.keys()])
def roi_to_brain(data, mask_x): ''' This function will create convert an expanded binary mask of ROIs (see expand_mask) based on a vector of of values. The dataframe of values must correspond to ROI numbers. This is useful for populating a parcellation scheme by a vector of Values Args: data: Pandas series or dataframe of ROI by observation mask_x: an expanded binary mask Returns: out: (Brain_Data) Brain_Data instance where each ROI is now populated with a value ''' from nltools.data import Brain_Data def series_to_brain(data, mask_x): '''Converts a pandas series of ROIs to a Brain_Data instance. Index must correspond to ROI index''' if not isinstance(data, pd.Series): raise ValueError('Data must be a pandas series') if len(mask_x) != len(data): raise ValueError( 'Data must have the same number of rows as mask has ROIs.') return Brain_Data([mask_x[x] * data[x] for x in data.keys()]).sum() if len(mask_x) != data.shape[0]: raise ValueError( 'Data must have the same number of rows as mask has ROIs.') if isinstance(data, pd.Series): return series_to_brain(data, mask_x) elif isinstance(data, pd.DataFrame): return Brain_Data( [series_to_brain(data[x], mask_x) for x in data.keys()])
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_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 series_to_brain(data, mask_x): '''Converts a pandas series of ROIs to a Brain_Data instance. Index must correspond to ROI index''' if not isinstance(data, pd.Series): raise ValueError('Data must be a pandas series') if len(mask_x) != len(data): raise ValueError( 'Data must have the same number of rows as mask has ROIs.') return Brain_Data([mask_x[x] * data[x] for x in data.keys()]).sum()
def check_brain_data(data): '''Check if data is a Brain_Data Instance.''' from nltools.data import Brain_Data if not isinstance(data, Brain_Data): if isinstance(data, nib.Nifti1Image): data = Brain_Data(data) else: raise ValueError("Make sure data is a Brain_Data instance.") return data
def test_indexing(sim_brain_data): index = [0, 3, 1] assert len(sim_brain_data[index]) == len(index) index = range(4) assert len(sim_brain_data[index]) == len(index) index = sim_brain_data.Y == 1 assert len(sim_brain_data[index.values.flatten()]) == index.values.sum() assert len(sim_brain_data[index]) == index.values.sum() assert len(sim_brain_data[:3]) == 3 d = sim_brain_data.to_nifti() assert d.shape[0:3] == shape_3d assert Brain_Data(d)
def simulate_data(n_observations, y, p, sigma, mask): ''' Simulate Brain Data Args: n_observations: (int) number of data points y: (array) one dimensional array of signal p: (float) probability of signal in voxels sigma: (float) amount of gaussian noise to add 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
def get_trialtype_pain_regressors(self,nifti_data,onset_file): print("importing nifti") #import the nifti if (os.path.isfile(nifti_data + "nltoolstandard.nii.gz")): msmrl1 = Brain_Data( nifti_data + "nltoolstandard.nii.gz") else: msmrl1 = Brain_Data( nifti_data + ".nii.gz") msmrl1.write(nifti_data + "nltoolstandard.nii.gz") #preprocess the nifti? print("importing onsets") #import the onset onsets = onsets_to_dm( onset_file, TR=2, runLength=msmrl1.shape()[0] ) #process the onset files # onsets.sampling_rate=2 onsets_convolved=onsets.convolve() for c in onsets_convolved.columns: if sum(onsets_convolved.ix[:, c]) <= 0: print('deleting '+ str(c)) del onsets_convolved[c] onsets_convolved['linearterm']=range(1,361) onsets_convolved['quadraticterm']=[pow(x,2) for x in onsets_convolved['linearterm']] onsets_convolved['cubicterm']=[pow(x,3) for x in onsets_convolved['linearterm']] onsets_convolved['ones']=[1]*360 msmrl1.X=onsets_convolved print("convolved onsets; regressing...") #regress regression=msmrl1.regress() print("Regressing; calculating similarity...") msm_predicted_pain = regression['beta'].similarity(self.stats['weight_map'], 'dot_product') onset_colnames = onsets_convolved.columns.tolist() msm_predicted_pain_dict={} for i, b in enumerate(msm_predicted_pain): msm_predicted_pain_dict[onset_colnames[i]] = b return msm_predicted_pain_dict
def test_predict_multi(): # Simulate data 100 images worth sim = Simulator() sigma = 1 y = [0, 1] n_reps = 50 output_dir = '.' dat = sim.create_data(y, sigma, reps=n_reps, output_dir=output_dir) y = pd.read_csv('y.csv', header=None, index_col=None) dat = Brain_Data('data.nii.gz', Y=y) # Predict within given ROIs # Generate some "rois" (in reality non-contiguous, but also not overlapping) roi_1 = dat[0].copy() roi_1.data = np.zeros_like(roi_1.data, dtype=bool) roi_2 = roi_1.copy() roi_3 = roi_1.copy() idx = np.random.choice(range(roi_1.shape()[-1]), size=9999, replace=False) roi_1.data[idx[:3333]] = 1 roi_2.data[idx[3333:6666]] = 1 roi_3.data[idx[6666:]] = 1 rois = roi_1.append(roi_2).append(roi_3) # Load in all 50 rois so we can "insert" signal into the first one # rois = expand_mask(Brain_Data(os.path.join(get_resource_path(), 'k50.nii.gz'))) # roi = rois[0] from sklearn.datasets import make_classification X, Y = make_classification(n_samples=100, n_features=rois[0].data.sum(), n_informative=500, n_redundant=5, n_classes=2) dat.data[:, rois[0].data.astype(bool)] = X dat.Y = pd.Series(Y) out = dat.predict_multi(algorithm='svm', cv_dict={'type': 'kfolds', 'n_folds': 3}, method='rois', n_jobs=-1, rois=rois[:3], kernel='linear') assert len(out) == 3 assert np.sum([elem['weight_map'].data.shape for elem in out]) == rois.data.sum() # Searchlight roi_mask = rois[:2].sum() out = dat.predict_multi(algorithm='svm', cv_dict={'type': 'kfolds', 'n_folds': 3}, method='searchlight', radius=4, verbose=50, n_jobs=-1, process_mask=roi_mask) assert len(np.nonzero(out.data)[0]) == len(np.nonzero(roi_mask.data)[0])
def expand_mask(mask): """ expand a mask with multiple integers into separate binary masks Args: mask: nibabel or Brain_Data instance Returns: out: Brain_Data instance of multiple binary masks """ from nltools.data import Brain_Data if isinstance(mask,nib.Nifti1Image): mask = Brain_Data(mask) if not isinstance(mask,Brain_Data): raise ValueError('Make sure mask is a nibabel or Brain_Data instance.') mask.data = mask.data.astype(int) tmp = [] for i in np.unique(mask.data): tmp.append((mask.data==i)*1) out = mask.empty() out.data = np.array(tmp) return out
def expand_mask(mask): """ expand a mask with multiple integers into separate binary masks Args: mask: nibabel or Brain_Data instance Returns: out: Brain_Data instance of multiple binary masks """ from nltools.data import Brain_Data if isinstance(mask, nib.Nifti1Image): mask = Brain_Data(mask) if not isinstance(mask, Brain_Data): raise ValueError('Make sure mask is a nibabel or Brain_Data instance.') mask.data = mask.data.astype(int) tmp = [] for i in np.unique(mask.data): tmp.append((mask.data == i) * 1) out = mask.empty() out.data = np.array(tmp) return out
def get_wager_nps_map(self, nps_map_filepath=None, data_mask=None): using_custom_filepath = False if nps_map_filepath is not None: using_custom_filepath = True else: nps_map_filepath = self.nps_map_filepath if (os.path.isfile(nps_map_filepath)): nps = Brain_Data(nps_map_filepath, mask=data_mask) self.decoder = nps if using_custom_filepath: self.decoder_origin = nps_map_filepath else: self.decoder_origin = 'nps' else: raise Exception("error; cannot find NPS map" + nps_map_filepath)
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'))) dat = Brain_Data(data=flist,Y=y) # 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 to_nifti d = dat.to_nifti assert d().shape[0:3] == shape_3d # # Test T-test out = dat.ttest() 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], threshold_dict={'fdr':.05}) assert tt.shape()[0] == shape_2d[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 fetch_emotion_ratings(data_dir=None, resume=True, verbose=1): """Download and loads emotion rating dataset from neurovault Args: data_dir: (string, optional). Path of the data directory. Used to force data storage in a specified location. Default: None Returns: out: (Brain_Data) Brain_Data object with downloaded data. X=metadata """ collection = 1964 dataset_name = "chang2015_emotion_ratings" data_dir = _get_dataset_dir(dataset_name, data_dir=data_dir, verbose=verbose) metadata, files = download_collection(collection=collection, data_dir=data_dir, resume=resume, verbose=verbose) return Brain_Data(data=files, X=metadata)
def multi_threshold(t_map, p_map, thresh): """ Threshold test image by multiple p-value from p image Args: stat: Brain_Data instance of arbitrary statistic metric (e.g., beta, t, etc) p: Brain_data instance of p-values threshold: list of p-values to threshold stat image Returns: out: Thresholded Brain_Data instance """ from nltools.data import Brain_Data if not isinstance(t_map, Brain_Data): raise ValueError('Make sure stat is a Brain_Data instance') if not isinstance(p_map, Brain_Data): raise ValueError('Make sure p is a Brain_Data instance') if not isinstance(thresh, list): raise ValueError('Make sure thresh is a list of p-values') affine = t_map.to_nifti().get_affine() pos_out = np.zeros(t_map.to_nifti().shape) neg_out = deepcopy(pos_out) for thr in thresh: t = threshold(t_map, p_map, thr=thr) t_pos = deepcopy(t) t_pos.data = np.zeros(len(t_pos.data)) t_neg = deepcopy(t_pos) t_pos.data[t.data > 0] = 1 t_neg.data[t.data < 0] = 1 pos_out = pos_out + t_pos.to_nifti().get_data() neg_out = neg_out + t_neg.to_nifti().get_data() pos_out = pos_out + neg_out * -1 return Brain_Data(nib.Nifti1Image(pos_out, affine))
def train_model(image_list, algorithm, cross_validation, output_dir, file_path_key='resampled_file', mask=None): """ :param image_list: A list of dictionaries of the form { 'collection_id': '504', 'filename': 'Pain_Subject_1_Low.nii.gz', 'target': '1', 'resampled_file': 'path/to/the/resampled/file.nii.gz', 'original_file': 'path/to/the/original/file.nii.gz' } """ tic = time.time() # Start Timer try: holdout = [int(item['subject_id']) for item in image_list] except KeyError: holdout = None if cross_validation: if holdout: cross_validation['subject_id'] = holdout elif cross_validation['type'] == 'loso': raise ValueError( "subject_id is required for a LOSO cross validation.") extra = {} if algorithm in ('svr', 'svm'): extra = {'kernel': 'linear'} categorical_mapping = None if algorithm in CLASSIFICATION_ALGORITHMS: classes = {item['target'] for item in image_list} assert len(classes) == 2, ('More than two classes. ' 'Classification requires binary data.') categorical_mapping = {cls: index for index, cls in enumerate(classes)} for image in image_list: image['target'] = categorical_mapping[image['target']] Y = pd.DataFrame([float(item['target']) for item in image_list]) file_path_list = [item[file_path_key] for item in image_list] dat = Brain_Data(data=file_path_list, Y=Y) if mask: log.info('Applying a mask') nifti_mask = nb.load(mask) dat = dat.apply_mask(nifti_mask) output = dat.predict(algorithm=algorithm, cv_dict=cross_validation, plot=True, **extra) weightmap_filename = '%s_weightmap.nii.gz' % algorithm output['weight_map'].write(os.path.join(output_dir, weightmap_filename)) log.info("Elapsed: %.2f seconds", (time.time() - tic)) # Stop timer result = {'weightmap': weightmap_filename, 'intercept': float(output['intercept']), 'scatterplot': '%s_scatterplot.png ' % algorithm, 'stats': {key: output[key].tolist() for key in ('Y', 'yfit_xval', 'yfit_all') if key in output}, 'categorical_mapping': categorical_mapping, 'summary': get_summary(output)} if 'roc' in output: result['roc'] = output['roc'] return result