def fun_with_precalculated_sift_reduce_rot(x0, numPlane, img1, xys1, normals1,
img2, xys2, normals2, init_R,
weight):
assert numPlane == len(xys1)
assert numPlane == len(xys2)
assert numPlane == len(normals1)
assert numPlane == len(normals2)
R = vec6dToSo3(x0[:6])
T = np.array(x0[6:9])
offsets1 = x0[9:9 + numPlane].reshape(-1, 1)
offsets2 = x0[9 + numPlane:9 + 2 * numPlane].reshape(-1, 1)
planes1_suncg = offsets1 * normals1
planes2_suncg = offsets2 * normals2
planes1_habitat = (planes1_suncg * np.array([1.0, -1.0, -1.0])).T
planes2_habitat = (planes2_suncg * np.array([1.0, -1.0, -1.0])).T
err_plane = huber(
weight["huber_delta"],
np.linalg.norm(project(R, T, planes1_habitat) - planes2_habitat,
axis=0),
).sum()
err_pixel = get_pixel_error_precalculated_sift(img1, xys1, planes1_suncg,
img2, xys2, planes2_suncg,
R, T)
change_R = angle_error_mat(R, init_R)
err = err_plane + err_pixel + change_R * weight["lambda_R"]
# err = huber(0.01, np.linalg.norm(project(R, T, x1) - x2, axis=0)).sum() + lambda_R * huber(1, change_R) #+ huber(1, change_T)
return err
def score(self, X_val, y_val, sample_weights='None'):
'''
This returns the huber loss of our validation
'''
if isinstance(sample_weights, str):
sample_weights = np.ones(y_val.shape[0])
sample_weights *= (1.0 / sample_weights.shape[0])
res = self.predict(X_val) - y_val
return np.dot(sample_weights, huber(self.eps, res) * 2.0 * self.eps)
def _print_metric(self, progress, loss_trace, targ_trace):
sigdig = 3
Y_flat = [y for batch in self._Y for y in batch]
if self._continuous:
resid_mean = np.mean(loss_trace)
if self._regression_type == "linear":
targ_var = np.mean(
np.square(np.array(targ_trace) - np.mean(Y_flat)))
r2 = 1. - (resid_mean / targ_var)
print(progress + "%" + '\t\t residual variance:\t',
np.round(resid_mean, sigdig),
'\n', ' \t\t total variance:\t',
np.round(targ_var, sigdig), '\n', ' \t\t r-squared:\t\t',
np.round(r2, sigdig), '\n')
elif self._regression_type == "robust":
ae = np.abs(targ_trace - np.median(Y_flat))
mae = np.mean(ae)
pmae = 1. - (resid_mean / mae)
print(progress + "%" + '\t\t residual absolute error:\t',
np.round(resid_mean, sigdig),
'\n', ' \t\t total absolute error:\t\t',
np.round(mae, sigdig), '\n',
' \t\t proportion absolute error:\t',
np.round(pmae, sigdig), '\n')
elif self._regression_type == "robust_smooth":
ae = huber(1., targ_trace - np.median(Y_flat))
mae = np.mean(ae)
pmae = 1. - (resid_mean / mae)
print(progress + "%" + '\t\t residual absolute error:\t',
np.round(resid_mean, sigdig),
'\n', ' \t\t total absolute error:\t\t',
np.round(mae, sigdig), '\n',
' \t\t proportion absolute error:\t',
np.round(pmae, sigdig), '\n')
else:
model_mean_neglogprob = np.mean(loss_trace)
targ_mean_neglogprob = -np.mean(
[self._Y_logprob[x] for x in targ_trace])
pnlp = 1. - (model_mean_neglogprob / targ_mean_neglogprob)
print(progress + "%" + '\t\t residual mean cross entropy:\t',
np.round(model_mean_neglogprob,
sigdig), '\n', ' \t\t total mean cross entropy:\t',
np.round(targ_mean_neglogprob, sigdig), '\n',
' \t\t proportion entropy explained:\t',
np.round(pnlp, sigdig), '\n')
def _print_metric(self, progress, loss_trace, targ_trace):
sigdig = 3
Y_flat = [y for batch in self._Y for y in batch]
if self._continuous:
resid_mean = np.mean(loss_trace)
if self._regression_type == "linear":
targ_var = np.mean(np.square(np.array(targ_trace) - np.mean(Y_flat)))
r2 = 1. - (resid_mean / targ_var)
print(progress + "%" + '\t\t residual variance:\t', np.round(resid_mean, sigdig), '\n',
' \t\t total variance:\t', np.round(targ_var, sigdig), '\n',
' \t\t r-squared:\t\t', np.round(r2, sigdig), '\n')
elif self._regression_type == "robust":
ae = np.abs(targ_trace - np.median(Y_flat))
mae = np.mean(ae)
pmae = 1. - (resid_mean / mae)
print(progress + "%" + '\t\t residual absolute error:\t', np.round(resid_mean, sigdig), '\n',
' \t\t total absolute error:\t\t', np.round(mae, sigdig), '\n',
' \t\t proportion absolute error:\t', np.round(pmae, sigdig), '\n')
elif self._regression_type == "robust_smooth":
ae = huber(1., targ_trace - np.median(Y_flat))
mae = np.mean(ae)
pmae = 1. - (resid_mean / mae)
print(progress + "%" + '\t\t residual absolute error:\t', np.round(resid_mean, sigdig), '\n',
' \t\t total absolute error:\t\t', np.round(mae, sigdig), '\n',
' \t\t proportion absolute error:\t', np.round(pmae, sigdig), '\n')
else:
model_mean_neglogprob = np.mean(loss_trace)
targ_mean_neglogprob = -np.mean([self._Y_logprob[x] for x in targ_trace])
pnlp = 1. - (model_mean_neglogprob / targ_mean_neglogprob)
print(progress + "%" + '\t\t residual mean cross entropy:\t', np.round(model_mean_neglogprob, sigdig), '\n',
' \t\t total mean cross entropy:\t', np.round(targ_mean_neglogprob, sigdig), '\n',
' \t\t proportion entropy explained:\t', np.round(pnlp, sigdig), '\n')
def tri_distance(pnts, triangles, all_vols, all_angles, omega=0.2):
"""calculates the area of all the triangles in the Delaunay triangulation."""
vols = []
for triangle in triangles:
points = [pnts[triangle[i]] for i in range(3)]
vec1 = points[1] - points[0]
vec2 = points[2] - points[0]
vec3 = points[2] - points[1]
angles = np.array(
[angle(vec1, vec2),
angle(vec3, -vec1),
angle(-vec2, -vec3)])
angle_loss = np.mean(huber(1, (angles - 1.047) / 0.864))
all_angles.append(angle_loss)
# Use log because the distribution is right skewed
normalized_vol = (np.log(volume(vec1, vec2)) + 3.40) / 0.62
vols.append(omega * normalized_vol**2 + (1.0 - omega) * angle_loss)
all_vols.append(normalized_vol)
return np.mean(vols)
def huber_norm(delta, x):
return (huber(delta, x) / delta).sum()
def _huber_loss_function(self, param, y, weights=None, huber_delta=None):
if weights is None:
weights = 1.0
if huber_delta is None:
huber_delta = 1.0
return huber(huber_delta, weights * self._errfunc(param, y)).sum()
def huberLoss(outputs, labels):
delta = 1
r = np.abs(outputs - labels)
loss = huber(delta, r)
return loss
def learn(self,
total_timesteps,
callback=None,
seed=None,
log_interval=100,
tb_log_name="DQN"):
with SetVerbosity(self.verbose), TensorboardWriter(
self.graph, self.tensorboard_log, tb_log_name) as writer:
self._setup_learn(seed)
# Create the replay buffer
if self.prioritized_replay:
self.replay_buffer = SimplePrioritizedReplayBuffer(
self.buffer_size, alpha=self.prioritized_replay_alpha)
if self.prioritized_replay_beta_iters is None:
prioritized_replay_beta_iters = total_timesteps * self.beta_fraction
self.beta_schedule = LinearSchedule(
prioritized_replay_beta_iters,
initial_p=self.prioritized_replay_beta0,
final_p=1.0)
else:
# self.replay_buffer = ReplayBuffer(self.buffer_size, gamma=self.gamma, hindsight=self.hindsight, multistep=self.multistep)
self.replay_buffer = EpisodeReplayBuffer(
self.buffer_size, hindsight=self.hindsight)
self.solved_replay_buffer = EpisodeReplayBuffer(
self.buffer_size, hindsight=self.hindsight)
# self.replay_buffer = SimpleReplayBuffer(self.buffer_size)
self.beta_schedule = None
# Create the schedule for exploration starting from 1.
self.exploration = LinearSchedule(
schedule_timesteps=int(self.exploration_fraction *
total_timesteps),
initial_p=1.0,
final_p=self.exploration_final_eps)
episode_rewards = [0.0]
episode_trans = []
episode_replays = []
episode_success = [0] * log_interval
episode_finals = [0] * log_interval
episode_losses = []
is_in_loop = False
loss_accumulator = [0.] * 50
episode_places = set()
episode_div = [0] * log_interval
full_obs = self.env.reset()
part_obs = np.concatenate(
(full_obs['observation'], full_obs['desired_goal']), axis=-1)
begin_obs = [full_obs] * log_interval
reset = True
self.episode_reward = np.zeros((1, ))
for step in range(total_timesteps):
# self.steps_made += 1
# if step >= 7 * 100 * 150:
# raise Exception("trigger")
# curriculum
# curriculum_scrambles = 1 + int(self.steps_made ** (0.50)) // 500
# curriculum_step_limit = min((curriculum_scrambles + 2) * 2, 100)
# self.replay_buffer.set_sampling_cut(curriculum_step_limit)
# self.env.scrambleSize = curriculum_scrambles
# self.env.step_limit = curriculum_step_limit
# Take action and update exploration to the newest value
kwargs = {}
if not self.param_noise:
update_eps = self.exploration.value(step)
update_param_noise_threshold = 0.
else:
update_eps = 0.
# Compute the threshold such that the KL divergence between perturbed and non-perturbed
# policy is comparable to eps-greedy exploration with eps = exploration.value(t).
# See Appendix C.1 in Parameter Space Noise for Exploration, Plappert et al., 2017
# for detailed explanation.
update_param_noise_threshold = \
-np.log(1. - self.exploration.value(step) +
self.exploration.value(step) / float(self.env.action_space.n))
kwargs['reset'] = reset
kwargs[
'update_param_noise_threshold'] = update_param_noise_threshold
kwargs['update_param_noise_scale'] = True
with self.sess.as_default():
# Loop breaking
if self.loop_breaking and is_in_loop:
# update_eps_value = (update_eps + 1.) / 2.
update_eps_value = 1.
else:
update_eps_value = update_eps
if self.boltzmann:
values = self.predict_q_values(np.array(part_obs))[0]
exp = 1. / update_eps_value
action = np.random.choice(
np.arange(0, values.shape[0]),
p=(exp**values) / sum(exp**values))
else:
action = self.act(np.array(part_obs)[None],
update_eps=update_eps_value,
**kwargs)[0]
# action = self.env.action_space.sample()
env_action = action
reset = False
new_obs, rew, done, _ = self.env.step(env_action)
current_place = None
is_in_loop = False
try:
current_place = tuple(self.env.room_state.flatten())
except AttributeError:
current_place = tuple(new_obs['observation'].flatten())
if current_place in episode_places:
is_in_loop = True
episode_places.add(current_place)
# Store transition in the replay buffer.
# self.replay_buffer.add(part_obs, action, rew, np.concatenate((new_obs['observation'], new_obs['desired_goal'])), float(done))
episode_replays.append(
(full_obs, action, rew, new_obs, float(done)))
episode_trans.append((full_obs, action, rew, new_obs))
full_obs = new_obs
part_obs = np.concatenate(
(full_obs['observation'], full_obs['desired_goal']),
axis=-1)
if writer is not None:
ep_rew = np.array([rew]).reshape((1, -1))
ep_done = np.array([done]).reshape((1, -1))
self.episode_reward = total_episode_reward_logger(
self.episode_reward, ep_rew, ep_done, writer, step)
episode_rewards[-1] += rew
if done:
if np.array_equal(full_obs['achieved_goal'],
full_obs['desired_goal']):
episode_success.append(1.)
self.solved_episodes.append(episode_replays)
else:
episode_success.append(0.)
episode_success = episode_success[1:]
episode_div.append(len(episode_places))
episode_div = episode_div[1:]
self.episodes_completed += 1
if self.model_save_freq > 0 and self.episodes_completed % self.model_save_freq == 0:
self.save_model_checkpoint()
if self.episodes_completed % (200 * 100) == 0:
self.dump_solved_episodes()
if not isinstance(self.env, VecEnv):
full_obs = self.env.reset()
# print(full_obs)
part_obs = np.concatenate((full_obs['observation'],
full_obs['desired_goal']),
axis=-1)
def postprocess_replays(raw_replays, buffer,
prioritized_replay):
if not prioritized_replay:
buffer.add(raw_replays)
return
for _ in range(10):
for id, (full_obs, action, rew, new_obs,
done) in enumerate(raw_replays):
offset = np.random.randint(
id, len(raw_replays))
target = raw_replays[offset][3][
'achieved_goal']
obs = np.concatenate(
[full_obs['observation'], target], axis=-1)
step = np.concatenate(
[new_obs['observation'], target], axis=-1)
if np.array_equal(new_obs['achieved_goal'],
target):
rew = 0.
done = 1.
else:
rew = -1.
done = 0.
buffer.add(obs, action, rew, step, done)
postprocess_replays(episode_replays, self.replay_buffer,
self.prioritized_replay)
begin_obs.append(full_obs)
begin_obs = begin_obs[1:]
if callback is not None:
callback(locals(), globals())
episode_rewards.append(0.0)
episode_trans = []
episode_replays = []
episode_places = set()
episode_losses = []
reset = True
is_in_loop = False
if step > self.learning_starts and step % self.train_freq == 0:
# Minimize the error in Bellman's equation on a batch sampled from replay buffer.
if self.prioritized_replay:
experience = self.replay_buffer.sample(
self.batch_size,
beta=self.beta_schedule.value(step))
(obses_t, actions, rewards, obses_tp1, dones, weights,
batch_idxes) = experience
weights /= np.mean(weights)
else:
if np.random.randint(0, 100) < 100: # always
obses_t, actions, rewards, obses_tp1, dones, info = self.replay_buffer.sample(
self.batch_size)
else:
obses_t, actions, rewards, obses_tp1, dones, info = self.solved_replay_buffer.sample(
self.batch_size)
weights, batch_idxes = np.ones_like(rewards), None
if writer is not None:
# run loss backprop with summary, but once every 100 steps save the metadata
# (memory, compute time, ...)
if (1 + step) % 100 == 0:
run_options = tf.RunOptions(
trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, td_errors = self._train_step(
obses_t,
actions,
rewards,
obses_tp1,
obses_tp1,
dones,
weights,
sess=self.sess,
options=run_options,
run_metadata=run_metadata)
writer.add_run_metadata(run_metadata,
'step%d' % step)
else:
summary, td_errors = self._train_step(
obses_t,
actions,
rewards,
obses_tp1,
obses_tp1,
dones,
weights,
sess=self.sess)
writer.add_summary(summary, step)
else:
_, td_errors = self._train_step(obses_t,
actions,
rewards,
obses_tp1,
obses_tp1,
dones,
weights,
sess=self.sess)
if not self.prioritized_replay:
for (dist, error) in zip(info, td_errors):
if len(loss_accumulator) < dist + 1:
loss_accumulator += [0.] * (
dist + 1 - len(loss_accumulator))
loss_accumulator[
dist] = loss_accumulator[dist] * 0.99 + huber(
1., error)
# if step % 1000 == 0:
# print('accumulator', [int(x) for x in loss_accumulator])
# weights_sum = sum(loss_accumulator)
# print('normalized ', ['%.2f' % (x / weights_sum) for x in loss_accumulator])
# print('distance ', info)
loss = np.mean(
np.dot(weights,
[huber(1., error) for error in td_errors]))
episode_losses.append(loss)
if self.prioritized_replay:
new_priorities = np.abs(
td_errors) + self.prioritized_replay_eps
self.replay_buffer.update_priorities(
batch_idxes, new_priorities)
if step > self.learning_starts and step % self.target_network_update_freq == 0:
# Update target network periodically.
self.update_target(sess=self.sess)
if len(episode_rewards[-(log_interval + 1):-1]) == 0:
mean_100ep_reward = -np.inf
else:
mean_100ep_reward = round(
float(np.mean(
episode_rewards[-(log_interval + 1):-1])), 1)
num_episodes = len(episode_rewards)
if self.verbose >= 1 and done and log_interval is not None and len(
episode_rewards) % log_interval == 0:
logger.record_tabular("steps", step)
logger.record_tabular("episodes", num_episodes)
logger.record_tabular(
"mean {0} episode reward".format(log_interval),
mean_100ep_reward)
logger.record_tabular(
"{0} episode success".format(log_interval),
np.mean(episode_success))
logger.record_tabular(
"% time spent exploring",
int(100 * self.exploration.value(step)))
logger.dump_tabular()
return self
def eval_model(self, dataset, vid, pairWise):
self.nn.model = self.nn.model.eval()
num_img_pair = dataset.get_num_images(vid)
quads = []
iou_list = []
sobel_x = []
sobel_y = []
imgs = []
in_video = dataset.get_in_video_path(vid)
out_video = dataset.get_out_video_path(vid)
info = self.nn.model.params.info
imgs_out_dir = join(out_video, "img_tcr")
model_out_dir = join(out_video, info)
make_dir(imgs_out_dir)
make_dir(model_out_dir)
print("Evaluating dataset for video ", vid)
data_x, quad_gt = dataset.get_data_point(vid, 0)
quads.append(data_x[2])
# data_x[0] = data_x[0][np.newaxis, :, :, :]
# bbox = data_x[2][np.newaxis, :]
# self.nn.init(data_x[0], bbox)
self.nn.cnt = 0
start_t = time.time()
loss = 0
sz_loss = 0
with torch.no_grad():
for img_pair in range(num_img_pair):
# print(img_pair)
data_x, quad_gt = dataset.get_data_point(vid, img_pair)
_, quad_pip_gt = dataset.get_train_data_point(vid, img_pair)
data_x[0] = data_x[0][np.newaxis, :, :, :]
bbox = data_x[2][np.newaxis, :]
data_x[1] = data_x[1][np.newaxis, :, :, :]
if(img_pair == 0 and not pairWise):
quad = bbox
self.nn.init(data_x[0], quad)
elif(pairWise):
quad = bbox
self.nn.init(data_x[0], quad)
# else:
# try:
outputs = self.nn.track(data_x[1])
# except:
# print("Error!!!!!!")
# break
if(len(outputs) == 9):
quad_new, sx, sy, img_pip_tcr, sx_ker, \
sy_ker, img_pip_i, quad_pip, scale_z = outputs
sx_ker = tensor_to_numpy(sx_ker[0])
sy_ker = tensor_to_numpy(sy_ker[0])
np.save(join(model_out_dir, str(img_pair) + "-sx.npy"),\
sx_ker)
np.save(join(model_out_dir, str(img_pair) + "-sy.npy"),\
sy_ker)
elif(len(outputs) == 7):
quad_new, sx, sy, img_pip_tcr, img_pip_i,\
quad_pip, scale_z = outputs
# print(quad_pip, quad_pip_gt)
sz_loss += huber(100, quad_pip - quad_pip_gt).mean()
loss += (scale_z[0]) * (scale_z[0]) * huber(100, quad_new - quad_gt).mean()
# from IPython import embed;embed()
# print(img_pair, quad.shape, quad_new.shape)
img_pip_tcr = img_to_numpy(img_pip_tcr[0])
# img_i = img_to_numpy(img_i[0])
# cv2.imwrite(join(imgs_out_dir,\
# str(img_pair) +"_i.jpeg"), data_x[1][0, :, :, :])
# np.save(join(imgs_out_dir, str(img_pair) + "-quad-gt.npy"),\
# quad_gt)
# print(img_pip_tcr.shape)
# cv2.imwrite(join(model_out_dir,\
# str(img_pair) +"_pip_tcr.jpeg"), img_pip_tcr)
# cv2.imwrite(join(model_out_dir,\
# str(img_pair) +"_pip_i.jpeg"), img_pip_i)
# np.save(join(model_out_dir, str(img_pair) + "_quad_pip.npy"),\
# quad_pip[-1][0, :])
# np.save(join(model_out_dir, str(img_pair) + "_quad_pip_id.npy"),\
# quad_pip[0][0, :])
# np.save(join(model_out_dir, str(img_pair) + "_quad_pip_gt.npy"),\
# quad_pip_gt)
# np.save(join(model_out_dir, str(img_pair) + "_quad.npy"),\
# quad_new[-1][0, :])
# np.save(join(model_out_dir, str(img_pair) + "_quad_id.npy"),\
# quad_new[0][0, :])
# np.save(join(model_out_dir, str(img_pair) + "_quad_gt.npy"),\
# quad_gt)
# for j in range(len(quad_new)):
# resize_path = join(model_out_dir, str(img_pair) + "-resized")
# dir_path = join(model_out_dir, str(img_pair))
# make_dir(dir_path)
# make_dir(resize_path)
# np.save(join(resize_path, str(j) + "-quad-resized.npy"), quad_uns[j][0, :])
# np.save(join(dir_path, str(j) + "-quad.npy"), quad_new[j][0, :])
# sx = img_to_numpy(sx[0])
# sy = img_to_numpy(sy[0])
# for i in range(3):
# cv2.imwrite(join(model_out_dir,\
# str(img_pair) + "-sx-" + str(i) +".jpeg"), sx[:, :, i])
# cv2.imwrite(join(model_out_dir,\
# str(img_pair) + "-sy-" + str(i) +".jpeg"), sy[:, :, i])
try:
iou = calc_iou(quad_new[0], quad_gt)
iou_list.append(iou)
except Exception as e:
print(e)
break
quads.append(quad_new[0])
quad = quad_new
end_t = time.time()
loss /= num_img_pair
sz_loss /= num_img_pair
mean_iou = np.sum(iou_list) / num_img_pair
write_to_output_file(quads, out_video + "/results.txt")
outputBboxes(in_video +"/", out_video + "/images/", out_video + "/results.txt")
print("Resized loss = ", sz_loss)
print("Actual loss = ", loss)
print("Total time taken = ", end_t - start_t)
print("Mean IOU = ", mean_iou)
# plt.plot(iou_list)
# plt.savefig(out_video + "/iou_plot.png")
# plt.close()
return mean_iou
def huber_loss(a, b):
r = a - b
delta = 1.0
return np.sum(huber(delta, r), axis=-1)
def learning_step(self, step, replay_buffer, writer, episode_losses):
if step > self.learning_starts and step % self.train_freq == 0:
# Minimize the error in Bellman's equation on a batch sampled from replay buffer.
if self.prioritized_replay:
experience = replay_buffer.sample(
self.batch_size, beta=self.beta_schedule.value(step))
(obses_t, actions, rewards, obses_tp1, dones, weights,
batch_idxes) = experience
else:
obses_t, actions, rewards, obses_tp1, dones = replay_buffer.sample(
self.batch_size)
weights, batch_idxes = np.ones_like(rewards), None
if writer is not None:
# run loss backprop with summary, but once every 100 steps save the metadata
# (memory, compute time, ...)
if (1 + step) % 100 == 0:
run_options = tf.RunOptions(
trace_level=tf.RunOptions.FULL_TRACE)
run_metadata = tf.RunMetadata()
summary, td_errors = self._train_step(
obses_t,
actions,
rewards,
obses_tp1,
obses_tp1,
dones,
weights,
sess=self.sess,
options=run_options,
run_metadata=run_metadata)
writer.add_run_metadata(run_metadata, 'step%d' % step)
else:
summary, td_errors = self._train_step(obses_t,
actions,
rewards,
obses_tp1,
obses_tp1,
dones,
weights,
sess=self.sess)
writer.add_summary(summary, step)
else:
_, td_errors = self._train_step(obses_t,
actions,
rewards,
obses_tp1,
obses_tp1,
dones,
weights,
sess=self.sess)
loss = np.mean(
np.dot(weights, [huber(1., error) for error in td_errors]))
episode_losses.append(loss)
if self.prioritized_replay:
new_priorities = np.abs(
td_errors) + self.prioritized_replay_eps
replay_buffer.update_priorities(batch_idxes, new_priorities)
if step > self.learning_starts and step % self.target_network_update_freq == 0:
# Update target network periodically.
self.update_target(sess=self.sess)
