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()
