示例#1
0
文件: gabor.py 项目: arokem/popeye
 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
示例#2
0
 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
示例#3
0
 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
示例#4
0
文件: dog.py 项目: arokem/popeye
 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
示例#5
0
    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
示例#6
0
 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
示例#7
0
 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
示例#8
0
 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
示例#9
0
文件: og_hrf.py 项目: arokem/popeye
 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
示例#10
0
文件: og_hrf.py 项目: arokem/popeye
 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
示例#11
0
文件: og.py 项目: arokem/popeye
 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
示例#12
0
 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
示例#13
0
 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
示例#14
0
 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
示例#15
0
文件: dog.py 项目: arokem/popeye
 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
示例#16
0
 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
示例#17
0
 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
示例#18
0
 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