def main(args):
dataset_config = Config(args.dataset_config)
model_config = Config(args.model_config)
exp_dir = Path("experiments") / model_config.type
exp_dir = exp_dir.joinpath(
f"epochs_{args.epochs}_batch_size_{args.batch_size}_learning_rate_{args.learning_rate}"
)
tokenizer = get_tokenizer(dataset_config, model_config)
checkpoint_manager = CheckpointManager(exp_dir)
checkpoint = checkpoint_manager.load_checkpoint("best.tar")
model = CharCNN(num_classes=model_config.num_classes,
embedding_dim=model_config.embedding_dim,
vocab=tokenizer.vocab)
model.load_state_dict(checkpoint["model_state_dict"])
summary_manager = SummaryManager(exp_dir)
filepath = getattr(dataset_config, args.data)
ds = Corpus(filepath, tokenizer.split_and_transform)
dl = DataLoader(ds, batch_size=args.batch_size, num_workers=4)
device = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
model.to(device)
summary = evaluate(model, dl, {
"loss": nn.CrossEntropyLoss(),
"acc": acc
}, device)
summary_manager.load("summary.json")
summary_manager.update({f"{args.data}": summary})
summary_manager.save("summary.json")
print(f"loss: {summary['loss']:.3f}, acc: {summary['acc']:.2%}")
def main(args):
dataset_config = Config(args.dataset_config)
model_config = Config(args.model_config)
exp_dir = Path("experiments") / model_config.type
exp_dir = exp_dir.joinpath(
f"epochs_{args.epochs}_batch_size_{args.batch_size}_learning_rate_{args.learning_rate}"
)
preprocessor = get_preprocessor(dataset_config, coarse_split_fn=split_morphs, fine_split_fn=split_jamos)
# model (restore)
checkpoint_manager = CheckpointManager(exp_dir)
checkpoint = checkpoint_manager.load_checkpoint("best.tar")
model = SAN(model_config.num_classes, preprocessor.coarse_vocab, preprocessor.fine_vocab,
model_config.fine_embedding_dim, model_config.hidden_dim, model_config.multi_step,
model_config.prediction_drop_ratio)
model.load_state_dict(checkpoint["model_state_dict"])
# evaluation
filepath = getattr(dataset_config, args.data)
ds = Corpus(filepath, preprocessor.preprocess)
dl = DataLoader(ds, batch_size=args.batch_size, num_workers=4, collate_fn=batchify)
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model.to(device)
summary_manager = SummaryManager(exp_dir)
summary = evaluate(model, dl, {"loss": log_loss, "acc": acc}, device)
summary_manager.load("summary.json")
summary_manager.update({f"{args.data}": summary})
summary_manager.save("summary.json")
print(f"loss: {summary['loss']:.3f}, acc: {summary['acc']:.2%}")
def predict(sentence1, sentence2):
ptr_dir = "C:/Users/aaaaa/workspace/fact-check/BERT_pairwise_text_classification/pretrained"
data_dir = "C:/Users/aaaaa/workspace/fact-check/BERT_pairwise_text_classification/data"
caseType = "skt"
model_dir = "C:/Users/aaaaa/workspace/fact-check/BERT_pairwise_text_classification/experiments/base_model"
checkpoint_model_file = "best_skt.tar"
# ptr_dir = "BERT_pairwise_text_classification/pretrained"
# data_dir = "BERT_pairwise_text_classification/data"
# caseType = "skt"
# model_dir = "BERT_pairwise_text_classification/experiments/base_model"
# checkpoint_model_file = "best_skt.tar"
# ptr_dir = "pretrained"
# data_dir = "data"
# caseType = "skt"
# model_dir = "experiments/base_model"
# checkpoint_model_file = "best_skt.tar"
ptr_dir = Path(ptr_dir)
data_dir = Path(data_dir)
model_dir = Path(model_dir)
checkpoint_model_file = Path(checkpoint_model_file)
ptr_config = Config(ptr_dir / 'config_skt.json')
data_config = Config(data_dir / 'config.json')
model_config = Config(model_dir / 'config.json')
# vocab
with open(os.path.join(ptr_dir, ptr_config.vocab), mode='rb') as io:
vocab = pickle.load(io)
ptr_tokenizer = SentencepieceTokenizer(os.path.join(ptr_dir, ptr_config.tokenizer))
pad_sequence = PadSequence(length=model_config.length, pad_val=vocab.to_indices(vocab.padding_token))
preprocessor = PreProcessor(vocab=vocab, split_fn=ptr_tokenizer, pad_fn=pad_sequence)
# model (restore)
checkpoint_manager = CheckpointManager(model_dir)
checkpoint = checkpoint_manager.load_checkpoint(checkpoint_model_file)
config = BertConfig(os.path.join(ptr_dir, ptr_config.config))
model = PairwiseClassifier(config, num_classes=model_config.num_classes, vocab=preprocessor.vocab)
model.load_state_dict(checkpoint['model_state_dict'])
device = torch.device('cpu')
model.to(device)
transform = preprocessor.preprocess
if model.training:
model.eval()
indices, token_types = [torch.tensor([elm]) for elm in transform(sentence1, sentence2)]
with torch.no_grad():
label = model(indices, token_types)
label = label.max(dim=1)[1]
label = label.numpy()[0]
return label
def main(args):
dataset_config = Config(args.dataset_config)
model_config = Config(args.model_config)
exp_dir = Path("experiments") / model_config.type
exp_dir = exp_dir.joinpath(
f"epochs_{args.epochs}_batch_size_{args.batch_size}_learning_rate_{args.learning_rate}"
f"_teacher_forcing_ratio_{args.teacher_forcing_ratio}")
src_processor, tgt_processor = get_processor(dataset_config)
# model (restore)
encoder = BidiEncoder(src_processor.vocab, model_config.encoder_hidden_dim,
model_config.drop_ratio)
decoder = AttnDecoder(
tgt_processor.vocab,
model_config.method,
model_config.encoder_hidden_dim * 2,
model_config.decoder_hidden_dim,
model_config.drop_ratio,
)
checkpoint_manager = CheckpointManager(exp_dir)
checkpoint = checkpoint_manager.load_checkpoint("best.tar")
encoder.load_state_dict(checkpoint["encoder_state_dict"])
decoder.load_state_dict(checkpoint["decoder_state_dict"])
encoder.eval()
decoder.eval()
# evaluation
summary_manager = SummaryManager(exp_dir)
filepath = getattr(dataset_config, args.data)
ds = NMTCorpus(filepath, src_processor.process, tgt_processor.process)
dl = DataLoader(
ds,
args.batch_size,
shuffle=False,
num_workers=4,
collate_fn=batchify,
drop_last=False,
)
device = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
encoder.to(device)
decoder.to(device)
loss = evaluate(encoder, decoder, tgt_processor.vocab, dl, device)
summary = {"perplexity": np.exp(loss)}
summary_manager.load("summary.json")
summary_manager.update({"{}".format(args.data): summary})
summary_manager.save("summary.json")
print("perplexity: {:.3f}".format(np.exp(loss)))
def main(args):
dataset_config = Config(args.dataset_config)
model_config = Config(args.model_config)
exp_dir = Path("experiments") / model_config.type
exp_dir = exp_dir.joinpath(
f"epochs_{args.epochs}_batch_size_{args.batch_size}_learning_rate_{args.learning_rate}"
)
tokenizer = get_tokenizer(dataset_config)
# model (restore)
checkpoint_manager = CheckpointManager(exp_dir)
checkpoint = checkpoint_manager.load_checkpoint("best.tar")
model = SAN(num_classes=model_config.num_classes,
lstm_hidden_dim=model_config.lstm_hidden_dim,
da=model_config.da,
r=model_config.r,
hidden_dim=model_config.hidden_dim,
vocab=tokenizer.vocab)
model.load_state_dict(checkpoint["model_state_dict"])
# evaluation
filepath = getattr(dataset_config, args.data)
ds = Corpus(filepath, tokenizer.split_and_transform)
dl = DataLoader(ds,
batch_size=args.batch_size,
num_workers=4,
collate_fn=batchify)
device = torch.device(
"cuda") if torch.cuda.is_available() else torch.device("cpu")
model.to(device)
summary_manager = SummaryManager(exp_dir)
summary = evaluate(model, dl, {
"loss": nn.CrossEntropyLoss(),
"acc": acc
}, device)
summary_manager.load("summary.json")
summary_manager.update({f"{args.data}": summary})
summary_manager.save("summary.json")
print("loss: {:.3f}, acc: {:.2%}".format(summary["loss"], summary["acc"]))
def main(args):
dataset_config = Config(args.dataset_config)
model_config = Config(args.model_config)
ptr_config_info = Config(f"conf/pretrained/{model_config.type}.json")
exp_dir = Path("experiments") / model_config.type
exp_dir = exp_dir.joinpath(
f"epochs_{args.epochs}_batch_size_{args.batch_size}_learning_rate_{args.learning_rate}"
f"_weight_decay_{args.weight_decay}")
preprocessor = get_preprocessor(ptr_config_info, model_config)
with open(ptr_config_info.config, mode="r") as io:
ptr_config = json.load(io)
# model (restore)
checkpoint_manager = CheckpointManager(exp_dir)
checkpoint = checkpoint_manager.load_checkpoint('best.tar')
config = BertConfig()
config.update(ptr_config)
model = SentenceClassifier(config,
num_classes=model_config.num_classes,
vocab=preprocessor.vocab)
model.load_state_dict(checkpoint['model_state_dict'])
# evaluation
filepath = getattr(dataset_config, args.data)
ds = Corpus(filepath, preprocessor.preprocess)
dl = DataLoader(ds, batch_size=args.batch_size, num_workers=4)
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
model.to(device)
summary_manager = SummaryManager(exp_dir)
summary = evaluate(model, dl, {
'loss': nn.CrossEntropyLoss(),
'acc': acc
}, device)
summary_manager.load('summary.json')
summary_manager.update({'{}'.format(args.data): summary})
summary_manager.save('summary.json')
print('loss: {:.3f}, acc: {:.2%}'.format(summary['loss'], summary['acc']))
vocab.padding_token))
preprocessor = PreProcessor(vocab=vocab,
split_fn=ptr_tokenizer.tokenize,
pad_fn=pad_sequence)
elif args.type == 'skt':
ptr_tokenizer = SentencepieceTokenizer(ptr_config.tokenizer)
pad_sequence = PadSequence(length=model_config.length,
pad_val=vocab.to_indices(
vocab.padding_token))
preprocessor = PreProcessor(vocab=vocab,
split_fn=ptr_tokenizer,
pad_fn=pad_sequence)
# model (restore)
checkpoint_manager = CheckpointManager(model_dir)
checkpoint = checkpoint_manager.load_checkpoint('best_{}.tar'.format(
args.type))
config = BertConfig(ptr_config.config)
model = PairwiseClassifier(config,
num_classes=model_config.num_classes,
vocab=preprocessor.vocab)
model.load_state_dict(checkpoint['model_state_dict'])
# evaluation
filepath = getattr(data_config, args.dataset)
ds = Corpus(filepath, preprocessor.preprocess)
dl = DataLoader(ds, batch_size=model_config.batch_size, num_workers=4)
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
model.to(device)
model_dir = Path(args.model_dir)
data_config = Config(json_path=data_dir / 'config.json')
model_config = Config(json_path=model_dir / 'config.json')
# tokenizer
with open(data_config.vocab, mode='rb') as io:
vocab = pickle.load(io)
pad_sequence = PadSequence(length=model_config.length,
pad_val=vocab.to_indices(vocab.padding_token))
tokenizer = Tokenizer(vocab=vocab,
split_fn=split_to_jamo,
pad_fn=pad_sequence)
# model (restore)
checkpoint_manager = CheckpointManager(model_dir)
checkpoint = checkpoint_manager.load_checkpoint(args.restore_file + '.tar')
model = CharCNN(num_classes=model_config.num_classes,
embedding_dim=model_config.embedding_dim,
vocab=tokenizer.vocab)
model.load_state_dict(checkpoint['model_state_dict'])
# evaluation
summary_manager = SummaryManager(model_dir)
filepath = getattr(data_config, args.data_name)
ds = Corpus(filepath, tokenizer.split_and_transform)
dl = DataLoader(ds, batch_size=model_config.batch_size, num_workers=4)
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
model.to(device)
if __name__ == "__main__":
args = parser.parse_args()
data_dir = Path(args.data_dir)
model_dir = Path(args.model_dir)
data_config = Config(data_dir / "config.json")
model_config = Config(model_dir / "config.json")
# tokenizer
with open(data_config.vocab, mode="rb") as io:
vocab = pickle.load(io)
tokenizer = Tokenizer(vocab, split_morphs)
# model (restore)
checkpoint_manager = CheckpointManager(model_dir)
checkpoint = checkpoint_manager.load_checkpoint("best.tar")
model = MaLSTM(
num_classes=model_config.num_classes,
hidden_dim=model_config.hidden_dim,
vocab=tokenizer.vocab,
)
model.load_state_dict(checkpoint["model_state_dict"])
# evaluation
filepath = getattr(data_config, args.dataset)
ds = Corpus(filepath, tokenizer.split_and_transform)
dl = DataLoader(ds,
batch_size=model_config.batch_size,
num_workers=4,
collate_fn=batchify)
model_dir = Path(args.model_dir)
data_config = Config(data_dir / 'config.json')
model_config = Config(model_dir / 'config.json')
# tokenizer
with open(data_config.vocab, mode='rb') as io:
vocab = pickle.load(io)
pad_sequence = PadSequence(length=model_config.length,
pad_val=vocab.to_indices(vocab.padding_token))
tokenizer = Tokenizer(vocab=vocab,
split_fn=split_to_jamo,
pad_fn=pad_sequence)
# model (restore)
checkpoint_manager = CheckpointManager(model_dir)
checkpoint = checkpoint_manager.load_checkpoint('best.tar')
model = VDCNN(num_classes=model_config.num_classes,
embedding_dim=model_config.embedding_dim,
k_max=model_config.k_max,
vocab=tokenizer.vocab)
model.load_state_dict(checkpoint['model_state_dict'])
# evaluation
summary_manager = SummaryManager(model_dir)
filepath = getattr(data_config, args.dataset)
ds = Corpus(filepath, tokenizer.split_and_transform)
dl = DataLoader(ds, batch_size=model_config.batch_size, num_workers=4)
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
model.to(device)
kg_test.n_rel)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
if device.type == 'cuda':
print('gpu is available')
torch.cuda.empty_cache()
if torch.cuda.device_count() > 1:
print('multiple gpus are available')
if args.gpu is not None:
model = DataParallel(model, device_ids=args.gpu)
else:
model = DataParallel(model)
checkpoint_manager = CheckpointManager(restore_dir)
ckpt = checkpoint_manager.load_checkpoint(f'best_{args.model}.tar')
model.load_state_dict(ckpt['model_state_dict'])
criterion = MarginLoss(margin)
model.to(device)
criterion.to(device)
sampler = BernoulliNegativeSampler(kg_test)
test_dl = DataLoader(kg_test, batch_size=args.batch_size)
model.eval()
test_loss = 0
for step, batch in tqdm(enumerate(test_dl),
desc='steps',
total=len(test_dl)):
h, t, r = map(lambda elm: elm.to(device), batch)
"params": model.classifier.parameters(),
"lr": model_config.learning_rate
},
],
weight_decay=5e-4)
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
model.to(device)
writer = SummaryWriter('{}/runs_{}'.format(model_dir, args.type))
checkpoint_manager = CheckpointManager(model_dir)
summary_manager = SummaryManager(model_dir)
best_val_loss = 1e+10
checkpoint = checkpoint_manager.load_checkpoint(checkpoint_model_file)
model.load_state_dict(checkpoint['model_state_dict'])
for epoch in tqdm(range(model_config.epochs), desc='epochs'):
tr_loss = 0
tr_acc = 0
model.train()
for step, mb in tqdm(enumerate(tr_dl), desc='steps', total=len(tr_dl)):
x_mb, x_types_mb, y_mb = map(lambda elm: elm.to(device), mb)
opt.zero_grad()
y_hat_mb = model(x_mb, x_types_mb)
mb_loss = loss_fn(y_hat_mb, y_mb)
mb_loss.backward()
opt.step()
ptr_tokenizer = KBertRankedTokenizer(ptr_config.tokenizer,
do_lower_case=False)
else:
ptr_tokenizer = BertTokenizer.from_pretrained(ptr_config.tokenizer,
do_lower_case=False)
print('[BERT TOKENIZER]')
pad_sequence = PadSequence(length=model_config.length,
pad_val=vocab.to_indices(vocab.padding_token))
preprocessor = PreProcessor(vocab=vocab,
split_fn=ptr_tokenizer.tokenize,
pad_fn=pad_sequence,
subchar=args.subchar)
# model (restore)
checkpoint_manager = CheckpointManager(model_dir)
checkpoint = checkpoint_manager.load_checkpoint('best_snu_{}.tar'.format(
args.pretrained_config))
config = BertConfig(ptr_config.config)
model = SentenceClassifier(config,
num_classes=model_config.num_classes,
vocab=preprocessor.vocab)
model.load_state_dict(checkpoint['model_state_dict'])
# evaluation
filepath = getattr(data_config, args.dataset)
ds = Corpus(filepath, preprocessor.preprocess)
dl = DataLoader(ds, batch_size=model_config.batch_size, num_workers=4)
device = torch.device(
'cuda') if torch.cuda.is_available() else torch.device('cpu')
model.to(device)