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