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.
@@ -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