|
import json, itertools, pyter |
|
from nltk.translate.bleu_score import SmoothingFunction, corpus_bleu |
|
|
|
|
|
class NLPFactGenerator: |
|
def __init__(self): |
|
self.gen_fact_list = [] |
|
self.evidence_list = [] |
|
|
|
def _split_into_words(self, sentences): |
|
return list(itertools.chain(*[_.split(" ") for _ in sentences])) |
|
|
|
def _get_word_ngrams(self, n, sentences): |
|
assert len(sentences) > 0 |
|
assert n > 0 |
|
words = self._split_into_words(sentences) |
|
return self._get_ngrams(n, words) |
|
|
|
def _get_ngrams(self, n, text): |
|
ngram_set = set() |
|
text_length = len(text) |
|
max_index_ngram_start = text_length - n |
|
for i in range(max_index_ngram_start + 1): |
|
ngram_set.add(tuple(text[i:i + n])) |
|
return ngram_set |
|
|
|
def load_data(self, filename): |
|
with open(filename, "r") as infile: |
|
self.data = json.load(infile) |
|
|
|
def get_title_evidence_generated_facts(self): |
|
titles = [] |
|
evidences = [] |
|
generated_facts = [] |
|
|
|
for entry in self.data: |
|
titles.append(entry["title"]) |
|
evidences.append(entry["evidence"]) |
|
generated_facts.append(entry["generated_fact"]) |
|
|
|
return evidences, generated_facts |
|
|
|
def ter(self): |
|
ref, gen = self.get_title_evidence_generated_facts() |
|
if len(ref) == 1: |
|
total_score = pyter.ter(gen[0].split(), ref[0].split()) |
|
else: |
|
total_score = 0 |
|
for i in range(len(gen)): |
|
total_score = total_score + pyter.ter(gen[i].split(), ref[i].split()) |
|
total_score = total_score/len(gen) |
|
return total_score |
|
|
|
def bleu(self): |
|
evidence_list, gen_fact_list = self.get_title_evidence_generated_facts() |
|
ref_bleu = [] |
|
gen_bleu = [] |
|
for l in evidence_list: |
|
gen_bleu.append(l.split()) |
|
for i,l in enumerate(gen_fact_list): |
|
ref_bleu.append([l.split()]) |
|
cc = SmoothingFunction() |
|
score_bleu = corpus_bleu(ref_bleu, gen_bleu, weights=(0, 1, 0, 0), smoothing_function=cc.method4) |
|
return score_bleu |
|
|
|
def rouge_one(self,n=3): |
|
evidence_list, gen_fact_list = self.get_title_evidence_generated_facts() |
|
evaluated_ngrams = self._get_word_ngrams(n, evidence_list) |
|
reference_ngrams = self._get_word_ngrams(n, gen_fact_list) |
|
reference_count = len(reference_ngrams) |
|
evaluated_count = len(evaluated_ngrams) |
|
overlapping_ngrams = evaluated_ngrams.intersection(reference_ngrams) |
|
overlapping_count = len(overlapping_ngrams) |
|
if evaluated_count == 0: |
|
precision = 0.0 |
|
else: |
|
precision = overlapping_count / evaluated_count |
|
|
|
if reference_count == 0: |
|
recall = 0.0 |
|
else: |
|
recall = overlapping_count / reference_count |
|
|
|
f1_score = 2.0 * ((precision * recall) / (precision + recall + 1e-8)) |
|
return recall |
|
|
|
|
|
if __name__ == "__main__": |
|
fact_generator = NLPFactGenerator() |
|
fact_generator.load_data("generated_facts_xlsum.json") |
|
rouge_one_score = fact_generator.rouge_one() |
|
blue_score = fact_generator.bleu() |
|
print(blue_score) |
|
print(rouge_one_score) |
|
|
|
|