def load_building(dataset_name, building_name): dataset = factory.get_dataset(dataset_name) navtask = get_args() cp = navtask.camera_param rgb_shader, d_shader = renderer.get_shaders(cp.modalities) r_obj = SwiftshaderRenderer() r_obj.init_display(width=cp.width, height=cp.height, fov=cp.fov, z_near=cp.z_near, z_far=cp.z_far, rgb_shader=rgb_shader, d_shader=d_shader) r_obj.clear_scene() b = VisualNavigationEnv(robot=navtask.robot, env=navtask.env, task_params=navtask.task_params, building_name=building_name, flip=False, logdir=None, building_loader=dataset, r_obj=r_obj) b.load_building_into_scene() b.set_building_visibility(False) return b
def _write_map_files(b_in, b_out, transform): cats = get_categories() env = utils.Foo(padding=10, resolution=5, num_point_threshold=2, valid_min=-10, valid_max=200, n_samples_per_face=200) robot = utils.Foo(radius=15, base=10, height=140, sensor_height=120, camera_elevation_degree=-15) building_loader = factory.get_dataset('sbpd') for flip in [False, True]: b = nav_env.Building(b_out, robot, env, flip=flip, building_loader=building_loader) logging.info("building_in: %s, building_out: %s, transform: %d", b_in, b_out, transform) maps = _get_semantic_maps(b_in, transform, b.map, flip, cats) maps = np.transpose(np.array(maps), axes=[1,2,0]) # Load file from the cache. file_name = '{:s}_{:d}_{:d}_{:d}_{:d}_{:d}_{:d}.pkl' file_name = file_name.format(b.building_name, b.map.size[0], b.map.size[1], b.map.origin[0], b.map.origin[1], b.map.resolution, flip) out_file = os.path.join(DATA_DIR, 'processing', 'class-maps', file_name) logging.info('Writing semantic maps to %s.', out_file) save_variables(out_file, [maps, cats], ['maps', 'cats'], overwrite=True)
def _write_map_files(b_in, b_out, transform): cats = get_categories() env = utils.Foo(padding=10, resolution=5, num_point_threshold=2, valid_min=-10, valid_max=200, n_samples_per_face=200) robot = utils.Foo(radius=15, base=10, height=140, sensor_height=120, camera_elevation_degree=-15) building_loader = factory.get_dataset('sbpd') for flip in [False, True]: b = nav_env.Building(b_out, robot, env, flip=flip, building_loader=building_loader) logging.info("building_in: %s, building_out: %s, transform: %d", b_in, b_out, transform) maps = _get_semantic_maps(b_in, transform, b.map, flip, cats) maps = np.transpose(np.array(maps), axes=[1,2,0]) # Load file from the cache. file_name = '{:s}_{:d}_{:d}_{:d}_{:d}_{:d}_{:d}.pkl' file_name = file_name.format(b.building_name, b.map.size[0], b.map.size[1], b.map.origin[0], b.map.origin[1], b.map.resolution, flip) out_file = os.path.join(DATA_DIR, 'processing', 'class-maps', file_name) logging.info('Writing semantic maps to %s.', out_file) save_variables(out_file, [maps, cats], ['maps', 'cats'], overwrite=True)
def accuracyVsIterations(network_name, dataset_name): percentRetrainable = [1.0, 2.0, 4.0, 5.0, 6.0, 7.0] #8.0, 9.0, 1.0, 11.0, 12.0, 13.0, 14.0, 15.0] #per = 10.0 stddevVar = 0.8 num_levels = 32 tf.reset_default_graph() dataset = get_dataset(dataset_name) network = get_network(network_name) max_iters = iters[dataset_name] output_dir = get_output_dir() path = 'experiments/out/accuracyVsIterations/' + network_name + '_' + dataset_name acc, iterations = train_net_v1(network, dataset, output_dir, max_iters, stddevVar, per, dataset_name, num_levels) """ path1 = path + str(int(per*10))+'.csv' with open(path1, 'wb+') as fid: for i in range(len(acc)): fid.write(str(iterations[i])+','+str(acc[i])+'\n') """ for per in percentRetrainable: path1 = path + str(int(per * 10)) + '.csv' acc, iterations = train_net_v1(network, dataset, output_dir, max_iters, stddevVar, per, dataset_name, num_levels) with open(path1, 'wb+') as fid: for i in range(len(acc)): fid.write(str(iterations[i]) + ',' + str(acc[i]) + '\n') """
def createModelWithVariation(percentRetrainable, stddevVar, network_name, dataset_name, num_levels=32): tf.reset_default_graph() dataset = get_dataset(dataset_name) network = get_network(network_name) max_iters = iters[dataset_name] output_dir = get_output_dir() acc = train_net(network, dataset, output_dir, max_iters, stddevVar, percentRetrainable, dataset_name, num_levels) return acc
def readVerifyTopN(network_name, dataset_name): stddevVar = 0.8 num_levels = 32 tf.reset_default_graph() dataset = get_dataset(dataset_name) network = get_network(network_name) output_dir = get_output_dir() topNs = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, \ 11.0, 12.0, 13.0, 14.0, 15.0, 16.0, 17.0, 18.0, 19.0, 20.0, \ 21.0, 22.0, 23.0, 24.0, 25.0, 26.0, 27.0, 28.0, 29.0, 30.0, \ 31.0, 32.0, 33.0, 33.0, 35.0, 36.0, 37.0, 38.0, 39.0, 40.0, \ 41.0, 42.0, 43.0, 44.0, 45.0, 46.0, 47.0, 48.0, 49.0, 50.0, \ 51.0, 52.0, 53.0, 54.0, 55.0, 56.0, 57.0, 58.0, 59.0, 60.0, \ 61.0, 62.0, 63.0, 64.0, 65.0, 66.0, 67.0, 68.0, 69.0, 70.0, \ 71.0, 72.0, 73.0, 74.0, 75.0, 76.0, 77.0, 78.0, 79.0, 80.0, \ 81.0, 82.0, 83.0, 84.0, 85.0, 86.0, 87.0, 88.0, 89.0, 90.0, \ 91.0, 92.0, 93.0, 94.0, 95.0, 96.0, 97.0, 98.0, 99.0 ] accuracy = [] p = 'experiments/out/readVerifyTopN/' + network_name + '_' + dataset_name + '.csv' with open(p, 'wb+') as fid: for topN in topNs: print 'Doing read and verify for top {} of parameters'.format(topN) print 'readVerifyTopN | stddev', str(stddevVar) acc = verifyTopN(network, dataset, output_dir, stddevVar, dataset_name, num_levels, topN) fid.write(str(acc) + '\n') accuracy.append(acc) if writeToPickle: result = [] metaData = 'accuracy, read Verified %, stddevVar,' + network_name + ',' + dataset_name + ', num_levels' result.append(metaData) result.append(accuracy) result.append(topNs) result.append(stddevVar) result.append(num_levels) path = 'experiments/out/readVerifyTopN/' + network_name + '_' + dataset_name + '_' + str( num_levels) + '_.pkl' with open(path, 'wb') as fid: cPickle.dump(result, fid, cPickle.HIGHEST_PROTOCOL) plt.plot(topNs, accuracy, 'xb-') plt.ylabel('Accuracy') plt.xlabel('% of parameters read_verified') plt.show()
def load_building(dataset_name, building_name): dataset = factory.get_dataset(dataset_name) navtask = get_args() cp = navtask.camera_param rgb_shader, d_shader = renderer.get_shaders(cp.modalities) r_obj = SwiftshaderRenderer() r_obj.init_display(width=cp.width, height=cp.height, fov=cp.fov, z_near=cp.z_near, z_far=cp.z_far, rgb_shader=rgb_shader, d_shader=d_shader) r_obj.clear_scene() b = VisualNavigationEnv(robot=navtask.robot, env=navtask.env, task_params=navtask.task_params, building_name=building_name, flip=False, logdir=None, building_loader=dataset, r_obj=r_obj) b.load_building_into_scene() b.set_building_visibility(False) return b
def process_navtask_str(navtask_str): navtask = nec.nav_env_base_config() # Clobber with overrides from strings. navtask_vars = get_navtask_vars(navtask_str) navtask.task_params.n_ori = int(navtask_vars.n_ori) navtask.task_params.max_dist = int(navtask_vars.max_dist) navtask.task_params.num_steps = int(navtask_vars.num_steps) navtask.task_params.step_size = int(navtask_vars.step_size) navtask.task_params.data_augment.delta_xy = int( navtask_vars.step_size) / 2. n_aux_views_each = int(navtask_vars.aux_views[2]) aux_delta_thetas = np.concatenate( (np.arange(n_aux_views_each) + 1, -1 - np.arange(n_aux_views_each))) aux_delta_thetas = aux_delta_thetas * np.deg2rad(navtask.camera_param.fov) navtask.task_params.aux_delta_thetas = aux_delta_thetas if navtask_vars.data_aug == 'aug': navtask.task_params.data_augment.structured = False elif navtask_vars.data_aug == 'straug': navtask.task_params.data_augment.structured = True else: logging.fatal('Unknown navtask_vars.data_aug %s.', navtask_vars.data_aug) assert (False) navtask.task_params.num_history_frames = int(navtask_vars.history[1:]) navtask.task_params.n_views = 1 + navtask.task_params.num_history_frames navtask.task_params.goal_channels = int(navtask_vars.n_ori) if navtask_vars.task == 'hard': navtask.task_params.type = 'rng_rejection_sampling_many' navtask.task_params.rejection_sampling_M = 2000 navtask.task_params.min_dist = 10 elif navtask_vars.task == 'r2r': navtask.task_params.type = 'room_to_room_many' elif navtask_vars.task == 'ST': # Semantic task at hand. navtask.task_params.goal_channels = \ len(navtask.task_params.semantic_task.class_map_names) navtask.task_params.rel_goal_loc_dim = \ len(navtask.task_params.semantic_task.class_map_names) navtask.task_params.type = 'to_nearest_obj_acc' else: logging.fatal('navtask_vars.task: should be hard or r2r, ST') assert (False) if navtask_vars.modality == 'rgb': navtask.camera_param.modalities = ['rgb'] navtask.camera_param.img_channels = 3 elif navtask_vars.modality == 'd': navtask.camera_param.modalities = ['depth'] navtask.camera_param.img_channels = 2 navtask.task_params.img_height = navtask.camera_param.height navtask.task_params.img_width = navtask.camera_param.width navtask.task_params.modalities = navtask.camera_param.modalities navtask.task_params.img_channels = navtask.camera_param.img_channels navtask.task_params.img_fov = navtask.camera_param.fov navtask.dataset = factory.get_dataset(navtask_vars.dataset_name) return navtask
print('Called with args:') print(args) if args.cfg_file is not None: cfg_from_file(args.cfg_file) print('Using config:') pprint.pprint(cfg) if not args.randomize: # fix the random seeds (numpy and caffe) for reproducibility np.random.seed(cfg.RNG_SEED) # prepare dataset cfg.MODE = 'TRAIN' dataset = get_dataset(args.dataset_name) worker_init_fn = dataset.worker_init_fn if hasattr(dataset, 'worker_init_fn') else None num_workers = 4 dataloader = torch.utils.data.DataLoader(dataset, batch_size=cfg.TRAIN.IMS_PER_BATCH, shuffle=True, num_workers=num_workers, worker_init_fn=worker_init_fn) print('Use dataset `{:s}` for training'.format(dataset.name)) # overwrite intrinsics if len(cfg.INTRINSICS) > 0: K = np.array(cfg.INTRINSICS).reshape(3, 3) dataset._intrinsic_matrix = K print(dataset._intrinsic_matrix) output_dir = get_output_dir(dataset, None) print('Output will be saved to `{:s}`'.format(output_dir)) if not os.path.exists(output_dir):
torch.manual_seed(cfg.RNG_SEED) # device cfg.gpu_id = 0 cfg.device = torch.device('cuda:{:d}'.format(cfg.gpu_id)) print('GPU device {:d}'.format(args.gpu_id)) cfg.classes = cfg.TEST.CLASSES # prepare dataset if cfg.TEST.VISUALIZE: shuffle = True else: shuffle = False cfg.MODE = 'TEST' dataset = get_dataset(args.dataset_name) dataloader = torch.utils.data.DataLoader(dataset, batch_size=cfg.TEST.IMS_PER_BATCH, shuffle=shuffle, num_workers=0) print('Use dataset `{:s}` for training'.format(dataset.name)) # background dataset if cfg.TEST.SYNTHESIZE: if cfg.TRAIN.SYN_BACKGROUND_SPECIFIC: background_dataset = get_dataset(args.dataset_background_name) else: background_dataset = get_dataset('background_coco') background_loader = torch.utils.data.DataLoader(background_dataset, batch_size=cfg.TRAIN.IMS_PER_BATCH, shuffle=True, num_workers=4) else: background_loader = None cfg.TEST.MODEL = args.pretrained.split('/')[-1]
if __name__ == '__main__': args = parse_args() root = '../data/YCB_Video/data/0009/' image_ids = [1] num_images = 1 anlge = 45 height = 480 width = 640 cfg.TRAIN.CLASSES = [10, 14, 15] cfg.MODE = 'TEST' cfg.TEST.SYNTHESIZE = False dataset = get_dataset('ycb_video_train') # prepare renderer print('loading 3D models') cfg.renderer = YCBRenderer(width=cfg.TRAIN.SYN_WIDTH, height=cfg.TRAIN.SYN_HEIGHT, render_marker=False, gpu_id=args.gpu_id) cfg.renderer.load_objects(dataset.model_mesh_paths_target, dataset.model_texture_paths_target, dataset.model_colors_target) print(dataset.model_mesh_paths_target) cfg.renderer.set_camera_default() for i in image_ids:
def crossBarTests(dataset_name, max_iters, network_name, output_dir, stddev=0.1, percentRetrain=5.0): tf.reset_default_graph() network = get_network(network_name) dataset = get_dataset(dataset_name) acc = train_net(network,dataset, output_dir, max_iters, stddevVar, percentRetrainable, dataset_name) return acc