Example #1
0
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)
Example #2
0
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)
Example #3
0
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)
Example #4
0
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)
Example #5
0
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
Example #6
0
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)
Example #7
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]))
Example #8
0
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)
Example #9
0
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)
Example #10
0
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()))
Example #11
0
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)
Example #12
0
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)])
Example #13
0
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)
Example #14
0
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)
Example #15
0
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
Example #17
0
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())
Example #19
0
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()))
Example #20
0
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)
Example #21
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
    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])
                                                     
                                                     
                                                     
                                                     
                                                     
Example #22
0
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())
Example #23
0
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()))
Example #24
0
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)])
    
Example #25
0
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)
Example #26
0
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)
Example #27
0
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))
Example #28
0
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)
Example #29
0
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])))
Example #30
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
    ])
Example #31
0
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)
Example #32
0
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)
Example #33
0
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()))
Example #34
0
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)