# Getting the test data from pytorch
dataset = SNLI(batch_size, device)
out_dim = dataset.out_dim()
vocab_size = dataset.vocabulary_size()
# from google.colab import drive
# drive.mount('/content/gdrive')
# Testing the LSTM model
# Loading the model using the parameters needed
filename = "Models/LSTM/" + '{0}_{1}_{2}_{3}_{4}_{5}_{6}_bidirect.pt'.format(batch_size, embedding_dim, dropout_ratio, hidden_dim, epochs, opt_name, lr)
model = BiLSTM(vocab_size, embedding_dim, dropout_ratio, hidden_dim, out_dim, bidirect)
model.to(device)
model.load_state_dict(torch.load(filename, map_location=torch.device('cpu')))
test_loss, test_accuracy, gt, pred = test(model, dataset)
# print("Test loss = {}, Test accuracy = {}".format(test_loss, test_accuracy))
# Writing the output from LSTM onto a text file
labels = ['entailment', 'contradiction', 'neutral']
with open("LSTM.txt", 'w') as f:
f.write("Loss on Test Data : {}\n".format(test_loss))
f.write("Accuracy on Test Data : {}\n".format(test_accuracy))
f.write("gt_label,pred_label \n")
for idx in range(len(gt)):
f.write("{},{}\n".format(labels[gt[idx]], labels[pred[idx]]))
def main(config):
trainDataPath = config['data']['trainDataPath']
validDataPath = config['data']['validDataPath']
testDataPath = config['data']['testDataPath']
modelName = config['modelName']
batchSize = config['model']['batchSize']
epochNum = config['model']['epochNum']
earlyStop = config['model']['earlyStop']
learningRate = config['model']['learningRate']
modelSavePath = config['model']['modelSavePath']
#GPU/CPU
DEVICE = config['DEVICE']
trianDataset = NERDataset(trainDataPath, config)
validDataset = NERDataset(validDataPath, config)
testDataset = NERDataset(testDataPath, config)
trainIter = data.DataLoader(dataset=trianDataset,
batch_size=batchSize,
shuffle=True,
num_workers=4,
collate_fn=pad)
validIter = data.DataLoader(dataset=validDataset,
batch_size=batchSize,
shuffle=False,
num_workers=4,
collate_fn=pad)
testIter = data.DataLoader(dataset=testDataset,
batch_size=batchSize,
shuffle=False,
num_workers=4,
collate_fn=pad)
if modelName == 'bilstm':
net = BiLSTM(config)
train = bilstmTrain
eval = bilstmEval
if torch.cuda.device_count() > 1:
net = nn.DataParallel(net)
if modelName == 'bilstm_crf':
net = BiLSTM_CRF(config)
train = bilstmCRFTrain
eval = bilstmCRFEval
if modelName == 'transformer_crf':
net = Transformer_CRF(config)
train = transformerCRFTrain
eval = transformerCRFEval
if modelName == 'cnn':
net = CNN(config)
train = cnnTrain
eval = cnnEval
net = net.to(DEVICE)
lossFunction = nn.NLLLoss()
optimizer = optim.Adam(net.parameters(),
lr=learningRate,
betas=(0.9, 0.999),
eps=1e-08)
earlyNumber, beforeLoss, maxScore = 0, sys.maxsize, -1
#开始训练
for epoch in range(epochNum):
print('第%d次迭代: ' % epoch)
totalLoss = train(net,
trainIter,
optimizer=optimizer,
criterion=lossFunction,
DEVICE=DEVICE)
print('训练损失为: %f' % totalLoss)
totalLoss, f1Score = eval(net,
validIter,
criterion=lossFunction,
DEVICE=DEVICE)
if f1Score > maxScore:
maxScore = f1Score
torch.save(net.state_dict(), modelSavePath)
print('验证损失为:%f f1Score:%f / %f' % (totalLoss, f1Score, maxScore))
if f1Score < maxScore:
earlyNumber += 1
print('earyStop: %d/%d' % (earlyNumber, earlyStop))
else:
earlyNumber = 0
if earlyNumber >= earlyStop: break
print('\n')
#加载最优模型
net.load_state_dict(torch.load(modelSavePath))
totalLoss, f1Score = eval(net,
testIter,
criterion=lossFunction,
DEVICE=DEVICE)
print('测试损失为: %f, f1Score: %f' % (totalLoss, f1Score))
def run(dataDir, fold=5):
f = open('./config.yml', encoding='utf-8', errors='ignore')
config = yaml.safe_load(f)
DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
config['DEVICE'] = DEVICE
batchSize = config['model']['batchSize']
optParser = OptionParser()
optParser.add_option('-m',
'--model',
action='store',
type='string',
dest='modelName')
option, args = optParser.parse_args()
modelName = config['modelName'] = option.modelName
#保存最终结果
f = open(os.path.join(dataDir, modelName, 'result.txt'),
'w',
encoding='utf-8',
errors='ignore')
#测试数据
testDataPath = config['data']['testDataPath']
testDataset = NERTestDataset(testDataPath, config)
testIter = data.DataLoader(dataset=testDataset,
batch_size=batchSize,
shuffle=False,
num_workers=4,
collate_fn=testPad)
for i in range(fold):
print('--------------------第%d次验证-------------------\n' % (i + 1))
#验证数据
validDataset = NERDataset(os.path.join(dataDir,
str(i) + '.txt'), config)
validIter = data.DataLoader(dataset=validDataset,
batch_size=batchSize,
shuffle=False,
num_workers=4,
collate_fn=pad)
#训练数据
trainPathArr = [
os.path.join(dataDir,
str(j) + '.txt') for j in range(fold) if j != i
]
assert len(trainPathArr) == fold - 1
trainDataset = NERDataset(trainPathArr, config)
trainIter = data.DataLoader(dataset=trainDataset,
batch_size=batchSize,
shuffle=True,
num_workers=4,
collate_fn=pad)
#加载网络
if modelName == 'bilstm':
net = BiLSTM(config)
if modelName == 'idcnn':
net = IDCNN(config)
if modelName == 'bilstm_attn':
net = BiLSTM_ATTN(config)
if torch.cuda.device_count() > 1:
net = nn.DataParallel(net)
net = net.to(DEVICE)
config['submitPath'] = os.path.join(dataDir, modelName,
str(i) + '.csv')
config['modelSavePath'] = os.path.join(dataDir, modelName,
str(i) + '.pkl')
trainLoss, validLoss, f1Score, accurate, recall = train(
net, trainIter, validIter, config)
#验证集中实际效果
modelSavePath = config['modelSavePath']
if os.path.exists(modelSavePath):
net.load_state_dict(torch.load(modelSavePath))
#未过滤训练集实体的缺失比、过滤完训练集实体的缺失比
disappear1, disappear2 = test(net, testIter, config)
f.write('第%d次验证\n' % (i + 1))
f.write('trainLoss: %f\n' % trainLoss)
f.write('validLoss: %f\n' % validLoss)
f.write('f1Score %f, accurate %f, recall %f\n' %
(f1Score, accurate, recall))
f.write('测试集中缺失比%f %f\n' % (disappear1, disappear2))
f.write('\n')
f.close()
def main(config):
trainDataPath = config['data']['trainDataPath']
validDataPath = config['data']['validDataPath']
testDataPath = config['data']['testDataPath']
batchSize = config['model']['batchSize']
#GPU/CPU
DEVICE = config['DEVICE']
trianDataset = NERDataset(trainDataPath, config)
validDataset = NERDataset(validDataPath, config)
testDataset = NERTestDataset(testDataPath, config)
trainIter = data.DataLoader(dataset=trianDataset,
batch_size=batchSize,
shuffle=True,
num_workers=6,
collate_fn=pad)
validIter = data.DataLoader(dataset=validDataset,
batch_size=batchSize,
shuffle=False,
num_workers=6,
collate_fn=pad)
testIter = data.DataLoader(dataset=testDataset,
batch_size=batchSize,
shuffle=False,
num_workers=6,
collate_fn=testPad)
if config['modelName'] == 'bilstm':
net = BiLSTM(config)
config['modelSavePath'] = config['data']['BiLSTMSavePath']
modelSavePath = config['modelSavePath']
config['submitDataPath'] = config['data']['BiLSTMSubmitDataPath']
train = bilstm_train
test = bilstm_test
if config['modelName'] == 'bilstm_crf':
net = BiLSTM_CRF(config)
config['modelSavePath'] = config['data']['BiLSTMCRFSavePath']
modelSavePath = config['modelSavePath']
config['submitDataPath'] = config['data']['BiLSTMCRFSubmitDataPath']
train = bilstm_crf_train
test = bilstm_crf_test
if config['modelName'] == 'transformer_cnn':
net = Transformer_CNN(config)
config['modelSavePath'] = config['data']['TransformerCNNSavePath']
config['submitDataPath'] = config['data'][
'TransformerCNNSubmitDataPath']
modelSavePath = config['modelSavePath']
train = transformer_cnn_train
test = transformer_cnn_test
if torch.cuda.device_count() > 1:
net = nn.DataParallel(net)
net = net.to(DEVICE)
if os.path.exists(modelSavePath):
net.load_state_dict(torch.load(modelSavePath))
#if config['train']:
#train(net, trainIter, validIter, config)
#if config['test']:
test(net, testIter, config)
result_list = list()
result_list_acc = list()
count = 0
try:
for Ques_train, Ques_test in kf.split(Dataset):
count += 1
print("Fold ", count)
if count == 2:
#writeContentEmbeddings(model)
break
# define model
model = BiLSTM(embedding_dim=EMBEDDING_DIM, hidden_dim=HIDDEN_DIM, vocab_size=len(text_field.vocab), label_size=len(label_field.vocab)-1,\
use_gpu=USE_GPU, batch_size=BATCH_SIZE)
if USE_GPU:
model = model.to(DEVICE)
model.embeddings.weight.data.copy_(
torch.from_numpy(pretrained_embeddings))
optimizer = optim.Adam(model.parameters(), lr=1e-3)
trainset = torch.utils.data.TensorDataset(
torch.LongTensor(Dataset[Ques_train]),
torch.torch.LongTensor(Dataset[Ques_train]))
testset = torch.utils.data.TensorDataset(
torch.LongTensor(Dataset[Ques_test]),
torch.torch.LongTensor(Dataset[Ques_test]))
train_loader = torch.utils.data.DataLoader(dataset=trainset,
batch_size=64)
test_loader = torch.utils.data.DataLoader(dataset=testset,
