Esempio n. 1
0
def test_brute_force_search():

    # create a parameter to estimate
    params = (10,10)

    # we need to define some search bounds
    grids = ((0,20),(5,15))

    # we don't need to specify bounds for the error function
    bounds = ()

    # set the number of grid samples for the coarse search
    Ns = 3

    # set the verbose level 0 is silent, 1 is final estimate, 2 is each iteration
    verbose = 0

    # create a simple function to transform the parameters
    func = lambda freq, offset: np.sin( np.linspace(0,1,1000) * 2 * np.pi * freq) + offset

    # create a "response"
    response = func(*params)

    # get the ball-park estimate
    p0 = utils.brute_force_search(response, utils.error_function, func, grids, bounds, Ns=Ns)

    # assert that the estimate is equal to the parameter
    npt.assert_equal(params, p0[0])
Esempio n. 2
0
def test_brute_force_search_manual_grids():

    # create a parameter to estimate
    params = (10,10)

    # we need to define some search bounds
    grid_1 = utils.grid_slice(5,15,5)
    grid_2 = utils.grid_slice(5,15,5)
    grids = (grid_1,grid_2,)
    bounds = ()

    # set the verbose level 0 is silent, 1 is final estimate, 2 is each iteration
    verbose = 0

    # create a simple function to transform the parameters
    func = lambda freq, offset: np.sin( np.linspace(0,1,1000) * 2 * np.pi * freq) + offset

    # create a "response"
    response = func(*params)

    # get the ball-park estimate
    p0 = utils.brute_force_search(response, utils.error_function, func, grids, bounds)

    # assert that the estimate is equal to the parameter
    npt.assert_equal(params, p0[0])
Esempio n. 3
0
 def brute_force(self):
     return utils.brute_force_search(self.data,
                                     utils.error_function,
                                     self.model.generate_ballpark_prediction,
                                     self.grids,
                                     self.bounds,
                                     self.Ns,
                                     self.very_verbose)
Esempio n. 4
0
File: og.py Progetto: mekman/popeye
 def ballpark_estimate(self):
     return utils.brute_force_search((self.model.stimulus.deg_x_coarse,
                                      self.model.stimulus.deg_y_coarse,
                                      self.model.stimulus.stim_arr_coarse,
                                      self.tr_length),
                                     self.search_bounds,
                                     self.fit_bounds,
                                     self.data,
                                     utils.error_function,
                                     compute_model_ts)
Esempio n. 5
0
 def ballpark(self):
     return utils.brute_force_search((self.model.stimulus.spectrogram,
                                      self.model.stimulus.freqs,
                                      self.model.stimulus.target_times),
                                     self.grids,
                                     self.bounds,
                                     self.Ns,
                                     self.data,
                                     utils.error_function,
                                     compute_model_ts,
                                     self.very_verbose)
Esempio n. 6
0
def test_grid_slice():
    
    # test this case
    from_1 = 5
    to_1 = 15
    from_2 = 0
    to_2 = 2
    Ns=5
    
    # set a parameter to estimate
    params = (10,1)
    
    # see if we properly tile the parameter space for Ns=2
    grid_1 = utils.grid_slice(from_1, to_1, Ns)
    grid_2 = utils.grid_slice(from_2, to_2, Ns)
    grids = (grid_1, grid_2)
    
    # unbounded
    bounds = ()
    
    # create a simple function to generate a response from the parameter
    func = lambda freq,offset: np.sin( np.linspace(0,1,1000) * 2 * np.pi * freq) + offset
    
    # create a "response"
    response = func(*params)
    
    # get the ball-park estimate
    p0 = utils.brute_force_search(response, utils.error_function, func, grids, bounds)
    
    # make sure we fit right
    npt.assert_equal(params, p0[0])
    
    # make sure we sliced it right
    npt.assert_equal(p0[2][0].min(),from_1)
    npt.assert_equal(p0[2][0].max(),to_1)
    npt.assert_equal(p0[2][1].min(),from_2)
    npt.assert_equal(p0[2][1].max(),to_2)