# Convolving with the hemodyamic response function¶

>>> import numpy as np  # the Python array package
>>> import matplotlib.pyplot as plt  # the Python plotting package


## Using scipy¶

Scipy is a large library of scientific routines that builds on top of numpy.

You can think of numpy as being a subset of MATLAB, and numpy + scipy as being as being roughly equivalent to MATLAB plus the MATLAB toolboxes.

Scipy has many sub-packages, for doing things like reading MATLAB .mat files (scipy.io) or working with sparse matrices (scipy.sparse). We are going to be using the functions and objects for working with statistical distributions in scipy.stats:

>>> import scipy.stats


scipy.stats contains objects for working with many different distributions. We are going to be working with scipy.stats.gamma, which implements the gamma distribution.

>>> from scipy.stats import gamma


In particular we are interested in the probability density function (PDF) of the gamma distribution.

Because this is a function, we need to pass it an array of values at which it will evaluate.

We can also pass various parameters which change the shape, location and width of the gamma PDF. The most important is the first parameter (after the input array) known as the shape parameter ($$k$$ in the wikipedia page on gamma distributions).

First we chose some x values at which to sample from the gamma PDF:

>>> x = np.arange(0, 25, 0.1)


Next we plot the gamma PDF for shape values of 2, 4, 8, 12.

>>> plt.plot(x, gamma.pdf(x, 2), label='k=2')
[...]
>>> plt.plot(x, gamma.pdf(x, 4), label='k=4')
[...]
>>> plt.plot(x, gamma.pdf(x, 8), label='k=8')
[...]
>>> plt.plot(x, gamma.pdf(x, 12), label='k=12')
[...]
>>> plt.legend()
<...>


(png, hires.png, pdf)

## Constructing a hemodynamic response function¶

We can use these gamma functions to construct a continuous function that is close to the hemodynamic response we observe for a single brief event in the brain.

Our function will accept an array that gives the times we want to calculate the HRF for, and returns the values of the HRF for those times. We will assume that the true HRF starts at zero, and gets to zero sometime before 35 seconds.

We’re going to try using the sum of two gamma distribution probability density functions.

Here is one example of such a function:

>>> def hrf(times):
...     """ Return values for HRF at given times """
...     # Gamma pdf for the peak
...     peak_values = gamma.pdf(times, 6)
...     # Gamma pdf for the undershoot
...     undershoot_values = gamma.pdf(times, 12)
...     # Combine them
...     values = peak_values - 0.35 * undershoot_values
...     # Scale max to 0.6
...     return values / np.max(values) * 0.6

>>> plt.plot(x, hrf(x))
[...]
>>> plt.xlabel('time')
<...>
>>> plt.ylabel('HRF model of signal')
<...>


(png, hires.png, pdf)

We can sample from the function, to get the estimates at the times of our TRs. Remember, the TR is 2.5 for our example data, meaning the scans were 2.5 seconds apart.

>>> TR = 2.5
>>> tr_times = np.arange(0, 30, TR)
>>> hrf_at_trs = hrf(tr_times)
>>> len(hrf_at_trs)
12
>>> plt.plot(tr_times, hrf_at_trs)
[...]
>>> plt.xlabel('time')
<...>
>>> plt.ylabel('HRF sampled every 2.5 seconds')
<...>


(png, hires.png, pdf)

We can use this to convolve our neural (on-off) prediction. This will give us a hemodynamic prediction, under the linear-time-invariant assumptions of the convolution:

>>> from stimuli import events2neural
>>> n_vols = 173
>>> neural_prediction = events2neural('ds114_sub009_t2r1_cond.txt',
...                                   TR, n_vols)
>>> all_tr_times = np.arange(173) * TR
>>> plt.plot(all_tr_times, neural_prediction)
[...]


(png, hires.png, pdf)

When we convolve, the output is length N + M-1, where N is the number of values in the vector we convolved, and M is the length of the convolution kernel (hrf_at_trs in our case). For a reminder of why this is, see the tutorial on convolution.

>>> convolved = np.convolve(neural_prediction, hrf_at_trs)
>>> N = len(neural_prediction)  # M == n_vols == 173
>>> M = len(hrf_at_trs)  # M == 12
>>> len(convolved) == N + M - 1
True


This is because of the HRF convolution kernel falling off the end of the input vector. The value at index 172 in the new vector refers to time 172 * 2.5 = 430.0 seconds, and value at index 173 refers to time 432.5 seconds, which is just after the end of the scanning run. To retain only the values in the new hemodynamic vector that refer to times up to (and including) 430s, we can just drop the last len(hrf_at_trs) - 1 == M - 1 values:

>>> n_to_remove = len(hrf_at_trs) - 1
>>> convolved = convolved[:-n_to_remove]

>>> plt.plot(all_tr_times, neural_prediction)
[...]
>>> plt.plot(all_tr_times, convolved)
[...]


(png, hires.png, pdf)

## Saving 1D and 2D arrays as text¶

We have so far seen floating point numbers in this kind of format in text files : 314.15926. It is common for numpy and MATLAB to write floating point numbers in exponential format, like this 3.1415926e02. You can read this as meaning 3.1415926 * 10**2 == 3.1415926 * 100 == 314.15926. Both np.loadtxt and the float function will happily convert these to floating point values in memory:

>>> float('2.2e02')
220.0


This is also the default format that np.savetxt uses. For example, let’s save our convolved time course:

>>> np.savetxt('ds114_sub009_t2r1_conv.txt', convolved)
>>> np.allclose(convolved, back)
True


Why might the saved, reloaded numbers not be exactly the same?

>>> fobj = open('ds114_sub009_t2r1_conv.txt', 'rt')
>>> fobj.close()
>>> len(lines)
173
>>> for line in lines[:10]:
...     print(line.strip())
0.000000000000000000e+00
0.000000000000000000e+00
0.000000000000000000e+00
0.000000000000000000e+00
0.000000000000000000e+00
2.321802309091016703e-01
8.321802309091016481e-01
1.141223007348432184e+00
1.134358594322657066e+00
1.035057581311021879e+00