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])
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])
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])
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])
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)
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)
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)
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)
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)
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)
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)