Fix dataset viewer (#3)

- Delete dataset_info from README (013210da4ac22fadbd20070a676d8aa345e87f01)
- Delete Python files (58fdf71183e6e8049a132bf53c38b34d1fef8bd7)
- Delete generated_facts.json (610949f573b4f8648417cd8373618252b08a5732)


Co-authored-by: Albert Villanova <albertvillanova@users.noreply.huggingface.co>

Fin-Fact.py

@@ -1,79 +0,0 @@
-"""Fin-Fact dataset."""
-
-import json
-import datasets
-
-_CITATION = """\
-@misc{rangapur2023finfact,
-      title={Fin-Fact: A Benchmark Dataset for Multimodal Financial Fact Checking and Explanation Generation}, 
-      author={Aman Rangapur and Haoran Wang and Kai Shu},
-      year={2023},
-      eprint={2309.08793},
-      archivePrefix={arXiv},
-      primaryClass={cs.AI}
-}
-"""
-
-_DESCRIPTION = """\
-Fin-Fact is a comprehensive dataset designed specifically for financial fact-checking and explanation generation. 
-The dataset consists of 3121 claims spanning multiple financial sectors.
-"""
-
-_HOMEPAGE = "https://github.com/IIT-DM/Fin-Fact"
-_LICENSE = "Apache 2.0"
-_URL = "https://huggingface.co/datasets/amanrangapur/Fin-Fact/resolve/main/finfact.json"
-
-class FinFact(datasets.GeneratorBasedBuilder):
-    """Fin-Fact dataset for financial fact-checking and text generation."""
-
-    VERSION = datasets.Version("1.0.0")
-    BUILDER_CONFIGS = [
-        datasets.BuilderConfig(
-            name="generation",
-            version=VERSION,
-            description="The Fin-Fact dataset for financial fact-checking and text generation",
-        ),
-    ]
-
-    DEFAULT_CONFIG_NAME = "generation"
-
-    def _info(self):
-        return datasets.DatasetInfo(
-            description=_DESCRIPTION,
-            features=datasets.Features(
-                {
-                    "url": datasets.Value("string"),
-                    "claim": datasets.Value("string"),
-                    "author": datasets.Value("string"),
-                    "posted": datasets.Value("string"),
-                    "label": datasets.Value("string"),
-                }
-            ),
-            supervised_keys=None,
-            homepage=_HOMEPAGE,
-            license=_LICENSE,
-            citation=_CITATION,
-        )
-
-    def _split_generators(self, dl_manager):
-        downloaded_file = dl_manager.download(_URL)
-        return [
-            datasets.SplitGenerator(
-                name=datasets.Split.TRAIN,
-                gen_kwargs={
-                    "filepath": downloaded_file,
-                },
-            ),
-        ]
-
-    def _generate_examples(self, filepath):
-        with open(filepath, encoding="utf-8") as f:
-            data = json.load(f)
-            for id_, row in enumerate(data):
-                yield id_, {
-                    "url": row.get("url", ""),
-                    "claim": row.get("claim", ""),
-                    "author": row.get("author", ""),
-                    "posted": row.get("posted", ""),
-                    "label": row.get("label", ""),
-                }

README.md

@@ -10,20 +10,6 @@ tags:
 pretty_name: FinFact
 size_categories:
   - 1K<n<10K
-dataset_info:
-  - config_name: generation
-    features:
-      - name: url
-        dtype: string
-      - name: claim
-        dtype: string
-      - name: author
-        dtype: string
-      - name: posted
-        dtype: string
-      - name: label
-        dtype: string
-
 ---
 
 <h1 align="center">Fin-Fact - Financial Fact-Checking Dataset</h1>

anli.py

@@ -1,90 +0,0 @@
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
-import torch
-import argparse
-import json
-from sklearn.metrics import confusion_matrix, accuracy_score, recall_score, precision_score, classification_report, f1_score
-
-class FactCheckerApp:
-    def __init__(self, hg_model_hub_name='ynie/electra-large-discriminator-snli_mnli_fever_anli_R1_R2_R3-nli'):
-        # hg_model_hub_name = "ynie/roberta-large-snli_mnli_fever_anli_R1_R2_R3-nli"
-        # hg_model_hub_name = "ynie/albert-xxlarge-v2-snli_mnli_fever_anli_R1_R2_R3-nli"
-        # hg_model_hub_name = "ynie/bart-large-snli_mnli_fever_anli_R1_R2_R3-nli"
-        # hg_model_hub_name = "ynie/electra-large-discriminator-snli_mnli_fever_anli_R1_R2_R3-nli"
-        # hg_model_hub_name = "ynie/xlnet-large-cased-snli_mnli_fever_anli_R1_R2_R3-nli"
-    
-        self.max_length = 248
-        self.tokenizer = AutoTokenizer.from_pretrained(hg_model_hub_name)
-        self.model = AutoModelForSequenceClassification.from_pretrained(hg_model_hub_name)
-        self.sentences_list = []
-        self.titles_list = []
-        self.labels_list = []
-        self.claim_list = []
-
-    def load_data(self, filename):
-        with open(filename, "r") as infile:
-            self.data = json.load(infile)
-
-    def preprocess_data(self):
-        for entry in self.data:
-            if "data" in entry:
-                self.titles_list.append(entry["title"])
-                _evidence = ' '.join([item["sentence"] for item in entry["data"]])
-                self.sentences_list.append(_evidence)
-                self.labels_list.append(entry["label"])
-
-    def validate_claims(self, threshold=0.5):
-        for title, evidence in zip(self.titles_list, self.sentences_list):
-            tokenized_input_seq_pair = self.tokenizer.encode_plus(evidence, title,
-                                                    max_length=self.max_length,
-                                                    return_token_type_ids=True, truncation=True)
-            input_ids = torch.Tensor(tokenized_input_seq_pair['input_ids']).long().unsqueeze(0)
-            token_type_ids = torch.Tensor(tokenized_input_seq_pair['token_type_ids']).long().unsqueeze(0)
-            attention_mask = torch.Tensor(tokenized_input_seq_pair['attention_mask']).long().unsqueeze(0)
-            outputs = self.model(input_ids,
-                            attention_mask=attention_mask,
-                            labels=None)
-            predicted_probability = torch.softmax(outputs.logits, dim=1)[0].tolist()
-            entailment_prob = predicted_probability[0]
-            neutral_prob = predicted_probability[1]
-            contradiction_prob = predicted_probability[2]
-
-            if entailment_prob > threshold:
-                is_claim_true = "true"
-            elif neutral_prob > threshold:
-                is_claim_true = "neutral"
-            else:
-                is_claim_true = "false"
-
-            print(is_claim_true)
-            self.claim_list.append(is_claim_true)
-    
-    def calculate_metrics(self):
-        precision = precision_score(self.labels_list, self.claim_list, average='macro')
-        accuracy = accuracy_score(self.labels_list, self.claim_list)
-        f1_scoree = f1_score(self.labels_list, self.claim_list, average='macro')
-        conf_matrix = confusion_matrix(self.labels_list, self.claim_list)
-        recall_metric = recall_score(self.labels_list, self.claim_list, pos_label="true", average="macro")
-        cls_report = classification_report(self.labels_list, self.claim_list, labels=["true", "false", "neutral"])
-        return precision, accuracy, f1_scoree, conf_matrix, recall_metric, cls_report
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Fact Checker Application")
-    parser.add_argument("--model_name", default="ynie/bart-large-snli_mnli_fever_anli_R1_R2_R3-nli", help="Name of the pre-trained model to use")
-    parser.add_argument("--data_file", required=True, help="Path to the JSON data file")
-    parser.add_argument("--threshold", type=float, default=0.5, help="Threshold for claim validation")
-    return parser.parse_args()
-
-if __name__ == "__main__":
-    args = parse_args()
-    fact_checker_app = FactCheckerApp(hg_model_hub_name=args.model_name)
-    fact_checker_app.load_data(args.data_file)
-    fact_checker_app.preprocess_data()
-    fact_checker_app.validate_claims(threshold=args.threshold)
-    precision, accuracy, f1_scoree, conf_matrix, recall_metric, cls_report = fact_checker_app.calculate_metrics()
-    print("Precision:", precision)
-    print("Accuracy:", accuracy)
-    print("F1 score:", f1_scoree)
-    print("Recall: ", recall_metric)
-    print("Confusion Matrix:\n", conf_matrix)
-    print("Report:\n", cls_report)
-    

bart_eval.py

@@ -1,95 +0,0 @@
-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)
-

bart_explaination_gen.py

@@ -1,61 +0,0 @@
-from transformers import BartTokenizer, BartForConditionalGeneration
-import json
-
-class NLPFactGenerator:
-    def __init__(self, model_name="facebook/bart-large-cnn"):
-        self.max_length = 1024
-        self.model = BartForConditionalGeneration.from_pretrained(model_name)
-        self.tokenizer = BartTokenizer.from_pretrained(model_name)
-        self.sentences_list = []
-        self.justification_list = []
-        self.titles_list = []
-        self.labels_list = []
-        self.claim_list = []
-    
-    def load_data(self, filename):
-        with open(filename, "r") as infile:
-            self.data = json.load(infile)
-
-    def preprocess_data(self):
-        max_seq_length = 1024
-        for entry in self.data:
-            if "data" in entry:
-                self.titles_list.append(entry["title"])
-                justification = ' '.join(entry["paragraphs"])
-                for evidence in self.sentences_list:
-                    if len(evidence) > max_seq_length:
-                        evidence = evidence[:max_seq_length]
-                _evidence = ' '.join([item["sentence"] for item in entry["data"]])
-                self.justification_list.append(justification)
-                self.sentences_list.append(_evidence)
-                self.labels_list.append(entry["label"])
-
-    def generate_fact(self):
-        max_seq_length = 1024
-        generated_facts = []
-        for evidence in self.justification_list:
-            if len(evidence) > max_seq_length:
-                evidence = evidence[:max_seq_length]
-            input_ids = self.tokenizer.encode(evidence, return_tensors="pt")
-            try:
-                generated_ids = self.model.generate(input_ids, max_length=self.max_length, num_return_sequences=1)
-                generated_text = self.tokenizer.decode(generated_ids[0], skip_special_tokens=True)
-                print('Done')
-                print('*'*50)
-                generated_facts.append(generated_text)
-            except:
-                print('Input ID: ', len(input_ids))
-        return generated_facts
-
-
-if __name__ == "__main__":
-    fact_generator = NLPFactGenerator()
-    fact_generator.load_data("finfact_old.json")
-    fact_generator.preprocess_data()
-    generated_facts = fact_generator.generate_fact()
-    generated_data = []
-
-    for title, evi, fact in zip(fact_generator.titles_list, fact_generator.sentences_list, generated_facts):
-        generated_data.append({"title": title, "evidence":evi, "generated_fact": fact})
-    with open("generated_facts.json", "w") as outfile:
-        json.dump(generated_data, outfile, indent=4)

bert_gen.py

@@ -1,83 +0,0 @@
-import torch
-from transformers import BertTokenizerFast, EncoderDecoderModel
-import json
-
-class NLPFactGenerator:
-    def __init__(self, ckpt="mrm8488/bert2bert_shared-german-finetuned-summarization"):
-        self.max_length = 1024
-        self.tokenizer = BertTokenizerFast.from_pretrained(ckpt)
-        self.model = EncoderDecoderModel.from_pretrained(ckpt)
-        self.sentences_list = []
-        self.justification_list = []
-        self.titles_list = []
-        self.labels_list = []
-        self.claim_list = []
-    
-    def load_data(self, filename):
-        with open(filename, "r") as infile:
-            self.data = json.load(infile)
-
-    def preprocess_data(self):
-        max_seq_length = 1024
-        for entry in self.data:
-            if "data" in entry:
-                self.titles_list.append(entry["title"])
-                justification = ' '.join(entry["paragraphs"])
-                for evidence in self.sentences_list:
-                    if len(evidence) > max_seq_length:
-                        evidence = evidence[:max_seq_length]
-                _evidence = ' '.join([item["sentence"] for item in entry["data"]])
-                self.justification_list.append(justification)
-                self.sentences_list.append(_evidence)
-                self.labels_list.append(entry["label"])
-
-    def generate_fact(self):
-        max_seq_length = 1024
-        generated_facts = []
-        count = 0
-        for evidence in self.justification_list:
-            if len(evidence) > max_seq_length:
-                evidence = evidence[:max_seq_length]
-            inputs = self.tokenizer([evidence], padding="max_length", truncation=True, max_length=1024, return_tensors="pt")
-            input_ids = inputs.input_ids
-            attention_mask = inputs.attention_mask
-            try:
-                
-                output = self.model.generate(input_ids, attention_mask=attention_mask)
-                summary = self.tokenizer.decode(output[0], skip_special_tokens=True)
-                count+=1
-                print(count)
-                generated_facts.append(summary)
-            except:
-                print('Input ID: ', len(input_ids))
-        return generated_facts
-
-
-if __name__ == "__main__":
-    fact_generator = NLPFactGenerator()
-    fact_generator.load_data("finfact_old.json")
-    fact_generator.preprocess_data()
-    generated_facts = fact_generator.generate_fact()
-    generated_data = []
-
-    for title, evi, fact in zip(fact_generator.titles_list, fact_generator.sentences_list, generated_facts):
-        generated_data.append({"title": title, "evidence":evi, "generated_fact": fact})
-    with open("generated_facts_bert.json", "w") as outfile:
-        json.dump(generated_data, outfile, indent=4)
-
-
-
-device = 'cuda' if torch.cuda.is_available() else 'cpu'
-ckpt = 'mrm8488/bert2bert_shared-german-finetuned-summarization'
-tokenizer = BertTokenizerFast.from_pretrained(ckpt)
-model = EncoderDecoderModel.from_pretrained(ckpt).to(device)
-def generate_summary(text):
-   inputs = tokenizer([text], padding="max_length", truncation=True, max_length=512, return_tensors="pt")
-   input_ids = inputs.input_ids.to(device)
-   attention_mask = inputs.attention_mask.to(device)
-   output = model.generate(input_ids, attention_mask=attention_mask)
-   return tokenizer.decode(output[0], skip_special_tokens=True)
-   
-text = "Your text here..."
-
-generate_summary(text)

data_crawler.py

@@ -1,76 +0,0 @@
-from bs4 import BeautifulSoup
-import pandas as pd
-import requests
-import json
-
-class FactCheckerScraper:
-    def __init__(self):
-        self.authors = []
-        self.statements = []
-        self.sources = []
-        self.targets = []
-        self.href_list = []
-
-    def scrape_website(self, page_number, source):
-        page_num = str(page_number)
-        URL = 'https://www.politifact.com/factchecks/list/?category=income&page={}&source={}'.format(page_num, source)
-        webpage = requests.get(URL) 
-        soup = BeautifulSoup(webpage.text, "html.parser")
-        statement_footer =  soup.find_all('footer', attrs={'class':'m-statement__footer'})
-        statement_quote = soup.find_all('div', attrs={'class':'m-statement__quote'})
-        statement_meta = soup.find_all('div', attrs={'class':'m-statement__meta'})
-        target = soup.find_all('div', attrs={'class':'m-statement__meter'})
-        
-        for i in statement_footer:
-            link1 = i.text.strip()
-            name_and_date = link1.split()
-            first_name = name_and_date[1]
-            last_name = name_and_date[2]
-            full_name = first_name+' '+last_name
-            self.authors.append(full_name)
-
-        for i in statement_quote:
-            link2 = i.find_all('a')
-            self.statements.append(link2[0].text.strip())
-
-        for i in statement_meta:
-            link3 = i.find_all('a') 
-            source_text = link3[0].text.strip()
-            self.sources.append(source_text)
-
-        for i in target:
-            fact = i.find('div', attrs={'class':'c-image'}).find('img').get('alt')
-            self.targets.append(fact)
-
-        for i in statement_quote:
-            href = i.find('a')['href']
-            href = 'https://www.politifact.com' + href
-            self.href_list.append(href)
-
-    def scrape_multiple_pages(self, num_pages, source):
-        for i in range(1, num_pages):
-            self.scrape_website(i, source)
-
-    def create_dataframe(self):
-        data = pd.DataFrame(columns=['author', 'statement', 'links', 'source', 'date', 'target'])
-        data['author'] = self.authors
-        data['statement'] = self.statements
-        data['links'] = self.href_list
-        data['source'] = self.sources
-        data['target'] = self.targets
-        return data
-
-    def save_to_json(self, filename):
-        data_json = {
-            "url": self.href_list,
-            "label": self.targets
-        }
-
-        with open(filename, "w") as outfile:
-            json.dump(data_json, outfile)
-
-if __name__ == "__main__":
-    scraper = FactCheckerScraper()
-    scraper.scrape_multiple_pages(70, source='covid')
-    data = scraper.create_dataframe()
-    scraper.save_to_json("./income.json")

data_generator.py

@@ -1,171 +0,0 @@
-from bs4 import BeautifulSoup
-import datetime
-import requests
-import nltk
-import json
-
-class WebScraper:
-    def __init__(self, url):
-        self.URL = url
-        try: 
-            self.webpage = requests.get(self.URL)
-        except requests.exceptions.RequestException as e:
-            print(f"Error: {e}")
-        if self.webpage:
-            try:
-                self.soup = BeautifulSoup(self.webpage.text, "html.parser")
-            except:
-                print("Error: Failed to create BeautifulSoup object.")
-    
-    def remove_unicode(self, string):
-        return string.encode('ascii', 'ignore').decode('utf-8')
-    
-    def get_page_title(self):
-        try:
-            div_element = self.soup.find('div', class_='m-statement__quote')
-            title = div_element.get_text(strip=True)
-            cleaned_title = self.remove_unicode(title)
-            cleaned_title = cleaned_title.replace('\"', '')
-        except AttributeError:
-            return None # Error: Failed to get page title.
-        return cleaned_title
-    
-    def get_page_author(self):
-        try:
-            author_element = self.soup.find('div', class_='m-author__content').find('a')
-            author = author_element.get_text(strip=True)
-        except AttributeError:
-            return None # Error: Failed to get page author.
-        return author
-    
-    def get_page_posted_date(self):
-        date_element = None
-        try:
-            date_element = self.soup.find('span', class_='m-author__date')
-            date = date_element.get_text(strip=True)
-            date_obj = datetime.datetime.strptime(date, "%B %d, %Y")
-            formatted_date = date_obj.strftime("%m/%d/%Y")
-        except (AttributeError, ValueError):
-            return None # Error: Failed to get page posted date.
-        return formatted_date
-    
-    def get_sci_check_digest(self):
-        try:
-            div_element = self.soup.find('div', class_='short-on-time')
-            li_tags = div_element.find_all('li') if div_element else []
-            sci_digest_list = [li.get_text(strip=True) for li in li_tags]
-            final_sci_digest = ", ".join(sci_digest_list)
-            cleaned_sci_digest = self.remove_unicode(final_sci_digest)
-            cleaned_sci_digest = cleaned_sci_digest.replace('\"', '')
-            tokenised_sci_digest = nltk.sent_tokenize(cleaned_sci_digest)
-        except AttributeError:
-            return None # Error: Failed to get SciCheck digest.
-        return tokenised_sci_digest
-    
-    def get_paragraph_list(self):
-        try:
-            paragraph_list = []
-            article_element = self.soup.find('article', class_='m-textblock')
-            p_elements = article_element.find_all('p')
-            text_list = [p.get_text(strip=True) for p in p_elements]
-            for text in text_list:
-                paragraph_list.append(text)
-            final_paragraphs = " ".join(paragraph_list)
-            cleaned_paragraphs = final_paragraphs.replace('\u00a0', ' ')
-            cleaned_paragraphs = self.remove_unicode(cleaned_paragraphs)
-            cleaned_paragraphs = cleaned_paragraphs.replace('\"', '')
-            tokenized_paragraphs = nltk.sent_tokenize(cleaned_paragraphs)
-        except AttributeError:
-            return None, None # Error: Failed to get paragraphs.
-        return paragraph_list, tokenized_paragraphs
-    
-    def get_sentences_citations(self):
-        try:
-            p_elements = self.soup.select('article.m-textblock p')
-            citation_list = []
-            for p in p_elements:
-                href = p.find('a')
-                if href and 'href' in href.attrs:
-                    href_text = href['href']
-                    sentence = p.get_text(strip=True)
-                    cleaned_sentence = sentence.replace('\u00a0', ' ')
-                    cleaned_sentence = self.remove_unicode(cleaned_sentence)
-                    cleaned_sentence = cleaned_sentence.replace('\"', '')
-                    citation_list.append({"sentence": cleaned_sentence, "hrefs": href_text})
-        except AttributeError:
-            return None  # Error: Failed to get citation list.
-        return citation_list
- 
-    def get_issue_list(self):
-        issue_list = []
-        try:
-            ul_element = self.soup.find('ul', class_='m-list--horizontal')
-            li_elements = ul_element.find_all('li', class_='m-list__item')
-            for li in li_elements[:-1]:
-                category = li.a['title']
-                issue_list.append(category)
-        except AttributeError:
-            return None # Error: Failed to get issue list.
-        return issue_list
-    
-    def get_image_info(self):
-        try:
-            article_element = self.soup.find('article', class_='m-textblock')
-            p_elements = article_element.find_all('p')
-            em_elements = article_element.find_all('em')
-            img_count = 0
-            image_captions = []
-            for p in p_elements:
-                img_tag = p.find('img')
-                if img_tag:
-                    img_src = img_tag['src']
-                    if img_src:
-                        img_count += 1
-                        if img_count <= len(em_elements):
-                            image_caption = em_elements[img_count - 1].get_text(strip=True)
-                            cleaned_captions = image_caption.replace('\u00a0', ' ')
-                            cleaned_captions = self.remove_unicode(cleaned_captions)
-                            cleaned_captions = cleaned_captions.replace('\"', '')
-                            image_captions.append({"image_src": img_src, "image_caption": cleaned_captions})
-        except:
-            return None
-        return image_captions
-
-    def get_label(self):
-        try:
-            target = self.soup.find_all('div', attrs={'class':'m-statement__meter'})
-            for i in target:
-                label = i.find('div', attrs={'class':'c-image'}).find('img').get('alt')
-                # if label == 'pants-fire':
-                #     label = 'false'
-                # elif label == 'mostly-true':
-                #     label = 'true'
-        except:
-            return None
-        return label
-        
-with open("./income.json", "r") as infile:
-    data = json.load(infile)
-    urls = data["url"]
-    labels = data["label"]
-
-scraped_data = []
-for url, label in zip(urls,labels):
-    print(url)
-    scraper = WebScraper(url)
-    data = {
-        "url": url,
-        "title": scraper.get_page_title(),
-        "author": scraper.get_page_author(),
-        "posted": scraper.get_page_posted_date(),
-        "sci_digest": scraper.get_sci_check_digest(),
-        "paragraphs": scraper.get_paragraph_list()[1],
-        "issues": scraper.get_issue_list(),
-        "image_data": scraper.get_image_info(),
-        "data": scraper.get_sentences_citations(),
-        "label": label
-    }
-    scraped_data.append(data)
-
-with open("./json_new/income.json", "w") as outfile:
-    json.dump(scraped_data, outfile)

generated_facts.json

@@ -1,17 +0,0 @@
-[
-    {
-        "title": "Video shows that George Soros is going bankrupt.",
-        "evidence": "IT HAPPENED, the July 18postsays. Elon Musk L.E.A.K.E.D_ GEORGE SOROS IS GOING B.A.N.K.R.U.P.T_, JOE BIDEN S.C.A.RED! - | BREAKING FOX NEWS BIDEN - JULY 19, 2023. This post was flagged as part of Metas efforts to combat false news and misinformation on its News Feed. (Read more about ourpartnership with Meta, which owns Facebook and Instagram.) According to Forbes, Soros wasworth $6.7 billionas of July 20. We found no news reports that hes heading into bankruptcy  or that Musk leaked this information. The narrator also refers torecent newsthat Soros nonprofit grant-making network, Open Society Foundations, plans to lay off 40% of its global staff as Soros hands over leadership tohis son, Alex Soros. The organization says it currently employs about 800 people around the world. In a statement, Open Society Foundations said its new operating model is meant to maximize its grantmaking dollars, The Associated Pressreported. The news outlet didnt hint that neither the nonprofit nor Soros is on the verge of bankruptcy. Soros has already given $32 billion to the foundations and has indicatedto The New York Timesthat his fortune will go to his familys philanthropic efforts. Such a gesture hasnt been highly regarded by Twitter owner Elon Musk, who recentlytweetedthat Soros wants to erode the very fabric of civilization.",
-        "generated_fact": "A recent Facebook post claims that billionaire philanthropist George Soros is in the red, but it provides no evidence that this is true. According to Forbes, Soros wasworth $6.7 billionas of July 20. This post was flagged as part of Metas efforts to combat false news and misinformation on its News Feed."
-    },
-    {
-        "title": "Because of Obamacare, Medicare is going broke.",
-        "evidence": "As U.S. House SpeakerPaul Ryandiscussed the repeal and replacement of the Affordable Care Act, a top priority of President-electDonald Trump, he made a claim about the financial health ofMedicare. What people dont realize is, because of Obamacare, Medicare is going broke, the Wisconsin RepublicantoldFox News hostBret Baieron Nov. 10, 2016. The Affordable Care Act certainly has its detractors. When Ryan claimed the same month that Obamacare is not a popular law, our rating wasMostly True. The polls generally showed most Americans had an unfavorable opinion of it. https://www.sharethefacts.co/share/7de6b429-1d9a-42de-ad08-c7998eaa6ca5 Heres howMarc Goldwein, senior policy director at the Committee for a Responsible Federal Budget, lays it out: Two health care policy experts further told us that the combination of spending curbs and revenue increases forMedicare Part A-- which covers hospital, nursing home and home care services, and is financed mainly through payroll taxes -- has extended the solvency of Medicare. Paul Ginsburg, a professor of the practice of health policy and management at the University of Southern California, pointed us to anOctober 2016 reportfrom the nonpartisan Congressional Research Service. The report noted that in 2010, the Medicare trustees projected that Obamacares spending curbs and revenue increases would mean MedicaresHospital Insurance Trust Fund, which finances Part A, would remain solvent until 2029. (The projection has since been revisedto 2028.) Michael Sparer, a professor health policy and management at Columbia University in New York, put it this way, financially speaking: Finally, its worth noting that bothFactcheck.organd the Washington PostFact Checkeralso concluded that Ryans claim is wrong. They both also noted that, even if the Part A trust fund did become depleted in 2028, the program wouldnt be broke, in that it is still set up to cover an estimated 87 percent of expenses.",
-        "generated_fact": "U.S. House Speaker Paul Ryan made a claim about the financial health of Medicare. Ryan: Because of Obamacare, Medicare is going broke. Ryan's claim flies in the face of evidence that it actually helps shore up Medicare. On one side of the ledger, Obamacare slowed the growth of Medicare spending."
-    },
-    {
-        "title": "Back in the Great Recession, when millions of jobs across America hung in the balance, Donald Trump said rescuing the auto industry didnt really matter very much. He said, and I quote again, Let it go. ",
-        "evidence": "Trumps position on an auto bailout was inconsistent leading up to Dec. 19, 2008, when Bush laid out plans to go forward with the bailout. Trump said the government should help the auto companies, but he also regularly suggested the they could save themselves if they filed forChapter 11 bankruptcy,with some government support. Mid 2009, months into his first year as president,ObamaforcedChryslerandGeneral Motorsto go through bankruptcy. Dec. 9, 2008, Fox:Trump told host Greta Van Susteren that I think you have to try and save the companies, and I think you can easily save the companies. He added, referring to bankruptcy, that auto companies don't like the B word. I think they probably should use it. Dec. 10, 2008, CNBC:You have to save the car industry in this country, Trump said. General Motors can be great again, Ford can be great again, and Chrysler could be great. Dec. 17, 2008, Fox:Cavuto asked Trump if he thought the country could do without one of the Big Three auto makers. Trump responded, No. I think you should have the Big Three. I think the government should stand behind them 100 percent. You cannot lose the auto companies. They are great. They make wonderful products. Maybe they are making too much. Maybe they are not making too much. I just bought a Dodge Ram truck from Arrigo Dodge, who is a member of one of my clubs and a great guy. Dec. 18, 2008, CNN:Host Wolf Blitzer asked Trump if Bush should bail out the auto industry. Trump replied, Well, I hope he does it, but you have to make a much better deal with the unions.  The fact is you have to make the companies competitive. And if you're not going to make a deal with the union, and a great and fair deal and a competitive deal, then they shouldn't do it. But absolutely, they should try and save the companies. You just can't lose Chrysler, you can't lose Ford, and you can't lose General Motors. You could have let it go, and rebuilt itself, through the free enterprise system, Trump said in August 2015, according to theWashington Post. You could have let it go bankrupt, frankly, and rebuilt itself, and a lot of people felt it should happen. Or you could have done it the way it went. I could have done it either way. Either way would have been acceptable. I think you would have wound up in the same place.",
-        "generated_fact": "Hillary Clinton said at a rally in Michigan that she supported the 2008 government bailout for the American auto industry. But Trump, she said, doesnt support American workers, much less those in MichigansAuto industry. Trump's public comments about the auto industry's demise were the opposite of what Clinton said."
-    }
-]

gpt2_nli.py

@@ -1,70 +0,0 @@
-from transformers import (
-    GPT2LMHeadModel,
-    GPT2Tokenizer,
-)
-import argparse
-import warnings
-warnings.filterwarnings("ignore")
-
-from fact_checking import FactChecker
-import json
-from sklearn.metrics import confusion_matrix, classification_report
-
-class FactCheckerApp:
-    def __init__(self, model_name='fractalego/fact-checking'):
-        self.tokenizer = GPT2Tokenizer.from_pretrained('gpt2')
-        self.fact_checking_model = GPT2LMHeadModel.from_pretrained(model_name)
-        self.fact_checker = FactChecker(self.fact_checking_model, self.tokenizer)
-        self.sentences_list = []
-        self.titles_list = []
-        self.labels_list = []
-        self.claim_list = []
-
-    def load_data(self, filename):
-        with open(filename, "r") as infile:
-            self.data = json.load(infile)
-
-    def preprocess_data(self):
-        for entry in self.data:
-            if "data" in entry:
-                self.titles_list.append(entry["title"])
-                _evidence = ' '.join([item["sentence"] for item in entry["data"]])
-                self.sentences_list.append(_evidence)
-                self.labels_list.append(entry["label"])
-
-    def validate_claims(self):
-        max_seq_length = 1024 
-        for title, evidence in zip(self.titles_list, self.sentences_list):
-            try:
-                if len(title) > max_seq_length:
-                    title = title[:max_seq_length]
-                if len(evidence) > max_seq_length:
-                    evidence = evidence[:max_seq_length]
-                    print(len(evidence))
-                is_claim_true = self.fact_checker.validate(evidence, title)
-                print(is_claim_true)
-                self.claim_list.append(is_claim_true)
-            except IndexError:
-                self.claim_list.append(None)
-
-    def calculate_metrics(self):
-        conf_matrix = confusion_matrix(self.labels_list, [str(is_claim).lower() for is_claim in self.claim_list])
-        cls_report = classification_report(self.labels_list, [str(is_claim).lower() for is_claim in self.claim_list], labels=["true", "false", "neutral"])
-
-        return conf_matrix, cls_report
-
-def parse_args():
-    parser = argparse.ArgumentParser(description="Fact Checker Application")
-    parser.add_argument("--model_name", default="fractalego/fact-checking", help="Name of the fact-checking model to use")
-    parser.add_argument("--data_file", required=True, help="Path to the JSON data file")
-    return parser.parse_args()
-
-if __name__ == "__main__":
-    args = parse_args()
-    fact_checker_app = FactCheckerApp(model_name=args.model_name)
-    fact_checker_app.load_data(args.data_file)
-    fact_checker_app.preprocess_data()
-    fact_checker_app.validate_claims()
-    conf_matrix, cls_report = fact_checker_app.calculate_metrics()
-    print("Confusion Matrix:\n", conf_matrix)
-    print("Report:\n", cls_report)

pegasus_gen.py

@@ -1,70 +0,0 @@
-from transformers import PegasusTokenizer, PegasusForConditionalGeneration
-import json
-
-class NLPFactGenerator:
-    def __init__(self, model_name="human-centered-summarization/financial-summarization-pegasus"):
-        self.max_length = 1024
-        self.tokenizer = PegasusTokenizer.from_pretrained(model_name)
-        self.model = PegasusForConditionalGeneration.from_pretrained(model_name)
-        self.sentences_list = []
-        self.justification_list = []
-        self.titles_list = []
-        self.labels_list = []
-        self.claim_list = []
-    
-    def load_data(self, filename):
-        with open(filename, "r") as infile:
-            self.data = json.load(infile)
-
-    def preprocess_data(self):
-        max_seq_length = 1024
-        for entry in self.data:
-            if "data" in entry:
-                self.titles_list.append(entry["title"])
-                justification = ' '.join(entry["paragraphs"])
-                for evidence in self.sentences_list:
-                    if len(evidence) > max_seq_length:
-                        evidence = evidence[:max_seq_length]
-                _evidence = ' '.join([item["sentence"] for item in entry["data"]])
-                self.justification_list.append(justification)
-                self.sentences_list.append(_evidence)
-                self.labels_list.append(entry["label"])
-
-    def generate_fact(self):
-        max_seq_length = 1024
-        generated_facts = []
-        count = 0
-        for evidence in self.justification_list:
-            if len(evidence) > max_seq_length:
-                evidence = evidence[:max_seq_length]
-            input_ids = self.tokenizer(evidence, return_tensors="pt").input_ids
-            try:
-                output = self.model.generate(
-                    input_ids, 
-                    max_length=64, 
-                    num_beams=5, 
-                    early_stopping=True
-                )
-                summary = self.tokenizer.decode(output[0], skip_special_tokens=True)
-                count+=1
-                print(count)
-                
-                generated_facts.append(summary)
-            except:
-                print('Input ID: ', len(input_ids))
-        return generated_facts
-
-
-if __name__ == "__main__":
-    fact_generator = NLPFactGenerator()
-    fact_generator.load_data("finfact_old.json")
-    fact_generator.preprocess_data()
-    generated_facts = fact_generator.generate_fact()
-    generated_data = []
-
-    for title, evi, fact in zip(fact_generator.titles_list, fact_generator.sentences_list, generated_facts):
-        generated_data.append({"title": title, "evidence":evi, "generated_fact": fact})
-    with open("generated_facts_pegasus.json", "w") as outfile:
-        json.dump(generated_data, outfile, indent=4)
-
-

xl_sum_gen.py

@@ -1,80 +0,0 @@
-import re
-from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-import json
-
-class NLPFactGenerator:
-    def __init__(self, model_name="csebuetnlp/mT5_multilingual_XLSum"):
-        self.max_length = 1024
-        self.tokenizer = AutoTokenizer.from_pretrained(model_name)
-        self.model = AutoModelForSeq2SeqLM.from_pretrained(model_name)
-        self.WHITESPACE_HANDLER = lambda k: re.sub('\s+', ' ', re.sub('\n+', ' ', k.strip()))
-        self.sentences_list = []
-        self.justification_list = []
-        self.titles_list = []
-        self.labels_list = []
-        self.claim_list = []
-    
-    def load_data(self, filename):
-        with open(filename, "r") as infile:
-            self.data = json.load(infile)
-
-    def preprocess_data(self):
-        max_seq_length = 1024
-        for entry in self.data:
-            if "data" in entry:
-                self.titles_list.append(entry["title"])
-                justification = ' '.join(entry["paragraphs"])
-                for evidence in self.sentences_list:
-                    if len(evidence) > max_seq_length:
-                        evidence = evidence[:max_seq_length]
-                _evidence = ' '.join([item["sentence"] for item in entry["data"]])
-                self.justification_list.append(justification)
-                self.sentences_list.append(_evidence)
-                self.labels_list.append(entry["label"])
-
-    def generate_fact(self):
-        max_seq_length = 1024
-        generated_facts = []
-        count = 0
-        for evidence in self.justification_list:
-            if len(evidence) > max_seq_length:
-                evidence = evidence[:max_seq_length]
-            input_ids = self.tokenizer(
-                    [self.WHITESPACE_HANDLER(evidence)],
-                    return_tensors="pt",
-                    padding="max_length",
-                    truncation=True,
-                    max_length=1024)["input_ids"]
-            try:
-                output_ids = self.model.generate(
-                    input_ids=input_ids,
-                    max_length=128,
-                    no_repeat_ngram_size=2,
-                    num_beams=4)[0]
-                summary = self.tokenizer.decode(
-                            output_ids,
-                            skip_special_tokens=True,
-                            clean_up_tokenization_spaces=False)
-                count+=1
-                print(count)
-                generated_facts.append(summary)
-            except:
-                print('Input ID: ', len(input_ids))
-        return generated_facts
-
-
-if __name__ == "__main__":
-    fact_generator = NLPFactGenerator()
-    fact_generator.load_data("finfact_old.json")
-    fact_generator.preprocess_data()
-    generated_facts = fact_generator.generate_fact()
-    generated_data = []
-
-    for title, evi, fact in zip(fact_generator.titles_list, fact_generator.sentences_list, generated_facts):
-        generated_data.append({"title": title, "evidence":evi, "generated_fact": fact})
-    with open("generated_facts_xlsum.json", "w") as outfile:
-        json.dump(generated_data, outfile, indent=4)
-
-
-
-