def test_lds(steps=1000, show_plot=False, verbose=False):
T = steps
n, m, d = 10, 10, 2 # state, input, and observation dimension
environment = tigercontrol.environment("LDS")
system_params = {}
gaussian = lambda dims: random.normal(generate_key(), shape=dims)
for matrix, shape in {
'A': (n, n),
'B': (n, m),
'C': (d, n),
'D': (d, m)
}.items():
system_params[matrix] = gaussian(shape)
system_params_only_AC = {}
system_params_only_AC['A'] = system_params['A']
system_params_only_AC['C'] = system_params['C']
x_init = gaussian((n, ))
# Test custom noise
custom_nd_vector = lambda x, u: (0.1 * x + np.cos(u), 0)
custom_nd_scalar = lambda x, u: 0.1 * x + np.cos(u)
environment = tigercontrol.environment("LDS")
environment.reset(n,
m,
d,
partially_observable=True,
noise_distribution=custom_nd_vector)
environment = tigercontrol.environment("LDS")
environment.reset(
n,
m,
d=None,
partially_observable=False,
noise_distribution=custom_nd_scalar) #, system_params={})
test_output = []
for t in range(T):
u = random.normal(generate_key(), shape=(m, ))
test_output.append(environment.step(u))
info = environment.hidden()
if verbose:
print(info)
assert environment.T == T
if show_plot:
plt.plot(test_output)
plt.title("lds")
plt.show(block=False)
plt.pause(3)
plt.close()
print("test_lds passed")
return
def get_trajectory(environment, controller, T=100):
(environment_id, environment_params) = environment
(controller_id, controller_params) = controller
environment = tigercontrol.environment(environment_id)
x = environment.reset(**environment_params)
controller_params['A'], controller_params[
'B'] = environment.A, environment.B
controller = tigercontrol.controller(controller_id)
controller.initialize(**controller_params)
trajectory = []
norms = []
avg_regret = []
cur_avg = 0
u = controller.plan(x, T)
for i in range(T):
x = environment.step(u[i])
trajectory.append(x)
norms.append(np.linalg.norm(x))
cur_avg = (i / (i + 1)) * cur_avg + (np.linalg.norm(x) +
np.linalg.norm(u[i])) / (i + 1)
avg_regret.append(cur_avg)
return trajectory, norms, avg_regret
def test_sgd_lstm(show=False):
environment = tigercontrol.environment('LDS')
x = environment.reset(p=2,q=0)
controller = tigercontrol.controllers('LSTM')
controller.initialize(n=1, m=1, l=3, h=10, optimizer=SGD) # initialize with class
controller.predict(1.0) # call controllers to verify it works
controller.update(1.0)
optimizer = SGD(learning_rate=0.001)
controller = tigercontrol.controllers('LSTM')
controller.initialize(n=1, m=1, l=3, h=10, optimizer=optimizer) # reinitialize with instance
loss = []
for t in range(1000):
y_pred = controller.predict(x)
y_true = environment.step()
loss.append(mse(y_pred, y_true))
controller.update(y_true)
x = y_true
if show:
plt.title("Test SGD on LQR(3) with LSTM controller")
plt.plot(loss)
plt.show(block=False)
plt.pause(3)
plt.close()
def test_minitaur(steps=1000, verbose=False):
environment = tigercontrol.environment("PyBullet-Minitaur")
environment.reset(render=verbose)
sum_reward = 0
amplitude1 = 0.5
amplitude2 = 0.5
speed = 40
for step_counter in range(steps):
time_step = 0.01
t = step_counter * time_step
a1 = np.sin(t * speed) * amplitude1
a2 = np.sin(t * speed + np.pi) * amplitude1
a3 = np.sin(t * speed) * amplitude2
a4 = np.sin(t * speed + np.pi) * amplitude2
action = [a1, a2, a2, a1, a3, a4, a4, a3]
_, reward, done, _ = environment.step(action)
time.sleep(1. / 100.)
sum_reward += reward
if done:
environment.reset()
environment.close()
print("test_minitaur passed")
def test_custom_controller(steps=1000, show_plot=False):
# initial preparation
T = steps
loss = lambda y_true, y_pred: (y_true - y_pred)**2
environment = tigercontrol.environment("LDS") # return class
n, m = 2, 2 # state and action dimension
env = environment()
cur_x = env.initialize(n, m)
# simple zero custom controller implementation
class Custom(tigercontrol.CustomController):
def get_action(self, x):
return np.zeros((m, 1))
def update(self, y):
pass
# try registering and calling the custom controller
tigercontrol.register_custom_controller(Custom, "TestCustomController")
custom_controller = tigercontrol.controller("TestCustomController")
controller = custom_controller()
results = []
for i in range(T):
a = controller.get_action(cur_x)
cur_x = env.step(a)
if show_plot:
plt.plot(results)
plt.title("Custom (last value) controller on LQR environment")
plt.show(block=False)
plt.pause(1)
plt.close()
print("test_custom_controller passed")
return
def test_simulator(verbose=False):
environment = tigercontrol.environment("PyBullet-CartPole")
obs = environment.reset(render=verbose)
controller = tigercontrol.controllers("CartPoleNN")
controller.initialize(environment.get_observation_space(),
environment.get_action_space())
t_start = time.time()
save_to_mem_ID = -1
frame = 0
score = 0
restart_delay = 0
while time.time() - t_start < 3:
a = controller.predict(obs)
obs, r, done, _ = environment.step(a)
score += r
frame += 1
if verbose:
time.sleep(1. / 60.)
if verbose:
print("about to save state")
save_to_mem_ID = environment.getState()
if verbose:
print("save_state_ID: " + str(save_to_mem_ID))
# run simulator for 4 seconds
environment.loadState(environment.getState())
sim = environment.fork()
if verbose:
print("environment.loadState worked")
sim_score = score
sim_frame = frame
while time.time() - t_start < 3:
if verbose:
time.sleep(1. / 60.)
a = controller.predict(obs)
obs, r, done, _ = environment.step(a)
sim_score += r
sim_frame += 1
# resume stepping through environment for 2 seconds from the point when the simulator was launched (i.e. t = 1)
environment.loadState(save_to_mem_ID)
if verbose:
print("environment.loadState worked")
while time.time() - t_start < 3:
a = controller.predict(obs)
obs, r, done, _ = environment.step(a)
score += r
frame += 1
if verbose:
time.sleep(1. / 60.)
environment.close()
print("test_simulator passed")
def test_stress(env_id):
""" Description: run environment in a few high pressure situations """
environment_class = tigercontrol.environment(env_id)
env = environment_class()
n, m = env.get_state_dim(), env.get_action_dim(
) # get dimensions of system
x_0 = env.reset()
for t in range(10000):
env.step(t * np.ones(m))
def test_api(env_id):
""" Description: verify that all default methods work for this environment """
environment_class = tigercontrol.environment(env_id)
env = environment_class()
n, m = env.get_state_dim(), env.get_action_dim(
) # get dimensions of system
x_0 = env.reset() # first state
x_1 = env.step(np.zeros(m)) # try step with 0 action
assert np.isclose(
x_0, env.reset()) # assert reset return back to original state
def test_cartpole_double(verbose=False):
# try to break this test
environment = tigercontrol.environment("PyBullet-CartPoleSwingup")
obs = environment.reset(render=False)
#environment.close()
environment = tigercontrol.environment("PyBullet-CartPoleDouble")
obs = environment.reset(render=verbose)
controller = SmallReactivePolicy()
controller.initialize(environment.get_observation_space(), environment.get_action_space())
t_start = time.time()
save_to_mem_ID = -1
frame = 0
score = 0
restart_delay = 0
saved = False
while time.time() - t_start < 3:
time.sleep(1. / 60.)
a = controller.predict(obs)
obs, r, done, _ = environment.step(a)
score += r
frame += 1
if time.time() - t_start > 0 and not saved:
if verbose:
print("about to save to memory")
#save_to_mem_ID = environment.getState()
saved = True
if not done: continue
if restart_delay == 0:
if verbose:
print("score=%0.2f in %i frames" % (score, frame))
restart_delay = 60 * 2 # 2 sec at 60 fps
else:
restart_delay -= 1
if restart_delay > 0: continue
break
environment.close()
print("test_cartpole_double passed")
def test_ons(show=False):
#tigercontrol.set_key(0) # consistent randomness
environment = tigercontrol.environment('LDS')
x, y_true = environment.reset()
controllers = []
labels = ['OGD', 'ONS', 'Adam'] # don't run deprecated ONS
controller = tigercontrol.controllers('LSTM')
controller.initialize(n = 1, m = 1, optimizer=OGD) # initialize with class
controllers.append(controller)
#controller = tigercontrol.controllers('AutoRegressor')
#controller.initialize(optimizer=Adagrad) # initialize with class
#controllers.append(controller)
controller = tigercontrol.controllers('LSTM')
controller.initialize(n = 1, m = 1, optimizer=ONS) # initialize with class
controllers.append(controller)
#controller = tigercontrol.controllers('AutoRegressor')
#controller.initialize(optimizer=Adam) # initialize with class
#controllers.append(controller)
losses = [[] for i in range(len(controllers))]
update_time = [0.0 for i in range(len(controllers))]
for t in tqdm(range(2000)):
for i in range(len(controllers)):
l, controller = losses[i], controllers[i]
y_pred = controller.predict(x)
l.append(mse(y_pred, y_true))
t = time.time()
controller.update(y_true)
update_time[i] += time.time() - t
x, y_true = environment.step()
print("time taken:")
for t, label in zip(update_time, labels):
print(label + ": " + str(t))
if show:
plt.yscale('log')
for l, label in zip(losses, labels):
plt.plot(l, label = label)
#plt.plot(avg_regret(l), label = label)
plt.legend()
plt.title("Autoregressors on ENSO-T6")
plt.show(block=False)
plt.pause(300)
plt.close()
print("test_ons passed")
def test_pendulum(verbose=False):
environment = tigercontrol.environment("Pendulum")
#L = lambda x, u: 1. - x[1] # 1 - cos(theta), where theta=0 is the goal (pendulum pointing up)
# L = lambda x, u: x[0]**2
# C_x, C_u = np.diag(np.array([0.1, 0.0, 0.0, 0.0])), np.diag(np.array([0.1]))
# L = lambda x, u: x.T @ C_x @ x + u.T @ C_u @ u
dim_x, dim_u = 2, 1
obs = environment.reset()
T = 50 # horizon
'''
threshold = 0.01
lamb = 0.1
max_iterations = 50
controller = tigercontrol.controller("ILQR_3state")
controller.initialize(environment, dim_x, dim_u, max_iterations, lamb, threshold)
if verbose:
print("Running iLQR...")
u = controller.plan(obs, T)'''
total_cost = 0
#print("u: " + str([float(u_t) for u_t in u]))
index = 0
for t in range(10 * T):
# print("t:" + str(t))
if verbose:
environment.render()
time.sleep(1. / 30.)
# obs, cost, done = environment.step(u[index])
obs, cost, done = environment.step(np.zeros((1, )))
# total_cost += cost
index += 1
'''
if done:
if verbose:
print("lasted {} time steps".format(t+1))
obs = environment.reset()
'''
if done or index == T:
if verbose:
print("recomputing u...")
# print(total_cost)
obs = environment.reset()
# controller.initialize(environment, dim_x, dim_u, max_iterations, lamb, threshold)
# u = controller.plan(obs, T)
total_cost = 0
index = 0
environment.close()
print("test_pendulum passed")
def test_obstacles(verbose=False):
environment = tigercontrol.environment("PyBullet-Obstacles")
# obs = environment.reset(render=verbose)
# controller = tigercontrol.controllers("CartPoleNN")
# controller.initialize(environment.get_observation_space(), environment.get_action_space())
# Initial setup
# Flag that sets if things are visualized
# GUI = True; # Only for debugging purposes
GUI = True
random_seed = 5
m = 1
state, params, husky, sphere, obsUid = environment.reset(render=verbose)
numRays = params['numRays']
thetas_nominal = params['thetas_nominal']
# Controller and optimization setup
# Choose L controllers
num_x_intercepts = 1
num_y_intercepts = 1
L = num_x_intercepts * num_y_intercepts
x_intercepts = np.linspace(0.1, 5.0, num_x_intercepts)
y_intercepts = np.linspace(0.0, 10.0, num_y_intercepts)
print("x_intercepts: " + str(x_intercepts))
print("y_intercepts: " + str(y_intercepts))
print("thetas_nominal: " + str(thetas_nominal))
print("numRays: " + str(numRays))
K = L * [None]
for i in range(num_x_intercepts):
for j in range(num_y_intercepts):
K[i * num_y_intercepts + j] = np.zeros((numRays, 1))
for r in range(numRays):
if (thetas_nominal[r] > 0):
K[i * num_y_intercepts + j][r] = y_intercepts[j] * (
x_intercepts[i] - thetas_nominal[r]) / x_intercepts[i]
else:
K[i * num_y_intercepts + j][r] = y_intercepts[j] * (
-x_intercepts[i] - thetas_nominal[r]) / x_intercepts[i]
print("First K = " + str(K))
costs_precomputed = precompute_environment_costs(m, K, L, params, husky,
sphere, GUI, random_seed,
environment, obsUid)
print("costs_precomputed: " + str(costs_precomputed))
print("test_obstacles passed")
def test_cartpole(verbose=False):
environment = tigercontrol.environment("CartPole")
# environment = CartPole()
# task = CartPole_v0()
C_x, C_u = np.diag(np.array([0.1, 0.0, 1.0,
0.0])), np.diag(np.array([0.1]))
L = lambda x, u: x.T @ C_x @ x + u.T @ C_u @ u
dim_x, dim_u = 4, 1
update_period = 75
obs = environment.reset()
T = 75 # horizon
threshold = 0.01
lamb = 0.1
max_iterations = 25
controller = ILQR(environment, max_iterations, lamb, threshold)
# controller.initialize
if verbose:
print("Running iLQR...")
u = controller.plan(obs, T)
index = 0
for t in range(10 * T):
if verbose:
environment.render()
time.sleep(1. / 50.)
obs = environment.step(u[index])
index += 1
'''
if done:
if verbose:
print("lasted {} time steps".format(t+1))
obs = environment.reset()'''
if index == T:
if verbose:
print("recomputing u...")
obs = environment.reset()
u = controller.plan(obs, T)
# print("u : " + str(u))
index = 0
environment.close()
print("test_cartpole passed")
def test_kuka(verbose=False):
environment = tigercontrol.environment("PyBullet-Kuka")
obs = environment.reset(render=verbose)
policy = ContinuousDownwardBiasPolicy()
t_start = time.time()
while time.time() - t_start < 5:
done = False
episode_rew = 0
while not done:
if verbose:
environment.render(mode='human')
act = policy.sample_action(obs, .1)
obs, rew, done, _ = environment.step(act)
episode_rew += rew
environment.close()
print("test_kuka passed")
def test_double_pendulum(verbose=False):
environment = tigercontrol.environment("DoublePendulum")
# observe [cos(theta1) sin(theta1) cos(theta2) sin(theta2) thetaDot1 thetaDot2]
L = lambda x, u: (x[0] - x[2])**2
dim_x, dim_u = 4, 1
obs = environment.reset()
update_period = 75
T = 75 # horizon
threshold = 0.01
lamb = 0.1
max_iterations = 25
controller = tigercontrol.controllers("ILQR")
controller.initialize(environment, L, dim_x, dim_u, update_period,
max_iterations, lamb, threshold)
if verbose:
print("Running iLQR...")
# u = controller.plan(obs, T, max_iterations, lamb, threshold)
index = 0
for t in range(10 * T):
if verbose:
environment.render()
time.sleep(1. / 15.)
u = controller.plan(obs)
obs, r, done, _ = environment.step(u)
index += 1
if done:
if verbose:
print("solved double pendulum in {} time steps!".format(t + 1))
obs = environment.reset()
'''
if done or index == T:
if verbose:
print("recomputing u...")
u = controller.plan(obs, T, max_iterations, lamb, threshold)
index = 0'''
environment.close()
print("test_double_pendulum passed")
def test_grid_search_arma(show=False):
environment_id = "LDS"
controller_id = "GPC"
environment_params = {'n':3, 'm':2}
controller_params = {}
loss = lambda a, b: np.sum((a-b)**2)
search_space = {'optimizer':[]} # parameters for LQR controller
opts = [Adam, Adagrad, ONS, OGD]
lr_start, lr_stop = 0, -4 # search learning rates from 10^start to 10^stop
learning_rates = np.logspace(lr_start, lr_stop, 1+2*np.abs(lr_start - lr_stop))
for opt, lr in itertools.product(opts, learning_rates):
search_space['optimizer'].append(opt(learning_rate=lr)) # create instance and append
trials = 15
hpo = GridSearch() # hyperparameter optimizer
optimal_params, optimal_loss = hpo.search(controller_id, controller_params, environment_id, environment_params, loss,
search_space, trials=trials, smoothing=10, start_steps=100, verbose=show)
if show:
print("optimal loss: ", optimal_loss)
print("optimal params: ", optimal_params)
# test resulting controller params
controller = tigercontrol.controllers(controller_id)
controller.initialize(**optimal_params)
environment = tigercontrol.environment(environment_id)
x = environment.reset(**environment_params)
loss = []
if show:
print("run final test with optimal parameters")
for t in range(5000):
y_pred = controller.predict(x)
y_true = environment.step()
loss.append(mse(y_pred, y_true))
controller.update(y_true)
x = y_true
if show:
plt.plot(loss)
plt.show(block=False)
plt.pause(10)
plt.close()
def test_ant(steps=1000, verbose=False):
environment = tigercontrol.environment("PyBullet-Ant")
environment.reset(render=verbose)
sum_reward = 0
amplitude1 = 0.5
amplitude2 = 0.5
speed = 40
action = np.random.normal(size=environment.action_space)
for step_counter in range(steps):
action = 0.95 * action + np.random.normal(
size=environment.action_space)
_, reward, done, _ = environment.step(action)
time.sleep(1. / 100.)
sum_reward += reward
if done:
environment.reset()
print("test_ant passed")
def _run_test(self, controller_params, smoothing, min_steps, verbose=0):
""" Run a single test with given controller params, using median stopping rule """
# initialize environment and controller
if verbose:
print("Currently testing parameters: " + str(controller_params))
controller = tigercontrol.controller(self.controller_id)
controller.initialize(**controller_params)
environment = tigercontrol.environment(self.environment_id)
if environment.has_regressors:
x, y_true = environment.reset(**self.environment_params)
else:
x = environment.reset(**self.environment_params)
t = 0
losses = [] # sorted losses, used to get median
smooth_losses = np.zeros(
smoothing) # store previous losses to get smooth loss
while True: # run controller until worse than median loss, ignoring first 100 steps
t += 1
y_pred = controller.predict(x)
if environment.has_regressors:
controller.update(y_true)
loss = self.loss(y_pred, y_true)
else:
x = environment.step()
controller.update(x)
loss = self.loss(y_pred, x)
if t == 1: # fill all of smooth_losses with the first loss
for i in range(smoothing):
smooth_losses = self._update_smoothing(smooth_losses, loss)
else: # else replace only the oldest loss
smooth_losses = self._update_smoothing(smooth_losses, loss)
smooth_loss = np.mean(smooth_losses)
if t % smoothing == 0:
self._add_to_list(losses, smooth_loss)
if self._halting_rule(losses, smooth_loss) and t >= min_steps:
break
if verbose:
print("Final loss: ", smooth_loss)
return smooth_loss
def test_sgd_autoregressor(show=False):
environment = tigercontrol.environment('LDS')
x = environment.reset(p=2,q=0)
optimizer = SGD(learning_rate=0.0003)
controller = tigercontrol.controllers('AutoRegressor')
controller.initialize(p=3, optimizer=optimizer) # reinitialize with instance
loss = []
for t in range(1000):
y_pred = controller.predict(x)
y_true = environment.step()
loss.append(mse(y_pred, y_true))
controller.update(y_true)
x = y_true
if show:
plt.title("Test SGD on LQR(3) with AutoRegressor controller")
plt.plot(loss)
plt.show(block=False)
plt.pause(3)
plt.close()
def test_quadcopter():
# Controller parameters
CONTROLLER_PARAMETERS = {
'Linear_PID':{'P':np.array([300,300,7000]),'I':np.array([0.04,0.04,4.5]),'D':np.array([450,450,5000])},
'Angular_PID':{'P':np.array([22000,22000,1500]),'I':np.array([0,0,1.2]),'D':np.array([12000,12000,0])},
}
GOAL = np.array([0, 0, 2]) # x, y, z
YAW = 0
# initialize quadcopter and GUI
quad_environment = tigercontrol.environment("Quadcopter")
#quad_environment = quad_environment_class()
state = quad_environment.reset()
# initialize model and targets
quad_controller = QuadcopterModel()
quad_controller.initialize(CONTROLLER_PARAMETERS, GOAL, YAW)
# start control loop
motor_action = None
for i in range(1000):
motor_action = quad_controller.get_action(state)
state = quad_environment.step(motor_action)
print("test_quadcopter passed")
def test_dynaboost_lstm(steps=500, show=True):
# controller initialize
T = steps
controller_id = "LSTM"
ogd = OGD(learning_rate=0.01)
controller_params = {'n': 1, 'm': 1, 'l': 5, 'h': 10, 'optimizer': ogd}
controllers = []
Ns = [1, 3, 6]
for n in Ns: # number of weak learners
controller = tigercontrol.controllers("DynaBoost")
controller.initialize(controller_id, controller_params, n,
reg=1.0) # regularization
controllers.append(controller)
# regular AutoRegressor for comparison
autoreg = tigercontrol.controllers("AutoRegressor")
autoreg.initialize(p=4) # regularization
# environment initialize
p, q = 4, 0
environment = tigercontrol.environment("LDS")
y_true = environment.reset(p, q, noise_magnitude=0.1)
# run all boosting controller
result_list = [[] for n in Ns]
last_value = []
autoreg_loss = []
for i in range(T):
y_next = environment.step()
# predictions for every boosting controller
for result_i, controller_i in zip(result_list, controllers):
y_pred = controller_i.predict(y_true)
result_i.append(mse(y_next, y_pred))
controller_i.update(y_next)
# last value and autoregressor predictions
last_value.append(mse(y_true, y_next))
autoreg_loss.append(mse(autoreg.predict(y_true), y_next))
autoreg.update(y_next)
y_true = y_next
# plot performance
if show:
start = 100
x = np.arange(start, steps)
plt.figure(figsize=(12, 8))
# plot every boosting controller loss
for n, results in zip(Ns, result_list):
print("Mean loss for n={}: {}".format(
n, np.mean(np.array(results[start:]))))
plt.plot(x,
avg_regret(results[start:]),
label="DynaBoost, n={}".format(n))
# plot loss for last value and autoregressor controllers
print("Mean loss for LastValue: {}".format(
np.mean(np.array(last_value[start:]))))
plt.plot(x,
avg_regret(last_value[start:]),
label="Last value controller")
print("Mean loss for AutoRegressor: {}".format(
np.mean(np.array(autoreg_loss[start:]))))
plt.plot(x,
avg_regret(autoreg_loss[start:]),
label="AutoRegressor controller")
plt.title("DynaBoost controller on LQR environment")
plt.legend()
plt.show(block=False)
plt.pause(10)
plt.close()
def test_dynaboost_arma(steps=500, show=True):
# controller initialize
T = steps
controller_id = "AutoRegressor"
controller_params = {'p': 18, 'optimizer': OGD}
Ns = [64]
timelines = [6, 9, 12]
# regular AutoRegressor for comparison
autoreg = tigercontrol.controllers("AutoRegressor")
autoreg.initialize(p=18, optimizer=OGD)
fig, ax = plt.subplots(nrows=1, ncols=3)
cur = 0
# run all boosting controller
for timeline in timelines:
# environment initialize
environment = tigercontrol.environment("ENSO")
x, y_true = environment.reset(input_signals=['oni'], timeline=timeline)
controllers = []
for n in Ns: # number of weak learners
controller = tigercontrol.controllers("DynaBoost")
controller.initialize(controller_id, controller_params, n,
reg=0.0) # regularization
controllers.append(controller)
result_list = [[] for n in Ns]
autoreg_loss = []
for i in tqdm(range(T)):
# predictions for every boosting controller
for result_i, controller_i in zip(result_list, controllers):
y_pred = controller_i.predict(x)
result_i.append(mse(y_true, y_pred))
controller_i.update(y_true)
# last value and autoregressor predictions
autoreg_loss.append(mse(autoreg.predict(x), y_true))
autoreg.update(y_true)
x, y_true = environment.step()
# plot performance
if show:
start = T // 2
# plot every boosting controller loss
for n, results in zip(Ns, result_list):
print("Mean loss for n={}: {}".format(
n, np.mean(np.array(results))))
ax[cur].plot(avg_regret(results[-start:]),
label="DynaBoost, n={}".format(n))
# plot loss for last value and autoregressor controllers
print("Mean loss for AutoRegressor: {}".format(
np.mean(np.array(autoreg_loss))))
ax[cur].plot(avg_regret(autoreg_loss[-start:]),
label="AutoRegressor controller")
ax[cur].legend(loc="upper right", fontsize=8)
cur += 1
fig.tight_layout()
plt.show()
def test_tigercontrol_environment():
environment = tigercontrol.environment('LDS')
return
import jax.numpy as np
import tigercontrol as tc
import numpy.random as random
import matplotlib.pyplot as plt
from scipy.linalg import solve_discrete_are as dare
from tigercontrol.controllers import Controller
T, H, M, lr = 200, 10, 10, 0.001
n, m, A, B = 2, 1, np.array([[1., 1.], [0., 1.]]), np.array([[0.], [1.]])
Q, R = np.eye(N=n), np.eye(N=m)
x0 = np.zeros((n, 1))
Wproc = lambda n, x, u, w, t: random.normal(size=(n, 1))
Wproc = lambda n, x, u, w, t: np.sin(t / (2 * np.pi)) * np.ones((2, 1))
env = tc.environment('LDS')
class LQR(Controller):
def __init__(self, A, B, Q, R):
P = dare(A, B, Q, R)
self.K = np.linalg.inv(R + B.T @ P @ B) @ (B.T @ P @ A)
def plan(self, x):
return -self.K @ x
x = env.initialize(n,
m,
noise_distribution=Wproc,
system_params={
