def load_config(): ''' Load the config .yml file. ''' args = parse_args() # If a previous configuration is available in the results directory, load. previous_config = os.path.join(args.results_dir, 'config.yml') if os.path.isfile(previous_config): args.cfg = previous_config # If we don't specify a config and no previous config is available. if args.cfg is None: raise Exception("No config file specified or available.") # Load configuration into memory. cfg_from_file(args.cfg) cfg.TIMESTAMP = TIMESTAMP cfg.INPUT_DIR = args.dataset_dir cfg.METADATA_FILENAME = args.metadata_filename cfg.OUTPUT_DIR = args.results_dir if args.cfg != previous_config: mkdir_p(cfg.OUTPUT_DIR) copyfile(args.cfg, os.path.join(cfg.OUTPUT_DIR, 'config.yml')) print('Data dir: {}'.format(cfg.INPUT_DIR)) print('Output dir: {}'.format(cfg.OUTPUT_DIR)) print('Using config {}:'.format(args.cfg)) pprint.pprint(cfg)
def load_config(): ''' Load the config .yml file. ''' args = parse_args() if args.cfg is None: raise Exception("No config file specified.") cfg_from_file(args.cfg) now = datetime.datetime.now(dateutil.tz.tzlocal()) timestamp = now.strftime('%Y_%m_%d_%H_%M_%S') print('timestamp: {}'.format(timestamp)) cfg.TIMESTAMP = timestamp cfg.INPUT_DIR = args.dataset_dir cfg.METADATA_FILENAME = args.metadata_filename cfg.OUTPUT_DIR = os.path.join(args.results_dir, '%s_%s' % (cfg.DATASET_NAME, timestamp)) mkdir_p(cfg.OUTPUT_DIR) copyfile(args.cfg, os.path.join(cfg.OUTPUT_DIR, 'config.yml')) print('Data dir: {}'.format(cfg.INPUT_DIR)) print('Output dir: {}'.format(cfg.OUTPUT_DIR)) print('Using config:') pprint.pprint(cfg)
def load_config(args): """ Load the config .yml file. """ if args.cfg is None: raise Exception("No config file specified.") cfg_from_file(args.cfg) now = datetime.datetime.now(dateutil.tz.tzlocal()) timestamp = now.strftime("%Y_%m_%d_%H_%M_%S") print("timestamp: {}".format(timestamp)) cfg.TIMESTAMP = timestamp cfg.INPUT_DIR = args.dataset_dir cfg.METADATA_FILENAME = args.metadata_filename cfg.OUTPUT_DIR = os.path.join( args.results_dir, "%s_%s_%s" % (cfg.DATASET_NAME, cfg.CONFIG_NAME, timestamp), ) mkdir_p(cfg.OUTPUT_DIR) copyfile(args.cfg, os.path.join(cfg.OUTPUT_DIR, "config.yml")) print("Data dir: {}".format(cfg.INPUT_DIR)) print("Output dir: {}".format(cfg.OUTPUT_DIR)) print("Using config:") pprint.pprint(cfg)
def parse_args(description): parser = argparse.ArgumentParser(description=description) parser.add_argument('--cfg', dest='cfg_file', action='append', help='an optional config file', default=None, type=str) parser.add_argument('--batch', dest='batch_size', help='batch size', default=None, type=int) parser.add_argument('--epoch', dest='epoch', help='epoch number', default=None, type=int) parser.add_argument('--model', dest='model', help='model name', default=None, type=str) parser.add_argument('--dataset', dest='dataset', help='dataset name', default=None, type=str) args = parser.parse_args() # load cfg from file if args.cfg_file is not None: for f in args.cfg_file: cfg_from_file(f) # load cfg from arguments if args.batch_size is not None: cfg_from_list(['BATCH_SIZE', args.batch_size]) if args.epoch is not None: cfg_from_list([ 'TRAIN.START_EPOCH', args.epoch, 'EVAL.EPOCH', args.epoch, 'VISUAL.EPOCH', args.epoch ]) if args.model is not None: cfg_from_list(['MODEL_NAME', args.model]) if args.dataset is not None: cfg_from_list(['DATASET_NAME', args.dataset]) if len(cfg.MODEL_NAME) != 0 and len(cfg.DATASET_NAME) != 0: outp_path = get_output_dir(cfg.MODEL_NAME, cfg.DATASET_NAME) cfg_from_list(['OUTPUT_PATH', outp_path]) assert len( cfg.OUTPUT_PATH ) != 0, 'Invalid OUTPUT_PATH! Make sure model name and dataset name are specified.' if not Path(cfg.OUTPUT_PATH).exists(): Path(cfg.OUTPUT_PATH).mkdir(parents=True) return args
def test_parse_args(description): parser = argparse.ArgumentParser() parser.add_argument('--cfg', dest='cfg_file', type=str, help='an optional config file', default="experiments/vgg16_scannet.yaml") parser.add_argument( '--model_path', dest='model_path', help='model name', default='output/vgg16_linematching_wire/params/params_0010.pt', type=str) parser.add_argument('--left_img', dest='left_img', help='left image name', default='test_data/000800.jpg', type=str) parser.add_argument('--right_img', dest='right_img', help='right image name', default='test_data/000900.jpg', type=str) parser.add_argument('--left_lines', dest='left_lines', help='left lines name', default='test_data/000800.txt', type=str) parser.add_argument('--right_lines', dest='right_lines', help='right lines name', default='test_data/000900.txt', type=str) parser.add_argument('--output_path', dest='output_path', help='output path name', default='./test_data/', type=str) args = parser.parse_args() # load cfg from file if args.cfg_file is not None: cfg_from_file(args.cfg_file) if len(cfg.MODEL_NAME) != 0 and len(cfg.DATASET_NAME) != 0: outp_path = get_output_dir(cfg.MODEL_NAME, cfg.DATASET_NAME) cfg_from_list(['OUTPUT_PATH', outp_path]) assert len( cfg.OUTPUT_PATH ) != 0, 'Invalid OUTPUT_PATH! Make sure model name and dataset name are specified.' if not Path(cfg.OUTPUT_PATH).exists(): Path(cfg.OUTPUT_PATH).mkdir(parents=True) return args
def main(args): cfg_from_file(args.cfg) np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) outputer = Outputer(args.output_dir, cfg.IMAGETEXT.PRINT_EVERY, cfg.IMAGETEXT.SAVE_EVERY) outputer.log(cfg) imsize = cfg.TREE.BASE_SIZE * (2**(cfg.TREE.BRANCH_NUM - 1)) val_transform = transforms.Compose([ transforms.Scale(int(imsize * 76 / 64)), transforms.CenterCrop(imsize), ]) if args.dataset == 'bird': val_dataset = ImageTextDataset(args.data_dir, 'test', transform=val_transform, sample_type='test') elif args.dataset == 'coco': val_dataset = CaptionDataset(args.data_dir, 'val', transform=val_transform, sample_type='test') else: raise NotImplementedError val_dataloader = torch.utils.data.DataLoader(val_dataset, batch_size=1, shuffle=False, num_workers=int(cfg.WORKERS)) if args.raw_checkpoint != '': outputer.log("load raw checkpoint from {}".format(args.raw_checkpoint)) encoder, decoder = load_raw_checkpoint(args.raw_checkpoint) else: # define the model encoder = Encoder() encoder.fine_tune(False) decoder = DecoderWithAttention( attention_dim=cfg.IMAGETEXT.ATTENTION_DIM, embed_dim=cfg.IMAGETEXT.EMBED_DIM, decoder_dim=cfg.IMAGETEXT.DECODER_DIM, vocab_size=val_dataset.n_words) assert args.model_path != "" outputer.log("load model dict from {}".format(args.model_path)) encoder, decoder = load_checkpoint(encoder, decoder, args.model_path) encoder.fine_tune(False) encoder, decoder = encoder.cuda(), decoder.cuda() outputer.log("eval the model...") pred_file = os.path.join(outputer.log_folder, 'pred_result.csv') eval_rtn, outputer = evaluate(val_dataloader, encoder, decoder, outputer, args.beam_size, pred_file) outputer.log("eval result: {}".format(dict2str(eval_rtn)))
def load_config(args): """ Load the config .yml file. """ if args.cfg is None: raise Exception("No config file specified.") cfg = cfg_from_file(args.cfg) now = datetime.datetime.now(dateutil.tz.tzlocal()) timestamp = now.strftime('%Y_%m_%d_%H_%M_%S') cfg.TIMESTAMP = timestamp cfg.INPUT_DIR = args.dataset_dir cfg.CHECKPOINT_DIR = args.checkpoint_dir cfg.METADATA_FILENAME = args.metadata_filename cfg.OUTPUT_DIR = os.path.join( args.results_dir, '%s_%s_%s' % (cfg.DATASET_NAME, cfg.CONFIG_NAME, timestamp)) mkdir_p(cfg.OUTPUT_DIR) copyfile(args.cfg, os.path.join(cfg.OUTPUT_DIR, 'config.yml')) return cfg
def parse_args(description): parser = argparse.ArgumentParser(description=description) parser.add_argument('--cfg', dest='cfg_file', action='append', help='an optional config file', default=None, type=str) args = parser.parse_args() # load cfg from file if args.cfg_file is not None: for f in args.cfg_file: cfg_from_file(f) return args
def load(self, checkpoint_name): """ Load the model and the config based on the checkpoint name The config is also loaded and can be accessed with the cfg object :param checkpoint_name: The name of the checkpoint without the file extension :return: The PyTorch model """ model_path = os.path.join(self.checkpoint_dir, "{0}.pth".format(checkpoint_name)) config_path = os.path.join(self.checkpoint_dir, "{0}.yml".format(checkpoint_name)) if not os.path.exists(model_path): raise FileNotFoundError( "Cannot find model checkpoint at {}".format(model_path)) if not os.path.exists(config_path): raise FileNotFoundError( "Cannot find config checkpoint at {}".format(config_path)) model = torch.load(model_path) cfg = cfg_from_file(config_path) return model, cfg
def parse_args(description): parser = argparse.ArgumentParser(description=description) parser.add_argument('--cfg', dest='cfg_file', action='append', help='an optional config file', default=['experiments/net1.yaml'], type=str) parser.add_argument('--batch', dest='batch_size', help='batch size', default=None, type=int) parser.add_argument('--epoch', dest='epoch', help='epoch number', default=None, type=int) parser.add_argument('--model', dest='model', help='model name', default=None, type=str) parser.add_argument('--dataset', dest='dataset', help='dataset name', default=None, type=str) args = parser.parse_args() # load cfg from file if args.cfg_file is not None: for f in args.cfg_file: cfg_from_file(f) # load cfg from arguments if args.batch_size is not None: cfg_from_list(['BATCH_SIZE', args.batch_size]) if args.epoch is not None: cfg_from_list( ['TRAIN.START_EPOCH', args.epoch, 'EVAL.EPOCH', args.epoch]) if args.model is not None: cfg_from_list(['MODEL_NAME', args.model]) if args.dataset is not None: cfg_from_list(['DATASET_NAME', args.dataset]) return args
] elif args.dataset == "vg": # train sizes: train, smalltrain, minitrain # train scale: ['150-50-20', '150-50-50', '500-150-80', '750-250-150', '1750-700-450', '1600-400-20'] args.imdb_name = "vg_150-50-50_minitrain" args.imdbval_name = "vg_150-50-50_minival" args.set_cfgs = [ 'ANCHOR_SCALES', '[4, 8, 16, 32]', 'ANCHOR_RATIOS', '[0.5,1,2]', 'MAX_NUM_GT_BOXES', '50' ] args.cfg_file = "cfgs/{}_ls.yml".format( args.net) if args.large_scale else "cfgs/{}.yml".format(args.net) if args.cfg_file is not None: cfg_from_file(args.cfg_file) if args.set_cfgs is not None: cfg_from_list(args.set_cfgs) print('Using config:') pprint.pprint(cfg) np.random.seed(cfg.RNG_SEED) #torch.backends.cudnn.benchmark = True if torch.cuda.is_available() and not args.cuda: print( "WARNING: You have a CUDA device, so you should probably run with --cuda" ) # train set # -- Note: Use validation set and disable the flipped to enable faster loading.
textdetector = TextDetector() boxes = textdetector.detect(boxes, scores[:, np.newaxis], img.shape[:2]) draw_boxes(img, image_name, boxes, scale) timer.toc() print(('Detection took {:.3f}s for ' '{:d} object proposals').format(timer.total_time, boxes.shape[0])) return timer.total_time if __name__ == '__main__': if os.path.exists("data/results/"): shutil.rmtree("data/results/") os.makedirs("data/results/") cfg_from_file('tools/text.yml') # init session # 自动选择运行设备 config = tf.ConfigProto(allow_soft_placement=True) sess = tf.Session(config=config) # load network net = model_test() # load model print(('Loading network {:s}... '.format("model_test")), end=' \n') saver = tf.train.Saver() try: ckpt = tf.train.get_checkpoint_state(cfg.TEST.checkpoints_path) print('Restoring from {}...'.format(ckpt.model_checkpoint_path), end=' ')
def eval_model( dataset_dir, metadata_filename, model_filename, model_cfg, batch_size=32, sample_size=-1, ): """ Validation loop. Parameters ---------- dataset_dir : str Directory with all the images. metadata_filename : str Absolute path to the metadata pickle file. model_filename : str path/filename where to save the model. batch_size : int Mini-batch size. sample_size : int Number of elements to use as sample size, for debugging purposes only. If -1, use all samples. Returns ------- y_pred : ndarray Prediction of the model. """ seed = 1234 print("pytorch/random seed: {}".format(seed)) np.random.seed(seed) random.seed(seed) torch.manual_seed(seed) torch.backends.cudnn.deterministic = True if torch.cuda.is_available(): torch.cuda.manual_seed_all(seed) dataset_split = "test" # dataset_split = 'train' test_loader = prepare_dataloaders( dataset_split=dataset_split, dataset_path=dataset_dir, metadata_filename=metadata_filename, batch_size=batch_size, sample_size=sample_size, num_worker=0, ) device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu") print("Device used: ", device) cfg_from_file(model_cfg) # Load best model model_dict = torch.load(model_filename, map_location=device) current_hyper_params_dict = model_dict["hyper_params"] model = ModularSVNHClassifier( cfg.MODEL, feature_transformation=ResNet34( current_hyper_params_dict["FEATURES_OUTPUT_SIZE"] ), length_classifier=LengthClassifier( cfg.MODEL, current_hyper_params_dict["FEATURES_OUTPUT_SIZE"] ), number_classifier=NumberClassifier, hyper_params=current_hyper_params_dict, ) model.load_state_dict(model_dict["model_state_dict"]) since = time.time() model = model.to(device) print("# Testing Model ... #") stats = StatsRecorder() performance_evaluator = PerformanceEvaluator(test_loader) y_pred, y_true = performance_evaluator.evaluate( model, device, stats, mode="test" ) test_accuracy = stats.test_best_accuracy print("===============================") print("\n\nTest Set Accuracy: {}".format(test_accuracy)) time_elapsed = time.time() - since print( "\n\nTesting complete in {:.0f}m {:.0f}s".format( time_elapsed // 60, time_elapsed % 60 ) ) y_true = np.asarray(y_true) y_pred = np.asarray(y_pred) return y_pred
def main(args): cfg_from_file(args.cfg) if args.gpu_id != -1: cfg.GPU_ID = args.gpu_id else: cfg.CUDA = False if args.data_dir != '': cfg.DATA_DIR = args.data_dir if args.textimage_nete_path != '': cfg.TRAIN.NET_E = args.textimage_nete_path pprint(cfg) np.random.seed(args.seed) torch.manual_seed(args.seed) outputer = Outputer(args.output_dir, cfg.IMAGETEXT.PRINT_EVERY, cfg.IMAGETEXT.SAVE_EVERY) outputer.log(cfg) imsize = cfg.TREE.BASE_SIZE * (2**(cfg.TREE.BRANCH_NUM - 1)) val_transform = transforms.Compose([ transforms.Scale(int(imsize * 76 / 64)), transforms.CenterCrop(imsize), ]) if args.dataset == 'bird': imagetext_val_dataset = ImageTextDataset(args.data_dir, 'test', transform=val_transform, sample_type='test') elif args.dataset == 'coco': imagetext_val_dataset = CaptionDataset(args.data_dir, 'val', transform=val_transform, sample_type='test') else: raise NotImplementedError imagetext_val_dataloader = torch.utils.data.DataLoader( imagetext_val_dataset, batch_size=1, shuffle=False, num_workers=int(cfg.WORKERS)) # evaluation imagetext model if args.imagetext_model_path != '': outputer.log("load raw checkpoint from: {}".format( args.imagetext_model_path)) if os.path.splitext( args.imagetext_model_path)[-1] == '.tar': # raw checkpoint imagetext_encoder, imagetext_decoder = load_raw_checkpoint( args.imagetext_model_path) else: #define the model imagetext_encoder = Encoder() imagetext_encoder.fine_tune(False) imagetext_decoder = DecoderWithAttention( attention_dim=cfg.IMAGETEXT.ATTENTION_DIM, embed_dim=cfg.IMAGETEXT.EMBED_DIM, decoder_dim=cfg.IMAGETEXT.DECODER_DIM, vocab_size=imagetext_val_dataset.n_words) imagetext_encoder, imagetext_decoder = load_checkpoint( imagetext_encoder, imagetext_decoder, args.imagetext_model_path) else: print("the model path for imagetext model is NULL") raise ValueError imagetext_encoder, imagetext_decoder = imagetext_encoder.cuda( ), imagetext_decoder.cuda() text_file = os.path.join(outputer.log_folder, "pred_result.csv") imagetext_eval_rtn, outputer = evaluate(imagetext_val_dataloader, imagetext_encoder, imagetext_decoder, outputer, args.beam_size, text_file) # write the pred to local file text_list = [] filename_list = [] with open(text_file, 'r') as fp: for _l in fp.readlines(): data_list = _l.strip().split(',') text_list.append(data_list[-2]) filename_list.append(data_list[-1]) #--------- generate images from the text -------# if args.dataset == 'bird': textimage_val_dataset = TextDataset(args.data_dir, 'test', base_size=cfg.TREE.BASE_SIZE, transform=val_transform) elif args.dataset == 'coco': textimage_val_dataset = CaptionDatasetMultisize( args.data_dir, 'val', base_size=cfg.TREE.BASE_SIZE, transform=val_transform) else: raise ValueError textimage_val_dataloader = torch.utils.data.DataLoader( textimage_val_dataset, batch_size=1) image_output_dir = os.path.join(args.output_dir, "images") algo = trainer(image_output_dir, textimage_val_dataloader, textimage_val_dataset.n_words, textimage_val_dataset.ixtoword) gen_example(textimage_val_dataset.wordtoix, algo, text_list, filename_list)
def train(args): cfg_from_file(args.cfg) cfg.WORKERS = args.num_workers pprint.pprint(cfg) # set the seed manually np.random.seed(args.seed) torch.manual_seed(args.seed) torch.cuda.manual_seed_all(args.seed) # define outputer outputer_train = Outputer(args.output_dir, cfg.IMAGETEXT.PRINT_EVERY, cfg.IMAGETEXT.SAVE_EVERY) outputer_val = Outputer(args.output_dir, cfg.IMAGETEXT.PRINT_EVERY, cfg.IMAGETEXT.SAVE_EVERY) # define the dataset split_dir, bshuffle = 'train', True # Get data loader imsize = cfg.TREE.BASE_SIZE * (2**(cfg.TREE.BRANCH_NUM - 1)) train_transform = transforms.Compose([ transforms.Scale(int(imsize * 76 / 64)), transforms.RandomCrop(imsize), ]) val_transform = transforms.Compose([ transforms.Scale(int(imsize * 76 / 64)), transforms.CenterCrop(imsize), ]) if args.dataset == 'bird': train_dataset = ImageTextDataset(args.data_dir, split_dir, transform=train_transform, sample_type='train') val_dataset = ImageTextDataset(args.data_dir, 'val', transform=val_transform, sample_type='val') elif args.dataset == 'coco': train_dataset = CaptionDataset(args.data_dir, split_dir, transform=train_transform, sample_type='train', coco_data_json=args.coco_data_json) val_dataset = CaptionDataset(args.data_dir, 'val', transform=val_transform, sample_type='val', coco_data_json=args.coco_data_json) else: raise NotImplementedError train_dataloader = torch.utils.data.DataLoader( train_dataset, batch_size=cfg.IMAGETEXT.BATCH_SIZE, shuffle=bshuffle, num_workers=int(cfg.WORKERS)) val_dataloader = torch.utils.data.DataLoader( val_dataset, batch_size=cfg.IMAGETEXT.BATCH_SIZE, shuffle=False, num_workers=1) # define the model and optimizer if args.raw_checkpoint != '': encoder, decoder = load_raw_checkpoint(args.raw_checkpoint) else: encoder = Encoder() decoder = DecoderWithAttention( attention_dim=cfg.IMAGETEXT.ATTENTION_DIM, embed_dim=cfg.IMAGETEXT.EMBED_DIM, decoder_dim=cfg.IMAGETEXT.DECODER_DIM, vocab_size=train_dataset.n_words) # load checkpoint if cfg.IMAGETEXT.CHECKPOINT != '': outputer_val.log("load model from: {}".format( cfg.IMAGETEXT.CHECKPOINT)) encoder, decoder = load_checkpoint(encoder, decoder, cfg.IMAGETEXT.CHECKPOINT) encoder.fine_tune(False) # to cuda encoder = encoder.cuda() decoder = decoder.cuda() loss_func = torch.nn.CrossEntropyLoss() if args.eval: # eval only outputer_val.log("only eval the model...") assert cfg.IMAGETEXT.CHECKPOINT != '' val_rtn_dict, outputer_val = validate_one_epoch( 0, val_dataloader, encoder, decoder, loss_func, outputer_val) outputer_val.log("\n[valid]: {}\n".format(dict2str(val_rtn_dict))) return # define optimizer optimizer_encoder = torch.optim.Adam(encoder.parameters(), lr=cfg.IMAGETEXT.ENCODER_LR) optimizer_decoder = torch.optim.Adam(decoder.parameters(), lr=cfg.IMAGETEXT.DECODER_LR) encoder_lr_scheduler = torch.optim.lr_scheduler.StepLR( optimizer_encoder, step_size=10, gamma=cfg.IMAGETEXT.LR_GAMMA) decoder_lr_scheduler = torch.optim.lr_scheduler.StepLR( optimizer_decoder, step_size=10, gamma=cfg.IMAGETEXT.LR_GAMMA) print("train the model...") for epoch_idx in range(cfg.IMAGETEXT.EPOCH): # val_rtn_dict, outputer_val = validate_one_epoch(epoch_idx, val_dataloader, encoder, # decoder, loss_func, outputer_val) # outputer_val.log("\n[valid] epoch: {}, {}".format(epoch_idx, dict2str(val_rtn_dict))) train_rtn_dict, outputer_train = train_one_epoch( epoch_idx, train_dataloader, encoder, decoder, optimizer_encoder, optimizer_decoder, loss_func, outputer_train) # adjust lr scheduler encoder_lr_scheduler.step() decoder_lr_scheduler.step() outputer_train.log("\n[train] epoch: {}, {}\n".format( epoch_idx, dict2str(train_rtn_dict))) val_rtn_dict, outputer_val = validate_one_epoch( epoch_idx, val_dataloader, encoder, decoder, loss_func, outputer_val) outputer_val.log("\n[valid] epoch: {}, {}\n".format( epoch_idx, dict2str(val_rtn_dict))) outputer_val.save_step({ "encoder": encoder.state_dict(), "decoder": decoder.state_dict() }) outputer_val.save({ "encoder": encoder.state_dict(), "decoder": decoder.state_dict() })
def train(): args = parse_args() if args.config_file is not None: cfg_from_file(args.config_file) train_model()