def main(argv):
set_seed(FLAGS.seed)
dialogue_checkpoints = list(
sorted(
glob(os.path.join(FLAGS.output_dir, "dialogue_*.ckpt"),
recursive=True)))
dialogue_model = ChitChat.load_from_checkpoint(
checkpoint_path=dialogue_checkpoints[-1])
dialogue_model.eval()
dialogue_model.freeze()
mmi_checkpoints = list(
sorted(
glob(os.path.join(FLAGS.output_dir, "mmi_*.ckpt"),
recursive=True)))
mmi_model = ChitChat.load_from_checkpoint(
checkpoint_path=mmi_checkpoints[-1])
mmi_model.eval()
mmi_model.freeze()
history = []
while True:
text = input("user: "******"chatbot:" + "".join(result))
def _fork_rng(self):
with fork_rng(cuda=self.cuda):
if self.rng_state is not None:
set_random_generator_state(self.rng_state)
else:
set_seed(self.random_seed)
try:
yield
finally:
self.rng_state = get_random_generator_state(cuda=self.cuda)
def test_deterministic_sampler__side_effects():
""" Ensure that the sampler does not affect random generation after it's finished. """
set_seed(123)
pre_randint = [random.randint(1, 2**31), random.randint(1, 2**31)]
sampler = DeterministicSampler(list(range(10)), random_seed=123)
list(iter(sampler))
post_randint = [random.randint(1, 2**31), random.randint(1, 2**31)]
set_seed(123)
assert pre_randint == [random.randint(1, 2**31), random.randint(1, 2**31)]
assert post_randint == [random.randint(1, 2**31), random.randint(1, 2**31)]
def test_fork_rng():
set_seed(123)
pre_randint = [random.randint(1, 2**31), random.randint(1, 2**31)]
with fork_rng(seed=123):
random.randint(1, 2**31)
post_randint = [random.randint(1, 2**31), random.randint(1, 2**31)]
set_seed(123)
assert pre_randint != post_randint
assert pre_randint == [random.randint(1, 2**31), random.randint(1, 2**31)]
assert post_randint == [random.randint(1, 2**31), random.randint(1, 2**31)]
def main(argv):
set_seed(FLAGS.seed)
qa_checkpoints = list(
sorted(
glob(os.path.join(FLAGS.output_dir, "qa_*.ckpt"), recursive=True)))
qa_model = QuestionAnswerGeneration.load_from_checkpoint(
checkpoint_path=qa_checkpoints[-1])
qa_model.eval()
qa_model.freeze()
while True:
text = input("qusetion is: ")
result = predict(qa_model, text)
print("answer is: ", result)
def run_training_pipeline(parser):
parser.add_argument("-f",
"--config",
default=False,
type=str,
help="Path to a YAML config file.")
parser.add_argument(
"--optimizer",
default=False,
type=str,
help="Optimizer to be used during training.",
)
parser.add_argument(
"--scheduler",
default=False,
type=str,
help="LR scheduler to be used during training.",
)
parser.add_argument(
"--model",
default=False,
type=str,
help="The estimator architecture we we wish to use.",
)
args, _ = parser.parse_known_args()
if not args.optimizer and not args.scheduler and not args.model:
optimizer, scheduler, model = get_main_args_from_yaml(args)
else:
optimizer = args.optimizer
scheduler = args.scheduler
model = args.model
parser = add_optimizer_args(parser, optimizer)
parser = add_scheduler_args(parser, scheduler)
parser = add_model_args(parser, model)
parser = add_trainer_specific_args(parser)
hparams = load_yaml_args(parser=parser, log=log)
set_seed(hparams.seed)
model = build_model(hparams)
trainer = setup_training(hparams)
if hparams.load_weights:
model.load_weights(hparams.load_weights)
log.info(f"{model.__class__.__name__} train starting:")
trainer.fit(model)
def test_fork_rng_wrap():
set_seed(123)
pre_randint = [random.randint(1, 2**31), random.randint(1, 2**31)]
@fork_rng_wrap()
def func():
random.randint(1, 2**31)
func()
post_randint = [random.randint(1, 2**31), random.randint(1, 2**31)]
set_seed(123)
assert pre_randint != post_randint
assert pre_randint == [random.randint(1, 2**31), random.randint(1, 2**31)]
assert post_randint == [random.randint(1, 2**31), random.randint(1, 2**31)]
def main(hparams) -> None:
"""
Main training routine specific for this project
:param hparams:
"""
set_seed(hparams.seed)
# ------------------------
# 1 INIT LIGHTNING MODEL AND DATA
# ------------------------
model = Classifier(hparams)
tb_logger = TensorBoardLogger(
save_dir='mednli_experiments/',
version="version_" + datetime.now().strftime("%d-%m-%Y--%H-%M-%S"),
name=f'{hparams.encoder_model}',
)
# ------------------------
# 5 INIT TRAINER
# ------------------------
trainer = Trainer(
logger=tb_logger,
gpus=hparams.gpus,
log_gpu_memory="all",
fast_dev_run=hparams.fast_dev_run,
accumulate_grad_batches=hparams.accumulate_grad_batches,
max_epochs=hparams.max_epochs,
default_root_dir=f'./classifier_pipeline_medNLI/{hparams.encoder_model}'
)
# ------------------------
# 6 START TRAINING
# ------------------------
trainer.fit(model, model.data)
trainer.test(model, model.data.test_dataloader())
cm = model.confusion_matrix.compute().detach().cpu().numpy()
model_name = model.hparams.encoder_model
np.save(
f'mednli_experiments/{model.hparams.encoder_model}/test_confusion_matrix.npy',
cm)
plot_confusion_matrix(
cm,
class_names=['entailment', 'neutral', 'contradiction'],
model=model.hparams.encoder_model)
def main(hparams) -> None:
set_seed(hparams.seed)
model = BERTClassifier(hparams)
early_stop_callback = EarlyStopping(
monitor=hparams.monitor,
min_delta=0.0,
patience=hparams.patience,
verbose=True,
mode=hparams.metric_mode,
)
save_dir = os.environ['HOME'] + "/data/lightning_experiments/"
trainer = Trainer(
logger=setup_testube_logger(save_dir),
checkpoint_callback=True,
early_stop_callback=early_stop_callback,
default_save_path=save_dir,
gpus=hparams.gpus,
num_nodes=hparams.num_nodes,
distributed_backend="ddp",
use_amp=True,
log_gpu_memory='all',
max_epochs=hparams.max_epochs,
min_epochs=hparams.min_epochs,
accumulate_grad_batches=hparams.accumulate_grad_batches,
val_percent_check=hparams.val_percent_check,
)
ckpt_path = os.path.join(
trainer.default_save_path,
trainer.logger.name,
f"version_{trainer.logger.version}",
"checkpoints",
)
checkpoint_callback = ModelCheckpoint(
filepath=ckpt_path,
save_top_k=hparams.save_top_k,
verbose=True,
monitor=hparams.monitor,
period=1,
mode=hparams.metric_mode,
)
trainer.checkpoint_callback = checkpoint_callback
trainer.fit(model)
def main(argv):
set_seed(FLAGS.seed)
nlg_tta_checkpoints = list(
sorted(
glob(os.path.join(FLAGS.output_dir, "nlg_tta_*.ckpt"),
recursive=True)))
nlg_tta_model = ChitChat.load_from_checkpoint(
checkpoint_path=nlg_tta_checkpoints[-1])
nlg_tta_model.eval()
nlg_tta_model.freeze()
history = []
while True:
text = input("user: ")
result = predict(nlg_tta_model, text, history)
print(result)
def main(hparams) -> None:
"""
Main training routine specific for this project
:param hparams:
"""
set_seed(hparams.seed)
# ------------------------
# 1 INIT LIGHTNING MODEL AND DATA
# ------------------------
model = Classifier(hparams)
tb_logger = TensorBoardLogger(
save_dir='experiments/',
version="version_" + datetime.now().strftime("%d-%m-%Y--%H-%M-%S"),
name=f'{hparams.encoder_model}',
)
# ------------------------
# 5 INIT TRAINER
# ------------------------
trainer = Trainer(
logger=tb_logger,
gpus=hparams.gpus,
log_gpu_memory="all",
fast_dev_run=hparams.fast_dev_run,
accumulate_grad_batches=hparams.accumulate_grad_batches,
max_epochs=hparams.max_epochs,
default_root_dir=f'./classifier_pipeline/{hparams.encoder_model}',
accelerator='dp'
)
# ------------------------
# 6 START TRAINING
# ------------------------
#datamodule = MedNLIDataModule
trainer.fit(model, model.data)
trainer.test(model, model.data.test_dataloader())
cms = np.array(model.test_conf_matrices)
np.save(f'experiments/{model.hparams.encoder_model}/test_confusion_matrices.npy',cms)
def main(hparams) -> None:
"""
Main training routine specific for this project
:param hparams:
"""
set_seed(hparams.seed)
# ------------------------
# 1 INIT LIGHTNING MODEL
# ------------------------
model = BERTClassifier(hparams)
# ------------------------
# 2 INIT EARLY STOPPING
# ------------------------
early_stop_callback = EarlyStopping(
monitor=hparams.monitor,
min_delta=0.0,
patience=hparams.patience,
verbose=True,
mode=hparams.metric_mode,
)
# ------------------------
# 3 INIT TRAINER
# ------------------------
trainer = Trainer(
logger=setup_testube_logger(),
checkpoint_callback=True,
early_stop_callback=early_stop_callback,
default_save_path="experiments/",
gpus=hparams.gpus,
distributed_backend=hparams.distributed_backend,
use_amp=hparams.use_16bit,
max_epochs=hparams.max_epochs,
min_epochs=hparams.min_epochs,
accumulate_grad_batches=hparams.accumulate_grad_batches,
log_gpu_memory=hparams.log_gpu_memory,
val_percent_check=hparams.val_percent_check,
)
# --------------------------------
# 4 INIT MODEL CHECKPOINT CALLBACK
# -------------------------------
ckpt_path = os.path.join(
trainer.default_save_path,
trainer.logger.name,
f"version_{trainer.logger.version}",
"checkpoints",
)
# initialize Model Checkpoint Saver
checkpoint_callback = ModelCheckpoint(
filepath=ckpt_path,
save_top_k=hparams.save_top_k,
verbose=True,
monitor=hparams.monitor,
period=1,
mode=hparams.metric_mode,
)
trainer.checkpoint_callback = checkpoint_callback
# ------------------------
# 5 START TRAINING
# ------------------------
trainer.fit(model)
def test_set_seed__smoke_test():
set_seed(123)
def main(hparams) -> None:
"""
Main training routine specific for this project
:param hparams:
"""
set_seed(hparams.seed)
# ------------------------
# 1 INIT LIGHTNING MODEL AND DATA
# ------------------------
model = Classifier(hparams)
version = "version_" + datetime.now().strftime("%d-%m-%Y--%H-%M-%S")
name = f'{hparams.encoder_model}'
save_path = 'experiments/' + name + '/' + version
tb_logger = TensorBoardLogger(save_dir='experiments/',
version=version,
name=name)
# # Early stopping
# early_stop = EarlyStopping(
# monitor=hparams.early_stop_metric,
# patience=hparams.early_stop_patience,
# verbose=True,
# mode=hparams.early_stop_mode
# )
# Checkpointing
# hparams.model_save_path = 'experiments/'
# model_save_path = '{}/{}/{}'.format(hparams.model_save_path, hparams.encoder_model, version)
# checkpoint = ModelCheckpoint(
# filepath=model_save_path,
# # save_function=None,
# # save_best_only=True,
# verbose=True,
# monitor=hparams.monitor,
# # mode=hparams.model_save_monitor_mode
# )
# ------------------------
# 5 INIT TRAINER
# ------------------------
# checkpoint_path = '/home/br384/project/clinical-longformer/experiments/allenai/longformer-base-4096/version_16-03-2021--21-15-47/checkpoints/epoch\=9-step\=169.ckpt'
trainer = Trainer(
logger=tb_logger,
gpus=hparams.gpus,
log_gpu_memory="all",
fast_dev_run=hparams.fast_dev_run,
accumulate_grad_batches=hparams.accumulate_grad_batches,
max_epochs=hparams.max_epochs,
# default_root_dir=f'./classifier_pipeline/{hparams.encoder_model}',
accelerator='dp',
profiler="simple",
# checkpoint_callback=checkpoint,
# overfit_batches=0.01,
limit_train_batches=0.3,
limit_val_batches=0.1,
# early_stop_callback=early_stop,
# resume_from_checkpoint=checkpoint_path
)
# ------------------------
# 6 START TRAINING
# ------------------------
#datamodule = MedNLIDataModule
trainer.fit(model, model.data)
trainer.test(model, model.data.test_dataloader())
# cms = np.array(model.test_conf_matrices)
# np.save(f'experiments/{model.hparams.encoder_model}/test_confusion_matrices.npy',cms)
preds = model.test_predictions.detach().cpu()
target = model.test_labels.detach().cpu()
logger.info(classification_report(preds, target))
logger.info(preds)
logger.info(target)
import pandas as pd
decoded_preds = model.mlb.inverse_transform(preds)
decoded_truth = model.mlb.inverse_transform(target)
logger.info(decoded_preds)
logger.info(decoded_truth)
logger.info(classification_report(decoded_preds, decoded_truth))
# out = pd.DataFrame.from_dict({"preds": preds, "truth": target, "decoded_preds": decoded_preds, "decoded_truth": decoded_truth})
out = pd.DataFrame.from_dict({
"decoded_preds": decoded_preds,
"decoded_truth": decoded_truth
})
out.to_csv('model_output.csv')
def main(hparams) -> None:
"""
Main training routine specific for this project
:param hparams:
"""
set_seed(hparams.seed)
# ------------------------
# 1 INIT LIGHTNING MODEL AND DATA
# ------------------------
model = Classifier(hparams)
# ------------------------
# 2 INIT EARLY STOPPING
# ------------------------
early_stop_callback = EarlyStopping(
monitor=hparams.monitor,
min_delta=0.0,
patience=hparams.patience,
verbose=True,
mode=hparams.metric_mode,
)
# ------------------------
# 3 INIT LOGGERS
# ------------------------
# Tensorboard Callback
tb_logger = TensorBoardLogger(
save_dir="experiments/",
version="version_" + datetime.now().strftime("%d-%m-%Y--%H-%M-%S"),
name="",
)
# Model Checkpoint Callback
ckpt_path = os.path.join(
"experiments/", tb_logger.version, "checkpoints",
)
# --------------------------------
# 4 INIT MODEL CHECKPOINT CALLBACK
# -------------------------------
checkpoint_callback = ModelCheckpoint(
filepath=ckpt_path,
save_top_k=hparams.save_top_k,
verbose=True,
monitor=hparams.monitor,
period=1,
mode=hparams.metric_mode,
save_weights_only=True
)
# ------------------------
# 5 INIT TRAINER
# ------------------------
trainer = Trainer(
logger=tb_logger,
checkpoint_callback=True,
early_stop_callback=early_stop_callback,
gradient_clip_val=1.0,
gpus=hparams.gpus,
log_gpu_memory="all",
deterministic=True,
check_val_every_n_epoch=1,
fast_dev_run=False,
accumulate_grad_batches=hparams.accumulate_grad_batches,
max_epochs=hparams.max_epochs,
min_epochs=hparams.min_epochs,
val_check_interval=hparams.val_check_interval,
distributed_backend="dp",
)
# ------------------------
# 6 START TRAINING
# ------------------------
trainer.fit(model, model.data)