|
|
import re |
|
|
import string |
|
|
from collections import Counter |
|
|
from typing import Dict, List |
|
|
|
|
|
import jieba |
|
|
from fuzzywuzzy import fuzz |
|
|
from rouge import Rouge |
|
|
|
|
|
|
|
|
def normalize_answer(s): |
|
|
"""Lower text and remove punctuation, articles and extra whitespace.""" |
|
|
|
|
|
def remove_articles(text): |
|
|
return re.sub(r"\b(a|an|the)\b", " ", text) |
|
|
|
|
|
def white_space_fix(text): |
|
|
return " ".join(text.split()) |
|
|
|
|
|
def remove_punc(text): |
|
|
exclude = set(string.punctuation) |
|
|
return "".join(ch for ch in text if ch not in exclude) |
|
|
|
|
|
def lower(text): |
|
|
return text.lower() |
|
|
|
|
|
return white_space_fix(remove_articles(remove_punc(lower(s)))) |
|
|
|
|
|
def normalize_zh_answer(s): |
|
|
"""Lower text and remove punctuation, extra whitespace.""" |
|
|
|
|
|
def white_space_fix(text): |
|
|
return "".join(text.split()) |
|
|
|
|
|
def remove_punc(text): |
|
|
cn_punctuation = "！？｡。＂＃＄％＆＇（）＊＋，－／：；＜＝＞＠［＼］＾＿｀｛｜｝～｟｠｢｣､、〃》「」『』【】〔〕〖〗〘〙〚〛〜〝〞〟〰〾〿–—‘’‛“”„‟…‧﹏." |
|
|
all_punctuation = set(string.punctuation + cn_punctuation) |
|
|
return "".join(ch for ch in text if ch not in all_punctuation) |
|
|
|
|
|
def lower(text): |
|
|
return text.lower() |
|
|
|
|
|
return white_space_fix(remove_punc(lower(s))) |
|
|
|
|
|
|
|
|
class Metric: |
|
|
@classmethod |
|
|
def compute(cls, predictions: List[str], answers: List[List[str]], metric_list: List[str], **kwargs) -> Dict[str, float]: |
|
|
metric_list = [metric.lower() for metric in metric_list] |
|
|
cls._check_metric_list(metric_list) |
|
|
|
|
|
result = {} |
|
|
for metric in metric_list: |
|
|
total_score = 0 |
|
|
for idx, (prediction, ground_truths) in enumerate(zip(predictions, answers)): |
|
|
score = 0 |
|
|
for ground_truth in ground_truths: |
|
|
score = max(score, getattr(cls, metric)(prediction, ground_truth, all_classes=kwargs["all_classes"][idx])) |
|
|
total_score += score |
|
|
result[metric] = total_score / len(predictions) |
|
|
|
|
|
return result |
|
|
|
|
|
@staticmethod |
|
|
def _check_metric_list(metric_list: List[str]): |
|
|
for metric in metric_list: |
|
|
assert hasattr(Metric, metric), f"Metric {metric} not found" |
|
|
|
|
|
@staticmethod |
|
|
def rouge_score(prediction: str, ground_truth: str, **kwargs) -> float: |
|
|
rouge = Rouge() |
|
|
try: |
|
|
scores = rouge.get_scores([prediction], [ground_truth], avg=True) |
|
|
except: |
|
|
return 0.0 |
|
|
return scores["rouge-l"]["f"] |
|
|
|
|
|
@staticmethod |
|
|
def rouge_zh_score(prediction: str, ground_truth: str, **kwargs) -> float: |
|
|
prediction = " ".join(list(jieba.cut(prediction, cut_all=False))) |
|
|
ground_truth = " ".join(list(jieba.cut(ground_truth, cut_all=False))) |
|
|
score = Metric.rouge_score(prediction, ground_truth) |
|
|
return score |
|
|
|
|
|
@staticmethod |
|
|
def f1_score(prediction: str, ground_truth: str, **kwargs) -> float: |
|
|
common = Counter(prediction) & Counter(ground_truth) |
|
|
num_same = sum(common.values()) |
|
|
if num_same == 0: |
|
|
return 0 |
|
|
precision = 1.0 * num_same / len(prediction) |
|
|
recall = 1.0 * num_same / len(ground_truth) |
|
|
f1 = (2 * precision * recall) / (precision + recall) |
|
|
return f1 |
|
|
|
|
|
@staticmethod |
|
|
def qa_f1_score(prediction: str, ground_truth: str, **kwargs) -> float: |
|
|
normalized_prediction = normalize_answer(prediction) |
|
|
normalized_ground_truth = normalize_answer(ground_truth) |
|
|
|
|
|
prediction_tokens = normalized_prediction.split() |
|
|
ground_truth_tokens = normalized_ground_truth.split() |
|
|
return Metric.f1_score(prediction_tokens, ground_truth_tokens) |
|
|
|
|
|
@staticmethod |
|
|
def qa_f1_zh_score(prediction, ground_truth, **kwargs): |
|
|
prediction_tokens = list(jieba.cut(prediction, cut_all=False)) |
|
|
ground_truth_tokens = list(jieba.cut(ground_truth, cut_all=False)) |
|
|
prediction_tokens = [normalize_zh_answer(token) for token in prediction_tokens] |
|
|
ground_truth_tokens = [normalize_zh_answer(token) for token in ground_truth_tokens] |
|
|
prediction_tokens = [token for token in prediction_tokens if len(token) > 0] |
|
|
ground_truth_tokens = [token for token in ground_truth_tokens if len(token) > 0] |
|
|
return Metric.f1_score(prediction_tokens, ground_truth_tokens) |
|
|
|
|
|
@staticmethod |
|
|
def classification_score(prediction: str, ground_truth: str, **kwargs) -> float: |
|
|
em_match_list = [] |
|
|
all_classes = kwargs["all_classes"] |
|
|
for class_name in all_classes: |
|
|
if class_name in prediction: |
|
|
em_match_list.append(class_name) |
|
|
for match_term in em_match_list: |
|
|
if match_term in ground_truth and match_term != ground_truth: |
|
|
em_match_list.remove(match_term) |
|
|
if ground_truth in em_match_list: |
|
|
score = (1.0 / len(em_match_list)) |
|
|
else: |
|
|
score = 0.0 |
|
|
return score |
|
|
|
|
|
@staticmethod |
|
|
def retrieval_score(prediction: str, ground_truth: str, **kwargs) -> float: |
|
|
pattern = r'Paragraph (\d+)' |
|
|
matches = re.findall(pattern, ground_truth) |
|
|
ground_truth_id = matches[0] |
|
|
numbers = re.findall(r"\d+", prediction) |
|
|
right_num = 0 |
|
|
for number in numbers: |
|
|
if str(number) == str(ground_truth_id): |
|
|
right_num += 1 |
|
|
final_score = 0.0 if len(numbers) == 0 else right_num / len(numbers) |
|
|
return float(final_score) |
|
|
|
|
|
@staticmethod |
|
|
def retrieval_zh_score(prediction: str, ground_truth: str, **kwargs) -> float: |
|
|
pattern = r'段落(\d+)' |
|
|
matches = re.findall(pattern, ground_truth) |
|
|
ground_truth_id = matches[0] |
|
|
numbers = re.findall(r"\d+", prediction) |
|
|
right_num = 0 |
|
|
for number in numbers: |
|
|
if str(number) == str(ground_truth_id): |
|
|
right_num += 1 |
|
|
final_score = 0.0 if len(numbers) == 0 else right_num / len(numbers) |
|
|
return float(final_score) |
|
|
|
|
|
@staticmethod |
|
|
def count_score(prediction: str, ground_truth: str, **kwargs) -> float: |
|
|
numbers = re.findall(r"\d+", prediction) |
|
|
right_num = 0 |
|
|
for number in numbers: |
|
|
if str(number) == str(ground_truth): |
|
|
right_num += 1 |
|
|
final_score = 0.0 if len(numbers) == 0 else right_num / len(numbers) |
|
|
return float(final_score) |
|
|
|
|
|
@staticmethod |
|
|
def code_edit_sim(prediction: str, ground_truth: str, **kwargs) -> float: |
|
|
all_lines = prediction.lstrip('\n').split('\n') |
|
|
prediction = "" |
|
|
for line in all_lines: |
|
|
if ('`' not in line) and ('#' not in line) and ('//' not in line): |
|
|
prediction = line |
|
|
break |
|
|
return (fuzz.ratio(prediction, ground_truth) / 100) |
