def test_show_design_matrix(): # test that the show code indeed (formally) runs frame_times = np.linspace(0, 127 * 1., 128) dmtx = make_first_level_design_matrix( frame_times, drift_model='polynomial', drift_order=3) ax = plot_design_matrix(dmtx) assert (ax is not None) with InTemporaryDirectory(): ax = plot_design_matrix(dmtx, output_file='dmtx.png') assert os.path.exists('dmtx.png') assert (ax is None) plot_design_matrix(dmtx, output_file='dmtx.pdf') assert os.path.exists('dmtx.pdf')
def _dmtx_to_svg_url(design_matrices): """ Accepts a FirstLevelModel or SecondLevelModel object with fitted design matrices & generates SVG Image URL, which can be inserted into an HTML template. Parameters ---------- design_matrices: List[pd.Dataframe] Design matrices computed in the model. Returns ------- svg_url_design_matrices: String SVG Image URL for the plotted design matrices, """ html_design_matrices = [] dmtx_template_path = os.path.join(HTML_TEMPLATE_ROOT_PATH, 'design_matrix_template.html') with open(dmtx_template_path) as html_template_obj: dmtx_template_text = html_template_obj.read() for dmtx_count, design_matrix in enumerate(design_matrices, start=1): dmtx_text_ = string.Template(dmtx_template_text) dmtx_plot = plot_design_matrix(design_matrix) dmtx_title = 'Session {}'.format(dmtx_count) plt.title(dmtx_title, y=0.987) dmtx_plot = _resize_plot_inches(dmtx_plot, height_change=.3) url_design_matrix_svg = plot_to_svg(dmtx_plot) # prevents sphinx-gallery & jupyter from scraping & inserting plots plt.close() dmtx_text_ = dmtx_text_.safe_substitute({ 'design_matrix': url_design_matrix_svg, 'dmtx_title': dmtx_title, }) html_design_matrices.append(dmtx_text_) svg_url_design_matrices = ''.join(html_design_matrices) return svg_url_design_matrices
# say that the hrf is an arbitrary function that lags behind the # stimulus onset. In the present case, given that the numbers of # conditions is high, we should use a simple FIR model. # # Concretely, we set `hrf_model` to 'fir' and `fir_delays` to [1, 2, # 3] (scans) corresponding to a 3-step functions on the [1 * t_r, 4 * # t_r] seconds interval. # from nilearn.glm.first_level import FirstLevelModel from nilearn.reporting import plot_design_matrix, plot_contrast_matrix first_level_model = FirstLevelModel(t_r, hrf_model='fir', fir_delays=[1, 2, 3]) first_level_model = first_level_model.fit(fmri_img, events=events) design_matrix = first_level_model.design_matrices_[0] plot_design_matrix(design_matrix) ######################################################################### # We have to adapt contrast specification. We characterize the BOLD # response by the sum across the three time lags. It's a bit hairy, # sorry, but this is the price to pay for flexibility... import numpy as np contrast_matrix = np.eye(design_matrix.shape[1]) contrasts = dict([(column, contrast_matrix[i]) for i, column in enumerate(design_matrix.columns)]) conditions = events.trial_type.unique() for condition in conditions: contrasts[condition] = np.sum([ contrasts[name]
raw.plot(duration=300, show_scrollbars=False) ############################################################################### # Create design matrix # ------------------------------------ # # Next we create a design matrix based on the annotation times in the simulated # data. We use the nilearn plotting function to visualise the design matrix. # For more details on this procedure see :ref:`tut-fnirs-hrf`. design_matrix = make_first_level_design_matrix(raw, stim_dur=5.0, drift_order=1, drift_model='polynomial') fig, ax1 = plt.subplots(figsize=(10, 6), nrows=1, ncols=1) fig = plot_design_matrix(design_matrix, ax=ax1) ############################################################################### # Estimate response on clean data # ------------------------------- # # Here we run the GLM analysis on the clean data. # The design matrix had three columns, so we get an estimate for our simulated # event, the first order drift, and the constant. # We see that the estimate of the first component is 4e-6 (4 uM), # which was the amplitude we used in the simulation. # We also see that the mean square error of the model fit is close to zero. glm_est = run_GLM(raw, design_matrix) print("Estimate:", glm_est['Simulated'].theta[0], " MSE:",
high_pass=.01) ############################################################################### # Now that we have specified the model, we can run it on the fMRI image fmri_glm = fmri_glm.fit(fmri_img, events) ############################################################################### # One can inspect the design matrix (rows represent time, and # columns contain the predictors). design_matrix = fmri_glm.design_matrices_[0] ############################################################################### # Formally, we have taken the first design matrix, because the model is # implictily meant to for multiple runs. from nilearn.reporting import plot_design_matrix plot_design_matrix(design_matrix) import matplotlib.pyplot as plt plt.show() ############################################################################### # Save the design matrix image to disk # first create a directory where you want to write the images import os outdir = 'results' if not os.path.exists(outdir): os.mkdir(outdir) from os.path import join plot_design_matrix( design_matrix, output_file=join(outdir, 'design_matrix.png'))
######################################################################### # Then we sample the design matrix. X2 = make_first_level_design_matrix(frame_times, events, drift_model='polynomial', drift_order=3, hrf_model=hrf_model) ######################################################################### # Finally we compute a FIR model events = pd.DataFrame({'trial_type': conditions, 'onset': onsets, 'duration': duration}) hrf_model = 'FIR' X3 = make_first_level_design_matrix(frame_times, events, hrf_model='fir', drift_model='polynomial', drift_order=3, fir_delays=np.arange(1, 6)) ######################################################################### # Here are the three designs side by side. from nilearn.reporting import plot_design_matrix fig, (ax1, ax2, ax3) = plt.subplots(figsize=(10, 6), nrows=1, ncols=3) plot_design_matrix(X1, ax=ax1) ax1.set_title('Event-related design matrix', fontsize=12) plot_design_matrix(X2, ax=ax2) ax2.set_title('Block design matrix', fontsize=12) plot_design_matrix(X3, ax=ax3) ax3.set_title('FIR design matrix', fontsize=12) ######################################################################### # Let's improve the layout and show the result. plt.subplots_adjust(left=0.08, top=0.9, bottom=0.21, right=0.96, wspace=0.3) plt.show()