def self_training(self, num_epochs, train_data, unlabeled_data):
self.optimizer = get_optimizer(self.config, self.model, 'sgd')
merged_data = train_data
unlabels = unlabeled_data
for epoch in range(num_epochs):
batched_data = batching_list_instances(self.config, merged_data)
epoch_loss = 0
self.model.zero_grad()
for index in tqdm(np.random.permutation(len(batched_data))):
self.model.train()
sequence_loss = self.model(*batched_data[index][0:5],
batched_data[index][-2],
batched_data[index][-3])
loss = sequence_loss
epoch_loss = epoch_loss + loss.data
loss.backward(retain_graph=True)
self.optimizer.step()
self.model.zero_grad()
print(epoch_loss)
self.model.eval()
dev_batches = batching_list_instances(self.config, self.dev)
test_batches = batching_list_instances(self.config, self.test)
dev_metrics = self.evaluate_model_top(dev_batches, "dev", self.dev,
self.triggers)
test_metrics = self.evaluate_model_top(test_batches, "test",
self.test, self.triggers)
self.model.zero_grad()
weaklabel, unlabel = self.weak_label_selftrain(
unlabels, self.triggers)
merged_data = merged_data + weaklabel
unlabels = unlabel
print(len(merged_data), len(weaklabel), len(unlabels))
return self.model
def train_model(self, num_epochs, train_data, eval):
batched_data = batching_list_instances(self.config, train_data)
self.optimizer = get_optimizer(self.config, self.model, 'sgd')
for epoch in range(num_epochs):
epoch_loss = 0
self.model.zero_grad()
for index in tqdm(np.random.permutation(len(batched_data))):
self.model.train()
sequence_loss = self.model(*batched_data[index][0:5],
batched_data[index][-2],
batched_data[index][-3])
loss = sequence_loss
epoch_loss = epoch_loss + loss.data
loss.backward(retain_graph=True)
self.optimizer.step()
self.model.zero_grad()
print(epoch_loss)
if eval:
self.model.eval()
dev_batches = batching_list_instances(self.config, self.dev)
test_batches = batching_list_instances(self.config, self.test)
dev_metrics = self.evaluate_model_top(dev_batches, "dev",
self.dev, self.triggers)
test_metrics = self.evaluate_model_top(test_batches, "test",
self.test,
self.triggers)
self.model.zero_grad()
return self.model
def train_model(self, num_epochs, train_data):
batched_data = batching_list_instances(self.config, train_data)
self.optimizer = get_optimizer(self.config, self.model, 'adam')
criterion = nn.NLLLoss()
for epoch in range(num_epochs):
epoch_loss = 0
self.model.zero_grad()
for index in tqdm(np.random.permutation(len(batched_data))):
self.model.train()
trig_rep, trig_type_probas, match_trig, match_sent = self.model(
*batched_data[index][0:5], batched_data[index][-2])
trigger_loss = criterion(trig_type_probas,
batched_data[index][-1])
soft_matching_loss = self.contrastive_loss(
match_trig, match_sent,
torch.stack([torch.tensor(1)] * trig_rep.size(0) +
[torch.tensor(0)] * trig_rep.size(0)))
loss = trigger_loss + soft_matching_loss
epoch_loss = epoch_loss + loss.data
loss.backward(retain_graph=True)
self.optimizer.step()
self.model.zero_grad()
print(epoch_loss)
self.test_model(train_data)
self.model.zero_grad()
return self.model
def train_procedure(model, config: Config, epoch: int, train_insts: List[Instance], dev_insts: List[Instance], test_insts: List[Instance], devscore=None, testscore=None):
optimizer = get_optimizer(config, model)
random.shuffle(train_insts)
batched_data = batching_list_instances(config, train_insts, is_soft=False, is_naive=True)
dev_batches = batching_list_instances(config, dev_insts)
test_batches = batching_list_instances(config, test_insts)
if devscore is None:
best_dev = [-1, 0]
else:
best_dev = devscore
if testscore is None:
best_test = [-1, 0]
else:
best_test = testscore
for i in range(1, epoch + 1):
epoch_loss = 0
start_time = time.time()
model.zero_grad()
if config.optimizer.lower() == "sgd":
optimizer = lr_decay(config, optimizer, i)
for index in tqdm(np.random.permutation(len(batched_data))):
model.train()
loss = model(*batched_data[index][0:5], batched_data[index][-3])
epoch_loss += loss.item()
loss.backward(retain_graph=True)
optimizer.step()
model.zero_grad()
end_time = time.time()
print("Epoch %d: %.5f, Time is %.2fs" % (i, epoch_loss, end_time - start_time), flush=True)
model.eval()
dev_metrics = evaluate_model(config, model, dev_batches, "dev", dev_insts)
test_metrics = evaluate_model(config, model, test_batches, "test", test_insts)
if dev_metrics[2] > best_dev[0]:
print("saving the best model...")
best_dev[0] = dev_metrics[2]
best_dev[1] = i
best_test[0] = test_metrics[2]
best_test[1] = i
model.zero_grad()
return model, best_dev, best_test
def __init__(self, model, config, dev, test):
"""
:param model:
:param config:
:param dev: List[Instance]
:param test: List[Instance]
"""
self.model = model
self.config = config
self.device = config.device
self.input_size = config.embedding_dim
self.use_char = config.use_char_rnn
self.optimizer = get_optimizer(self.config, self.model,
self.config.optimizer)
if self.use_char:
self.input_size += config.charlstm_hidden_dim
self.dev = dev
self.test = test
def train_model(self,
num_epochs,
train_data,
output_count="",
is_paint=True):
batched_data, batch_insts = batching_list_instances(
self.config, train_data)
size = len(batched_data) // 10
self.optimizer = get_optimizer(self.config, self.model,
self.config.optimizer)
start = time.gmtime()
losses = []
train_precisions = []
train_recalls = []
train_fscores = []
test_precisions = []
test_recalls = []
test_fscores = []
for epoch in range(num_epochs):
epoch_loss = 0
self.model.zero_grad()
print(f"------------------epoch: {(epoch+1)}------------------")
for index in tqdm(np.random.permutation(len(batched_data))):
self.model.train()
sequence_loss = self.model(*batched_data[index][0:5],
batched_data[index][-1],
batch_insts[index])
loss = sequence_loss
if index % size == 0:
losses.append(loss.data)
epoch_loss = epoch_loss + loss.data
loss.backward(retain_graph=True)
self.optimizer.step()
self.model.zero_grad()
print(epoch_loss)
self.model.eval()
# train_batches, train_insts = batching_list_instances(self.config, train_data)
# train_metrics = self.evaluate_model(train_batches, "train", train_data, train_insts)
# train_precisions.append(train_metrics[0])
# train_recalls.append(train_metrics[1])
# train_fscores.append(train_metrics[2])
test_batches, test_insts = batching_list_instances(
self.config, self.test)
test_metrics = self.evaluate_model(test_batches, "test", self.test,
test_insts)
test_precisions.append(test_metrics[0])
test_recalls.append(test_metrics[1])
test_fscores.append(test_metrics[2])
self.model.zero_grad()
end = time.gmtime()
start = time.strftime("%H:%M:%S", start).split(":")
start = [str((int(start[0]) + 8) % 24)] + start[1:]
end = time.strftime("%H:%M:%S", end).split(":")
end = [str((int(end[0]) + 8) % 24)] + end[1:]
print(f"startTime: {start}")
print(f"endTime: {end}")
# print("Train")
# print("precisions", train_precisions)
# print("recalls", train_recalls)
# print("fscores:", train_fscores)
# print("Test")
print("precisions", test_precisions)
print("recalls", test_recalls)
print("fscores:", test_fscores)
x = list(range(1, num_epochs + 1))
x_list = [
i / (len(losses) / num_epochs)
for i in list(range(1,
len(losses) + 1))
]
# for i, v in enumerate(epoch_list):
# if ((i + 1) % train_plt_size) == 0:
# epoch_list[i] = (i // train_plt_size) + 1
if is_paint:
plt.figure()
plt.grid(linestyle="--") # 设置背景网格线为虚线
ax = plt.gca()
ax.spines['top'].set_visible(False) # 去掉上边框
ax.spines['right'].set_visible(False) # 去掉右边框
plt.plot(x,
test_precisions,
marker='o',
color="red",
label="precision",
linewidth=1.5)
plt.plot(x,
test_recalls,
marker='o',
color="green",
label="recall",
linewidth=1.5)
plt.plot(x,
test_fscores,
marker='o',
color="blue",
label="fscore",
linewidth=1.5)
plt.xlabel('epoch')
plt.ylabel('Performance Percentile')
plt.legend(loc=0, numpoints=1)
leg = plt.gca().get_legend()
ltext = leg.get_texts()
plt.setp(ltext, fontsize=12, fontweight='bold') # 设置图例字体的大小和粗细
plt.savefig(
f'per-{self.config.dataset}-{self.config.optimizer}-{num_epochs}-{self.config.learning_rate}-{output_count}.pdf',
format='pdf')
plt.savefig(
f'per-{self.config.dataset}-{self.config.optimizer}-{num_epochs}-{self.config.learning_rate}-{output_count}.svg',
format='svg')
# plt.show()
plt.figure()
plt.grid(linestyle="--") # 设置背景网格线为虚线
ax = plt.gca()
ax.spines['top'].set_visible(False) # 去掉上边框
ax.spines['right'].set_visible(False) # 去掉右边框
plt.plot(x_list, losses)
plt.xlabel('epoch')
plt.ylabel('Train Loss')
plt.legend(loc=0, numpoints=1)
leg = plt.gca().get_legend()
ltext = leg.get_texts()
plt.setp(ltext, fontsize=12, fontweight='bold') # 设置图例字体的大小和粗细
plt.savefig(
f'loss-{self.config.dataset}-{self.config.optimizer}-{num_epochs}-{self.config.learning_rate}-{output_count}.pdf',
format='pdf')
plt.savefig(
f'loss-{self.config.dataset}-{self.config.optimizer}-{num_epochs}-{self.config.learning_rate}-{output_count}.svg',
format='svg')
# plt.show()
else:
plt.figure()
plt.grid(linestyle="--") # 设置背景网格线为虚线
ax = plt.gca()
ax.spines['top'].set_visible(False) # 去掉上边框
ax.spines['right'].set_visible(False) # 去掉右边框
plt.plot(x_list, losses)
plt.xlabel('epoch')
plt.ylabel('Train Loss')
plt.legend(loc=0, numpoints=1)
leg = plt.gca().get_legend()
ltext = leg.get_texts()
plt.setp(ltext, fontsize=12, fontweight='bold') # 设置图例字体的大小和粗细
plt.savefig(
f'loss-{self.config.dataset}-{self.config.optimizer}-{num_epochs}-{self.config.learning_rate}-{output_count}.pdf',
format='pdf')
plt.savefig(
f'loss-{self.config.dataset}-{self.config.optimizer}-{num_epochs}-{self.config.learning_rate}-{output_count}.svg',
format='svg')
return self.model
