braincoder 0.7.1__py3-none-any.whl
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- braincoder/__init__.py +27 -0
- braincoder/barstimuli.py +569 -0
- braincoder/data/szinte2024/dm_gazecenter.npz +0 -0
- braincoder/data/szinte2024/gauss_parameters.tsv +2366 -0
- braincoder/data/szinte2024/grid_coordinates.tsv +3601 -0
- braincoder/data/szinte2024/mask-v1_bold.tsv.gz +0 -0
- braincoder/hrf.py +272 -0
- braincoder/models/__init__.py +21 -0
- braincoder/models/base.py +1004 -0
- braincoder/models/linear.py +100 -0
- braincoder/models/prf_1d.py +369 -0
- braincoder/models/prf_2d.py +824 -0
- braincoder/noise.py +614 -0
- braincoder/optimize/__init__.py +22 -0
- braincoder/optimize/bayesian_fitter.py +467 -0
- braincoder/optimize/gp_prior.py +361 -0
- braincoder/optimize/parameter_fitter.py +666 -0
- braincoder/optimize/residual_fitter.py +563 -0
- braincoder/optimize/stimulus_fitter.py +656 -0
- braincoder/optimize/weight_fitter.py +112 -0
- braincoder/stimuli.py +224 -0
- braincoder/utils/__init__.py +4 -0
- braincoder/utils/backend.py +533 -0
- braincoder/utils/calibration.py +186 -0
- braincoder/utils/cortex.py +141 -0
- braincoder/utils/data.py +252 -0
- braincoder/utils/formatting.py +63 -0
- braincoder/utils/math.py +131 -0
- braincoder/utils/mcmc.py +114 -0
- braincoder/utils/stats.py +267 -0
- braincoder/utils/visualize.py +26 -0
- braincoder-0.7.1.dist-info/METADATA +136 -0
- braincoder-0.7.1.dist-info/RECORD +36 -0
- braincoder-0.7.1.dist-info/WHEEL +5 -0
- braincoder-0.7.1.dist-info/licenses/LICENSE +22 -0
- braincoder-0.7.1.dist-info/top_level.txt +1 -0
|
@@ -0,0 +1,824 @@
|
|
|
1
|
+
import logging
|
|
2
|
+
import pandas as pd
|
|
3
|
+
import numpy as np
|
|
4
|
+
from tqdm import tqdm
|
|
5
|
+
import keras
|
|
6
|
+
from keras import ops
|
|
7
|
+
from ..utils import norm, format_data, format_paradigm, format_parameters, format_weights, logit, restrict_radians, lognormalpdf_n, von_mises_pdf, lognormal_pdf_mode_fwhm, norm2d
|
|
8
|
+
from ..utils.math import aggressive_softplus, aggressive_softplus_inverse, norm
|
|
9
|
+
from ..utils.backend import softplus_inverse
|
|
10
|
+
import scipy.stats as ss
|
|
11
|
+
from ..stimuli import Stimulus, OneDimensionalRadialStimulus, OneDimensionalGaussianStimulus, OneDimensionalStimulusWithAmplitude, OneDimensionalRadialStimulusWithAmplitude, ImageStimulus, TwoDimensionalStimulus
|
|
12
|
+
from patsy import dmatrix, build_design_matrices
|
|
13
|
+
from .base import _reject_state_kwargs, EncodingModel, HRFEncodingModel
|
|
14
|
+
|
|
15
|
+
class GaussianPointPRF2D(EncodingModel):
|
|
16
|
+
|
|
17
|
+
def __init__(self, allow_neg_amplitudes=False, verbosity=logging.INFO,
|
|
18
|
+
model_stimulus_amplitude=False, correlated_response=False,
|
|
19
|
+
**kwargs):
|
|
20
|
+
|
|
21
|
+
self.correlated_response = correlated_response
|
|
22
|
+
|
|
23
|
+
if correlated_response:
|
|
24
|
+
self.parameter_labels = ['mu_x', 'mu_y', 'sd_x', 'sd_y', 'rho', 'amplitude', 'baseline']
|
|
25
|
+
else:
|
|
26
|
+
self.parameter_labels = ['mu_x', 'mu_y', 'sd_x', 'sd_y', 'amplitude', 'baseline']
|
|
27
|
+
|
|
28
|
+
if allow_neg_amplitudes:
|
|
29
|
+
self._transform_parameters_forward = self._transform_parameters_forward1
|
|
30
|
+
self._transform_parameters_backward = self._transform_parameters_backward1
|
|
31
|
+
else:
|
|
32
|
+
self._transform_parameters_forward = self._transform_parameters_forward2
|
|
33
|
+
self._transform_parameters_backward = self._transform_parameters_backward2
|
|
34
|
+
|
|
35
|
+
self.stimulus_type = self._get_stimulus_type(model_stimulus_amplitude=model_stimulus_amplitude)
|
|
36
|
+
self._basis_predictions = self._get_basis_predictions(model_stimulus_amplitude=model_stimulus_amplitude)
|
|
37
|
+
|
|
38
|
+
super().__init__(verbosity=logging.INFO, **kwargs)
|
|
39
|
+
|
|
40
|
+
def _get_stimulus_type(self, model_stimulus_amplitude=False):
|
|
41
|
+
return TwoDimensionalStimulus
|
|
42
|
+
|
|
43
|
+
def _get_basis_predictions(self, model_stimulus_amplitude=False):
|
|
44
|
+
if model_stimulus_amplitude:
|
|
45
|
+
return self._basis_predictions_with_amplitude
|
|
46
|
+
else:
|
|
47
|
+
return self._basis_predictions_without_amplitude
|
|
48
|
+
|
|
49
|
+
def basis_predictions(self, paradigm, parameters):
|
|
50
|
+
|
|
51
|
+
paradigm = self.get_paradigm(paradigm)
|
|
52
|
+
parameters = self._get_parameters(parameters)
|
|
53
|
+
|
|
54
|
+
if hasattr(parameters, 'values'):
|
|
55
|
+
parameters = parameters.values
|
|
56
|
+
|
|
57
|
+
parameters = np.float32(parameters)
|
|
58
|
+
|
|
59
|
+
return self._basis_predictions(self.stimulus._generate_stimulus(paradigm.values), parameters[np.newaxis, ...])[0]
|
|
60
|
+
|
|
61
|
+
def get_init_pars(self, data, paradigm, confounds=None):
|
|
62
|
+
|
|
63
|
+
paradigm = self._get_paradigm(paradigm)
|
|
64
|
+
data = format_data(data)
|
|
65
|
+
|
|
66
|
+
if confounds is not None:
|
|
67
|
+
beta = ops.lstsq(confounds, data)
|
|
68
|
+
predictions = (confounds @ beta)
|
|
69
|
+
data -= predictions
|
|
70
|
+
|
|
71
|
+
if hasattr(data, 'values'):
|
|
72
|
+
data = data.values
|
|
73
|
+
|
|
74
|
+
baselines = ops.min(data, axis=0)
|
|
75
|
+
data_ = (data - baselines)
|
|
76
|
+
|
|
77
|
+
mus_x = ops.sum((data_ * self.stimulus._generate_stimulus(paradigm.values[..., 0])), axis=0) / ops.sum(data_, axis=0)
|
|
78
|
+
mus_y = ops.sum((data_ * self.stimulus._generate_stimulus(paradigm.values[..., 1])), axis=0) / ops.sum(data_, axis=0)
|
|
79
|
+
sds_x = ops.sqrt(ops.sum(data_ * (self.stimulus._generate_stimulus(paradigm.values[..., 0]) - mus_x)
|
|
80
|
+
** 2, axis=0) / ops.sum(data_, axis=0))
|
|
81
|
+
sds_y = ops.sqrt(ops.sum(data_ * (self.stimulus._generate_stimulus(paradigm.values[..., 1]) - mus_y)
|
|
82
|
+
** 2, axis=0) / ops.sum(data_, axis=0))
|
|
83
|
+
amplitudes = ops.max(data_, axis=0)
|
|
84
|
+
|
|
85
|
+
if self.correlated_response:
|
|
86
|
+
covariances = ops.sum((data_ * (self.stimulus._generate_stimulus(paradigm.values[..., 0]) - mus_x) *
|
|
87
|
+
(self.stimulus._generate_stimulus(paradigm.values[..., 1]) - mus_y)), axis=0) / ops.sum(data_, axis=0)
|
|
88
|
+
parameters = ops.concatenate([mus_x[:, None],
|
|
89
|
+
mus_y[:, None],
|
|
90
|
+
sds_x[:, None],
|
|
91
|
+
sds_y[:, None],
|
|
92
|
+
covariances[:, None],
|
|
93
|
+
amplitudes[:, None],
|
|
94
|
+
baselines[:, None]], axis=1)
|
|
95
|
+
else:
|
|
96
|
+
parameters = ops.concatenate([mus_x[:, None],
|
|
97
|
+
mus_y[:, None],
|
|
98
|
+
sds_x[:, None],
|
|
99
|
+
sds_y[:, None],
|
|
100
|
+
amplitudes[:, None],
|
|
101
|
+
baselines[:, None]], axis=1)
|
|
102
|
+
|
|
103
|
+
return parameters
|
|
104
|
+
|
|
105
|
+
def _basis_predictions_without_amplitude(self, paradigm, parameters):
|
|
106
|
+
if self.correlated_response:
|
|
107
|
+
return norm2d(paradigm[..., None, 0],
|
|
108
|
+
paradigm[..., None, 1],
|
|
109
|
+
parameters[:, None, :, 0],
|
|
110
|
+
parameters[:, None, :, 1],
|
|
111
|
+
parameters[:, None, :, 2],
|
|
112
|
+
parameters[:, None, :, 3],
|
|
113
|
+
parameters[:, None, :, 4]) * \
|
|
114
|
+
parameters[:, None, :, 5] + parameters[:, None, :, 6]
|
|
115
|
+
else:
|
|
116
|
+
return norm2d(paradigm[..., None, 0],
|
|
117
|
+
paradigm[..., None, 1],
|
|
118
|
+
parameters[:, None, :, 0],
|
|
119
|
+
parameters[:, None, :, 1],
|
|
120
|
+
parameters[:, None, :, 2],
|
|
121
|
+
parameters[:, None, :, 3]) * \
|
|
122
|
+
parameters[:, None, :, 4] + parameters[:, None, :, 5]
|
|
123
|
+
|
|
124
|
+
def _basis_predictions_with_amplitude(self, paradigm, parameters):
|
|
125
|
+
if self.correlated_response:
|
|
126
|
+
return norm2d(paradigm[..., None, 0],
|
|
127
|
+
paradigm[..., None, 1],
|
|
128
|
+
parameters[:, None, :, 0],
|
|
129
|
+
parameters[:, None, :, 1],
|
|
130
|
+
parameters[:, None, :, 2],
|
|
131
|
+
parameters[:, None, :, 3],
|
|
132
|
+
parameters[:, None, :, 4]) * \
|
|
133
|
+
parameters[:, None, :, 5] * paradigm[:, :, None, 2] + parameters[:, None, :, 6]
|
|
134
|
+
else:
|
|
135
|
+
return norm2d(paradigm[..., None, 0],
|
|
136
|
+
paradigm[..., None, 1],
|
|
137
|
+
parameters[:, None, :, 0],
|
|
138
|
+
parameters[:, None, :, 1],
|
|
139
|
+
parameters[:, None, :, 2],
|
|
140
|
+
parameters[:, None, :, 3]) * \
|
|
141
|
+
parameters[:, None, :, 4] * paradigm[:, :, None, 2] + parameters[:, None, :, 5]
|
|
142
|
+
|
|
143
|
+
def get_pseudoWWT(self, stimulus_range, parameters, subtract_baseline=True):
|
|
144
|
+
|
|
145
|
+
stimulus_range = stimulus_range.astype(np.float32)
|
|
146
|
+
if subtract_baseline:
|
|
147
|
+
parameters = self._zero_baseline(parameters)
|
|
148
|
+
W = self.basis_predictions(stimulus_range, parameters)
|
|
149
|
+
|
|
150
|
+
pseudoWWT = ops.tensordot(W, W, axes=[[0], [0]])
|
|
151
|
+
return ops.where(ops.isnan(pseudoWWT), ops.zeros_like(pseudoWWT), pseudoWWT)
|
|
152
|
+
|
|
153
|
+
|
|
154
|
+
def _transform_parameters_forward1(self, parameters):
|
|
155
|
+
|
|
156
|
+
if self.correlated_response:
|
|
157
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
158
|
+
parameters[:, 1][:, None],
|
|
159
|
+
ops.softplus(parameters[:, 2][:, None]),
|
|
160
|
+
ops.softplus(parameters[:, 3][:, None]),
|
|
161
|
+
ops.softplus(parameters[:, 4][:, None]) * 2 - 1,
|
|
162
|
+
parameters[:, 5][:, None],
|
|
163
|
+
parameters[:, 6][:, None]], axis=1)
|
|
164
|
+
else:
|
|
165
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
166
|
+
parameters[:, 1][:, None],
|
|
167
|
+
ops.softplus(parameters[:, 2][:, None]),
|
|
168
|
+
ops.softplus(parameters[:, 3][:, None]),
|
|
169
|
+
parameters[:, 4][:, None],
|
|
170
|
+
parameters[:, 5][:, None]], axis=1)
|
|
171
|
+
|
|
172
|
+
def _transform_parameters_backward1(self, parameters):
|
|
173
|
+
|
|
174
|
+
if self.correlated_response:
|
|
175
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
176
|
+
parameters[:, 1][:, None],
|
|
177
|
+
softplus_inverse(parameters[:, 2][:, None]),
|
|
178
|
+
softplus_inverse(parameters[:, 3][:, None]),
|
|
179
|
+
softplus_inverse((parameters[:, 4][:, None] + 1) / 2.),
|
|
180
|
+
parameters[:, 5][:, None],
|
|
181
|
+
parameters[:, 6][:, None]], axis=1)
|
|
182
|
+
|
|
183
|
+
else:
|
|
184
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
185
|
+
parameters[:, 1][:, None],
|
|
186
|
+
softplus_inverse(parameters[:, 2][:, None]),
|
|
187
|
+
softplus_inverse(parameters[:, 3][:, None]),
|
|
188
|
+
parameters[:, 4][:, None],
|
|
189
|
+
parameters[:, 5][:, None]], axis=1)
|
|
190
|
+
|
|
191
|
+
def _transform_parameters_forward2(self, parameters):
|
|
192
|
+
|
|
193
|
+
if self.correlated_response:
|
|
194
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
195
|
+
parameters[:, 1][:, None],
|
|
196
|
+
ops.softplus(parameters[:, 2][:, None]),
|
|
197
|
+
ops.softplus(parameters[:, 3][:, None]),
|
|
198
|
+
ops.softplus(parameters[:, 4][:, None]) * 2 - 1,
|
|
199
|
+
ops.softplus(parameters[:, 5][:, None]),
|
|
200
|
+
parameters[:, 6][:, None]], axis=1)
|
|
201
|
+
else:
|
|
202
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
203
|
+
parameters[:, 1][:, None],
|
|
204
|
+
ops.softplus(parameters[:, 2][:, None]),
|
|
205
|
+
ops.softplus(parameters[:, 3][:, None]),
|
|
206
|
+
ops.softplus(parameters[:, 4][:, None]),
|
|
207
|
+
parameters[:, 5][:, None]], axis=1)
|
|
208
|
+
|
|
209
|
+
def _transform_parameters_backward2(self, parameters):
|
|
210
|
+
|
|
211
|
+
if self.correlated_response:
|
|
212
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
213
|
+
parameters[:, 1][:, None],
|
|
214
|
+
softplus_inverse(parameters[:, 2][:, None]),
|
|
215
|
+
softplus_inverse(parameters[:, 3][:, None]),
|
|
216
|
+
softplus_inverse((parameters[:, 4][:, None] + 1) / 2.),
|
|
217
|
+
softplus_inverse(parameters[:, 5][:, None]),
|
|
218
|
+
parameters[:, 6][:, None]], axis=1)
|
|
219
|
+
|
|
220
|
+
else:
|
|
221
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
222
|
+
parameters[:, 1][:, None],
|
|
223
|
+
softplus_inverse(parameters[:, 2][:, None]),
|
|
224
|
+
softplus_inverse(parameters[:, 3][:, None]),
|
|
225
|
+
softplus_inverse(parameters[:, 4][:, None]),
|
|
226
|
+
parameters[:, 5][:, None]], axis=1)
|
|
227
|
+
|
|
228
|
+
class GaussianMixturePRF2D(EncodingModel):
|
|
229
|
+
|
|
230
|
+
def __init__(self, allow_neg_amplitudes=False, verbosity=logging.INFO,
|
|
231
|
+
model_stimulus_amplitude=False,
|
|
232
|
+
same_rfs=False,
|
|
233
|
+
**kwargs):
|
|
234
|
+
|
|
235
|
+
if allow_neg_amplitudes:
|
|
236
|
+
self._transform_parameters_forward = self._transform_parameters_forward1
|
|
237
|
+
self._transform_parameters_backward = self._transform_parameters_backward1
|
|
238
|
+
else:
|
|
239
|
+
self._transform_parameters_forward = self._transform_parameters_forward2
|
|
240
|
+
self._transform_parameters_backward = self._transform_parameters_backward2
|
|
241
|
+
|
|
242
|
+
self.stimulus_type = self._get_stimulus_type()
|
|
243
|
+
|
|
244
|
+
self.same_rfs = same_rfs
|
|
245
|
+
|
|
246
|
+
if same_rfs:
|
|
247
|
+
self.parameter_labels = ['mu', 'sd', 'weight', 'amplitude', 'baseline']
|
|
248
|
+
else:
|
|
249
|
+
self.parameter_labels = ['mu_x', 'mu_y', 'sd_x', 'sd_y', 'weight', 'amplitude', 'baseline']
|
|
250
|
+
|
|
251
|
+
super().__init__(verbosity=logging.INFO, **kwargs)
|
|
252
|
+
|
|
253
|
+
def _get_stimulus_type(self):
|
|
254
|
+
return TwoDimensionalStimulus
|
|
255
|
+
|
|
256
|
+
def _get_basis_predictions(self, model_stimulus_amplitude=False):
|
|
257
|
+
if model_stimulus_amplitude:
|
|
258
|
+
return self._basis_predictions_with_amplitude
|
|
259
|
+
else:
|
|
260
|
+
return self._basis_predictions_without_amplitude
|
|
261
|
+
|
|
262
|
+
def basis_predictions(self, paradigm, parameters):
|
|
263
|
+
|
|
264
|
+
paradigm = self.get_paradigm(paradigm)
|
|
265
|
+
parameters = self._get_parameters(parameters)
|
|
266
|
+
|
|
267
|
+
if hasattr(parameters, 'values'):
|
|
268
|
+
parameters = parameters.values
|
|
269
|
+
|
|
270
|
+
parameters = np.float32(parameters)
|
|
271
|
+
|
|
272
|
+
return self._basis_predictions(self.stimulus._generate_stimulus(paradigm.values), parameters[np.newaxis, ...])[0]
|
|
273
|
+
|
|
274
|
+
def _basis_predictions(self, paradigm, parameters):
|
|
275
|
+
|
|
276
|
+
if self.same_rfs:
|
|
277
|
+
return (parameters[:, None, :, 2] * norm(paradigm[..., None, 0],
|
|
278
|
+
parameters[:, None, :, 0],
|
|
279
|
+
parameters[:, None, :, 1]) + \
|
|
280
|
+
(1 - parameters[:, None, :, 2]) * norm(paradigm[..., None, 1],
|
|
281
|
+
parameters[:, None, :, 0],
|
|
282
|
+
parameters[:, None, :, 1])) * \
|
|
283
|
+
parameters[:, None, :, 3] + parameters[:, None, :, 4]
|
|
284
|
+
|
|
285
|
+
else:
|
|
286
|
+
return (parameters[:, None, :, 4] * norm(paradigm[..., None, 0],
|
|
287
|
+
parameters[:, None, :, 0],
|
|
288
|
+
parameters[:, None, :, 2]) + \
|
|
289
|
+
(1 - parameters[:, None, :, 4]) * norm(paradigm[..., None, 1],
|
|
290
|
+
parameters[:, None, :, 1],
|
|
291
|
+
parameters[:, None, :, 3])) * \
|
|
292
|
+
parameters[:, None, :, 5] + parameters[:, None, :, 6]
|
|
293
|
+
|
|
294
|
+
def get_pseudoWWT(self, stimulus_range, parameters, subtract_baseline=True):
|
|
295
|
+
|
|
296
|
+
stimulus_range = stimulus_range.astype(np.float32)
|
|
297
|
+
if subtract_baseline:
|
|
298
|
+
parameters = self._zero_baseline(parameters)
|
|
299
|
+
W = self.basis_predictions(stimulus_range, parameters)
|
|
300
|
+
|
|
301
|
+
pseudoWWT = ops.tensordot(W, W, axes=[[0], [0]])
|
|
302
|
+
return ops.where(ops.isnan(pseudoWWT), ops.zeros_like(pseudoWWT), pseudoWWT)
|
|
303
|
+
|
|
304
|
+
|
|
305
|
+
|
|
306
|
+
def _transform_parameters_forward1(self, parameters):
|
|
307
|
+
|
|
308
|
+
if self.same_rfs:
|
|
309
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
310
|
+
ops.softplus(parameters[:, 1][:, None]),
|
|
311
|
+
ops.sigmoid(parameters[:, 2][:, None]),
|
|
312
|
+
ops.softplus(parameters[:, 3][:, None]),
|
|
313
|
+
parameters[:, 4][:, None]],
|
|
314
|
+
axis=1)
|
|
315
|
+
|
|
316
|
+
else:
|
|
317
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
318
|
+
parameters[:, 1][:, None],
|
|
319
|
+
ops.softplus(parameters[:, 2][:, None]),
|
|
320
|
+
ops.softplus(parameters[:, 3][:, None]),
|
|
321
|
+
ops.sigmoid(parameters[:, 4][:, None]),
|
|
322
|
+
parameters[:, 5][:, None],
|
|
323
|
+
parameters[:, 6][:, None]], axis=1)
|
|
324
|
+
|
|
325
|
+
def _transform_parameters_backward1(self, parameters):
|
|
326
|
+
if self.same_rfs:
|
|
327
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
328
|
+
softplus_inverse(parameters[:, 1][:, None]),
|
|
329
|
+
logit(parameters[:, 2][:, None]),
|
|
330
|
+
softplus_inverse(parameters[:, 3][:, None]),
|
|
331
|
+
parameters[:, 4][:, None]],
|
|
332
|
+
axis=1)
|
|
333
|
+
else:
|
|
334
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
335
|
+
parameters[:, 1][:, None],
|
|
336
|
+
softplus_inverse(parameters[:, 2][:, None]),
|
|
337
|
+
softplus_inverse(parameters[:, 3][:, None]),
|
|
338
|
+
logit(parameters[:, 4][:, None]),
|
|
339
|
+
parameters[:, 5][:, None],
|
|
340
|
+
parameters[:, 6][:, None]], axis=1)
|
|
341
|
+
|
|
342
|
+
def _transform_parameters_forward2(self, parameters):
|
|
343
|
+
if self.same_rfs:
|
|
344
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
345
|
+
ops.softplus(parameters[:, 1][:, None]),
|
|
346
|
+
ops.sigmoid(parameters[:, 2][:, None]),
|
|
347
|
+
ops.softplus(parameters[:, 3][:, None]),
|
|
348
|
+
parameters[:, 4][:, None]], axis=1)
|
|
349
|
+
else:
|
|
350
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
351
|
+
parameters[:, 1][:, None],
|
|
352
|
+
ops.softplus(parameters[:, 2][:, None]),
|
|
353
|
+
ops.softplus(parameters[:, 3][:, None]),
|
|
354
|
+
ops.sigmoid(parameters[:, 4][:, None]),
|
|
355
|
+
ops.softplus(parameters[:, 5][:, None]),
|
|
356
|
+
parameters[:, 6][:, None]], axis=1)
|
|
357
|
+
|
|
358
|
+
def _transform_parameters_backward2(self, parameters):
|
|
359
|
+
if self.same_rfs:
|
|
360
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
361
|
+
softplus_inverse(parameters[:, 1][:, None]),
|
|
362
|
+
logit(parameters[:, 2][:, None]),
|
|
363
|
+
softplus_inverse(parameters[:, 3][:, None]),
|
|
364
|
+
parameters[:, 4][:, None]], axis=1)
|
|
365
|
+
else:
|
|
366
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
367
|
+
parameters[:, 1][:, None],
|
|
368
|
+
softplus_inverse(parameters[:, 2][:, None]),
|
|
369
|
+
softplus_inverse(parameters[:, 3][:, None]),
|
|
370
|
+
logit(parameters[:, 4][:, None]),
|
|
371
|
+
softplus_inverse(parameters[:, 5][:, None]),
|
|
372
|
+
parameters[:, 6][:, None]], axis=1)
|
|
373
|
+
|
|
374
|
+
class GaussianPRF2D(EncodingModel):
|
|
375
|
+
"""2D Gaussian population receptive field on a pixel grid.
|
|
376
|
+
|
|
377
|
+
``rf_normalization`` (ctor kwarg) sets the scale of the Gaussian
|
|
378
|
+
before ``amplitude`` multiplies it, and so what the amplitude means:
|
|
379
|
+
|
|
380
|
+
- ``'legacy'`` (default): divided by ``σ·√(2π) / pixel_area``.
|
|
381
|
+
- ``'peak'``: peak 1 (prfpy's ``normalize_RFs=False``); amplitude is
|
|
382
|
+
the drive per stimulated pixel at the pRF centre.
|
|
383
|
+
- ``'area'``: integral 1 over the visual field (``pixel_area /
|
|
384
|
+
(2π σ²)``); ``<stimulus, G>`` is the stimulated fraction of the pRF.
|
|
385
|
+
|
|
386
|
+
The three are reparameterisations of each other: with σ fixed,
|
|
387
|
+
amplitudes convert exactly by the ratio of the scale factors.
|
|
388
|
+
"""
|
|
389
|
+
|
|
390
|
+
parameter_labels = ['x', 'y', 'sd', 'baseline', 'amplitude']
|
|
391
|
+
stimulus_type = ImageStimulus
|
|
392
|
+
RF_NORMALIZATIONS = ('legacy', 'peak', 'area')
|
|
393
|
+
|
|
394
|
+
def __init__(self, grid_coordinates=None, positive_image_values_only=True, verbosity=logging.INFO,
|
|
395
|
+
rf_normalization='legacy', **kwargs):
|
|
396
|
+
|
|
397
|
+
if rf_normalization not in self.RF_NORMALIZATIONS:
|
|
398
|
+
raise ValueError(f'rf_normalization must be one of {self.RF_NORMALIZATIONS}, '
|
|
399
|
+
f'got {rf_normalization!r}')
|
|
400
|
+
_reject_state_kwargs(kwargs, type(self).__name__)
|
|
401
|
+
self.rf_normalization = rf_normalization
|
|
402
|
+
|
|
403
|
+
if grid_coordinates is None:
|
|
404
|
+
raise ValueError(f'{type(self).__name__} needs grid_coordinates: (n_pixels, 2) x and y.')
|
|
405
|
+
|
|
406
|
+
self.grid_coordinates = pd.DataFrame(
|
|
407
|
+
grid_coordinates, columns=['x', 'y'])
|
|
408
|
+
self._grid_coordinates = self.grid_coordinates.values
|
|
409
|
+
|
|
410
|
+
self.n_x = len(self.grid_coordinates['x'].unique())
|
|
411
|
+
self.n_y = len(self.grid_coordinates['y'].unique())
|
|
412
|
+
self.stimulus = self.stimulus_type(self.grid_coordinates, positive_only=positive_image_values_only)
|
|
413
|
+
|
|
414
|
+
x_diff = np.diff(np.sort(self.grid_coordinates['x'].unique())).mean()
|
|
415
|
+
y_diff = np.diff(np.sort(self.grid_coordinates['y'].unique())).mean()
|
|
416
|
+
self.pixel_area = x_diff * y_diff
|
|
417
|
+
|
|
418
|
+
#: The pseudo-WWT of an image model comes from its receptive fields.
|
|
419
|
+
pseudo_wwt_needs_stimulus_range = False
|
|
420
|
+
|
|
421
|
+
def get_rf(self, parameters, as_frame=False, unpack=False):
|
|
422
|
+
|
|
423
|
+
grid_coordinates = self.grid_coordinates.values
|
|
424
|
+
|
|
425
|
+
index = format_parameters(parameters).index
|
|
426
|
+
parameters = self._get_parameters(parameters).values[np.newaxis, ...]
|
|
427
|
+
|
|
428
|
+
rf = self._get_rf(grid_coordinates, parameters)
|
|
429
|
+
rf = ops.convert_to_numpy(rf)[0]
|
|
430
|
+
|
|
431
|
+
if as_frame:
|
|
432
|
+
rf = pd.concat([pd.DataFrame(e,
|
|
433
|
+
index=pd.MultiIndex.from_frame(self.grid_coordinates))
|
|
434
|
+
for e in rf],
|
|
435
|
+
keys=index)
|
|
436
|
+
|
|
437
|
+
if unpack:
|
|
438
|
+
rf = rf.unstack('x').sort_index(ascending=False)
|
|
439
|
+
|
|
440
|
+
return rf
|
|
441
|
+
|
|
442
|
+
def _basis_predictions(self, paradigm, parameters):
|
|
443
|
+
|
|
444
|
+
rf = self._get_rf(self.grid_coordinates, parameters)
|
|
445
|
+
baseline = parameters[:, None, :, 3]
|
|
446
|
+
result = ops.tensordot(paradigm, rf, axes=[[2], [2]])[:, :, 0, :] + baseline
|
|
447
|
+
|
|
448
|
+
return result
|
|
449
|
+
|
|
450
|
+
def _get_rf(self, grid_coordinates, parameters, normalize=True):
|
|
451
|
+
|
|
452
|
+
if hasattr(grid_coordinates, 'values'):
|
|
453
|
+
grid_coordinates = grid_coordinates.values
|
|
454
|
+
|
|
455
|
+
x = ops.convert_to_tensor(grid_coordinates[:, 0][None, None, :], dtype='float32')
|
|
456
|
+
y = ops.convert_to_tensor(grid_coordinates[:, 1][None, None, :], dtype='float32')
|
|
457
|
+
parameters = ops.convert_to_tensor(parameters, dtype='float32')
|
|
458
|
+
|
|
459
|
+
mu_x = parameters[:, :, 0, None]
|
|
460
|
+
mu_y = parameters[:, :, 1, None]
|
|
461
|
+
sd = parameters[:, :, 2, None]
|
|
462
|
+
amplitude = parameters[:, :, 4, None]
|
|
463
|
+
|
|
464
|
+
gauss = (ops.exp(-((x-mu_x)**2 + (y-mu_y)**2)/(2*sd**2))) * amplitude
|
|
465
|
+
|
|
466
|
+
if normalize:
|
|
467
|
+
gauss = gauss * self._rf_scale(sd)
|
|
468
|
+
|
|
469
|
+
return gauss
|
|
470
|
+
|
|
471
|
+
def _rf_scale(self, sd):
|
|
472
|
+
"""Factor applied to a peak-1 Gaussian of width ``sd`` (see ``rf_normalization``)."""
|
|
473
|
+
if self.rf_normalization == 'peak':
|
|
474
|
+
return ops.ones_like(sd)
|
|
475
|
+
if self.rf_normalization == 'area':
|
|
476
|
+
return float(self.pixel_area) / (2 * np.pi * sd ** 2)
|
|
477
|
+
return float(self.pixel_area) / (sd * np.sqrt(2 * np.pi))
|
|
478
|
+
|
|
479
|
+
def _transform_parameters_forward(self, parameters):
|
|
480
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
481
|
+
parameters[:, 1][:, None],
|
|
482
|
+
ops.softplus(parameters[:, 2][:, None]),
|
|
483
|
+
parameters[:, 3][:, None],
|
|
484
|
+
parameters[:, 4][:, None]], axis=1)
|
|
485
|
+
|
|
486
|
+
def _transform_parameters_backward(self, parameters):
|
|
487
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
488
|
+
parameters[:, 1][:, None],
|
|
489
|
+
softplus_inverse(parameters[:, 2][:, None]),
|
|
490
|
+
parameters[:, 3][:, None],
|
|
491
|
+
parameters[:, 4][:, None]], axis=1)
|
|
492
|
+
|
|
493
|
+
def get_pseudoWWT(self, stimulus_range=None, parameters=None, subtract_baseline=True):
|
|
494
|
+
"""Tuning similarity between voxels, from their receptive fields."""
|
|
495
|
+
|
|
496
|
+
parameters = self._get_parameters(parameters).copy()
|
|
497
|
+
|
|
498
|
+
if subtract_baseline:
|
|
499
|
+
parameters['baseline'] = np.float32(0.0)
|
|
500
|
+
|
|
501
|
+
rf = self.get_rf(parameters.astype(np.float32))
|
|
502
|
+
|
|
503
|
+
return rf.dot(rf.T)
|
|
504
|
+
|
|
505
|
+
def to_linear_model(self, parameters):
|
|
506
|
+
"""Equivalent linear model: returns ``(model, parameters, weights)``."""
|
|
507
|
+
from .linear import LinearModelWithBaseline
|
|
508
|
+
parameters = self._get_parameters(parameters)
|
|
509
|
+
return (LinearModelWithBaseline(n_dimensions=len(self.grid_coordinates)),
|
|
510
|
+
parameters[['baseline']],
|
|
511
|
+
pd.DataFrame(self.get_rf(parameters).T, columns=parameters.index))
|
|
512
|
+
|
|
513
|
+
def unpack_stimulus(self, stimulus):
|
|
514
|
+
return np.reshape(stimulus, (-1, self.n_x, self.n_y))
|
|
515
|
+
|
|
516
|
+
class GaussianPRF2DAngle(GaussianPRF2D):
|
|
517
|
+
|
|
518
|
+
parameter_labels = ['theta', 'ecc', 'sd', 'baseline', 'amplitude']
|
|
519
|
+
|
|
520
|
+
def _get_rf(self, grid_coordinates, parameters):
|
|
521
|
+
|
|
522
|
+
if hasattr(grid_coordinates, 'values'):
|
|
523
|
+
grid_coordinates = grid_coordinates.values
|
|
524
|
+
|
|
525
|
+
x = ops.convert_to_tensor(grid_coordinates[:, 0][None, None, :], dtype='float32')
|
|
526
|
+
y = ops.convert_to_tensor(grid_coordinates[:, 1][None, None, :], dtype='float32')
|
|
527
|
+
parameters = ops.convert_to_tensor(parameters, dtype='float32')
|
|
528
|
+
|
|
529
|
+
theta = parameters[:, :, 0, None]
|
|
530
|
+
ecc = parameters[:, :, 1, None]
|
|
531
|
+
mu_x = ops.cos(theta) * ecc
|
|
532
|
+
mu_y = ops.sin(theta) * ecc
|
|
533
|
+
sd = parameters[:, :, 2, None]
|
|
534
|
+
amplitude = parameters[:, :, 4, None]
|
|
535
|
+
|
|
536
|
+
return (ops.exp(-((x-mu_x)**2 + (y-mu_y)**2)/(2*sd**2))) * amplitude
|
|
537
|
+
|
|
538
|
+
def _transform_parameters_forward(self, parameters):
|
|
539
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
540
|
+
ops.softplus(parameters[:, 1][:, None]),
|
|
541
|
+
ops.softplus(parameters[:, 2][:, None]),
|
|
542
|
+
parameters[:, 3][:, None],
|
|
543
|
+
parameters[:, 4][:, None]], axis=1)
|
|
544
|
+
|
|
545
|
+
def _transform_parameters_backward(self, parameters):
|
|
546
|
+
return ops.concatenate([restrict_radians(parameters[:, 0][:, None]),
|
|
547
|
+
softplus_inverse(parameters[:, 1][:, None]),
|
|
548
|
+
softplus_inverse(parameters[:, 2][:, None]),
|
|
549
|
+
parameters[:, 3][:, None],
|
|
550
|
+
parameters[:, 4][:, None]], axis=1)
|
|
551
|
+
|
|
552
|
+
def to_linear_model(self, parameters):
|
|
553
|
+
"""Equivalent linear model: returns ``(model, parameters, weights)``."""
|
|
554
|
+
from .linear import LinearModelWithBaseline
|
|
555
|
+
parameters = self._get_parameters(parameters)
|
|
556
|
+
return (LinearModelWithBaseline(n_dimensions=len(self.grid_coordinates)),
|
|
557
|
+
parameters[['baseline']],
|
|
558
|
+
pd.DataFrame(self.get_rf(parameters).T, columns=parameters.index))
|
|
559
|
+
|
|
560
|
+
def unpack_stimulus(self, stimulus):
|
|
561
|
+
return np.reshape(stimulus, (-1, self.n_x, self.n_y))
|
|
562
|
+
|
|
563
|
+
def _xy_parameters(self, parameters):
|
|
564
|
+
parameters = self._get_parameters(parameters).copy()
|
|
565
|
+
parameters['x'] = np.cos(parameters['theta']) * parameters['ecc']
|
|
566
|
+
parameters['y'] = np.sin(parameters['theta']) * parameters['ecc']
|
|
567
|
+
return parameters[['x', 'y', 'sd', 'baseline', 'amplitude']]
|
|
568
|
+
|
|
569
|
+
def to_xy_model(self, parameters):
|
|
570
|
+
"""Equivalent x/y model: returns ``(model, parameters)``."""
|
|
571
|
+
return GaussianPRF2D(grid_coordinates=self.grid_coordinates), self._xy_parameters(parameters)
|
|
572
|
+
|
|
573
|
+
class GaussianPRF2DWithHRF(HRFEncodingModel, GaussianPRF2D):
|
|
574
|
+
def __init__(self, grid_coordinates=None, positive_image_values_only=True,
|
|
575
|
+
hrf_model=None, flexible_hrf_parameters=False, verbosity=logging.INFO, **kwargs):
|
|
576
|
+
|
|
577
|
+
GaussianPRF2D.__init__(self, grid_coordinates=grid_coordinates, verbosity=verbosity,
|
|
578
|
+
positive_image_values_only=positive_image_values_only, **kwargs)
|
|
579
|
+
HRFEncodingModel.__init__(self, hrf_model=hrf_model, flexible_hrf_parameters=flexible_hrf_parameters, **kwargs)
|
|
580
|
+
|
|
581
|
+
def to_linear_model(self, parameters):
|
|
582
|
+
"""Equivalent linear model: returns ``(model, parameters, weights)``."""
|
|
583
|
+
from .linear import LinearModelWithBaselineHRF
|
|
584
|
+
parameters = self._get_parameters(parameters)
|
|
585
|
+
return (LinearModelWithBaselineHRF(hrf_model=self.hrf_model, n_dimensions=len(self.grid_coordinates)),
|
|
586
|
+
parameters[['baseline']],
|
|
587
|
+
pd.DataFrame(self.get_rf(parameters).T, columns=parameters.index))
|
|
588
|
+
|
|
589
|
+
def _transform_parameters_forward(self, parameters):
|
|
590
|
+
if self.flexible_hrf_parameters:
|
|
591
|
+
n_hrf_pars = len(self.hrf_model.parameter_labels)
|
|
592
|
+
encoding_pars = GaussianPRF2D._transform_parameters_forward(self, parameters[:, :-n_hrf_pars])
|
|
593
|
+
hrf_pars = self.hrf_model._transform_parameters_forward(parameters[:, -n_hrf_pars:])
|
|
594
|
+
return ops.concatenate([encoding_pars, hrf_pars], axis=1)
|
|
595
|
+
else:
|
|
596
|
+
return GaussianPRF2D._transform_parameters_forward(self, parameters)
|
|
597
|
+
|
|
598
|
+
def _transform_parameters_backward(self, parameters):
|
|
599
|
+
if self.flexible_hrf_parameters:
|
|
600
|
+
n_hrf_pars = len(self.hrf_model.parameter_labels)
|
|
601
|
+
encoding_pars = GaussianPRF2D._transform_parameters_backward(self, parameters[:, :-n_hrf_pars])
|
|
602
|
+
hrf_pars = self.hrf_model._transform_parameters_backward(parameters[:, -n_hrf_pars:])
|
|
603
|
+
return ops.concatenate([encoding_pars, hrf_pars], axis=1)
|
|
604
|
+
else:
|
|
605
|
+
return GaussianPRF2D._transform_parameters_backward(self, parameters)
|
|
606
|
+
|
|
607
|
+
class GaussianPRF2DAngleWithHRF(HRFEncodingModel, GaussianPRF2DAngle):
|
|
608
|
+
|
|
609
|
+
def __init__(self, grid_coordinates=None, hrf_model=None, verbosity=logging.INFO,
|
|
610
|
+
positive_image_values_only=True, flexible_hrf_parameters=False, **kwargs):
|
|
611
|
+
|
|
612
|
+
GaussianPRF2DAngle.__init__(self, grid_coordinates=grid_coordinates, verbosity=verbosity,
|
|
613
|
+
positive_image_values_only=positive_image_values_only, **kwargs)
|
|
614
|
+
|
|
615
|
+
HRFEncodingModel.__init__(self, hrf_model=hrf_model, flexible_hrf_parameters=flexible_hrf_parameters, **kwargs)
|
|
616
|
+
self.hrf_model = hrf_model
|
|
617
|
+
|
|
618
|
+
def to_linear_model(self, parameters):
|
|
619
|
+
"""Equivalent linear model: returns ``(model, parameters, weights)``."""
|
|
620
|
+
from .linear import LinearModelWithBaselineHRF
|
|
621
|
+
parameters = self._get_parameters(parameters)
|
|
622
|
+
return (LinearModelWithBaselineHRF(hrf_model=self.hrf_model, n_dimensions=len(self.grid_coordinates)),
|
|
623
|
+
parameters[['baseline']],
|
|
624
|
+
pd.DataFrame(self.get_rf(parameters).T, columns=parameters.index))
|
|
625
|
+
|
|
626
|
+
def to_xy_model(self, parameters):
|
|
627
|
+
"""Equivalent x/y model: returns ``(model, parameters)``."""
|
|
628
|
+
return (GaussianPRF2DWithHRF(grid_coordinates=self.grid_coordinates, hrf_model=self.hrf_model),
|
|
629
|
+
self._xy_parameters(parameters))
|
|
630
|
+
|
|
631
|
+
class DifferenceOfGaussiansPRF2D(GaussianPRF2D):
|
|
632
|
+
|
|
633
|
+
parameter_labels = ['x', 'y', 'sd', 'baseline',
|
|
634
|
+
'amplitude', 'srf_amplitude', 'srf_size']
|
|
635
|
+
|
|
636
|
+
transformations = ['identity', 'identity', 'softplus', 'identity',
|
|
637
|
+
'softplus', 'softplus', 'softplus']
|
|
638
|
+
|
|
639
|
+
# The parent Gaussian transforms cover only the first 5 columns.
|
|
640
|
+
def _transform_parameters_forward(self, parameters):
|
|
641
|
+
gauss_pars = GaussianPRF2D._transform_parameters_forward(self, parameters[:, :5])
|
|
642
|
+
srf_amplitude = ops.softplus(parameters[:, 5][:, None])
|
|
643
|
+
srf_size = ops.softplus(parameters[:, 6][:, None]) + 1.0 # surround wider than center
|
|
644
|
+
return ops.concatenate([gauss_pars, srf_amplitude, srf_size], axis=1)
|
|
645
|
+
|
|
646
|
+
def _transform_parameters_backward(self, parameters):
|
|
647
|
+
gauss_pars = GaussianPRF2D._transform_parameters_backward(self, parameters[:, :5])
|
|
648
|
+
srf_amplitude = softplus_inverse(parameters[:, 5][:, None])
|
|
649
|
+
srf_size = softplus_inverse(parameters[:, 6][:, None] - 1.0)
|
|
650
|
+
return ops.concatenate([gauss_pars, srf_amplitude, srf_size], axis=1)
|
|
651
|
+
|
|
652
|
+
def _get_rf(self, grid_coordinates, parameters):
|
|
653
|
+
|
|
654
|
+
mu_x = parameters[:, :, 0, None]
|
|
655
|
+
mu_y = parameters[:, :, 1, None]
|
|
656
|
+
sd = parameters[:, :, 2, None]
|
|
657
|
+
amplitude = parameters[:, :, 4, None]
|
|
658
|
+
|
|
659
|
+
srf_amplitude = parameters[:, :, 5, None]
|
|
660
|
+
srf_size = parameters[:, :, 6, None]
|
|
661
|
+
|
|
662
|
+
standard_prf = super()._get_rf(grid_coordinates, parameters)
|
|
663
|
+
|
|
664
|
+
srf_pars = ops.concatenate([mu_x, mu_y, sd*srf_size, ops.zeros_like(mu_x), srf_amplitude*amplitude*srf_size], axis=2)
|
|
665
|
+
sprf = super()._get_rf(grid_coordinates, srf_pars)
|
|
666
|
+
|
|
667
|
+
return standard_prf - sprf
|
|
668
|
+
|
|
669
|
+
class DifferenceOfGaussiansPRF2DWithHRF(HRFEncodingModel, DifferenceOfGaussiansPRF2D):
|
|
670
|
+
|
|
671
|
+
def __init__(self, grid_coordinates=None, positive_image_values_only=True,
|
|
672
|
+
hrf_model=None, flexible_hrf_parameters=False, verbosity=logging.INFO, **kwargs):
|
|
673
|
+
|
|
674
|
+
DifferenceOfGaussiansPRF2D.__init__(self, grid_coordinates=grid_coordinates, verbosity=verbosity,
|
|
675
|
+
positive_image_values_only=positive_image_values_only, **kwargs)
|
|
676
|
+
|
|
677
|
+
HRFEncodingModel.__init__(self, hrf_model=hrf_model, flexible_hrf_parameters=flexible_hrf_parameters, **kwargs)
|
|
678
|
+
|
|
679
|
+
def _transform_parameters_forward(self, parameters):
|
|
680
|
+
|
|
681
|
+
if self.flexible_hrf_parameters:
|
|
682
|
+
n_hrf_pars = len(self.hrf_model.parameter_labels)
|
|
683
|
+
|
|
684
|
+
encoding_pars = DifferenceOfGaussiansPRF2D._transform_parameters_forward(self, parameters[:, :-n_hrf_pars])
|
|
685
|
+
hrf_pars = self.hrf_model._transform_parameters_forward(parameters[:, -n_hrf_pars:])
|
|
686
|
+
|
|
687
|
+
return ops.concatenate([encoding_pars, hrf_pars], axis=1)
|
|
688
|
+
else:
|
|
689
|
+
return DifferenceOfGaussiansPRF2D._transform_parameters_forward(self, parameters)
|
|
690
|
+
|
|
691
|
+
def _transform_parameters_backward(self, parameters):
|
|
692
|
+
|
|
693
|
+
if self.flexible_hrf_parameters:
|
|
694
|
+
n_hrf_pars = len(self.hrf_model.parameter_labels)
|
|
695
|
+
|
|
696
|
+
encoding_pars = DifferenceOfGaussiansPRF2D._transform_parameters_backward(self, parameters[:, :-n_hrf_pars])
|
|
697
|
+
hrf_pars = self.hrf_model._transform_parameters_backward(parameters[:, -n_hrf_pars:])
|
|
698
|
+
|
|
699
|
+
return ops.concatenate([encoding_pars, hrf_pars], axis=1)
|
|
700
|
+
else:
|
|
701
|
+
return DifferenceOfGaussiansPRF2D._transform_parameters_backward(self, parameters)
|
|
702
|
+
|
|
703
|
+
class DivisiveNormalizationGaussianPRF2D(GaussianPRF2D):
|
|
704
|
+
parameter_labels = ['x', 'y', 'sd',
|
|
705
|
+
'rf_amplitude', 'srf_amplitude', 'srf_size',
|
|
706
|
+
'neural_baseline', 'surround_baseline']
|
|
707
|
+
|
|
708
|
+
def _transform_parameters_forward(self, parameters):
|
|
709
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
710
|
+
parameters[:, 1][:, None],
|
|
711
|
+
ops.softplus(parameters[:, 2][:, None]),
|
|
712
|
+
parameters[:, 3][:, None],
|
|
713
|
+
ops.softplus(parameters[:, 4][:, None]),
|
|
714
|
+
ops.softplus(parameters[:, 5][:, None]) + 1,
|
|
715
|
+
ops.softplus(parameters[:, 6][:, None]),
|
|
716
|
+
ops.softplus(parameters[:, 7][:, None]),
|
|
717
|
+
], axis=1)
|
|
718
|
+
|
|
719
|
+
def _transform_parameters_backward(self, parameters):
|
|
720
|
+
return ops.concatenate([parameters[:, 0][:, None],
|
|
721
|
+
parameters[:, 1][:, None],
|
|
722
|
+
softplus_inverse(parameters[:, 2][:, None]),
|
|
723
|
+
parameters[:, 3][:, None],
|
|
724
|
+
softplus_inverse(parameters[:, 4][:, None]),
|
|
725
|
+
softplus_inverse(parameters[:, 5][:, None] - 1),
|
|
726
|
+
softplus_inverse(parameters[:, 6][:, None]),
|
|
727
|
+
softplus_inverse(parameters[:, 7][:, None])], axis=1)
|
|
728
|
+
|
|
729
|
+
def _basis_predictions(self, paradigm, parameters):
|
|
730
|
+
|
|
731
|
+
mu_x = parameters[:, :, 0, None]
|
|
732
|
+
mu_y = parameters[:, :, 1, None]
|
|
733
|
+
sd = parameters[:, :, 2, None]
|
|
734
|
+
rf_parameters = ops.concatenate([mu_x, mu_y, sd, ops.zeros_like(mu_x), ops.ones_like(mu_x)], axis=2)
|
|
735
|
+
rf = self._get_rf(self.grid_coordinates, rf_parameters)
|
|
736
|
+
|
|
737
|
+
srf_size = parameters[:, :, 5, None]
|
|
738
|
+
|
|
739
|
+
srf_parameters = ops.concatenate([mu_x, mu_y, sd*srf_size, ops.zeros_like(mu_x), ops.ones_like(mu_x)], axis=2)
|
|
740
|
+
|
|
741
|
+
srf = self._get_rf(self.grid_coordinates, srf_parameters)
|
|
742
|
+
|
|
743
|
+
rf_amplitude = parameters[:, :, 3][:, None, :]
|
|
744
|
+
srf_amplitude = parameters[:, :, 4][:, None, :]
|
|
745
|
+
neural_baseline = parameters[:, :, 6][:, None, :]
|
|
746
|
+
surround_baseline = parameters[:, :, 7][:, None, :]
|
|
747
|
+
|
|
748
|
+
neural_activation = rf_amplitude * ops.tensordot(paradigm, rf, axes=[[2], [2]])[:, :, 0, :] + neural_baseline
|
|
749
|
+
normalization = (srf_amplitude * ops.abs(rf_amplitude)) * ops.tensordot(paradigm, srf, axes=[[2], [2]])[:, :, 0, :] + surround_baseline
|
|
750
|
+
|
|
751
|
+
normalized_activation = (neural_activation / normalization)
|
|
752
|
+
|
|
753
|
+
return normalized_activation
|
|
754
|
+
|
|
755
|
+
class DivisiveNormalizationGaussianPRF2DWithHRF(HRFEncodingModel, DivisiveNormalizationGaussianPRF2D):
|
|
756
|
+
|
|
757
|
+
parameter_labels = ['x', 'y', 'sd',
|
|
758
|
+
'rf_amplitude', 'srf_amplitude', 'srf_size',
|
|
759
|
+
'neural_baseline', 'surround_baseline',
|
|
760
|
+
'bold_baseline']
|
|
761
|
+
|
|
762
|
+
def __init__(self, grid_coordinates=None, positive_image_values_only=True,
|
|
763
|
+
hrf_model=None, flexible_hrf_parameters=False, verbosity=logging.INFO, **kwargs):
|
|
764
|
+
|
|
765
|
+
DivisiveNormalizationGaussianPRF2D.__init__(self, grid_coordinates=grid_coordinates, verbosity=verbosity,
|
|
766
|
+
positive_image_values_only=positive_image_values_only, **kwargs)
|
|
767
|
+
|
|
768
|
+
HRFEncodingModel.__init__(self, hrf_model=hrf_model, flexible_hrf_parameters=flexible_hrf_parameters, **kwargs)
|
|
769
|
+
|
|
770
|
+
def _transform_parameters_forward(self, parameters):
|
|
771
|
+
|
|
772
|
+
if self.flexible_hrf_parameters:
|
|
773
|
+
n_hrf_pars = len(self.hrf_model.parameter_labels)
|
|
774
|
+
|
|
775
|
+
encoding_pars = DivisiveNormalizationGaussianPRF2D._transform_parameters_forward(self, parameters[:, :-n_hrf_pars-1])
|
|
776
|
+
bold_baseline = parameters[:, -n_hrf_pars-1][:, None]
|
|
777
|
+
hrf_pars = self.hrf_model._transform_parameters_forward(parameters[:, -n_hrf_pars:])
|
|
778
|
+
|
|
779
|
+
return ops.concatenate([encoding_pars, bold_baseline, hrf_pars], axis=1)
|
|
780
|
+
else:
|
|
781
|
+
encoding_pars1 = DivisiveNormalizationGaussianPRF2D._transform_parameters_forward(self, parameters[:, :-1])
|
|
782
|
+
bold_baseline = parameters[:, -1:]
|
|
783
|
+
return ops.concatenate([encoding_pars1, bold_baseline], axis=1)
|
|
784
|
+
|
|
785
|
+
def _transform_parameters_backward(self, parameters):
|
|
786
|
+
|
|
787
|
+
if self.flexible_hrf_parameters:
|
|
788
|
+
n_hrf_pars = len(self.hrf_model.parameter_labels)
|
|
789
|
+
|
|
790
|
+
encoding_pars = DivisiveNormalizationGaussianPRF2D._transform_parameters_backward(self, parameters[:, :-n_hrf_pars-1])
|
|
791
|
+
bold_baseline = parameters[:, -n_hrf_pars-1][:, None]
|
|
792
|
+
hrf_pars = self.hrf_model._transform_parameters_backward(parameters[:, -n_hrf_pars:])
|
|
793
|
+
return ops.concatenate([encoding_pars, bold_baseline, hrf_pars], axis=1)
|
|
794
|
+
|
|
795
|
+
else:
|
|
796
|
+
encoding_pars1 = DivisiveNormalizationGaussianPRF2D._transform_parameters_backward(self, parameters[:, :-1])
|
|
797
|
+
bold_baseline = parameters[:, -1:]
|
|
798
|
+
return ops.concatenate([encoding_pars1, bold_baseline], axis=1)
|
|
799
|
+
|
|
800
|
+
def _predict_no_hrf(self, paradigm, parameters, weights):
|
|
801
|
+
parameters = ops.convert_to_tensor(parameters, dtype='float32')
|
|
802
|
+
pre_convolve = DivisiveNormalizationGaussianPRF2D._predict(self, paradigm, parameters[..., :8], weights)
|
|
803
|
+
return pre_convolve - parameters[None, :, :, 6] / parameters[None, :, :, 7] + parameters[None, :, :, 8]
|
|
804
|
+
|
|
805
|
+
def _predict(self, paradigm, parameters, weights):
|
|
806
|
+
|
|
807
|
+
parameters = ops.convert_to_tensor(parameters, dtype='float32')
|
|
808
|
+
pre_convolve_parameters = parameters[..., :8]
|
|
809
|
+
pre_convolve = DivisiveNormalizationGaussianPRF2D._predict(self, paradigm, pre_convolve_parameters, weights)
|
|
810
|
+
|
|
811
|
+
neural_baseline = parameters[None, :, :, 6]
|
|
812
|
+
surround_baseline = parameters[None, :, :, 7]
|
|
813
|
+
bold_baseline = parameters[None, :, :, 8]
|
|
814
|
+
|
|
815
|
+
pre_convolve = pre_convolve - (neural_baseline / surround_baseline)
|
|
816
|
+
|
|
817
|
+
kwargs = {}
|
|
818
|
+
if self.flexible_hrf_parameters:
|
|
819
|
+
for ix, label in enumerate(self.hrf_model.parameter_labels):
|
|
820
|
+
kwargs[label] = parameters[:, :, -len(self.hrf_model.parameter_labels) + ix]
|
|
821
|
+
|
|
822
|
+
pred_convolved = self.hrf_model.convolve(pre_convolve, **kwargs) + bold_baseline
|
|
823
|
+
|
|
824
|
+
return pred_convolved
|