def predict(self, seq2seq): predicts = [] ids = [] sentences = [] lengths = [] seq2seq = Seq2seq(self.config, device=self.device, load_emb=True) # gold = [] data = prepare.load_data(self.mode) if mode == 'test': data = prepare.test_process(data) else: data = prepare.process(data) data = data_prepare.Data(data, config.batch_size, config) for batch_i in range(data.batch_number): batch_data = data.next_batch(is_random=False) pred_action_list, _ = self.test_step(batch_data, seq2seq) pred_action_list = pred_action_list.cpu().numpy() sentences.extend(batch_data.sentence_fw) predicts.extend([ pred_action_list[:, i] for i in range(pred_action_list.shape[1]) ]) # print(len(predicts)) ids.extend(batch_data.standard_outputs) lengths.extend(batch_data.input_sentence_length) evaluation.get_result(ids, sentences, lengths, predicts, config) # gold.extend(batch_data.all_triples) # (r_f1, r_precision, r_recall), (e_f1, e_precision, e_recall) = evaluation.rel_entity_compare(predicts, gold, self.config) data.reset()
def __init__(self, config: const.Config, mode: str, device: torch.device) -> None: self.config = config self.device = device self.seq2seq = Seq2seq(config, device=device) data = prepare.load_data(mode) data = prepare.process(data) self.data = data_prepare.Data(data, config.batch_size, config)
def rel_test(self, seq2seq) -> Tuple[Tuple[float, float, float]]: predicts = [] gold = [] loss = 0.0 data = prepare.load_data(self.mode) if mode == 'test': data = prepare.test_process(data) else: data = prepare.process(data) data = data_prepare.Data(data, config.batch_size, config) for batch_i in tqdm(range(data.batch_number)): batch_data = data.next_batch(is_random=False) pred_action_list, pred_logits_list = self.test_step( batch_data, seq2seq) predicts.extend(pred_action_list) gold.extend(batch_data.all_triples) mean_loss = 0.0 if self.config.losstype == 1: ##1.原来################################### for t in range(seq2seq.decoder.decodelen): # print(pred_logits_list[t]) mean_loss = mean_loss + F.nll_loss( pred_logits_list[t], torch.from_numpy(batch_data.standard_outputs).to( self.device).to(torch.long)[:, t]) # print(pred_logits_list[t], # torch.from_numpy(batch_data.standard_outputs).to(self.device).to( # torch.long)[:, t]) # print(torch.from_numpy(batch_data.standard_outputs).to(self.device).to( # torch.long)[:, t],pred_logits_list[t].shape,F.nll_loss(pred_logits_list[t], # torch.from_numpy(batch_data.standard_outputs).to(self.device).to( # torch.long)[:, t]),loss) mean_loss /= pred_logits_list[0].shape[0] if (batch_i < 1000): loss += mean_loss loss /= 1000 f1, precision, recall = evaluation.compare(predicts, gold, self.config, show_rate=None, simple=True) (r_f1, r_precision, r_recall), (e_f1, e_precision, e_recall) = evaluation.rel_entity_compare( predicts, gold, self.config) return loss.item(), (f1, precision, recall), (r_f1, r_precision, r_recall), (e_f1, e_precision, e_recall)
def __init__(self, config: const.Config, device: torch.device) -> None: self.config = config self.device = device self.seq2seq = Seq2seq(config, device=device, load_emb=True) self.loss = nn.NLLLoss() self.optimizer = torch.optim.Adam(self.seq2seq.parameters()) data = prepare.load_data('train') data = prepare.process(data) self.data = data_prepare.Data(data, config.batch_size, config) self.epoch_number = config.epoch_number + 1
def rel_test(self) -> Tuple[Tuple[float, float, float]]: predicts = [] gold = [] data = prepare.load_data(mode) if mode == 'test': data = prepare.test_process(data) else: data = prepare.process(data) data = data_prepare.Data(data, config.batch_size, config) for batch_i in range(data.batch_number): batch_data = data.next_batch(is_random=False) pred_action_list, pred_logits_list = self.test_step(batch_data) pred_action_list = pred_action_list.cpu().numpy() predicts.extend(pred_action_list) gold.extend(batch_data.all_triples) (r_f1, r_precision, r_recall), (e_f1, e_precision, e_recall) = evaluation.rel_entity_compare( predicts, gold, self.config) self.data.reset() return (r_f1, r_precision, r_recall), (e_f1, e_precision, e_recall)
def test(self) -> Tuple[float, float, float]: predicts = [] gold = [] data = prepare.load_data(mode) if mode == 'test': data = prepare.test_process(data) else: data = prepare.process(data) data = data_prepare.Data(data, config.batch_size, config) for batch_i in range(data.batch_number): batch_data = data.next_batch(is_random=False) pred_action_list, pred_logits_list = self.test_step(batch_data) pred_action_list = pred_action_list.cpu().numpy() predicts.extend(pred_action_list) gold.extend(batch_data.all_triples) f1, precision, recall = evaluation.compare(predicts, gold, self.config, show_rate=None, simple=True) data.reset() return f1, precision, recall
def event_test(self, seq2seq) -> Tuple[Tuple[float, float, float]]: predicts = [] gold = [] data = prepare.load_data(self.mode) if mode == 'test': data = prepare.test_process(data) else: data = prepare.process(data) data = data_prepare.Data(data, config.batch_size, config) loss = 0.0 # Loss=nn.NLLLoss() for batch_i in tqdm(range(data.batch_number)): batch_data = data.next_batch(is_random=False) pred_action_list, pred_logits_list = self.test_step( batch_data, seq2seq) pred_action_list = pred_action_list.cpu().numpy() gold.extend(batch_data.standard_outputs) # for i in range() predicts.extend([ pred_action_list[:, i] for i in range(pred_action_list.shape[1]) ]) if decoder_type == 'onecrf': loss += pred_logits_list #crf的时候输出的是loss else: if self.config.losstype == 1: ##1.原来################################### for t in range(seq2seq.decoder.decodelen): # print(pred_logits_list[t]) loss = loss + F.nll_loss( pred_logits_list[t], torch.from_numpy(batch_data.standard_outputs).to( self.device).to(torch.long)[:, t]) elif self.config.losstype == 2: ##2.loss2,排列组合################################### all_events = torch.from_numpy( batch_data.standard_outputs).to(self.device).to( torch.long) all_triples = batch_data.all_triples lengths = batch_data.input_sentence_length # print(pred_logits_list) # print(pred_action_list) for i in range(all_events.shape[0]): # print(all_triples[i]) now_loss = 0. triple_num = min( len(all_triples[i]) // (lengths[i] + 1), self.config.triple_number) # print(pred_action_list[:self.max_sentence_length*triple_num,i].shape) # pred_logits_list_event[:1+triple_num,i] # print(pred_logits_list_entity[:self.max_sentence_length*triple_num,i].shape) for j in range(triple_num): glob = all_events[i, j * (self.max_sentence_length + 1):(j + 1) * (self.max_sentence_length + 1)] # print(glob.shape) for k in range(triple_num): # print(pred_logits_list.shape,pred_logits_list[k*(self.max_sentence_length+1):(k+1)*(self.max_sentence_length+1),i].shape) now_loss += F.nll_loss( pred_logits_list[ k * (self.max_sentence_length + 1):(k + 1) * (self.max_sentence_length + 1), i], glob) if (triple_num != 0): now_loss /= (triple_num * triple_num) # print(pred_logits_list[triple_num*(self.max_sentence_length+1)+1,i],all_events[i,triple_num*(self.max_sentence_length+1)+1]) loss += now_loss + F.nll_loss( pred_logits_list[ triple_num * (self.max_sentence_length + 1):triple_num * (self.max_sentence_length + 1) + 1, i], all_events[i, triple_num * (self.max_sentence_length + 1):triple_num * (self.max_sentence_length + 1) + 1]) # for t in range(seq2seq.decoder.decodelen): # # print(pred_logits_list[t], batch_data.standard_outputs[:, t]) # loss += F.nll_loss(pred_logits_list[t],torch.from_numpy(batch_data.standard_outputs).to(self.device).to(torch.long)[:, t]).item() # print(loss) loss /= batch_i # for g in gold: # for i in range(5): # l=g[i*(config.max_sentence_length+1):(i+1)*(config.max_sentence_length+1)] # if(l[0]>30): # print(l) require_f1, require_precision, require_recall = evaluation.event_entity_yaoqiu_compare( predicts, gold, self.config) f1, precision, recall = evaluation.compare(predicts, gold, self.config, show_rate=None, simple=True) (r_f1, r_precision, r_recall), (e_f1, e_precision, e_recall) = evaluation.rel_entity_compare( predicts, gold, self.config) (event_f1, event_precision, event_recall), (entity_f1, entity_precision, entity_recall) = evaluation.event_entity_compare( predicts, gold, self.config) data.reset() return loss.item(), (require_f1, require_precision, require_recall), ( f1, precision, r_recall), (r_f1, r_precision, r_recall), ( e_f1, e_precision, e_recall), (event_f1, event_precision, event_recall), (entity_f1, entity_precision, entity_recall)
else: print 'illegal dataset name: %s' % config.dataset_name exit() if is_train: if config.train_method == TrainMethod.NLL_METHOD: min_number = 1 if config.train_method == TrainMethod.RL_METHOD: min_number = 1 else: min_number = 1 # this is the min number of triples in a sentence logger.info('Prepare {} data'.format(train_test_valid)) data = prepare.load_data(train_test_valid.lower()) data = prepare.process(data, min_number) data = data_prepare.Data(data, config.batch_size, config) decoder, sess = get_model(train_method=config.train_method, config=config) # decoder, sess = None, None if is_train: if config.train_method == TrainMethod.NLL_METHOD: logger.info('****************************** NLL Train ******************************') train_NLL_model(data, epoch_range=range(1, config.epoch_number + 1), decoder=decoder, sess=sess) if config.train_method == TrainMethod.RL_METHOD: logger.info('%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% RL Train %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%') train_RL_model(data, epoch_range=range(1, config.epoch_number + 1), decoder=decoder, sess=sess) else: logger.info(