def train(self, session):
"""
模型训练函数
:param session:
:return:
"""
training_set = SequenceData(filename=self.conf.training_data, max_seq_len=self.seq_max_len)
for step in range(1, self.conf.training_steps + 1):
batch_x, batch_y, batch_seqlen = training_set.next(self.conf.batch_size)
# Run optimization op (backprop)
session.run(self.optimizer_op,
feed_dict={self.X: batch_x, self.Y: batch_y,
self.seqlen: batch_seqlen,
self.dropout_keep_prob: self.conf.dropout_keep_prob})
if step % self.conf.display_steps == 0 or step == 1:
# Calculate batch accuracy & loss
acc, loss = session.run([self.accuracy_op, self.loss_op],
feed_dict={self.X: batch_x, self.Y: batch_y,
self.seqlen: batch_seqlen,
self.dropout_keep_prob: self.conf.dropout_keep_prob})
print("Step " + str(step) + ", Minibatch Loss= " + \
"{:.6f}".format(loss) + ", Training Accuracy= " + \
"{:.5f}".format(acc))
print("Optimization Finished!")
print('Start to save model.')
saver = tf.train.Saver()
saver.save(session, self.conf.save_model_path)
def test(self, load_model=False):
"""
test
:param load_model:
:return:
"""
if load_model:
print 'Start loading model from "%s"' % self.config.load_model_path
self.model.load_state_dict(torch.load(self.config.load_model_path))
test_set = SequenceData(filename=self.config.test_file, max_seq_len=self.max_seq_len)
with torch.no_grad():
correct = 0
total = 0
features, labels, seqlen, words = test_set.get_all_data()
features = features.to(device)
_, labels = torch.max(labels, 1)
labels = labels.to(device)
seqlen = seqlen.to(device)
outputs, all_outputs = self.model(features, seqlen)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()
print 'Test Accuracy of the model: {} %'.format(100 * correct / total)
def train(self):
"""
train
:return:
"""
print 'Start training model.'
training_set = SequenceData(filename=self.config.training_file, max_seq_len=self.max_seq_len)
for i in range(self.config.training_steps):
batch_x, batch_y, batch_seqlen, batch_words = training_set.next(self.config.batch_size)
batch_x = batch_x.to(device)
_, batch_y = torch.max(batch_y, 1) # 元组第一个维度为最大值，第二个维度为最大值的索引
batch_y = batch_y.to(device)
batch_seqlen = batch_seqlen.to(device)
# Forward pass
outputs, all_outputs = self.model(batch_x, batch_seqlen)
# loss = self.cross_entropy_loss(outputs, batch_y)
loss = self.cross_entropy_loss(outputs, batch_y) + \
self.regularized_loss(all_outputs, batch_seqlen, batch_words)
# loss = self.criterion(outputs, batch_y)
# Backward and optimize
self.optimizer.zero_grad() # 清空梯度缓存
loss.backward() # 反向传播，计算梯度
self.optimizer.step() # 利用梯度更新模型参数
if (i + 1) % 100 == 0:
print 'Step [{}/{}], Loss: {:.4f}'\
.format(i + 1, self.config.training_steps, loss.item())
# Save the model checkpoint
print 'Start saving model to "%s".' % self.config.save_model_path
torch.save(self.model.state_dict(), self.config.save_model_path)
def test(self, session, load_model=False):
"""
测试函数
:param session:
:param load_model: 是否加载模型
:return:
"""
if load_model:
print('Start to load model.')
saver = tf.train.Saver()
saver.restore(session, self.conf.load_model_path)
test_set = SequenceData(filename=self.conf.test_data, max_seq_len=self.seq_max_len)
test_data = test_set.data
test_label = test_set.labels
test_seqlen = test_set.seqlen
print("Testing Accuracy:", \
session.run(self.accuracy_op, feed_dict={self.X: test_data, self.Y: test_label,
self.seqlen: test_seqlen,
self.dropout_keep_prob: 1.0}))
print("Testing PR:")
# 准召结果
y_list = [label.index(1) for label in test_label]
predict_pro = session.run(self.predict_pro_op, feed_dict={self.X: test_data,
self.seqlen: test_seqlen,
self.dropout_keep_prob: 1.0})
y_pre_list = indicator.threshold_judge_by_y_index(pro_list=predict_pro, axis=1, threshold=0.5)
indicator.cal_precision_recall_F1(y_list, y_pre_list)
def predict(self, session, load_model=False):
"""
预测函数
:param session:
:param load_model: 是否加载模型
:return:
"""
if load_model:
print('Start to load model.')
saver = tf.train.Saver()
saver.restore(session, self.conf.load_model_path)
predict_set = SequenceData(filename=self.conf.predict_data,
max_seq_len=self.seq_max_len)
predict_result = session.run(self.predict_op,
feed_dict={
self.X: predict_set.data,
self.seqlen: predict_set.seqlen,
self.dropout_keep_prob: 1.0
})
predict_result_list = []
for predict_index in predict_result:
result = [0] * self.num_class
result[predict_index] = 1
predict_result_list.append(result)
# print("Predict Result:", predict_result)
print("Predict Result:", predict_result_list)
def test(self, session, load_model=False):
"""
@brief: test func
@Args:
session
load_model: whether load model or not
"""
if load_model:
print('Start to load model.')
saver = tf.train.Saver()
saver.restore(session, self.conf.load_model_path)
test_set = SequenceData(filename=self.conf.test_data,
max_seq_len=self.seq_max_len)
test_data = test_set.data
test_label = test_set.labels
test_seqlen = test_set.seqlen
print("Testing Accuracy:", \
session.run(self.accuracy_op, feed_dict={self.X: test_data, self.Y: test_label,
self.seqlen: test_seqlen,
self.dropout_keep_prob: 1.0}))
def test(self, session, load_model=False):
"""
测试函数
:param session:
:param load_model: 是否加载模型
:return:
"""
if load_model:
print('Start to load model.')
saver = tf.train.Saver()
saver.restore(session, self.conf.load_model_path)
test_set = SequenceData(filename=self.conf.test_data,
max_seq_len=self.seq_max_len)
test_data = test_set.data
test_label = test_set.labels
test_seqlen = test_set.seqlen
print("Testing Accuracy:", \
session.run(self.accuracy_op, feed_dict={self.X: test_data, self.Y: test_label,
self.seqlen: test_seqlen,
self.dropout_keep_prob: 1.0}))