def main(): parser = argparse.ArgumentParser() ## Required parameters parser.add_argument("--data_dir", default=None, type=str, required=True, help="The input data dir. Should contain the .tsv files for the task.") parser.add_argument("--model_dir", default=None, type=str, required=True, help="The output directory where the model checkpoints are written.") args = parser.parse_args() # TODO: Fix hardcoded values max_seq_length = 512 bert_model = 'bert-base-cased' do_lower_case = False n_classe = 3 test_file = 'gap-development.tsv' batch_size = 1 # Load a trained model and config that you have fine-tuned config = BertConfig(os.path.join(args.model_dir, CONFIG_NAME)) model = BertForMultipleChoice(config, num_choices=3) model.load_state_dict(torch.load(os.path.join(args.model_dir, WEIGHTS_NAME))) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") model.to(device) tokenizer = BertTokenizer.from_pretrained(bert_model, do_lower_case=do_lower_case) # Prepare test data examples = read_GAP_examples(os.path.join(args.data_dir, test_file), n_classes=n_classes), is_training=False) features = convert_examples_to_features(examples, tokenizer, max_seq_length, True) all_input_ids = torch.tensor(select_field(features, 'input_ids'), dtype=torch.long) all_input_mask = torch.tensor(select_field(features, 'input_mask'), dtype=torch.long) all_segment_ids = torch.tensor(select_field(features, 'segment_ids'), dtype=torch.long) data = TensorDataset(all_input_ids, all_input_mask, all_segment_ids) dataloader = DataLoader(data, sampler=SequentialSampler(data), batch_size=batch_size, shuffle=False)
def get_scores(args, split='test'): if split == 'train': input_file = os.path.join(args.data_dir, args.csvtrain) filescores = os.path.join( args.data_dir, 'PriorScores/priorscores_answers_train.pckl') elif split == 'val': input_file = os.path.join(args.data_dir, args.csvval) filescores = os.path.join(args.data_dir, 'PriorScores/priorscores_answers_val.pckl') elif split == 'test': input_file = os.path.join(args.data_dir, args.csvtest) filescores = os.path.join(args.data_dir, 'PriorScores/priorscores_answers_test.pckl') if os.path.exists(filescores): return # Load Model tokenizer = BertTokenizer.from_pretrained(args.bert_model, do_lower_case=args.do_lower_case) output_model_file = os.path.join(outdir, WEIGHTS_NAME) output_config_file = os.path.join(outdir, CONFIG_NAME) config = BertConfig(output_config_file) model = BertForMultipleChoice(config, num_choices=4) model.load_state_dict(torch.load(output_model_file)) model.to(args.device) n_gpu = torch.cuda.device_count() logger.info("device: {} n_gpu: {}".format(args.device, n_gpu)) if n_gpu > 1: model = torch.nn.DataParallel(model) # Data eval_examples = read_samples(input_file) eval_features = convert_to_features(eval_examples, tokenizer, args.max_seq_length) all_input_ids = torch.tensor(select_field(eval_features, 'input_ids'), dtype=torch.long) all_input_mask = torch.tensor(select_field(eval_features, 'input_mask'), dtype=torch.long) all_segment_ids = torch.tensor(select_field(eval_features, 'segment_ids'), dtype=torch.long) all_labels = torch.tensor([example.label for example in eval_examples], dtype=torch.long) eval_data = TensorDataset(all_input_ids, all_input_mask, all_segment_ids, all_labels) eval_sampler = SequentialSampler(eval_data) eval_dataloader = DataLoader(eval_data, sampler=eval_sampler, batch_size=args.eval_batch_size) # Run prediction logger.info("***** Compute prior scores *****") logger.info("Num examples = %d", len(eval_examples)) logger.info("Batch size = %d", args.eval_batch_size) model.eval() batch_idx = 0 for _, batch in enumerate(tqdm(eval_dataloader, desc="Iteration")): input_ids, input_mask, segment_ids, truelabel = batch input_ids = input_ids.to(args.device) input_mask = input_mask.to(args.device) segment_ids = segment_ids.to(args.device) with torch.no_grad(): logits = model(input_ids, segment_ids, input_mask) logits = nn.functional.softmax(logits) logits = logits.detach().cpu().numpy() if batch_idx == 0: scores = logits else: scores = np.concatenate((scores, logits), axis=0) batch_idx += 1 if not os.path.exists(os.path.dirname(filescores)): os.mkdir(os.path.dirname(filescores)) utils.save_obj(scores, filescores) logger.info('Prior scores for %s saved into %s' % (split, filescores))
def main(config, bert_vocab_file, bert_model_dir): if not os.path.exists(config.output_dir): os.makedirs(config.output_dir) if not os.path.exists(config.cache_dir): os.makedirs(config.cache_dir) output_model_file = os.path.join(config.output_dir, config.weights_name) # 模型输出文件 output_config_file = os.path.join(config.output_dir, config.config_name) # 设备准备 gpu_ids = [int(device_id) for device_id in config.gpu_ids.split()] device, n_gpu = get_device(gpu_ids[0]) if n_gpu > 1: n_gpu = len(gpu_ids) config.train_batch_size = config.train_batch_size // config.gradient_accumulation_steps """ 设定随机种子 """ random.seed(config.seed) np.random.seed(config.seed) torch.manual_seed(config.seed) if n_gpu > 0: torch.cuda.manual_seed_all(config.seed) tokenizer = BertTokenizer.from_pretrained( bert_vocab_file, do_lower_case=config.do_lower_case) label_list = ["0", "1", "2", "3"] if config.do_train: # 数据准备 train_file = os.path.join(config.data_dir, "train.json") dev_file = os.path.join(config.data_dir, "dev.json") train_dataloader, train_len = load_data(train_file, tokenizer, config.max_seq_length, config.train_batch_size) dev_dataloader, dev_len = load_data(dev_file, tokenizer, config.max_seq_length, config.dev_batch_size) num_train_steps = int(train_len / config.train_batch_size / config.gradient_accumulation_steps * config.num_train_epochs) # 模型准备 model = BertForMultipleChoice.from_pretrained( bert_model_dir, cache_dir=config.cache_dir, num_choices=4) model.to(device) if n_gpu > 1: model = torch.nn.DataParallel(model, device_ids=gpu_ids) # 优化器准备 param_optimizer = list(model.named_parameters()) param_optimizer = [n for n in param_optimizer if 'pooler' not in n[0]] no_decay = ['bias', 'LayerNorm.bias', 'LayerNorm.weight'] optimizer_grouped_parameters = [{ 'params': [ p for n, p in param_optimizer if not any(nd in n for nd in no_decay) ], 'weight_decay': 0.01 }, { 'params': [p for n, p in param_optimizer if any(nd in n for nd in no_decay)], 'weight_decay': 0.0 }] optimizer = BertAdam(optimizer_grouped_parameters, lr=config.learning_rate, warmup=config.warmup_proportion, t_total=num_train_steps) criterion = nn.CrossEntropyLoss() criterion = criterion.to(device) train(config.num_train_epochs, n_gpu, train_dataloader, dev_dataloader, model, optimizer, criterion, config.gradient_accumulation_steps, device, label_list, output_model_file, output_config_file, config.log_dir, config.print_step) test_file = os.path.join(config.data_dir, "test.json") test_dataloader, _ = load_data(test_file, tokenizer, config.max_seq_length, config.test_batch_size) bert_config = BertConfig(output_config_file) model = BertForMultipleChoice(bert_config, num_choices=len(label_list)) model.load_state_dict(torch.load(output_model_file)) model.to(device) """ 损失函数准备 """ criterion = nn.CrossEntropyLoss() criterion = criterion.to(device) test_loss, test_acc, test_report = evaluate(model, test_dataloader, criterion, device, label_list) print("-------------- Test -------------") print(f'\t Loss: {test_loss: .3f} | Acc: {test_acc*100: .3f} %') for label in label_list: print('\t {}: Precision: {} | recall: {} | f1 score: {}'.format( label, test_report[label]['precision'], test_report[label]['recall'], test_report[label]['f1-score'])) print_list = ['macro avg', 'weighted avg'] for label in print_list: print('\t {}: Precision: {} | recall: {} | f1 score: {}'.format( label, test_report[label]['precision'], test_report[label]['recall'], test_report[label]['f1-score']))