def main(_):
working_dir = os.path.dirname(os.path.abspath(__file__))
# print FLAGS
print("#--- FLAGS: ---#")
print("config: {}".format(FLAGS.config))
print("new_run: {}".format(FLAGS.new_run))
print("init_run_name: {}".format(FLAGS.init_run_name))
print("run_name: {}".format(FLAGS.run_name))
print("batch_size: {}".format(FLAGS.batch_size))
# load config file
config = run_utils.load_config(FLAGS.config)
# Check config setting coherences
assert len(config["level_loss_coefs_params"]) == config["pool_count"], \
"level_loss_coefs_params ({} elements) must have model_res_levels ({}) elements".format(
len(config["level_loss_coefs_params"]), config["pool_count"])
tfrecords_dirpath_list = [
os.path.join(working_dir, tfrecords_dirpath)
for tfrecords_dirpath in config["tfrecords_partial_dirpath_list"]
]
ds_repeat_list = config["ds_repeat_list"]
# setup init run directory of one is specified:
if FLAGS.init_run_name is not None:
init_run_dirpath = run_utils.setup_run_dir(config["runs_dirname"],
FLAGS.init_run_name)
else:
init_run_dirpath = None
# setup run directory:
runs_dir = os.path.join(working_dir, config["runs_dirname"])
current_run_dirpath = run_utils.setup_run_dir(runs_dir, FLAGS.run_name,
FLAGS.new_run)
# save config in logs directory
run_utils.save_config(config, current_run_dirpath)
# save FLAGS
FLAGS_filepath = os.path.join(current_run_dirpath, "FLAGS.json")
python_utils.save_json(
FLAGS_filepath, {
"run_name": FLAGS.run_name,
"new_run": FLAGS.new_run,
"batch_size": FLAGS.batch_size
})
train(config, tfrecords_dirpath_list, init_run_dirpath,
current_run_dirpath, FLAGS.batch_size, ds_repeat_list)
def aggregate_results(exp_dirpath, params, stats_params):
working_dir = os.path.dirname(os.path.abspath(__file__))
aggregated_data_names = [
"neighbors_soft",
"neighbors_soft_no_normalization",
"alpha",
"x",
"pred",
"gt",
"error",
"curvature",
"density",
"train_loss",
"val_loss",
"loss_ratio",
]
for neighbors_t in stats_params["neighbors_t"]:
aggregated_data_names.append("neighbors_hard_t_{}".format(neighbors_t))
for neighbors_n in stats_params["neighbors_n"]:
aggregated_data_names.append("neighbors_less_soft_n_{}".format(neighbors_n))
for n, f in itertools.product(params["sample_count"], params["frequency"]):
aggregated_data = {}
for run in range(params["run_count"]):
all_params = {
"run": run,
"sample_count": n,
"frequency": f,
"noise_std": params["noise_std"],
"distribution": params["distribution"],
}
run_name = get_run_name(all_params)
runs_dir = os.path.join(working_dir, exp_dirpath)
run_dirpath = run_utils.setup_run_dir(runs_dir, run_name, check_exists=True)
stats_dirpath = os.path.join(run_dirpath, "stats_1d")
for name in aggregated_data_names:
filepath = os.path.join(stats_dirpath, "{}.npy".format(name))
try:
data = np.load(filepath)
if name in aggregated_data:
aggregated_data[name].append(data)
else:
aggregated_data[name] = [data]
except FileNotFoundError:
pass
# print("File {} not found, skipping...".format(filepath))
for key, value in aggregated_data.items():
aggregated_data[key] = np.median(value, axis=0) # Average runs with the same params
# Save aggregated data
all_params = {
"sample_count": n,
"frequency": f,
"noise_std": params["noise_std"],
"distribution": params["distribution"],
}
exp_params = get_exp_params(all_params)
dataset_params_str = python_utils.params_to_str(exp_params)
filepath_format = os.path.join(exp_dirpath, "{}.{{}}.npy".format(dataset_params_str))
for key, value in aggregated_data.items():
np.save(filepath_format.format(key), aggregated_data[key])
def main(_):
# Print flags
print("#--- Flags: ---#")
print("new_run: {}".format(FLAGS.new_run))
print("init_run_name: {}".format(FLAGS.init_run_name))
print("run_name: {}".format(FLAGS.run_name))
print("batch_size: {}".format(FLAGS.batch_size))
print("ds_fac: {}".format(FLAGS.ds_fac))
if FLAGS.ds_fac is not None:
ds_fac_list = [FLAGS.ds_fac]
ds_repeat_list = [1]
else:
ds_fac_list = config.DS_FAC_LIST
ds_repeat_list = config.DS_REPEAT_LIST
# Setup init run directory of one is specified:
if FLAGS.init_run_name is not None:
init_run_dirpath = run_utils.setup_run_dir(config.RUNS_DIR,
FLAGS.init_run_name)
else:
init_run_dirpath = None
# Setup run directory:
current_run_dirpath = run_utils.setup_run_dir(config.RUNS_DIR,
FLAGS.run_name,
FLAGS.new_run)
# Save config.py in logs directory
run_utils.save_config(config.PROJECT_DIR, current_run_dirpath)
# Save flags
flags_filepath = os.path.join(current_run_dirpath, "flags.json")
python_utils.save_json(
flags_filepath, {
"run_name": FLAGS.run_name,
"new_run": FLAGS.new_run,
"batch_size": FLAGS.batch_size,
"ds_fac": FLAGS.ds_fac,
})
train(init_run_dirpath, current_run_dirpath, FLAGS.batch_size, ds_fac_list,
ds_repeat_list)
def compute_grads(config, run_params, dataset_params, split_name):
# print("# --- Compute grads --- #")
working_dir = os.path.dirname(os.path.abspath(__file__))
# Find data_dir
data_dirpath = python_utils.choose_first_existing_path(
config["data_dir_candidates"])
if data_dirpath is None:
print_utils.print_error("ERROR: Data directory not found!")
exit()
# print_utils.print_info("Using data from {}".format(data_dirpath))
root_dir = os.path.join(data_dirpath, config["data_root_partial_dirpath"])
# setup run directory:
runs_dir = os.path.join(working_dir, config["runs_dirpath"])
run_dirpath = None
try:
run_dirpath = run_utils.setup_run_dir(runs_dir, run_params["run_name"])
except ValueError:
print_utils.print_error(
"Run name {} was not found. Aborting...".format(
run_params["run_name"]))
exit()
# Choose device
dev = torch.device("cuda") if torch.cuda.is_available() else torch.device(
"cpu")
# Instantiate dataset
ds = Synthetic1DDataset(root_dir=root_dir,
params=dataset_params,
split_name=split_name,
transform=torchvision.transforms.Compose([
transforms.ToTensor(),
transforms.ToDevice(device=dev)
]))
dl = DataLoader(ds, batch_size=1)
model = Simple1DInputNet(config, run_params["capacity"])
model.to(dev)
analyzer = Analyzer(config, model, run_dirpath)
analyzer.compute_and_save_grads(dl)
def plot_stats(config, run_name, source_idx_list):
print("# --- Plot stats --- #")
working_dir = os.path.dirname(os.path.abspath(__file__))
# setup run directory:
runs_dir = os.path.join(working_dir, config["runs_dirpath"])
run_dirpath = None
try:
run_dirpath = run_utils.setup_run_dir(runs_dir, run_name)
except ValueError:
print_utils.print_error(
"Run name {} was not found. Aborting...".format(run_name))
exit()
stats_dirpath = os.path.join(run_dirpath, "stats")
stats_list = load_stats_list(stats_dirpath, source_idx_list)
plot_k_nearest(stats_list)
for stats in stats_list:
plot_hist(stats)
def main():
# --- Process args --- #
args = get_args()
config = run_utils.load_config(args.config)
if config is None:
print_utils.print_error(
"ERROR: cannot continue without a config file. Exiting now...")
exit()
if args.batch_size is not None:
config["batch_size"] = args.batch_size
if args.exps_dirpath is not None:
config["exps_dirpath"] = args.exps_dirpath
distribution = "uniform"
params = {
"run_count": args.run_count,
"sample_count": args.sample_count,
"frequency": args.frequency,
"noise_std": args.noise_std,
"distribution": distribution,
}
stats_params = {
"neighbors_t": args.neighbors_t,
"neighbors_n": args.neighbors_n,
}
working_dir = os.path.dirname(os.path.abspath(__file__))
# Setup exp directory:
exps_dir = os.path.join(working_dir, config["exps_dirpath"])
exp_dirpath = run_utils.setup_run_dir(exps_dir, args.exp_name, args.new_exp)
# Launch experiments
launch_experiments(config, exp_dirpath, args.new_exp, args.recompute_stats, params, stats_params)
# Aggregate results
aggregate_results(exp_dirpath, params, stats_params)
def compute_grads(raw_dirpath, runs_dirpath, run_name, ds_fac,
overwrite_config, tile_info_list, polygon_dirname,
output_dirname, output_filepath_format):
# -- Params:
# Setup run dir and load config file
run_dir = run_utils.setup_run_dir(runs_dirpath, run_name)
_, checkpoints_dir = run_utils.setup_run_subdirs(run_dir)
config = run_utils.load_config(config_dirpath=run_dir)
# --- Instantiate model
output_res = model.MapAlignModel.get_output_res(
overwrite_config["input_res"], config["pool_count"])
map_align_model = model.MapAlignModel(
config["model_name"], overwrite_config["input_res"],
config["add_image_input"], config["image_channel_count"],
config["image_feature_base_count"], config["add_poly_map_input"],
config["poly_map_channel_count"],
config["poly_map_feature_base_count"],
config["common_feature_base_count"], config["pool_count"],
config["add_disp_output"], config["disp_channel_count"],
config["add_seg_output"], config["seg_channel_count"], output_res,
overwrite_config["batch_size"], config["loss_params"],
config["level_loss_coefs_params"], config["learning_rate_params"],
config["weight_decay"], config["image_dynamic_range"],
config["disp_map_dynamic_range_fac"], config["disp_max_abs_value"])
map_align_model.setup_compute_grads() # Add ops to compute gradients
saver = tf.train.Saver(save_relative_paths=True)
with tf.Session() as sess:
# Restore checkpoint
restore_checkpoint_success = map_align_model.restore_checkpoint(
sess, saver, checkpoints_dir)
if not restore_checkpoint_success:
sys.exit('No checkpoint found in {}'.format(checkpoints_dir))
# Compute patch count
patch_total_count = 0
for tile_info in tile_info_list:
patch_total_count += len(tile_info["bbox_list"])
pbar = tqdm(total=patch_total_count,
desc="Computing patch gradients: ")
for tile_info in tile_info_list:
# --- Path setup:
unused_filepath = output_filepath_format.format(
dir=raw_dirpath,
fold=tile_info["fold"],
out_dir=output_dirname,
tile="",
b0=0,
b1=0,
b2=0,
b3=0,
out_name="",
ext="")
os.makedirs(os.path.dirname(unused_filepath), exist_ok=True)
tile_name = read.IMAGE_NAME_FORMAT.format(
city=tile_info["city"], number=tile_info["number"])
# Compute grads for that image
additional_args = {
"overwrite_polygon_dir_name": polygon_dirname,
}
# t = time.clock()
image, metadata, polygons = read.load_gt_data(
raw_dirpath,
tile_info["city"],
tile_info["number"],
additional_args=additional_args)
# t_read = time.clock() - t
# Downsample
image, polygons = process_utils.downsample_data(
image, metadata, polygons, ds_fac,
config["reference_pixel_size"])
spatial_shape = image.shape[:2]
# Draw polygon map
# t = time.clock()
polygon_map = polygon_utils.draw_polygon_map(polygons,
spatial_shape,
fill=True,
edges=True,
vertices=True)
# t_draw = time.clock() - t
t_grads = 0
t_save = 0
for bbox in tile_info["bbox_list"]:
p_im = image[bbox[0]:bbox[2], bbox[1]:bbox[3], :]
p_polygon_map = polygon_map[bbox[0]:bbox[2],
bbox[1]:bbox[3], :]
# p_polygons = polygon_utils.crop_polygons_to_patch_if_touch(polygons, bbox)
# Grad compute
t = time.clock()
grads = map_align_model.compute_grads(sess, p_im,
p_polygon_map)
t_grads += time.clock() - t
# Saving
t = time.clock()
flattened_grads_x = get_flattened_gradients(grads["x"])
flattened_grads_y = get_flattened_gradients(grads["y"])
flattened_grads = np.stack(
[flattened_grads_x, flattened_grads_y], axis=-1)
# # Save patch for later visualization
# im_filepath = output_filepath_format.format(dir=raw_dirpath, fold=tile_info["fold"],
# out_dir=output_dirname, tile=tile_name,
# b0=bbox[0], b1=bbox[1], b2=bbox[2], b3=bbox[3],
# out_name="image", ext="png")
# skimage.io.imsave(im_filepath, p_im)
# # Save polygons as well
# polygons_filepath = output_filepath_format.format(dir=raw_dirpath, fold=tile_info["fold"],
# out_dir=output_dirname, tile=tile_name,
# b0=bbox[0], b1=bbox[1], b2=bbox[2], b3=bbox[3],
# out_name="polygons", ext="npy")
# np.save(polygons_filepath, p_polygons)
# Save grads
grads_filepath = output_filepath_format.format(
dir=raw_dirpath,
fold=tile_info["fold"],
out_dir=output_dirname,
tile=tile_name,
b0=bbox[0],
b1=bbox[1],
b2=bbox[2],
b3=bbox[3],
out_name="grads",
ext="npy")
np.save(grads_filepath, flattened_grads)
t_save += time.clock() - t
pbar.update(len(tile_info["bbox_list"]))
pbar.set_postfix(t_grads=t_grads, t_save=t_save)
pbar.close()
def inference(runs_dirpath, ori_image, ori_metadata, ori_disp_polygons,
model_disp_max_abs_value, batch_size, scale_factor, run_name):
# Setup run dir and load config file
run_dir = run_utils.setup_run_dir(runs_dirpath, run_name)
_, checkpoints_dir = run_utils.setup_run_subdirs(run_dir)
config = run_utils.load_config(
config_dirpath=os.path.dirname(os.path.realpath(__file__)))
#run_dir) why would there be a second config in run dir??
# Downsample
image, disp_polygons = downsample_data(ori_image, ori_metadata,
ori_disp_polygons, scale_factor,
config["reference_pixel_size"])
spatial_shape = image.shape[:2]
# Draw displaced polygon map
# disp_polygons_to_rasterize = []
disp_polygons_to_rasterize = disp_polygons
disp_polygon_map = polygon_utils.draw_polygon_map(
disp_polygons_to_rasterize,
spatial_shape,
fill=True,
edges=True,
vertices=True)
# Compute output_res
output_res = model.MapAlignModel.get_output_res(config["input_res"],
config["pool_count"])
# print("output_res: {}".format(output_res))
map_align_model = model.MapAlignModel(
config["model_name"], config["input_res"], config["add_image_input"],
config["image_channel_count"], config["image_feature_base_count"],
config["add_poly_map_input"], config["poly_map_channel_count"],
config["poly_map_feature_base_count"],
config["common_feature_base_count"], config["pool_count"],
config["add_disp_output"], config["disp_channel_count"],
config["add_seg_output"], config["seg_channel_count"], output_res,
batch_size, config["loss_params"], config["level_loss_coefs_params"],
config["learning_rate_params"], config["weight_decay"],
config["image_dynamic_range"], config["disp_map_dynamic_range_fac"],
model_disp_max_abs_value)
pred_field_map, segmentation_image = map_align_model.inference(
image, disp_polygon_map, checkpoints_dir)
# --- align disp_polygon according to pred_field_map --- #
# print("# --- Align disp_polygon according to pred_field_map --- #")
aligned_disp_polygons = disp_polygons
# First remove polygons that are not fully inside the inner_image
padding = (spatial_shape[0] - pred_field_map.shape[0]) // 2
bounding_box = [
padding, padding, spatial_shape[0] - padding,
spatial_shape[1] - padding
]
# aligned_disp_polygons = polygon_utils.filter_polygons_in_bounding_box(aligned_disp_polygons, bounding_box) # TODO: reimplement? But also filter out ori_gt_polygons for comparaison
aligned_disp_polygons = polygon_utils.transform_polygons_to_bounding_box_space(
aligned_disp_polygons, bounding_box)
# Then apply displacement field map to aligned_disp_polygons
aligned_disp_polygons = polygon_utils.apply_disp_map_to_polygons(
pred_field_map, aligned_disp_polygons)
# Restore polygons to original image space
bounding_box = [
-padding, -padding, spatial_shape[0] + padding,
spatial_shape[1] + padding
]
aligned_disp_polygons = polygon_utils.transform_polygons_to_bounding_box_space(
aligned_disp_polygons, bounding_box)
# Add padding to segmentation_image
final_segmentation_image = np.zeros(
(spatial_shape[0], spatial_shape[1], segmentation_image.shape[2]))
final_segmentation_image[padding:-padding,
padding:-padding, :] = segmentation_image
# --- Upsample outputs --- #
# print("# --- Upsample outputs --- #")
final_segmentation_image, aligned_disp_polygons = upsample_data(
final_segmentation_image, ori_metadata, aligned_disp_polygons,
scale_factor, config["reference_pixel_size"])
return aligned_disp_polygons, final_segmentation_image
def train(config, run_params, dataset_params):
# print("# --- Starting training --- #")
run_name = run_params["run_name"]
new_run = run_params["new_run"]
init_run_name = run_params["init_run_name"]
working_dir = os.path.dirname(os.path.abspath(__file__))
# Find data_dir
data_dirpath = python_utils.choose_first_existing_path(
config["data_dir_candidates"])
if data_dirpath is None:
print_utils.print_error("ERROR: Data directory not found!")
exit()
# print_utils.print_info("Using data from {}".format(data_dirpath))
root_dir = os.path.join(data_dirpath, config["data_root_partial_dirpath"])
# setup init checkpoints directory path if one is specified:
if init_run_name is not None:
init_run_dirpath = run_utils.setup_run_dir(config["runs_dirpath"],
init_run_name)
_, init_checkpoints_dirpath = run_utils.setup_run_subdirs(
init_run_dirpath)
else:
init_checkpoints_dirpath = None
# setup run directory:
runs_dir = os.path.join(working_dir, config["runs_dirpath"])
run_dirpath = run_utils.setup_run_dir(runs_dir, run_name, new_run)
# save config in logs directory
run_utils.save_config(config, run_dirpath)
# save args
args_filepath = os.path.join(run_dirpath, "args.json")
python_utils.save_json(
args_filepath, {
"run_name": run_name,
"new_run": new_run,
"init_run_name": init_run_name,
"batch_size": config["batch_size"],
})
# Choose device
# dev = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
dev = "cpu" # For small networks and experiments, cpu is much faster
# Instantiate dataset
# sobol_generator = rand_utils.SobolGenerator()
sobol_generator = None
train_ds = Synthetic1DDataset(root_dir=root_dir,
params=dataset_params,
split_name="train",
sobol_generator=sobol_generator,
transform=torchvision.transforms.Compose([
transforms.ToTensor(),
transforms.ToDevice(device=dev)
]))
val_ds = Synthetic1DDataset(root_dir=root_dir,
params=dataset_params,
split_name="val",
sobol_generator=sobol_generator,
transform=torchvision.transforms.Compose([
transforms.ToTensor(),
transforms.ToDevice(device=dev)
]))
# print(train_ds.alpha)
# print(val_ds.alpha)
# exit()
# Generate test dataset here because if using Sobel numbers, all datasets should be using the same SobolGenerator
# so that they do not generate the same samples.
test_ds = Synthetic1DDataset(root_dir=root_dir,
params=dataset_params,
split_name="test",
sobol_generator=sobol_generator,
transform=torchvision.transforms.Compose([
transforms.ToTensor(),
transforms.ToDevice(device=dev)
]))
train_dl = DataLoader(train_ds,
batch_size=config["batch_size"],
shuffle=True)
val_dl = DataLoader(val_ds, batch_size=config["batch_size"])
success = False
while not success:
try:
model = Simple1DInputNet(config)
model.to(dev)
optimizer = torch.optim.Adam(model.parameters(),
lr=config["lr"],
weight_decay=config["weight_decay"])
loss_func = measures.l1_loss
trainer = Trainer(config, model, optimizer, loss_func,
init_checkpoints_dirpath, run_dirpath)
trainer.fit(config, train_dl, val_dl)
success = True
except ValueError: # Catches NaN errors
# Try again
run_utils.wipe_run_subdirs(run_dirpath)
print("\nTry again\n")
pass
def main(_):
working_dir = os.path.dirname(os.path.abspath(__file__))
config_dir = os.path.dirname(os.path.realpath(__file__))
# print FLAGS
print("#--- FLAGS: ---#")
print("config: {}".format(FLAGS.config))
print("new_run: {}".format(FLAGS.new_run))
print("init_run_name: {}".format(FLAGS.init_run_name))
print("run_name: {}".format(FLAGS.run_name))
print("batch_size: {}".format(FLAGS.batch_size))
print("ds_fac: {}".format(FLAGS.ds_fac))
# load config file
config = run_utils.load_config(FLAGS.config, config_dir)
# Check config setting coherences
assert len(config["level_loss_coefs_params"]) == config["pool_count"], \
"level_loss_coefs_params ({} elements) must have model_res_levels ({}) elements".format(
len(config["level_loss_coefs_params"]), config["pool_count"])
# Find data_dir
data_dir = python_utils.choose_first_existing_path(
config["data_dir_candidates"])
if data_dir is None:
print("ERROR: Data directory not found!")
exit()
else:
print("Using data from {}".format(data_dir))
# Setup dataset dirpaths
tfrecords_dirpath_list = [
os.path.join(data_dir, tfrecords_dirpath)
for tfrecords_dirpath in config["tfrecords_partial_dirpath_list"]
]
# Overwrite config ds_fac if FLAGS specify them
if FLAGS.ds_fac is not None:
ds_fac_list = [FLAGS.ds_fac]
ds_repeat_list = [1]
else:
ds_fac_list = config["ds_fac_list"]
ds_repeat_list = config["ds_repeat_list"]
# setup init run directory of one is specified:
if FLAGS.init_run_name is not None:
init_run_dirpath = run_utils.setup_run_dir(config["runs_dirname"],
FLAGS.init_run_name)
else:
init_run_dirpath = None
# setup run directory:
runs_dir = os.path.join(working_dir, config["runs_dirname"])
current_run_dirpath = run_utils.setup_run_dir(runs_dir, FLAGS.run_name,
FLAGS.new_run)
# save config in logs directory
run_utils.save_config(config, current_run_dirpath)
# save FLAGS
FLAGS_filepath = os.path.join(current_run_dirpath, "FLAGS.json")
python_utils.save_json(
FLAGS_filepath, {
"run_name": FLAGS.run_name,
"new_run": FLAGS.new_run,
"batch_size": FLAGS.batch_size,
"ds_fac": FLAGS.ds_fac,
})
train(config, tfrecords_dirpath_list, init_run_dirpath,
current_run_dirpath, FLAGS.batch_size, ds_fac_list, ds_repeat_list)
def similarity_stats_1d(config, run_name, dataset_params, split_name,
stats_params):
# print("# --- Similarity Stats --- #")
working_dir = os.path.dirname(os.path.abspath(__file__))
# Find data_dir
data_dirpath = python_utils.choose_first_existing_path(
config["data_dir_candidates"])
if data_dirpath is None:
print_utils.print_error("ERROR: Data directory not found!")
exit()
# print_utils.print_info("Using data from {}".format(data_dirpath))
root_dir = os.path.join(data_dirpath, config["data_root_partial_dirpath"])
# setup run directory:
runs_dir = os.path.join(working_dir, config["runs_dirpath"])
run_dirpath = None
try:
run_dirpath = run_utils.setup_run_dir(runs_dir, run_name)
except ValueError:
print_utils.print_error(
"Run name {} was not found. Aborting...".format(run_name))
exit()
# Instantiate dataset
# ds = Synthetic1DDataset(root_dir=root_dir, params=dataset_params, split_name="test",
# distribution="triangular"
# )
ds = Synthetic1DDataset(root_dir=root_dir,
params=dataset_params,
split_name=split_name,
transform=None)
sample_count = len(ds)
# Load grads and pred
grads_dirpath = os.path.join(run_dirpath, "grads")
grads_filepath_list = python_utils.get_filepaths(grads_dirpath,
endswith_str=".npy",
startswith_str="grads.")
grads_list = [
np.load(grads_filepath)
for grads_filepath in tqdm(grads_filepath_list, desc="Loading grads")
]
# print("Grads shape: {}".format(grads_list[0].shape))
pred_filepath_list = python_utils.get_filepaths(grads_dirpath,
endswith_str=".npy",
startswith_str="pred.")
pred_list = [
np.load(pred_filepath)
for pred_filepath in tqdm(pred_filepath_list, desc="Loading pred")
]
# Create stats dir
stats_dirpath = os.path.join(run_dirpath, "stats_1d")
os.makedirs(stats_dirpath, exist_ok=True)
# import time
# t1 = time.clock()
neighbor_count, neighbor_count_no_normalization = netsimilarity_utils.compute_soft_neighbor_count(
grads_list)
neighbors_filepath = os.path.join(stats_dirpath, "neighbors_soft.npy")
np.save(neighbors_filepath, neighbor_count)
neighbors_filepath = os.path.join(stats_dirpath,
"neighbors_soft_no_normalization.npy")
np.save(neighbors_filepath, neighbor_count_no_normalization)
if not COMPUTE_ONLY_NEIGHBORS_SOFT:
# Compute similarity matrix
similarity_mat = netsimilarity_utils.compute_similarity_mat_1d(
grads_list)
# Compute number of neighbors
# Hard-thresholding:
for t in stats_params["neighbors_t"]:
neighbor_count = netsimilarity_utils.compute_neighbor_count(
similarity_mat, "hard", t=t)
neighbors_filepath = os.path.join(
stats_dirpath, "neighbors_hard_t_{}.npy".format(t))
np.save(neighbors_filepath, neighbor_count)
# # Soft estimate
# neighbor_count = netsimilarity_utils.compute_neighbor_count(similarity_mat, "soft")
# neighbors_filepath = os.path.join(stats_dirpath, "neighbors_soft.npy")
# np.save(neighbors_filepath, neighbor_count)
# Mix
for n in stats_params["neighbors_n"]:
neighbor_count = netsimilarity_utils.compute_neighbor_count(
similarity_mat, "less_soft", n=n)
neighbors_filepath = os.path.join(
stats_dirpath, "neighbors_less_soft_n_{}.npy".format(n))
np.save(neighbors_filepath, neighbor_count)
# print("Time to compute number of neighbors:")
# print(time.clock() - t1)
# Save inputs
for key in ["alpha", "x", "density", "gt", "noise", "curvature"]:
filepath = os.path.join(stats_dirpath, "{}.npy".format(key))
values = [sample[key] for sample in ds]
np.save(filepath, values)
# Save outputs
pred_filepath = os.path.join(stats_dirpath, "pred.npy")
pred = [pred[0] for pred in pred_list]
np.save(pred_filepath, pred)
# Error
error_filepath = os.path.join(stats_dirpath, "error.npy")
error = [
np.abs(sample["gt"] - pred[0]) for sample, pred in zip(ds, pred_list)
]
np.save(error_filepath, error)
# Losses
logs_dirpath = os.path.join(run_dirpath, "logs")
final_losses = python_utils.load_json(
os.path.join(logs_dirpath, "final_losses.json"))
train_loss_filepath = os.path.join(stats_dirpath, "train_loss.npy")
np.save(train_loss_filepath, final_losses["train_loss"])
val_loss_filepath = os.path.join(stats_dirpath, "val_loss.npy")
np.save(val_loss_filepath, final_losses["val_loss"])
loss_ratio_filepath = os.path.join(stats_dirpath, "loss_ratio.npy")
np.save(loss_ratio_filepath,
final_losses["val_loss"] / final_losses["train_loss"])
def inference(ori_image, ori_metadata, ori_disp_polygons,
model_disp_max_abs_value, batch_size, scale_factor, run_name):
# Downsample
image, disp_polygons = downsample_data(ori_image, ori_metadata,
ori_disp_polygons, scale_factor)
spatial_shape = image.shape[:2]
# Draw displaced polygon map
# disp_polygons_to_rasterize = []
disp_polygons_to_rasterize = disp_polygons
disp_polygon_map = polygon_utils.draw_polygon_map(
disp_polygons_to_rasterize,
spatial_shape,
fill=True,
edges=True,
vertices=True)
# Compute output_res
output_res = model.MapAlignModel.get_output_res(config.INPUT_RES,
config.POOL_COUNT)
print("output_res: {}".format(output_res))
map_align_model = model.MapAlignModel(
config.MODEL_NAME, config.INPUT_RES, config.IMAGE_INPUT_CHANNELS,
config.IMAGE_DYNAMIC_RANGE, config.DISP_MAP_DYNAMIC_RANGE_FAC,
config.POLY_MAP_INPUT_CHANNELS, config.IMAGE_FEATURE_BASE_COUNT,
config.POLY_MAP_FEATURE_BASE_COUNT, config.COMMON_FEATURE_BASE_COUNT,
config.POOL_COUNT, output_res, config.DISP_OUTPUT_CHANNELS,
model_disp_max_abs_value, config.ADD_SEG_OUTPUT,
config.SEG_OUTPUT_CHANNELS, batch_size, config.LEARNING_RATE_PARAMS,
config.LEVEL_LOSS_COEFS_PARAMS, config.DISP_LOSS_COEF,
config.SEG_LOSS_COEF, config.LAPLACIAN_PENALTY_COEF,
config.WEIGHT_DECAY)
run_dir = run_utils.setup_run_dir(config.RUNS_DIR, run_name)
_, checkpoints_dir = run_utils.setup_run_subdirs(
run_dir, config.LOGS_DIRNAME, config.CHECKPOINTS_DIRNAME)
pred_field_map, segmentation_image = map_align_model.inference(
image, disp_polygon_map, checkpoints_dir)
# --- Align disp_polygon according to pred_field_map --- #
print("# --- Align disp_polygon according to pred_field_map --- #")
aligned_disp_polygons = disp_polygons
# First remove polygons that are not fully inside the inner_image
padding = (spatial_shape[0] - pred_field_map.shape[0]) // 2
bounding_box = [
padding, padding, spatial_shape[0] - padding,
spatial_shape[1] - padding
]
# aligned_disp_polygons = polygon_utils.filter_polygons_in_bounding_box(aligned_disp_polygons, bounding_box) # TODO: reimplement? But also filter out ori_gt_polygons for comparaison
aligned_disp_polygons = polygon_utils.transform_polygons_to_bounding_box_space(
aligned_disp_polygons, bounding_box)
# Then apply displacement field map to aligned_disp_polygons
aligned_disp_polygons = polygon_utils.apply_disp_map_to_polygons(
pred_field_map, aligned_disp_polygons)
# Restore polygons to original image space
bounding_box = [
-padding, -padding, spatial_shape[0] + padding,
spatial_shape[1] + padding
]
aligned_disp_polygons = polygon_utils.transform_polygons_to_bounding_box_space(
aligned_disp_polygons, bounding_box)
# Add padding to segmentation_image
final_segmentation_image = np.zeros(
(spatial_shape[0], spatial_shape[1], segmentation_image.shape[2]))
final_segmentation_image[padding:-padding,
padding:-padding, :] = segmentation_image
# --- Upsample outputs --- #
print("# --- Upsample outputs --- #")
final_segmentation_image, aligned_disp_polygons = upsample_data(
final_segmentation_image, ori_metadata, aligned_disp_polygons,
scale_factor)
return aligned_disp_polygons, final_segmentation_image
