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()
