Note
Go to the end to download the full example code.
Decoding of stimuli from neural data¶
- Here we will simulate neural data given a ground truth encoding model
and try to decode the stimulus from the data.
# Set up a neural model
from braincoder.models import GaussianPRF
import numpy as np
import pandas as pd
import scipy.stats as ss
# Set up 100 random of PRF parameters
n = 20
n_trials = 50
noise = 1.
mu = np.random.rand(n) * 100
sd = np.random.rand(n) * 45 + 5
amplitude = np.random.rand(n) * 5
baseline = np.random.rand(n) * 2 - 1
parameters = pd.DataFrame({'mu':mu, 'sd':sd, 'amplitude':amplitude, 'baseline':baseline})
# We have a paradigm of random numbers between 0 and 100
paradigm = np.ceil(np.random.rand(n_trials) * 100)
model = GaussianPRF()
data = model.simulate(paradigm, parameters, noise=noise)
# Now we fit back the PRF parameters
from braincoder.optimize import ParameterFitter, ResidualFitter
fitter = ParameterFitter(model, data, paradigm)
mu_grid = np.arange(0, 100, 5)
sd_grid = np.arange(5, 50, 5)
grid_pars = fitter.fit_grid(mu_grid, sd_grid, [1.0], [0.0], use_correlation_cost=True, progressbar=False)
grid_pars = fitter.refine_baseline_and_amplitude(grid_pars)
for par in ['mu', 'sd', 'amplitude', 'baseline']:
print(f'Correlation grid-fitted parameter and ground truth for *{par}*: {ss.pearsonr(grid_pars[par], parameters[par])[0]:0.2f}')
gd_pars = fitter.fit(init_pars=grid_pars, progressbar=False)
for par in ['mu', 'sd', 'amplitude', 'baseline']:
print(f'Correlation gradient descent-fitted parameter and ground truth for *{par}*: {ss.pearsonr(grid_pars[par], parameters[par])[0]:0.2f}')
0%| | 0/1 [00:00<?, ?it/s]
100%|██████████| 1/1 [00:00<00:00, 312.01it/s]
Correlation grid-fitted parameter and ground truth for *mu*: 0.97
Correlation grid-fitted parameter and ground truth for *sd*: 0.66
Correlation grid-fitted parameter and ground truth for *amplitude*: 0.91
Correlation grid-fitted parameter and ground truth for *baseline*: 0.84
Correlation gradient descent-fitted parameter and ground truth for *mu*: 0.97
Correlation gradient descent-fitted parameter and ground truth for *sd*: 0.66
Correlation gradient descent-fitted parameter and ground truth for *amplitude*: 0.91
Correlation gradient descent-fitted parameter and ground truth for *baseline*: 0.84
# Now we fit the covariance matrix
stimulus_range = np.arange(1, 100).astype(np.float32)
resid_fitter = ResidualFitter(model, data, paradigm, gd_pars)
omega, dof = resid_fitter.fit(stimulus_range=stimulus_range, progressbar=False)
WWT max: 1448.0950927734375
# Now we simulate unseen test data:
test_paradigm = np.ceil(np.random.rand(n_trials) * 100)
test_data = model.simulate(test_paradigm, parameters, noise=noise)
# And decode the test paradigm
posterior = model.get_stimulus_pdf(test_data, stimulus_range, gd_pars, omega=omega, dof=dof)
# Rename the row index so it doesn't clash with the column index (both default to 'stimulus')
posterior.index.name = 'frame'
# Finally, we make some plots to see how well the decoder did
import matplotlib.pyplot as plt
import seaborn as sns
tmp = posterior.set_index(pd.Series(test_paradigm, name='ground truth'), append=True).loc[:8].stack().to_frame('p')
g = sns.FacetGrid(tmp.reset_index(), col='frame', col_wrap=3)
g.map(plt.plot, 'stimulus', 'p', color='k')
def test(data, **kwargs):
plt.axvline(data.mean(), c='k', ls='--', **kwargs)
g.map(test, 'ground truth')
g.set(xlabel='Stimulus value', ylabel='Posterior probability density')

<seaborn.axisgrid.FacetGrid object at 0x1762f3fb0>
# Let's look at the summary statistics of the posteriors posteriors
def get_posterior_stats(posterior, normalize=True):
posterior = posterior.copy()
posterior = posterior.div(np.trapezoid(posterior, posterior.columns,axis=1), axis=0)
# Take integral over the posterior to get to the expectation (mean posterior)
E = np.trapezoid(posterior*posterior.columns.values[np.newaxis,:], posterior.columns, axis=1)
# Take the integral over the posterior to get the expectation of the distance to the
# mean posterior (i.e., standard deviation)
sd = np.trapezoid(np.abs(E[:, np.newaxis] - posterior.columns.astype(float).values[np.newaxis, :]) * posterior, posterior.columns, axis=1)
stats = pd.DataFrame({'E':E, 'sd':sd}, index=posterior.index)
return stats
posterior_stats = get_posterior_stats(posterior)
# Let's see how far the posterior mean is from the ground truth
plt.errorbar(test_paradigm, posterior_stats['E'],posterior_stats['sd'], fmt='o',)
plt.plot([0, 100], [0,100], c='k', ls='--')
plt.xlabel('Ground truth')
plt.ylabel('Mean posterior')
# Let's see how the error depends on the standard deviation of the posterior
error = test_paradigm - posterior_stats['E']
error_abs = np.abs(error)
error_abs.name = 'error'
sns.lmplot(x='sd', y='error', data=posterior_stats.join(error_abs))
plt.xlabel('Standard deviation of posterior')
plt.ylabel('Objective error')
Text(29.0, 0.5, 'Objective error')
# Now, let's try to find the MAP estimate using gradient descent
from braincoder.optimize import StimulusFitter
stimulus_fitter = StimulusFitter(model=model, data=test_data, omega=omega, parameters=gd_pars)
# We start with a very coarse grid search, so we are sure we are in the right ballpark
estimated_stimuli_grid = stimulus_fitter.fit_grid(np.arange(1, 100, 5))
# We can then refine the estimate using gradient descent
estimated_stimuli_gd = stimulus_fitter.fit(init_pars=estimated_stimuli_grid, progressbar=False)
# Let's see how well we did
plt.scatter(test_paradigm, estimated_stimuli_grid, alpha=.5, label='MAP (grid search)')
plt.scatter(test_paradigm, estimated_stimuli_gd, alpha=.5, label='MAP (gradient descent)')
plt.scatter(test_paradigm, posterior_stats['E'], alpha=.5, label='Mean posterior')
plt.plot([0, 100], [0,100], c='k', ls='--', label='Identity line')
plt.legend()
# %%

0%| | 0/1000 [00:00<?, ?it/s]
0%| | 1/1000 [00:00<01:40, 9.91it/s]
4%|▍ | 41/1000 [00:00<00:04, 236.32it/s]
8%|▊ | 81/1000 [00:00<00:02, 306.61it/s]
11%|█▏ | 113/1000 [00:00<00:02, 310.87it/s]
15%|█▍ | 146/1000 [00:00<00:02, 316.73it/s]
18%|█▊ | 180/1000 [00:00<00:02, 322.18it/s]
22%|██▏ | 217/1000 [00:00<00:02, 334.86it/s]
25%|██▌ | 254/1000 [00:00<00:02, 344.41it/s]
29%|██▉ | 293/1000 [00:00<00:01, 357.22it/s]
33%|███▎ | 334/1000 [00:01<00:01, 370.48it/s]
37%|███▋ | 372/1000 [00:01<00:01, 368.75it/s]
41%|████ | 412/1000 [00:01<00:01, 377.32it/s]
45%|████▌ | 451/1000 [00:01<00:01, 380.11it/s]
49%|████▉ | 491/1000 [00:01<00:01, 385.49it/s]
53%|█████▎ | 531/1000 [00:01<00:01, 388.78it/s]
57%|█████▋ | 571/1000 [00:01<00:01, 390.06it/s]
61%|██████ | 612/1000 [00:01<00:00, 393.22it/s]
65%|██████▌ | 653/1000 [00:01<00:00, 395.77it/s]
69%|██████▉ | 694/1000 [00:01<00:00, 397.14it/s]
73%|███████▎ | 734/1000 [00:02<00:00, 392.67it/s]
78%|███████▊ | 775/1000 [00:02<00:00, 394.86it/s]
82%|████████▏ | 815/1000 [00:02<00:00, 396.17it/s]
86%|████████▌ | 855/1000 [00:02<00:00, 397.22it/s]
90%|████████▉ | 895/1000 [00:02<00:00, 396.44it/s]
94%|█████████▎| 935/1000 [00:02<00:00, 395.78it/s]
98%|█████████▊| 976/1000 [00:02<00:00, 397.21it/s]
100%|██████████| 1000/1000 [00:02<00:00, 369.74it/s]
<matplotlib.legend.Legend object at 0x17645c230>
Total running time of the script: (0 minutes 20.973 seconds)

