import os import re from tqdm import tqdm import torch from transformers import AutoTokenizer, AutoModel, AutoConfig from transformers.generation.logits_process import LogitsProcessor from transformers.generation.utils import LogitsProcessorList from evaluators.evaluator import Evaluator class InvalidScoreLogitsProcessor(LogitsProcessor): def __call__(self, input_ids: torch.LongTensor, scores: torch.FloatTensor) -> torch.FloatTensor: if torch.isnan(scores).any() or torch.isinf(scores).any(): scores.zero_() scores[..., 5] = 5e4 return scores class ChatGLM_Evaluator(Evaluator): def __init__(self, choices, k, model_name, device, finetune=None): super(ChatGLM_Evaluator, self).__init__(choices, model_name, k) # try adding 'mirror="tuna"' and 'resume_download=True' if facing the 'read timed out' problem # or directly clone the model self.tokenizer = AutoTokenizer.from_pretrained("THUDM/chatglm-6b", trust_remote_code=True, mirror="tuna") if finetune: CHECKPOINT_PATH = "ptuning/" + finetune config = AutoConfig.from_pretrained("THUDM/chatglm-6b", trust_remote_code=True, pre_seq_len=128) self.model = AutoModel.from_pretrained("THUDM/chatglm-6b", config=config, trust_remote_code=True) prefix_state_dict = torch.load(os.path.join(CHECKPOINT_PATH, "pytorch_model.bin")) new_prefix_state_dict = {} for k, v in prefix_state_dict.items(): if k.startswith("transformer.prefix_encoder."): new_prefix_state_dict[k[len("transformer.prefix_encoder."):]] = v self.model.transformer.prefix_encoder.load_state_dict(new_prefix_state_dict) self.model = self.model.half().to(device) self.model.transformer.prefix_encoder.float() print("Model loaded! use GLM + " + finetune) else: self.model = AutoModel.from_pretrained("THUDM/chatglm-6b", trust_remote_code=True, mirror="tuna", resume_download=True).half().to(device) print("Model loaded!(GLM)") # self.model = self.model.eval() def eval_subject(self, subject_name, test_df, dev_df=None, few_shot=False, cot=False, save_result_dir=None): correct_num = 0 if save_result_dir: if few_shot: result = [] score = [] answer_list = [] if few_shot: history = self.generate_few_shot_prompt(subject_name, dev_df, cot=cot) else: history = [] answers = list(test_df['answer']) for row_index, row in tqdm(test_df.iterrows(), total=len(test_df)): question = self.format_example(row, include_answer=False, cot=cot) if few_shot: response, _ = self.model.chat(self.tokenizer, question, do_sample=False, history=history) response = response.strip() # For ChatGLM, we use answer extraction in answer-only mode too. ans, direct_extract = self.extract_cot_answer(row, response) else: # zero-shot by extracting answer from distribution ans = self.generate_dist(self.model, self.tokenizer, question, do_sample=False, max_length=2048, history=history) if ans == answers[row_index]: correct_num += 1 correct = 1 else: correct = 0 if save_result_dir: if few_shot: result.append(response) score.append(correct) answer_list.append(ans) correct_ratio = 100 * correct_num / len(answers) if save_result_dir: if few_shot: test_df['model_output'] = result test_df['correctness'] = score test_df['model_answer'] = answer_list result_file_name = f'{subject_name}_{correct_ratio}_test.csv' if few_shot: result_file_name = f'{subject_name}_{correct_ratio}_few_shot_test.csv' test_df.to_csv(os.path.join(save_result_dir, result_file_name)) return correct_ratio def eval_qa(self, subject_name, qa_df, save_result_dir=None): history = [] for row_index, row in tqdm(qa_df.iterrows(), total=len(qa_df)): question = row['question'] response, _ = self.model.chat(self.tokenizer, question, do_sample=False, history=history) response = response.strip() qa_df.loc[row_index, 'model_output'] = response if save_result_dir: result_file_name = f'{subject_name}_qa_test_result.csv' qa_df.to_csv(os.path.join(save_result_dir, result_file_name)) def generate_few_shot_prompt(self, subject, dev_df, cot=False): message = [] k = self.k if self.k == -1: k = dev_df.shape[0] message.append(self.format_example(dev_df.iloc[0, :], cot=cot, add_prompt=f"以下是中国关于{subject}考试的单项选择题，请选出其中的正确答案。\n\n")) for i in range(1, k): message.append(self.format_example(dev_df.iloc[i, :], cot=cot)) return message def format_example(self, line, include_answer=True, cot=False, add_prompt=''): example = add_prompt + line['question'] # print(example) for choice in self.choices: example += f'\n{choice}. {line[f"{choice}"]}' example += '\n答案：' if include_answer: if cot: ans = "让我们一步一步思考，\n" + line["explanation"] + f"\n所以答案是{line['answer']}。" else: ans = line["answer"] m = (example, ans) return m return example def extract_cot_answer(self, line, gen_ans): m = re.findall(r'所以答案是(.+?)。', gen_ans, re.M) if len(m) > 0 and m[-1] in self.choices: return m[-1], True answer_patterns = [ r'([ABCD])是正确的', r'选项([ABCD])正确', r'答案为([ABCD])', r'答案是([ABCD])', r'答案([ABCD])', r'选择([ABCD])', r'答案：([ABCD])', r'选择答案([ABCD])', r'正确答案是([ABCD])' ] # RE extraction for answer_pattern in answer_patterns: m = re.search(answer_pattern, gen_ans, re.M) if m: answer = m.group(1) return answer, False # only containing one choice-character m = re.findall(r'[ABCD]', gen_ans, re.M) if len(m) == 1: answer = m[0] return answer, False answer_word_counter = 0 # only containing one choice-context for c in self.choices: if str(line[f'{c}']) in gen_ans: answer = c answer_word_counter += 1 if answer_word_counter == 1: return answer, False return '-', False def generate_dist(self, model, tokenizer, query, history, num_beams=1, max_length=2048, do_sample=False, top_p=0.7, temperature=0.95, logits_processor=None, **kwargs): if history is None: history = [] if logits_processor is None: logits_processor = LogitsProcessorList() logits_processor.append(InvalidScoreLogitsProcessor()) gen_kwargs = {"num_beams": num_beams, "do_sample": do_sample, "top_p": top_p, "max_length": 2048, "temperature": temperature, "logits_processor": logits_processor, **kwargs} if not history: prompt = query else: prompt = "" for i, (old_query, response) in enumerate(history): prompt += "[Round {}]\n问：{}\n答：{}\n".format(i, old_query, response) prompt += "[Round {}]\n问：{}\n答：".format(len(history), query) inputs = tokenizer([prompt], return_tensors="pt") inputs = inputs.to(model.device) outputs = model.generate(**inputs, return_dict_in_generate=True, output_scores=True, **gen_kwargs) score = outputs.scores[0][0].tolist() choice_score = [score[167], score[333], score[251], score[416]] ranked_index = [index for index, value in sorted(list(enumerate(choice_score)), key=lambda x: x[1], reverse=True)] return self.choices[ranked_index[0]]