Neurodesign (tutorial)

Neurodesign (tutorial)

In the previous tutorial, you have seen that jittered-ISI designs display quite some variance in efficiency (ranging from approx. 2.3 tot 3.1). This shows you that there are very many different designs possible, even with only two conditions, each associated with its own efficiency. Ideally, we want the best design (i.e., most efficient) out of all the possible designs. This is, however, for many (slightly more complex) designs not possible, because you would need to simulate billions of designs to exhaustively test them all! Moreover, we have also seen that high statistical efficiency (long blocked designs) may also have unwanted psychological effects (predictability, boredom).

So, how then should we look for (psychologically and statistically) efficient designs in the space of all possible designs? Fortunately, there exist methods to intelligently “search” for the optimal design among all possible designs without having to test them all and that allow you to define a balance between different aspects of your desired design.

Many different packages exist that implement this type of “design optimisation” (like optseq2, and the MATLAB toolbox by Kao). Here, we will give a short demonstration of the “neurodesign” toolbox; neurodesign is a Python package, but they offer also a web interface. Here, we will briefly walk you through the package. (Note that we use a slightly modified version of the original that works with Python3, which you can download here.)

import os
# Neurodesigninternally paralellizes some computations using multithreading,
# which is a massive burden on the CPU. So let's limit the number of threads
os.environ["OMP_NUM_THREADS"] = "1"
os.environ["OPENBLAS_NUM_THREADS"] = "1"
os.environ["MKL_NUM_THREADS"] = "1"

import numpy as np  # we'll also need Numpy
import neurodesign

The neurodesign package contains two important Python classes: the experiment class and the optimisation class. In the experiment class you define the most important parameters of your experiment.

First, we have to define the intended functional scan’s TR (let’s choose 1.6) and the expected degree of autocorrelation, rho, in the BOLD signal (we’ll discuss this in more detail next week; let’s set it to 0.6).

TR = 1.6
rho = 0.6

Now, more importantly, we have to define parameters related to the experimental conditions:

  • n_stimuli: the number of different stimulus conditions;

  • n_trials: the number of different stimulus presentations per condition;

  • duration: the duration of the experimental run (you can choose to set either n_trials or duration);

  • stim_duration: the duration of each stimulus;

  • P: the probability of occurring for each condition (e.g., [0.5, 0.5] for 50/50);

  • t_pre: the time before the stimulus within each trial (e.g., fixation cross);

  • t_post: the time after the stimulus within each trial (e.g., fixation cross; see image below);

Image from the neurodesign preprint from Biorxiv

Now, let’s assume we our experiment is a simple “functional localizer”, in which we want to find brain regions that respond more strongly to faces than to houses. Now, we want those to conditions to occur equally often and have a stimulus duration of 2 seconds. We assume that we don’t want runs longer than 5 minutes (otherwise the participant might lose focus/fall asleep), so we’ll set the duration instead of the n_trials parameter. And we assume that there is a pre and post trial time of 0.1 seconds.

n_stimuli = 2
stim_duration = 1
duration = 5*60
P = [0.5, 0.5]
t_pre = 0.1
t_post = 0.1

Now, we have to define how neurodesign should create intertrial intervals (ITIs), the time between the offset of the previous trial and the onset of the next trial. In this package, you can specify a specific distribution and associated parameters from which these ITIs should be drawn (ITImodel). You can choose from "fixed", "uniform", and "exponential". Let’s pick "uniform" here, with a minimum ITI (ITImin) of 0.1 seconds and a maximum ITI (ITImax) of 8 seconds.

ITImodel = "uniform"
ITImin = 2
ITImax = 4

Lastly, we need to define the contrast(s) that we want to test (C). Let’s assume we want to test both “faces > houses” and “houses > faces”.

C = np.array([
    [1, -1],
    [-1, 1]
]) 

Now, with these parameters, let’s create an experiment object!

exp = neurodesign.experiment(
    TR=TR,
    rho=rho,
    n_stimuli=n_stimuli,
    stim_duration=stim_duration,
    P=P,
    duration=duration,
    t_pre=t_pre,
    t_post=t_post,
    ITImodel=ITImodel,
    ITImin=ITImin,
    ITImax=ITImax,
    C=C
)

Alright, now we need to create the optimisation object! This object defines how the experiment will be optimised. Neurodesign uses a “genetic algorithm” to efficiently look for the most efficient designs within the vast set of all possible designs, inspired by the way biological evolution works. We won’t go into the specifics of the algorithm.

The weights parameter of the optimisation class is very important: this allows you to balance different statistical and psychological aspects of your design. There are four aspects that can be optimized:

  • \(F_{e}\): the estimation efficiency (when you want to investigate the entire shape of the HRF);

  • \(F_{d}\): the detection efficiency (when you are only interested in amplitude changes/differences);

  • \(F_{f}\): how close the frequency of each condition is to the desired probability (given by P in the experiment object);

  • \(F_{c}\): how well the conditions are “counterbalanced” in time. “Counterbalancing”, here, means that trying to make sure that each trial (\(n\)) has an equal probability to be followed by any condition (e.g., 50% condition A, 50% condition B for trial \(n+1\)), which can be extended to trials further in the future (\(n+2, n+3\), etc.). You can think of this parameter reflecting “predictability” (higher = less predictable).

Given that we’re only interested in detecting the difference between faces and houses, let’s set the weight for \(F_{d}\) to 1 and the rest to zero. Also, let’s tell neurodesign to save the best 10 designs (instead of only the very best) by setting the parameter outdes to 10. The other parameters (preruncycles, cycles, seed) are not important for now (but know that setting cycles, the number of iteration the algorithm runs for, to a higher number will increase the time it takes to run).

weights = [0, 1, 0, 0]  # order: Fe, Fd, Ff, Fc
outdes = 10

opt = neurodesign.optimisation(
    experiment=exp,  # we have to give our previously created `exp` object to this class as well
    weights=weights,
    preruncycles=10,
    cycles=1,
    seed=2,
    outdes=outdes
)

Now we can start the algorithm by calling the optimize method from the opt variable (this may take 5 minutes or so).

opt.optimise()
<neurodesign.classes.optimisation at 0x7f4b34c27850>

Lastly, call the evaluate method to finalize the optimization run:

opt.evaluate()
<neurodesign.classes.optimisation at 0x7f4b34c27850>

We can inspect the opt object, which now contains an attribute, bestdesign, that gives us the onsets (.onsets) and order (.order) of the best design found by the algorithm.

print("Onsets: %s" % (opt.bestdesign.onsets,), end='\n\n')
print("Order: %s" % (opt.bestdesign.order,))
Onsets: [  0.    3.9   7.4  11.6  16.3  19.9  23.8  27.2  31.3  34.7  38.3  41.6
  46.1  49.4  53.1  57.   61.7  65.2  69.6  74.5  78.7  83.9  87.5  92.4
  96.4  99.8 103.5 106.8 110.2 114.4 119.6 123.7 127.7 132.8 136.7 140.5
 145.5 149.1 152.4 155.7 160.3 164.6 169.3 173.9 178.7 182.  185.6 190.
 193.8 197.5 201.3 206.3 209.9 214.1 219.2 222.5 225.9 230.4 235.2 240.
 244.9 249.1 253.3 256.8 261.2 266.  269.5 273.1 277.9 282.3 286. ]

Order: [1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1]

We even have access to the HRF-convolved design (Xconv; we’ll plot the onsets on top):

import matplotlib.pyplot as plt
%matplotlib inline

Xconv = opt.bestdesign.Xconv

plt.figure(figsize=(15, 5))
plt.plot(Xconv)
for ons, cond in zip(opt.bestdesign.onsets, opt.bestdesign.order):
    c = 'tab:blue' if cond == 0 else 'tab:orange'
    plt.plot([ons, ons], [0.35, 0.37], c=c, lw=2)
    
plt.legend(['Faces', 'Houses'])
plt.grid()
plt.xlim(0, Xconv.shape[0])
plt.show()
../../_images/neurodesign_21_0.png
ToDo (0 points): Try changing the weights for the optimisation object and rerun the optimisation procedure. Plot the Xconv attribute of the resulting bestdesign. How does it differ from just optimizing detection efficiency?
""" Try the ToDo here. """
' Try the ToDo here. '