def _make_output_figures(self): """ Generate the desired figure and save the files according to self.inputs.output_figure_file """ if self.inputs.figure_type == 'matrix': fig_coh = viz.drawmatrix_channels(self.coherence, channel_names=self.ROIs, color_anchor=0) fig_coh.savefig(fname_presuffix(self.inputs.output_figure_file, suffix='_coherence')) fig_dt = viz.drawmatrix_channels(self.delay, channel_names=self.ROIs, color_anchor=0) fig_dt.savefig(fname_presuffix(self.inputs.output_figure_file, suffix='_delay')) else: fig_coh = viz.drawgraph_channels(self.coherence, channel_names=self.ROIs) fig_coh.savefig(fname_presuffix(self.inputs.output_figure_file, suffix='_coherence')) fig_dt = viz.drawgraph_channels(self.delay, channel_names=self.ROIs) fig_dt.savefig(fname_presuffix(self.inputs.output_figure_file, suffix='_delay'))
def analyze(data,chan_names): TR = 1000.0 ##sample rate f_ub = 100 ##upper freq bound f_lb = 0 ##lower freq bound ##compute the result for each trial coh = [] g1 = [] g2 = [] for trial in range(data.shape[0]): trialdata = data[trial,:,:] time_series = ts.TimeSeries(trialdata, sampling_rate=TR) G = nta.GrangerAnalyzer(input=time_series,order=2) C1 = nta.CoherenceAnalyzer(time_series) C2 = nta.CorrelationAnalyzer(time_series) freq_idx_G = np.where((G.frequencies > f_lb) * (G.frequencies < f_ub))[0] freq_idx_C = np.where((C1.frequencies > f_lb) * (C1.frequencies < f_ub))[0] coh.append(np.nanmean(C1.coherence[:, :, freq_idx_C], -1)) # Averaging on the last dimension g1.append(np.nanmean(G.causality_xy[:, :, freq_idx_G], -1)) g2.append(np.nanmean(G.causality_xy[:, :, freq_idx_G] - G.causality_yx[:, :, freq_idx_G], -1)) ##now average across trials coh = np.nanmean(np.asarray(coh),axis=0) g1 = np.nanmean(np.asarray(g1),axis=0) g2 = np.nanmean(np.asarray(g2),axis=0) fig01 = drawmatrix_channels(coh, chan_names, size=[10., 10.], title='Coherence') fig02 = drawmatrix_channels(C2.corrcoef, chan_names, size=[10., 10.], title="Correlations") fig03 = drawmatrix_channels(g1.T, chan_names, size=[10., 10.],title="Forward causality") fig04 = drawmatrix_channels(g2.T, chan_names, size=[10., 10.], title="Reverse causality")
def slicesdir_connectivity_matrices(output_dir, cmat_list, dpi=150, lower_triangle=True, **kwargs): """ @param output_dir: @param file_list1: list of ndarrays List of connectivity matrices @param dpi: int Dots per inch resolution of the plot images @param lower_triangle: bool If true, will plot a lower triangle of the matrix, the full matrix otherwise. @param kwargs: arguments to show_many_slices See draw_square_matrix_channels named arguments. """ import os import skimage.io as skio import matplotlib.pyplot as plt from nitime.viz import drawmatrix_channels if not os.path.exists(output_dir): os.makedirs(output_dir) img_files = [] #cmap = kwargs.pop('cmap', plt.cm.rainbow) channel_names = kwargs.pop('channel_names', None) color_anchor = kwargs.pop('color_anchor', 0) size = kwargs.pop('size', [10., 10.]) #CREATE separate images of each file_list2 file # on the corresponding file_list1 file for idx in list(range(len(cmat_list))): cmat = cmat_list[idx] png_fname = 'connectivity_matrix' + str(idx) + '.png' png_path = os.path.join(output_dir, png_fname) if lower_triangle: fig = drawmatrix_channels(cmat, channel_names, size=size, color_anchor=color_anchor, **kwargs) else: fig = draw_square_matrix_channels(cmat, channel_names, size=size, color_anchor=color_anchor, **kwargs) #fig = plt.matshow(cmat, cmap=cmap) fig.savefig(png_path, transparent=True, dpi=dpi) img = autocrop_img(skio.imread(png_path)) skio.imsave(png_path, img) img_files.append(os.path.basename(png_path)) plt.close() #Create the index.html file with all images create_imglist_html(output_dir, img_files) return img_files
def nitime_solution(animal, day, cutoff=True): # TODO: add support for custom freq bands import h5py import nitime import numpy as np import nitime.analysis as nta from utils_loading import encode_to_filename from nitime.viz import drawmatrix_channels import matplotlib.pyplot as plt folder = "/Volumes/DATA_01/NL/layerproject/processed/" hf = h5py.File(encode_to_filename(folder, animal, day), 'r') dff = np.array(hf['dff']) NEUR = 'ens' # Critical neuron pair vs general neuron gc if NEUR == 'ens': rois = dff[hf['ens_neur']] elif NEUR == 'neur': rois = dff[hf['nerden']] else: rois = dff[NEUR] rois_ts = nitime.TimeSeries(rois, sampling_interval=1 / hf.attrs['fr']) G = nta.GrangerAnalyzer(rois_ts) if cutoff: sel = np.where(G.frequencies < hf.attrs['fr'])[0] caus_xy = G.causality_xy[:, :, sel] caus_yx = G.causality_yx[:, :, sel] caus_sim = G.simultaneous_causality[:, :, sel] else: caus_xy = G.causality_xy caus_yx = G.causality_yx caus_sim = G.simultaneous_causality g1 = np.mean(caus_xy, -1) g2 = np.mean(caus_yx, -1) g3 = np.mean(caus_sim, -1) g4 = g1-g2 fig03 = drawmatrix_channels(g1, ['E11', 'E12', 'E21', 'E22'], size=[10., 10.], color_anchor = 0) plt.colorbar()
def granger_causality_analysis(time_series, f_lb, f_ub, granger_order, roi_names,result_dir, s='', c=''): # initialize GrangerAnalyzer object G = nta.GrangerAnalyzer(time_series, order = granger_order) # initialize CoherenceAnalyzer C = nta.CoherenceAnalyzer(time_series) # initialize CorrelationAnalyzer R = nta.CorrelationAnalyzer(time_series) # get the index of the frequency band of interest for different analyzer freq_idx_G = np.where((G.frequencies > f_lb) * (G.frequencies < f_ub))[0] freq_idx_C = np.where((C.frequencies> f_lb) * (C.frequencies < f_ub)) [0] # average the last dimension coh = np.mean(C.coherence[:, :, freq_idx_C], -1) gl = np.mean(G.causality_xy[:, :, freq_idx_G], -1) # Difference in HRF between ROI may result misattriution of causality # examine diference between x-->y and y-->x g2 = np.mean(G.causality_xy[:,:,freq_idx_G] - G.causality_yx[:,:,freq_idx_G],-1) # Figure organization: # causality_xy: x-->y, or roi_names[0]-->roi_names[1], roi_names[0]-->roi_names[2], etc. # this makes: given a column, transverse through rows. Directionality is # from current column label to each row label # plot coherence from x to y, drawmatrix_channels(coh, roi_names, size=[10., 10.], color_anchor=0) plt.title(('%s %s pair-wise Coherence' % (s, c)).replace(' ',' ')) plt.savefig(os.path.join(result_dir,s,('%s_%s_pairwise_coherence.png' % (s, c)).replace('__','_'))) # plot correlation from x to y #drawmatrix_channels(R.corrcoef, roi_names, size=[10., 10.], color_anchor=0) #plt.title(('%s %s pair-wise Correlation' % (s, c)).replace(' ',' ')) #plt.savefig(os.path.join(result_dir,s,('%s_%s_pairwise_correlation.png' % (s, c)).replace('__','_'))) # plot granger causality from x to y drawmatrix_channels(gl, roi_names, size=[10., 10.], color_anchor=0) plt.title(('%s %s pair-wise Granger Causality' % (s, c)).replace(' ',' ')) plt.savefig(os.path.join(result_dir,s,('%s_%s_pairwise_granger_causality.png' % (s, c)).replace('__','_'))) # plot granger causliaty forward-backward difference drawmatrix_channels(g2, roi_names, size=[10., 10.], color_anchor = 0) plt.title(('%s %s pair-wise Granger Causality Forward-Backward Difference' % (s, c)).replace(' ',' ')) plt.savefig(os.path.join(result_dir,s,('%s_%s_granger_causality_forward_backward_diff.png' % (s, c)).replace('__','_'))) # close all the figures plt.close("all") return(coh, gl, g2, G, C, R)
def robust_viz(g, labels): from nitime.viz import drawmatrix_channels g[np.isnan(g)] = 0 drawmatrix_channels(g, labels, size=[10., 10.], color_anchor=0)
freq_idx_G = np.where((G.frequencies > f_lb) * (G.frequencies < f_ub))[0] freq_idx_C = np.where((C1.frequencies > f_lb) * (C1.frequencies < f_ub))[0] """ We plot the 'causality' from x to y ($F_{x \rightarrow y}$) and from y to x ($F_{y \rightarrow x}$ for the first two ROIs and compare to the coherence between these two time-series: """ coh = np.mean(C1.coherence[:, :, freq_idx_C], -1) # Averaging on the last dimension g1 = np.mean(G.causality_xy[:, :, freq_idx_G], -1) fig01 = drawmatrix_channels(coh, roi_names, size=[10., 10.], color_anchor=0) """ .. image:: fig/granger_fmri_01.png """ fig02 = drawmatrix_channels(C2.corrcoef, roi_names, size=[10., 10.], color_anchor=0) """ .. image:: fig/granger_fmri_02.png """
def test_drawmatrix_channels(): fig01 = drawmatrix_channels(C.corrcoef, roi_names, size=[10., 10.], color_anchor=0)
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. """ # Initialize the correlation analyzer C = CorrelationAnalyzer(T) # Display the correlation matrix fig01 = drawmatrix_channels(C.corrcoef, roi_names, size=[10., 10.], color_anchor=0) """ .. image:: fig/resting_state_fmri_01.png Notice that setting the color_anchor input to this function to 0 makes sure that the center of the color map (here a blue => white => red) is at 0. In this case, positive values will be displayed as red and negative values in blue. We notice that the left caudate nucleus (labeled 'lcau') has an interesting pattern of correlations. It has a high correlation with both the left putamen ('lput', which is located nearby) and also with the right caudate nucleus ('lcau'), which is the homologous region in the other hemisphere. Are these two correlation values related to each other? The right caudate and left putamen seem to have a moderately low correlation value. One way to examine this
#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 = TimeSeries(data,sampling_interval=TR) T.metadata['roi'] = roi_names C = CoherenceAnalyzer(T) freq_idx = np.where((C.frequencies>0.02) * (C.frequencies<0.15))[0] idx_lcau = np.where(roi_names=='lcau')[0] idx_rcau = np.where(roi_names=='rcau')[0] idx_lput = np.where(roi_names=='lput')[0] idx_rput = np.where(roi_names=='rput')[0] idx = np.hstack([idx_lcau,idx_rcau,idx_lput,idx_rput]) idx1 = np.vstack([[idx[i]]*4 for i in range(4)]).ravel() idx2 = np.hstack(4*[idx]) #For the third dimension, take always the index of the left caudate: idx3 = np.hstack(16*[idx_lcau]) #Extract the partial coherence and average across the frequency bands: coh = C.coherence_partial[idx1,idx2,idx3].reshape(4,4,C.frequencies.shape[0]) coh = np.mean(coh[:,:,freq_idx],-1) #Averaging on the last dimension drawgraph_channels(coh,roi_names[idx]) drawmatrix_channels(coh,roi_names[idx],color_anchor=0)
# reshape ROI matrix allROIS=reshapeTS(t_fix) numRuns=allROIS.shape[1] corr_all[subject] = np.zeros((numRuns,len(rois),len(rois))) * np.nan coh_all[subject] = np.zeros((numRuns,len(rois),len(rois))) * np.nan # Get roi correlations and coherence for runNum in range(allROIS.shape[1]): #need to load timeseries by run fixTS=ts.TimeSeries(allROIS[:,runNum,:], sampling_interval=TR) fixTS.metadata['roi'] = roi_names # Get plot and correlations C=CorrelationAnalyzer(fixTS) fig01 = drawmatrix_channels(C.corrcoef, roi_names, size=[10., 10.], color_anchor=0, title='Correlation Results Run %i' % runNum) plt.show() # Save correlation corr_all[subject][runNum]=C.corrcoef # Get coherence Coh = CoherenceAnalyzer(fixTS) Coh.method['NFFT'] = NFFT Coh.method['n_overlap']=n_overlap # Get the index for the frequencies inside the ub and lb freq_idx = np.where((Coh.frequencies > f_lb) * (Coh.frequencies < f_ub))[0] # Extract coherence # Coher[0]= correlations for first ROI in list with others
coherAll_flat[ind] = np.nan ind = np.where( corrAll_flat == np.Infinity) corrAll_flat[ind] = np.nan # Reshape back into matrix of runs x rois x rois coherAll_t=coherAll_flat.reshape(numRuns, roiNames.size, roiNames.size) corrAll_t=corrAll_flat.reshape(numRuns, roiNames.size, roiNames.size) # Average over runs (the first dimension) coherAvg_t=np.mean(coherAll_t, 0) coherSTD=np.std(coherAll_t, 0) corrAvg_t=np.mean(corrAll_t,0) corrSTD=np.std(corrAll_t, 0) # Plot graph of coherence and correlation values fig1 = drawmatrix_channels(coherAvg_t, roiNames, size=coherAvg_t.shape, color_anchor=0, title='Average ' +condition+ ' Coherence Results over ' +str(numRuns) + ' runs for ' + sub) fig2=drawmatrix_channels(coherSTD, roiNames, size=coherSTD.shape, color_anchor=0, title='Average ' +condition+ ' Coherence STD over ' +str(numRuns) + ' runs for ' + sub) fig3=drawmatrix_channels(corrAvg_t, roiNames, size=corrAvg_t.shape, color_anchor=0, title='Average ' +condition+ ' Correlation Results over ' +str(numRuns) + ' runs for ' + sub) fig4=drawmatrix_channels(corrSTD, roiNames, size=corrSTD.shape, color_anchor=0, title='Average ' +condition+ ' Correlation STD over ' +str(numRuns) + ' runs for ' + sub) plt.show() #Plot data for 3 streams (btw for all) titleName=condition+" coherence " #get3NetworkAvg(coherAvg_t, titleName, roiNames, numRuns) titleName=condition+" correlation " #get3NetworkAvg(corrAvg_t, titleName, roiNames, numRuns) #Plot the data for 4 groups #Define the streams r_earlyVent=[1, 2, 3] r_earlyDors=[7, 8, 9]
tmin, tmax, proj=True, picks=picks, baseline=(None, 0), preload=True, reject=dict(grad=4000e-13, eog=150e-6), ) # Export to NiTime epochs_ts = epochs.to_nitime(picks=np.arange(20), collapse=True) ############################################################################### # Now use nitime's OO-interface to compute coherence between sensors from nitime.analysis import MTCoherenceAnalyzer from nitime.viz import drawmatrix_channels import matplotlib.pyplot as plt # setup coherency analyzer C = MTCoherenceAnalyzer(epochs_ts) # confine analysis to 10 - 20 Hz freq_idx = np.where((C.frequencies > 10) * (C.frequencies < 30))[0] # compute average coherence coh = np.mean(C.coherence[:, :, freq_idx], -1) # Averaging on last dimension drawmatrix_channels(coh, epochs.ch_names, color_anchor=0, title="MEG gradiometer coherence") plt.show()
# stack the value to sum_'s stack_coh = np.dstack((stack_coh, coh)) stack_gl = np.dstack((stack_gl, gl)) stack_R = np.dstack((stack_R, R.corrcoef)) # save extracted data np.savez(os.path.join(result_dir,s,'%s_data.npz' % (s)),G,C,R,coh,gl,g2) # clear the variables coh, gl, g2, G, C, R = (None, None, None, None, None, None) # calcualte mean mean_coh = np.mean(stack_coh, axis = 2) mean_gl = np.mean(stack_gl, axis = 2) mean_R = np.mean(stack_R, axis = 2) # plot group averaged figGroup_coh = drawmatrix_channels(mean_coh, roi_names,size=[10.,10.], color_anchor=0) plt.title('Control pair-wise Coherence') plt.savefig(os.path.join(result_dir,'Control_pair_wise_coherence.png')) figGroup_gl = drawmatrix_channels(mean_gl, roi_names,size=[10.,10.], color_anchor=0) plt.title('Control pair-wise Granger Causality') plt.savefig(os.path.join(result_dir,'Control_pair_wise_granger_causality.png')) figGroup_R = drawmatrix_channels(mean_R, roi_names,size=[10.,10.], color_anchor=0) plt.title('Control pair-wise Correlation') plt.savefig(os.path.join(result_dir,'Control_pair_wise_correlation.png')) np.savez(os.path.join(result_dir,'Control_Group_average.npz'), stack_coh, stack_gl, stack_R, mean_coh, mean_gl, mean_R)
def slicesdir_connectivity_matrices(output_dir, cmat_list, dpi=150, lower_triangle=True, **kwargs): """ @param output_dir: @param file_list1: list of ndarrays List of connectivity matrices @param dpi: int Dots per inch resolution of the plot images @param lower_triangle: bool If true, will plot a lower triangle of the matrix, the full matrix otherwise. @param kwargs: arguments to show_many_slices See draw_square_matrix_channels named arguments. """ if not os.path.exists(output_dir): os.makedirs(output_dir) img_files = [] #cmap = kwargs.pop('cmap', plt.cm.rainbow) channel_names = kwargs.pop('channel_names', None) color_anchor = kwargs.pop('color_anchor', 0) size = kwargs.pop('size', [10., 10.]) #CREATE separate images of each file_list2 file # on the corresponding file_list1 file for idx in list(range(len(cmat_list))): cmat = cmat_list[idx] if lower_triangle: fig = drawmatrix_channels(cmat, channel_names, size=size, color_anchor=color_anchor, **kwargs) else: fig = draw_square_matrix_channels(cmat, channel_names, size=size, color_anchor=color_anchor, **kwargs) png_fname = 'connectivity_matrix' + str(idx) + '.png' png_path = os.path.join(output_dir, png_fname) export_figure(fig, png_path, dpi=dpi) img_files.append(os.path.basename(png_path)) plt.close() #Create the index.html file with all images create_imglist_html(output_dir, img_files) return img_files
caus_yx = G.causality_yx[:, :, sel] else: caus_xy = G.causality_xy caus_yx = G.causality_yx cutoff = False G = nta.GrangerAnalyzer(rois_ts, order=1) if cutoff: sel = np.where(G.frequencies < hf.attrs['fr'])[0] caus_xy = G.causality_xy[:, :, sel] caus_yx = G.causality_yx[:, :, sel] else: caus_xy = G.causality_xy caus_yx = G.causality_yx g1 = np.mean(caus_xy, -1) g2 = np.mean(caus_yx, -1) fig03 = drawmatrix_channels(g1, ['a', 'b'], size=[10., 10.], color_anchor=0) plt.show() fig03 = drawmatrix_channels(g2, ['a', 'b'], size=[10., 10.], color_anchor=0) plt.show() fig03 = drawmatrix_channels(g1 - g2, ['a', 'b'], size=[10., 10.], color_anchor=0) plt.show() g1 g2 def robust_viz(g, labels): from nitime.viz import drawmatrix_channels g[np.isnan(g)] = 0 drawmatrix_channels(g, labels, size=[10., 10.], color_anchor=0)
method='boxcar'), verbose=True).data # normalize='percent' # seed_ts[i_seed] = ntio.time_series_from_file(data_file, # coords=seed_coords, # TR=TR, # average=True, # verbose=True).data seed_T = ntts.TimeSeries(seed_ts, sampling_interval=TR) fig_seed_tseries = viz.plot_tseries(seed_T) plt.title('seed tseries, {}'.format(fmri_file)) seed_Cor = nta.CorrelationAnalyzer(seed_T) fig_seed_cor = viz.drawmatrix_channels(seed_Cor.corrcoef, seed_rois, color_anchor=0) plt.title('correlation, {}'.format(fmri_file)) # Get target data # initialize target time series target_ts = np.zeros((len(target_rois), n_TRs)) for i_target, target_name in enumerate(target_rois): print '\n', target_name target_file = os.path.join(roi_dir, '{}.mat'.format(target_name)) # find the coordinates of cortex voxels target_coords = tsv.upsample_coords(tsv.getROIcoords(target_file), upsample_factor) if flip_x: target_coords[0] = (volume_shape[0]-1) - (target_coords[0])
import nitime.viz reload(nitime.viz) from nitime.viz import drawmatrix_channels # This time Import the coherence analyzer from nitime.analysis import CoherenceAnalyzer # 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 = TimeSeries(data, sampling_interval=TR) T.metadata["roi"] = roi_names C = CoherenceAnalyzer(T) # We look only at frequencies between 0.02 and 0.15 (the physiologically # relevant band, see http://imaging.mrc-cbu.cam.ac.uk/imaging/DesignEfficiency: freq_idx = np.where((C.frequencies > 0.02) * (C.frequencies < 0.15))[0] # Extract the coherence and average across these frequency bands: coh = np.mean(C.coherence[:, :, freq_idx], -1) # Averaging on the last dimension drawmatrix_channels(coh, roi_names, size=[10.0, 10.0], color_anchor=0)
filter=dict(lb=f_lb, ub=f_ub, method='boxcar'), verbose=True).data # seed_ts[i_seed] = ntio.time_series_from_file(data_file, # coords=seed_coords, # TR=TR, # average=True, # verbose=True).data seed_T = ntts.TimeSeries(seed_ts, sampling_interval=TR) fig = viz.plot_tseries(seed_T) seed_Cor = nta.CorrelationAnalyzer(seed_T) fig = viz.drawmatrix_channels(seed_Cor.corrcoef, seed_rois, color_anchor=0) # Get target data # initialize target time series list target_ts = np.zeros((len(target_rois), n_TRs)) for i_target, target_name in enumerate(target_rois): print '\n', target_name, target_roi_type if target_roi_type is 'mask': target_file = os.path.join(mask_roi_dir, '{}.nii'.format(target_name)) # load roi mask target_mask = nib.load(target_file) # find the coordinates of cortex voxels
for j in range(cohMatrixNormal.shape[2]): niTS = TimeSeries(labelTsNormal[j], sampling_rate=epochs.info["sfreq"]) niTS.metadata["roi"] = labels_name C = MTCoherenceAnalyzer(niTS) # confine analysis to Aplha (8 12 Hz) freq_idx = np.where((C.frequencies > f_lw) * (C.frequencies < f_up))[0] # compute average coherence & Averaging on last dimension cohMatrixNormal[:, :, j] = np.mean(C.coherence[:, :, freq_idx], -1) # %% drawmatrix_channels(bin.astype(int), labels_name, color_anchor=0, title='MEG coherence') plt.show() # %% thresholdLeft = np.median(cohMatrixLeft[np.nonzero(cohMatrixLeft)]) \ + np.std(cohMatrixLeft[np.nonzero(cohMatrixLeft)]) binMatrixLeft = cohMatrixLeft > thresholdLeft thresholdRight = np.median(cohMatrixRight[np.nonzero(cohMatrixRight)]) \ + np.std(cohMatrixRight[np.nonzero(cohMatrixRight)]) binMatrixRight = cohMatrixRight > thresholdRight # %%
""" coh = np.mean(coh_mat[:, :, freq_idx], -1) # Averaging on the last dimension """ The next line calls the visualization routine which displays the data """ fig01 = drawmatrix_channels(coh, roi_names, size=[10., 10.], color_anchor=0, title='MTM Coherence') """ .. image:: fig/multi_taper_coh_01.png Next we perform the same analysis, using the nitime object oriented interface. We start by initializing a TimeSeries object with this data and with the sampling_interval provided above. We set the metadata 'roi' field with the ROI names.
proj=True, picks=picks, baseline=(None, 0), preload=True, reject=dict(grad=4000e-13, eog=150e-6)) # Export to NiTime epochs_ts = epochs.to_nitime(picks=np.arange(20), collapse=True) ############################################################################### # Now use nitime's OO-interface to compute coherence between sensors from nitime.analysis import MTCoherenceAnalyzer from nitime.viz import drawmatrix_channels import matplotlib.pyplot as plt # setup coherency analyzer C = MTCoherenceAnalyzer(epochs_ts) # confine analysis to 10 - 20 Hz freq_idx = np.where((C.frequencies > 10) * (C.frequencies < 30))[0] # compute average coherence coh = np.mean(C.coherence[:, :, freq_idx], -1) # Averaging on last dimension drawmatrix_channels(coh, epochs.ch_names, color_anchor=0, title='MEG gradiometer coherence') plt.show()
numRuns = allROIS.shape[1] corr_all[subject] = np.zeros((numRuns, len(rois), len(rois))) * np.nan coh_all[subject] = np.zeros((numRuns, len(rois), len(rois))) * np.nan # Get roi correlations and coherence for runNum in range(allROIS.shape[1]): #need to load timeseries by run fixTS = ts.TimeSeries(allROIS[:, runNum, :], sampling_interval=TR) fixTS.metadata['roi'] = roi_names # Get plot and correlations C = CorrelationAnalyzer(fixTS) fig01 = drawmatrix_channels(C.corrcoef, roi_names, size=[10., 10.], color_anchor=0, title='Correlation Results Run %i' % runNum) plt.show() # Save correlation corr_all[subject][runNum] = C.corrcoef # Get coherence Coh = CoherenceAnalyzer(fixTS) Coh.method['NFFT'] = NFFT Coh.method['n_overlap'] = n_overlap # Get the index for the frequencies inside the ub and lb freq_idx = np.where( (Coh.frequencies > f_lb) * (Coh.frequencies < f_ub))[0]
""" We extract the coherence and average over all these frequency bands: """ coh = np.mean(coh_mat[:, :, freq_idx], -1) # Averaging on the last dimension """ The next line calls the visualization routine which displays the data """ fig01 = drawmatrix_channels(coh, roi_names, size=[10., 10.], color_anchor=0, title='MTM Coherence') """ .. image:: fig/multi_taper_coh_01.png Next we perform the same analysis, using the nitime object oriented interface. We start by initializing a TimeSeries object with this data and with the sampling_interval provided above. We set the metadata 'roi' field with the ROI names. """
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 draw_matrix function, displaying the correlation matrix with the ROIs labeled. """ #Initialize the correlation analyzer C = CorrelationAnalyzer(T) #Display the correlation matrix fig01 = drawmatrix_channels(C.corrcoef, roi_names, size=[10., 10.], color_anchor=0) """ .. image:: fig/resting_state_fmri_01.png Notice that setting the color_anchor input to this function to 0 makes sure that the center of the color map (here a blue => white => red) is at 0. In this case, positive values will be displayed as red and negative values in blue. We notice that the left caudate nucleus (labeled 'lcau') has an interesting pattern of correlations. It has a high correlation with both the left putamen ('lput', which is located nearby) and also with the right caudate nucleus ('lcau'), which is the homologous region in the other hemisphere. Are these two correlation values related to each other? The right caudate and left putamen
#This information (the sampling rate) has to be known in advance: TR=1.89 #Load the data from the csv file: data_rec = csv2rec('data/fmri_timeseries.csv') #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) #Initialize the time-series from the normalized data: T = TimeSeries(data,sampling_interval=TR) T.metadata['roi'] = roi_names #Initialize the correlation analyzer C = CorrelationAnalyzer(T) #Display the correlation matrix drawmatrix_channels(C(),roi_names,size=[10.,10.],color_anchor=0)