Datasets:

amanrangapur
/

Fin-Fact

@@ -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", ""),
-                }

anli.py DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

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

gpt2_nli.py DELETED Viewed

@@ -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 DELETED Viewed

@@ -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 DELETED Viewed

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