def main(_): global PATCH_SIZE args = parser.parse_args() print(args) # Get available GPUs local_device_protos = utils.get_available_devices() print('Found devices:', [x.name for x in local_device_protos]) # set gpu if args.gpu_id is not None: print('using gpu %d' % args.gpu_id) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) else: print('no gpu specified') # load config and run training cfg = utils.load_config(args.cfg_dir, nopause=args.nopause) adjust_cfg_for_extract(args, cfg) print(os.path.join(cfg['log_dir'], "{}_label.png").format(args.stat_type)) if 'metric_kwargs' in cfg: cfg['target_dim_tuple'] = (cfg['metric_kwargs']['output_size'], ) if type(cfg['target_dim']) == int: cfg['target_dim_tuple'] = (cfg['target_dim'], ) else: cfg['target_dim_tuple'] = cfg['target_dim'] run_training(cfg, args.cfg_dir, args)
def main( _ ): args = parser.parse_args() # Get available GPUs local_device_protos = utils.get_available_devices() print( 'Found devices:', [ x.name for x in local_device_protos ] ) # set GPU id task_dir = os.path.join('/home/ubuntu/task-taxonomy-331b/experiments', 'class_gt') cfg = utils.load_config( task_dir, nopause=args.nopause ) dataset_dir = '/home/ubuntu/s3/meta' train = np.load(os.path.join(dataset_dir, 'train_image_split_0.npy')) val = np.load(os.path.join(dataset_dir, 'val_image_split_0.npy')) total = np.concatenate((train, val)) import math num_split = 200. unit_size = math.ceil(len(total) / num_split) total = total[args.idx * unit_size: (args.idx + 1) * unit_size] # split_file = '/home/ubuntu/this_split.npy' # with open(split_file, 'wb') as fp: # np.save(fp, total) # cfg['preprocess_fn'] = load_and_specify_preprocessors_for_representation_extraction # cfg['train_filenames'] = split_file # cfg['val_filenames'] = split_file # cfg['test_filenames'] = split_file cfg['randomize'] = False cfg['num_epochs'] = 2 cfg['num_read_threads'] = 1 run_extract_representations( args, cfg, total)
def __init__(self, model_file_path, char_dict_path, word_dict_path=None, emb_dim=128, hidden_dim=128): self.model_file_path = model_file_path self.char_dict_path = char_dict_path self.word_dict_path = word_dict_path with io.open(self.char_dict_path, 'rb') as f: self.char2index = pickle.load(f) self.device, gpu_ids = utils.get_available_devices() bilstm_crf = BiLSTMCRF(self.device, utils.tag_to_ix, len(self.char2index) + 2, emb_dim, hidden_dim) self.segmentor_model = utils.load_model(bilstm_crf, self.model_file_path, gpu_ids, return_step=False) self.segmentor_model = self.segmentor_model.to(self.device) self.segmentor_model.eval() self.userdict = Trie() self.userdict.add_dict(self.word_dict_path)
def main(_): args = parser.parse_args() # TODO(apply proposed change) # shim to reboot if the transport end point is disconnected # We will remove this in the next experiment and add it as a background process launched from user data # subprocess.call( # "watch -n 300 'bash /home/ubuntu/task-taxonomy-331b/tools/script/reboot_if_disconnected.sh' &>/dev/null &", # shell=True # ) print(args) # Get available GPUs local_device_protos = utils.get_available_devices() print('Found devices:', [x.name for x in local_device_protos]) # set gpu if args.gpu_id is not None: print('using gpu %d' % args.gpu_id) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) else: print('no gpu specified') # load config and run training cfg = utils.load_config(args.cfg_dir, nopause=args.nopause) # cfg['num_read_threads'] = 1 run_training(cfg, args.cfg_dir)
def __init__(self, device_serial=None, is_emulator=True, output_dir=None, grant_perm=False, telnet_auth_token=None): """ initialize a device connection :param device_serial: serial number of target device :param is_emulator: boolean, type of device, True for emulator, False for real device :return: """ self.logger = logging.getLogger(self.__class__.__name__) if device_serial is None: import utils all_devices = utils.get_available_devices() if len(all_devices) == 0: self.logger.warning("ERROR: No device connected.") sys.exit(-1) device_serial = all_devices[0] self.serial = device_serial self.is_emulator = is_emulator self.output_dir = output_dir if output_dir is not None: if not os.path.isdir(output_dir): os.mkdir(output_dir) self.grant_perm = grant_perm # basic device information self.settings = {} self.display_info = None self.model_number = None self.sdk_version = None self.release_version = None self.ro_debuggable = None self.ro_secure = None self.connected = True self.last_know_state = None self.__used_ports = [] self.pause_sending_event = False # adapters self.adb = ADB(device=self) self.telnet = TelnetConsole(device=self, auth_token=telnet_auth_token) self.droidbot_app = DroidBotAppConn(device=self) self.minicap = Minicap(device=self) self.logcat = Logcat(device=self) self.user_input_monitor = UserInputMonitor(device=self) self.process_monitor = ProcessMonitor(device=self) self.droidbot_ime = DroidBotIme(device=self) self.adapters = { self.adb: True, self.telnet: False, self.droidbot_app: True, self.minicap: True, self.logcat: True, self.user_input_monitor: True, self.process_monitor: True, self.droidbot_ime: True }
def main(_): args = parser.parse_args() # Get available GPUs local_device_protos = utils.get_available_devices() print('Found devices:', [x.name for x in local_device_protos]) # set GPU id if args.gpu_id: print('using gpu %d' % args.gpu_id) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) else: print('no gpu specified') cfg = load_config(args.cfg_dir) run_training(cfg)
def main(_): args = parser.parse_args() print(args) # Get available GPUs local_device_protos = utils.get_available_devices() print('Found devices:', [x.name for x in local_device_protos]) # set gpu if args.gpu_id is not None: print('using gpu %d' % args.gpu_id) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) else: print('no gpu specified') # load config and run training cfg = utils.load_config(args.cfg_dir, nopause=args.nopause) run_training(cfg, args.cfg_dir)
def main(_): print('Available devices:', utils.get_available_devices()) for _ in range(FLAGS.runs): # Initialize parameters. params = config.GANParams(config.params_defs.initialized()) # Override parameters by flag values. # for k, v in FLAGS.__dict__['__flags'].items(): # if v is not None: # params[k] = v # Load dataset. images, labels = params.dataset.get(params) # Run training. run(images, labels, params)
def main(_): args = parser.parse_args() print(args) # Get available GPUs local_device_protos = utils.get_available_devices() print('Found devices:', [x.name for x in local_device_protos]) # set gpu if args.gpu_id is not None: print('using gpu %d' % args.gpu_id) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) else: print('no gpu specified') # load config and run training cfg = utils.load_config(args.cfg_dir, nopause=args.nopause) cfg['task_name'] = args.cfg_dir.split('/')[-1] cfg['task_name'] = 'class_selected' cfg['num_epochs'] = 1 run_val_test(cfg)
def main( _ ): args = parser.parse_args() #task_list = ["autoencoder", "colorization","curvature", "denoise", "edge2d", "edge3d", "ego_motion", "fix_pose", "impainting", "jigsaw", "keypoint2d", "keypoint3d", "non_fixated_pose", "point_match", "reshade", "rgb2depth", "rgb2mist", "rgb2sfnorm", "room_layout", "segment25d", "segment2d", "vanishing_point"] #single channel for colorization !!!!!!!!!!!!!!!!!!!!!!!!! COME BACK TO THIS !!!!!!!!!!!!!!!!!!!!!!!!!!! #task_list = [ "point_match"] task_list = [ "vanishing_point"] # Get available GPUs local_device_protos = utils.get_available_devices() print( 'Found devices:', [ x.name for x in local_device_protos ] ) # set GPU id if args.gpu_id: print( 'using gpu %d' % args.gpu_id ) os.environ[ 'CUDA_VISIBLE_DEVICES' ] = str( args.gpu_id ) else: print( 'no gpu specified' ) for task in task_list: task_dir = os.path.join(args.cfg_dir, task) cfg = utils.load_config( task_dir, nopause=args.nopause ) root_dir = cfg['root_dir'] cfg['randomize'] = False cfg['num_epochs'] = 1 run_rand_baseline( args, cfg, task )
def main( _ ): args = parser.parse_args() print(args) # Get available GPUs local_device_protos = utils.get_available_devices() print( 'Found devices:', [ x.name for x in local_device_protos ] ) # set gpu if args.gpu_id is not None: print( 'using gpu %d' % args.gpu_id ) os.environ[ 'CUDA_VISIBLE_DEVICES' ] = str( args.gpu_id ) else: print( 'no gpu specified' ) # load config and run training cfg = utils.load_config( args.cfg_dir, nopause=args.nopause ) cfg['train_filenames'] = cfg['train_filenames'].replace('task-taxonomy-331b/assets/aws_data', 's3/meta') cfg['num_epochs'] = 6 cfg['learning_rate_schedule_kwargs' ] = { 'boundaries': [np.int64(0), np.int64(1800000)], # need to be int64 since global step is... 'values': [cfg['initial_learning_rate'], cfg['initial_learning_rate']/10] } cfg['randomize'] = True run_training( cfg, args.cfg_dir )
def __init__(self, device_serial=None, device_ip=None, is_emulator=False, output_dir=None, cv_mode=False, grant_perm=False, telnet_auth_token=None, enable_accessibility_hard=False, humanoid=None, ignore_ad=False): """ initialize a device connection :param device_serial: serial number of target device :param is_emulator: boolean, type of device, True for emulator, False for real device :return: """ self.logger = logging.getLogger(self.__class__.__name__) if device_serial is None: from utils import get_available_devices all_devices = get_available_devices() if len(all_devices) == 0: self.logger.warning("ERROR: No device connected.") sys.exit(-1) device_serial = all_devices[0] if "emulator" in device_serial and not is_emulator: self.logger.warning( "Seems like you are using an emulator. If so, please add is_emulator option." ) self.serial = device_serial self.ip = device_ip self.is_emulator = is_emulator self.cv_mode = cv_mode self.output_dir = output_dir if output_dir is not None: if not os.path.isdir(output_dir): os.makedirs(output_dir) self.grant_perm = grant_perm self.enable_accessibility_hard = enable_accessibility_hard self.humanoid = humanoid self.ignore_ad = ignore_ad # basic device information self.settings = {} self.display_info = None self.model_number = None self.sdk_version = None self.release_version = None self.ro_debuggable = None self.ro_secure = None self.connected = True self.last_know_state = None self.__used_ports = [] self.pause_sending_event = False # adapters self.adb = ADB(device=self) self.telnet = TelnetConsole(device=self, auth_token=telnet_auth_token) self.droidbot_app = DroidBotAppConn(device=self) self.minicap = Minicap(device=self) self.logcat = Logcat(device=self) self.user_input_monitor = UserInputMonitor(device=self) self.process_monitor = ProcessMonitor(device=self) self.droidbot_ime = DroidBotIme(device=self) self.adapters = { self.adb: True, self.telnet: False, self.droidbot_app: True, self.minicap: True, self.logcat: True, self.user_input_monitor: True, self.process_monitor: True, self.droidbot_ime: True } # minicap currently not working on emulators if self.is_emulator: self.logger.info("disable minicap on emulator") self.adapters[self.minicap] = False
def main(_): args = parser.parse_args() global TRAIN_MODE TRAIN_MODE = args.train_mode #task_list = ["autoencoder", "colorization","curvature", "denoise", "edge2d", "edge3d", "ego_motion", "fix_pose", "impainting", "jigsaw", "keypoint2d", "keypoint3d", "non_fixated_pose", "point_match", "reshade", "rgb2depth", "rgb2mist", "rgb2sfnorm", "room_layout", "segment25d", "segment2d", "vanishing_point"] #single channel for colorization !!!!!!!!!!!!!!!!!!!!!!!!! COME BACK TO THIS !!!!!!!!!!!!!!!!!!!!!!!!!!! #task_list = [ args.task ] with open('/home/ubuntu/task-taxonomy-331b/tools/config_list.txt', 'r') as fp: task_list = [x.split(' ')[0] for x in fp.readlines()] #config_prefix = 'second_order/DO_NOT_REPLACE_TARGET_DECODER/16k' #task_list = ['{}/{}'.format(config_prefix, x) for x in task_list] # Get available GPUs local_device_protos = utils.get_available_devices() print('Found devices:', [x.name for x in local_device_protos]) # set GPU id if args.gpu_id: print('using gpu %d' % args.gpu_id) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) else: print('no gpu specified') should_flip_dict = {} for task in task_list: flip_loss = [] for flip_num in range(2): task_dir = os.path.join(args.cfg_dir, task) cfg = utils.load_config(task_dir, nopause=args.nopause) root_dir = cfg['root_dir'] if flip_num == 0: cfg['val_representations_file'] = cfg[ 'val_representations_file'][::-1] if args.data_split == 'train': split_file = cfg['train_filenames'] elif args.data_split == 'val': split_file = cfg['val_filenames'] elif args.data_split == 'test': split_file = cfg['test_filenames'] else: raise NotImplementedError( "Unknown data split section: {}".format(args.data_split)) cfg['train_filenames'] = split_file cfg['val_filenames'] = split_file cfg['test_filenames'] = split_file if 'train_list_of_fileinfos' in cfg: split_file_ = cfg['{}_representations_file'.format( args.data_split)] cfg['train_representations_file'] = split_file_ cfg['val_representations_file'] = split_file_ cfg['test_representations_file'] = split_file_ split_file_ = cfg['{}_list_of_fileinfos'.format( args.data_split)] cfg['train_list_of_fileinfos'] = split_file_ cfg['val_list_of_fileinfos'] = split_file_ cfg['test_list_of_fileinfos'] = split_file_ if args.representation_task: split_file_ = args.representation_task if 'multiple_input_tasks' in cfg: split_file_ = [split_file_] cfg['train_representations_file'] = split_file_ cfg['val_representations_file'] = split_file_ cfg['test_representations_file'] = split_file_ # Try latest checkpoint by epoch cfg['model_path'] = tf.train.latest_checkpoint( os.path.join(cfg['log_root'], 'logs', 'slim-train')) # Try latest checkpoint by time if cfg['model_path'] is None: cfg['model_path'] = tf.train.latest_checkpoint( os.path.join(cfg['log_root'], 'logs', 'slim-train', 'time')) # Try to get one saved manually if cfg['model_path'] is None: continue #cfg['model_path'] = os.path.join(cfg['log_root'], task, "model.permanent-ckpt") cfg['randomize'] = False cfg['num_epochs'] = 3 cfg['batch_size'] = 32 cfg['num_read_threads'] = 3 if 'batch_size' in cfg['encoder_kwargs']: cfg['encoder_kwargs']['batch_size'] = cfg['batch_size'] try: cfg['target_cfg']['batch_size'] = cfg['batch_size'] except: pass try: cfg['target_cfg']['encoder_kwargs']['batch_size'] = cfg[ 'batch_size'] except: pass loss_dir = args.cfg_dir curr_loss = run_extract_losses_5_steps(args, cfg, loss_dir, task) flip_loss.append(curr_loss) should_flip_dict[task] = (flip_loss[0] > flip_loss[1]) with open( '/home/ubuntu/task-taxonomy-331b/tools/second_order_should_flip.pkl', 'wb') as fp: pickle.dump(should_flip_dict, fp)
def main(args): #denoiser = VQ_CVAE(128, k=512, num_channels=3) #denoiser.load_state_dict(torch.load("/mnt/home2/dlongo/eegML/VQ-VAE-master/vq_vae/saved_models/train.pt")) #denoiser = torch.no_grad(denoiser) #denoiser.cuda() #denoiser = nn.DataParallel(denoiser) # Get device device, args.gpu_ids = utils.get_available_devices() args.train_batch_size *= max(1, len(args.gpu_ids)) args.test_batch_size *= max(1, len(args.gpu_ids)) # Set random seed utils.seed_torch(seed=SEED) # Get save directories train_save_dir = utils.get_save_dir(args.save_dir, training=True) args.train_save_dir = train_save_dir # Save args args_file = os.path.join(train_save_dir, ARGS_FILE_NAME) with open(args_file, 'w') as f: json.dump(vars(args), f, indent=4, sort_keys=True) # Set up logging and devices log = utils.get_logger(train_save_dir, 'train_denoised') tbx = SummaryWriter(train_save_dir) log.info('Args: {}'.format(dumps(vars(args), indent=4, sort_keys=True))) if args.cross_val: # Loop over folds for fold_idx in range(args.num_folds): log.info('Starting fold {}...'.format(fold_idx)) # Train fold_save_dir = os.path.join(train_save_dir, 'fold_' + str(fold_idx)) if not os.path.exists(fold_save_dir): os.makedirs(fold_save_dir) # Training on current fold... train_fold(args, device, fold_save_dir, log, tbx, cross_val=True, fold_idx=fold_idx) best_path = os.path.join(fold_save_dir, 'best.pth.tar') # Predict on current fold with best model.. if args.model_name == 'SeizureNet': model = SeizureNet(args) model = nn.DataParallel(model, args.gpu_ids) model, _ = utils.load_model(model, best_path, args.gpu_ids) model.to(device) results = evaluate_fold(model, args, fold_save_dir, device, cross_val=True, fold_idx=fold_idx, is_test=True, write_outputs=True) # Log to console results_str = ', '.join('{}: {:05.2f}'.format(k, v) for k, v in results.items()) print('Fold {} test results: {}'.format(fold_idx, results_str)) log.info('Finished fold {}...'.format(fold_idx)) else: # no cross-validation # Train train_fold(args, device, train_save_dir, log, tbx, cross_val=False) best_path = os.path.join(train_save_dir, 'best.pth.tar') if args.model_name == 'SeizureNet': model = SeizureNet(args) model = nn.DataParallel(model, args.gpu_ids) model, _ = utils.load_model(model, best_path, args.gpu_ids) model.to(device) results = evaluate_fold(model, args, train_save_dir, device, cross_val=False, fold_idx=None, is_test=True, write_outputs=True) # Log to console results_str = ', '.join('{}: {:05.2f}'.format(k, v) for k, v in results.items()) print('Test set prediction results: {}'.format(results_str))
if __name__ == '__main__': global train_logger args.save_dir = get_save_dir( args.save_dir, args.name + '_lr' + f'{args.lr}' + '_epochs' + f'{args.num_epochs}' + '_hidden' + f'{args.HIDDEN_DIM}' + '_embed' + f'{args.EMBEDDING_DIM}' + '_batch' + f'{args.batch_size}', training=True) train_logger = get_logger(args.save_dir, args.name) train_logger.info('Args: {}'.format( dumps(vars(args), indent=4, sort_keys=True))) tbx = SummaryWriter(args.save_dir) device, args.gpu_ids = utils.get_available_devices() args.batch_size *= 1 # max(1, len(args.gpu_ids)) set_random() train_logger.info('Loading data from file') train_data, dev_data, word_to_ix = load_data() # print(dev_data) train_logger.info('Transferring data into dataset') train_dataset = utils.Dataset(train_data) train_loader = data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, collate_fn=utils.collate_fn_with_label) dev_dataset = utils.Dataset(dev_data)
def main(args): # Set up logging and devices args.save_dir = utils.get_save_dir(args.save_dir, args.name, training=True) log = utils.get_logger(args.save_dir, args.name) tbx = SummaryWriter(args.save_dir) device, args.gpu_ids = utils.get_available_devices() log.info(f'Args: {dumps(vars(args), indent=4, sort_keys=True)}') args.batch_size *= max(1, len(args.gpu_ids)) # Set random seed log.info(f'Using random seed {args.seed}...') random.seed(args.seed) np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) # Get model log.info('Building model...') model = get_model(args) model = nn.DataParallel(model, args.gpu_ids) if args.load_path: log.info(f'Loading checkpoint from {args.load_path}...') model, step = utils.load_model(model, args.load_path, args.gpu_ids) else: step = 0 model = model.to(device) model.train() # Get saver saver = utils.CheckpointSaver(args.save_dir, max_checkpoints=args.max_checkpoints, metric_name=args.metric_name, maximize_metric=args.maximize_metric, log=log) # Set optimizer and scheduler optimizer_grouped_params = [{ 'params': [p for n, p in model.named_parameters() if 'classifier' not in n] }, { 'params': [p for n, p in model.named_parameters() if 'classifier' in n], 'lr': args.lr_1 }] optimizer = optim.AdamW(optimizer_grouped_params, args.lr_2, weight_decay=args.l2_wd) scheduler = sched.LambdaLR(optimizer, lambda s: 1.) # Constant LR # Get data loader log.info('Building dataset...') transform = transforms.Compose([ transforms.Resize((224, 224)), transforms.ToTensor(), transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]) ]) train_dataset = NEWS(args.train_record_file, transform=transform) train_loader = data.DataLoader(train_dataset, batch_size=args.batch_size, shuffle=True, num_workers=args.num_workers, collate_fn=collate_fn) dev_dataset = NEWS(args.dev_record_file, transform=transform) dev_loader = data.DataLoader(dev_dataset, batch_size=args.batch_size, shuffle=False, num_workers=args.num_workers, collate_fn=collate_fn) # Train log.info('Training...') steps_till_eval = args.eval_steps epoch = step // len(train_dataset) while epoch != args.num_epochs: epoch += 1 log.info(f'Starting epoch {epoch}...') with torch.enable_grad(), tqdm( total=len(train_loader.dataset)) as progress_bar: # for input_idxs, atten_masks, images, ids, y in train_loader: for input_idxs, atten_masks, y in train_loader: # print(y) # Setup for forward input_idxs = input_idxs.to(device) atten_masks = atten_masks.to(device) y = y.to(device) batch_size = input_idxs.size(0) optimizer.zero_grad() # Forward log_p = model(input_idxs, atten_masks) loss = torch.nn.functional.binary_cross_entropy( log_p, y, weight=None, size_average=None, reduce=None, reduction='mean') loss_val = loss.item() # Backward loss.backward() optimizer.step() scheduler.step(step // batch_size) # Log info step += batch_size progress_bar.update(batch_size) progress_bar.set_postfix(epoch=epoch, NLL=loss_val) tbx.add_scalar('train/NLL', loss_val, step) tbx.add_scalar('train/LR', optimizer.param_groups[0]['lr'], step) steps_till_eval -= batch_size if steps_till_eval <= 0: steps_till_eval = args.eval_steps # Evaluate and save checkpoint log.info(f'Evaluating at step {step}...') results, pred_dict = evaluate(model, dev_loader, device) saver.save(step, model, results[args.metric_name], device) # Log to console results_str = ', '.join(f'{k}: {v:05.2f}' for k, v in results.items()) log.info(f'Dev {results_str}') # Log to TensorBoard log.info('Visualizing in TensorBoard...') for k, v in results.items(): tbx.add_scalar(f'dev/{k}', v, step)
def main(_): args = parser.parse_args() global TRAIN_MODE TRAIN_MODE = args.train_mode #task_list = ["autoencoder", "colorization","curvature", "denoise", "edge2d", "edge3d", "ego_motion", "fix_pose", "impainting", "jigsaw", "keypoint2d", "keypoint3d", "non_fixated_pose", "point_match", "reshade", "rgb2depth", "rgb2mist", "rgb2sfnorm", "room_layout", "segment25d", "segment2d", "vanishing_point"] #single channel for colorization !!!!!!!!!!!!!!!!!!!!!!!!! COME BACK TO THIS !!!!!!!!!!!!!!!!!!!!!!!!!!! task_list = [args.task] # Get available GPUs local_device_protos = utils.get_available_devices() print('Found devices:', [x.name for x in local_device_protos]) # set GPU id if args.gpu_id: print('using gpu %d' % args.gpu_id) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) else: print('no gpu specified') for task in task_list: to_task = 'class_places' if args.pretrain_transfer: task_dir = os.path.join( args.cfg_dir, args.pretrain_transfer_type, 'DO_NOT_REPLACE_TARGET_DECODER/16k', "{}__{}__8__unlocked".format(task, to_task)) else: task_dir = os.path.join(args.cfg_dir, 'final', task) cfg = utils.load_config(task_dir, nopause=args.nopause) root_dir = cfg['root_dir'] split_file = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/train_places_info.pkl')) cfg['dataset_dir'] = '/home/ubuntu/place' cfg['train_filenames'] = split_file cfg['val_filenames'] = split_file cfg['test_filenames'] = split_file if 'train_list_of_fileinfos' in cfg: if type(cfg['train_representations_file']) is not list: split_file_ = os.path.join( cfg['input_cfg']['log_root'], task, '{task}_train_places_representations.pkl'.format( task=task)) else: split_file_ = [] for fname in cfg['train_representations_file']: split_file_.append(fname.replace('val', 'train_places')) if args.add_places_knowledge: split_file_.append( os.path.join( cfg['input_cfg'][0]['log_root'], 'class_places', 'class_places_train_places_representations.pkl')) cfg['representation_dim'] = [16, 16, 8 * len(split_file_)] if args.add_alexnet: split_file_.append( os.path.join(cfg['input_cfg'][0]['log_root'], 'alex', 'alex_train_places_representations.pkl')) cfg['representation_dim'] = [ 16, 16, 8 * (len(split_file_) + 1) ] cfg['train_representations_file'] = split_file_ cfg['val_representations_file'] = split_file_ cfg['test_representations_file'] = split_file_ split_file_ = os.path.join(root_dir, 'assets/aws_data/train_places.npy') cfg['train_list_of_fileinfos'] = split_file_ cfg['val_list_of_fileinfos'] = split_file_ cfg['test_list_of_fileinfos'] = split_file_ # cfg['resize_interpolation_order'] = 0 # if cfg['model_path'] is None: # cfg['model_path'] = os.path.join(cfg['dataset_dir'], "model_log", task, "model.permanent-ckpt") cfg['target_from_filenames'] = class_places # Try latest checkpoint by epoch cfg['model_path'] = tf.train.latest_checkpoint( os.path.join(cfg['log_root'], 'logs', 'slim-train')) # Try latest checkpoint by time if cfg['model_path'] is None: cfg['model_path'] = tf.train.latest_checkpoint( os.path.join(cfg['log_root'], 'logs', 'slim-train', 'time')) # Try to get one saved manually if cfg['model_path'] is None: cfg['model_path'] = os.path.join(cfg['log_root'], task, "model.permanent-ckpt") # cfg['model_path'] = os.path.join(cfg['log_root'], 'logs', 'slim-train', 'time', "model.ckpt-1350") cfg['randomize'] = False cfg['num_epochs'] = args.num_epochs cfg['batch_size'] = 32 #if TRAIN_MODE else 1 cfg['num_read_threads'] = 30 if 'batch_size' in cfg['encoder_kwargs']: cfg['encoder_kwargs']['batch_size'] = cfg['batch_size'] try: cfg['target_cfg']['batch_size'] = cfg['batch_size'] except: pass try: cfg['target_cfg']['encoder_kwargs']['batch_size'] = cfg[ 'batch_size'] except: pass loss_dir = args.cfg_dir if args.train_encoder: cfg['src_encoder_ckpt'] = tf.train.latest_checkpoint( os.path.join(cfg['input_cfg']['log_root'], task, 'logs', 'slim-train', 'time')) if cfg['src_encoder_ckpt'] is None: cfg['src_encoder_ckpt'] = os.path.join( cfg['input_cfg']['log_root'], task, "model.permanent-ckpt") cfg['finetune_encoder_imagenet'] = True if args.metric_only: cfg['metric_net_only'] = True # cfg['target_cfg']['metric_kwargs'] = { # 'hidden_size': args.hidden, # 'layer_num': args.layers, # 'output_size': 63, # 'initial_dropout': True, # 'dropout':args.dropout # } cfg['target_cfg']['metric_kwargs'] = { 'hidden_size': args.hidden, 'layer_num': args.layers, 'output_size': 63, 'dropout': args.dropout } print(cfg['target_cfg']['metric_kwargs']) cfg['data_used'] = args.data_used # cfg['weight_decay'] = 1e-3 # cfg['encoder_kwargs']['weight_decay'] = cfg['weight_decay'] # cfg['target_cfg']['weight_decay'] = cfg['weight_decay'] # cfg['target_cfg']['metric_kwargs']['weight_decay'] = 0.001 cfg['initial_learning_rate'] = 1e-3 cfg['learning_rate_schedule_kwargs'] = { 'boundaries': [np.int64(0), np.int64(20000), np.int64(40000)], 'values': [ cfg['initial_learning_rate'], cfg['initial_learning_rate'] / 5., cfg['initial_learning_rate'] / 10. ] } if type(cfg['input_cfg']) is not list: cfg['input_cfg']['num_input'] = 1 #cfg['target_cfg']['metric_kwargs']['output_size'] = cfg['target_dim'] run_extract_losses(args, cfg, loss_dir, task)
def main( _ ): args = parser.parse_args() global TRAIN_MODE TRAIN_MODE = args.train_mode #task_list = ["autoencoder", "colorization","curvature", "denoise", "edge2d", "edge3d", "ego_motion", "fix_pose", "impainting", "jigsaw", "keypoint2d", "keypoint3d", "non_fixated_pose", "point_match", "reshade", "rgb2depth", "rgb2mist", "rgb2sfnorm", "room_layout", "segment25d", "segment2d", "vanishing_point"] #single channel for colorization !!!!!!!!!!!!!!!!!!!!!!!!! COME BACK TO THIS !!!!!!!!!!!!!!!!!!!!!!!!!!! task_list = [ args.task ] # Get available GPUs local_device_protos = utils.get_available_devices() print( 'Found devices:', [ x.name for x in local_device_protos ] ) # set GPU id if args.gpu_id: print( 'using gpu %d' % args.gpu_id ) os.environ[ 'CUDA_VISIBLE_DEVICES' ] = str( args.gpu_id ) else: print( 'no gpu specified' ) for task in task_list: if args.is_selected: to_task = 'class_selected' target_loading_fn = class_selected_imagenet else: to_task = 'class_1000' target_loading_fn = class_1000_imagenet if args.pretrain_transfer: task_dir = os.path.join(args.cfg_dir, args.pretrain_transfer_type, "{}__{}__8__unlocked".format(task, to_task)) else: task_dir = os.path.join(args.cfg_dir, 'final', task) cfg = utils.load_config( task_dir, nopause=args.nopause ) root_dir = cfg['root_dir'] if args.is_selected: split_file = os.path.abspath( os.path.join( root_dir, 'assets/aws_data/val_selected_imagenet_info.pkl') ) else: split_file = os.path.abspath( os.path.join( root_dir, 'assets/aws_data/val_split_imagenet_info.pkl') ) cfg['dataset_dir'] = '/home/ubuntu/imagenet' cfg['train_filenames'] = split_file cfg['val_filenames'] = split_file cfg['test_filenames'] = split_file if 'train_list_of_fileinfos' in cfg: split_file_ = os.path.join( cfg['input_cfg']['log_root'], task, '{task}_val_imagenet_representations.pkl'.format( task=task )) cfg['train_representations_file'] = split_file_ cfg['val_representations_file'] = split_file_ cfg['test_representations_file'] = split_file_ split_file_ = os.path.join(root_dir, 'assets/aws_data/val_imagenet.npy') cfg['train_list_of_fileinfos'] = split_file_ cfg['val_list_of_fileinfos'] = split_file_ cfg['test_list_of_fileinfos'] = split_file_ # cfg['resize_interpolation_order'] = 0 # if cfg['model_path'] is None: # cfg['model_path'] = os.path.join(cfg['dataset_dir'], "model_log", task, "model.permanent-ckpt") cfg['target_from_filenames'] = target_loading_fn # Try latest checkpoint by epoch cfg['model_path'] = tf.train.latest_checkpoint( os.path.join( cfg['log_root'], 'logs', 'slim-train' )) # Try latest checkpoint by time if cfg['model_path'] is None: cfg['model_path'] = tf.train.latest_checkpoint( os.path.join( cfg['log_root'], 'logs', 'slim-train', 'time' )) # Try to get one saved manually if cfg['model_path'] is None: cfg['model_path'] = os.path.join(cfg['log_root'], task, "model.permanent-ckpt") # cfg['model_path'] = os.path.join(cfg['log_root'], 'logs', 'slim-train', 'time', "model.ckpt-1350") finetuned=True if finetuned: cfg['model_path'] = os.path.join(cfg['log_root'], task, "imagenet_scratch") cfg['randomize'] = False cfg['num_epochs'] = 3 cfg['batch_size'] = 32 if TRAIN_MODE else 1 cfg['num_read_threads'] = 3 if 'batch_size' in cfg['encoder_kwargs']: cfg['encoder_kwargs']['batch_size'] = cfg['batch_size'] try: cfg['target_cfg']['batch_size'] = cfg['batch_size'] except: pass try: cfg['target_cfg']['encoder_kwargs']['batch_size'] = cfg['batch_size'] except: pass loss_dir = args.cfg_dir cfg['finetune_encoder_imagenet'] = True cfg['data_used'] = 100000000 cfg['input_cfg']['num_input'] = 1 run_extract_losses( args, cfg, loss_dir, task )
def main(_): args = parser.parse_args() global TRAIN_MODE TRAIN_MODE = args.train_mode #task_list = ["autoencoder", "colorization","curvature", "denoise", "edge2d", "edge3d", "ego_motion", "fix_pose", "impainting", "jigsaw", "keypoint2d", "keypoint3d", "non_fixated_pose", "point_match", "reshade", "rgb2depth", "rgb2mist", "rgb2sfnorm", "room_layout", "segment25d", "segment2d", "vanishing_point"] #single channel for colorization !!!!!!!!!!!!!!!!!!!!!!!!! COME BACK TO THIS !!!!!!!!!!!!!!!!!!!!!!!!!!! task_list = [args.task] # Get available GPUs local_device_protos = utils.get_available_devices() print('Found devices:', [x.name for x in local_device_protos]) # set GPU id if args.gpu_id: print('using gpu %d' % args.gpu_id) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) else: print('no gpu specified') for task in task_list: task_dir = os.path.join(args.cfg_dir, task) cfg = utils.load_config(task_dir, nopause=args.nopause) root_dir = cfg['root_dir'] if args.gen: cfg['train_filenames'] = os.path.abspath( os.path.join('/home/ubuntu/s3', 'meta/val_split_image_info.pkl')) cfg['val_filenames'] = os.path.abspath( os.path.join('/home/ubuntu/s3', 'meta/test_split_image_info.pkl')) cfg['test_filenames'] = os.path.abspath( os.path.join('/home/ubuntu/s3', 'meta/test_split_image_info.pkl')) if args.data_split == 'train': split_file = cfg['train_filenames'] elif args.data_split == 'val': split_file = cfg['val_filenames'] elif args.data_split == 'test': split_file = cfg['test_filenames'] else: raise NotImplementedError("Unknown data split section: {}".format( args.data_split)) global SPLIT_FILE SPLIT_FILE = split_file cfg['train_filenames'] = split_file cfg['val_filenames'] = split_file cfg['test_filenames'] = split_file if 'train_list_of_fileinfos' in cfg: split_file_ = cfg['{}_representations_file'.format( args.data_split)] cfg['train_representations_file'] = split_file_ cfg['val_representations_file'] = split_file_ cfg['test_representations_file'] = split_file_ split_file_ = cfg['{}_list_of_fileinfos'.format(args.data_split)] cfg['train_list_of_fileinfos'] = split_file_ cfg['val_list_of_fileinfos'] = split_file_ cfg['test_list_of_fileinfos'] = split_file_ if args.representation_task: split_file_ = args.representation_task if 'multiple_input_tasks' in cfg: split_file_ = [split_file_] cfg['train_representations_file'] = split_file_ cfg['val_representations_file'] = split_file_ cfg['test_representations_file'] = split_file_ # Flip order # with open('/home/ubuntu/task-taxonomy-331b/tools/second_order_should_flip.pkl', 'rb') as fp: # to_flip_dict = pickle.load(fp) # if not to_flip_dict[task.split('/')[-1]]: # cfg['val_representations_file'] = cfg['val_representations_file'][::-1] # Try latest checkpoint by epoch #if cfg['model_path'] is None: cfg['model_path'] = tf.train.latest_checkpoint( os.path.join(cfg['log_root'], 'logs', 'slim-train')) # Try latest checkpoint by time if cfg['model_path'] is None: cfg['model_path'] = tf.train.latest_checkpoint( os.path.join(cfg['log_root'], 'logs', 'slim-train', 'time')) # Try to get one saved manually if cfg['model_path'] is None: if task.split('/')[0] == 'final': cfg['model_path'] = os.path.join(cfg['log_root'], task.split('/')[-1], "model.permanent-ckpt") task = task.split('/')[-1] else: cfg['model_path'] = os.path.join(cfg['log_root'], task, "model.permanent-ckpt") # cfg['model_path'] = os.path.join(cfg['log_root'], 'logs', 'slim-train', 'time', "model.ckpt-1350") cfg['randomize'] = False cfg['num_epochs'] = 1 cfg['batch_size'] = 32 if TRAIN_MODE else 1 cfg['num_read_threads'] = 1 if 'batch_size' in cfg['encoder_kwargs']: cfg['encoder_kwargs']['batch_size'] = cfg['batch_size'] try: cfg['target_cfg']['batch_size'] = cfg['batch_size'] except: pass try: cfg['target_cfg']['encoder_kwargs']['batch_size'] = cfg[ 'batch_size'] except: pass loss_dir = args.cfg_dir run_extract_losses(args, cfg, loss_dir, task)
def main(_): args = parser.parse_args() #task_list = ["autoencoder", "colorization","curvature", "denoise", "edge2d", "edge3d", "ego_motion", "fix_pose", "impainting", "jigsaw", "keypoint2d", "keypoint3d", "non_fixated_pose", "point_match", "reshade", "rgb2depth", "rgb2mist", "rgb2sfnorm", "room_layout", "segment25d", "segment2d", "vanishing_point"] #single channel for colorization !!!!!!!!!!!!!!!!!!!!!!!!! COME BACK TO THIS !!!!!!!!!!!!!!!!!!!!!!!!!!! task_list = [args.task] # Get available GPUs local_device_protos = utils.get_available_devices() print('Found devices:', [x.name for x in local_device_protos]) # set GPU id if args.gpu_id: print('using gpu %d' % args.gpu_id) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) else: print('no gpu specified') for task in task_list: task_dir = os.path.join(args.cfg_dir, task) cfg = utils.load_config(task_dir, nopause=args.nopause) root_dir = cfg['root_dir'] transfer = (cfg['model_type'] == architectures.TransferNet) if not transfer: # For siamese tasks, we only need one representation per image. Pairs are irrelevant. if args.imagenet: cfg['train_filenames'] = os.path.abspath( os.path.join( root_dir, 'assets/aws_data/val_split_imagenet_info.pkl')) cfg['val_filenames'] = os.path.abspath( os.path.join( root_dir, 'assets/aws_data/val_split_imagenet_info.pkl')) cfg['dataset_dir'] = '/home/ubuntu/imagenet' elif args.places: cfg['train_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/train_places_info.pkl')) cfg['val_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/val_places_info.pkl')) cfg['dataset_dir'] = '/home/ubuntu/place' elif args.vid: cfg['train_filenames'] = os.path.abspath( os.path.join( root_dir, 'assets/aws_data/video{}_info.pkl'.format( args.vid_id))) cfg['val_filenames'] = os.path.abspath( os.path.join( root_dir, 'assets/aws_data/video{}_info.pkl'.format( args.vid_id))) cfg['dataset_dir'] = '/home/ubuntu' low_sat_tasks = 'autoencoder curvature denoise edge2d edge3d \ keypoint2d keypoint3d fix_pose random vanishing_point_well_defined \ reshade rgb2depth rgb2mist rgb2sfnorm point_match ego_motion \ room_layout segment25d segment2d non_fixated_pose \ segmentsemantic_rb class_1000 class_places class_selected \ ego_motion impainting_whole jigsaw'.split() if task.split('/')[-1] in low_sat_tasks: cfg['input_preprocessing_fn'] = load_ops.resize_rescale_image_low_sat_2 if task.split('/')[-1] == 'colorization': cfg['input_preprocessing_fn'] = load_ops.to_light_low_sat elif args.gen: cfg['train_filenames'] = os.path.abspath( os.path.join('/home/ubuntu/s3', 'meta/val_split_image_info.pkl')) cfg['val_filenames'] = os.path.abspath( os.path.join('/home/ubuntu/s3', 'meta/val_split_image_info.pkl')) cfg['test_filenames'] = os.path.abspath( os.path.join('/home/ubuntu/s3', 'meta/test_split_image_info.pkl')) else: cfg['train_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/train_2.pkl')) cfg['val_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/val_split_imag_info.pkl')) cfg['test_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/test_split_image_info.pkl')) cfg['preprocess_fn'] = load_and_specify_preprocessors_for_representation_extraction else: if args.imagenet: cfg['train_filenames'] = os.path.abspath( os.path.join( root_dir, 'assets/aws_data/val_split_imagenet_info.pkl')) cfg['val_filenames'] = os.path.abspath( os.path.join( root_dir, 'assets/aws_data/val_split_imagenet_info.pkl')) cfg['dataset_dir'] = '/home/ubuntu/imagenet' elif args.places: cfg['train_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/train_places_info.pkl')) cfg['val_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/val_places_info.pkl')) cfg['dataset_dir'] = '/home/ubuntu/place' elif args.vid: cfg['train_filenames'] = os.path.abspath( os.path.join( root_dir, 'assets/aws_data/video{}_info.pkl'.format( args.vid_id))) cfg['val_filenames'] = os.path.abspath( os.path.join( root_dir, 'assets/aws_data/video{}_info.pkl'.format( args.vid_id))) cfg['dataset_dir'] = '/home/ubuntu' elif args.gen: cfg['train_filenames'] = os.path.abspath( os.path.join('/home/ubuntu/s3', 'meta/val_split_image_info.pkl')) cfg['val_filenames'] = os.path.abspath( os.path.join('/home/ubuntu/s3', 'meta/test_split_image_info.pkl')) else: cfg['train_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/val_split_imag_info.pkl')) cfg['val_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/test_split_image_info.pkl')) cfg['preprocess_fn'] = load_and_specify_preprocessors_for_representation_extraction # pdb.set_trace() if args.data_split == 'train': split_file = cfg['train_filenames'] elif args.data_split == 'val': split_file = cfg['val_filenames'] elif args.data_split == 'test': split_file = cfg['test_filenames'] else: raise NotImplementedError("Unknown data split section: {}".format( args.data_split)) cfg['train_filenames'] = split_file cfg['val_filenames'] = split_file cfg['test_filenames'] = split_file if 'train_list_of_fileinfos' in cfg: split_file_ = cfg['{}_representations_file'.format( args.data_split)] cfg['train_representations_file'] = split_file_ cfg['val_representations_file'] = split_file_ cfg['test_representations_file'] = split_file_ split_file_ = cfg['{}_list_of_fileinfos'.format(args.data_split)] cfg['train_list_of_fileinfos'] = split_file_ cfg['val_list_of_fileinfos'] = split_file_ cfg['test_list_of_fileinfos'] = split_file_ if args.representation_task: split_file_ = args.representation_task if 'multiple_input_tasks' in cfg: split_file_ = [split_file_] cfg['train_representations_file'] = split_file_ cfg['val_representations_file'] = split_file_ cfg['test_representations_file'] = split_file_ if len(task.split('/')) > 1 and task.split('/')[-2] == 'final': task = task.split('/')[-1] perm_ckpt = os.path.join(cfg['log_root'], task, "model.permanent-ckpt.meta") if os.path.exists(perm_ckpt): cfg['model_path'] = perm_ckpt.replace(".meta", "") else: cfg['model_path'] = None # Try latest checkpoint by epoch if cfg['model_path'] is None: cfg['model_path'] = tf.train.latest_checkpoint( os.path.join(cfg['log_root'], 'logs', 'slim-train')) # Try latest checkpoint by time if cfg['model_path'] is None: cfg['model_path'] = tf.train.latest_checkpoint( os.path.join(cfg['log_root'], 'logs', 'slim-train', 'time')) if cfg['input_preprocessing_fn'] == load_ops.generate_jigsaw_input: cfg['input_preprocessing_fn'] = load_ops.generate_jigsaw_input_for_representation_extraction cfg['randomize'] = False cfg['num_epochs'] = 2 cfg['num_read_threads'] = 1 global REPRESENTATIONS_SHAPE REPRESENTATIONS_SHAPE = tuple([cfg['batch_size']] + REPRESENTATIONS_SHAPE) representation_dir = args.cfg_dir run_extract_representations(args, cfg, representation_dir, task)
def main(_): args = parser.parse_args() #task_list = ["autoencoder", "colorization","curvature", "denoise", "edge2d", "edge3d", "ego_motion", "fix_pose", "impainting", "jigsaw", "keypoint2d", "keypoint3d", "non_fixated_pose", "point_match", "reshade", "rgb2depth", "rgb2mist", "rgb2sfnorm", "room_layout", "segment25d", "segment2d", "vanishing_point"] #single channel for colorization !!!!!!!!!!!!!!!!!!!!!!!!! COME BACK TO THIS !!!!!!!!!!!!!!!!!!!!!!!!!!! task_list = [args.task] # Get available GPUs local_device_protos = utils.get_available_devices() print('Found devices:', [x.name for x in local_device_protos]) # set GPU id if args.gpu_id: print('using gpu %d' % args.gpu_id) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) else: print('no gpu specified') for task in task_list: task_dir = os.path.join(args.cfg_dir, task) cfg = utils.load_config(task_dir, nopause=args.nopause) root_dir = cfg['root_dir'] transfer = (cfg['model_type'] == architectures.TransferNet) if not transfer: # For siamese tasks, we only need one representation per image. Pairs are irrelevant. cfg['train_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/train_split_image_info.pkl')) cfg['val_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/val_split_imag_info.pkl')) cfg['test_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/test_split_image_info.pkl')) cfg['preprocess_fn'] = load_and_specify_preprocessors_for_representation_extraction else: cfg['train_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/val_split_imag_info.pkl')) cfg['val_filenames'] = os.path.abspath( os.path.join(root_dir, 'assets/aws_data/test_split_image_info.pkl')) if args.data_split == 'train': split_file = cfg['train_filenames'] elif args.data_split == 'val': split_file = cfg['val_filenames'] elif args.data_split == 'test': split_file = cfg['test_filenames'] else: raise NotImplementedError("Unknown data split section: {}".format( args.data_split)) cfg['train_filenames'] = split_file cfg['val_filenames'] = split_file cfg['test_filenames'] = split_file if 'train_list_of_fileinfos' in cfg: split_file_ = cfg['{}_representations_file'.format( args.data_split)] cfg['train_representations_file'] = split_file_ cfg['val_representations_file'] = split_file_ cfg['test_representations_file'] = split_file_ split_file_ = cfg['{}_list_of_fileinfos'.format(args.data_split)] cfg['train_list_of_fileinfos'] = split_file_ cfg['val_list_of_fileinfos'] = split_file_ cfg['test_list_of_fileinfos'] = split_file_ if args.representation_task: split_file_ = args.representation_task if 'multiple_input_tasks' in cfg: split_file_ = [split_file_] cfg['train_representations_file'] = split_file_ cfg['val_representations_file'] = split_file_ cfg['test_representations_file'] = split_file_ if cfg['model_path'] is None: cfg['model_path'] = os.path.join(cfg['dataset_dir'], "model_log", task, "model.permanent-ckpt") if cfg['model_type'] == architectures.TransferNet: cfg['model_path'] = os.path.join(cfg['log_root'], task, "model.permanent-ckpt") cfg['randomize'] = False cfg['num_epochs'] = 1 cfg['num_read_threads'] = 1 cfg['input_dim'] = (32, 32) # (1024, 1024) cfg['input_num_channels'] = 1 cfg['input_dtype'] = tf.float32 cfg['input_domain_name'] = 'rgb' cfg['input_preprocessing_fn'] = to_light cfg['input_preprocessing_fn_kwargs'] = { 'new_dims': cfg['input_dim'], 'new_scale': [-1, 1], 'interp_order': 1 } representation_dir = args.cfg_dir run_extract_representations(args, cfg, representation_dir, task)
def main(_): global args args = parser.parse_args() #task_list = ["autoencoder", "colorization","curvature", "denoise", "edge2d", "edge3d", "ego_motion", "fix_pose", "impainting", "jigsaw", "keypoint2d", "keypoint3d", "non_fixated_pose", "point_match", "reshade", "rgb2depth", "rgb2mist", "rgb2sfnorm", "room_layout", "segment25d", "segment2d", "vanishing_point"] #single channel for colorization !!!!!!!!!!!!!!!!!!!!!!!!! COME BACK TO THIS !!!!!!!!!!!!!!!!!!!!!!!!!!! task_list = [args.task] #task_list = [ "vanishing_point"] # Get available GPUs local_device_protos = utils.get_available_devices() print('Found devices:', [x.name for x in local_device_protos]) # set GPU id if args.gpu_id: print('using gpu %d' % args.gpu_id) os.environ['CUDA_VISIBLE_DEVICES'] = str(args.gpu_id) else: print('no gpu specified') for task in task_list: task_dir = os.path.join(args.cfg_dir, task) cfg = utils.load_config(task_dir, nopause=args.nopause) root_dir = cfg['root_dir'] if args.data_split == 'train': split_file = cfg['train_filenames'] elif args.data_split == 'val': split_file = cfg['val_filenames'] elif args.data_split == 'test': split_file = cfg['test_filenames'] else: raise NotImplementedError("Unknown data split section: {}".format( args.data_split)) cfg['train_filenames'] = split_file cfg['val_filenames'] = split_file cfg['test_filenames'] = split_file if 'train_list_of_fileinfos' in cfg: split_file_ = cfg['{}_representations_file'.format( args.data_split)] cfg['train_representations_file'] = split_file_ cfg['val_representations_file'] = split_file_ cfg['test_representations_file'] = split_file_ split_file_ = cfg['{}_list_of_fileinfos'.format(args.data_split)] cfg['train_list_of_fileinfos'] = split_file_ cfg['val_list_of_fileinfos'] = split_file_ cfg['test_list_of_fileinfos'] = split_file_ if cfg['model_path'] is None: cfg['model_path'] = os.path.join(cfg['dataset_dir'], "model_log", task, "model.permanent-ckpt") if cfg['model_type'] == architectures.TransferNet: cfg['model_path'] = os.path.join(cfg['log_root'], task, "model.permanent-ckpt") cfg['randomize'] = False cfg['num_epochs'] = 1 cfg['num_read_threads'] = 20 cfg['batch_size'] = 1 loss_dir = args.cfg_dir avg_img = load_avg_img(cfg, args) # print(np.sum(avg_img, axis=2)) print(avg_img.max()) print("Average image size: {}".format(avg_img.shape)) avg_img = map_img_to_target_range(avg_img, cfg) run_extract_losses(avg_img, args, cfg, loss_dir, task)