|
- # -*- coding: utf-8 -*-
- import logging
- import argparse
- import math
- import os
- import sys
- import random
- import numpy
- from losses import SupConLoss
- from sklearn import metrics
- from time import strftime, localtime
- import pandas as pd
-
- from pytorch_pretrained_bert import BertModel
-
- import torch
- import torch.nn as nn
- from torch.utils.data import DataLoader, random_split
-
- from data_utils_bert import build_tokenizer, build_embedding_matrix, Tokenizer4Bert, QADataset
- from models import PURE_BERT,RIA_BERT,RIA_BERT_2,CONTRAST_BERT,LSTM,RIA,IAN,RoomConditional,CONTRAST_BERT_2
- from eval_utils import count_label, cal_prf, cal_acc
- import pickle
-
-
- logger = logging.getLogger()
- logger.setLevel(logging.INFO)
- logger.addHandler(logging.StreamHandler(sys.stdout))
-
- def collate_fn_no_shuffle(batch):
- '''
- :param batch: batch[0] is tensor by defalt
- :return:
- '''
-
- # 当前aspect中的大小
- # 8
- batch_len = len(batch)
-
- return batch,batch_len
-
- class Instructor:
- def __init__(self, opt):
- self.opt = opt
-
- # 如果模型名字有Bert,选用
- if 'bert' in opt.model_name:
-
- print("-----------------启用bert模型-------------------------------------")
- tokenizer = Tokenizer4Bert(opt.max_seq_len, opt.pretrained_bert_name)
- bert = BertModel.from_pretrained(opt.pretrained_bert_name)
- self.model = opt.model_class(bert, opt).to(opt.device)
- print("-----------------加载bert模型成功-------------------------------------")
-
- else:
- print("启用其他模型")
-
- tokenizer = build_tokenizer(
- fnames=[opt.dataset_file['train'], opt.dataset_file['test']],
- max_seq_len=opt.max_seq_len,
- dat_fname='{0}_tokenizer.dat'.format(opt.dataset))
- embedding_matrix = build_embedding_matrix(
- word2idx=tokenizer.word2idx,
- embed_dim=opt.embed_dim,
- dat_fname='{0}_{1}_embedding_matrix.dat'.format(str(opt.embed_dim), opt.dataset))
- self.model = opt.model_class(embedding_matrix, opt).to(opt.device)
-
- # if not os.path.exists("./datasets/opt.dataset"+"_train.csv"):
- # if 1:
- # self.trainset = QADataset(opt.dataset_file['train'], tokenizer)
- # self.testset = QADataset(opt.dataset_file['test'], tokenizer)
- # f = open("./datasets/"+opt.dataset+"_train.csv", 'wb')
- # pickle.dump(self.trainset, f)
- # f.close()
- # f = open("./datasets/"+opt.dataset+"_test.csv", 'wb')
- # pickle.dump(self.testset, f)
- # f.close()
- # else:
- self.trainset = QADataset(opt.dataset_file['train'], tokenizer)
- self.testset = QADataset(opt.dataset_file['test'], tokenizer)
-
- assert 0 <= opt.valset_ratio < 1
- if opt.valset_ratio > 0:
- valset_len = int(len(self.trainset) * opt.valset_ratio)
- self.trainset, self.valset = random_split(self.trainset, (len(self.trainset)-valset_len, valset_len))
- else:
- self.valset = self.testset
-
- if opt.device.type == 'cuda':
- logger.info('cuda memory allocated: {}'.format(torch.cuda.memory_allocated(device=opt.device.index)))
- self._print_args()
-
- if torch.cuda.device_count() > 1:
- self.model = torch.nn.DataParallel(self.model)
-
- def _print_args(self):
- n_trainable_params, n_nontrainable_params = 0, 0
- for p in self.model.parameters():
- n_params = torch.prod(torch.tensor(p.shape))
- if p.requires_grad:
- n_trainable_params += n_params
- else:
- n_nontrainable_params += n_params
- logger.info('> n_trainable_params: {0}, n_nontrainable_params: {1}'.format(n_trainable_params, n_nontrainable_params))
- logger.info('> training arguments:')
- for arg in vars(self.opt):
- logger.info('>>> {0}: {1}'.format(arg, getattr(self.opt, arg)))
-
- def _reset_params(self):
- for child in self.model.children():
- if type(child) != BertModel: # skip bert params
- for p in child.parameters():
- if p.requires_grad:
- if len(p.shape) > 1:
- self.opt.initializer(p)
- else:
- stdv = 1. / math.sqrt(p.shape[0])
- torch.nn.init.uniform_(p, a=-stdv, b=stdv)
-
- # 模型训练
- def _train(self, criterion,contrastiveLoss,criterion_consistency,optimizer, train_data_loader, val_data_loader):
- max_val_acc = 0
- max_val_f1 = 0
- max_val_epoch = 0
- global_step = 0
- path = None
- for i_epoch in range(self.opt.num_epoch):
- logger.info('>' * 100)
- logger.info('epoch: {}'.format(i_epoch))
- n_correct, n_total, loss_total = 0, 0, 0
- # switch models to training mode
- self.model.train()
-
- for i_batch, batch in enumerate(train_data_loader):
- global_step += 1
- # clear gradient accumulators
- optimizer.zero_grad()
-
- # 获得输入
- # inputs = [batch[col].to(self.opt.device) for col in self.opt.inputs_cols]
- inputs = [batch[col].to(self.opt.device) for col in self.opt.inputs_cols if col!='ques' and col!='answ']
-
- # 预测值
- outputs = self.model(inputs)
-
- # 真实值
- targets = batch['label'].to(self.opt.device)
- cllabel = batch['con_label'].to(self.opt.device)
-
- #损失计算
- if self.opt.type=='cl_2x3':
- # 情感交叉赛+一致性对比
- loss1 = criterion(outputs[0], targets)
- loss2 = contrastiveLoss(outputs[1], cllabel)
- loss = loss1.mean() + loss2.mean()
- loss.backward()
- optimizer.step()
- elif self.opt.type=='multi':
- loss1 = criterion(outputs[0], targets)
- loss2 = criterion_consistency(outputs[0], cllabel)
- loss = loss1.mean() + loss2.mean()
- loss.backward()
- optimizer.step()
- elif self.opt.type=='cl_emo2':
- loss1 = criterion(outputs[0], targets)
- loss2 = contrastiveLoss(outputs[1], targets)
- loss = loss1.mean() + loss2.mean()
- loss.backward()
- optimizer.step()
- elif self.opt.type=='cl_emo_con_2x3':
- loss1 = criterion(outputs[0], targets)
- loss2 = contrastiveLoss(outputs[1], targets)
- loss3 = contrastiveLoss(outputs[1], cllabel)
- loss = loss1.mean() + loss2.mean() + loss3.mean()
- loss.backward()
- optimizer.step()
- elif self.opt.type=='normal':
-
- #--------------------------------------------------
- loss = criterion(outputs[0], targets)
- loss = loss.mean()
- loss.backward()
- optimizer.step()
- #---------------------------------------------------
-
-
- #-----------------评估-----------------------------------------------------
- n_correct += (torch.argmax(outputs[0], -1) == targets).sum().item()
- n_total += len(outputs)
-
-
- loss_total += loss.item() * len(outputs)
- if global_step % self.opt.log_step == 0:
- train_acc = n_correct / n_total
- train_loss = loss_total / n_total
-
- if self.opt.type == 'cl_2x3':
- logger.info('loss1: {:.4f},loss2: {:.4f},loss: {:.4f}, acc: {:.4f}'.format(loss1,loss2,train_loss, train_acc))
- elif self.opt.type == 'multi':
- logger.info('loss1: {:.4f},loss2: {:.4f},loss: {:.4f}, acc: {:.4f}'.format(loss1,loss2,train_loss, train_acc))
- elif self.opt.type == 'cl_emo2':
- logger.info('loss1: {:.4f},loss2: {:.4f},loss: {:.4f}, acc: {:.4f}'.format(loss1,loss2,train_loss, train_acc))
- elif self.opt.type=='cl_emo_con_2x3':
- logger.info('loss1: {:.4f},loss2: {:.4f},loss3: {:.4f},loss: {:.4f}, acc: {:.4f}'.format(loss1,loss2,loss3,train_loss, train_acc))
- else:
- logger.info('loss: {:.4f}, acc: {:.4f}'.format(train_loss, train_acc))
-
- val_acc, val_f1,pred,true = self._evaluate_acc_f1(val_data_loader)
- self.model.train()
- logger.info('> val_acc: {:.4f}, val_f1: {:.4f}'.format(val_acc, val_f1))
-
- if val_acc > max_val_acc:
- max_val_acc = val_acc
- max_val_epoch = i_epoch
-
- self.log_prf_single(pred,true, self.opt.model_name)
-
- if not os.path.exists('state_dict'):
- os.mkdir('state_dict')
- # if self.opt.type == 'cl_2x3':
- path = 'state_dict/{0}_{1}_val_acc_{2}_f1_{3}_{4}_{5}_{6}'.format(self.opt.model_name, self.opt.dataset, round(val_acc, 4),round(val_f1, 4),self.opt.lr,self.opt.type,self.opt.seed)
- # else:
- # path = 'state_dict/{0}_{1}_val_acc_{2}_f1_{3}_'.format(self.opt.model_name, self.opt.dataset, round(val_acc, 4),round(val_f1, 4))
-
-
- if max_val_acc>=0.65 and "bert" not in self.opt.model_name:
- torch.save(self.model.state_dict(), path)
- logger.info('>> best_saved: {}'.format(path))
- elif max_val_acc>=0.67 and "bert" in self.opt.model_name:
- torch.save(self.model.state_dict(), path)
- logger.info('>> best_saved: {}'.format(path))
- else:
- logger.info('>> now_saved: {}'.format(path))
- if val_f1 > max_val_f1:
- max_val_f1 = val_f1
- # if i_epoch - max_val_epoch >= self.opt.patience:
- # print('>> early stop.')
- # break
-
- return path
-
- def _evaluate_acc_f1(self, data_loader):
- n_correct, n_total = 0, 0
- t_targets_all, t_outputs_all = None, None
- ques,answ = [],[]
- List_label = []
- # switch models to evaluation mode
- self.model.eval()
-
- f = open("./save_result_test/label_con_stance_consis.txt","w")
-
- with torch.no_grad():
- for i_batch, t_batch in enumerate(data_loader):
-
- t_inputs = [t_batch[col].to(self.opt.device) for col in self.opt.inputs_cols if col!='ques' and col!='answ']
-
- t_targets = t_batch['label'].to(self.opt.device)
- t_outputs = self.model(t_inputs)
-
- n_correct += (torch.argmax(t_outputs[0], -1) == t_targets).sum().item()
- n_total += len(t_outputs[0])
-
- if t_targets_all is None:
- t_targets_all = t_targets
- t_outputs_all = t_outputs[0]
- ques.append(t_batch['ques'])
- answ.append(t_batch['answ'])
- else:
- t_targets_all = torch.cat((t_targets_all, t_targets), dim=0)
- t_outputs_all = torch.cat((t_outputs_all, t_outputs[0]), dim=0)
- ques.append(t_batch['ques'])
- answ.append(t_batch['answ'])
-
- for i in range(self.opt.batch_size):
- try:
- label = torch.argmax(t_outputs[0][i], -1).cpu().data.numpy()
- hiddenState = t_outputs[1][i].cpu().data.numpy().tolist()
- Str = str(label) + "\t" + str(hiddenState) + "\n"
- # Str = str(label) + "\t" + str(hiddenState) + "\n"
- f.write(Str)
- except:
- break
-
- f.close()
- acc = n_correct / n_total
- f1 = metrics.f1_score(t_targets_all.cpu(), torch.argmax(t_outputs_all, -1).cpu(), labels=[0, 1, 2], average='macro')
- # print(acc)
-
- pred = torch.argmax(t_outputs_all, -1).cpu().numpy()
- true = t_targets_all.cpu().numpy()
-
- from tkinter import _flatten # python2.7也可以from compiler.ast import flatten
- ques = _flatten(ques)
- answ = _flatten(answ)
-
- self.log_prf_single(torch.argmax(t_outputs_all, -1).cpu().numpy(),t_targets_all.cpu().numpy(), self.opt.model_name,1,ques,answ)
-
-
- return acc, f1, pred , true
-
- def log_prf_single(self,y_pred, y_true, model_name="RIA",op=0,ques="1",answ="1",data_part="Test"):
- """
- cal prf and macro-f1 for single models
- :param y_true:
- :param y_pred:
- :param model_name:
- :return:
- """
- print("-------------------------------")
- print(model_name, " 模型结果:")
-
- accuracy = cal_acc(y_pred, y_true)
- print("acc:",accuracy)
- # for All kinds of classes
- # 所有类别情况下的结果
- pred, right, gold = count_label(y_pred, y_true, include_class=[0, 1, 2])
-
- if(op==1):
- # -----------------------------------------
- inf_data_pro = []
- #############
- # 预测结果存储
- #############
- # print(y_pred[0])
- import pandas as pd
- from tqdm import tqdm
- for index in tqdm(range(len(y_pred))):
- _it = {}
- _it['index'] = index
- _it['ques'] = ques[index]
- _it['answ'] = answ[index]
- _it['pred'] = y_pred[index]
- _it['true'] = y_true[index]
- #
- inf_data_pro.append(_it)
- #
- inf_data_pro = pd.DataFrame(inf_data_pro)
- inf_data_pro.to_csv(
- "./result/result_a_" + str(self.opt.lr) + "_" + str(self.opt.batch_size) + "_" + str(self.opt.model_name) +str("_mask")+".csv",
- index=0,columns=['index',"ques","answ","true",'pred'])
- # -----------------------------------------
-
- # 计算
- prf_result = cal_prf(pred, right, gold, formation=False)
- # 参数
- p = prf_result['p']
- r = prf_result['r']
- f1 = prf_result['f']
- macro_f1 = prf_result["macro"][-1]
- micro_f1 = prf_result["micro"][-1]
-
- print(" *** Cons|Neu|Pros ***\n ***", pred, right, gold)
- print(" *Accuracy is %d/%d = %f" % (sum(right), sum(gold), accuracy))
- print(" Precision: %s" % p)
- print(" Recall : %s" % r)
- print(" F1 score : %s" % f1)
- print(" Macro F1 score on is %f" % macro_f1)
- print(" Micro F1 score on is %f" % micro_f1)
-
- # for classes of interest
- # 对于支持和反对类别
- pred, right, gold = count_label(y_pred, y_true, include_class=[0, 2])
- prf_result = cal_prf(pred, right, gold, formation=False)
- p = prf_result['p']
- r = prf_result['r']
- f1 = prf_result['f']
- macro_f1 = prf_result["macro"][-1]
- micro_f1 = prf_result["micro"][-1]
-
- print(" *** Cons|Pros ***\n ***", pred, right, gold)
- print(" *Right on test is %d/%d = %f" % (sum(right), sum(gold), sum(right) / sum(gold)))
- print(" Precision: %s" % p)
- print(" Recall : %s" % r)
- print(" F1 score : %s" % f1)
- print(" Macro F1 score on is %f" % macro_f1)
- print(" Micro F1 score on is %f" % micro_f1)
-
- # eval_result = [accuracy, macro_f1, micro_f1]
- eval_result = {
- "accuracy": accuracy,
- "macro_f": macro_f1,
- "micro_f": micro_f1,
- "f_score": f1
- }
-
- def run(self):
- # Loss and Optimizer
- criterion = nn.CrossEntropyLoss()
- criterion_consistency = nn.CrossEntropyLoss()
- contrastiveLoss = SupConLoss()
- _params = filter(lambda p: p.requires_grad, self.model.parameters())
- optimizer = self.opt.optimizer(_params, lr=self.opt.lr, weight_decay=self.opt.l2reg)
-
- train_data_loader = DataLoader(dataset=self.trainset, batch_size=self.opt.batch_size, shuffle=True)
- test_data_loader = DataLoader(dataset=self.testset, batch_size=self.opt.batch_size, shuffle=False)
- val_data_loader = DataLoader(dataset=self.valset, batch_size=self.opt.batch_size, shuffle=False)
-
- self._reset_params()
- best_model_path = self._train(criterion,contrastiveLoss,criterion_consistency, optimizer, train_data_loader, val_data_loader)
- self.model.load_state_dict(torch.load(best_model_path))
- val_acc, val_f1, pred, true = self._evaluate_acc_f1(test_data_loader)
- logger.info('>> test_acc: {:.4f}, test_f1: {:.4f}'.format(val_acc, val_f1))
-
-
- def run_test(self,path):
- # 初始化损失函数和优化器
- criterion = nn.CrossEntropyLoss()
- _params = filter(lambda p: p.requires_grad, self.model.parameters())
- optimizer = self.opt.optimizer(_params, lr=self.opt.lr, weight_decay=self.opt.l2reg)
- test_data_loader = DataLoader(dataset=self.testset, batch_size=self.opt.batch_size, shuffle=False)
-
- # 加载模型并设置成测试模式
- self.model.load_state_dict(
- torch.load(path))
- self.model.eval()
-
- val_acc, val_f1, pred, true = self._evaluate_acc_f1(test_data_loader)
- self.log_prf_single(pred, true, self.opt.model_name)
- logger.info('测试结果:')
- logger.info('>> test_acc: {}, test_f1: {}'.format(val_acc, val_f1))
- logger.info(self.opt.model_name)
-
- def main():
- # Hyper Parameters
- parser = argparse.ArgumentParser()
-
- parser.add_argument('--model_name', default='bert', type=str)# 模型名称
- parser.add_argument('--dataset', default='QAstance', type=str, help='')# 数据集
- parser.add_argument('--optimizer', default='adam', type=str)
- parser.add_argument('--initializer', default='xavier_uniform_', type=str)
- parser.add_argument('--lr', default=5e-5, type=float, help='try 5e-5, 2e-5 for BERT, 1e-3 for others')
- parser.add_argument('--dropout', default=0.1, type=float)
- parser.add_argument('--l2reg', default=0.01, type=float)
- parser.add_argument('--num_epoch', default=20, type=int, help='try larger number for non-BERT models')
- parser.add_argument('--batch_size', default=8, type=int, help='try 16, 32, 64 for BERT models')
- parser.add_argument('--log_step', default=200, type=int)
- parser.add_argument('--embed_dim', default=300, type=int)
- parser.add_argument('--hidden_dim', default=300, type=int)
- parser.add_argument('--bert_dim', default=768, type=int)
- parser.add_argument('--pretrained_bert_name', default='./chinese_L-12_H-768_A-12/', type=str)
- parser.add_argument('--max_seq_len', default=80, type=int)
- parser.add_argument('--polarities_dim', default=3, type=int)
- parser.add_argument('--hops', default=3, type=int)
- parser.add_argument('--is_test', default=0, type=int)
- parser.add_argument('--patience', default=50, type=int)
- parser.add_argument('--desc', default="NoneDesc", type=str)
- parser.add_argument('--type', default="None", type=str)
- parser.add_argument('--device', default=None, type=str, help='e.g. cuda:0')
- parser.add_argument('--seed', default=1234, type=int, help='set seed for reproducibility')
- parser.add_argument('--valset_ratio', default=0, type=float, help='set ratio between 0 and 1 for validation support')
- # The following parameters are only valid for the lcf-bert models
- parser.add_argument('--local_context_focus', default='cdm', type=str, help='local context focus mode, cdw or cdm')
- parser.add_argument('--SRD', default=3, type=int, help='semantic-relative-distance, see the paper of LCF-BERT models')
- # 维度分类
- parser.add_argument('--polarities_dim_classifier', default=4, type=int)
- # 极性维度门
- parser.add_argument('--polarities_dim_gating', default=12, type=int)
- parser.add_argument('--decoder', default="gnn", help='default True')
-
-
- opt = parser.parse_args()
-
- model_classes = {
- 'pure_bert': PURE_BERT,
- 'contrast_bert':CONTRAST_BERT,
- 'lstm':LSTM,
- 'ria_bert':RIA_BERT,
- 'rca':RoomConditional,
- 'ria':RIA,
- 'ian':IAN,
- 'contrast_bert_2':CONTRAST_BERT_2,
- # default hyper-parameters for BERT models is as follws:
- # lr: 2e-5
- # l2: 1e-5
- # batch size: 16
- # num epochs: 5
- }
- dataset_files = {
- 'QAstance_train': {
- 'train': './datasets/QAtrain.csv',
- 'test': './datasets/QAtrain_mask.csv'
- },
- 'QAstance_c':{
- 'train': './datasets/QAstance_train_c.csv',
- 'test': './datasets/QAstance_test_c.csv'
- },
- 'QAstance': {
- 'train': './datasets/QAtrain.csv',
- 'test': './datasets/QAtest.csv'
- },
- 'QAstance_cl_2x3': {
- 'train': './datasets/QA_train_con.csv',
- 'test': './datasets/QAtest.csv'
- },
- 'QAstance_cl_2x3_c': {
- 'train': './datasets/QA_train_con_c.csv',
- 'test': './datasets/QAstance_test_c.csv'
- },
- 'QAstance_case': {
- 'train': './datasets/QAstance_case.csv',
- 'test': './datasets/QAstance_case.csv'
- },
- }
- input_colses = {
- 'pure_bert': ['concat_bert_indices', 'concat_segments_indices'],
- 'contrast_bert': ['concat_bert_indices', 'concat_segments_indices',"ques",'answ'],
- 'contrast_bert_2':['concat_bert_indices', 'concat_segments_indices',"ques",'answ'],
- 'ria_bert': ['ques_bert_indices', 'answ_bert_indices','ques_mask_indices','answ_mask_indices',"ques",'answ'],
- }
- initializers = {
- 'xavier_uniform_': torch.nn.init.xavier_uniform_,
- 'xavier_normal_': torch.nn.init.xavier_normal_,
- 'orthogonal_': torch.nn.init.orthogonal_,
- }
- optimizers = {
- 'adadelta': torch.optim.Adadelta, # default lr=1.0
- 'adagrad': torch.optim.Adagrad, # default lr=0.01
- 'adam': torch.optim.Adam, # default lr=0.001
- 'adamax': torch.optim.Adamax, # default lr=0.002
- 'asgd': torch.optim.ASGD, # default lr=0.01
- 'rmsprop': torch.optim.RMSprop, # default lr=0.01
- 'sgd': torch.optim.SGD,
- }
- opt.model_class = model_classes[opt.model_name]
- opt.dataset_file = dataset_files[opt.dataset]
- opt.inputs_cols = input_colses[opt.model_name]
- opt.initializer = initializers[opt.initializer]
- opt.optimizer = optimizers[opt.optimizer]
- opt.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') \
- if opt.device is None else torch.device(opt.device)
-
- # 模型训练is_test==0
- if opt.is_test==0:
- print("model training phrase ----------*******")
- if not os.path.exists("./log_save_bert"):
- os.mkdir("./log_save_bert")
-
- log_file = 'log_save_bert/' + '{}-{}-{}-{}-{}_{}_test.log'.format(opt.model_name, opt.dataset, opt.type,
- opt.seed, opt.lr,
- strftime("%y%m%d-%H%M", localtime()))
- # log_file = 'log_save_bert/'+'{}-{}-{}-{}.log'.format(opt.model_name, opt.dataset,opt.desc, strftime("%y%m%d-%H%M", localtime()))
- logger.addHandler(logging.FileHandler(log_file))
-
- # 设置随机种子,755
- for seed in range(755,755+1):
- print('\n============固定随机种子===========> seed:', opt.seed, '\n')
- random.seed(opt.seed)
- numpy.random.seed(opt.seed)
- torch.manual_seed(opt.seed)
- torch.cuda.manual_seed(opt.seed)
- torch.backends.cudnn.deterministic = True
- torch.backends.cudnn.benchmark = False
- os.environ['PYTHONHASHSEED'] = str(opt.seed)
-
- # 模型初始化
- ins = Instructor(opt)
- # 模型训练和测试
- ins.run()
- print('#'*30)
-
- # 模型测试is_test==1
- elif opt.is_test==1:
- print("model testing phrase ----------*******")
- if not os.path.exists("./log_save_bert"):
- os.mkdir("./log_save_bert")
-
- log_file = 'log_save_bert/'+'{}-{}-{}-{}-{}_{}_test.log'.format(opt.model_name, opt.dataset,opt.type,opt.seed,opt.lr, strftime("%y%m%d-%H%M", localtime()))
- logger.addHandler(logging.FileHandler(log_file))
-
- for seed in range(755,755+1):
- print('\n============固定随机种子===========> seed:', opt.seed, '\n')
- random.seed(opt.seed)
- numpy.random.seed(opt.seed)
- torch.manual_seed(opt.seed)
- torch.cuda.manual_seed(opt.seed)
- torch.backends.cudnn.deterministic = True
- torch.backends.cudnn.benchmark = False
- os.environ['PYTHONHASHSEED'] = str(opt.seed)
-
- # 模型初始化
- ins = Instructor(opt)
- # 模型训练和测试
-
- # cl_emo2_2x3
- # 主实验
- ins.run_test("./state_dict/contrast_bert_QAstance_cl_2x3_val_acc_0.7083_f1_0.6847_2e-05_cl_emo_con_2x3_1220")
-
-
- #------------------------------------------------------------------------------------------------------------
- # 消融实验--multi
- # ins.run_test("./state_dict/contrast_bert_QAstance_cl_2x3_val_acc_0.6549_f1_0.6588_2e-05_multi_755")
- # 消融实验-去除La(问答一致性对比)
- # ins.run_test("./state_dict/contrast_bert_QAstance_cl_2x3_val_acc_0.6746_f1_0.6412_2e-05_cl_emo2_755")
- # 消融实验-去除l
- # ins.run_test("./state_dict/contrast_bert_QAstance_cl_2x3_val_acc_0.6739_f1_0.6302_1e-05_normal_755")
- #--------------------------------------------------------------------------------------------------------
- # normal
- # ins.run_test("./state_dict/ria_bert_QAstance_cl_2x3_val_acc_0.6736_f1_0.6581_1e-05_normal_755")
- # ins.run_test("./state_dict/contrast_bert_QAstance_cl_2x3_val_acc_0.6512_f1_0.5919_1e-05_normal_755")
- # first_6963
- # ins.run_test("./state_dict/contrast_bert_QAstance_cl_2x3_val_acc_0.6963_f1_0.6688_cl_2x3_")
- # ins.run_test("./state_dict/contrast_bert_QAstance_cl_2x3_val_acc_0.6819_f1_0.6456_cl_2x3_")
- #--------------------------------------------------------------------------------------------------------------
-
- # cl_emo2
- # ins.run_test("./state_dict/contrast_bert_QAstance_cl_2x3_val_acc_0.699_f1_0.6737_2e-05_cl_emo2_1224")
- print('#'*30)
-
-
- # 模型训练
- if __name__ == '__main__':
- os.environ['CUDA_VISIBLE_DEVICES']='0'
- main()
|