def fit(self): """ Fits the inverse normalised cdf and generates a lookup table of sort """ # the for loop generates a lookup table correlating x and y based on the normalised cdf for idx, x_value in enumerate(self.x): res = sp_minimize(self.diff, 1.0, args=(x_value), method='Nelder-Mead', tol=1e-6) self.y[idx] = res.x[0]
def optimize_taper_params(x, ERV, wavelengths, lambda_0, init_taper_params, SNAP_exp, bounds=None, max_iter=5): def _difference_on_taper(taper_params, *details): (absS, phaseS, ReD, ImD_exc, C) = taper_params x, ERV, wavelengths, lambda_0, x_exp, signal_exp = details SNAP = SNAP_model.SNAP(x, ERV, wavelengths, lambda_0) SNAP.set_taper_params(absS, phaseS, ReD, ImD_exc, C) x, wavelengths, num_data = SNAP.derive_transmission() t = _difference_between_exp_and_num(x_exp, signal_exp, x, num_data, wavelengths) print('taper opt. delta_t is {}'.format(t)) return t if SNAP_exp.transmission_scale == 'log': SNAP_exp.convert_to_lin_transmission() x_exp, signal_exp = SNAP_exp.x, SNAP_exp.transmission options = {} options['maxiter'] = max_iter [absS, phaseS, ReD, ImD_exc, C] = init_taper_params # use current taper parameters as initial guess res = sp_minimize(_difference_on_taper, [absS, phaseS, ReD, ImD_exc, C], args=(x, ERV, wavelengths, lambda_0, x_exp, signal_exp), bounds=bounds, options=options) taper_params = res.x return res, taper_params
def minimize(fun, x0, args=(), method='BFGS', jac=None, hess=None, hessp=None, bounds=None, constraints=(), tol=None, callback=None, options=None): """ wrapper around scipy.optimize.minimize with extra functions """ if method in SCIPY_METHODS: return sp_minimize(fun, x0, args, method, jac, hess, hessp, bounds, constraints, tol, callback, options) if options is None: options = {} if method is None: res = to_result(x=x0, fun=fun(x0, *args), niter=1, nfev=1) if callback is not None: callback(x0) return res if method == "MIMIC": return _minimize_mimic(fun, x0, args, callback=callback, **options) elif method == "genetic": return _minimize_genetic(fun, x0, args, callback=callback, **options) elif method == "rhc": return _minimize_rhc(fun, x0, args, callback=callback, # minimize_rhc mutates options options=copy.deepcopy(options)) elif method == "ab_test": return _minimize_ab_test(fun, x0, args, callback=callback, **options) elif method == "twiddle": return _minimize_twiddle(fun, x0, args, callback=callback, **options) elif method == "simbo_general": return _minimize_simbo_general(fun, x0, args, callback=callback, **options) else: raise ValueError("Unknown solver: %s" % method)
def expected_minimum(res, n_random_starts=20, random_state=None): """ Compute the minimum over the predictions of the last surrogate model. Uses `expected_minimum_random_sampling` with `n_random_starts`=100000, when the space contains any categorical values. .. note:: The returned minimum may not necessarily be an accurate prediction of the minimum of the true objective function. Parameters ---------- res : `OptimizeResult`, scipy object The optimization result returned by a `skopt` minimizer. n_random_starts : int, default=20 The number of random starts for the minimization of the surrogate model. random_state : int, RandomState instance, or None (default) Set random state to something other than None for reproducible results. Returns ------- x : list location of the minimum. fun : float the surrogate function value at the minimum. """ if res.space.is_partly_categorical: return expected_minimum_random_sampling(res, n_random_starts=100000, random_state=random_state) def func(x): reg = res.models[-1] x = res.space.transform(x.reshape(1, -1)) return reg.predict(x.reshape(1, -1))[0] xs = [res.x] if n_random_starts > 0: xs.extend(res.space.rvs(n_random_starts, random_state=random_state)) best_x = None best_fun = np.inf for x0 in xs: r = sp_minimize(func, x0=x0, bounds=res.space.bounds) if r.fun < best_fun: best_x = r.x best_fun = r.fun return [v for v in best_x], best_fun
def run_optimizer(self, loss_wrapper, sim_id, init_pos, bounds, max_iter, **kwargs): def local_callback(_): self.sim_info_dicts[sim_id]['task_id_index'] += 1 res = sp_minimize(loss_wrapper, init_pos, method = self.method, bounds = bounds, options = {'maxiter': max_iter}, callback = local_callback) content = open('TIME_res_report', 'a') content.write('completed %s\n' % sim_id) for prop in dir(res): try: content.write('%s\t%s\n' % (prop, str(getattr(res, prop)))) except: pass content.write('===============\n') content.close() self.SCIPY_OPTIMIZERS_FINISHED[sim_id] = True
def expected_minimum(res, n_random_starts=20, random_state=None): """ Compute the minimum over the predictions of the last surrogate model. Note that the returned minimum may not necessarily be an accurate prediction of the minimum of the true objective function. Parameters ---------- * `res` [`OptimizeResult`, scipy object]: The optimization result returned by a `skopt` minimizer. * `n_random_starts` [int, default=20]: The number of random starts for the minimization of the surrogate model. * `random_state` [int, RandomState instance, or None (default)]: Set random state to something other than None for reproducible results. Returns ------- * `x` [list]: location of the minimum. * `fun` [float]: the surrogate function value at the minimum. """ def func(x): reg = res.models[-1] x = res.space.transform(x.reshape(1, -1)) return reg.predict(x.reshape(1, -1))[0] xs = [res.x] if n_random_starts > 0: xs.extend(res.space.rvs(n_random_starts, random_state=random_state)) best_x = None best_fun = np.inf for x0 in xs: r = sp_minimize(func, x0=x0, bounds=res.space.bounds) if r.fun < best_fun: best_x = r.x best_fun = r.fun return [v for v in best_x], best_fun
def minimize(input_file, variables_names, x0, target_filepath, target_variable, number=0, overwrite=True): if isinstance(variables_names, Iterable): if len(variables_names) != len(x0): raise ValueError('variables and x0 should be of the same length') result = sp_minimize(minimization_function, x0, args=(input_file, variables_names, target_filepath, target_variable, number, overwrite), tol=1e-5) return result
def minimize(self): """Minimise self.score_function, given the initial values and the constraints using scipy.optimize.minimize. Returns: res: the scipy.optimize.OptimizeResult (a dict). """ if self.debug_level>0: print '-'*90 print '::: initial values:', self.initial_values print '::: constraints:', self.constraints res = sp_minimize(self, self.initial_values, constraints=self.constraints, ) if self.debug_level>0: print res return res
def expected_minimum(res, n_random_starts=20, random_state=None): """ Compute the minimum over the predictions of the last surrogate model. Note that the returned minimum may not necessarily be an accurate prediction of the minimum of the true objective function. Parameters ---------- * `res` [`OptimizeResult`, scipy object]: The optimization result returned by a `skopt` minimizer. * `n_random_starts` [int, default=20]: The number of random starts for the minimization of the surrogate model. * `random_state` [int, RandomState instance, or None (default)]: Set random state to something other than None for reproducible results. Returns ------- * `x` [list]: location of the minimum. * `fun` [float]: the surrogate function value at the minimum. """ def func(x): reg = res.models[-1] x = res.space.transform(x.reshape(1, -1)) return reg.predict(x.reshape(1, -1))[0] xs = [res.x] if n_random_starts > 0: xs.extend(res.space.rvs(n_random_starts, random_state=random_state)) best_x = None best_fun = np.inf for x0 in xs: r = sp_minimize(func, x0=x0, bounds=res.space.bounds) if r.fun < best_fun: best_x = r.x best_fun = r.fun return [v for v in best_x], best_fun
def optimize_ERV_shape_by_modes(ERV_f, initial_ERV_params, x_0_ERV, x, lambda_0, taper_params, SNAP_exp, bounds=None, max_iter=20): def _difference_for_ERV_shape(ERV_params, *details): ERV_f, x_0_ERV, x, wavelengths, lambda_0, taper_params, SNAP_exp = details exp_modes = SNAP_exp.find_modes() ERV_array = ERV_f(x, x_0_ERV, ERV_params) SNAP = SNAP_model.SNAP(x, ERV_array, wavelengths, lambda_0) SNAP.set_taper_params(*taper_params) x_num, wavelengths, num_data = SNAP.derive_transmission() num_modes = SNAP.find_modes() N_num = len(num_modes) N_exp = len(exp_modes) if N_num > N_exp: exp_modes = np.sort( np.append(exp_modes, lambda_0 * np.ones((N_num - N_exp, 1)))) elif N_exp > N_num: num_modes = np.sort( np.append(num_modes, lambda_0 * np.ones((N_exp - N_num, 1)))) t = np.sum(abs(num_modes - exp_modes)) print('mode positions difference is {}'.format(t)) return t if SNAP_exp.transmission_scale == 'log': SNAP_exp.convert_to_lin_transmission() wavelengths = SNAP_exp.wavelengths options = {} options['maxiter'] = max_iter [absS, phaseS, ReD, ImD_exc, C] = taper_params # use current taper parameters as initial guess res = sp_minimize(_difference_for_ERV_shape, initial_ERV_params, args=(ERV_f, x_0_ERV, x, wavelengths, lambda_0, taper_params, SNAP_exp), bounds=bounds, options=options, method='Nelder-Mead') ERV_params = res.x return res, ERV_params
def sp_sample_quantile_pN_av(vn_perm, rho, quantile, key, T): d = jnp.shape(vn_perm)[2] #unif rv y0_init = ndtri_(quantile) ##for scipy optimize def fun_sp(y0): return np.array(calc_pN_av_err2(y0, vn_perm, rho, quantile, key, T), dtype='float64') def grad_sp(y0): return np.array(grad_pN_av_err2(y0, vn_perm, rho, quantile, key, T), dtype='float64') opt = sp_minimize(fun_sp, y0_init, method="SLSQP", jac=grad_sp) y_samp = opt.x err2 = opt.fun n_iter = opt.nit return y_samp, err2, n_iter
def optimize_ERV_shape_by_whole_transmission(ERV_f, initial_ERV_params, x_0_ERV, x, lambda_0, taper_params, SNAP_exp, bounds=None, max_iter=20): def _difference_for_ERV_shape(ERV_params, *details): ERV_f, x_0_ERV, x, wavelengths, lambda_0, taper_params, SNAP_exp = details ERV_array = ERV_f(x, x_0_ERV, ERV_params) SNAP = SNAP_model.SNAP(x, ERV_array, wavelengths, lambda_0) SNAP.set_taper_params(*taper_params) x_num, wavelengths, num_data = SNAP.derive_transmission() t = _difference_between_exp_and_num(SNAP_exp.x, SNAP_exp.transmission, x_num, num_data, wavelengths) print('ERV opt, delta_t is {}'.format(t)) return t if SNAP_exp.transmission_scale == 'log': SNAP_exp.convert_to_lin_transmission() wavelengths = SNAP_exp.wavelengths options = {} options['maxiter'] = max_iter [absS, phaseS, ReD, ImD_exc, C] = taper_params # use current taper parameters as initial guess res = sp_minimize(_difference_for_ERV_shape, initial_ERV_params, args=(ERV_f, x_0_ERV, x, wavelengths, lambda_0, taper_params, SNAP_exp), bounds=bounds, options=options, method='Nelder-Mead') ERV_params = res.x return res, ERV_params
def find_minimum(self) -> np.mat: res = sp_minimize(self.g, self.theta, method="Nelder-Mead", tol=1e-6) return np.mat(res.x)