def main():
parser = argparse.ArgumentParser()
parser.add_argument('--save_dir', type=str, default='./models', help='directory to store checkpointed models')
parser.add_argument('--val_frac', type=float, default=0.1, help='fraction of data to be witheld in validation set')
parser.add_argument('--ckpt_name', type= str, default='', help='name of checkpoint file to load (blank means none)')
parser.add_argument('--batch_size', type=int, default= 64, help='minibatch size')
parser.add_argument('--state_dim', type=int, default= 51, help='number of state variables')
parser.add_argument('--num_classes', type=int, default= 4, help='number of driver classes')
parser.add_argument('--action_dim', type=int, default= 2, help='number of action variables')
parser.add_argument('--num_epochs', type=int, default= 50, help='number of epochs')
parser.add_argument('--learning_rate', type=float, default= 0.004, help='learning rate')
parser.add_argument('--decay_rate', type=float, default= 0.5, help='decay rate for learning rate')
parser.add_argument('--grad_clip', type=float, default= 5.0, help='clip gradients at this value')
parser.add_argument('--save_h5', type=bool, default= False, help='Whether to save network params to h5 file')
parser.add_argument('--seq_length', type=int, default=50, help='Sequence length for training')
parser.add_argument('--burn_in_length', type=int, default=10, help='Amount of time steps for initializing LSTM internal state')
############################
# Policy Network #
############################
parser.add_argument('--policy_size', type=int, default= 128, help='number of neurons in each layer')
parser.add_argument('--num_policy_layers', type=int, default= 2, help='number of layers in the policy network')
parser.add_argument('--recurrent', type=bool, default= False, help='whether to use recurrent policy')
parser.add_argument('--oracle', type=bool, default= False, help='whether to include class as input to policy')
parser.add_argument('--dropout_level', type=float, default= 1.0, help='dropout applied to fc policy')
args = parser.parse_args()
# Construct model
net = bc_policy.BCPolicy(args)
# Export model parameters or perform training
if args.save_h5:
data_loader = DataLoader(args.batch_size, args.val_frac, args.seq_length + args.burn_in_length, args.oracle)
save_h5(args, net, data_loader)
else:
train(args, net)
env.close()
exit(1)
### use the GT vision
rgb, depth, seg, obj_seg = cam.get_observation()
Image.fromarray(
(rgb * 255).astype(np.uint8)).save(os.path.join(out_dir, 'rgb.png'))
pickle.dump(seg, open(os.path.join(out_dir, 'seg.pkl'), "wb"))
pickle.dump(obj_seg, open(os.path.join(out_dir, 'obj_seg.pkl'), "wb"))
cam_XYZA_id1, cam_XYZA_id2, cam_XYZA_pts = cam.compute_camera_XYZA(depth)
cam_XYZA = cam.compute_XYZA_matrix(cam_XYZA_id1, cam_XYZA_id2, cam_XYZA_pts,
depth.shape[0], depth.shape[1])
save_h5(os.path.join(out_dir, 'cam_XYZA.h5'), \
[(cam_XYZA_id1.astype(np.uint64), 'id1', 'uint64'), \
(cam_XYZA_id2.astype(np.uint64), 'id2', 'uint64'), \
(cam_XYZA_pts.astype(np.float32), 'pc', 'float32'), \
])
gt_nor = cam.get_normal_map()
Image.fromarray(((gt_nor + 1) / 2 * 255).astype(np.uint8)).save(
os.path.join(out_dir, 'gt_nor.png'))
object_link_ids = env.movable_link_ids
gt_movable_link_mask = cam.get_movable_link_mask(object_link_ids)
Image.fromarray((gt_movable_link_mask > 0).astype(np.uint8) * 255).save(
os.path.join(out_dir, 'interaction_mask.png'))
# sample a pixel to interact
xs, ys = np.where(gt_movable_link_mask > 0)
if len(xs) == 0:
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--save_dir',
type=str,
default='./models',
help='directory to store checkpointed models')
parser.add_argument(
'--val_frac',
type=float,
default=0.1,
help='fraction of data to be witheld in validation set')
parser.add_argument(
'--ckpt_name',
type=str,
default='',
help='name of checkpoint file to load (blank means none)')
parser.add_argument('--batch_size',
type=int,
default=64,
help='minibatch size')
parser.add_argument('--state_dim',
type=int,
default=51,
help='number of state variables')
parser.add_argument('--action_dim',
type=int,
default=2,
help='number of action variables')
parser.add_argument('--z_dim',
type=int,
default=2,
help='dimensions of latent variable')
parser.add_argument('--sample_size',
type=int,
default=10,
help='number of samples from z')
parser.add_argument('--num_epochs',
type=int,
default=50,
help='number of epochs')
parser.add_argument('--learning_rate',
type=float,
default=0.004,
help='learning rate')
parser.add_argument('--decay_rate',
type=float,
default=0.5,
help='decay rate for learning rate')
parser.add_argument('--grad_clip',
type=float,
default=5.0,
help='clip gradients at this value')
parser.add_argument('--save_h5',
type=bool,
default=False,
help='Whether to save network params to h5 file')
###############################
# Encoder #
###############################
parser.add_argument('--encoder_size',
type=int,
default=128,
help='number of neurons in each LSTM layer')
parser.add_argument('--num_encoder_layers',
type=int,
default=2,
help='number of layers in the LSTM')
parser.add_argument('--seq_length',
type=int,
default=50,
help='LSTM sequence length')
############################
# Policy Network #
############################
parser.add_argument('--policy_size',
type=int,
default=128,
help='number of neurons in each feedforward layer')
parser.add_argument('--num_policy_layers',
type=int,
default=2,
help='number of layers in the policy network')
parser.add_argument('--recurrent',
type=bool,
default=False,
help='whether to use recurrent policy')
parser.add_argument('--dropout_level',
type=float,
default=1.0,
help='percent of state values to keep')
############################
# Reconstructor #
############################
parser.add_argument('--rec_size',
type=int,
default=64,
help='number of neurons in each feedforward layer')
parser.add_argument('--num_rec_layers',
type=int,
default=2,
help='number of layers in the policy network')
parser.add_argument('--rec_weight',
type=float,
default=0.03,
help='weight applied to reconstruction cost')
args = parser.parse_args()
# Construct model
net = vae.VariationalAutoencoder(args)
# Export model parameters or perform training
if args.save_h5:
data_loader = DataLoader(args.batch_size, args.val_frac,
args.seq_length)
save_h5(args, net, data_loader)
else:
train(args, net)
]
# Deal with batches size 1
if len(oris) == 1:
img_keypoints[0] = img_keypoints[0].unsqueeze(0)
img_keypoints[1] = img_keypoints[1].unsqueeze(0)
img_keypoints[2] = img_keypoints[2].unsqueeze(0)
descriptors, patches = model({key: imgs}, img_keypoints,
[key] * len(img_keypoints[0]))
all_desc.append(descriptors.data.cpu().numpy())
seq_descriptors[key] = np.vstack(np.array(all_desc)).astype(
np.float32)
cur_path = os.path.join(args.save_path, args.method_name, seq_name)
if not os.path.exists(cur_path):
os.makedirs(cur_path)
save_h5(seq_descriptors, os.path.join(cur_path, 'descriptors.h5'))
sub_files_in = [
'keypoints{}.h5'.format(suffix), 'scales{}.h5'.format(suffix),
'angles{}.h5'.format(suffix), 'scores{}.h5'.format(suffix)
]
sub_files_out = ['keypoints.h5', 'scales.h5', 'angles.h5', 'scores.h5']
for sub_file_in, sub_file_out in zip(sub_files_in, sub_files_out):
shutil.copyfile(
os.path.join(args.dataset_path, seq_name, sub_file_in),
os.path.join(cur_path, sub_file_out))
print('Done sequence: {}'.format(seq_name))
adv[~mask3d] = np.nan
str[~mask3d] = np.nan
div[~mask3d] = np.nan
smb[~mask3d] = np.nan
melt = dHdt + div - smb
melt_steady = div - smb
mass = dHdt * RHO_ICE * 1e-12 # kg/yr -> Gt/yr
melt_mean = np.nanmean(melt, axis=2)
# NOTE: Change name of variables for new version
data = {
"dHdt_melt10": melt,
"dHdt_steady10": melt_steady,
"dMdt_net10": mass,
"dHdt_net10": dHdt,
"dHdt_melt_mean10": melt_mean,
"H_filt10": H,
"dHdt_adv_filt10": adv,
"dHdt_str_filt10": str,
"dHdt_div_filt10": div,
"smb_gemb_filt10": smb,
}
if SAVE:
save_h5(FCUBE, data, "a")
print("saved.")
plt.matshow(melt_mean, cmap="RdBu", vmin=-5, vmax=5)
plt.show()
num_patches.append(patches.shape[0])
scene_patches[img_name] = patches
scene_kp[img_name] = keypoints
scene_scale[img_name] = scales
sec_ori[img_name] = angles
sec_resp[img_name] = responses
print('Processed {} images: {} patches/image'.format(
len(num_patches),
np.array(num_patches).mean()))
cur_path = os.path.join(args.folder_outp, scene)
# if args.force_upright == 'no-dups':
# cur_path += '_upright_v1'
# elif args.force_upright == 'no-dups-more-points':
# cur_path += '_upright_v2'
if not os.path.isdir(cur_path):
os.makedirs(cur_path)
save_h5(scene_patches,
os.path.join(cur_path, 'patches{}.h5'.format(suffix)))
save_h5(scene_kp,
os.path.join(cur_path, 'keypoints{}.h5'.format(suffix)))
save_h5(scene_scale,
os.path.join(cur_path, 'scales{}.h5'.format(suffix)))
save_h5(sec_ori, os.path.join(cur_path, 'angles{}.h5'.format(suffix)))
save_h5(sec_resp, os.path.join(cur_path, 'scores{}.h5'.format(suffix)))
print('Done!')
err_div = 2 * np.abs(H) * err_u / dx
err_melt = np.sqrt(err_dHdt ** 2 + err_div ** 2 + ds.err_smb ** 2)
# Save
if 0:
FILE_SAVE = "/Users/fspaolo/work/melt/data/FULL_CUBE_v4.h5"
save_h5(
FILE_SAVE,
{
"dh_err10": err_dh,
"H_err10": err_H,
"dHdt_net_err10": err_dHdt,
"dHdt_div_err10": err_div,
"dHdt_melt_err10": err_melt,
},
) # not corrected for firn
print("saved ->", FILE_SAVE)
# Plot to double check
def plot_error(t, cube, error, indices, title="", detrend=False):
for k, (i, j) in enumerate(indices, start=1):
def make_emb_db(self,
args,
net,
data_loader,
eval_sampled,
eval_per_class,
newly_trained=True,
batch_size=None,
mode='val'):
"""
:param batch_size:
:param eval_sampled:
:param eval_per_class:
:param newly_trained:
:param mode:
:param args: utils args
:param net: trained top_model network
:param data_loader: DataLoader object
:return: None
"""
if newly_trained:
net.eval()
if batch_size is None:
batch_size = args.batch_size
steps = int(np.ceil(len(data_loader) / batch_size))
test_classes = np.zeros(((len(data_loader.dataset))))
test_seen = np.zeros(((len(data_loader.dataset))))
test_paths = np.empty(dtype='S20',
shape=((len(data_loader.dataset))))
if args.feat_extractor == 'resnet50':
test_feats = np.zeros((len(data_loader.dataset), 2048))
elif args.feat_extractor == 'resnet18':
test_feats = np.zeros((len(data_loader.dataset), 512))
else:
raise Exception('Not handled feature extractor')
for idx, (img, lbl, seen, path) in enumerate(data_loader):
if args.cuda:
img = img.cuda()
img = Variable(img)
output = net.forward(img, None, single=True)
output = output.data.cpu().numpy()
end = min((idx + 1) * batch_size, len(test_feats))
test_feats[idx * batch_size:end, :] = output
test_classes[idx * batch_size:end] = lbl
test_paths[idx * batch_size:end] = path
test_seen[idx * batch_size:end] = seen.to(int)
utils.save_h5(f'{mode}_ids', test_paths, 'S20',
os.path.join(self.save_path, f'{mode}Ids.h5'))
utils.save_h5(f'{mode}_classes', test_classes, 'i8',
os.path.join(self.save_path, f'{mode}Classes.h5'))
utils.save_h5(f'{mode}_feats', test_feats, 'f',
os.path.join(self.save_path, f'{mode}Feats.h5'))
utils.save_h5(f'{mode}_seen', test_seen, 'i2',
os.path.join(self.save_path, f'{mode}Seen.h5'))
test_feats = utils.load_h5(
f'{mode}_feats', os.path.join(self.save_path, f'{mode}Feats.h5'))
test_classes = utils.load_h5(
f'{mode}_classes', os.path.join(self.save_path,
f'{mode}Classes.h5'))
test_seen = utils.load_h5(
f'{mode}_seen', os.path.join(self.save_path, f'{mode}Seen.h5'))
utils.calculate_k_at_n(args,
test_feats,
test_classes,
test_seen,
logger=self.logger,
limit=args.limit_samples,
run_number=args.number_of_runs,
save_path=self.save_path,
sampled=eval_sampled,
per_class=eval_per_class,
mode=mode)
self.logger.info('results at: ' + self.save_path)
# Sort the scores and subsample
indices = np.argsort(scores)[::-1]
if args.num_kp > 0:
top_k = indices[:args.num_kp]
else:
top_k = indices
# Flip coordinates: network provides [y, x]
seq_keypoints[key] = np.concatenate(
[keypoints[top_k, 1][..., None], keypoints[top_k, 0][..., None]],
axis=1)
seq_scales[key] = keypoints[top_k, 2]
seq_scores[key] = scores[top_k]
seq_descriptors[key] = descriptors[top_k, :]
# print('Processed "{}" in {:.02f} sec. Found {} features'.format(
# key, t_end - t_start, keypoints.shape[0]))
print('Average number of keypoints per image: {:.02f}'.format(
np.mean([v.shape[0] for v in seq_keypoints.values()])))
cur_path = os.path.join(args.save_path, args.method_name, seq)
if not os.path.exists(cur_path):
os.makedirs(cur_path)
save_h5(seq_descriptors, os.path.join(cur_path, 'descriptors.h5'))
save_h5(seq_keypoints, os.path.join(cur_path, 'keypoints.h5'))
save_h5(seq_scores, os.path.join(cur_path, 'scores.h5'))
save_h5(seq_scales, os.path.join(cur_path, 'scales.h5'))
print('Done')
def main():
# TODO: COMBINE CUBEDIV.PY AND CUBEDEM.PY?
"""
1. Reference all time series
2. Correc dh for dFAC
3. Correct dh for SLT
4. Compute h(t) time series: h_mean + dh(t)
5. Compute freeboard: H_freeb = h(t) - MSL
6. Compute thickness and draft
"""
print("loading ...")
x, y, t, dh, h_mean, fac, msl, slt = read_h5(
FILE_CUBE,
[x_var, y_var, t_var, dh_var, h_var, fac_var, msl_var, slt_var],
)
# TODO: Maybe do this from the beguining (in cubefilt2.py)?
# Mask out constant values (pole hole)
dhdt = np.apply_along_axis(np.gradient, 2, dh)
dh[dhdt == 0] = np.nan
# Generate time series of sea-level trend (2D -> 3D)
slt = slt[:, :, None] * (t - REF_TIME)
# --- Smooth and reference series --- #
if SMOOTH_WINDOW != 0:
print("smoothing ...")
dh = np.apply_along_axis(smooth_series, 2, dh)
fac = np.apply_along_axis(smooth_series, 2, fac)
print("referencing ...")
# Correct mean height CS2 for FAC (before referencing)
k_ref, = find_nearest(t, REF_TIME)
h_mean = h_mean - fac[:, :, k_ref]
# Reference all time series to a common epoch
dh = np.apply_along_axis(lambda y: y - y[k_ref], 2, dh)
fac = np.apply_along_axis(lambda y: y - y[k_ref], 2, fac)
if PLOT:
i_, j_ = test_ij_3km["PEAK_2"]
plt.figure()
plt.plot(t, dh[i_, j_, :], label="dh")
plt.plot(t, fac[i_, j_, :], label="fac")
plt.plot(t, slt[i_, j_, :], label="slt")
plt.legend()
plt.show()
plt.pcolormesh(fac[:, :, 10], cmap='RdBu', rasterized=True)
plt.plot([j_], [i_], 'or')
plt.show()
# Correct dh(t)
dh_cor = dh - fac - slt
# Compute time-evolving DEM (and correct for FAC)
h = h_mean[:, :, None] + dh_cor
if PLOT:
plt.figure()
plt.plot(t, dh[i_, j_, :], label="dh")
plt.plot(t, dh_cor[i_, j_, :], label="dh_cor")
plt.legend()
plt.figure()
plt.plot(t, h[i_, j_, :], label="h_mean + dh_cor 1")
plt.legend()
plt.show()
# h(t) -> Freeboard, Draft, Thickness
rho_ocean = 1028.0
rho_ice = 917.0
H_freeb = h - msl[:, :, None]
H_draft = H_freeb * ((rho_ocean / (rho_ocean - rho_ice)) - 1)
H = H_freeb * rho_ocean / (rho_ocean - rho_ice)
# if PLOT:
# plt.figure()
# plt.plot(t, H_freeb[i_, j_, :] / 1000.0)
# plt.plot(t, -H_draft[i_, j_, :] / 1000.0)
if SAVE:
data = {"h10": h, "H_freeb10": H_freeb, "H_draft10": H_draft, "H10": H}
save_h5(FILE_OUT, data, 'a')
print("saved.")