def show_stack_info(model):
p = Plotter(ax_num=4)
lb = LabelBinarizer()
#load spectrum
spec = np.load(args['stack'])[args['index']]
#classify spectrum
p1, p2, p_stack = classify(model, spec, lb)
#load true stack parameters
name = args['stack'].split("/")[-1][:-4]
batch_dir_list = args['stack'].split("/")[:-2]
batch_dir = ""
for f in batch_dir_list:
batch_dir += f
batch_dir += "/"
with open(f"{batch_dir}params/{name}.pickle", "rb") as f:
stack_params = pickle.load(f)
t1, t2, t_stack = stack_params[args['index']]
pred_text = p.write_text(p1, p2, p_stack, loss_val=0)
true_text = p.write_text(t1, t2, t_stack, loss_val=0)
p.double_spec(spec, pred_text, true_text)
plt.show()
def run(config):
scores_history = []
solution = Solution(config)
for i in range(1000):
ep_start_time = datetime.datetime.now()
solution.reset()
Init()
observation = Game_step(2)
# Draw()
for stp in range(1000):
# print(str(stp))
action_button = solution.get_action(observation)
observation = Game_step(action_button)
# Draw()
scores_history.append(observation[4])
with open('config_0' + str(config) + '.pkl',
'wb') as file: # .pickle # wb = write binary
pickle.dump(scores_history, file)
print('Episode ' + str(i + 1) + ' - Runtime: %s ' %
(str(datetime.datetime.now() - ep_start_time).split('.')[0])
) # score: %.2f
Plotter.plot_running_average('Interceptor',
'config 0' + str(config),
scores_history,
window=100,
file_name='config_0' + str(config))
def main():
# reader = CsvReader()
# filename = "/media/jetxeberria/linux_storage/data/documents/besteak/egunean_behin_results.txt.csv"
# target_columns = ["Aciertos", "time", "Puntuacion"]
# contents = reader.raw_read(filename)
# cols_index, subcontents = reader.extract_columns(contents, target_columns)
# print(f"cols_index: {cols_index}")
# print(f"subcontents: {subcontents}")
reader = CsvReader()
reader.load_csv(
"/media/jetxeberria/linux_storage/data/documents/besteak/egunean_behin_results.csv"
)
reader.select_columns_by_name(["Aciertos", "time", "Puntuacion"])
plotter = Plotter()
x = np.array(reader.selection[1:, 0], dtype=np.float)
y = np.array(reader.selection[1:, 1], dtype=np.float)
z = np.array(reader.selection[1:, 2], dtype=np.float)
print(type(reader.selection))
print(x)
print(y)
print(z)
title = "Egunean Behin lehiaketa puntuatioiak"
plot = plotter.plot_3d(x,
y,
z,
suptitle=title,
xlabel="Aciertos",
ylabel="Tiempo [min]",
zlabel="Puntuacion")
outpath = "/media/jetxeberria/linux_storage/data/documents/besteak/egunean_behin_graph.png"
# save_plot(plot, outpath)
print(reader.selection)
def NN_test_loop(crawler, lb):
while True:
while True:
spectrum, true1, true2, true_stack = create_random_stack(
crawler, param_dict)
if np.max(spectrum) > 0.1:
break
l1, l2, stack = classify(model, spectrum, lb)
plotter = Plotter(ax3_on=True)
pred_text = plotter.write_text(l1, l2, stack, loss_val=0)
true_text = plotter.write_text(true1, true2, true_stack, loss_val=0)
plotter.double_text(spectrum, pred_text, true_text)
plt.show()
def preprocess_kitti_raw(raw_seq_dir, output_dir, cam_subset_range, plot_figures=True):
logger.initialize(working_dir=output_dir, use_tensorboard=False)
logger.print("================ PREPROCESS KITTI RAW ================")
logger.print("Preprocessing %s" % raw_seq_dir)
logger.print("Output to: %s" % output_dir)
logger.print("Camera images: %d => %d" % (cam_subset_range[0], cam_subset_range[1]))
oxts_dir = os.path.join(raw_seq_dir, "oxts")
image_dir = os.path.join(raw_seq_dir, "image_02")
gps_poses = np.loadtxt(os.path.join(oxts_dir, "poses.txt"))
gps_poses = np.array([np.vstack([np.reshape(p, [3, 4]), [0, 0, 0, 1]]) for p in gps_poses])
T_velo_imu = np.loadtxt(os.path.join(raw_seq_dir, "../T_velo_imu.txt"))
T_cam_velo = np.loadtxt(os.path.join(raw_seq_dir, '../T_cam_velo.txt'))
T_cam_imu = T_cam_velo.dot(T_velo_imu)
# imu timestamps
imu_timestamps = read_timestamps(os.path.join(oxts_dir, "timestamps.txt"))
assert (len(imu_timestamps) == len(gps_poses))
# load image data
cam_timestamps = read_timestamps(os.path.join(image_dir, "timestamps.txt"))
image_paths = [os.path.join(image_dir, "data", p) for p in sorted(os.listdir(os.path.join(image_dir, "data")))]
assert (len(cam_timestamps) == len(image_paths))
assert (cam_subset_range[0] >= 0 and cam_subset_range[1] < len(image_paths))
# the first camera timestamps must be between IMU timestamps
assert (cam_timestamps[cam_subset_range[0]] >= imu_timestamps[0])
assert (cam_timestamps[cam_subset_range[1]] <= imu_timestamps[-1])
# take subset of the camera images int the range of images we are interested in
image_paths = image_paths[cam_subset_range[0]: cam_subset_range[1] + 1]
cam_timestamps = cam_timestamps[cam_subset_range[0]: cam_subset_range[1] + 1]
# convert to local time reference in seconds
cam_timestamps = (cam_timestamps - imu_timestamps[0]) / np.timedelta64(1, 's')
imu_timestamps = (imu_timestamps - imu_timestamps[0]) / np.timedelta64(1, 's')
# take a subset of imu data corresponds to camera images
idx_imu_data_start = find_timestamps_in_between(cam_timestamps[0], imu_timestamps)[0]
idx_imu_data_end = find_timestamps_in_between(cam_timestamps[-1], imu_timestamps)[1]
imu_timestamps = imu_timestamps[idx_imu_data_start:idx_imu_data_end + 1]
gps_poses = gps_poses[idx_imu_data_start:idx_imu_data_end + 1]
# load IMU data from list of text files
imu_data = []
imu_data_files = sorted(os.listdir(os.path.join(oxts_dir, "data")))
start_time = time.time()
for i in range(idx_imu_data_start, idx_imu_data_end + 1):
print("Loading IMU data files %d/%d (%.2f%%)"
% (i + 1 - idx_imu_data_start, len(imu_timestamps),
100 * (i + 1 - idx_imu_data_start) / len(imu_timestamps)), end='\r')
imu_data.append(np.loadtxt(os.path.join(oxts_dir, "data", imu_data_files[i])))
imu_data = np.array(imu_data)
logger.print("\nLoading IMU data took %.2fs" % (time.time() - start_time))
assert (len(imu_data) == len(gps_poses))
# imu_data = imu_data[idx_imu_data_start:idx_imu_data_end + 1]
imu_timestamps, imu_data, gps_poses = remove_negative_timesteps(imu_timestamps, imu_data, gps_poses)
data_frames = []
start_time = time.time()
idx_imu_slice_start = 0
idx_imu_slice_end = 0
for k in range(0, len(cam_timestamps) - 1):
print("Processing IMU data files %d/%d (%.2f%%)" % (
k + 1, len(cam_timestamps), 100 * (k + 1) / len(cam_timestamps)), end='\r')
t_k = cam_timestamps[k]
t_kp1 = cam_timestamps[k + 1]
# the start value does not need to be recomputed, since you can get that from the previous time step, but
# i am a lazy person, this will work
while imu_timestamps[idx_imu_slice_start] < t_k:
idx_imu_slice_start += 1
assert (imu_timestamps[idx_imu_slice_start - 1] <= t_k <= imu_timestamps[idx_imu_slice_start])
# interpolate
tk_i = imu_timestamps[idx_imu_slice_start - 1]
tk_j = imu_timestamps[idx_imu_slice_start]
alpha_k = (t_k - tk_i) / (tk_j - tk_i)
T_i_vk, v_vk, w_vk, a_vk = \
interpolate(imu_data[idx_imu_slice_start - 1], imu_data[idx_imu_slice_start],
gps_poses[idx_imu_slice_start - 1], gps_poses[idx_imu_slice_start], alpha_k)
while imu_timestamps[idx_imu_slice_end] < t_kp1:
idx_imu_slice_end += 1
assert (imu_timestamps[idx_imu_slice_end - 1] <= t_kp1 <= imu_timestamps[idx_imu_slice_end])
# interpolate
tkp1_i = imu_timestamps[idx_imu_slice_end - 1]
tkp1_j = imu_timestamps[idx_imu_slice_end]
alpha_kp1 = (t_kp1 - tkp1_i) / (tkp1_j - tkp1_i)
T_i_vkp1, v_vkp1, w_vkp1, a_vkp1 = \
interpolate(imu_data[idx_imu_slice_end - 1], imu_data[idx_imu_slice_end],
gps_poses[idx_imu_slice_end - 1], gps_poses[idx_imu_slice_end], alpha_kp1)
imu_timestamps_k_kp1 = np.concatenate(
[[t_k], imu_timestamps[idx_imu_slice_start:idx_imu_slice_end - 1], [t_kp1]])
imu_poses = np.concatenate([[T_i_vk], gps_poses[idx_imu_slice_start:idx_imu_slice_end - 1], [T_i_vkp1]])
accel_measurements_k_kp1 = np.concatenate([[a_vk],
imu_data[idx_imu_slice_start: idx_imu_slice_end - 1, ax:az + 1],
[a_vkp1]])
gyro_measurements_k_kp1 = np.concatenate([[w_vk],
imu_data[idx_imu_slice_start: idx_imu_slice_end - 1, wx:wz + 1],
[w_vkp1]])
frame_k = SequenceData.Frame(image_paths[k], t_k, T_i_vk, v_vk,
imu_poses, imu_timestamps_k_kp1, accel_measurements_k_kp1, gyro_measurements_k_kp1)
data_frames.append(frame_k)
# assertions for sanity check
assert (np.allclose(data_frames[-1].timestamp, data_frames[-1].imu_timestamps[0], atol=1e-13))
assert (np.allclose(data_frames[-1].T_i_vk, data_frames[-1].imu_poses[0], atol=1e-13))
if len(data_frames) > 1:
assert (np.allclose(data_frames[-1].timestamp, data_frames[-2].imu_timestamps[-1], atol=1e-13))
assert (np.allclose(data_frames[-1].T_i_vk, data_frames[-2].imu_poses[-1], atol=1e-13))
assert (
np.allclose(data_frames[-1].accel_measurements[0], data_frames[-2].accel_measurements[-1], atol=1e-13))
assert (
np.allclose(data_frames[-1].accel_measurements[0], data_frames[-2].accel_measurements[-1], atol=1e-13))
# add the last frame without any IMU data
data_frames.append(SequenceData.Frame(image_paths[-1], t_kp1, T_i_vkp1, v_vkp1,
np.zeros([0, 4, 4]), np.zeros([0]), np.zeros([0, 3]), np.zeros([0, 3])))
logger.print("\nProcessing data took %.2fs" % (time.time() - start_time))
df = SequenceData.save_as_pd(data_frames, np.array([0, 0, 9.808679801065017]), np.zeros(3), T_cam_imu, output_dir)
data = df.to_dict("list")
if not plot_figures:
logger.print("All done!")
return
# ============================== FIGURES FOR SANITY TESTS ==============================
# plot trajectory
start_time = time.time()
plotter = Plotter(output_dir)
p_poses = np.array(data["T_i_vk"])
p_timestamps = np.array(data["timestamp"])
p_velocities = np.array(data["v_vk_i_vk"])
p_imu_timestamps = np.concatenate([d[:-1] for d in data['imu_timestamps']])
p_gyro_measurements = np.concatenate([d[:-1] for d in data['gyro_measurements']])
p_accel_measurements = np.concatenate([d[:-1] for d in data["accel_measurements"]])
p_imu_poses = np.concatenate([d[:-1, :, :] for d in data["imu_poses"]])
assert (len(p_imu_timestamps) == len(p_gyro_measurements))
assert (len(p_imu_timestamps) == len(p_accel_measurements))
assert (len(p_imu_timestamps) == len(p_imu_poses))
# integrate accel to compare against velocity
p_accel_int = [p_velocities[0, :]]
p_accel_int_int = [p_poses[0, :3, 3]]
# g = np.array([0, 0, 9.80665])
g = np.array([0, 0, 9.808679801065017])
# g = np.array([0, 0, 9.8096])
for i in range(0, len(p_imu_timestamps) - 1):
dt = p_imu_timestamps[i + 1] - p_imu_timestamps[i]
C_i_vk = p_imu_poses[i, :3, :3]
C_vkp1_vk = p_imu_poses[i + 1, :3, :3].transpose().dot(p_imu_poses[i, :3, :3])
v_vk_i_vk = p_accel_int[-1]
v_vkp1_vk_vk = dt * (p_accel_measurements[i] - C_i_vk.transpose().dot(g))
v_vkp1_i_vk = v_vk_i_vk + v_vkp1_vk_vk
p_accel_int.append(C_vkp1_vk.dot(v_vkp1_i_vk))
p_accel_int_int.append(p_accel_int_int[-1] + p_imu_poses[i, :3, :3].dot(p_accel_int[-1]) * dt)
p_accel_int = np.array(p_accel_int)
p_accel_int_int = np.array(p_accel_int_int)
# poses from integrating velocity
p_vel_int_poses = [p_poses[0, :3, 3]]
for i in range(0, len(p_velocities) - 1):
dt = p_timestamps[i + 1] - p_timestamps[i]
dp = p_poses[i, :3, :3].dot(p_velocities[i]) * dt
p_vel_int_poses.append(p_vel_int_poses[-1] + dp)
p_vel_int_poses = np.array(p_vel_int_poses)
plotter.plot(([p_poses[:, 0, 3], p_poses[:, 1, 3]],
[p_vel_int_poses[:, 0], p_vel_int_poses[:, 1]],
[p_accel_int_int[:, 0], p_accel_int_int[:, 1]],),
"x [m]", "Y [m]", "XY Plot", labels=["dat_poses", "dat_vel_int", "dat_acc_int^2"], equal_axes=True)
plotter.plot(([p_poses[:, 0, 3], p_poses[:, 2, 3]],
[p_vel_int_poses[:, 0], p_vel_int_poses[:, 2]],
[p_accel_int_int[:, 0], p_accel_int_int[:, 2]],),
"X [m]", "Z [m]", "XZ Plot", labels=["dat_poses", "dat_vel_int", "dat_acc_int^2"], equal_axes=True)
plotter.plot(([p_poses[:, 1, 3], p_poses[:, 2, 3]],
[p_vel_int_poses[:, 1], p_vel_int_poses[:, 2]],
[p_accel_int_int[:, 1], p_accel_int_int[:, 2]],),
"Y [m]", "Z [m]", "YZ Plot", labels=["dat_poses", "dat_vel_int", "dat_acc_int^2"], equal_axes=True)
plotter.plot(([p_timestamps, p_poses[:, 0, 3]],
[p_timestamps, p_vel_int_poses[:, 0]],
[p_imu_timestamps, p_accel_int_int[:, 0]],),
"t [s]", "Y [m]", "X Plot From Zero", labels=["dat_poses", "dat_vel_int", "dat_acc_int^2"])
plotter.plot(([p_timestamps, p_poses[:, 1, 3]],
[p_timestamps, p_vel_int_poses[:, 1]],
[p_imu_timestamps, p_accel_int_int[:, 1]],),
"t [s]", "Z [m]", "Y Plot From Zero", labels=["dat_poses", "dat_vel_int", "dat_acc_int^2"])
plotter.plot(([p_timestamps, p_poses[:, 2, 3]],
[p_timestamps, p_vel_int_poses[:, 2]],
[p_imu_timestamps, p_accel_int_int[:, 2]],),
"t [s]", "Z [m]", "Z Plot From Zero", labels=["dat_poses", "dat_vel_int", "dat_acc_int^2"])
# plot trajectory rotated wrt to the first frame
p_poses_from_I = np.array([np.linalg.inv(p_poses[0]).dot(p) for p in p_poses])
plotter.plot(([p_poses_from_I[:, 0, 3], p_poses_from_I[:, 1, 3]],),
"x [m]", "Y [m]", "XY Plot From Identity", equal_axes=True)
plotter.plot(([p_poses_from_I[:, 0, 3], p_poses_from_I[:, 2, 3]],),
"X [m]", "Z [m]", "XZ Plot From Identity", equal_axes=True)
plotter.plot(([p_poses_from_I[:, 1, 3], p_poses_from_I[:, 2, 3]],),
"Y [m]", "Z [m]", "YZ Plot From Identity", equal_axes=True)
# plot p_velocities
plotter.plot(([p_timestamps, p_velocities[:, 0]], [p_timestamps, p_velocities[:, 1]],
[p_timestamps, p_velocities[:, 2]]), "t [s]", "v [m/s]", "YZ Plot",
labels=["dat_vx", "dat_vy", "dat_vz"])
# make sure the interpolated acceleration and gyroscope measurements are the same
plotter.plot(([p_imu_timestamps, p_gyro_measurements[:, 0]], [imu_timestamps, imu_data[:, wx]],),
"t [s]", "w [rad/s]", "Rot Vel X Verification")
plotter.plot(([p_imu_timestamps, p_gyro_measurements[:, 1]], [imu_timestamps, imu_data[:, wy]],),
"t [s]", "w [rad/s]", "Rot Vel Y Verification")
plotter.plot(([p_imu_timestamps, p_gyro_measurements[:, 2]], [imu_timestamps, imu_data[:, wz]],),
"t [s]", "w [rad/s]", "Rot Vel Z Verification")
plotter.plot(([p_imu_timestamps, p_accel_measurements[:, 0]], [imu_timestamps, imu_data[:, ax]],),
"t [s]", "a [m/s^2]", "Accel X Verification")
plotter.plot(([p_imu_timestamps, p_accel_measurements[:, 1]], [imu_timestamps, imu_data[:, ay]],),
"t [s]", "a [m/s^2]", "Accel Y Verification")
plotter.plot(([p_imu_timestamps, p_accel_measurements[:, 2]], [imu_timestamps, imu_data[:, az]],),
"t [s]", "a [m/s^2]", "Accel Z Verification")
# integrate gyroscope to compare against rotation
p_gyro_int = [data["T_i_vk"][0][:3, :3]]
for i in range(0, len(p_imu_timestamps) - 1):
dt = p_imu_timestamps[i + 1] - p_imu_timestamps[i]
p_gyro_int.append(p_gyro_int[-1].dot(exp_SO3(dt * p_gyro_measurements[i])))
p_gyro_int = np.array([log_SO3(o) for o in p_gyro_int])
p_orientation = np.array([log_SO3(p[:3, :3]) for p in data["T_i_vk"]])
plotter.plot(([p_imu_timestamps, np.unwrap(p_gyro_int[:, 0])], [p_timestamps, np.unwrap(p_orientation[:, 0])],),
"t [s]", "rot [rad/s]", "Theta X Cmp Plot", labels=["gyro_int", "dat_pose"])
plotter.plot(([p_imu_timestamps, np.unwrap(p_gyro_int[:, 1])], [p_timestamps, np.unwrap(p_orientation[:, 1])],),
"t [s]", "rot [rad/s]", "Theta Y Cmp Plot", labels=["gyro_int", "dat_pose"])
plotter.plot(([p_imu_timestamps, np.unwrap(p_gyro_int[:, 2])], [p_timestamps, np.unwrap(p_orientation[:, 2])],),
"t [s]", "rot [rad/s]", "Theta Z Cmp Plot", labels=["gyro_int", "dat_pose"])
vel_from_gps_rel_poses = []
for k in range(0, len(gps_poses) - 1):
dt = imu_timestamps[k + 1] - imu_timestamps[k]
T_i_vk = gps_poses[k]
T_i_vkp1 = gps_poses[k + 1]
T_vk_vkp1 = np.linalg.inv(T_i_vk).dot(T_i_vkp1)
vel_from_gps_rel_poses.append(T_vk_vkp1[0:3, 3] / dt)
# vel_from_gps_rel_poses.append(log_SE3(T_vk_vkp1)[0:3] / dt)
vel_from_gps_rel_poses = np.array(vel_from_gps_rel_poses)
plotter.plot(([imu_timestamps[1:], vel_from_gps_rel_poses[:, 0]],
[p_timestamps, p_velocities[:, 0]],
[p_imu_timestamps, p_accel_int[:, 0]],),
"t [s]", "v [m/s]", "Velocity X Cmp Plot", labels=["gps_rel", "dat_vel", "dat_accel_int"])
plotter.plot(([imu_timestamps[1:], vel_from_gps_rel_poses[:, 1]],
[p_timestamps, p_velocities[:, 1]],
[p_imu_timestamps, p_accel_int[:, 1]],),
"t [s]", "v [m/s]", "Velocity Y Cmp Plot", labels=["gps_rel", "dat_vel", "dat_accel_int"])
plotter.plot(([imu_timestamps[1:], vel_from_gps_rel_poses[:, 2]],
[p_timestamps, p_velocities[:, 2]],
[p_imu_timestamps, p_accel_int[:, 2]],),
"t [s]", "v [m/s]", "Velocity Z Cmp Plot", labels=["gps_rel", "dat_vel", "dat_accel_int"])
logger.print("Generating figures took %.2fs" % (time.time() - start_time))
logger.print("All done!")
def main(args):
# DATASET
print('\nLOADING DATASET.')
train_data = datasets.FashionMNIST(args.dataset_dir,
train=False,
transform=args.transform,
download=True)
train_sampler, val_sampler = subdivide_dataset(train_data,
val_size=args.val_size,
shuffle=True)
train_loader = torch.utils.data.DataLoader(train_data,
batch_size=args.batch_size,
sampler=train_sampler,
**args.kwargs)
val_loader = torch.utils.data.DataLoader(train_data,
batch_size=args.batch_size,
sampler=val_sampler,
**args.kwargs)
print('Dataset: {:d} samples (T: {:d} / V: {:d})'.format(
len(train_data), len(train_sampler), len(val_sampler)))
# MODEL
print('\nLOADING MODEL.')
model = eval(args.model)()
model.to(args.device)
print('Model: {} ({:.2f}M params)'.format(
model._get_name(),
sum(p.numel() for p in model.parameters()) / 1e6))
# TRAINING
print('\nTRAINING')
criterion = torch.nn.CrossEntropyLoss()
optim = torch.optim.Adam(filter(lambda p: p.requires_grad,
model.parameters()),
lr=args.lr,
weight_decay=args.wd)
scheduler = torch.optim.lr_scheduler.ExponentialLR(
optim, gamma=args.scheduler_gamma)
train_loss, val_loss, val_acc = [], [], []
best_acc, i = 0, 0
start_time = time.time()
for epoch in range(args.epochs):
# Train loop
model.train()
for i, (images, labels) in enumerate(train_loader, 1):
images, labels = images.to(args.device), labels.to(args.device)
# Forward pass
optim.zero_grad()
output = model(images)
loss = criterion(output, labels)
# Backward pass
loss.backward()
optim.step()
# Log
train_loss.append(float(loss))
if args.log_interval and i % args.log_interval == 0:
mean_loss = np.mean(train_loss[-args.log_interval:])
print(
"[Epoch {:02d} / Iter: {:04d}]: TRAIN loss: {:.3f}".format(
epoch + 1,
epoch * len(train_loader) + i, mean_loss))
# Validation loop
model.eval()
val_loss_meter = AverageMeter()
val_acc_meter = AverageMeter()
for images, labels in val_loader:
images, labels = images.to(args.device), labels.to(args.device)
with torch.no_grad():
output = model(images)
val_loss_meter.update(float(criterion(output, labels)),
n=labels.size(0))
pred = torch.max(output, 1)[1]
val_acc_meter.update(torch.sum(pred == labels).item() /
labels.size(0),
n=labels.size(0))
val_loss.append(val_loss_meter.avg)
val_acc.append(val_acc_meter.avg)
scheduler.step()
# Epoch logging
if args.log_interval:
print("[Epoch {:02d} / Iter: {:04d}]: EVAL. loss: {:.3f}".format(
epoch + 1,
epoch * len(train_loader) + i, val_loss_meter.avg))
print("[Epoch {:02d} / Iter: {:04d}]: EVAL. acc.: {:.3f}".format(
epoch + 1,
epoch * len(train_loader) + i, val_acc_meter.avg))
eta = int((time.time() - start_time) *
(args.epochs - (epoch + 1)) / ((epoch + 1)))
print('ETA: {:s}'.format(str(datetime.timedelta(seconds=eta))))
# Early Stopping
is_best = val_acc_meter.avg > best_acc
if is_best:
best_acc = val_acc_meter.avg
print('Saving at checkpoint...')
state = {
"train_loss": train_loss,
"val_loss": val_loss,
"val_acc": val_acc,
"best_acc": best_acc,
"epoch": epoch,
"model": model.state_dict(),
"args": args.__dict__
}
torch.save(
state,
os.path.join(args.output_dir, args.expID + "_checkpoint.pth"))
# Plot training curves
plotter = Plotter(os.path.join(args.output_dir, args.expID))
plotter.plot_training(train_loss, val_loss, val_acc)
save_dirs = get_paths(drive=args.drive_save, env_name=ENV_NAME)
PRINT_FREQ_EP = args.log_freq
SAVE_MODEL_FREQ = args.save_freq
LEARNING_START = args.learn_start
logger = Logger(save_dirs=save_dirs,
log_types=[],
log_freq=args.log_freq,
mode=args.mode)
plotter = Plotter(save_dirs=save_dirs,
plot_types=[
'avg_scores_ep', 'avg_scores_ts', 'avg_scores_100_ep',
'avg_scores_100_ts', 'scores_ep', 'scores_ts',
'high_scores_ep', 'high_scores_ts', 'low_scores_ep',
'low_scores_ts', 'avg_loss_ep', 'avg_acc_ep',
'timesteps_ep'
],
interval_types=['overall', 'window'],
plot_freq=args.plot_freq,
mode=args.mode)
env = make_atari(ENV_GYM)
env = wrap_deepmind(env, frame_stack=True, scale=False)
if args.mode == 'train':
agent = DDQNLearner(
env=env,
save_dirs=save_dirs,
save_freq=args.save_freq,
gamma=args.gamma,
"thickness": [20, 80],
"periode": [250, 700],
}
bounds_l2 = {
"width": [40, 350],
"length": [40, 350],
"thickness": [20, 80],
"periode": [250, 700],
}
bounds_stack = {
"angle": [0, 90],
"spacer_height": [0, 0.3],
}
plt.ion()
plotter = Plotter(ax_num=3)
sli = SingleLayerInterpolator(crawler)
sli.interpolate = args["interpolate"]
stp = 0
def callback(xk):
global stp
print(stp)
stp += 1
print("[INFO] optimizing continuous parameters...")
sol = minimize(loss,
guess,
args=(target_spectrum, p1, p2, p_stack, bounds_l1,
bounds_l2, bounds_stack, crawler, plotter, sli, stp),
method="Nelder-Mead",
def __init__(self, parameters={}):
""" If it exists, use user-defined parameters, otherwise use defaults
Parameters
---------
parameters: dict
Model hyperparameters. Supports 'lr', 'batch_size'.
"""
defaults = {
"lr": 0.0005,
"batch_size": 256
}
for param_name, value in defaults.items():
if param_name in parameters:
value = parameters[param_name]
setattr(self, param_name, value)
def train(self, X):
""" Fit model to training data """
pass
def test(self, X):
""" Reconstruct input/test data """
pass
if __name__ == "__main__""":
mnist = fetch_mldata('MNIST original')
plt = Plotter()
print("=== Job Complete ===")
with open('w.pickle','wb')as w:
pickle.dump(wins,w)
with open('rnd.pickle','wb') as rnd:
pickle.dump(i,rnd)
with open('g.pickle','wb')as g:
moves = []
pickle.dump(moves, g)
def update(self):
"""Update the gui with the current value."""
self.drawBoard()
if __name__ == "__main__":
global plotter
plotter = Plotter(env_name='GrandmasterFLEX')
app = QApplication(sys.argv)
gui = MainWindow()
# chess board and "engine"
s = State()
wins=pd.DataFrame({'W':[1,0],'B':[0,1],'Winner':['White','Black']})
with open('w.pickle','wb')as w:
pickle.dump(wins,w)
with open('si.pickle', 'wb') as p:
pickle.dump(s, p)
i = 0
with open('rnd.pickle','wb') as rnd:
pickle.dump(i,rnd)
with open('g.pickle','wb')as g:
moves = []
pickle.dump(moves, g)
def train(env,
agent_class: Type[RLAgent],
epochs: int = 100,
num_rollouts: int = 1,
max_timesteps: int = -1,
print_frequency: int = 1,
tests: int = None,
render_frequency: Optional[int] = None,
plot_frequency: Optional[int] = None,
seed: Optional[int] = None):
"""
Generalized training function.
--------------------------------------------------------------------------------------------------------------------
For each epoch, creates several rollouts (trajectories) of the given environment.
Requires get_action(state) function to determine an action for the given state and let an agent act in the
environment, and update_agent(trajectories), that is called at the end of an epoch - when all rollouts have finished
to train an agent.
--------------------------------------------------------------------------------------------------------------------
:param env: OpenAI gym environment
:param agent_class: Agent instance to be acting in the environment
:param epochs: Number of epochs to train
:param num_rollouts: Number of trajectories per epoch
:param print_frequency: How often will the results be printed.
For example, if set to 5, will print results every 5 epochs
:param render_frequency: How often will the environment be rendered. This number is shared across trajectories
and epochs. For example, if set to 5, and number of trajectories is 3, will render at
(epoch 0, traj. 0), (epoch 1, traj. 1), (epoch 2, traj. 0) ...
:param max_timesteps: Maximum timesteps per trajectory. If the rollout is too long (for example, when agent performs
well, this will cut of the rollout, so we don't have infinitely long rollouts
:param plot_frequency: How often should the results be plotted
:param tests: How many test should run on the trained model, or None
:param seed: Custom seed, or None
"""
if max_timesteps < 0:
max_timesteps = math.inf
if seed is not None:
env.seed(seed)
plotter = Plotter()
plotter['reward'].name = "Mean total epoch reward"
total_time = 0.
epochs_time = 0.
start_time = time.time()
agent = agent_class(env)
global_rollout = 0
for epoch in range(epochs):
rollouts = []
rollout_rewards = []
for rollout in range(num_rollouts):
state = env.reset()
done = False
agent.on_trajectory_started(state)
total_reward = 0
t = 0
while not done and t < max_timesteps:
if render_frequency and global_rollout % render_frequency == 0:
env.render()
action = agent.get_action(state)
state, reward, done, _ = env.step(action)
agent.save_step(action, reward, state)
t += 1
total_reward += reward
agent.on_trajectory_finished()
rollout_rewards.append(total_reward)
global_rollout += 1
agent.update()
plotter['reward'] += mean(rollout_rewards)
end_time = time.time()
epochs_time += end_time - start_time
start_time = end_time
if epoch % print_frequency == 0:
total_time += epochs_time
print(f'Epoch\t{epoch} \t| '
f'{total_time:.02f}s \t| '
f'Mean total reward\t{mean(plotter["reward"].y[-print_frequency:]):.4f}')
epochs_time = 0.
if plot_frequency is not None and epoch % plot_frequency == 0:
plotter.show("reward", running_average=True)
# Display the performance of the trained model for several times
if tests is not None:
agent.evaluate()
for t in range(tests):
state = env.reset()
total_reward = 0
step = 0
while step < max_timesteps:
env.render()
action = agent.get_action(state)
state, reward, done, _ = env.step(action)
total_reward += reward
step += 1
if done:
break
print(f'Test {t}: total reward: {total_reward}')
def main():
args = parse_args()
if not os.path.exists(config.OUTPUT_DIR):
os.makedirs(config.OUTPUT_DIR)
print(config)
device = torch.device('cuda:0' if torch.cuda.is_available() else 'cpu')
model = AnoVAEGAN(config.MODEL.IN_CHANNELS, config.MODEL.N_LAYERS,
config.MODEL.N_FEATURES)
discriminator = Discriminator(config.MODEL.IN_CHANNELS,
config.DATASET.INPUT_SIZE,
config.MODEL.N_LAYERS,
config.MODEL.N_FEATURES)
model.to(device)
discriminator.to(device)
model.train()
discriminator.train()
print(model)
dataset = MNISTDataset(data_dir=config.DATASET.DIR,
split='train',
input_size=config.DATASET.INPUT_SIZE,
transforms=[("HorizontalFlip", None),
("Rotation", {
"degrees": 30
})])
train_loader = DataLoader(dataset,
batch_size=config.OPTIM.BATCH_SIZE,
shuffle=True)
model_opt, model_scheduler = build_opt(config, model, len(train_loader))
disc_opt, disc_scheduler = build_opt(config,
discriminator,
len(train_loader),
discriminator=True)
rec_loss = build_loss(config.LOSS.REC_LOSS)
prior_loss = build_loss(config.LOSS.PRIOR_LOSS)
adv_loss = build_loss(config.LOSS.ADV_LOSS)
rec_key = rec_loss_map[config.LOSS.REC_LOSS]
loss_meter = ExpAvgMeter(0.98)
rec_loss_meter = ExpAvgMeter(0.98)
prior_loss_meter = ExpAvgMeter(0.98)
adv_loss_meter = ExpAvgMeter(0.98)
if config.VISDOM:
plotter = Plotter(
log_to_filename=os.path.join(config.OUTPUT_DIR, "logs.viz"))
step = 0
for e in range(config.OPTIM.EPOCH):
pbar = tqdm(train_loader)
for img in pbar:
step += 1
img = img.to(device)
valid = torch.full((img.shape[0], 1),
1,
dtype=torch.float,
device=device)
fake = torch.full((img.shape[0], 1),
0,
dtype=torch.float,
device=device)
out = model(img)
rec_l = rec_loss(out[rec_key], img)
prior_l = prior_loss(out['mu'], out['logvar'])
adv_l = adv_loss(discriminator(out['rec']), valid)
loss = config.LOSS.REC_LOSS_COEFF * rec_l \
+ config.LOSS.PRIOR_LOSS_COEFF * prior_l \
+ config.LOSS.ADV_LOSS_COEFF * adv_l
model_opt.zero_grad()
loss.backward()
model_opt.step()
if model_scheduler.update_on_step:
model_scheduler.step()
real_loss = adv_loss(discriminator(img), valid)
fake_loss = adv_loss(discriminator(out['rec'].detach()), fake)
disc_loss = 0.5 * (real_loss + fake_loss)
disc_opt.zero_grad()
disc_loss.backward()
disc_opt.step()
if disc_scheduler.update_on_step:
disc_scheduler.step()
loss_meter.update(float(loss.data))
rec_loss_meter.update(float(rec_l.data))
prior_loss_meter.update(float(prior_l.data))
adv_loss_meter.update(float(adv_l.data))
pbar.set_description(
'Train Epoch : {0}/{1} Loss : {2:.4f} '.format(
e + 1, config.OPTIM.EPOCH, loss_meter.value))
if config.VISDOM and step % config.PLOT_EVERY == 0:
plotter.plot("Loss", step, loss_meter.value, "Loss", "Step",
"Value")
plotter.plot("Loss", step, rec_loss_meter.value, "Rec loss",
"Step", "Value")
plotter.plot("Loss", step, prior_loss_meter.value,
"Prior loss", "Step", "Value")
plotter.plot("Loss", step, adv_loss_meter.value, "Adv loss",
"Step", "Value")
model_lr = model_opt.param_groups[0]['lr']
disc_lr = disc_opt.param_groups[0]['lr']
plotter.plot("LR", step, model_lr, "Model LR", "Step", "Value")
plotter.plot("LR", step, disc_lr, "Discr LR", "Step", "Value")
if config.DEBUG.USE and step % config.DEBUG.DEBUG_EVERY == 0:
save_batch_output(img, out['rec'], config.DEBUG.DETECT_THRESH,
config.DEBUG.SAVE_SIZE, config.OUTPUT_DIR,
'batch_{}'.format(step))
if not model_scheduler.update_on_step:
model_scheduler.step()
if not disc_scheduler.update_on_step:
disc_scheduler.step()
save_path = os.path.join(config.OUTPUT_DIR,
config.EXP_NAME + "_checkpoint.pth")
torch.save({'cfg': config, 'params': model.state_dict()}, save_path)
base_dir = "/home/cs4li/Dev/deep_ekf_vio/results/final_thesis_results"
gt_poses = np.load(
os.path.join(pfind(base_dir, "KITTI_nogloss", seq + "_train"),
"saved_model.eval.traj/gt_poses", seq + ".npy"))
vanilla_poses = np.load(
os.path.join(pfind(base_dir, "KITTI_nogloss", seq + "_train"),
"saved_model.eval.traj/est_poses", seq + ".npy"))
vision_only_poses = np.load(
os.path.join(pfind(base_dir, "KITTI_vision_only_aug", seq),
"saved_model.eval.traj/est_poses", seq + ".npy"))
msf_fusion_poses = np.load(
os.path.join(base_dir, "KITTI_msf", seq, "est_shifted.npy"))
imu_only_poses = np.load(
os.path.join(base_dir, "KITTI_imu_only", seq, "est.npy"))
plotter = Plotter(os.path.join(base_dir, "KITTI_figures"))
def plot_callback(fig, ax):
ax.plot(gt_poses[0, 0, 3],
gt_poses[0, 1, 3],
'x',
color='black',
markersize=10,
markeredgewidth=2,
label="start")
ax.plot()
ax.legend(numpoints=1, prop={'size': 8})
#K07
if seq == "K07":
return net
if __name__ == '__main__':
# parser = argparse.ArgumentParser()
# parser.add_argument("--datapath", type=str, default="../data", help="path to the dataset")
# parser.add_argument("--file", type=str, default="combined2.csv")
# args = parser.parse_args()
# file_name = args.datapath + '/' + args.file
path = '../data/*.csv'
for fname in glob.glob(path):
global plotter
plotter = Plotter(env_name='Algo Trading Project')
print(fname)
data = DataProcessing(fname, train_size)
train_data, train_target = data.trainingData()
net = Train()
n = fname.split('/')[-1].split('.')[0]
for epoch in range(num_epochs):
net = trainNetwork(net, train_data, train_target, epoch, n)
if os.path.isdir('../saved_models') == False:
os.mkdir('../saved_models')
torch.save(net.network.state_dict(),
def run(self):
best_plotter = Plotter(1)
particle_plotter = Plotter(2)
for particle in self.particles:
viol_cost = particle.calc_violation(particle.pos)
aep = self.calc_aep(particle.pos)
particle.fitness = self.calc_fitness(aep, viol_cost)
if (self.g_best_fitness is None
or particle.fitness > self.g_best_fitness):
self.g_best_fitness = particle.fitness
self.g_best_pos = particle.pos
self.g_best_aep = aep
particle.best_pos = particle.pos
particle.best_aep = aep
particle.best_fitness = particle.fitness
self.log_data()
for particle in self.particles:
particle_plotter.plot(particle.pos)
best_plotter.plot(self.g_best_pos)
self.iter_count = 1
while (self.iter_count < self.max_iterations):
self.iterate()
self.log_data()
self.iter_count = self.iter_count + 1
for particle in self.particles:
particle_plotter.plot(particle.pos)
best_plotter.plot(self.g_best_pos)
self.log_data()
self.log_file('results/' + str(round(self.g_best_aep, 4)) + "_" +
str(round(self.g_best_fitness, 4)) + "_" +
str(self.num_particles) + "_" +
str(self.max_iterations) + '.csv')
X_base_train, y_base_train, vocab_processor_base, X_base_test, y_base_test = pp.preprocess(
datasource="s140")
X1_train, y1_train, vocab_processor1, X1_test, y1_test = pp.preprocess(
datasource="scv1")
X2_train, y2_train, vocab_processor2, X2_test, y2_test = pp.preprocess(
datasource="scv2")
X_val, y_val = pp.preprocess(datasource="s140", split=False)
# third, run the models
# baseline
cnn_model_base = SarcasmCNN(data=((X_base_train, y_base_train), (X_base_test,
y_base_test)),
vocab_processor=vocab_processor_base)
print("Baseline Performance")
cnn_model_base.run()
Plotter(cnn_model_base.history).plot_history()
# Pretrained on SCv1
cnn_model1 = SarcasmCNN(data=((X1_train, y1_train), (X1_test, y1_test)),
vocab_processor=vocab_processor1)
print("Internal validation on SCv1")
cnn_model1.run()
Plotter(cnn_model1.history).plot_history()
print("Test validation on hand labeled S140")
cnn_model1.evaluate(X_val, y_val)
# Pretrained on SCv2
cnn_model2 = SarcasmCNN(data=((X2_train, y2_train), (X2_test, y2_test)),
vocab_processor=vocab_processor2)
print("Internal validation on SCv2")
def plot_ekf_data(output_dir,
timestamps,
gt_poses,
gt_vels,
est_poses,
est_states,
g_const=9.80665):
# convert all to np
timestamps = np.array([np.array(item) for item in timestamps],
dtype=np.float64)
gt_poses = np.array([np.array(item) for item in gt_poses],
dtype=np.float64)
gt_vels = np.array([np.array(item) for item in gt_vels], dtype=np.float64)
est_poses = np.array([np.array(item) for item in est_poses],
dtype=np.float64)
est_states = np.array([np.array(item) for item in est_states],
dtype=np.float64)
est_positions = []
est_vels = []
est_rots = []
est_gravities = []
est_ba = []
est_bw = []
for i in range(0, len(est_poses)):
pose = np.linalg.inv(est_poses[i])
g, C, r, v, bw, ba = IMUKalmanFilter.decode_state(
torch.tensor(est_states[i]))
est_positions.append(pose[0:3, 3])
est_rots.append(log_SO3(pose[0:3, 0:3]))
est_vels.append(np.array(v))
est_gravities.append(np.array(g))
est_bw.append(np.array(bw))
est_ba.append(np.array(ba))
est_positions = np.squeeze(est_positions)
est_vels = np.squeeze(est_vels)
est_rots = np.squeeze(est_rots)
est_gravities = np.squeeze(est_gravities)
est_bw = np.squeeze(est_bw)
est_ba = np.squeeze(est_ba)
gt_rots = np.array([log_SO3(p[:3, :3]) for p in gt_poses])
gt_gravities = np.array([
gt_poses[i, 0:3, 0:3].transpose().dot([0, 0, g_const])
for i in range(0, len(gt_poses))
])
est_rots[:, 0] = np.unwrap(est_rots[:, 0])
est_rots[:, 1] = np.unwrap(est_rots[:, 1])
est_rots[:, 2] = np.unwrap(est_rots[:, 2])
gt_rots[:, 0] = np.unwrap(gt_rots[:, 0])
gt_rots[:, 1] = np.unwrap(gt_rots[:, 1])
gt_rots[:, 2] = np.unwrap(gt_rots[:, 2])
plotter = Plotter(output_dir)
plotter.plot((
[gt_poses[:, 0, 3], gt_poses[:, 1, 3]],
[est_positions[:, 0], est_positions[:, 1]],
),
"x [m]",
"y [m]",
"XY Plot",
labels=["gt_poses", "est_pose"],
equal_axes=True)
plotter.plot((
[gt_poses[:, 0, 3], gt_poses[:, 2, 3]],
[est_positions[:, 0], est_positions[:, 2]],
),
"x [m]",
"z [m]",
"XZ Plot",
labels=["gt_poses", "est_pose"],
equal_axes=True)
plotter.plot((
[gt_poses[:, 1, 3], gt_poses[:, 2, 3]],
[est_positions[:, 1], est_positions[:, 2]],
),
"y [m]",
"z [m]",
"YZ Plot",
labels=["gt_poses", "est_pose"],
equal_axes=True)
plotter.plot((
[timestamps, gt_poses[:, 0, 3]],
[timestamps, est_positions[:, 0]],
),
"t [s]",
"p [m]",
"Pos X",
labels=["gt", "est"])
plotter.plot((
[timestamps, gt_poses[:, 1, 3]],
[timestamps, est_positions[:, 1]],
),
"t [s]",
"p [m]",
"Pos Y",
labels=["gt", "est"])
plotter.plot((
[timestamps, gt_poses[:, 2, 3]],
[timestamps, est_positions[:, 2]],
),
"t [s]",
"p [m]",
"Pos Z",
labels=["gt", "est"])
plotter.plot((
[timestamps, gt_vels[:, 0]],
[timestamps, est_vels[:, 0]],
),
"t [s]",
"v [m/s]",
"Vel X",
labels=["gt", "est"])
plotter.plot((
[timestamps, gt_vels[:, 1]],
[timestamps, est_vels[:, 1]],
),
"t [s]",
"v [m/s]",
"Vel Y",
labels=["gt", "est"])
plotter.plot((
[timestamps, gt_vels[:, 2]],
[timestamps, est_vels[:, 2]],
),
"t [s]",
"v [m/s]",
"Vel Z",
labels=["gt", "est"])
plotter.plot((
[timestamps, gt_rots[:, 0]],
[timestamps, est_rots[:, 0]],
),
"t [s]",
"rot [rad]",
"Rot X",
labels=["gt", "est"])
plotter.plot((
[timestamps, gt_rots[:, 1]],
[timestamps, est_rots[:, 1]],
),
"t [s]",
"rot [rad]",
"Rot Y",
labels=["gt", "est"])
plotter.plot((
[timestamps, gt_rots[:, 2]],
[timestamps, est_rots[:, 2]],
),
"t [s]",
"rot [rad]",
"Rot Z",
labels=["gt", "set"])
plotter.plot((
[timestamps, gt_gravities[:, 0]],
[timestamps, est_gravities[:, 0]],
),
"t [s]",
"accel [m/s^2]",
"Gravity X",
labels=["gt", "est"])
plotter.plot((
[timestamps, gt_gravities[:, 1]],
[timestamps, est_gravities[:, 1]],
),
"t [s]",
"accel [m/s^2]",
"Gravity Y",
labels=["gt", "est"])
plotter.plot((
[timestamps, gt_gravities[:, 2]],
[timestamps, est_gravities[:, 2]],
),
"t [s]",
"accel [m/s^2]",
"Gravity Z",
labels=["gt", "est"])
plotter.plot(([timestamps, est_bw[:, 0]], ), "t [s]", "w [rad/s]",
"Gyro Bias X")
plotter.plot(([timestamps, est_bw[:, 1]], ), "t [s]", "w [rad/s]",
"Gyro Bias Y")
plotter.plot(([timestamps, est_bw[:, 2]], ), "t [s]", "w [rad/s]",
"Gyro Bias Z")
plotter.plot(([timestamps, est_ba[:, 0]], ), "t [s]", "a [m/s^2]",
"Accel Bias X")
plotter.plot(([timestamps, est_ba[:, 1]], ), "t [s]", "a [m/s^2]",
"Accel Bias Y")
plotter.plot(([timestamps, est_ba[:, 2]], ), "t [s]", "a [m/s^2]",
"Accel Bias Z")
vanilla_traj_aligned = trajectory.align_trajectory(vanilla_traj_synced,
gt_traj_synced_vanilla,
correct_scale=False,
correct_only_scale=False)
vision_only_traj_aligned = trajectory.align_trajectory(
vision_only_traj_synced,
gt_traj_synced_vision_only,
correct_scale=False,
correct_only_scale=False)
vins_mono_traj_aligned = trajectory.align_trajectory(vins_mono_traj_synced,
gt_traj_synced_vins_mono,
correct_scale=False,
correct_only_scale=False)
plotter = Plotter(os.path.join(base_dir, "KITTI_figures"))
def plot_callback(fig, ax):
pass
# ax.plot(gt_poses[0, 0, 3], gt_poses[0, 1, 3], 'x', color='black', markersize=10, markeredgewidth=2, label="start")
# ax.plot()
# ax.legend(numpoints=1, prop={'size': 8})
#K07
# ax.arrow(75, 195, -20, -20, head_width=5, head_length=5, fc='r', ec='r')
# circle = plt.Circle((45, 170), 20, color='r', fill=False, linestyle="--")
# ax.add_artist(circle)
#
# plot_margin = 25
# x0, x1, y0, y1 = ax.axis()
