def _convolve_regressors(events,
hrf_model,
frame_times,
fir_delays=[0],
min_onset=-24,
oversampling=50):
""" Creation of a matrix that comprises
the convolution of the conditions onset with a certain hrf model
Parameters
----------
events : DataFrame instance,
Events data describing the experimental paradigm
see nistats.experimental_paradigm to check the specification
for these to be valid paradigm descriptors
hrf_model : {'spm', 'spm + derivative', 'spm + derivative + dispersion',
'glover', 'glover + derivative', 'glover + derivative + dispersion',
'fir', None}
String that specifies the hemodynamic response function
frame_times : array of shape (n_scans,)
The targeted timing for the design matrix.
fir_delays : array-like of shape (n_onsets,), optional,
In case of FIR design, yields the array of delays
used in the FIR model (in scans).
min_onset : float, optional (default: -24),
Minimal onset relative to frame_times[0] (in seconds) events
that start before frame_times[0] + min_onset are not considered.
oversampling: int optional, default:50,
Oversampling factor used in temporal convolutions.
Returns
-------
regressor_matrix : array of shape (n_scans, n_regressors),
Contains the convolved regressors associated with the
experimental conditions.
regressor_names : list of strings,
The regressor names, that depend on the hrf model used
if 'glover' or 'spm' then this is identical to the input names
if 'glover + derivative' or 'spm + derivative', a second name is output
i.e. '#name_derivative'
if 'spm + derivative + dispersion' or
'glover + derivative + dispersion',
a third name is used, i.e. '#name_dispersion'
if 'fir', the regressos are numbered accoding to '#name_#delay'
"""
regressor_names = []
regressor_matrix = None
trial_type, onset, duration, modulation = check_events(events)
for condition in np.unique(trial_type):
condition_mask = (trial_type == condition)
exp_condition = (onset[condition_mask], duration[condition_mask],
modulation[condition_mask])
reg, names = compute_regressor(exp_condition,
hrf_model,
frame_times,
con_id=condition,
fir_delays=fir_delays,
oversampling=oversampling,
min_onset=min_onset)
regressor_names += names
if regressor_matrix is None:
regressor_matrix = reg
else:
regressor_matrix = np.hstack((regressor_matrix, reg))
return regressor_matrix, regressor_names
def create_design_matrix(tr,
frame_times,
events,
hrf_model='kay',
hrf_idx=None):
""" Creates a design matrix based on a HRF from Kendrick Kay's set
or a default one from Nilearn. """
# This is to keep oversampling consistent across hrf_models
hrf_oversampling = 10
design_oversampling = tr / (0.1 / hrf_oversampling)
if hrf_model != 'kay': # just use Nilearn!
return make_first_level_design_matrix(frame_times,
events,
drift_model=None,
min_onset=0,
oversampling=design_oversampling,
hrf_model=hrf_model)
if hrf_model == 'kay':
if hrf_idx is None: # 20 different DMs (based on different HRFs)
to_iter = range(HRFS_HR.shape[1])
else: # use the supplied HRF idx (e.g., 5)
to_iter = [hrf_idx]
dms = [] # will store all design matrices
for hrf_idx in to_iter: # iterate across all HRFs
hrf = HRFS_HR[:, hrf_idx]
# scale HRF to have the same max as the glover HRF
# makes comparison easier
hrf /= (hrf.max() / 0.249007)
# Get info
trial_type, onset, duration, modulation = check_events(events)
# Pre-allocate design matrix; note: columns are alphabetically sorted
X = np.zeros((frame_times.size, np.unique(trial_type).size))
uniq_trial_types = np.unique(trial_type) # this is sorted
# Create separate regressor for each unique trial type
# Code copied from Nilearn glm module
for i, condition in enumerate(uniq_trial_types):
condition_mask = (trial_type == condition)
exp_condition = (onset[condition_mask],
duration[condition_mask],
modulation[condition_mask])
# Create high resolution regressor/frame times
hr_regressor, hr_frame_times = _sample_condition(
exp_condition, frame_times, design_oversampling, 0)
# Convolve with HRF and downsample
conv_reg = np.convolve(hr_regressor, hrf)[:hr_regressor.size]
# linear interpolation for now ...
f = interp1d(hr_frame_times, conv_reg)
X[:, i] = f(frame_times).T
# Note to self: do not scale such that max(X, axis=0) is 1, because you'll lose info
# about predictor variance!
dm = pd.DataFrame(X, columns=uniq_trial_types, index=frame_times)
dm['constant'] = 1 # and intercept/constant
dms.append(dm)
if len(dms) == 1:
# Just return single design matrix
dms = dms[0]
return dms