def compute_model_ts(center_freq, sigma, spectrogram, freqs, target_times): # generate stimulus time-series rf = gaussian_1D(freqs, center_freq, sigma) # make sure sigma isn't too big # if np.any(np.round(rf[0],3) > 0): # return np.inf # if np.any(np.round(rf[-1],3) > 0): # return np.inf # create mask for speed distance = freqs - center_freq mask = np.zeros_like(distance, dtype='uint8') mask[distance < (5 * sigma)] = 1 # extract the response stim = generate_rf_timeseries_1D(spectrogram, rf, mask) # recast the stimulus into a time-series that i can source_times = np.linspace(0, target_times[-1], len(stim), endpoint=True) f = interp1d(source_times, stim, kind='linear') new_stim = f(target_times) # hard-set the hrf_delay hrf_delay = 0 # convolve it with the HRF hrf = utils.double_gamma_hrf(hrf_delay, 1.0, 10) stim_pad = np.tile(new_stim, 3) model = fftconvolve(stim_pad, hrf, 'same')[len(new_stim):len(new_stim) * 2] # normalize it model = utils.zscore(model) return model
def estimate_scaling(self, center_freq, sigma): # de-log the center and spread center_freq = np.e ** center_freq sigma = np.e ** sigma # generate stimulus time-series rf = np.exp(-((self.stimulus.freqs-center_freq)**2)/(2*sigma**2)) rf /= (sigma*np.sqrt(2*np.pi)) mask = np.ones_like(rf).astype('uint8') # extract the response response = generate_rf_timeseries_1D(self.stimulus.spectrogram, 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 to find beta and baseline p = linregress(model, self.data) return p
def generate_ballpark_prediction(self, center_freq, sigma, hrf_delay): r""" Generate a prediction for the 1D Gaussian model. This function generates a prediction of the 1D Gaussian model, given a stimulus and the stimulus-referred model parameters. This function operates on the native stimulus. Usually, the function `generate_ballpark_prediction` would operate on the downsampled stimulus. Paramaters ---------- center_freq : float The center frequency of the 1D Gaussian, units are in Hz. sigma : float The dispersion of the 1D Gaussian, units are in Hz. beta : float The scaling factor to account for arbitrary units of the BOLD signal. hrf_delay : float The delay of the HRF, units are in seconds. """ # receptive field rf = np.exp(-((10**self.stimulus.freqs - 10**center_freq)**2) / (2 * (10**sigma)**2)) rf /= (10**sigma * np.sqrt(2 * np.pi)) # # create mask for speed # distance = self.stimulus.freqs - center_freq # mask = np.zeros_like(distance, dtype='uint8') # mask[distance < (self.mask_size*sigma)] = 1 mask = np.ones_like(rf).astype('uint8') # extract the response response = generate_rf_timeseries_1D(self.stimulus.spectrogram, 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 to find beta and baseline p = linregress(model, self.data) # offset model += p[1] # scale it model *= np.abs(p[0]) return model
def generate_ballpark_prediction(self, center_freq, sigma, hrf_delay): r""" Generate a prediction for the 1D Gaussian model. This function generates a prediction of the 1D Gaussian model, given a stimulus and the stimulus-referred model parameters. This function operates on the native stimulus. Usually, the function `generate_ballpark_prediction` would operate on the downsampled stimulus. Paramaters ---------- center_freq : float The center frequency of the 1D Gaussian, units are in Hz. sigma : float The dispersion of the 1D Gaussian, units are in Hz. beta : float The scaling factor to account for arbitrary units of the BOLD signal. hrf_delay : float The delay of the HRF, units are in seconds. """ # receptive field rf = np.exp(-((10**self.stimulus.freqs-10**center_freq)**2)/(2*(10**sigma)**2)) rf /= (10**sigma*np.sqrt(2*np.pi)) # # create mask for speed # distance = self.stimulus.freqs - center_freq # mask = np.zeros_like(distance, dtype='uint8') # mask[distance < (self.mask_size*sigma)] = 1 mask = np.ones_like(rf).astype('uint8') # extract the response response = generate_rf_timeseries_1D(self.stimulus.spectrogram, 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 *= p[0] return model
def generate_prediction(self, center_freq, sigma, beta, baseline, hrf_delay): r""" Generate a prediction for the 1D Gaussian model. This function generates a prediction of the 1D Gaussian model, given a stimulus and the stimulus-referred model parameters. This function operates on the native stimulus. Paramaters ---------- center_freq : float The center frequency of the 1D Gaussian, units are in Hz. sigma : float The dispersion of the 1D Gaussian, units are in Hz. beta : float The scaling factor to account for arbitrary units of the BOLD signal. hrf_delay : float The delay of the HRF, units are in seconds. """ # de-log the center and spread center_freq = np.e ** center_freq sigma = np.e ** sigma # generate stimulus time-series rf = np.exp(-((self.stimulus.freqs-center_freq)**2)/(2*sigma**2)) rf /= (sigma*np.sqrt(2*np.pi)) # # create mask for speed # distance = self.stimulus.freqs - center_freq # mask = np.zeros_like(distance, dtype='uint8') # mask[distance < (self.mask_size*sigma)] = 1 mask = np.ones_like(rf).astype('uint8') # extract the response response = generate_rf_timeseries_1D(self.stimulus.spectrogram, rf, mask) # convolve it with the stimulus self.hrf_delay = hrf_delay model = fftconvolve(response, self.hrf())[0:len(response)] # units model = (model - np.mean(model)) / np.mean(model) # offset model += baseline # scale it model *= beta return model
def generate_prediction(self, center_freq, sigma, beta, baseline, unscaled=False): r""" Generate a prediction for the 1D Gaussian auditory pRF model. This function generates a prediction of the 1D Gaussian model, given a stimulus and the stimulus-referred model parameters. This function operates on a spectrogram representation of an auditory stimulus. Paramaters ---------- center_freq : float The center frequency of the 1D Gaussian, units are in Hz. sigma : float The dispersion of the 1D Gaussian, units are in Hz. baseline : float The y-intercept aka offset in amplitude to account for baseline. beta : float The scaling factor to account for arbitrary units of the BOLD signal. """ # receptive field rf = np.exp(-((10**self.stimulus.freqs-10**center_freq)**2)/(2*(10**sigma)**2)) rf /= (10**sigma*np.sqrt(2*np.pi)) # evaluate entire RF mask = np.ones_like(rf).astype('uint8') # extract the response response = generate_rf_timeseries_1D(self.stimulus.spectrogram, 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: # offset model += baseline # scale it by beta model *= beta return model
def generate_prediction(self, center_freq, sigma, beta, baseline, unscaled=False): r""" Generate a prediction for the 1D Gaussian auditory pRF model. This function generates a prediction of the 1D Gaussian model, given a stimulus and the stimulus-referred model parameters. This function operates on a spectrogram representation of an auditory stimulus. Paramaters ---------- center_freq : float The center frequency of the 1D Gaussian, units are in Hz. sigma : float The dispersion of the 1D Gaussian, units are in Hz. baseline : float The y-intercept aka offset in amplitude to account for baseline. beta : float The scaling factor to account for arbitrary units of the BOLD signal. """ # receptive field rf = np.exp(-((10**self.stimulus.freqs-10**center_freq)**2)/(2*(10**sigma)**2)) rf /= (10**sigma*np.sqrt(2*np.pi)) # evaluate entire RF mask = np.ones_like(rf).astype('uint8') # extract the response response = generate_rf_timeseries_1D(self.stimulus.spectrogram, 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, center_freq, sigma): r""" Generate a prediction for the 1D Gaussian model. This function generates a prediction of the 1D Gaussian model, given a stimulus and the stimulus-referred model parameters. This function operates on a spectrogram representation of an auditory stimulus. This method does not estimate the scaling paramter `beta` or the offset parameter `baseline`, since this method will be used for a grid-fit and these values can simply be calculated for a particular `center_freq` and `sigma` pair. Paramaters ---------- center_freq : float The center frequency of the 1D Gaussian, units are in Hz. sigma : float The dispersion of the 1D Gaussian, units are in Hz. """ # receptive field rf = np.exp(-((10**self.stimulus.freqs - 10**center_freq)**2) / (2 * (10**sigma)**2)) rf /= (10**sigma * np.sqrt(2 * np.pi)) # evaluate entire RF mask = np.ones_like(rf).astype('uint8') # extract the response response = generate_rf_timeseries_1D(self.stimulus.spectrogram, 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 to find beta and baseline p = linregress(model, self.data) # offset model += p[1] # scale it model *= np.abs(p[0]) return model
def generate_ballpark_prediction(self, center_freq, sigma): r""" Generate a prediction for the 1D Gaussian model. This function generates a prediction of the 1D Gaussian model, given a stimulus and the stimulus-referred model parameters. This function operates on a spectrogram representation of an auditory stimulus. This method does not estimate the scaling paramter `beta` or the offset parameter `baseline`, since this method will be used for a grid-fit and these values can simply be calculated for a particular `center_freq` and `sigma` pair. Paramaters ---------- center_freq : float The center frequency of the 1D Gaussian, units are in Hz. sigma : float The dispersion of the 1D Gaussian, units are in Hz. """ # receptive field rf = np.exp(-((10**self.stimulus.freqs-10**center_freq)**2)/(2*(10**sigma)**2)) rf /= (10**sigma*np.sqrt(2*np.pi)) # evaluate entire RF mask = np.ones_like(rf).astype('uint8') # extract the response response = generate_rf_timeseries_1D(self.stimulus.spectrogram, 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 compute_model_ts(center_freq, sigma, spectrogram, freqs, target_times): # generate stimulus time-series rf = gaussian_1D(freqs, center_freq, sigma) # make sure sigma isn't too big # if np.any(np.round(rf[0],3) > 0): # return np.inf # if np.any(np.round(rf[-1],3) > 0): # return np.inf # create mask for speed distance = freqs - center_freq mask = np.zeros_like(distance, dtype='uint8') mask[distance < (5*sigma)] = 1 # extract the response stim = generate_rf_timeseries_1D(spectrogram,rf,mask) # recast the stimulus into a time-series that i can source_times = np.linspace(0,target_times[-1],len(stim),endpoint=True) f = interp1d(source_times,stim,kind='linear') new_stim = f(target_times) # hard-set the hrf_delay hrf_delay = 0 # convolve it with the HRF hrf = utils.double_gamma_hrf(hrf_delay, 1.0, 10) stim_pad = np.tile(new_stim,3) model = fftconvolve(stim_pad, hrf,'same')[len(new_stim):len(new_stim)*2] # normalize it model = utils.zscore(model) return model