def main():
"""Main workflow."""
args = utils.build_predict_args(argparse.ArgumentParser())
log_handler = add_file_handler(logger,
Path(args.output_file).with_suffix(".log"))
utils.init_random(args.seed)
with torch.cuda.device(args.gpuid):
flair.device = torch.device(f"cuda:{args.gpuid}")
predict(args)
logger.removeHandler(log_handler)
def sample_p_0(replay_buffer, bs, y=None):
if len(replay_buffer) == 0:
return init_random(bs), []
buffer_size = len(replay_buffer) if y is None else len(replay_buffer) // args.n_classes
inds = torch.randint(0, buffer_size, (bs,))
# if cond, convert inds to class conditional inds
if y is not None:
inds = y.cpu() * buffer_size + inds
assert not args.uncond, "Can't drawn conditional samples without giving me y"
buffer_samples = replay_buffer[inds]
random_samples = init_random(bs)
choose_random = (torch.rand(bs) < args.reinit_freq).float()[:, None, None, None]
samples = choose_random * random_samples + (1 - choose_random) * buffer_samples
return samples.to(device), inds
def get_model_and_buffer(args, sample_q):
if args.pxycontrast > 0 or args.pxyjointcontrast > 0 or args.pxcontrast > 0:
model_cls = HYM
f = model_cls(args.depth,
args.width,
args.norm,
dropout_rate=args.dropout_rate,
n_classes=args.n_classes,
K=args.contrast_k,
T=args.contrast_t)
else:
model_cls = F if args.uncond else CCF
f = model_cls(args.depth,
args.width,
args.norm,
dropout_rate=args.dropout_rate,
n_classes=args.n_classes)
if not args.uncond:
assert args.buffer_size % args.n_classes == 0, "Buffer size must be divisible by args.n_classes"
if args.load_path is None:
replay_buffer = init_random(args, args.buffer_size)
else:
print(f"loading model from {args.load_path}")
ckpt_dict = torch.load(args.load_path)
f.load_state_dict(ckpt_dict["model_state_dict"])
replay_buffer = ckpt_dict["replay_buffer"]
f = f.to(device)
return f, replay_buffer
def main():
"""Main workflow."""
args = utils.build_train_args(argparse.ArgumentParser())
log_handler = add_file_handler(logger,
Path(args.model_dir) / "training.log")
logger.info(f"Args: {pformat(vars(args))}")
utils.init_random(args.seed)
with torch.cuda.device(args.gpuid):
flair.device = torch.device(f"cuda:{args.gpuid}")
train(args)
logger.removeHandler(log_handler)
def main():
"""Main workflow"""
args = utils.build_args(argparse.ArgumentParser())
utils.init_logger(args.model_file)
assert torch.cuda.is_available()
torch.cuda.set_device(args.gpuid)
utils.init_random(args.seed)
utils.set_params(args)
logger.info("Config:\n%s", pformat(vars(args)))
fields = utils.build_fields()
logger.info("Fields: %s", fields.keys())
logger.info("Load %s", args.train_file)
train_data = LMDataset(fields, args.train_file, args.sent_length_trunc)
logger.info("Training sentences: %d", len(train_data))
logger.info("Load %s", args.valid_file)
val_data = LMDataset(fields, args.valid_file, args.sent_length_trunc)
logger.info("Validation sentences: %d", len(val_data))
fields["sent"].build_vocab(train_data)
train_iter = utils.build_dataset_iter(train_data, args)
val_iter = utils.build_dataset_iter(val_data, args, train=False)
if args.resume and os.path.isfile(args.checkpoint_file):
logger.info("Resume training")
logger.info("Load checkpoint %s", args.checkpoint_file)
checkpoint = torch.load(args.checkpoint_file,
map_location=lambda storage, loc: storage)
es_stats = checkpoint["es_stats"]
args = utils.set_args(args, checkpoint)
else:
checkpoint = None
es_stats = ESStatistics(args)
model = utils.build_model(fields, args, checkpoint)
logger.info("Model:\n%s", model)
optimizer = utils.build_optimizer(model, args, checkpoint)
try_train_val(fields, model, optimizer, train_iter, val_iter, es_stats,
args)
def main():
"""Main workflow."""
args = utils.build_train_args(argparse.ArgumentParser())
if not args.data_columns:
raise RuntimeError("Specify data_column (e.g., text ner)")
log_handler = add_file_handler(logger, Path(args.model_dir) / "training.log")
logger.info(f"Args: {pformat(vars(args))}")
utils.init_random(args.seed)
with torch.cuda.device(args.gpuid):
flair.device = torch.device(f"cuda:{args.gpuid}")
train(args)
logger.removeHandler(log_handler)
def main():
"""Main workflow"""
args = utils.build_gen_args(argparse.ArgumentParser())
utils.init_logger(args.out_file)
logger.info("Config:\n%s", pformat(vars(args)))
assert torch.cuda.is_available()
torch.cuda.set_device(args.gpuid)
utils.init_random(args.seed)
logger.info("Load parameters from '%s'", args.model_file)
params = torch.load(args.model_file, map_location=lambda storage, loc: storage)
utils.set_params(params["args"])
fields = utils.load_fields_from_vocab(params["vocab"])
logger.info("Fields: %s", fields.keys())
model = utils.build_test_model(fields, params)
sent_idx = [i for i in range(args.num_sentences)]
num_batches = math.ceil(float(args.num_sentences) / args.batch_size)
samples = []
with torch.no_grad():
for i in range(num_batches):
running_batch_size = len(
sent_idx[i * args.batch_size : (i + 1) * args.batch_size]
)
samples.append(
model.generate(
running_batch_size, args.max_sent_length, args.temperature
)
)
samples = torch.cat(samples, 0)
save(samples, fields, args.out_file)
pickle.dump(x, fin)
return 0
# Should be updated with the new way evaluation is performed or deleted
if __name__ == '__main__':
parser = argparse.ArgumentParser(description="Entry point of the application.")
parser.add_argument("--learning-rate", type=float, required=False, default=0.1,
help="Learning rate to pass to the optimizer")
parser.add_argument("--embeddings-path", type=str, required=True, help="Path to the saved embeddings file")
parser.add_argument("--model-path", type=str, required=True, help="Path to the model file")
parser.add_argument("--train-file", type=str, required=True,
help="Path to the file containing the data to train on")
parser.add_argument("--dev-file", type=str, required=True,
help="Path to the file containing the data to evaluate on")
parser.add_argument("--batch-size", type=int, required=False, default=64,
help="Number of examples to consider per batch")
parser.add_argument("--num-epochs", type=int, required=False, default=10)
parser.add_argument("--hidden-size", type=int, required=False, default=500)
parser.add_argument("--weight-decay", type=float, required=False, default=0.001)
result = parser.parse_args()
init_random(1)
device = torch.device('cpu')
model = LSTMMultiply(300, result.hidden_size)
model.load_state_dict(torch.load(result.model_path, map_location=device))
sg_embeddings = torch.load(result.embeddings_path, map_location=device)
evaluation = Evaluation(result.train_file, result.dev_file, model, sg_embeddings, 'vocab/vocab_250.json')
print(evaluation.evaluate())
model_config = json.load(open(config['model']))
config = {**config, **model_config}
result = vars(result)
print(result)
print(config)
# Override based on cli arguments
for update_param in ['learning_rate', 'batch_size', 'num_epochs', 'number_of_negative_examples', 'save_path', 'which_cuda', 'weight_decay', 'early_stopping', 'random_seed', 'pretrained_model', 'heldout_data', 'flip_right_sentence']:
if result[update_param] is not None:
config[update_param] = result[update_param]
if result['hidden_size'] is not None:
config['model']['attributes']['hidden_size'] = result['hidden_size']
if result['model_type'] is not None:
config['model']['name'] = result['model_type']
if result['num_models'] is not None:
config['model']['attributes']['num_models'] = result['num_models']
print(config)
print(f"Init random seed with {config['random_seed']}")
init_random(seed=config['random_seed'])
if result['pretrained_model'] is not None:
print(f"Loading pretrained model from {result['pretrained_model']}")
train_obj = MWETrain(config)
if result['only_eval']:
print("Only evaluate the pretrained model")
train_obj.eval()
else:
print("Start training")
train_obj.train()
def main():
"""Main workflow"""
args = utils.build_test_args(argparse.ArgumentParser())
suff = ".test"
if args.report_iw_nll:
if (
args.num_iw_samples > args.iw_batch_size
and args.num_iw_samples % args.iw_batch_size != 0
):
raise RuntimeError("Expected num_iw_samples divisible by iw_batch_size")
suff = ".test.iw" + str(args.num_iw_samples)
utils.init_logger(args.model_file + suff)
logger.info("Config:\n%s", pformat(vars(args)))
assert torch.cuda.is_available()
torch.cuda.set_device(args.gpuid)
utils.init_random(args.seed)
logger.info("Load parameters from '%s'", args.model_file)
params = torch.load(args.model_file, map_location=lambda storage, loc: storage)
utils.set_params(params["args"])
fields = utils.load_fields_from_vocab(params["vocab"])
logger.info("Fields: %s", fields.keys())
model = utils.build_test_model(fields, params)
logger.info("Model:\n%s", model)
logger.info("Load %s", args.test_file)
test_data = LMDataset(fields, args.test_file, args.sent_length_trunc)
logger.info("Test sentences: %d", len(test_data))
test_iter = utils.OrderedIterator(
dataset=test_data,
batch_size=args.batch_size,
device=params["args"].device,
train=False,
shuffle=False,
repeat=False,
sort=False,
sort_within_batch=True,
)
if model.encoder is None:
args.report_iw_nll = False
logger.info("Force report_iw_nll to False")
start_time = time.time()
logger.info("Start testing")
if args.report_iw_nll:
if args.num_iw_samples <= args.iw_batch_size:
n_iw_iter = 1
else:
n_iw_iter = args.num_iw_samples // args.iw_batch_size
args.num_iw_samples = args.iw_batch_size
test_stats = report_iw_nll(model, test_iter, n_iw_iter, args.num_iw_samples)
logger.info(
"Results: test nll %.2f | test ppl %.2f", test_stats.nll(), test_stats.ppl()
)
else:
test_stats = validate(model, test_iter)
logger.info(
"Results: test nll %.2f | test kl %.2f | test ppl %.2f",
test_stats.nll(),
test_stats.kl(),
test_stats.ppl(),
)
logger.info("End of testing: time %.1f min", (time.time() - start_time) / 60)
