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