def test_noresample_stimulus(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,90) num_blank_steps = 0 num_bar_steps = 30 ecc = 12 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 1.0 pixels_across = 100 pixels_down = 100 dtype = ctypes.c_int16 Ns = 3 voxel_index = (1,2,3) auto_fit = True verbose = 1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # stimulus npt.assert_equal(stimulus.stim_arr.shape[0:2],stimulus.stim_arr0.shape[0:2]) npt.assert_equal(stimulus.deg_x.shape,stimulus.deg_x0.shape) npt.assert_equal(stimulus.deg_y.shape,stimulus.deg_y0.shape)
def test_kfold_xval_unique_runs(): # stimulus features pixels_across = 800 pixels_down = 600 viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,45) num_steps = 20 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.05 dtype = 'short' num_runs = 4 folds = 2 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, dtype=) # set up bounds for the grid search search_bounds = ((-10,10),(-10,10),(0.25,5.25),(-5,5),(0.1,1e2)) fit_bounds = ((-12,12),(-12,12),(1/stimulus.ppd,12),(-5,5),(0.1,1e2)) # initialize the gaussian model model = og.GaussianModel(stimulus) # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = 2.5 hrf_delay = -0.25 # create the args context for calling the Fit class fit_args = [search_bounds, fit_bounds, tr_length, [0,0,0],] fit_kwargs = {'auto_fit': False, 'verbose' : False} # create a series of "runs" data = np.zeros((stimulus.stim_arr.shape[-1],num_runs)) for r in range(num_runs): # fill out the data list data[:,r] = og.compute_model_ts(x, y, sigma, beta, hrf_delay, stimulus.deg_x, stimulus.deg_y, stimulus.stim_arr, tr_length) # get predictions out for each of the folds ... models = np.tile(model,num_runs) left_out_data, predictions = xval.kfold_xval(models, data, gaussian.GaussianFit, folds, fit_args, fit_kwargs) # assert the coeff of determination is 100 for each prediction for k in range(folds): cod = xval.coeff_of_determination(left_out_data[k], predictions[k]) npt.assert_almost_equal(cod,100, 4)
def test_noresample_stimulus(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,90) num_blank_steps = 0 num_bar_steps = 30 ecc = 12 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 1.0 pixels_across = 100 pixels_down = 100 dtype = ctypes.c_int16 Ns = 3 voxel_index = (1,2,3) auto_fit = True verbose = 1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # stimulus npt.assert_equal(stimulus.stim_arr.shape[0:2],stimulus.stim_arr0.shape[0:2]) npt.assert_equal(stimulus.deg_x.shape,stimulus.deg_x0.shape) npt.assert_equal(stimulus.deg_y.shape,stimulus.deg_y0.shape)
def test_dog(): # stimulus features pixels_across = 800 pixels_down = 600 viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,45) num_steps = 20 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.10 dtype = 'short' # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_steps, ecc) # resample the stimulus to 50% of original bar = resample_stimulus(bar, 0.50) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, dtype) # initialize the gaussian model model = dog.DifferenceOfGaussiansModel(stimulus) # set the pRF params x = -5.2 y = 2.5 sigma_center = 1.2 sigma_surround = 2.9 beta_center = 2.5 beta_surround = 1.6 hrf_delay = -0.2 # create "data" data = dog.compute_model_ts(x, y, sigma_center, sigma_surround, beta_center, beta_surround, hrf_delay, stimulus.deg_x, stimulus.deg_y, stimulus.stim_arr, tr_length) # first fit the one gaussian search_bounds = ((-10,10),(-10,10),(0.25,5.25),(0.1,1e2),(-5,5)) fit_bounds = ((-12,12),(-12,12),(1/stimulus.ppd,12),(0.1,1e3),(-5,5)) og_fit = og.GaussianFit(model, data, search_bounds, fit_bounds, tr_length, (1,2,3), False, False) # then fit the two gaussian fit_bounds = ((-12,12),(-12,12),(1/stimulus.ppd,12),(1/stimulus.ppd,12),(0.1,1e2),(0.1,1e2),(-5,5),) dog_fit = dog.DifferenceOfGaussiansFit(og_fit, fit_bounds, True, False) # assert equivalence nt.assert_almost_equal(dog_fit.x, x) nt.assert_almost_equal(dog_fit.y, y) nt.assert_almost_equal(dog_fit.sigma_center, sigma_center) nt.assert_almost_equal(dog_fit.sigma_surround, sigma_surround) nt.assert_almost_equal(dog_fit.beta_center, beta_center) nt.assert_almost_equal(dog_fit.beta_surround, beta_surround) nt.assert_almost_equal(dog_fit.hrf_delay, hrf_delay)
def generate_bars(): thetas = arange(0, 360, 90) thetas = insert(thetas, 0, -1) thetas = append(thetas, -1) num_blank_steps = 30 num_bar_steps = 30 ecc = 12 bar = simulate_bar_stimulus(N_PIXELS, N_PIXELS, VIEWING_DISTANCE, SCREEN_WIDTH, thetas, num_bar_steps, num_blank_steps, ecc) return bar
def test_resurrect_model(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,90) thetas = np.insert(thetas,0,-1) thetas = np.append(thetas,-1) num_blank_steps = 20 num_bar_steps = 20 ecc = 10 tr_length = 1.5 frames_per_tr = 1.0 scale_factor = 0.50 pixels_across = 100 pixels_down = 100 dtype = ctypes.c_int16 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc, clip=0.01) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # set cache grids x_grid = utils.grid_slice(-10, 10, 5) y_grid = utils.grid_slice(-10, 10, 5) s_grid = utils.grid_slice(0.55,5.25, 5) grids = (x_grid, y_grid, s_grid,) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.spm_hrf) model.hrf_delay = 0 model.mask_size = 5 # seed rng np.random.seed(4932) # cache the model cache = model.cache_model(grids, ncpus=3) # resurrect cached model cached_model_path = '/tmp/og_cached_model.pkl' model = og.GaussianModel(stimulus, utils.double_gamma_hrf, cached_model_path=cached_model_path) model.hrf_delay = 0 model.mask_size = 5 # make sure the same nt.assert_true(np.sum([c[0] for c in cache] - model.cached_model_timeseries) == 0) nt.assert_true(np.sum([c[1] for c in cache] - model.cached_model_parameters) == 0)
def test_cache_model_Ns(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,90) thetas = np.insert(thetas,0,-1) thetas = np.append(thetas,-1) num_blank_steps = 20 num_bar_steps = 20 ecc = 10 tr_length = 1.5 frames_per_tr = 1.0 scale_factor = 0.50 pixels_across = 100 pixels_down = 100 dtype = ctypes.c_int16 Ns = 5 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc, clip=0.01) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.spm_hrf) model.hrf_delay = 0 model.mask_size = 5 # set cache grids x_grid = (-10, 10) y_grid = (-10, 10) s_grid = (0.55,5.25) grids = (x_grid, y_grid, s_grid,) # seed rng np.random.seed(4932) # cache the pRF model cache = model.cache_model(grids, Ns=Ns, ncpus=3) # save it out pickle.dump(cache, open('/tmp/og_cached_model.pkl','wb')) # make sure its the right size cached_model = pickle.load(open('/tmp/og_cached_model.pkl','rb')) nt.assert_equal(np.sum([c[0] for c in cache]),np.sum([c[0] for c in cached_model]))
def test_og_fit(): # stimulus features pixels_across = 800 pixels_down = 600 viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,45) num_steps = 20 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.05 dtype='short' # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, dtype) # set up bounds for the grid search search_bounds = ((-10,10),(-10,10),(0.25,5.25),(0.1,1e2),(-5,5),) fit_bounds = ((-12,12),(-12,12),(1/stimulus.ppd,12),(0.1,1e3),(-5,5),) # initialize the gaussian model model = og.GaussianModel(stimulus) # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = 2.5 hrf_delay = -0.25 # create the "data" data = og.compute_model_ts(x, y, sigma, beta, hrf_delay, stimulus.deg_x, stimulus.deg_y, stimulus.stim_arr, tr_length) # fit the response fit = og.GaussianFit(model, data, search_bounds, fit_bounds, tr_length) # assert equivalence nt.assert_almost_equal(fit.x, x) nt.assert_almost_equal(fit.y, y) nt.assert_almost_equal(fit.sigma, sigma) nt.assert_almost_equal(fit.beta, beta) nt.assert_almost_equal(fit.hrf_delay, hrf_delay)
def test_resample_stimulus(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,90) num_blank_steps = 0 num_bar_steps = 30 ecc = 12 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.50 pixels_across = 100 pixels_down = 100 dtype = ctypes.c_int16 Ns = 3 voxel_index = (1,2,3) auto_fit = True verbose = 1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # grab the stimulus dimensions stim_dims = stimulus.stim_arr.shape stim_coarse_dims = stimulus.stim_arr0.shape # assert nt.assert_true(stim_coarse_dims[0]/stim_dims[0] == scale_factor) nt.assert_true(stim_coarse_dims[1]/stim_dims[1] == scale_factor) nt.assert_true(stim_coarse_dims[2] == stim_dims[2]) npt.assert_array_equal(np.unique(stimulus.stim_arr0), [0, 1]) # make sure the duty-cycle doesn't change with resampling npt.assert_almost_equal(np.sum(stimulus.stim_arr0==1)/np.sum(stimulus.stim_arr0>-1),np.sum(stimulus.stim_arr==1)/np.sum(stimulus.stim_arr>-1),3)
def test_strf_fit(): viewing_distance = 38 screen_width = 25 thetas = np.tile(np.arange(0,360,90),2) thetas = np.insert(thetas,0,-1) thetas = np.append(thetas,-1) num_blank_steps = 20 num_bar_steps = 20 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.50 pixels_down = 200 pixels_across = 200 dtype = ctypes.c_int16 Ns = 3 voxel_index = (1,2,3) auto_fit = True verbose = 1 projector_hz = 480 tau = 0.00875 mask_size = 5 hrf = 0.25 # create the sweeping bar stimulus in memory stim = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(stim, viewing_distance, screen_width, scale_factor, tr_length, dtype) stimulus.fps = projector_hz flicker_vec = np.zeros_like(stim[0,0,:]).astype('uint8') flicker_vec[1*20:5*20] = 1 flicker_vec[5*20:9*20] = 2 stimulus.flicker_vec = flicker_vec stimulus.flicker_hz = [10,20] # initialize the gaussian model model = strf.SpatioTemporalModel(stimulus, utils.spm_hrf) model.tau = tau model.hrf_delay = hrf model.mask_size = mask_size # generate a random pRF estimate x = -2.24 y = 1.58 sigma = 1.23 weight = 0.90 beta = 1.0 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, weight, beta, baseline) # set search grid x_grid = utils.grid_slice(-8.0,7.0,5) y_grid = utils.grid_slice(-8.0,7.0,5) s_grid = utils.grid_slice(0.75,3.0,5) w_grid = utils.grid_slice(0.05,0.95,5) # set search bounds x_bound = (-10,10) y_bound = (-10,10) s_bound = (1/stimulus.ppd,10) w_bound = (1e-8,1.0) b_bound = (1e-8,1e5) u_bound = (None, None) # loop over each voxel and set up a GaussianFit object grids = (x_grid, y_grid, s_grid, w_grid,) bounds = (x_bound, y_bound, s_bound, w_bound, b_bound, u_bound) # fit the response fit = strf.SpatioTemporalFit(model, data, grids, bounds) # coarse fit ballpark = [-0.5, 3.25, 2.4375, 0.94999999999999996, 1.0292, -0.24999999999999992] npt.assert_almost_equal((fit.x0,fit.y0,fit.sigma0,fit.weight0,fit.beta0,fit.baseline0),ballpark,4) # fine fit npt.assert_almost_equal(fit.x, x, 2) npt.assert_almost_equal(fit.y, y, 2) npt.assert_almost_equal(fit.sigma, sigma, 2) npt.assert_almost_equal(fit.weight, weight, 2) npt.assert_almost_equal(fit.beta, beta, 2) npt.assert_almost_equal(fit.baseline, baseline, 2) # overloaded npt.assert_almost_equal(fit.overloaded_estimate, [ 2.5272803, 2.7411676, 1.23 , 0.9 , 1. , -0.25 ], 2) m_rf = fit.model.m_rf(fit.model.tau) p_rf = fit.model.p_rf(fit.model.tau) npt.assert_almost_equal(simps(np.abs(m_rf)),simps(p_rf),2) # responses m_resp = fit.model.generate_m_resp(fit.model.tau) p_resp = fit.model.generate_p_resp(fit.model.tau) npt.assert_(np.max(m_resp,0)[0]<np.max(m_resp,0)[1]) npt.assert_(np.max(p_resp,0)[0]>np.max(p_resp,0)[1]) # amps npt.assert_(fit.model.m_amp[0]<fit.model.m_amp[1]) npt.assert_(fit.model.p_amp[0]>fit.model.p_amp[1]) # receptive field rf = generate_og_receptive_field(x, y, sigma, fit.model.stimulus.deg_x, fit.model.stimulus.deg_y) rf /= (2 * np.pi * sigma**2) * 1/np.diff(model.stimulus.deg_x[0,0:2])**2 npt.assert_almost_equal(np.round(rf.sum()), np.round(fit.receptive_field.sum())) # test model == fit RF npt.assert_almost_equal(np.round(fit.model.generate_receptive_field(x,y,sigma).sum()), np.round(fit.receptive_field.sum()))
def test_kfold_xval_repeated_runs(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,90) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.10 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 Ns = 3 voxel_index = (1,2,3) auto_fit = True verbose = 1 num_runs = 4 folds = 2 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # set up bounds for the grid search grids = ((-10,10),(-10,10),(0.25,5.25)) bounds = ((-12,12),(-12,12),(1/stimulus.ppd,12),(1e-8,None),(None,None)) # set the grid smaples Ns = 5 # initialize the gaussian model model = og.GaussianModel(stimulus, utils.double_gamma_hrf) model.hrf_delay = 0 # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = 2.5 baseline = -0.25 # create the args context for calling the Fit class fit_args = [grids, bounds, [0,0,0], Ns] fit_kwargs = {'auto_fit': False, 'verbose' : 0} # create a series of "runs" data = np.zeros((num_runs,stimulus.stim_arr.shape[-1])) for r in range(num_runs): # fill out the data list data[r,:] = model.generate_prediction(x, y, sigma, beta, baseline) # get predictions out for each of the folds ... models = (model,) predictions = xval.kfold_xval(models, data, og.GaussianFit, folds, fit_args, fit_kwargs) # assert the coeff of determination is 100 for each prediction for p in predictions: cod = xval.coeff_of_determination(p.data,p.prediction) npt.assert_almost_equal(cod,100, 4) # def test_kfold_xval_unique_runs(): # # # stimulus features # pixels_across = 800 # pixels_down = 600 # viewing_distance = 38 # screen_width = 25 # thetas = np.arange(0,360,45) # num_steps = 20 # ecc = 10 # tr_length = 1.0 # frames_per_tr = 1.0 # scale_factor = 0.05 # dtype = ctypes.c_short # num_runs = 4 # folds = 2 # # # create the sweeping bar stimulus in memory # bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_steps, ecc) # # # create an instance of the Stimulus class # stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, dtype) # # # set up bounds for the grid search # grids = ((-10,10),(-10,10),(0.25,5.25),(0.1,1e2),(-5,5)) # bounds = ((-12,12),(-12,12),(1/stimulus.ppd,12),(0.1,1e3),(-5,5)) # # # initialize the gaussian model # model = og.GaussianModel(stimulus) # # # generate a random pRF estimate # x = -5.24 # y = 2.58 # sigma = 1.24 # beta = 2.5 # hrf_delay = -0.25 # # # create the args context for calling the Fit class # fit_args = [grids, bounds, tr_length, [0,0,0],] # fit_kwargs = {'auto_fit': False, 'verbose' : False} # # # create a series of "runs" # data = np.zeros((stimulus.stim_arr.shape[-1],num_runs)) # # for r in range(num_runs): # # # fill out the data list # data[:,r] = og.compute_model_ts(x, y, sigma, beta, hrf_delay, # stimulus.deg_x, stimulus.deg_y, # stimulus.stim_arr, tr_length) # # # # get predictions out for each of the folds ... # models = np.tile(model,num_runs) # left_out_data, predictions = xval.kfold_xval(models, data, og.GaussianFit, folds, fit_args, fit_kwargs) # # # assert the coeff of determination is 100 for each prediction # for k in range(folds): # cod = xval.coeff_of_determination(left_out_data[k], predictions[k]) # npt.assert_almost_equal(cod,100, 4)
def test_dog(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0, 360, 90) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.50 pixels_down = 50 pixels_across = 50 dtype = ctypes.c_int16 voxel_index = (1, 2, 3) auto_fit = True verbose = 1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = dog.DifferenceOfGaussiansModel(stimulus, utils.spm_hrf) model.hrf_delay = 0.2 # set the pRF params x = -1.4 y = 1.5 sigma = 1.0 sigma_ratio = 2.0 volume_ratio = 0.5 hrf_delay = -0.2 # create "data" data = model.generate_prediction( x, y, sigma, sigma_ratio, volume_ratio, ) # set up the grids x_grid = slice(-10, 10, 3) y_grid = slice(-10, 10, 3) s_grid = slice(1 / stimulus.ppd, 5, 3) sr_grid = slice(1.0, 5.0, 3) vr_grid = slice(0.01, 0.99, 3) grids = ( x_grid, y_grid, s_grid, sr_grid, vr_grid, ) # set up the bounds x_bound = (-ecc, ecc) y_bound = (-ecc, ecc) s_bound = (1 / stimulus.ppd, 5) sr_bound = (1.0, None) vr_bound = (1e-8, 1.0) bounds = ( x_bound, y_bound, s_bound, sr_bound, vr_bound, ) # fit it fit = dog.DifferenceOfGaussiansFit(model, data, grids, bounds, voxel_index) # coarse fit nt.assert_almost_equal((fit.x0, fit.y0, fit.s0, fit.sr0, fit.vr0), (-1.0, 2.0, 0.72833937882323319, 1.0, 0.01)) # fine fit nt.assert_almost_equal(fit.x, x) nt.assert_almost_equal(fit.y, y) nt.assert_almost_equal(fit.sigma, sigma) nt.assert_almost_equal(fit.sigma_ratio, sigma_ratio) nt.assert_almost_equal(fit.volume_ratio, volume_ratio) # test the RF rf = fit.model.receptive_field(*fit.estimate) est = fit.estimate.copy() est[2] *= 2 rf_new = fit.model.receptive_field(*est) value_1 = np.sqrt(simps(simps(rf))) value_2 = np.sqrt(simps(simps(rf_new))) nt.assert_almost_equal(value_2 / value_1, sigma_ratio, 1) # polar coordinates npt.assert_almost_equal( [fit.theta, fit.rho], [np.arctan2(y, x), np.sqrt(x**2 + y**2)])
def test_parallel_og_fit(): # stimulus features pixels_across = 800 pixels_down = 600 viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,45) num_steps = 20 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.05 dtype='short' num_voxels = multiprocessing.cpu_count()-1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, dtype) # set up bounds for the grid search search_bounds = [((-10,10),(-10,10),(0.25,5.25),(0.1,1e2),(-5,5),)]*num_voxels fit_bounds = [((-12,12),(-12,12),(1/stimulus.ppd,12),(0.1,1e3),(-5,5),)]*num_voxels # make fake voxel indices indices = [(1,2,3)]*num_voxels # initialize the gaussian model model = og.GaussianModel(stimulus) # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = 2.5 hrf_delay = -0.25 # create the simulated time-series timeseries = [] for voxel in range(num_voxels): # create "data" data = og.compute_model_ts(x, y, sigma, beta, hrf_delay, stimulus.deg_x, stimulus.deg_y, stimulus.stim_arr, tr_length) # append it timeseries.append(data) # package the data structure dat = zip(repeat(model,num_voxels), timeseries, search_bounds, fit_bounds, repeat(tr_length,num_voxels), indices, repeat(True,num_voxels), repeat(True,num_voxels)) # run analysis pool = multiprocessing.Pool(multiprocessing.cpu_count()-1) output = pool.map(og.parallel_fit,dat) pool.close() pool.join() # assert equivalence for fit in output: nt.assert_almost_equal(fit.x, x) nt.assert_almost_equal(fit.y, y) nt.assert_almost_equal(fit.sigma, sigma) nt.assert_almost_equal(fit.beta, beta) nt.assert_almost_equal(fit.hrf_delay, hrf_delay)
def test_parallel_fit_manual_grids(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,45) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.10 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 voxel_index = (1,2,3) auto_fit = True verbose = 1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.double_gamma_hrf) model.hrf_delay = 0 # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = 2.5 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, beta, baseline) # set search grid x_grid = slice(-5,4,5) y_grid = slice(-5,7,5) s_grid = slice(1/stimulus.ppd,5.25,5) b_grid = slice(0.1,4.0,5) # set search bounds x_bound = (-12.0,12.0) y_bound = (-12.0,12.0) s_bound = (1/stimulus.ppd,12.0) b_bound = (1e-8,1e2) m_bound = (None, None) # loop over each voxel and set up a GaussianFit object grids = (x_grid, y_grid, s_grid,) bounds = (x_bound, y_bound, s_bound, b_bound, m_bound) # make 3 voxels all_data = np.array([data,data,data]) num_voxels = data.shape[0] indices = [(1,2,3)]*3 # bundle the voxels bundle = utils.multiprocess_bundle(og.GaussianFit, model, all_data, grids, bounds, indices) # run analysis with sharedmem.Pool(np=3) as pool: output = pool.map(utils.parallel_fit, bundle) # assert equivalence for fit in output: npt.assert_almost_equal(fit.x, x, 2) npt.assert_almost_equal(fit.y, y, 2) npt.assert_almost_equal(fit.sigma, sigma, 2) npt.assert_almost_equal(fit.beta, beta, 2) npt.assert_almost_equal(fit.baseline, baseline, 2)
def test_strf_css_fit(): viewing_distance = 38 screen_width = 25 thetas = np.tile(np.arange(0,360,90),2) thetas = np.insert(thetas,0,-1) thetas = np.append(thetas,-1) num_blank_steps = 20 num_bar_steps = 20 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.50 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 Ns = 3 voxel_index = (1,2,3) auto_fit = True verbose = 1 projector_hz = 480 tau = 0.00875 mask_size = 5 hrf = 0.25 # create the sweeping bar stimulus in memory stim1 = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc, clip=0.33) # create the sweeping bar stimulus in memory stim2 = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc, clip=0.0001) stim = np.concatenate((stim1,stim2),-1) # create an instance of the Stimulus class stimulus = VisualStimulus(stim, viewing_distance, screen_width, scale_factor, tr_length, dtype) stimulus.fps = projector_hz flicker_vec = np.zeros_like(stim1[0,0,:]).astype('uint8') flicker_vec[1*20:5*20] = 1 flicker_vec[5*20:9*20] = 2 flicker_vec = np.tile(flicker_vec,2) stimulus.flicker_vec = flicker_vec stimulus.flicker_hz = [10,20,10,20] # initialize the gaussian model model = strf.SpatioTemporalModel(stimulus, utils.double_gamma_hrf) model.tau = tau model.hrf_delay = hrf model.mask_size = mask_size # generate a random pRF estimate x = -2.24 y = 1.58 sigma = 1.23 n = 0.90 weight = 0.95 beta = 1.0 baseline = 0 # create the "data" data = model.generate_prediction(x, y, sigma, n, weight, beta, baseline) # set search grid x_grid = utils.grid_slice(-8.0,7.0,3) y_grid = utils.grid_slice(-8.0,7.0,3) s_grid = utils.grid_slice(0.75,3.0,3) n_grid = utils.grid_slice(0.25,0.95,3) w_grid = utils.grid_slice(0.25,0.95,3) # set search bounds x_bound = (-10,10) y_bound = (-10,10) s_bound = (1/stimulus.ppd,10) n_bound = (1e-8,1.0-1e-8) w_bound = (1e-8,1.0-1e-8) b_bound = (1e-8,1e5) u_bound = (None, None) # loop over each voxel and set up a GaussianFit object grids = (x_grid, y_grid, s_grid, n_grid, w_grid,) bounds = (x_bound, y_bound, s_bound, n_bound, w_bound, b_bound, u_bound) # fit the response fit = strf.SpatioTemporalFit(model, data, grids, bounds) # coarse fit npt.assert_almost_equal((fit.x0,fit.y0,fit.sigma0, fit.n0, fit.weight0,fit.beta0,fit.baseline0),[-0.5 , -0.5 , 1.875, 0.95 , 0.95 , 1. , 0. ]) # fine fit npt.assert_almost_equal(fit.x, x, 1) npt.assert_almost_equal(fit.y, y, 1) npt.assert_almost_equal(fit.sigma, sigma, 1) npt.assert_almost_equal(fit.n, n, 1) npt.assert_almost_equal(fit.weight, weight, 1) npt.assert_almost_equal(fit.beta, beta, 1) npt.assert_almost_equal(fit.baseline, baseline, 1) # overloaded npt.assert_almost_equal(fit.overloaded_estimate, [2.5259863707822303, 2.7330681871539069, 1.3062396482386418, 0.9011492100931614, 0.94990930073215352, 1.0005707740082497],4) # rfs m_rf = fit.model.m_rf(fit.model.tau) p_rf = fit.model.p_rf(fit.model.tau) npt.assert_almost_equal(simps(np.abs(m_rf)),simps(p_rf),5) # responses m_resp = fit.model.generate_m_resp(fit.model.tau) p_resp = fit.model.generate_p_resp(fit.model.tau) npt.assert_(np.max(m_resp,0)[0]<np.max(m_resp,0)[1]) npt.assert_(np.max(p_resp,0)[0]>np.max(p_resp,0)[1]) # amps npt.assert_(fit.model.m_amp[0]<fit.model.m_amp[1]) npt.assert_(fit.model.p_amp[0]>fit.model.p_amp[1]) # receptive field npt.assert_almost_equal(4.0, fit.receptive_field.sum())
import ctypes, multiprocessing import numpy as np import sharedmem import popeye.og_hrf as og import popeye.utilities as utils from popeye.visual_stimulus import VisualStimulus, simulate_bar_stimulus # seed random number generator so we get the same answers ... np.random.seed(2764932) ### STIMULUS ## create sweeping bar stimulus sweeps = np.array([-1, 0, 90, 180, 270, -1]) # in degrees, -1 is blank bar = simulate_bar_stimulus(100, 100, 40, 20, sweeps, 30, 30, 10) ## create an instance of the Stimulus class stimulus = VisualStimulus(bar, 50, 25, 0.50, 1.0, ctypes.c_int16) ### MODEL ## initialize the gaussian model model = og.GaussianModel(stimulus, utils.double_gamma_hrf) ## generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 hrf_delay = -0.25 beta = 0.55 baseline = -0.88 x = 6
def test_og_fit(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,90) thetas = np.insert(thetas,0,-1) thetas = np.append(thetas,-1) num_blank_steps = 30 num_bar_steps = 30 ecc = 12 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.10 pixels_across = 100 pixels_down = 100 dtype = ctypes.c_int16 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.double_gamma_hrf) model.hrf_delay = 0 model.mask_size = 6 # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = 2.5 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, beta, baseline) # set search grid x_grid = (-10,10) y_grid = (-10,10) s_grid = (0.25,5.25) # set search bounds x_bound = (-12.0,12.0) y_bound = (-12.0,12.0) s_bound = (0.001,12.0) b_bound = (1e-8,None) m_bound = (None,None) # loop over each voxel and set up a GaussianFit object grids = (x_grid, y_grid, s_grid,) bounds = (x_bound, y_bound, s_bound, b_bound, m_bound) # fit the response fit = og.GaussianFit(model, data, grids, bounds, Ns=3) # coarse fit npt.assert_almost_equal(fit.x0,-10.0) npt.assert_almost_equal(fit.y0,0.0) npt.assert_almost_equal(fit.s0, 5.25) npt.assert_almost_equal(fit.beta0, 1.0) # assert equivalence npt.assert_almost_equal(fit.x, x, 2) npt.assert_almost_equal(fit.y, y, 2) npt.assert_almost_equal(fit.sigma, sigma, 2) npt.assert_almost_equal(fit.beta, beta, 2) # test receptive field rf = generate_og_receptive_field(x, y, sigma, fit.model.stimulus.deg_x, fit.model.stimulus.deg_y) npt.assert_almost_equal(np.round(rf.sum()), np.round(fit.receptive_field.sum())) # test model == fit RF npt.assert_almost_equal(np.round(fit.model.generate_receptive_field(x,y,sigma).sum()), np.round(fit.receptive_field.sum())) # def test_og_nuisance_fit(): # # # stimulus features # viewing_distance = 38 # screen_width = 25 # thetas = np.arange(0,360,90) # thetas = np.insert(thetas,0,-1) # thetas = np.append(thetas,-1) # num_blank_steps = 30 # num_bar_steps = 30 # ecc = 12 # tr_length = 1.0 # frames_per_tr = 1.0 # scale_factor = 1.0 # pixels_across = 200 # pixels_down = 200 # dtype = ctypes.c_int16 # # # create the sweeping bar stimulus in memory # bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, # screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # # # create an instance of the Stimulus class # stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # # # initialize the gaussian model # model = og.GaussianModel(stimulus, utils.double_gamma_hrf) # model.hrf_delay = 0 # # # generate a random pRF estimate # x = -5.24 # y = 2.58 # sigma = 0.98 # beta = 2.5 # baseline = 0.0 # # # create the "data" # data = model.generate_prediction(x, y, sigma, beta, baseline) # # # create nuisance signal # step = np.zeros(len(data)) # step[30:-30] = 1 # # # add to data # data += step # # # create design matrix # nuisance = sm.add_constant(step) # # # recreate model with nuisance # model = og.GaussianModel(stimulus, utils.double_gamma_hrf, nuisance) # model.hrf_delay = 0 # # # set search grid # x_grid = (-7,7) # y_grid = (-7,7) # s_grid = (0.25,3.25) # # # set search bounds # x_bound = (-10.0,10.0) # y_bound = (-10.0,10.0) # s_bound = (0.001,10.0) # b_bound = (1e-8,None) # m_bound = (None, None) # # # loop over each voxel and set up a GaussianFit object # grids = (x_grid, y_grid, s_grid,) # bounds = (x_bound, y_bound, s_bound, b_bound, m_bound) # # # fit the response # fit = og.GaussianFit(model, data, grids, bounds, Ns=3) # # # assert equivalence # nt.assert_almost_equal(fit.x, x, 1) # nt.assert_almost_equal(fit.y, y, 1) # nt.assert_almost_equal(fit.sigma, sigma, 1) # nt.assert_almost_equal(fit.beta, beta, 1)
def test_strf_hrf_fit(): viewing_distance = 38 screen_width = 25 thetas = np.tile(np.arange(0, 360, 90), 2) thetas = np.insert(thetas, 0, -1) thetas = np.append(thetas, -1) num_blank_steps = 20 num_bar_steps = 20 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.50 pixels_down = 200 pixels_across = 200 dtype = ctypes.c_int16 Ns = 3 voxel_index = (1, 2, 3) auto_fit = True verbose = 1 projector_hz = 480 tau = 0.00875 mask_size = 5 # create the sweeping bar stimulus in memory stim = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(stim, viewing_distance, screen_width, scale_factor, tr_length, dtype) stimulus.fps = projector_hz flicker_vec = np.zeros_like(stim[0, 0, :]).astype('uint8') flicker_vec[1 * 20:5 * 20] = 1 flicker_vec[5 * 20:9 * 20] = 2 stimulus.flicker_vec = flicker_vec stimulus.flicker_hz = [10, 20] # initialize the gaussian model model = strf.SpatioTemporalModel(stimulus, utils.double_gamma_hrf) model.tau = tau model.mask_size = mask_size # generate a random pRF estimate x = -2.24 y = 1.58 sigma = 1.23 weight = 0.90 hrf_delay = -0.13 beta = 1.0 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, weight, hrf_delay, beta, baseline) # set search grid x_grid = utils.grid_slice(-8.0, 7.0, 3) y_grid = utils.grid_slice(-8.0, 7.0, 3) s_grid = utils.grid_slice(0.75, 3.0, 3) w_grid = utils.grid_slice(0.05, 0.95, 3) h_grid = utils.grid_slice(-0.25, 0.25, 3) # set search bounds x_bound = (-10, 10) y_bound = (-10, 10) s_bound = (1 / stimulus.ppd, 10) w_bound = (1e-8, 1.0) b_bound = (1e-8, 1e5) u_bound = (None, None) h_bound = (-2.0, 2.0) # loop over each voxel and set up a GaussianFit object grids = ( x_grid, y_grid, s_grid, w_grid, h_grid, ) bounds = (x_bound, y_bound, s_bound, w_bound, h_bound, b_bound, u_bound) # fit the response fit = strf.SpatioTemporalFit(model, data, grids, bounds) # coarse fit npt.assert_almost_equal((fit.x0, fit.y0, fit.sigma0, fit.weight0, fit.hrf0, fit.beta0, fit.baseline0), [-0.5, -0.5, 3., 0.95, -0.25, 1., 0.02], 2) # fine fit npt.assert_almost_equal(fit.x, x, 2) npt.assert_almost_equal(fit.y, y, 2) npt.assert_almost_equal(fit.sigma, sigma, 2) npt.assert_almost_equal(fit.weight, weight, 2) npt.assert_almost_equal(fit.beta, beta, 2) npt.assert_almost_equal(fit.baseline, baseline, 2) # overloaded npt.assert_almost_equal(fit.overloaded_estimate, [2.53, 2.74, 1.23, 0.9, 5.87, 1., -0.25], 2) m_rf = fit.model.m_rf(fit.model.tau) p_rf = fit.model.p_rf(fit.model.tau) npt.assert_almost_equal(simps(np.abs(m_rf)), simps(p_rf), 5) # responses m_resp = fit.model.generate_m_resp(fit.model.tau) p_resp = fit.model.generate_p_resp(fit.model.tau) npt.assert_(np.max(m_resp, 0)[0] < np.max(m_resp, 0)[1]) npt.assert_(np.max(p_resp, 0)[0] > np.max(p_resp, 0)[1]) # amps npt.assert_(fit.model.m_amp[0] < fit.model.m_amp[1]) npt.assert_(fit.model.p_amp[0] > fit.model.p_amp[1]) # receptive field npt.assert_almost_equal(4.0, fit.receptive_field.sum())
def test_negative_og_fit(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,90) thetas = np.insert(thetas,0,-1) thetas = np.append(thetas,-1) num_blank_steps = 30 num_bar_steps = 30 ecc = 12 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 1.0 pixels_across = 100 pixels_down = 100 dtype = ctypes.c_int16 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.double_gamma_hrf, utils.percent_change) model.hrf_delay = 0 model.mask_size = 6 # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = -0.25 baseline = 0.25 # create the "data" data = model.generate_prediction(x, y, sigma, beta, baseline) # set search grid x_grid = utils.grid_slice(-10,10,5) y_grid = utils.grid_slice(-10,10,5) s_grid = utils.grid_slice (0.25,5.25,5) # set search bounds x_bound = (-12.0,12.0) y_bound = (-12.0,12.0) s_bound = (0.001,12.0) b_bound = (None,None) m_bound = (None,None) # loop over each voxel and set up a GaussianFit object grids = (x_grid, y_grid, s_grid,) bounds = (x_bound, y_bound, s_bound, b_bound, m_bound) # fit the response fit = og.GaussianFit(model, data, grids, bounds) # coarse fit ballpark = [-5.0, 5.0, 2.75, -0.27940915461573274, -0.062499999999999993] npt.assert_almost_equal((fit.x0, fit.y0, fit.s0, fit.beta0, fit.baseline0), ballpark) # assert equivalence npt.assert_almost_equal(fit.x, x, 2) npt.assert_almost_equal(fit.y, y, 2) npt.assert_almost_equal(fit.sigma, sigma, 2) npt.assert_almost_equal(fit.beta, beta, 2) nt.assert_false(fit.model.bounded_amplitude) nt.assert_true(fit.slope<0) nt.assert_true(fit.beta0<0) nt.assert_true(fit.beta<0) # test receptive field rf = generate_og_receptive_field(x, y, sigma, fit.model.stimulus.deg_x, fit.model.stimulus.deg_y) rf /= (2 * np.pi * sigma**2) * 1/np.diff(model.stimulus.deg_x[0,0:2])**2 npt.assert_almost_equal(np.round(rf.sum()), np.round(fit.receptive_field.sum())) # test model == fit RF npt.assert_almost_equal(np.round(fit.model.generate_receptive_field(x,y,sigma).sum()), np.round(fit.receptive_field.sum()))
def test_dog(): # stimulus features viewing_distance = 31 screen_width = 41 thetas = np.arange(0,360,90) # thetas = np.insert(thetas,0,-1) # thetas = np.append(thetas,-1) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.50 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 auto_fit = True verbose = 0 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = dog.DifferenceOfGaussiansModel(stimulus, utils.spm_hrf) model.hrf_delay = 0 model.mask_size = 20 # set the pRF params x = 2.2 y = 2.5 sigma = 0.90 sigma_ratio = 1.5 volume_ratio = 0.5 beta = 0.25 baseline = -0.10 # create "data" data = model.generate_prediction(x, y, sigma, sigma_ratio, volume_ratio, beta, baseline) # set up the grids x_grid = utils.grid_slice(-5,5,4) y_grid = utils.grid_slice(-5,5,4) s_grid = utils.grid_slice(1/stimulus.ppd0*1.10,3.5,4) sr_grid = utils.grid_slice(1.0,2.0,4) vr_grid = utils.grid_slice(0.10,0.90,4) grids = (x_grid, y_grid, s_grid, sr_grid, vr_grid,) # set up the bounds x_bound = (-ecc,ecc) y_bound = (-ecc,ecc) s_bound = (1/stimulus.ppd,5) sr_bound = (1.0,None) vr_bound = (1e-8,1.0) bounds = (x_bound, y_bound, s_bound, sr_bound, vr_bound,) # fit it fit = dog.DifferenceOfGaussiansFit(model, data, grids, bounds) # coarse fit ballpark = [1.666666666666667, 1.666666666666667, 2.8243187483428391, 1.9999999999999998, 0.10000000000000001, 0.3639449, -0.025000000000000022] npt.assert_almost_equal((fit.x0,fit.y0,fit.s0,fit.sr0,fit.vr0, fit.beta0, fit.baseline0), ballpark) # fine fit npt.assert_almost_equal(fit.x, x, 2) npt.assert_almost_equal(fit.y, y, 2) npt.assert_almost_equal(fit.sigma, sigma, 2) npt.assert_almost_equal(fit.sigma_ratio, sigma_ratio, 1) npt.assert_almost_equal(fit.volume_ratio, volume_ratio, 1) # test the RF rf = fit.model.receptive_field(*fit.estimate[0:-2]) est = fit.estimate[0:-2].copy() rf_new = fit.model.receptive_field(*est) value_1 = np.sqrt(simps(simps(rf))) value_2 = np.sqrt(simps(simps(rf_new))) nt.assert_almost_equal(value_1, value_2) # polar coordinates npt.assert_almost_equal([fit.theta,fit.rho],[np.arctan2(y,x),np.sqrt(x**2+y**2)], 5)
def test_css_fit(): viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,90) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.50 pixels_down = 50 pixels_across = 50 dtype = ctypes.c_int16 Ns = 3 voxel_index = (1,2,3) auto_fit = True verbose = 1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = css.CompressiveSpatialSummationModel(stimulus, utils.spm_hrf) model.hrf_delay = 0.2 # generate a random pRF estimate x = -2.24 y = 1.58 sigma = 1.23 n = 0.90 beta = 1.0 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, n, beta, baseline) # set search grid x_grid = (-3,2) y_grid = (-3,2) s_grid = (1/stimulus.ppd,2.75) n_grid = (0.1,0.90) # set search bounds x_bound = (-10,10) y_bound = (-10,10) s_bound = (1/stimulus.ppd,10) n_bound = (1e-8,1.0) b_bound = (1e-8,1e5) h_bound = (-3.0,3.0) # loop over each voxel and set up a GaussianFit object grids = (x_grid, y_grid, s_grid, n_grid,) bounds = (x_bound, y_bound, s_bound, n_bound, b_bound,) # fit the response fit = css.CompressiveSpatialSummationFit(model, data, grids, bounds, Ns=Ns) # coarse fit npt.assert_almost_equal((fit.x0,fit.y0,fit.s0,fit.n0,fit.beta0,fit.baseline0),[-3., 2., 0.72833938, 0.5,1., -0.02902576]) # fine fit npt.assert_almost_equal(fit.x, x, 1) npt.assert_almost_equal(fit.y, y, 1) npt.assert_almost_equal(fit.sigma, sigma, 1) npt.assert_almost_equal(fit.n, n, 1) npt.assert_almost_equal(fit.beta, beta, 1) npt.assert_almost_equal(fit.beta, beta, 1) # overloaded npt.assert_almost_equal(fit.overloaded_estimate, [2.5272803327893043, 2.7411676344215277, 1.2965338406691291, 0.90000000000036384, 0.99999999999999067, -0.25000000000200889])
def test_strf_css_fit(): viewing_distance = 38 screen_width = 25 thetas = np.tile(np.arange(0,360,90),2) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.50 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 Ns = 3 voxel_index = (1,2,3) auto_fit = True verbose = 1 projector_hz = 480 tau = 0.00875 mask_size = 5 hrf = 0.25 # create the sweeping bar stimulus in memory stim1 = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc, clip=0.33) # create the sweeping bar stimulus in memory stim2 = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc, clip=0.0001) stim = np.concatenate((stim1,stim2),-1) # create an instance of the Stimulus class stimulus = VisualStimulus(stim, viewing_distance, screen_width, scale_factor, tr_length, dtype) stimulus.fps = projector_hz flicker_vec = np.zeros_like(stim1[0,0,:]).astype('uint8') flicker_vec[1*20:5*20] = 1 flicker_vec[5*20:9*20] = 2 flicker_vec = np.tile(flicker_vec,2) stimulus.flicker_vec = flicker_vec stimulus.flicker_hz = [10,20,10,20] # initialize the gaussian model model = strf.SpatioTemporalModel(stimulus, utils.spm_hrf) model.tau = tau model.hrf_delay = hrf model.mask_size = mask_size # generate a random pRF estimate x = -2.24 y = 1.58 sigma = 1.23 n = 0.90 weight = 0.95 beta = 0.88 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, n, weight, beta, baseline) # set search grid x_grid = utils.grid_slice(-8.0,7.0,4) y_grid = utils.grid_slice(-8.0,7.0,4) s_grid = utils.grid_slice(0.75,3.0,4) n_grid = utils.grid_slice(0.25,0.95,4) w_grid = utils.grid_slice(0.25,0.95,4) # set search bounds x_bound = (-10,10) y_bound = (-10,10) s_bound = (1/stimulus.ppd,10) n_bound = (1e-8,1.0-1e-8) w_bound = (1e-8,1.0-1e-8) b_bound = (1e-8,1e5) u_bound = (None, None) # loop over each voxel and set up a GaussianFit object grids = (x_grid, y_grid, s_grid, n_grid, w_grid,) bounds = (x_bound, y_bound, s_bound, n_bound, w_bound, b_bound, u_bound) # fit the response fit = strf.SpatioTemporalFit(model, data, grids, bounds) # coarse fit ballpark = [-3.0, 2.0, 1.5, 0.95, 0.95, 0.88574075, -0.25] npt.assert_almost_equal((fit.x0,fit.y0,fit.sigma0, fit.n0, fit.weight0,fit.beta0,fit.baseline0),ballpark) # fine fit npt.assert_almost_equal(fit.x, x, 2) npt.assert_almost_equal(fit.y, y, 2) npt.assert_almost_equal(fit.sigma, sigma, 1) npt.assert_almost_equal(fit.n, n, 2) npt.assert_almost_equal(fit.weight, weight, 2) npt.assert_almost_equal(fit.beta, beta, 2) npt.assert_almost_equal(fit.baseline, baseline, 2) # overloaded npt.assert_almost_equal(fit.overloaded_estimate,[2.5266437, 2.7390143, 1.3014282, 0.9004958, 0.9499708, 0.8801774], 2) # rfs m_rf = fit.model.m_rf(fit.model.tau) p_rf = fit.model.p_rf(fit.model.tau) npt.assert_almost_equal(simps(np.abs(m_rf)),simps(p_rf),5) # responses m_resp = fit.model.generate_m_resp(fit.model.tau) p_resp = fit.model.generate_p_resp(fit.model.tau) npt.assert_(np.max(m_resp,0)[0]<np.max(m_resp,0)[1]) npt.assert_(np.max(p_resp,0)[0]>np.max(p_resp,0)[1]) # amps npt.assert_(fit.model.m_amp[0]<fit.model.m_amp[1]) npt.assert_(fit.model.p_amp[0]>fit.model.p_amp[1]) # receptive field npt.assert_almost_equal(4.0, fit.receptive_field.sum())
def test_og_fit(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0, 360, 90) thetas = np.insert(thetas, 0, -1) thetas = np.append(thetas, -1) num_blank_steps = 30 num_bar_steps = 30 ecc = 12 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 1.0 pixels_across = 100 pixels_down = 100 dtype = ctypes.c_int16 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.spm_hrf) model.hrf_delay = 0 model.mask_size = 5 # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 hrf_delay = 0.66 beta = 2.5 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, hrf_delay, beta, baseline) # set search grid x_grid = (-10, 10) y_grid = (-10, 10) s_grid = (0.25, 5.25) h_grid = (-1.0, 1.0) # set search bounds x_bound = (-12.0, 12.0) y_bound = (-12.0, 12.0) s_bound = (0.001, 12.0) h_bound = (-1.5, 1.5) b_bound = (1e-8, None) m_bound = (None, None) # loop over each voxel and set up a GaussianFit object grids = ( x_grid, y_grid, s_grid, h_grid, ) bounds = (x_bound, y_bound, s_bound, h_bound, b_bound, m_bound) # fit the response fit = og.GaussianFit(model, data, grids, bounds, Ns=5) # coarse fit npt.assert_almost_equal(fit.x0, -5.0) npt.assert_almost_equal(fit.y0, 5.0) npt.assert_almost_equal(fit.s0, 2.75) npt.assert_almost_equal(fit.hrf0, 0.5) # the baseline/beta should be 0/1 when regressed data vs. estimate (m, b) = np.polyfit(fit.scaled_ballpark_prediction, data, 1) npt.assert_almost_equal(m, 1.0) npt.assert_almost_equal(b, 0.0) # assert equivalence npt.assert_almost_equal(fit.x, x) npt.assert_almost_equal(fit.y, y) npt.assert_almost_equal(fit.hrf_delay, hrf_delay) npt.assert_almost_equal(fit.sigma, sigma) npt.assert_almost_equal(fit.beta, beta) # test receptive field rf = generate_og_receptive_field(x, y, sigma, fit.model.stimulus.deg_x, fit.model.stimulus.deg_y) rf /= (2 * np.pi * sigma**2) * 1 / np.diff(model.stimulus.deg_x[0, 0:2])**2 npt.assert_almost_equal(np.round(rf.sum()), np.round(fit.receptive_field.sum())) # test model == fit RF npt.assert_almost_equal( np.round(fit.model.generate_receptive_field(x, y, sigma).sum()), np.round(fit.receptive_field.sum()))
def test_dog(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,90) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.50 pixels_down = 50 pixels_across = 50 dtype = ctypes.c_int16 voxel_index = (1,2,3) auto_fit = True verbose = 1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = dog.DifferenceOfGaussiansModel(stimulus, utils.spm_hrf) model.hrf_delay = 0.2 # set the pRF params x = -1.4 y = 1.5 sigma = 1.0 sigma_ratio = 2.0 volume_ratio = 0.5 hrf_delay = -0.2 # create "data" data = model.generate_prediction(x, y, sigma, sigma_ratio, volume_ratio,) # set up the grids x_grid = slice(-10,10,3) y_grid = slice(-10,10,3) s_grid = slice(1/stimulus.ppd,5,3) sr_grid = slice(1.0,5.0,3) vr_grid = slice(0.01,0.99,3) grids = (x_grid, y_grid, s_grid, sr_grid, vr_grid,) # set up the bounds x_bound = (-ecc,ecc) y_bound = (-ecc,ecc) s_bound = (1/stimulus.ppd,5) sr_bound = (1.0,None) vr_bound = (1e-8,1.0) bounds = (x_bound, y_bound, s_bound, sr_bound, vr_bound,) # fit it fit = dog.DifferenceOfGaussiansFit(model, data, grids, bounds, voxel_index) # coarse fit nt.assert_almost_equal((fit.x0,fit.y0,fit.s0,fit.sr0,fit.vr0),(-1.0, 2.0, 0.72833937882323319, 1.0, 0.01)) # fine fit nt.assert_almost_equal(fit.x, x) nt.assert_almost_equal(fit.y, y) nt.assert_almost_equal(fit.sigma, sigma) nt.assert_almost_equal(fit.sigma_ratio, sigma_ratio) nt.assert_almost_equal(fit.volume_ratio, volume_ratio) # test the RF rf = fit.model.receptive_field(*fit.estimate) est = fit.estimate.copy() est[2] *= 2 rf_new = fit.model.receptive_field(*est) value_1 = np.sqrt(simps(simps(rf))) value_2 = np.sqrt(simps(simps(rf_new))) nt.assert_almost_equal(value_2/value_1,sigma_ratio,1) # polar coordinates npt.assert_almost_equal([fit.theta,fit.rho],[np.arctan2(y,x),np.sqrt(x**2+y**2)])
def test_recast_estimation_results(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,45) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.10 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 voxel_index = (1,2,3) auto_fit = True verbose = 1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.spm_hrf) model.hrf_delay = 0 # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = 2.5 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, beta, baseline) # set search grid x_grid = utils.grid_slice(-5,4,5) y_grid = utils.grid_slice(-5,7,5) s_grid = utils.grid_slice(1/stimulus.ppd,5.25,5) b_grid = utils.grid_slice(0.1,4.0,5) # set search bounds x_bound = (-12.0,12.0) y_bound = (-12.0,12.0) s_bound = (1/stimulus.ppd,12.0) b_bound = (1e-8,1e2) m_bound = (None,None) # loop over each voxel and set up a GaussianFit object grids = (x_grid, y_grid, s_grid,) bounds = (x_bound, y_bound, s_bound, b_bound, m_bound) # create 3 voxels of data all_data = np.array([data,data,data]) indices = [(0,0,0),(0,0,1),(0,0,2)] # bundle the voxels bundle = utils.multiprocess_bundle(og.GaussianFit, model, all_data, grids, bounds, indices) # run analysis with sharedmem.Pool(np=3) as pool: output = pool.map(utils.parallel_fit, bundle) # create grid parent arr = np.zeros((1,1,3)) grid_parent = nibabel.Nifti1Image(arr,np.eye(4,4)) # recast the estimation results nif = utils.recast_estimation_results(output, grid_parent) dat = nif.get_data() # assert equivalence npt.assert_almost_equal(np.mean(dat[...,0]), x) npt.assert_almost_equal(np.mean(dat[...,1]), y) npt.assert_almost_equal(np.mean(dat[...,2]), sigma) npt.assert_almost_equal(np.mean(dat[...,3]), beta) npt.assert_almost_equal(np.mean(dat[...,4]), baseline) # recast the estimation results - OVERLOADED nif = utils.recast_estimation_results(output, grid_parent, True) dat = nif.get_data() # assert equivalence npt.assert_almost_equal(np.mean(dat[...,0]), np.arctan2(y,x),2) npt.assert_almost_equal(np.mean(dat[...,1]), np.sqrt(x**2+y**2),2) npt.assert_almost_equal(np.mean(dat[...,2]), sigma) npt.assert_almost_equal(np.mean(dat[...,3]), beta) npt.assert_almost_equal(np.mean(dat[...,4]), baseline)
def test_recast_estimation_results(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0, 360, 45) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.10 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 voxel_index = (1, 2, 3) auto_fit = True verbose = 1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.spm_hrf) model.hrf_delay = 0 # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = 2.5 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, beta, baseline) # set search grid x_grid = utils.grid_slice(-5, 4, 5) y_grid = utils.grid_slice(-5, 7, 5) s_grid = utils.grid_slice(1 / stimulus.ppd, 5.25, 5) b_grid = utils.grid_slice(0.1, 4.0, 5) # set search bounds x_bound = (-12.0, 12.0) y_bound = (-12.0, 12.0) s_bound = (1 / stimulus.ppd, 12.0) b_bound = (1e-8, 1e2) m_bound = (None, None) # loop over each voxel and set up a GaussianFit object grids = ( x_grid, y_grid, s_grid, ) bounds = (x_bound, y_bound, s_bound, b_bound, m_bound) # create 3 voxels of data all_data = np.array([data, data, data]) indices = [(0, 0, 0), (0, 0, 1), (0, 0, 2)] # bundle the voxels bundle = utils.multiprocess_bundle(og.GaussianFit, model, all_data, grids, bounds, indices) # run analysis with sharedmem.Pool(np=3) as pool: output = pool.map(utils.parallel_fit, bundle) # create grid parent arr = np.zeros((1, 1, 3)) grid_parent = nibabel.Nifti1Image(arr, np.eye(4, 4)) # recast the estimation results nif = utils.recast_estimation_results(output, grid_parent) dat = nif.get_data() # assert equivalence npt.assert_almost_equal(np.mean(dat[..., 0]), x) npt.assert_almost_equal(np.mean(dat[..., 1]), y) npt.assert_almost_equal(np.mean(dat[..., 2]), sigma) npt.assert_almost_equal(np.mean(dat[..., 3]), beta) npt.assert_almost_equal(np.mean(dat[..., 4]), baseline) # recast the estimation results - OVERLOADED nif = utils.recast_estimation_results(output, grid_parent, True) dat = nif.get_data() # assert equivalence npt.assert_almost_equal(np.mean(dat[..., 0]), np.arctan2(y, x), 2) npt.assert_almost_equal(np.mean(dat[..., 1]), np.sqrt(x**2 + y**2), 2) npt.assert_almost_equal(np.mean(dat[..., 2]), sigma) npt.assert_almost_equal(np.mean(dat[..., 3]), beta) npt.assert_almost_equal(np.mean(dat[..., 4]), baseline)
def test_xval(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.array([-1, 0, 90, 180, 270, -1]) num_blank_steps = 30 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.10 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 voxel_index = (1,2,3) auto_fit = True verbose = 1 # rng np.random.seed(2764932) # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.spm_hrf) model.hrf_delay = 0 # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = 2.5 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, beta, baseline) # set search grid x_grid = utils.grid_slice(-10, 10, 5) y_grid = utils.grid_slice(-10, 10, 5) s_grid = utils.grid_slice(0.5, 3.25, 5) # set search bounds x_bound = (-12.0,12.0) y_bound = (-12.0,12.0) s_bound = (0.001,12.0) b_bound = (1e-8,None) m_bound = (None,None) # loop over each voxel and set up a GaussianFit object grids = (x_grid, y_grid, s_grid,) bounds = (x_bound, y_bound, s_bound, b_bound, m_bound) # pack multiple "runs" data = np.vstack((data,data)) # make it a singular "voxel" data = np.reshape(data, (1,data.shape[0],data.shape[1])) # set bootstraps and resamples bootstraps = 2 kfolds = 2 # make fodder bundle = utils.xval_bundle(bootstraps, kfolds, og.GaussianFit, model, data, grids, bounds, np.tile((1,2,3),(3,1))) # test for b in bundle: fit = utils.parallel_xval(b) npt.assert_almost_equal(fit.rss,0) npt.assert_equal(fit.cod, 100.0) npt.assert_(np.all(fit.tst_data == fit.trn_data)) npt.assert_(np.all(fit.tst_idx != fit.trn_idx))
def test_bounded_amplitude_failure(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0, 360, 90) thetas = np.insert(thetas, 0, -1) thetas = np.append(thetas, -1) num_blank_steps = 30 num_bar_steps = 30 ecc = 12 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 1.0 pixels_across = 100 pixels_down = 100 dtype = ctypes.c_int16 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.double_gamma_hrf, utils.percent_change) model.hrf_delay = 0 model.mask_size = 6 # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = -0.25 baseline = 0.25 # create the "data" data = model.generate_prediction(x, y, sigma, beta, baseline) # set search grid x_grid = utils.grid_slice(-10, 10, 5) y_grid = utils.grid_slice(-10, 10, 5) s_grid = utils.grid_slice(0.25, 5.25, 5) # set search bounds x_bound = (-12.0, 12.0) y_bound = (-12.0, 12.0) s_bound = (0.001, 12.0) b_bound = (1e-8, None) m_bound = (None, None) # loop over each voxel and set up a GaussianFit object grids = ( x_grid, y_grid, s_grid, ) bounds = (x_bound, y_bound, s_bound, b_bound, m_bound) # fit the response fit = og.GaussianFit(model, data, grids, bounds) nt.assert_true(fit.model.bounded_amplitude) nt.assert_true(fit.slope > 0) nt.assert_true(fit.beta0 > 0) nt.assert_true(fit.beta > 0) nt.assert_true(fit.beta != beta)
def test_bootstrap(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.array([-1, 0, 90, 180, 270, -1]) num_blank_steps = 30 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.10 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 voxel_index = (1, 2, 3) auto_fit = True verbose = 1 # rng np.random.seed(2764932) # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.spm_hrf) model.hrf_delay = 0 # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = 2.5 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, beta, baseline) # set search grid x_grid = utils.grid_slice(-10, 10, 5) y_grid = utils.grid_slice(-10, 10, 5) s_grid = utils.grid_slice(0.5, 3.25, 5) # set search bounds x_bound = (-12.0, 12.0) y_bound = (-12.0, 12.0) s_bound = (0.001, 12.0) b_bound = (1e-8, None) m_bound = (None, None) # loop over each voxel and set up a GaussianFit object grids = ( x_grid, y_grid, s_grid, ) bounds = (x_bound, y_bound, s_bound, b_bound, m_bound) # pack multiple "runs" data = np.vstack((data, data, data)) # make it a singular "voxel" data = np.reshape(data, (1, data.shape[0], data.shape[1])) # set bootstraps and resamples bootstraps = 2 resamples = np.array((2, )) # make fodder bundle = utils.bootstrap_bundle(bootstraps, resamples, og.GaussianFit, model, data, grids, bounds, np.tile((1, 2, 3), (bootstraps, 1))) # test for b in bundle: fit = utils.parallel_bootstrap(b) npt.assert_almost_equal(fit.rss, 0) npt.assert_equal(fit.n_resamples, resamples[0]) npt.assert_equal(np.sum(fit.resamples), np.sum(np.arange(resamples[0])))
def test_css_fit(): viewing_distance = 38 screen_width = 25 thetas = np.arange(0, 360, 90) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.50 pixels_down = 50 pixels_across = 50 dtype = ctypes.c_int16 Ns = 3 voxel_index = (1, 2, 3) auto_fit = True verbose = 1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = css.CompressiveSpatialSummationModel(stimulus, utils.spm_hrf) model.hrf_delay = 0.2 # generate a random pRF estimate x = -2.24 y = 1.58 sigma = 1.23 n = 0.90 beta = 1.0 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, n, beta, baseline) # set search grid x_grid = (-3, 2) y_grid = (-3, 2) s_grid = (1 / stimulus.ppd, 2.75) n_grid = (0.1, 0.90) # set search bounds x_bound = (-10, 10) y_bound = (-10, 10) s_bound = (1 / stimulus.ppd, 10) n_bound = (1e-8, 1.0) b_bound = (1e-8, 1e5) h_bound = (-3.0, 3.0) # loop over each voxel and set up a GaussianFit object grids = ( x_grid, y_grid, s_grid, n_grid, ) bounds = ( x_bound, y_bound, s_bound, n_bound, b_bound, ) # fit the response fit = css.CompressiveSpatialSummationFit(model, data, grids, bounds, Ns=Ns) # coarse fit observed = [fit.x0, fit.y0, fit.s0, fit.n0, fit.beta0, fit.baseline0] expected = [-3., 2., 0.72833938, 0.5, 0.9358213, -0.24999999999999997] npt.assert_almost_equal(observed, expected) # fine fit npt.assert_almost_equal(fit.x, x) npt.assert_almost_equal(fit.y, y) npt.assert_almost_equal(fit.sigma, sigma) npt.assert_almost_equal(fit.n, n) npt.assert_almost_equal(fit.beta, beta) npt.assert_almost_equal(fit.beta, beta) # overloaded npt.assert_almost_equal(fit.overloaded_estimate, [ 2.5272803327893043, 2.7411676344215277, 1.2965338406691291, 0.90000000000036384, 0.99999999999999067, -0.25000000000200889 ])
def test_parallel_fit_manual_grids(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0, 360, 45) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.10 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 voxel_index = (1, 2, 3) auto_fit = True verbose = 1 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.double_gamma_hrf) model.hrf_delay = 0 # generate a random pRF estimate x = -5.24 y = 2.58 sigma = 1.24 beta = 2.5 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, beta, baseline) # set search grid x_grid = slice(-5, 4, 5) y_grid = slice(-5, 7, 5) s_grid = slice(1 / stimulus.ppd, 5.25, 5) b_grid = slice(0.1, 4.0, 5) # set search bounds x_bound = (-12.0, 12.0) y_bound = (-12.0, 12.0) s_bound = (1 / stimulus.ppd, 12.0) b_bound = (1e-8, 1e2) m_bound = (None, None) # loop over each voxel and set up a GaussianFit object grids = ( x_grid, y_grid, s_grid, ) bounds = (x_bound, y_bound, s_bound, b_bound, m_bound) # make 3 voxels all_data = np.array([data, data, data]) num_voxels = data.shape[0] indices = [(1, 2, 3)] * 3 # bundle the voxels bundle = utils.multiprocess_bundle(og.GaussianFit, model, all_data, grids, bounds, indices) # run analysis with sharedmem.Pool(np=3) as pool: output = pool.map(utils.parallel_fit, bundle) # assert equivalence for fit in output: npt.assert_almost_equal(fit.x, x, 2) npt.assert_almost_equal(fit.y, y, 2) npt.assert_almost_equal(fit.sigma, sigma, 2) npt.assert_almost_equal(fit.beta, beta, 2) npt.assert_almost_equal(fit.baseline, baseline, 2)
def test_dog(): # stimulus features viewing_distance = 31 screen_width = 41 thetas = np.arange(0, 360, 90) # thetas = np.insert(thetas,0,-1) # thetas = np.append(thetas,-1) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1.0 frames_per_tr = 1.0 scale_factor = 0.50 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 auto_fit = True verbose = 0 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # initialize the gaussian model model = dog.DifferenceOfGaussiansModel(stimulus, utils.spm_hrf) model.hrf_delay = 0 model.mask_size = 20 # set the pRF params x = 2.2 y = 2.5 sigma = 0.90 sigma_ratio = 1.5 volume_ratio = 0.5 beta = 0.25 baseline = -0.10 # create "data" data = model.generate_prediction(x, y, sigma, sigma_ratio, volume_ratio, beta, baseline) # set up the grids x_grid = utils.grid_slice(-5, 5, 4) y_grid = utils.grid_slice(-5, 5, 4) s_grid = utils.grid_slice(1 / stimulus.ppd0 * 1.10, 3.5, 4) sr_grid = utils.grid_slice(1.0, 2.0, 4) vr_grid = utils.grid_slice(0.10, 0.90, 4) grids = ( x_grid, y_grid, s_grid, sr_grid, vr_grid, ) # set up the bounds x_bound = (-ecc, ecc) y_bound = (-ecc, ecc) s_bound = (1 / stimulus.ppd, 5) sr_bound = (1.0, None) vr_bound = (1e-8, 1.0) bounds = ( x_bound, y_bound, s_bound, sr_bound, vr_bound, ) # fit it fit = dog.DifferenceOfGaussiansFit(model, data, grids, bounds) # coarse fit ballpark = [ 1.666666666666667, 1.666666666666667, 2.8243187483428391, 1.9999999999999998, 0.10000000000000001 ] npt.assert_almost_equal((fit.x0, fit.y0, fit.s0, fit.sr0, fit.vr0), ballpark) # the baseline/beta should be 0/1 when regressed data vs. estimate (m, b) = np.polyfit(fit.scaled_ballpark_prediction, data, 1) npt.assert_almost_equal(m, 1.0) npt.assert_almost_equal(b, 0.0) # fine fit npt.assert_almost_equal(fit.x, x, 2) npt.assert_almost_equal(fit.y, y, 2) npt.assert_almost_equal(fit.sigma, sigma, 2) npt.assert_almost_equal(fit.sigma_ratio, sigma_ratio, 1) npt.assert_almost_equal(fit.volume_ratio, volume_ratio, 1) # test the RF rf = fit.model.receptive_field(*fit.estimate[0:-2]) est = fit.estimate[0:-2].copy() rf_new = fit.model.receptive_field(*est) value_1 = np.sqrt(simps(simps(rf))) value_2 = np.sqrt(simps(simps(rf_new))) nt.assert_almost_equal(value_1, value_2) # polar coordinates npt.assert_almost_equal( [fit.theta, fit.rho], [np.arctan2(y, x), np.sqrt(x**2 + y**2)], 4)
def test_strf_2dcos_fit(): viewing_distance = 38 screen_width = 25 thetas = np.tile(np.arange(0, 360, 90), 2) thetas = np.insert(thetas, 0, -1) thetas = np.append(thetas, -1) num_blank_steps = 0 num_bar_steps = 30 ecc = 10 tr_length = 1 frames_per_tr = 1 scale_factor = 1.0 pixels_down = 100 pixels_across = 100 dtype = ctypes.c_int16 Ns = 5 voxel_index = (1, 2, 3) auto_fit = True verbose = 1 projector_hz = 480 tau = 0.00875 mask_size = 5 hrf = 0.25 # create the sweeping bar stimulus in memory stim = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc) # create an instance of the Stimulus class stimulus = VisualStimulus(stim, viewing_distance, screen_width, scale_factor, tr_length, dtype) stimulus.fps = projector_hz flicker_vec = np.zeros_like(stim[0, 0, :]).astype('uint8') flicker_vec[1 * 20:5 * 20] = 1 flicker_vec[5 * 20:9 * 20] = 2 stimulus.flicker_vec = flicker_vec stimulus.flicker_hz = [10, 20] # initialize the gaussian model model = strf.SpatioTemporalModel(stimulus, utils.spm_hrf) model.tau = tau model.hrf_delay = hrf model.mask_size = mask_size model.power = 0.7 # generate a random pRF estimate x = -2.24 y = 1.58 sigma = 1.23 weight = 0.90 beta = 1.0 baseline = -0.25 # create the "data" data = model.generate_prediction(x, y, sigma, weight, beta, baseline) # set search grid x_grid = utils.grid_slice(-8.0, 7.0, 5) y_grid = utils.grid_slice(-8.0, 7.0, 5) s_grid = utils.grid_slice(0.75, 3.0, 5) w_grid = utils.grid_slice(0.05, 0.95, 5) # set search bounds x_bound = (-10, 10) y_bound = (-10, 10) s_bound = (1 / stimulus.ppd, 10) w_bound = (1e-8, 1.0) b_bound = (1e-8, 1e5) u_bound = (None, None) # loop over each voxel and set up a GaussianFit object grids = ( x_grid, y_grid, s_grid, w_grid, ) bounds = (x_bound, y_bound, s_bound, w_bound, b_bound, u_bound) # fit the response fit = strf.SpatioTemporalFit(model, data, grids, bounds) # coarse fit ballpark = [ -0.5, 3.25, 3.0, 0.72499999999999998, 0.858317, -0.25000000000000011 ] npt.assert_almost_equal( (fit.x0, fit.y0, fit.sigma0, fit.weight0, fit.beta0, fit.baseline0), ballpark) # fine fit npt.assert_almost_equal(fit.x, x) npt.assert_almost_equal(fit.y, y) npt.assert_almost_equal(fit.sigma, sigma) npt.assert_almost_equal(fit.weight, weight) npt.assert_almost_equal(fit.beta, beta) npt.assert_almost_equal(fit.baseline, baseline) # overloaded npt.assert_almost_equal(fit.overloaded_estimate, [ 2.5272803327887128, 2.7411676344185993, 1.2300000000008835, 0.89999999999333258, 1.0000000000005003, -0.25000000000063088 ]) m_rf = fit.model.m_rf(fit.model.tau) p_rf = fit.model.p_rf(fit.model.tau) npt.assert_almost_equal(simps(np.abs(m_rf)), simps(p_rf), 5) # responses m_resp = fit.model.generate_m_resp(fit.model.tau) p_resp = fit.model.generate_p_resp(fit.model.tau) npt.assert_(np.max(m_resp, 0)[0] < np.max(m_resp, 0)[1]) npt.assert_(np.max(p_resp, 0)[0] > np.max(p_resp, 0)[1]) # amps npt.assert_(fit.model.m_amp[0] < fit.model.m_amp[1]) npt.assert_(fit.model.p_amp[0] > fit.model.p_amp[1]) # receptive field rf = generate_2dcos_receptive_field(x, y, sigma, fit.model.power, fit.model.stimulus.deg_x, fit.model.stimulus.deg_y) rf /= (2 * np.pi * sigma**2) * 1 / np.diff(model.stimulus.deg_x[0, 0:2])**2 npt.assert_almost_equal(np.round(rf.sum()), np.round(fit.receptive_field.sum())) # test model == fit RF npt.assert_almost_equal( np.round(fit.model.generate_receptive_field(x, y, sigma).sum()), np.round(fit.receptive_field.sum()))
def test_resurrect_model(): # stimulus features viewing_distance = 38 screen_width = 25 thetas = np.arange(0,360,90) thetas = np.insert(thetas,0,-1) thetas = np.append(thetas,-1) num_blank_steps = 20 num_bar_steps = 20 ecc = 10 tr_length = 1.5 frames_per_tr = 1.0 scale_factor = 1.0 pixels_across = 100 pixels_down = 100 dtype = ctypes.c_int16 # create the sweeping bar stimulus in memory bar = simulate_bar_stimulus(pixels_across, pixels_down, viewing_distance, screen_width, thetas, num_bar_steps, num_blank_steps, ecc, clip=0.01) # create an instance of the Stimulus class stimulus = VisualStimulus(bar, viewing_distance, screen_width, scale_factor, tr_length, dtype) # set cache grids x_grid = utils.grid_slice(-10, 10, 5) y_grid = utils.grid_slice(-10, 10, 5) s_grid = utils.grid_slice(0.55,5.25, 5) grids = (x_grid, y_grid, s_grid,) # set search bounds x_bound = (-12.0,12.0) y_bound = (-12.0,12.0) s_bound = (0.001,12.0) b_bound = (1e-8,None) m_bound = (None,None) bounds = (x_bound, y_bound, s_bound, b_bound, m_bound) # initialize the gaussian model model = og.GaussianModel(stimulus, utils.double_gamma_hrf) model.hrf_delay = 0 model.mask_size = 5 cache = model.cache_model(grids, ncpus=3) # seed rng np.random.seed(4932) # pluck an estimate and create timeseries x, y, sigma = cache[51][1] beta = 1.25 baseline = 0.25 # create "data" data = cache[51][0] # fit it fit = og.GaussianFit(model, data, grids, bounds, verbose=0) # assert npt.assert_equal(fit.estimate,fit.ballpark) # create "data" data = model.generate_prediction(x,y,sigma,beta,baseline) # fit it fit = og.GaussianFit(model, data, grids, bounds, verbose=0) # assert npt.assert_almost_equal(np.sum(fit.scaled_ballpark_prediction-fit.data)**2,0)