def test_percent_change(): x = np.array([[99, 100, 101], [4, 5, 6]]) p = utils.percent_change(x) npt.assert_equal(x.shape, p.shape) npt.assert_almost_equal(p[0, 2], 1.0) ts = np.arange(4 * 5).reshape(4, 5) ax = 0 npt.assert_almost_equal( utils.percent_change(ts, ax), np.array( [ [-100.0, -88.23529412, -78.94736842, -71.42857143, -65.2173913], [-33.33333333, -29.41176471, -26.31578947, -23.80952381, -21.73913043], [33.33333333, 29.41176471, 26.31578947, 23.80952381, 21.73913043], [100.0, 88.23529412, 78.94736842, 71.42857143, 65.2173913], ] ), ) ax = 1 npt.assert_almost_equal( utils.percent_change(ts, ax), np.array( [ [-100.0, -50.0, 0.0, 50.0, 100.0], [-28.57142857, -14.28571429, 0.0, 14.28571429, 28.57142857], [-16.66666667, -8.33333333, 0.0, 8.33333333, 16.66666667], [-11.76470588, -5.88235294, 0.0, 5.88235294, 11.76470588], ] ), )
def test_percent_change(): x = np.array([[99, 100, 101], [4, 5, 6]]) p = utils.percent_change(x) npt.assert_equal(x.shape, p.shape) npt.assert_almost_equal(p[0, 2], 1.0) ts = np.arange(4 * 5).reshape(4, 5) ax = 0 npt.assert_almost_equal( utils.percent_change(ts, ax), np.array( [[-100., -88.23529412, -78.94736842, -71.42857143, -65.2173913], [ -33.33333333, -29.41176471, -26.31578947, -23.80952381, -21.73913043 ], [33.33333333, 29.41176471, 26.31578947, 23.80952381, 21.73913043], [100., 88.23529412, 78.94736842, 71.42857143, 65.2173913]])) ax = 1 npt.assert_almost_equal( utils.percent_change(ts, ax), np.array([[-100., -50., 0., 50., 100.], [-28.57142857, -14.28571429, 0., 14.28571429, 28.57142857], [-16.66666667, -8.33333333, 0., 8.33333333, 16.66666667], [-11.76470588, -5.88235294, 0., 5.88235294, 11.76470588]]))
def compute_coherence(time_windows, TR, f_lb, f_ub, roi_names): n_timewindows = time_windows.shape[0] n_samples = time_windows.shape[1] n_rois = time_windows.shape[2] coherence_3Darray = np.zeros((n_timewindows, n_rois, n_rois)) if n_rois == len(roi_names): for time_index in range(n_timewindows): ts = time_windows[time_index, :, :] data = np.zeros((n_rois, n_samples)) for n_idx, roi in enumerate(roi_names): data[n_idx] = ts[:, n_idx] data = percent_change(data) T = TimeSeries(data, sampling_interval=TR) C = CoherenceAnalyzer(T) freq_idx = np.where( (C.frequencies > f_lb) * (C.frequencies < f_ub))[0] coh = np.mean(C.coherence[:, :, freq_idx], -1) coherence_3Darray[time_index] = coh else: raise Exception( "Number of ROIs in 3D Array do not match number of ROI names provided." ) return coherence_3Darray
""" roi_names = np.array(data_rec.dtype.names) nseq = len(roi_names) n_samples = data_rec.shape[0] data = np.zeros((nseq, n_samples)) for n_idx, roi in enumerate(roi_names): data[n_idx] = data_rec[roi] """ We normalize the data in each of the ROIs to be in units of % change: """ pdata = utils.percent_change(data) """ We start by performing the detailed analysis, but note that a significant short-cut is presented below, so if you just want to know how to do this (without needing to understand the details), skip on down. We start by defining how many tapers will be used and calculate the values of the tapers and the associated eigenvalues of each taper: """ NW = 4 K = 2 * NW - 1 tapers, eigs = alg.dpss_windows(n_samples, NW, K)
roi_names = np.array(data_rec.dtype.names) nseq = len(roi_names) n_samples = data_rec.shape[0] data = np.zeros((nseq, n_samples)) for n_idx, roi in enumerate(roi_names): data[n_idx] = data_rec[roi] """ We normalize the data in each of the ROIs to be in units of % change: """ pdata = utils.percent_change(data) """ We start by performing the detailed analysis, but note that a significant short-cut is presented below, so if you just want to know how to do this (without needing to understand the details), skip on down. We start by defining how many tapers will be used and calculate the values of the tapers and the associated eigenvalues of each taper: """ NW = 4 K = 2 * NW - 1
from nitime.utils import percent_change import nitime.viz reload(nitime.viz) from nitime.viz import plot_xcorr #This part is the same as before TR=1.89 data_rec = csv2rec('data/fmri_timeseries.csv') roi_names= np.array(data_rec.dtype.names) n_samples = data_rec.shape[0] data = np.zeros((len(roi_names),n_samples)) for n_idx, roi in enumerate(roi_names): data[n_idx] = data_rec[roi] data = percent_change(data) T = UniformTimeSeries(data,sampling_interval=TR) T.metadata['roi'] = roi_names C = CorrelationAnalyzer(T) #Extract the cross-correlation: xc = C.xcorr_norm idx_lcau = np.where(roi_names=='lcau')[0] idx_rcau = np.where(roi_names=='rcau')[0] idx_lput = np.where(roi_names=='lput')[0] plot_xcorr(xc,((idx_lcau,idx_rcau),(idx_lcau,idx_lput)), line_labels = ['rcau','lput'])
data_rec = mlab.csv2rec('data/fmri_timeseries.csv') #Extract information: roi_names= data_rec.dtype.names n_samples = data_rec.shape[0] #This information has to be known in advance: TR=1.89 #Make an empty container for the data data = np.zeros((len(roi_names),n_samples)) for n_idx in range(len(roi_names)): data[n_idx] = data_rec[roi_names[n_idx]] #Normalize the data: data = tsu.percent_change(data) #Initialize the time-series from the normalized data: T = ts.UniformTimeSeries(data,sampling_interval=TR) T.metadata['roi'] = roi_names C = tsa.CorrelationAnalyzer(T) xc = C.xcorr_norm N = len(roi_names) ind = np.arange(N) # the evenly spaced plot indices
def percent_change(self): return ts.TimeSeries(tsu.percent_change(self.input.data), sampling_rate=self.input.sampling_rate, time_unit = self.input.time_unit)
percent signal change, using the utils.percent_change function. """ #Extract information: roi_names = np.array(data_rec.dtype.names) n_samples = data_rec.shape[0] #Make an empty container for the data data = np.zeros((len(roi_names), n_samples)) for n_idx, roi in enumerate(roi_names): data[n_idx] = data_rec[roi] #Normalize the data: data = percent_change(data) """ We initialize a TimeSeries object from the normalized data: """ T = TimeSeries(data, sampling_interval=TR) T.metadata['roi'] = roi_names """ First, we examine the correlations between the time-series extracted from different parts of the brain. The following script extracts the data (using the drawmatrix_channels function, displaying the correlation matrix with the ROIs labeled.
roi_names = np.array(data_rec.dtype.names) nseq = len(roi_names) n_samples = data_rec.shape[0] data = np.zeros((nseq, n_samples)) for n_idx, roi in enumerate(roi_names): data[n_idx] = data_rec[roi] """ We normalize the data in each of the ROIs to be in units of % change and initialize the TimeSeries object: """ pdata = tsu.percent_change(data) time_series = ts.TimeSeries(pdata, sampling_interval=TR) """ We initialize the GrangerAnalyzer object, while specifying the order of the autoregressive model to be 1 (predict the current behavior of the time-series based on one time-point back). """ G = nta.GrangerAnalyzer(time_series, order=1) """ For comparison, we also initialize a CoherenceAnalyzer and a CorrelationAnalyzer, with the same TimeSeries object:
def percent_change(self): return ts.TimeSeries(tsu.percent_change(self.input.data), sampling_rate=self.input.sampling_rate, time_unit=self.input.time_unit)
def get_time_series_inplane(coords,scan_file, f_c=0.01,up_sample_factor=[1,1,1], detrend=True,normalize=True,average=True, TR=None): """vista_get_time_series: Acquire a time series for a particular scan/ROI. Parameters ---------- coords: a list of arrays each array holds the X,Y,Z locations of an ROI (as represented in the Inplane) scan_file: string, full path to the analyze file of the scan TR: float the repetition time in the experiment up_sample_factor: float the ratio between the size of the inplane and the size of the gray (taking into account FOV and number of voxels in each dimension). Defaults to [1,1,1] - no difference detrend: bool, optional whether to detrend the signal. Default to 'True' normalize: bool, optional whether to transform the signal into % signal change. Default to 'True' average: bool, optional whether to average the resulting signal Returns ------- time_series: array, the resulting time_series Depending on the averaging flag, can have the dimensions 1*time-points or number-voxels*time-points. Notes ----- The order of the operations on the time-series is: detrend(on a voxel-by-voxel basis) => normalize (on a voxel-by-voxel basis) => average (across voxels, on a time-point-by-time-point basis) """ from nibabel import load #Get the nifti image object print 'Reading data from %s' %scan_file data = load(scan_file).get_data() #if using nipy.io.imageformats.load #Adjusted the coordinates according to the ratio between the #sampling in the gray and the sampling in the inplane, move the #slice dimension to be the first one and change the indexing from #1-based to 0-based. The coord order is as it is in the input, so need to #make sure that it is correct on the input side. this_data = data[np.round(coords[0]/up_sample_factor[0]).astype(int)-1, np.round(coords[1]/up_sample_factor[1]).astype(int)-1, np.round(coords[2]/up_sample_factor[2]).astype(int)-1] if normalize: this_data = tsu.percent_change(this_data) if average: this_data = np.mean(this_data,0) time_series = ts.TimeSeries(data=this_data,sampling_interval=TR) if detrend: F = ta.FilterAnalyzer(this_bold,lb=f_c) time_series = F.filtered_boxcar return time_series
def get_time_series_inplane(coords, scan_file, f_c=0.01, up_sample_factor=[1, 1, 1], detrend=True, normalize=True, average=True, TR=None): """vista_get_time_series: Acquire a time series for a particular scan/ROI. Parameters ---------- coords: a list of arrays each array holds the X,Y,Z locations of an ROI (as represented in the Inplane) scan_file: string, full path to the analyze file of the scan TR: float the repetition time in the experiment up_sample_factor: float the ratio between the size of the inplane and the size of the gray (taking into account FOV and number of voxels in each dimension). Defaults to [1,1,1] - no difference detrend: bool, optional whether to detrend the signal. Default to 'True' normalize: bool, optional whether to transform the signal into % signal change. Default to 'True' average: bool, optional whether to average the resulting signal Returns ------- time_series: array, the resulting time_series Depending on the averaging flag, can have the dimensions 1*time-points or number-voxels*time-points. Notes ----- The order of the operations on the time-series is: detrend(on a voxel-by-voxel basis) => normalize (on a voxel-by-voxel basis) => average (across voxels, on a time-point-by-time-point basis) """ from nibabel import load #Get the nifti image object print 'Reading data from %s' % scan_file data = load(scan_file).get_data() #if using nipy.io.imageformats.load #Adjusted the coordinates according to the ratio between the #sampling in the gray and the sampling in the inplane, move the #slice dimension to be the first one and change the indexing from #1-based to 0-based. The coord order is as it is in the input, so need to #make sure that it is correct on the input side. this_data = data[np.round(coords[0] / up_sample_factor[0]).astype(int) - 1, np.round(coords[1] / up_sample_factor[1]).astype(int) - 1, np.round(coords[2] / up_sample_factor[2]).astype(int) - 1] if normalize: this_data = tsu.percent_change(this_data) if average: this_data = np.mean(this_data, 0) time_series = ts.TimeSeries(data=this_data, sampling_interval=TR) if detrend: F = ta.FilterAnalyzer(this_bold, lb=f_c) time_series = F.filtered_boxcar return time_series
def time_series_from_nifti(nifti_im,coords,normalize=False,detrend=False, average=False,f_c=0.01,TR=None): """ Make a time series from a Nifti file, provided coordinates into the Nifti file Parameters ---------- analyze_im: nifti.image.NiftiImage object an object derived from the Nifti file containing the time-series data coords: ndarray or list of ndarrays x,y,z (slice,inplane,inplane) coordinates of the ROI from which the time-series is to be derived. If the list has more than one such array, the t-series will have more than one row in the data, as many as there are coordinates in the total list. Averaging is done on each item in the list separately, such that if several ROIs are entered, averaging will be done on each one separately and the result will be a time-series with as many rows of data as different ROIs in the input detrend: bool, optional whether to detrend the time-series . For now, we do box-car detrending, but in the future we will do real high-pass filtering normalize: bool, optional whether to convert the time-series values into % signal change (on a voxel-by-voxel level) average: bool, optional whether to average the time-series across the voxels in the ROI. In which case, self.data will be 1-d f_c: float, optional cut-off frequency for detrending TR: float, optional TR, if different from the one which can be extracted from the nifti file header Returns ------- time-series object """ #extract the data from the file: nifti_data = nifti_im.asarray() #Per default read TR from file: if TR is None: TR = nifti_im.getRepetitionTime()/1000.0 #in msec - convert to seconds #If we got a list of coord arrays, we're happy. Otherwise, we want to force #our input to be a list: try: coords.shape #If it is an array, it has a shape, otherwise, we #assume it's a list. If it's an array, we want to #make it into a list: coords = [coords] except: #If it's a list already, we don't need to do anything: pass #Make a list the size of the coords-list, with place-holder 0's data_out = list([0]) * len(coords) for c in xrange(len(coords)): data_out[c] = nifti_data[:,coords[c][0],coords[c][1],coords[c][2]].T #Take the transpose in order to make time the last dimension if normalize: data_out[c] = tsu.percent_change(data_out[c]) #Currently uses mrVista style box-car detrending, will eventually be #replaced by a filter: if detrend: data_out[c] = tsu.vista_detrend_tseries(data_out[c],TR,f_c) if average: data_out[c] = np.mean(data_out[c],0) #Convert this into the array with which the time-series object is #initialized: data_out = np.array(data_out) tseries = UniformTimeSeries(data_out,sampling_interval=TR) return tseries
def test_percent_change(): x = np.array([[99,100,101],[4,5,6]]) p = utils.percent_change(x) npt.assert_equal(x.shape,p.shape) npt.assert_almost_equal(p[0,2],1.0)