|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
import re |
|
|
|
class RougeRaw: |
|
"""Compute RougeRAW-1, RougeRAW-2, RougeRAW-L metrics.""" |
|
|
|
class FScore: |
|
"""F1 score representation.""" |
|
def __init__(self, correct, gold, system): |
|
self.p = correct / system if system else 0. |
|
self.r = correct / gold if gold else 0. |
|
self.f = 2 * correct / (system + gold) if system + gold else 0. |
|
|
|
def _rouge_n(self, n, gold_words, system_words): |
|
"""Compute Rouge-n for given words.""" |
|
def n_grams(n, words): |
|
ngrams = {} |
|
total = 0 |
|
for i in range(len(words) - n + 1): |
|
ngram = "\t".join(words[i:i + n]) |
|
ngrams[ngram] = 1 + ngrams.get(ngram, 0) |
|
total += 1 |
|
return ngrams, total |
|
|
|
gold_ngrams, gold_total = n_grams(n, gold_words) |
|
system_ngrams, system_total = n_grams(n, system_words) |
|
|
|
intersection = 0 |
|
for ngram in system_ngrams: |
|
intersection += min(system_ngrams[ngram], gold_ngrams.get(ngram, 0)) |
|
|
|
return self.FScore(intersection, gold_total, system_total) |
|
|
|
def _rouge_l(self, gold_words, system_words): |
|
"""Compute Rouge-L for given words.""" |
|
lcs = [[0] * len(system_words) for _ in gold_words] |
|
for r in range(len(gold_words)): |
|
for s in range(len(system_words)): |
|
if gold_words[r] == system_words[s]: |
|
lcs[r][s] = 1 + (lcs[r - 1][s - 1] if r and s else 0) |
|
lcs[r][s] = max(lcs[r][s], lcs[r - 1][s] if r else 0) |
|
lcs[r][s] = max(lcs[r][s], lcs[r][s - 1] if s else 0) |
|
|
|
return self.FScore(lcs[-1][-1], len(gold_words), len(system_words)) |
|
|
|
def _tokenize(self, text): |
|
"""Tokenize given text.""" |
|
return re.sub(r"\s+", " ", re.sub(r"\b", " ", text, re.UNICODE), re.UNICODE).strip().split(" ") |
|
|
|
def document(self, gold, system): |
|
"""Compute RougeRAW-1, RougeRAW-2, RougeRAW-L for given documents. |
|
|
|
Each document should be a string. |
|
""" |
|
|
|
assert isinstance(gold, str) and isinstance(system, str), "Expected string arguments" |
|
|
|
lc_gold_words = [word.lower() for word in self._tokenize(gold)] |
|
lc_system_words = [word.lower() for word in self._tokenize(system)] |
|
|
|
return { |
|
"1": self._rouge_n(1, lc_gold_words, lc_system_words), |
|
"2": self._rouge_n(2, lc_gold_words, lc_system_words), |
|
"L": self._rouge_l(lc_gold_words, lc_system_words), |
|
} |
|
|
|
def corpus(self, gold, system): |
|
"""Compute RougeRAW-1, RougeRAW-2, RougeRAW-L for given corpora. |
|
|
|
Each corpus should be a collection of documents, each document a string. |
|
""" |
|
|
|
assert isinstance(gold, list) and isinstance(system, list), "Expected list arguments" |
|
assert len(gold) == len(system), "Given corpora should be of the same length" |
|
|
|
rouge = {key: self.FScore(0, 0, 0) for key in ["1", "2", "L"]} |
|
|
|
if len(gold): |
|
for gold_document, system_document in zip(gold, system): |
|
for key, value in self.document(gold_document, system_document).items(): |
|
rouge[key].p += value.p |
|
rouge[key].r += value.r |
|
rouge[key].f += value.f |
|
|
|
for key in rouge: |
|
rouge[key].p /= len(gold) |
|
rouge[key].r /= len(gold) |
|
rouge[key].f /= len(gold) |
|
|
|
return rouge |
|
|
|
|
|
if __name__ == "__main__": |
|
import argparse |
|
import json |
|
|
|
parser = argparse.ArgumentParser() |
|
parser.add_argument("gold", type=str, help="Gold jsonl file path") |
|
parser.add_argument("system", type=str, help="System jsonl output file") |
|
parser.add_argument("field", type=str, help="Which jsonl field to compare") |
|
args = parser.parse_args() |
|
|
|
gold = [] |
|
with open(args.gold, "r", encoding="utf-8") as gold_file: |
|
for gold_line in gold_file: |
|
gold.append(json.loads(gold_line)[args.field]) |
|
|
|
system = [] |
|
with open(args.system, "r", encoding="utf-8") as system_file: |
|
for system_line in system_file: |
|
system.append(json.loads(system_line)[args.field]) |
|
|
|
rouge = RougeRaw().corpus(gold, system) |
|
print(" RougeRAW-1 RougeRAW-2 RougeRAW-L") |
|
print(" P R F P R F P R F") |
|
for metric in ["1", "2", "L"]: |
|
print("{:04.1f} {:04.1f} {:04.1f}{}".format( |
|
100 * rouge[metric].p, |
|
100 * rouge[metric].r, |
|
100 * rouge[metric].f, |
|
"\n" if metric == "L" else " "), end="") |
|
|
