Upload 6 files

README.md

@@ -1,10 +1,10 @@
 ---
-title: T5 Base Question Generator
-emoji: 💻
-colorFrom: pink
-colorTo: yellow
+title: Question Generation Using T5
+emoji: ⚡
+colorFrom: blue
+colorTo: gray
 sdk: gradio
-sdk_version: 4.7.1
+sdk_version: 3.44.1
 app_file: app.py
 pinned: false
 ---

app.py

@@ -0,0 +1,146 @@
+import gradio as gr
+import requests
+import os
+import numpy as np
+import pandas as pd
+import json
+import socket
+import huggingface_hub
+from huggingface_hub import Repository
+# from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForSequenceClassification
+from questiongenerator import QuestionGenerator
+import csv
+from urllib.request import urlopen
+import re as r
+
+qg = QuestionGenerator()
+
+HF_TOKEN = os.environ.get("HF_TOKEN")
+DATASET_NAME = "question_generation_T5_dataset"
+DATASET_REPO_URL = f"https://huggingface.co/datasets/pragnakalp/{DATASET_NAME}"
+DATA_FILENAME = "que_gen_logs.csv"
+DATA_FILE = os.path.join("que_gen_logs", DATA_FILENAME)
+DATASET_REPO_ID = "pragnakalp/question_generation_T5_dataset"
+print("is none?", HF_TOKEN is None)
+article_value = """Google was founded in 1998 by Larry Page and Sergey Brin while they were Ph.D. students at Stanford University in California. Together they own about 14 percent of its shares and control 56 percent of the stockholder voting power through supervoting stock. They incorporated Google as a privately held company on September 4, 1998. An initial public offering (IPO) took place on August 19, 2004, and Google moved to its headquarters in Mountain View, California, nicknamed the Googleplex. In August 2015, Google announced plans to reorganize its various interests as a conglomerate called Alphabet Inc. Google is Alphabet's leading subsidiary and will continue to be the umbrella company for Alphabet's Internet interests. Sundar Pichai was appointed CEO of Google, replacing Larry Page who became the CEO of Alphabet."""
+# REPOSITORY_DIR = "data"
+# LOCAL_DIR = 'data_local'
+# os.makedirs(LOCAL_DIR,exist_ok=True)
+
+try:
+    hf_hub_download(
+        repo_id=DATASET_REPO_ID,
+        filename=DATA_FILENAME,
+        cache_dir=DATA_DIRNAME,
+        force_filename=DATA_FILENAME
+    )
+    
+except:
+    print("file not found")
+
+repo = Repository(
+    local_dir="que_gen_logs", clone_from=DATASET_REPO_URL, use_auth_token=HF_TOKEN
+)
+
+
+def getIP():
+    ip_address = ''
+    try:
+    	d = str(urlopen('http://checkip.dyndns.com/')
+    			.read())
+    
+    	return r.compile(r'Address: (\d+\.\d+\.\d+\.\d+)').search(d).group(1)
+    except Exception as e:
+        print("Error while getting IP address -->",e)
+        return ip_address
+
+def get_location(ip_addr):
+    location = {}
+    try:
+        ip=ip_addr
+    
+        req_data={
+            "ip":ip,
+            "token":"pkml123"
+        }
+        url = "https://demos.pragnakalp.com/get-ip-location"
+    
+        # req_data=json.dumps(req_data)
+        # print("req_data",req_data)
+        headers = {'Content-Type': 'application/json'}
+    
+        response = requests.request("POST", url, headers=headers, data=json.dumps(req_data))
+        response = response.json()
+        print("response======>>",response)
+        return response
+    except Exception as e:
+        print("Error while getting location -->",e)
+        return location
+    
+def generate_questions(article,num_que):
+    result = ''
+    if article.strip():
+        if num_que == None or num_que == '':
+            num_que = 3
+        else:
+            num_que = num_que
+        generated_questions_list = qg.generate(article, num_questions=int(num_que))
+        summarized_data = {
+            "generated_questions" : generated_questions_list
+        }
+        generated_questions = summarized_data.get("generated_questions",'')
+            
+        for q in generated_questions:
+            print(q)
+            result = result + q + '\n'
+        save_data_and_sendmail(article,generated_questions,num_que)
+        print("sending result***!!!!!!", result)
+        return result
+    else:
+        raise gr.Error("Please enter text in inputbox!!!!")
+   
+"""
+Save generated details
+"""
+def save_data_and_sendmail(article,generated_questions,num_que):
+    try:
+        ip_address= getIP()
+        print(ip_address)
+        location = get_location(ip_address)
+        print(location)
+        add_csv = [article, generated_questions, num_que, ip_address,location]
+        print("data^^^^^",add_csv)
+        with open(DATA_FILE, "a") as f:
+            writer = csv.writer(f)
+            # write the data
+            writer.writerow(add_csv)
+            commit_url = repo.push_to_hub()
+            print("commit data   :",commit_url)
+            
+        url = 'https://pragnakalpdev35.pythonanywhere.com/HF_space_que_gen'
+        # url = 'http://pragnakalpdev33.pythonanywhere.com/HF_space_question_generator'
+        myobj = {'article': article,'total_que': num_que,'gen_que':generated_questions,'ip_addr':ip_address,'loc':location}
+        x = requests.post(url, json = myobj) 
+        print("myobj^^^^^",myobj)
+
+    except Exception as e:
+        return "Error while sending mail" + str(e)
+        
+    return "Successfully save data"
+
+## design 1
+inputs=gr.Textbox(value=article_value, lines=5, label="Input Text/Article",elem_id="inp_div")
+total_que = gr.Textbox(label="Number of questions to generate",elem_id="inp_div")
+outputs=gr.Textbox(label="Generated Questions",lines=6,elem_id="inp_div")
+
+demo = gr.Interface(
+    generate_questions,
+    [inputs,total_que],
+    outputs,
+    title="Question Generation Using T5-Base Model",
+    css=".gradio-container {background-color: lightgray} #inp_div {background-color: #7FB3D5;}",
+    article="""<p style='text-align: center;'>Feel free to give us your <a href="https://www.pragnakalp.com/contact/" target="_blank">feedback</a> on this Question Generation using T5 demo.</p>
+                                        <p style='text-align: center;'>Developed by: <a href="https://www.pragnakalp.com" target="_blank">Pragnakalp Techlabs</a></p>"""
+    
+)
+demo.launch()

gitattributes

@@ -0,0 +1,34 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

questiongenerator.py

@@ -0,0 +1,345 @@
+import os
+import sys
+import math
+import numpy as np
+import torch
+import spacy
+import re
+import random
+import json
+import en_core_web_sm
+from string import punctuation
+
+#from transformers import T5Tokenizer, T5ForConditionalGeneration, T5Config
+#from transformers import BertTokenizer, BertForSequenceClassification
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForSequenceClassification
+class QuestionGenerator():
+
+    def __init__(self, model_dir=None):
+
+        QG_PRETRAINED = 'iarfmoose/t5-base-question-generator'
+        self.ANSWER_TOKEN = '<answer>'
+        self.CONTEXT_TOKEN = '<context>'
+        self.SEQ_LENGTH = 512
+
+        self.device = torch.device('cpu')
+        # self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+        self.qg_tokenizer = AutoTokenizer.from_pretrained(QG_PRETRAINED)
+        self.qg_model = AutoModelForSeq2SeqLM.from_pretrained(QG_PRETRAINED)
+        self.qg_model.to(self.device)
+
+        self.qa_evaluator = QAEvaluator(model_dir)
+
+    def generate(self, article, use_evaluator=True, num_questions=None, answer_style='all'):
+
+        print("Generating questions...\n")
+
+        qg_inputs, qg_answers = self.generate_qg_inputs(article, answer_style)
+        print("qg_inputs, qg_answers=>",qg_inputs, qg_answers)
+        generated_questions = self.generate_questions_from_inputs(qg_inputs,num_questions)
+        print("generated_questions(generate)=>",generated_questions)
+        return generated_questions
+        message = "{} questions doesn't match {} answers".format(
+            len(generated_questions),
+            len(qg_answers))
+        assert len(generated_questions) == len(qg_answers), message
+
+        if use_evaluator:
+
+            print("Evaluating QA pairs...\n")
+
+            encoded_qa_pairs = self.qa_evaluator.encode_qa_pairs(generated_questions, qg_answers)
+            scores = self.qa_evaluator.get_scores(encoded_qa_pairs)
+            if num_questions:
+                qa_list = self._get_ranked_qa_pairs(generated_questions, qg_answers, scores, num_questions)
+            else:
+                qa_list = self._get_ranked_qa_pairs(generated_questions, qg_answers, scores)
+
+        else:
+            print("Skipping evaluation step.\n")
+            qa_list = self._get_all_qa_pairs(generated_questions, qg_answers)
+
+        return qa_list
+
+    def generate_qg_inputs(self, text, answer_style):
+
+        VALID_ANSWER_STYLES = ['all', 'sentences', 'multiple_choice']
+
+        if answer_style not in VALID_ANSWER_STYLES:
+            raise ValueError(
+                "Invalid answer style {}. Please choose from {}".format(
+                    answer_style,
+                    VALID_ANSWER_STYLES
+                )
+            )
+
+        inputs = []
+        answers = []
+
+        if answer_style == 'sentences' or answer_style == 'all':
+            segments = self._split_into_segments(text)
+            for segment in segments:
+                sentences = self._split_text(segment)
+                prepped_inputs, prepped_answers = self._prepare_qg_inputs(sentences, segment)
+                inputs.extend(prepped_inputs)
+                answers.extend(prepped_answers)
+
+        if answer_style == 'multiple_choice' or answer_style == 'all':
+            sentences = self._split_text(text)
+            prepped_inputs, prepped_answers = self._prepare_qg_inputs_MC(sentences)
+            inputs.extend(prepped_inputs)
+            answers.extend(prepped_answers)
+
+        return inputs, answers
+
+    def generate_questions_from_inputs(self, qg_inputs,num_questions):
+        generated_questions = []
+        count = 0
+        print("num que => ", num_questions)
+        for qg_input in qg_inputs:
+            if count < int(num_questions):
+                question = self._generate_question(qg_input)
+
+                question = question.strip()                 #remove trailing spaces
+                question = question.strip(punctuation)      #remove trailing questionmarks
+                question += "?"                             #add one ?
+                if question not in generated_questions:
+                    generated_questions.append(question)
+                    print("question ===> ",question)
+                    count += 1
+            else:
+                return generated_questions
+        return generated_questions #
+    def _split_text(self, text):
+        MAX_SENTENCE_LEN = 128
+
+        sentences = re.findall('.*?[.!\?]', text)
+
+        cut_sentences = []
+        for sentence in sentences:
+            if len(sentence) > MAX_SENTENCE_LEN:
+                cut_sentences.extend(re.split('[,;:)]', sentence))
+        # temporary solution to remove useless post-quote sentence fragments
+        cut_sentences = [s for s in sentences if len(s.split(" ")) > 5]
+        sentences = sentences + cut_sentences
+
+        return list(set([s.strip(" ") for s in sentences]))
+
+    def _split_into_segments(self, text):
+        MAX_TOKENS = 490
+
+        paragraphs = text.split('\n')
+        tokenized_paragraphs = [self.qg_tokenizer(p)['input_ids'] for p in paragraphs if len(p) > 0]
+
+        segments = []
+        while len(tokenized_paragraphs) > 0:
+            segment = []
+            while len(segment) < MAX_TOKENS and len(tokenized_paragraphs) > 0:
+                paragraph = tokenized_paragraphs.pop(0)
+                segment.extend(paragraph)
+            segments.append(segment)
+        return [self.qg_tokenizer.decode(s) for s in segments]
+
+    def _prepare_qg_inputs(self, sentences, text):
+        inputs = []
+        answers = []
+
+        for sentence in sentences:
+            qg_input = '{} {} {} {}'.format(
+                self.ANSWER_TOKEN,
+                sentence,
+                self.CONTEXT_TOKEN,
+                text
+            )
+            inputs.append(qg_input)
+            answers.append(sentence)
+
+        return inputs, answers
+
+    def _prepare_qg_inputs_MC(self, sentences):
+
+        spacy_nlp = en_core_web_sm.load()
+        docs = list(spacy_nlp.pipe(sentences, disable=['parser']))
+        inputs_from_text = []
+        answers_from_text = []
+
+        for i in range(len(sentences)):
+            entities = docs[i].ents
+            if entities:
+                for entity in entities:
+                    qg_input = '{} {} {} {}'.format(
+                        self.ANSWER_TOKEN,
+                        entity,
+                        self.CONTEXT_TOKEN,
+                        sentences[i]
+                    )
+                    answers = self._get_MC_answers(entity, docs)
+                    inputs_from_text.append(qg_input)
+                    answers_from_text.append(answers)
+
+        return inputs_from_text, answers_from_text
+
+    def _get_MC_answers(self, correct_answer, docs):
+
+        entities = []
+        for doc in docs:
+            entities.extend([{'text': e.text, 'label_': e.label_} for e in doc.ents])
+
+        # remove duplicate elements
+        entities_json = [json.dumps(kv) for kv in entities]
+        pool = set(entities_json)
+        num_choices = min(4, len(pool)) - 1  # -1 because we already have the correct answer
+
+        # add the correct answer
+        final_choices = []
+        correct_label = correct_answer.label_
+        final_choices.append({'answer': correct_answer.text, 'correct': True})
+        pool.remove(json.dumps({'text': correct_answer.text, 'label_': correct_answer.label_}))
+
+        # find answers with the same NER label
+        matches = [e for e in pool if correct_label in e]
+
+        # if we don't have enough then add some other random answers
+        if len(matches) < num_choices:
+            choices = matches
+            pool = pool.difference(set(choices))
+            choices.extend(random.sample(pool, num_choices - len(choices)))
+        else:
+            choices = random.sample(matches, num_choices)
+
+        choices = [json.loads(s) for s in choices]
+        for choice in choices:
+            final_choices.append({'answer': choice['text'], 'correct': False})
+        random.shuffle(final_choices)
+        return final_choices
+
+    def _generate_question(self, qg_input):
+        self.qg_model.eval()
+        encoded_input = self._encode_qg_input(qg_input)
+        with torch.no_grad():
+            output = self.qg_model.generate(input_ids=encoded_input['input_ids'])
+        return self.qg_tokenizer.decode(output[0])
+
+    def _encode_qg_input(self, qg_input):
+        return self.qg_tokenizer(
+            qg_input,
+            pad_to_max_length=True,
+            max_length=self.SEQ_LENGTH,
+            truncation=True,
+            return_tensors="pt"
+        ).to(self.device)
+
+    def _get_ranked_qa_pairs(self, generated_questions, qg_answers, scores, num_questions=10):
+        if num_questions > len(scores):
+            num_questions = len(scores)
+            print("\nWas only able to generate {} questions. For more questions, please input a longer text.".format(num_questions))
+
+        qa_list = []
+        for i in range(num_questions):
+            index = scores[i]
+            qa = self._make_dict(
+                generated_questions[index].split('?')[0] + '?',
+                qg_answers[index])
+            qa_list.append(qa)
+        return qa_list
+
+    def _get_all_qa_pairs(self, generated_questions, qg_answers):
+        qa_list = []
+        for i in range(len(generated_questions)):
+            qa = self._make_dict(
+                generated_questions[i].split('?')[0] + '?',
+                qg_answers[i])
+            qa_list.append(qa)
+        return qa_list
+
+    def _make_dict(self, question, answer):
+        qa = {}
+        qa['question'] = question
+        qa['answer'] = answer
+        return qa
+
+
+class QAEvaluator():
+    def __init__(self, model_dir=None):
+
+        QAE_PRETRAINED = 'iarfmoose/bert-base-cased-qa-evaluator'
+        self.SEQ_LENGTH = 512
+
+        self.device = torch.device('cpu')
+        # self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+        self.qae_tokenizer = AutoTokenizer.from_pretrained(QAE_PRETRAINED)
+        self.qae_model = AutoModelForSequenceClassification.from_pretrained(QAE_PRETRAINED)
+        self.qae_model.to(self.device)
+
+
+    def encode_qa_pairs(self, questions, answers):
+        encoded_pairs = []
+        for i in range(len(questions)):
+            encoded_qa = self._encode_qa(questions[i], answers[i])
+            encoded_pairs.append(encoded_qa.to(self.device))
+        return encoded_pairs
+
+    def get_scores(self, encoded_qa_pairs):
+        scores = {}
+        self.qae_model.eval()
+        with torch.no_grad():
+            for i in range(len(encoded_qa_pairs)):
+                scores[i] = self._evaluate_qa(encoded_qa_pairs[i])
+
+        return [k for k, v in sorted(scores.items(), key=lambda item: item[1], reverse=True)]
+
+    def _encode_qa(self, question, answer):
+        if type(answer) is list:
+            for a in answer:
+                if a['correct']:
+                    correct_answer = a['answer']
+        else:
+            correct_answer = answer
+        return self.qae_tokenizer(
+            text=question,
+            text_pair=correct_answer,
+            pad_to_max_length=True,
+            max_length=self.SEQ_LENGTH,
+            truncation=True,
+            return_tensors="pt"
+        )
+
+    def _evaluate_qa(self, encoded_qa_pair):
+        output = self.qae_model(**encoded_qa_pair)
+        return output[0][0][1]
+
+
+def print_qa(qa_list, show_answers=True):
+    for i in range(len(qa_list)):
+        space = ' ' * int(np.where(i < 9, 3, 4)) # wider space for 2 digit q nums
+
+        print('{}) Q: {}'.format(i + 1, qa_list[i]['question']))
+
+        answer = qa_list[i]['answer']
+
+        # print a list of multiple choice answers
+        if type(answer) is list:
+
+            if show_answers:
+                print('{}A: 1.'.format(space),
+                      answer[0]['answer'],
+                      np.where(answer[0]['correct'], '(correct)', ''))
+                for j in range(1, len(answer)):
+                    print('{}{}.'.format(space + '   ', j + 1),
+                          answer[j]['answer'],
+                          np.where(answer[j]['correct'] == True, '(correct)', ''))
+
+            else:
+                print('{}A: 1.'.format(space),
+                      answer[0]['answer'])
+                for j in range(1, len(answer)):
+                    print('{}{}.'.format(space + '   ', j + 1),
+                          answer[j]['answer'])
+            print('')
+
+        # print full sentence answers
+        else:
+            if show_answers:
+                print('{}A:'.format(space), answer, '\n')

requirements (1).txt

@@ -0,0 +1,15 @@
+
+en-core-web-sm @ https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-2.3.1/en_core_web_sm-2.3.1.tar.gz
+Flask==1.1.2
+future==0.18.2
+gradio==3.44.1
+Jinja2==2.11.2
+joblib==0.17.0
+markupsafe==2.0.1
+numpy
+requests==2.24.0
+sentencepiece==0.1.99
+spacy
+torch==2.0.1
+tqdm==4.51.0
+transformers==4.30.2

run_qg.py

@@ -0,0 +1,73 @@
+import argparse
+import numpy as np
+from questiongenerator import QuestionGenerator
+from questiongenerator import print_qa
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--text_dir",
+        default=None,
+        type=str,
+        required=True,
+        help="The text that will be used as context for question generation.",
+    )
+    parser.add_argument(
+        "--model_dir",
+        default=None,
+        type=str,
+        help="The folder that the trained model checkpoints are in.",
+    )
+    parser.add_argument(
+        "--num_questions",
+        default=10,
+        type=int,
+        help="The desired number of questions to generate.",
+    )
+    parser.add_argument(
+        "--answer_style",
+        default="all",
+        type=str,
+        help="The desired type of answers. Choose from ['all', 'sentences', 'multiple_choice']",
+    )
+    parser.add_argument(
+        "--show_answers",
+        default='True',
+        type=parse_bool_string,
+        help="Whether or not you want the answers to be visible. Choose from ['True', 'False']",
+    )
+    parser.add_argument(
+        "--use_qa_eval",
+        default='True',
+        type=parse_bool_string,
+        help="Whether or not you want the generated questions to be filtered for quality. Choose from ['True', 'False']",
+    )
+    args = parser.parse_args()
+
+    with open(args.text_dir, 'r') as file:
+        text_file = file.read()
+
+    qg = QuestionGenerator(args.model_dir)
+
+    qa_list = qg.generate(
+        text_file,
+        num_questions=int(args.num_questions),
+        answer_style=args.answer_style,
+        use_evaluator=args.use_qa_eval
+    )
+    print_qa(qa_list, show_answers=args.show_answers)
+
+# taken from https://stackoverflow.com/questions/15008758/parsing-boolean-values-with-argparse
+def parse_bool_string(s):
+    if isinstance(s, bool):
+        return s
+    if s.lower() in ('yes', 'true', 't', 'y', '1'):
+        return True
+    elif s.lower() in ('no', 'false', 'f', 'n', '0'):
+        return False
+    else:
+        raise argparse.ArgumentTypeError('Boolean value expected.')
+
+
+if __name__ == "__main__":
+    main()