| 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) | |