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