Estimation for many voxels at the same time

We often want to fit the same design to many different voxels.

Let’s make a design with a linear trend and a constant term:

import numpy as np
import matplotlib.pyplot as plt
# Print arrays to 2 decimal places
np.set_printoptions(precision=2)

X = np.ones((12, 2))
X[:, 0] = np.linspace(-1, 1, 12)
plt.imshow(X, cmap='gray')

<matplotlib.image.AxesImage at 0x7fd58af1e3e0>

To fit this design to any data, we take the pseudo-inverse:

import numpy.linalg as npl
piX = npl.pinv(X)
piX

array([[-0.21, -0.17, -0.13, -0.1 , -0.06, -0.02,  0.02,  0.06,  0.1 ,
         0.13,  0.17,  0.21],
       [ 0.08,  0.08,  0.08,  0.08,  0.08,  0.08,  0.08,  0.08,  0.08,
         0.08,  0.08,  0.08]])

Notice the shape of the pseudo-inverse:

piX.shape

(2, 12)

Now let’s make some data to fit to. We will draw some samples from the standard normal distribution.

# Random number generator.
rng = np.random.default_rng()
# 12 random numbers from normal distribution, mean 0, std 1.
y_0 = rng.normal(size=12)
y_0

array([ 0.56,  0.95,  0.7 , -0.1 , -0.25, -0.19, -0.76,  0.92,  0.87,
       -0.86, -0.13, -2.05])

beta_0 = piX @ y_0
beta_0

array([-0.8 , -0.03])

We can fit this same design to another set of data, using our already-calculated pseudo-inverse.

y_1 = rng.normal(size=12)
y_1

array([ 0.99,  1.62,  0.31,  1.5 ,  0.21,  0.87,  0.32,  2.4 ,  0.49,
       -0.12,  2.35,  0.5 ])

beta_1 = piX @ y_1
beta_1

array([-0.02,  0.95])

And another!:

y_2 = rng.normal(size=12)
beta_2 = piX @ y_2
beta_2

array([-0.35, -0.38])

Now the trick. Because of the way that matrix multiplication works, we can fit to these three sets of data with the one single matrix multiply:

# Stack the data vectors into columns in a 2D array.
Y = np.stack([y_0, y_1, y_2], axis=1)
Y

array([[ 0.56,  0.99, -1.81],
       [ 0.95,  1.62, -0.02],
       [ 0.7 ,  0.31,  0.08],
       [-0.1 ,  1.5 ,  0.12],
       [-0.25,  0.21, -0.23],
       [-0.19,  0.87, -0.4 ],
       [-0.76,  0.32,  2.18],
       [ 0.92,  2.4 ,  1.18],
       [ 0.87,  0.49, -1.51],
       [-0.86, -0.12, -1.06],
       [-0.13,  2.35, -2.24],
       [-2.05,  0.5 , -0.82]])

betas = piX @ Y
betas

array([[-0.8 , -0.02, -0.35],
       [-0.03,  0.95, -0.38]])

Notice some features of the betas array:

• There is one row per column in the design X.

• There is one column per column in the data Y.

• The first row of betas contains the parameters corresponding to the first column of the design. The first row therefore contains the slope parameters.

• The second row contains the parameters corresponding to the second column of the design. The second row therefore contains the intercept parameters.

• The first column of betas contains the slope, intercept for the first data vector y_0.

Of course this trick will work for any number of columns of Y.

This trick is important because it allows us to estimate the same design on huge number of data vectors very efficiently. In imaging, this is useful because we can arrange our image data in a one row per volume, one column per voxel array, and use technique here for very fast estimation.