def train(self, train_file, dev_file, test_file):
self.hyperParams.show()
torch.set_num_threads(self.hyperParams.thread)
reader = Reader(self.hyperParams.maxInstance)
trainInsts = reader.readInstances(train_file)
devInsts = reader.readInstances(dev_file)
testInsts = reader.readInstances(test_file)
print("Training Instance: ", len(trainInsts))
print("Dev Instance: ", len(devInsts))
print("Test Instance: ", len(testInsts))
self.createAlphabet(trainInsts, devInsts, testInsts)
trainExamples = self.instance2Example(trainInsts)
devExamples = self.instance2Example(devInsts)
testExamples = self.instance2Example(testInsts)
self.model = RNNLabeler(self.hyperParams)
parameters = filter(lambda p: p.requires_grad, self.model.parameters())
optimizer = torch.optim.Adagrad(parameters,
lr=self.hyperParams.learningRate)
indexes = []
for idx in range(len(trainExamples)):
indexes.append(idx)
for iter in range(self.hyperParams.maxIter):
print('###Iteration' + str(iter) + "###")
random.shuffle(indexes)
for idx in range(len(trainExamples)):
self.model.zero_grad()
self.model.LSTMHidden = self.model.init_hidden()
exam = trainExamples[indexes[idx]]
lstm_feats = self.model(exam.feat)
loss = self.model.crf.neg_log_likelihood(
lstm_feats, exam.labelIndexs)
loss.backward()
optimizer.step()
if (idx + 1) % self.hyperParams.verboseIter == 0:
print('current: ', idx + 1, ", cost:", loss.data[0])
eval_dev = Eval()
for idx in range(len(devExamples)):
predictLabels = self.predict(devExamples[idx])
devInsts[idx].evalPRF(predictLabels, eval_dev)
print('Dev: ', end="")
eval_dev.getFscore()
eval_test = Eval()
for idx in range(len(testExamples)):
predictLabels = self.predict(testExamples[idx])
testInsts[idx].evalPRF(predictLabels, eval_test)
print('Test: ', end="")
eval_test.getFscore()
def test(self, test_file, model_file):
self.loadModel(model_file)
reader = Reader()
testInsts = reader.readInstances(test_file, self.hyperParams.maxInstance)
testExamples = self.instance2Example(testInsts)
for idx in range(len(testExamples)):
self.predict(testExamples[idx])
def train(self, train_file, dev_file, test_file):
self.hyperParams.show()
torch.set_num_threads(self.hyperParams.thread)
reader = Reader(self.hyperParams.maxInstance)
trainInsts = reader.readInstances(train_file)
devInsts = reader.readInstances(dev_file)
trainExamples = self.instance2Example(trainInsts)
devExamples = self.instance2Example(devInsts)
print("Training Instance: ", len(trainInsts))
print("Dev Instance: ", len(devInsts))
self.createAlphabet(trainInsts)
self.model = RNNLabeler(self.hyperParams)
optimizer = torch.optim.Adagrad(self.model.parameters(),
lr=self.hyperParams.learningRate)
indexes = []
for idx in range(len(trainExamples)):
indexes.append(idx)
for iter in range(self.hyperParams.maxIter):
print('###Iteration' + str(iter) + "###")
random.shuffle(indexes)
for idx in range(len(trainExamples)):
self.model.zero_grad()
self.model.LSTMHidden = self.model.init_hidden()
exam = trainExamples[indexes[idx]]
tag_scores = self.model(exam.feat)
loss = torch.nn.functional.cross_entropy(
tag_scores, exam.labelIndexs)
loss.backward()
optimizer.step()
if (idx + 1) % self.hyperParams.verboseIter == 0:
print('current: ', idx + 1, ", cost:", loss.data[0])
eval_dev = Eval()
for idx in range(len(devExamples)):
predictLabels = self.predict(devExamples[idx])
devInsts[idx].evalPRF(predictLabels, eval_dev)
eval_dev.getFscore()
def train(self, train_file, dev_file, test_file):
self.hyperParams.show()
torch.set_num_threads(self.hyperParams.thread)
reader = Reader()
trainInsts = reader.readInstances(train_file, self.hyperParams.maxInstance)
devInsts = reader.readInstances(dev_file, self.hyperParams.maxInstance)
testInsts = reader.readInstances(test_file, self.hyperParams.maxInstance)
print("Training Instance: ", len(trainInsts))
print("Dev Instance: ", len(devInsts))
print("Test Instance: ", len(testInsts))
self.createAlphabet(trainInsts, devInsts, testInsts)
trainExamples = self.instance2Example(trainInsts)
devExamples = self.instance2Example(devInsts)
testExamples = self.instance2Example(testInsts)
self.model = RNNLabeler(self.hyperParams)
parameters = filter(lambda p: p.requires_grad, self.model.parameters())
optimizer = torch.optim.Adam(parameters, lr=self.hyperParams.learningRate)
indexes = []
for idx in range(len(trainExamples)):
indexes.append(idx)
batchBlock = len(trainExamples) // self.hyperParams.batch
for iter in range(self.hyperParams.maxIter):
print('###Iteration' + str(iter) + "###")
random.shuffle(indexes)
self.model.train()
for updateIter in range(batchBlock):
#self.model.zero_grad()
optimizer.zero_grad()
exams = []
start_pos = updateIter * self.hyperParams.batch
end_pos = (updateIter + 1) * self.hyperParams.batch
for idx in range(start_pos, end_pos):
exams.append(trainExamples[indexes[idx]])
feats, labels = self.getBatchFeatLabel(exams)
output = self.model(feats, self.hyperParams.batch)
loss = torch.nn.functional.cross_entropy(output, labels)
loss.backward()
optimizer.step()
if (updateIter + 1) % self.hyperParams.verboseIter == 0:
print('current: ', idx + 1, ", cost:", loss.data[0])
self.model.eval()
eval_dev = Eval()
for idx in range(len(devExamples)):
predictLabel = self.predict(devExamples[idx])
devInsts[idx].evalACC(predictLabel, eval_dev)
print("dev: ", end='')
eval_dev.getACC()
eval_test = Eval()
for idx in range(len(testExamples)):
predictLabel = self.predict(testExamples[idx])
testInsts[idx].evalACC(predictLabel, eval_test)
print("test: ", end='')
eval_test.getACC()
def train(self, train_file, dev_file, test_file, model_file):
self.hyperParams.show()
torch.set_num_threads(self.hyperParams.thread)
reader = Reader()
trainInsts = reader.readInstances(train_file, self.hyperParams.maxInstance)
devInsts = reader.readInstances(dev_file, self.hyperParams.maxInstance)
testInsts = reader.readInstances(test_file, self.hyperParams.maxInstance)
print("Training Instance: ", len(trainInsts))
print("Dev Instance: ", len(devInsts))
print("Test Instance: ", len(testInsts))
self.createAlphabet(trainInsts, devInsts, testInsts)
trainExamples = self.instance2Example(trainInsts)
devExamples = self.instance2Example(devInsts)
testExamples = self.instance2Example(testInsts)
self.encoder = Encoder(self.hyperParams)
self.decoder = Decoder(self.hyperParams)
indexes = []
for idx in range(len(trainExamples)):
indexes.append(idx)
encoder_parameters = filter(lambda p: p.requires_grad, self.encoder.parameters())
encoder_optimizer = torch.optim.Adam(encoder_parameters, lr = self.hyperParams.learningRate)
decoder_parameters = filter(lambda p: p.requires_grad, self.decoder.parameters())
decoder_optimizer = torch.optim.Adam(decoder_parameters, lr = self.hyperParams.learningRate)
train_num = len(trainExamples)
batchBlock = train_num // self.hyperParams.batch
if train_num % self.hyperParams.batch != 0:
batchBlock += 1
for iter in range(self.hyperParams.maxIter):
print('###Iteration' + str(iter) + "###")
random.shuffle(indexes)
self.encoder.train()
self.decoder.train()
train_eval = Eval()
for updateIter in range(batchBlock):
exams = []
start_pos = updateIter * self.hyperParams.batch
end_pos = (updateIter + 1) * self.hyperParams.batch
if end_pos > train_num:
end_pos = train_num
for idx in range(start_pos, end_pos):
exams.append(trainExamples[indexes[idx]])
batchCharFeats, batchBiCharFeats, batchLabel, batch, maxSentSize = self.getBatchFeatLabel(exams)
encoder_optimizer.zero_grad()
decoder_optimizer.zero_grad()
encoderHidden = self.encoder.init_hidden(batch)
encoderOutput, encoderHidden = self.encoder(batchCharFeats, batchBiCharFeats, encoderHidden)
loss = 0
decoderOutput = self.decoder(batch, encoderOutput, exams, bTrain=True)
for idx in range(batch):
exam = exams[idx]
for idy in range(exam.size):
labelID = getMaxIndex(self.hyperParams, decoderOutput[idx * maxSentSize + idy])
if labelID == exam.labelIndexes[idy]:
train_eval.correct_num += 1
train_eval.gold_num += 1
loss += torch.nn.functional.nll_loss(decoderOutput, batchLabel)
loss.backward()
if (updateIter + 1) % self.hyperParams.verboseIter == 0:
print('Current: ', updateIter + 1, ", Cost:", loss.data[0], ", ACC:", train_eval.acc())
encoder_optimizer.step()
decoder_optimizer.step()
self.encoder.eval()
self.decoder.eval()
dev_eval = Eval()
for idx in range(len(devExamples)):
exam = devExamples[idx]
predict_labels = self.predict(exam)
devInsts[idx].evalPRF(predict_labels, dev_eval)
p, r, f = dev_eval.getFscore()
print("precision: ", p, ", recall: ", r, ", fscore: ", f)
test_eval = Eval()
for idx in range(len(testExamples)):
exam = testExamples[idx]
predict_labels = self.predict(exam)
testInsts[idx].evalPRF(predict_labels, test_eval)
p, r, f = test_eval.getFscore()
print("precision: ", p, ", recall: ", r, ", fscore: ", f)
'''
def train(self, train_file, dev_file, test_file, model_file):
self.hyperParams.show()
torch.set_num_threads(self.hyperParams.thread)
reader = Reader()
trainInsts = reader.readInstances(train_file,
self.hyperParams.maxInstance)
devInsts = reader.readInstances(dev_file, self.hyperParams.maxInstance)
testInsts = reader.readInstances(test_file,
self.hyperParams.maxInstance)
print("Training Instance: ", len(trainInsts))
print("Dev Instance: ", len(devInsts))
print("Test Instance: ", len(testInsts))
self.createAlphabet(trainInsts)
trainExamples = self.instance2Example(trainInsts)
devExamples = self.instance2Example(devInsts)
testExamples = self.instance2Example(testInsts)
self.encoder = Encoder(self.hyperParams)
self.decoder = Decoder(self.hyperParams)
indexes = []
for idx in range(len(trainExamples)):
indexes.append(idx)
encoder_parameters = filter(lambda p: p.requires_grad,
self.encoder.parameters())
encoder_optimizer = torch.optim.Adam(encoder_parameters,
lr=self.hyperParams.learningRate)
decoder_parameters = filter(lambda p: p.requires_grad,
self.decoder.parameters())
decoder_optimizer = torch.optim.Adam(decoder_parameters,
lr=self.hyperParams.learningRate)
batchBlock = len(trainExamples) // self.hyperParams.batch
for iter in range(self.hyperParams.maxIter):
print('###Iteration' + str(iter) + "###")
random.shuffle(indexes)
self.encoder.train()
self.decoder.train()
for updateIter in range(batchBlock):
exams = []
start_pos = updateIter * self.hyperParams.batch
end_pos = (updateIter + 1) * self.hyperParams.batch
for idx in range(start_pos, end_pos):
exams.append(trainExamples[indexes[idx]])
postFeats, responseFeats = self.getBatchFeatLabel(exams)
encoder_optimizer.zero_grad()
decoder_optimizer.zero_grad()
encoder_hidden = self.encoder.init_hidden(
self.hyperParams.batch)
encoder_output, encoder_hidden = self.encoder(
postFeats, encoder_hidden)
decoder_hidden = self.decoder.initHidden(
self.hyperParams.batch)
response_len = responseFeats.size()[1]
last_word = torch.autograd.Variable(
torch.LongTensor(1, self.hyperParams.batch))
for idx in range(self.hyperParams.batch):
last_word.data[0][idx] = self.hyperParams.responseStartID
loss = 0
for idx in range(response_len):
decoder_output, decoder_hidden = self.decoder(
encoder_hidden, decoder_hidden, last_word)
loss += torch.nn.functional.nll_loss(
decoder_output,
responseFeats.permute(1, 0)[idx])
for idy in range(self.hyperParams.batch):
last_word.data[0][idy] = self.getMaxIndex(
decoder_output[idy])
loss.backward()
print('Current: ', updateIter + 1, ", Cost:", loss.data[0])
encoder_optimizer.step()
decoder_optimizer.step()
if iter + 1 % 10 == 0:
self.encoder.eval()
self.decoder.eval()
print("Save model .....")
self.saveModel(model_file + str(iter))
print("Model model ok")
