def generate_ballpark_prediction(self, x, y, sigma, sigma_ratio, volume_ratio):
# extract the center response
rf_center = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x0, self.stimulus.deg_y0)
# extract surround response
rf_surround = generate_og_receptive_field(x, y, sigma*sigma_ratio,
self.stimulus.deg_x0, self.stimulus.deg_x0) * 1/sigma_ratio**2
# difference
rf = ne.evaluate('rf_center - sqrt(volume_ratio)*rf_surround')
# extract the response
mask = self.distance_mask(x, y, sigma*sigma_ratio)
response = generate_rf_timeseries(self.stimulus.stim_arr0, rf, mask)
# generate the hrf
hrf = self.hrf_model(self.hrf_delay, self.stimulus.tr_length)
# convolve it
model = fftconvolve(response, hrf)[0:len(response)]
# units
model = self.normalizer(model)
# regress out mean and linear
beta, baseline = self.regress(model, self.data)
# offset
model += baseline
# scale
model *= beta
return model
def generate_ballpark_prediction(self, x, y, sigma, weight):
r"""
Predict signal for the Gaussian Model using the downsampled stimulus.
The rate of stimulus downsampling is defined in `model.stimulus.scale_factor`.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
weight: float
Mixture of the magnocellar and parvocellular temporal response to
a flickering visual stimulus. The `weight` ranges between 0 and 1,
with 0 being a totally magnocellular response and ` being a totally
parvocellular response.
"""
# mask for speed
mask = self.distance_mask_coarse(x, y, sigma)
# generate the RF
spatial_rf = generate_og_receptive_field(x, y, sigma,
self.stimulus.deg_x0,
self.stimulus.deg_y0)
spatial_rf /= ((2 * np.pi * sigma**2) * 1 /
np.diff(self.stimulus.deg_x0[0, 0:2])**2)
# spatial_response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr0,
spatial_rf, mask)
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp,
self.stimulus.flicker_vec)
# mix them
mp_ts = (1 - weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(mp_ts, self.hrf())[0:len(mp_ts)]
# units
model = self.normalizer(model)
# regress out mean and linear
p = linregress(model, self.data)
# scale
model *= p[0]
# offset
model += p[1]
return model
def generate_ballpark_prediction(self, x, y, sigma, hrf_delay):
# mask for speed
mask = self.distance_mask_coarse(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x0, self.stimulus.deg_y0)
rf /= (2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x0[0,0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr0, rf, mask)
# convolve it with the stimulus
hrf = self.hrf_model(hrf_delay, self.stimulus.tr_length)
model = fftconvolve(response, hrf)[0:len(response)]
# units
model = (model-np.mean(model)) / np.mean(model)
# regress out mean and linear
p = linregress(model, self.data)
# offset
model += p[1]
# scale
model *= np.abs(p[0])
return model
def generate_ballpark_prediction(self, x, y, sigma, weight):
# mask for speed
mask = self.distance_mask_coarse(x, y, sigma)
# generate the RF
spatial_rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x0, self.stimulus.deg_y0)
spatial_rf /= ((2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x0[0,0:2])**2)
# spatial_response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr0, spatial_rf, mask)
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp, self.stimulus.flicker_vec)
# mix them
mp_ts = (1-weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(mp_ts, self.hrf())[0:len(mp_ts)]
# units
model = (model - np.mean(model)) / np.mean(model)
# regress out mean and linear
p = linregress(model, self.data)
# offset
model += p[1]
# scale
model *= np.abs(p[0])
return model
def generate_prediction(self, x, y, sigma, mbeta, pbeta):
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
spatial_rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x, self.stimulus.deg_y)
spatial_rf /= ((2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x[0,0:2])**2)
# spatial response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr, spatial_rf, mask)
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp, self.stimulus.flicker_vec)
# convolve with HRF
hrf = self.hrf_model(self.hrf_delay, self.stimulus.tr_length)
# M
m_model = fftconvolve(m_ts, hrf)[0:len(m_ts)]
# P
p_model = fftconvolve(p_ts, hrf)[0:len(p_ts)]
# convert units
m_model = (m_model - np.mean(m_model))/np.mean(m_model)
p_model = (p_model - np.mean(p_model))/np.mean(p_model)
# mix
model = m_model * mbeta + p_model * pbeta
return model
def generate_prediction(self, x, y, sigma, hrf_delay, beta, baseline):
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x, self.stimulus.deg_y)
rf /= (2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x[0,0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr, rf, mask)
# convolve it with the stimulus
hrf = self.hrf_model(hrf_delay, self.stimulus.tr_length)
model = fftconvolve(response, hrf)[0:len(response)]
# units
model = (model-np.mean(model)) / np.mean(model)
# offset
model += baseline
# scale it by beta
model *= beta
return model
def generate_prediction(self, x, y, sigma, theta, phi, cpd):
# make sure theta and phi are 0-2*pi
theta = np.mod(theta, 2*np.pi)
phi = np.mod(theta, 2*np.pi)
# create mask for speed
distance = (self.stimulus.deg_x - x)**2 + (self.stimulus.deg_y - y)**2
mask = np.zeros_like(distance, dtype='uint8')
mask[distance < (5*sigma)**2] = 1
# generate the RF
rf = generate_gabor_receptive_field(x, y, sigma, theta, phi, cpd,
self.stimulus.deg_x, self.stimulus.deg_y)
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr, rf, mask)
# convolve with the HRF
hrf = self.hrf_model(0, self.stimulus.tr_length)
# convolve it with the stimulus
model = fftconvolve(response, hrf, 'same')
return model
def generate_prediction(self, x, y, sigma, weight, beta, hrf_delay):
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
spatial_rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x, self.stimulus.deg_y)
spatial_rf /= (2 * np.pi * sigma ** 2) * 1 / np.diff(self.stimulus.deg_x[0, 0:2]) ** 2
# spatial response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr, spatial_rf, mask)
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp, self.stimulus.flicker_vec)
# mix them
mp_ts = (1 - weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(mp_ts, self.hrf_model(hrf_delay, self.stimulus.tr_length))[0 : len(mp_ts)]
# convert units
model = (model - np.mean(model)) / np.mean(model)
# scale
model *= beta
return model
def generate_prediction(self, x, y, sigma, n, weight, beta, baseline):
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
spatial_rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x, self.stimulus.deg_y)
spatial_rf /= ((2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x[0,0:2])**2)
# spatial response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr, spatial_rf, mask)
# compression
spatial_ts **= n
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp, self.stimulus.flicker_vec)
# mix them
mp_ts = (1-weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(mp_ts, self.hrf())[0:len(mp_ts)]
# convert units
model = (model - np.mean(model)) / np.mean(model)
# scale
model *= beta
# offset
model += baseline
return model
def generate_prediction(self, x, y, sigma, weight, beta, baseline):
r"""
Predict signal for the Gaussian Model using the full resolution stimulus.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
weight: float
Mixture of the magnocellar and parvocellular temporal response to
a flickering visual stimulus. The `weight` ranges between 0 and 1,
with 0 being a totally magnocellular response and ` being a totally
parvocellular response.
beta : float
Amplitude scaling factor to account for units.
baseline: float
Amplitude intercept to account for baseline.
"""
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
spatial_rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x, self.stimulus.deg_y)
spatial_rf /= ((2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x[0,0:2])**2)
# spatial response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr, spatial_rf, mask)
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp, self.stimulus.flicker_vec)
# mix them
mp_ts = (1-weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(mp_ts, self.hrf())[0:len(mp_ts)]
# units
model = (model - np.mean(model)) / np.mean(model)
# offset
model += baseline
# scale it by beta
model *= beta
return model
def generate_ballpark_prediction(self, x, y, sigma, weight):
r"""
Predict signal for the Gaussian Model using the downsampled stimulus.
The rate of stimulus downsampling is defined in `model.stimulus.scale_factor`.
Parameters
__________
x : float
Horizontal location of the 2D Cosine RF.
y: float
Vertical location of the 2D Cosine RF.
sigma: float
Dipsersion of the 2D Cosine RF.
weight: float
Mixture of the magnocellar and parvocellular temporal response to
a flickering visual stimulus. The `weight` ranges between 0 and 1,
with 0 being a totally magnocellular response and ` being a totally
parvocellular response.
"""
# generate the RF
spatial_rf = generate_2dcos_receptive_field(x, y, sigma, self.power, self.stimulus.deg_x0, self.stimulus.deg_y0)
# normalize by volume
spatial_rf /= (trapz(trapz(spatial_rf)) * 1/np.diff(self.stimulus.deg_x0[0,0:2])**2)
# make mask
mask = np.uint8(spatial_rf>0)
# spatial_response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr0, spatial_rf, mask)
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp, self.stimulus.flicker_vec)
# mix them
mp_ts = (1-weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(mp_ts, self.hrf())[0:len(mp_ts)]
# units
model = (model - np.mean(model)) / np.mean(model)
# regress out mean and linear
p = linregress(model, self.data)
# offset
model += p[1]
# scale
model *= p[0]
return model
def generate_prediction(self, x, y, sigma, hrf_delay, beta, baseline, unscaled=False):
r"""
Predict signal for the Gaussian Model.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
hrf_delay: float
The delay of the hemodynamic response function (HRF). We assume the
cannonical HRF delay is 5 s, and that this parameter is a deviation
+/- that 5 s.
beta : float
Amplitude scaling factor to account for units.
baseline: float
Amplitude intercept to account for baseline.
"""
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x, self.stimulus.deg_y)
rf /= (2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x[0,0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr, rf, mask)
# convolve it with the stimulus
hrf = self.hrf_model(hrf_delay, self.stimulus.tr_length)
model = fftconvolve(response, hrf)[0:len(response)]
# units
model = self.normalizer(model)
if unscaled:
return model
else:
# offset
model += baseline
# scale it by beta
model *= beta
return model
def generate_prediction(self, x, y, sigma, hrf_delay, beta, baseline):
r"""
Predict signal for the Gaussian Model.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
hrf_delay: float
The delay of the hemodynamic response function (HRF). We assume the
cannonical HRF delay is 5 s, and that this parameter is a deviation
+/- that 5 s.
beta : float
Amplitude scaling factor to account for units.
baseline: float
Amplitude intercept to account for baseline.
"""
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x, self.stimulus.deg_y)
rf /= (2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x[0,0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr, rf, mask)
# convolve it with the stimulus
hrf = self.hrf_model(hrf_delay, self.stimulus.tr_length)
model = fftconvolve(response, hrf)[0:len(response)]
# units
model = (model-np.mean(model)) / np.mean(model)
# offset
model += baseline
# scale it by beta
model *= beta
return model
def generate_ballpark_prediction(self, x, y, sigma, hrf_delay):
r"""
Predict signal for the Gaussian Model using the downsampled stimulus.
The rate of stimulus downsampling is defined in `model.stimulus.scale_factor`.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
hrf_delay: float
The delay of the hemodynamic response function (HRF). We assume the
cannonical HRF delay is 5 s, and that this parameter is a deviation
+/- that 5 s.
"""
# mask for speed
mask = self.distance_mask_coarse(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x0,
self.stimulus.deg_y0)
rf /= (2 * np.pi * sigma**2) * 1 / np.diff(
self.stimulus.deg_x0[0, 0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr0, rf, mask)
# convolve it with the stimulus
hrf = self.hrf_model(hrf_delay, self.stimulus.tr_length)
model = fftconvolve(response, hrf)[0:len(response)]
# units
model = self.normalizer(model)
# regress out mean and linear
p = linregress(model, self.data)
# scale
model *= p[0]
# offset
model += p[1]
return model
def generate_prediction(self, x, y, sigma, beta, baseline, unscaled=False):
r"""
Predict signal for the Gaussian Model.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
beta : float
Amplitude scaling factor to account for units.
baseline: float
Amplitude intercept to account for baseline.
"""
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x,
self.stimulus.deg_y)
rf /= (2 * np.pi * sigma**2) * 1 / np.diff(self.stimulus.deg_x[0,
0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr, rf, mask)
# convolve it with the stimulus
model = fftconvolve(response, self.hrf())[0:len(response)]
# units
model = self.normalizer(model)
if unscaled:
return model
else:
# scale it by beta
model *= beta
# offset
model += baseline
return model
def generate_ballpark_prediction(self, x, y, sigma, hrf_delay):
r"""
Predict signal for the Gaussian Model using the downsampled stimulus.
The rate of stimulus downsampling is defined in `model.stimulus.scale_factor`.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
hrf_delay: float
The delay of the hemodynamic response function (HRF). We assume the
cannonical HRF delay is 5 s, and that this parameter is a deviation
+/- that 5 s.
"""
# mask for speed
mask = self.distance_mask_coarse(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x0, self.stimulus.deg_y0)
rf /= (2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x0[0,0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr0, rf, mask)
# convolve it with the stimulus
hrf = self.hrf_model(hrf_delay, self.stimulus.tr_length)
model = fftconvolve(response, hrf)[0:len(response)]
# units
model = self.normalizer(model)
# regress out mean and linear
p = linregress(model, self.data)
# offset
model += p[1]
# scale
model *= p[0]
return model
def generate_ballpark_prediction(self, x, y, sigma):
r"""
Predict signal for the Gaussian Model using the downsampled stimulus.
The rate of stimulus downsampling is defined in `model.stimulus.scale_factor`.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
"""
# mask for speed
mask = self.distance_mask_coarse(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x0,
self.stimulus.deg_y0)
rf /= (2 * np.pi * sigma**2) * 1 / np.diff(
self.stimulus.deg_x0[0, 0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr0, rf, mask)
# convolve it with the stimulus
model = fftconvolve(response, self.hrf())[0:len(response)]
# units
model = self.normalizer(model)
# regress out mean and amplitude
beta, baseline = self.regress(model, self.data)
# scale
model *= beta
# offset
model += baseline
return model
def generate_ballpark_prediction(self, x, y, sigma):
r"""
Predict signal for the Gaussian Model using the downsampled stimulus.
The rate of stimulus downsampling is defined in `model.stimulus.scale_factor`.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
"""
# mask for speed
mask = self.distance_mask_coarse(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x0, self.stimulus.deg_y0)
rf /= (2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x0[0,0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr0, rf, mask)
# convolve it with the stimulus
model = fftconvolve(response, self.hrf())[0:len(response)]
# units
model = self.normalizer(model)
# regress out mean and amplitude
beta, baseline = self.regress(model, self.data)
# offset
model += baseline
# scale
model *= beta
return model
def generate_prediction(self, x, y, sigma, beta, baseline, hrf_delay):
r"""
Predict signal for the Gaussian Model using the downsampled stimulus.
The rate of stimulus downsampling is defined in `model.stimulus.scale_factor`.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
"""
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x,
self.stimulus.deg_y)
rf /= (2 * np.pi * sigma**2) * 1 / np.diff(self.stimulus.deg_x[0,
0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr, rf, mask)
# convolve it with the stimulus
model = fftconvolve(response, self.hrf_delay())[0:len(response)]
# units
model = (model - np.mean(model)) / np.mean(model)
# offset
model += baseline
# scale it by beta
model *= beta
return model
def generate_ballpark_prediction(self, x, y, sigma, n, weight):
# mask for speed
mask = self.distance_mask_coarse(x, y, sigma)
# generate the RF
spatial_rf = generate_og_receptive_field(x, y, sigma,
self.stimulus.deg_x0,
self.stimulus.deg_y0)
spatial_rf /= ((2 * np.pi * sigma**2) * 1 /
np.diff(self.stimulus.deg_x0[0, 0:2])**2)
# spatial_response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr0,
spatial_rf, mask)
# compression
spatial_ts **= n
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp,
self.stimulus.flicker_vec)
# mix them
mp_ts = (1 - weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(mp_ts, self.hrf())[0:len(mp_ts)]
# units
# model = (model - np.mean(model)) / np.mean(model)
model = self.normalizer(model)
# regress out mean and linear
p = linregress(model, self.data)
# scale
model *= p[0]
# offset
model += p[1]
return model
def generate_prediction(self, x, y, sigma, beta, baseline, hrf_delay):
r"""
Predict signal for the Gaussian Model using the downsampled stimulus.
The rate of stimulus downsampling is defined in `model.stimulus.scale_factor`.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
"""
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x, self.stimulus.deg_y)
rf /= (2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x[0,0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr, rf, mask)
# convolve it with the stimulus
model = fftconvolve(response, self.hrf_delay())[0:len(response)]
# units
model = (model-np.mean(model)) / np.mean(model)
# offset
model += baseline
# scale it by beta
model *= beta
return model
def estimate_scaling(self, x, y, sigma):
# mask for speed
mask = self.distance_mask_coarse(x, y, sigma)
# generate the RF
rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x0, self.stimulus.deg_y0)
rf /= (2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x0[0,0:2])**2
# extract the stimulus time-series
response = generate_rf_timeseries(self.stimulus.stim_arr0, rf, mask)
# convolve it with the stimulus
model = fftconvolve(response, self.hrf())[0:len(response)]
# units
model = (model-np.mean(model)) / np.mean(model)
# regress out mean and linear
p = linregress(model, self.data)
return p
def generate_prediction(self, x, y, sigma, n, weight, beta, baseline, unscaled=False):
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
spatial_rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x, self.stimulus.deg_y)
spatial_rf /= ((2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x[0,0:2])**2)
# spatial response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr, spatial_rf, mask)
# compression
spatial_ts **= n
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp, self.stimulus.flicker_vec)
# mix them
mp_ts = (1-weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(mp_ts, self.hrf())[0:len(mp_ts)]
# convert units
model = self.normalizer(model)
if unscaled:
return model
else:
# scale
model *= beta
# offset
model += baseline
return model
def generate_prediction(self, x, y, sigma, sigma_ratio, volume_ratio, beta, baseline, unscaled=False):
# extract the center response
rf_center = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x, self.stimulus.deg_y)
# extract surround response
rf_surround = generate_og_receptive_field(x, y, sigma*sigma_ratio,
self.stimulus.deg_x, self.stimulus.deg_y) * 1/sigma_ratio**2
# difference
rf = ne.evaluate('rf_center - sqrt(volume_ratio)*rf_surround')
# extract the response
mask = self.distance_mask(x, y, sigma*sigma_ratio)
response = generate_rf_timeseries(self.stimulus.stim_arr, rf, mask)
# generate the hrf
hrf = self.hrf_model(self.hrf_delay, self.stimulus.tr_length)
# convolve it
model = fftconvolve(response, hrf)[0:len(response)]
# units
model = self.normalizer(model)
if unscaled:
return model
else:
# offset
model += baseline
# scale it by beta
model *= beta
return model
def generate_prediction(self, x, y, sigma, weight, beta, baseline, unscaled=False):
r"""
Predict signal for the Gaussian Model using the full resolution stimulus.
Parameters
__________
x : float
Horizontal location of the 2D Cosine RF.
y: float
Vertical location of the 2D Cosine RF.
sigma: float
Dipsersion of the 2D Cosine RF.
weight: float
Mixture of the magnocellar and parvocellular temporal response to
a flickering visual stimulus. The `weight` ranges between 0 and 1,
with 0 being a totally magnocellular response and ` being a totally
parvocellular response.
beta : float
Amplitude scaling factor to account for units.
baseline: float
Amplitude intercept to account for baseline.
"""
# generate the RF
spatial_rf = generate_2dcos_receptive_field(x, y, sigma, self.power, self.stimulus.deg_x, self.stimulus.deg_y)
# normalize by volume
spatial_rf /= (trapz(trapz(spatial_rf)) * 1/np.diff(self.stimulus.deg_x[0,0:2])**2)
# make mask
mask = np.uint8(spatial_rf>0)
# spatial response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr, spatial_rf, mask)
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp, self.stimulus.flicker_vec)
# mix them
mp_ts = (1-weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(mp_ts, self.hrf())[0:len(mp_ts)]
# units
model = (model - np.mean(model)) / np.mean(model)
if unscaled:
return model
else:
# offset
model += baseline
# scale it by beta
model *= beta
return model
def generate_ballpark_prediction(self, x, y, sigma, weight, hrf_delay):
r"""
Predict signal for the Gaussian Model using the downsampled stimulus.
The rate of stimulus downsampling is defined in `model.stimulus.scale_factor`.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
weight: float
Mixture of the magnocellar and parvocellular temporal response to
a flickering visual stimulus. The `weight` ranges between 0 and 1,
with 0 being a totally magnocellular response and ` being a totally
parvocellular response.
hrf_delay : float
The delay of the peak and undershoot of the hemodynamic response
function in seconds. This is a number varying about 0 which will
be added to the 5 and 15, representing the constant delay of the
peak and undershoot.
"""
# mask for speed
mask = self.distance_mask_coarse(x, y, sigma)
# generate the RF
spatial_rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x0, self.stimulus.deg_y0)
spatial_rf /= ((2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x0[0,0:2])**2)
# spatial_response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr0, spatial_rf, mask)
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp, self.stimulus.flicker_vec)
# mix them
mp_ts = (1-weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(mp_ts, self.hrf_model(hrf_delay, self.stimulus.tr_length))[0:len(mp_ts)]
# units
model = self.normalizer(model)
# regress out mean and linear
p = linregress(model, self.data)
# offset
model += p[1]
# scale
model *= p[0]
return model
def generate_prediction(self, x, y, sigma, weight, hrf_delay, beta, baseline, unscaled=False):
r"""
Predict signal for the Gaussian Model using the full resolution stimulus.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
weight: float
Mixture of the magnocellar and parvocellular temporal response to
a flickering visual stimulus. The `weight` ranges between 0 and 1,
with 0 being a totally magnocellular response and ` being a totally
parvocellular response.
hrf_delay : float
The delay of the peak and undershoot of the hemodynamic response
function in seconds. This is a number varying about 0 which will
be added to the 5 and 15, representing the constant delay of the
peak and undershoot.
beta : float
Amplitude scaling factor to account for units.
baseline: float
Amplitude intercept to account for baseline.
"""
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
spatial_rf = generate_og_receptive_field(x, y, sigma, self.stimulus.deg_x, self.stimulus.deg_y)
spatial_rf /= ((2 * np.pi * sigma**2) * 1/np.diff(self.stimulus.deg_x[0,0:2])**2)
# spatial response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr, spatial_rf, mask)
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp, self.stimulus.flicker_vec)
# mix them
mp_ts = (1-weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(mp_ts, self.hrf_model(hrf_delay, self.stimulus.tr_length))[0:len(mp_ts)]
# convert units
model = self.normalizer(model)
if unscaled:
return model
else:
# scale
model *= beta
# offset
model += baseline
return model
def generate_prediction(self,
x,
y,
sigma,
weight,
hrf_delay,
beta,
baseline,
unscaled=False):
r"""
Predict signal for the Gaussian Model using the full resolution stimulus.
Parameters
__________
x : float
Horizontal location of the Gaussian RF.
y: float
Vertical location of the Gaussian RF.
sigma: float
Dipsersion of the Gaussian RF.
weight: float
Mixture of the magnocellar and parvocellular temporal response to
a flickering visual stimulus. The `weight` ranges between 0 and 1,
with 0 being a totally magnocellular response and ` being a totally
parvocellular response.
hrf_delay : float
The delay of the peak and undershoot of the hemodynamic response
function in seconds. This is a number varying about 0 which will
be added to the 5 and 15, representing the constant delay of the
peak and undershoot.
beta : float
Amplitude scaling factor to account for units.
baseline: float
Amplitude intercept to account for baseline.
"""
# mask for speed
mask = self.distance_mask(x, y, sigma)
# generate the RF
spatial_rf = generate_og_receptive_field(x, y, sigma,
self.stimulus.deg_x,
self.stimulus.deg_y)
spatial_rf /= ((2 * np.pi * sigma**2) * 1 /
np.diff(self.stimulus.deg_x[0, 0:2])**2)
# spatial response
spatial_ts = generate_rf_timeseries(self.stimulus.stim_arr, spatial_rf,
mask)
# temporal response
m_ts, p_ts = generate_mp_timeseries(spatial_ts, self.m_amp, self.p_amp,
self.stimulus.flicker_vec)
# mix them
mp_ts = (1 - weight) * m_ts + weight * p_ts
# convolve with HRF
model = fftconvolve(
mp_ts, self.hrf_model(hrf_delay,
self.stimulus.tr_length))[0:len(mp_ts)]
# convert units
model = self.normalizer(model)
if unscaled:
return model
else:
# scale
model *= beta
# offset
model += baseline
return model