def calc_score():
seed_everything()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Seq2seq().to(device)
model.load(
torch.load('{}/{}_{}.pth'.format(OUTPUT_DIR, FN, CKPT_NUM))['model'])
sp = spm.SentencePieceProcessor()
sp.Load(SP_PATH)
test_data_txt = open(TEST_DATA_TXT_PATH, 'r', encoding='utf8')
with open(TEST_DATA_PKL_PATH, 'rb') as f:
test_data_pkl = pickle.load(f)
dataset = DialogDataset(test_data_pkl)
data_loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
if LOSS == 'SCE':
criterion = SCELoss()
elif LOSS == 'ITF':
criterion = ITFLoss(device, _lambda=LAMBDA)
else:
criterion = INFLoss(device, _lambda=LAMBDA)
count = 0
test_ref, test_hyp = [], []
for line in test_data_txt:
count += 1
if count % 2 != 0:
if LANGUAGE == 'JP':
test_ref.append(
sp.EncodeAsPieces(
evaluate(line, sp, model, device).replace('▁', '')))
else:
test_ref.append(
sp.EncodeAsPieces(
evaluate(line, sp, model, device).replace('▁', ' ')))
else:
if LANGUAGE == 'JP':
test_hyp.append(sp.EncodeAsPieces(line.replace('▁', '')))
else:
test_hyp.append(sp.EncodeAsPieces(line.replace('▁', ' ')))
print("---------- RESULTS ---------")
test_ppl = get_perplexity(model, criterion, data_loader, device)
print("PPL: {}".format(test_ppl))
test_bleu_1 = get_bleu_score(test_ref, test_hyp, 1) * 100
test_bleu_2 = get_bleu_score(test_ref, test_hyp, 2) * 100
print("BLEU-1:{}, 2:{}".format(test_bleu_1, test_bleu_2))
test_rouge_1 = get_rouge_score(test_ref, test_hyp, 1) * 100
test_rouge_2 = get_rouge_score(test_ref, test_hyp, 2) * 100
print("ROUGE-1:{}, 2:{}".format(test_rouge_1, test_rouge_2))
test_dist_1 = get_dist_n(test_ref, 1) * 100
test_dist_2 = get_dist_n(test_ref, 2) * 100
print("DIST-1:{}, 2:{}".format(test_dist_1, test_dist_2))
test_len = get_length(test_ref) / count
print("LENGTH:{}".format(test_len))
seed_everything(Config.seed)
device = torch.device(Config.device)
start_epoch = 0
logging.info('Define Models')
model = build_model(Config).to(device)
tokenizer = Tokenizer.from_pretrained(Config.model_name)
logging.info('Define Loss and Optimizer')
criterion = LabelSmoothing(tokenizer.vocab_size,
pad_id=tokenizer.pad_token_id,
smoothing=Config.smoothing)
_opt = optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9)
optimizer = get_optimizer(_opt, factor=Config.factor, warmup=Config.warmup)
logging.info('Preparing training data')
if Config.use_pickle:
with open(f'{Config.pickle_path}', 'rb') as f:
train_data = pickle.load(f)
else:
train_data = make_train_data_from_txt(Config, tokenizer)
dataset = DialogDataset(train_data, tokenizer)
logging.info('Start Training')
for epoch in range(start_epoch, Config.n_epoch):
one_cycle(epoch, Config, model, optimizer, criterion,
BalancedDataLoader(dataset, tokenizer.pad_token_id),
tokenizer, device)
evaluate(Config, 'もう疲れたー', tokenizer, model, device)
_opt = optim.Adam(model.parameters(), lr=1e-3, betas=(0.9, 0.98), eps=1e-9)
optimizer = get_optimizer(_opt)
if LOAD_MODEL:
logging.info('---------- Load Models ----------')
save_obj = torch.load(f'{OUTPUT_DIR}/{FN}.pth')
model.module.load(save_obj['model'])
optimizer.load(save_obj['opt'], save_obj['param'])
start_epoch = save_obj['epoch']
logging.info('---------- Preparing training data ----------')
with open(TRAIN_DATA_PATH, 'rb') as f:
train_data = pickle.load(f)
with open(TEST_DATA_PKL_PATH, 'rb') as f:
valid_data = pickle.load(f)
train_dataset = DialogDataset(train_data)
valid_dataset = DialogDataset(valid_data)
train_data_loader = DataLoader(train_dataset,
batch_size=BATCH_SIZE,
shuffle=True)
valid_data_loader = DataLoader(valid_dataset,
batch_size=BATCH_SIZE,
shuffle=True)
logging.info('---------- Start Training ----------')
one_cycle(model, optimizer, criterion, train_data_loader,
valid_data_loader, sp, device, start_epoch)
from nn import Seq2SeqModel, LabelSmoothing, get_optimizer
from utils import DialogDataset, train, seed_everything
if __name__ == '__main__':
seed_everything(Config.seed)
start_epoch = 0
model = Seq2SeqModel(bert_model_dir=Config.bert_path).cuda()
sp = spm.SentencePieceProcessor()
sp.Load(Config.sp_path)
criterion = LabelSmoothing(len(sp), pad_id=Config.pad_id, smoothing=Config.smoothing)
_opt = optim.Adam(model.parameters(), lr=0, betas=(0.9, 0.98), eps=1e-9)
optimizer = get_optimizer(_opt, factor=Config.factor, warmup=Config.warmup)
if Config.load:
save_obj = torch.load(f'{Config.output_dir}/{Config.fn}.pth')
model.load(save_obj['model'])
# optimizer.load(save_obj['opt'], save_obj['param'])
# start_epoch = save_obj['epoch']
with open(Config.train_data_path, 'rb') as f:
train_data = pickle.load(f)
dataset = DialogDataset(train_data)
loader = DataLoader(dataset, batch_size=Config.batch_size, shuffle=True)
train(Config, model, optimizer, criterion, loader,
sp, start_epoch)
from train_multitask import train_multitask
from train_lved import train_lved
from test import test
from utils import constant, DialogDataset, make_dialog_data_loader, SentimentDataset, make_sentiment_data_loader
from utils.utils import load_model
# Usage: python main.py --task emotion --data dailydialog --B 64 --full --fasttext --H 300 --D 300 --L 1
if __name__ == "__main__":
fasttext = True if constant.embedding == 'fasttext' else False
if constant.task != 'sentiment':
usr = True if constant.parse == 'user' else False
sys = True if constant.parse == 'system' else False
train_dataset = DialogDataset(mode='train',
dataset=constant.data,
sys=sys,
usr=usr,
path=None,
load_fasttext=fasttext)
train_dataloader = make_dialog_data_loader(train_dataset,
constant.USE_CUDA,
constant.embeddings_cpu,
constant.B,
pad_idx=1,
shuffle=constant.shuffle)
if constant.eval_parse:
usr = True if constant.parse == 'user' else False
sys = True if constant.parse == 'system' else False
else:
usr = False
sys = False
dev_dataset = DialogDataset(mode='dev',
import torch
import torch.nn as nn
from models import RNNEncoder, RNNDecoder, LinearClassifier, Seq2Seq, MultiSeq2Seq
from train_emotion import train_emotion
from train_seq2seq import eval_seq2seq, train_seq2seq
from train_multitask import train_multitask
from test import test
from utils import constant, DialogDataset, make_data_loader, collate_fn
if __name__ == "__main__":
fasttext = True if constant.embedding == 'fasttext' else False
aug = True if constant.parse == 'augment' else False
sld = True if constant.parse == 'sliding' else False
train_dataset = DialogDataset(mode='train', dataset=constant.data, sld=sld, aug=aug, path=None, load_fasttext=fasttext)
dev_dataset = DialogDataset(mode='dev', dataset=constant.data, sld=False, aug=False, path=None, load_fasttext=fasttext)
test_dataset = DialogDataset(mode='test', dataset=constant.data, sld=False, aug=False, path=None, load_fasttext=fasttext)
train_dataloader = make_data_loader(train_dataset, constant.USE_CUDA, constant.embeddings_cpu, constant.B, full=constant.full, sld=sld, aug=aug, pad_idx=1, shuffle=constant.shuffle)
dev_dataloader = make_data_loader(dev_dataset, constant.USE_CUDA, constant.embeddings_cpu, constant.B, full=constant.full, sld=sld, aug=aug, pad_idx=1, shuffle=constant.shuffle)
test_dataloader = make_data_loader(test_dataset, constant.USE_CUDA, constant.embeddings_cpu, constant.B, full=constant.full, sld=sld, aug=aug, pad_idx=1, shuffle=constant.shuffle)
print()
for dialogs, lens, targets, target_lens, emotions in train_dataloader:
print('train')
print("dialogs: ", dialogs.shape)
print("lens: ", lens.shape)
print("targets: ", targets.shape)
print("target_lens: ", target_lens.shape)
print("emotions: ", emotions.shape)
break
def t_test():
seed_everything()
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = Seq2seq().to(device)
model.load(
torch.load('{}/{}_{}.pth'.format(OUTPUT_DIR, FN, CKPT_NUM))['model'])
sp = spm.SentencePieceProcessor()
sp.Load(SP_PATH)
test_data_txt = open(TEST_DATA_TXT_PATH, 'r', encoding='utf8')
with open(TEST_DATA_PKL_PATH, 'rb') as f:
test_data_pkl = pickle.load(f)
dataset = DialogDataset(test_data_pkl)
data_loader = DataLoader(dataset, batch_size=BATCH_SIZE, shuffle=True)
csv_name = './t-test_result_{}_{}_epoch{}.csv'.format(
LOSS, LAMBDA, EPOCH_NUM)
col_name = ["ppl", "bleu_1", "bleu_2", "rouge", "dist_1", "dist_2", "len"]
if LOSS == 'SCE':
criterion = SCELoss()
elif LOSS == 'ITF':
criterion = ITFLoss(device, _lambda=LAMBDA)
else:
criterion = INFLoss(device, _lambda=LAMBDA)
count = 0
convs, test_ref, test_hyp = [], [], []
for line in test_data_txt:
count += 1
if count % 2 != 0:
if LANGUAGE == 'JP':
test_ref.append(
sp.EncodeAsPieces(
evaluate(line, sp, model, device).replace('▁', '')))
else:
test_ref.append(
sp.EncodeAsPieces(
evaluate(line, sp, model, device).replace('▁', ' ')))
else:
if LANGUAGE == 'JP':
test_hyp.append(sp.EncodeAsPieces(line.replace('▁', '')))
else:
test_hyp.append(sp.EncodeAsPieces(line.replace('▁', ' ')))
if count % 256 == 0:
convs.append({
"ppl":
get_perplexity(model, criterion, data_loader, device),
"bleu_1":
get_bleu_score(test_ref, test_hyp, 1) * 100,
"bleu_2":
get_bleu_score(test_ref, test_hyp, 2) * 100,
"rouge":
get_rouge_score(test_ref, test_hyp) * 100,
"dist_1":
get_dist_n(test_ref, 1) * 100,
"dist_2":
get_dist_n(test_ref, 2) * 100,
"len":
get_length(test_ref),
})
test_ref, test_hyp = [], []
try:
with open(csv_name, 'w', newline='',
encoding='utf8') as output_csv:
csv_writer = csv.writer(output_csv)
if count == 256:
csv_writer.writerow(col_name)
for conv in convs:
row_items = [
conv["ppl"], conv["bleu_1"], conv["bleu_2"],
conv["rouge"], conv["dist_1"], conv["dist_2"],
conv["len"]
]
csv_writer.writerow(row_items)
except OSError:
print('---------- OS Error ----------')