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
