def get_bounds_output(self, idx=None): """ :return: class R.utils.bounds """ # TODO: add idx return rutils.bounds(min=np.array(self.output.min(axis=1)), max=np.array(self.output.max(axis=1)))
def __init__(self, BOdict, PolicyDict): self.PID_Object = PID_Objective(BOdict, PolicyDict) self.PIDMODE = BOdict['POLICYMODE'] evals = BOdict['ITERATIONS'] zeros = [0, 0, 0] maximums = [300, 150, 20] if self.PIDMODE == 'EULER': self.n_parameters = 9 elif self.PIDMODE == 'HYBRID': self.n_parameters = 12 elif self.PIDMODE == 'RATE' or self.PIDMODE == 'ALL': self.n_parameters = 18 else: print("Invalid PID mode selected") sys.exit(0) self.task = OptTask(f=self.PID_Object, n_parameters=self.n_parameters, n_objectives=1, bounds=bounds( min=zeros * int(self.n_parameters / 3), max=maximums * int(self.n_parameters / 3)), task={'minimize'}, vectorized=False) # labels_param = ['KP_pitch','KI_pitch','KD_pitch', 'KP_roll' 'KI_roll', 'KD_roll', 'KP_yaw', 'KI_yaw', 'KD_yaw', 'KP_pitchRate', 'KI_pitchRate', 'KD_pitchRate', 'KP_rollRate', # 'KI_rollRate', 'KD_rollRate', "KP_yawRate", "KI_yawRate", "KD_yawRate"]) self.Stop = StopCriteria(maxEvals=evals) self.sim = BOdict['sim']
def __init__(self, cfg, opt_function): # self.Objective = SimulationOptimizer(bo_cfg, policy_cfg) self.b_cfg = cfg.bo self.p_cfg = cfg.policy self.cfg = cfg self.t_c = self.p_cfg.pid.params.terminal_cost self.l_c = self.p_cfg.pid.params.living_cost self.norm_cost = 1 self.policy = PidPolicy(cfg) evals = cfg.bo.iterations param_min = [0] * len(list(cfg.pid.params.min_values)) param_max = [1] * len(list(cfg.pid.params.max_values)) self.n_parameters = self.policy.numParameters self.n_pids = self.policy.numpids params_per_pid = self.n_parameters / self.n_pids assert params_per_pid % 1 == 0 params_per_pid = int(params_per_pid) self.task = OptTask(f=opt_function, n_parameters=self.n_parameters, n_objectives=1, bounds=bounds(min=param_min * self.n_pids, max=param_max * self.n_pids), task={'minimize'}, vectorized=False) # labels_param = ['KP_pitch','KI_pitch','KD_pitch', 'KP_roll' 'KI_roll', 'KD_roll', 'KP_yaw', 'KI_yaw', 'KD_yaw', 'KP_pitchRate', 'KI_pitchRate', 'KD_pitchRate', 'KP_rollRate', # 'KI_rollRate', 'KD_rollRate', "KP_yawRate", "KI_yawRate", "KD_yawRate"]) self.Stop = StopCriteria(maxEvals=evals) self.sim = cfg.bo.sim
def __init__(self): """ Branin function """ super(Branin, self).__init__(f=self._f, name='Branin', n_parameters=2, n_objectives=1, order=0, bounds=rutils.bounds(max=[10, 15], min=[-5, 0]), task={'minimize'}, labels_param=None, labels_obj=None, vectorized=True, info=None, opt_obj=0.397887, opt_parameters=np.matrix([[-np.pi, 12.275], [np.pi, 2.275], [9.42478, 2.475]]), codomain=rutils.bounds(min=0, max=250) )
def __init__(self): """ MOP2 function """ super(MOP2, self).__init__(f=self._f, name='MOP2', n_parameters=2, n_objectives=2, order=0, bounds=rutils.bounds(min=[-2, -2], max=[2, 2]), task={'minimize', 'minimize'}, labels_param=None, labels_obj=None, vectorized=True, info=None, referencePoint=np.array([1, 1]))
def scalarization(self, dataset): """ Scalarize the dataset using the tchebycheff function :return: """ logging.info('Computing Tchebycheff scalarization') fx = dataset.get_output() fx_min = np.array(np.min(fx, axis=1)).squeeze() fx_max = np.array(np.max(fx, axis=1)).squeeze() rescaled_fx = rutils.bounds(min=fx_min, max=fx_max).transform_01().transform( fx).T # Rescale fx axis to 0-1 lambdas = np.random.rand(self.task.get_n_objectives()) lambdas = lambdas / np.sum( lambdas) # Rescale such that np.lambdas == 1 new_fx = self.tchebycheff_function(fx=rescaled_fx, lambdas=lambdas) out = rdata.dataset(data_input=dataset.get_input(), data_output=new_fx) return out
def __init__(self, n_parameters=2): """ Quadratic function """ super(Quadratic, self).__init__( f=self._f, fprime=self._g, name='Quadratic', n_parameters=n_parameters, n_objectives=1, order=1, bounds=rutils.bounds(max=[1] * n_parameters, min=[-1] * n_parameters), task={'minimize'}, labels_param=None, labels_obj=None, vectorized=False, info=None, opt_obj=0, opt_parameters=np.matrix([[0] * n_parameters]), )
def __init__(self, n_parameters=4, visualize=True): """ Quadratic function """ super(Rolling, self).__init__( f=self._f, fprime=self._g, name="Rolling", n_parameters=n_parameters, n_objectives=1, order=1, bounds=rutils.bounds(max=[2] * n_parameters, min=[-2] * n_parameters), task={"minimize"}, labels_param=None, labels_obj=None, vectorized=False, info=None, opt_obj=0, opt_parameters=np.matrix([[0] * n_parameters]), ) self.env = RollingEnv.RollingEnv(visTacto=visualize, visPyBullet=visualize)
from opto.opto.classes import StopCriteria from opto.utils import bounds from opto.opto.acq_func import EI from opto import regression from objective_functions import * import numpy as np import matplotlib.pyplot as plt from dotmap import DotMap init_vrep() load_scene('scenes/normal.ttt') obj_f = generate_f(parameter_mode='normal', objective_mode='single', steps=400) task = OptTask(f=obj_f, n_parameters=4, n_objectives=1, \ bounds=bounds(min=[1, -np.pi, 0, 0], max=[60, np.pi, 1, 1]), \ vectorized=False) stopCriteria = StopCriteria(maxEvals=50) p = DotMap() p.verbosity = 1 p.acq_func = EI(model=None, logs=None) p.optimizer = opto.CMAES p.model = regression.GP opt = opto.BO(parameters=p, task=task, stopCriteria=stopCriteria) opt.optimize() logs = opt.get_logs() print("Parameters: " + str(logs.get_parameters())) print("Objectives: " + str(logs.get_objectives())) exit_vrep()
from opto.opto.classes import StopCriteria from opto.utils import bounds from opto.opto.acq_func import EI from opto import regression from objective_functions import * import numpy as np import matplotlib.pyplot as plt from dotmap import DotMap init_vrep() load_scene('scenes/normal.ttt') obj_f = generate_f(parameter_mode='discovery', objective_mode='moo', steps=400) task = OptTask(f=obj_f, n_parameters=8, n_objectives=2, name='MOO', \ bounds=bounds(min=[1e-10,0,0,0,0,0,0,0], max=[60, 2 * np.pi, \ 2 * np.pi, 2 * np.pi, 2 * np.pi, 2 * np.pi, 2 * np.pi, 2 * np.pi]), \ vectorized=False) stopCriteria = StopCriteria(maxEvals=1250) p = DotMap() p.verbosity = 1 p.acq_func = EI(model=None, logs=None) p.optimizer = opto.CMAES p.model = regression.GP opt = opto.PAREGO(parameters=p, task=task, stopCriteria=stopCriteria) opt.optimize() logs = opt.get_logs() print("Parameters: " + str(logs.get_parameters())) print("Objectives: " + str(logs.get_objectives())) exit_vrep()
# load all of the parameters for the given date df = get_info_date("2019-03-26") # creates dataset object for our parameters and objective values # df[obj_labels] print("Parameters:") print(np.matrix(df[param_labels].values.T)) print("Objectives:") print(np.matrix(df['InvHuber'].values.T)) data_in = np.matrix(df[param_labels].values.T) data_out = np.matrix(df['InvHuber'].values.T) dataset = rdata.dataset(data_input=data_in, data_output=data_out) PID = PID_Objective(mode='Time') task = OptTask(f=PID, n_parameters=4, n_objectives=1, \ bounds=bounds(min=[0,0,0,0],max=[100,100,10,10]), vectorized=False, \ labels_param = ['KP_pitch','KP_roll', 'KD_pitch', 'KD_roll']) Stop = StopCriteria(maxEvals=50) # p_EI = DotMap() # p_EI.target = 999 # print(p_EI.get('target', 0)) # quit() # Create our own log object logs = Logs(store_x=True, store_fx=True, store_gx=False) logs.add_evals( x=data_in, # matrix will all parameters evaluated (N_param x N_Data) fx= data_out, # matrix with all corresponding obj function (N_obj x N_Data) # opt_x = , # Best parameters so far