Removed old scripts and added quiz logic

mcq_generator.ipynb

@@ -1,423 +0,0 @@
-{
-  "nbformat": 4,
-  "nbformat_minor": 0,
-  "metadata": {
-    "colab": {
-      "provenance": [],
-      "gpuType": "T4",
-      "authorship_tag": "ABX9TyNlLgN36uc2PRyXWiLUUS03",
-      "include_colab_link": true
-    },
-    "kernelspec": {
-      "name": "python3",
-      "display_name": "Python 3"
-    },
-    "language_info": {
-      "name": "python"
-    },
-    "accelerator": "GPU"
-  },
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "view-in-github",
-        "colab_type": "text"
-      },
-      "source": [
-        "<a href=\"https://colab.research.google.com/github/DishaKushwah/custom-quiz-generator/blob/main/mcq_generator.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "## MCQS\n",
-        "import torch\n",
-        "from transformers import (\n",
-        "    AutoTokenizer, AutoModel\n",
-        ")\n",
-        "from transformers.pipelines import pipeline\n",
-        "from transformers.models.t5 import T5ForConditionalGeneration, T5Tokenizer\n",
-        "\n",
-        "from sentence_transformers import SentenceTransformer\n",
-        "import spacy\n",
-        "import numpy as np\n",
-        "from sklearn.metrics.pairwise import cosine_similarity\n",
-        "import re\n",
-        "import random\n",
-        "from typing import List, Dict, Tuple\n",
-        "import nltk\n",
-        "from nltk.corpus import wordnet\n",
-        "import string\n",
-        "\n",
-        "class MultipleChoiceQuestionGenerator:\n",
-        "    def __init__(self):\n",
-        "        \"\"\"Initialize the MCQ generator with advanced models.\"\"\"\n",
-        "        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
-        "\n",
-        "        # Load T5 model for question generation\n",
-        "        self.qg_model_name = \"valhalla/t5-base-qg-hl\"\n",
-        "        self.qg_tokenizer = T5Tokenizer.from_pretrained(self.qg_model_name)\n",
-        "        self.qg_model = T5ForConditionalGeneration.from_pretrained(self.qg_model_name).to(self.device)\n",
-        "\n",
-        "        # Load question-answering pipeline for answer validation\n",
-        "        self.qa_pipeline = pipeline(\n",
-        "            \"question-answering\",\n",
-        "            model=\"deepset/roberta-large-squad2\",\n",
-        "            tokenizer=\"deepset/roberta-large-squad2\",\n",
-        "            device=0 if torch.cuda.is_available() else -1\n",
-        "        )\n",
-        "\n",
-        "        # Load sentence transformer for semantic similarity (distractor generation)\n",
-        "        self.sentence_model = SentenceTransformer('all-MiniLM-L6-v2')\n",
-        "\n",
-        "        # Load spaCy for NLP processing\n",
-        "        try:\n",
-        "            self.nlp = spacy.load(\"en_core_web_sm\")\n",
-        "        except OSError:\n",
-        "            print(\"Please install spaCy English model: python -m spacy download en_core_web_sm\")\n",
-        "            self.nlp = None\n",
-        "\n",
-        "        # Load fill-mask pipeline for generating distractors\n",
-        "        self.fill_mask = pipeline(\"fill-mask\",model=\"roberta-large\",tokenizer=\"roberta-large\",device=0 if torch.cuda.is_available() else -1)\n",
-        "\n",
-        "        # Download NLTK data\n",
-        "        try:\n",
-        "            nltk.download('wordnet', quiet=True)\n",
-        "            nltk.download('omw-1.4', quiet=True)\n",
-        "        except:\n",
-        "            pass\n",
-        "\n",
-        "    def extract_key_information(self, text: str) -> Dict:\n",
-        "        \"\"\"Extract key information from text for question generation.\"\"\"\n",
-        "        if not self.nlp:\n",
-        "            return {\"entities\": [], \"noun_chunks\": [], \"sentences\": []}\n",
-        "\n",
-        "        doc = self.nlp(text)\n",
-        "        # Extract named entities\n",
-        "        entities = []\n",
-        "        for ent in doc.ents:\n",
-        "            if ent.label_ in ['PERSON', 'ORG', 'GPE', 'DATE', 'EVENT', 'WORK_OF_ART', 'CARDINAL', 'ORDINAL']:\n",
-        "                entities.append({'text': ent.text,'label': ent.label_,'start': ent.start_char,'end': ent.end_char})\n",
-        "\n",
-        "        # Extract noun chunks\n",
-        "        noun_chunks = [chunk.text for chunk in doc.noun_chunks if len(chunk.text.split()) <= 4]\n",
-        "\n",
-        "        # Extract sentences\n",
-        "        sentences = [sent.text.strip() for sent in doc.sents if len(sent.text.split()) > 5]\n",
-        "\n",
-        "        return {\"entities\": entities,\"noun_chunks\": noun_chunks,\"sentences\": sentences}\n",
-        "\n",
-        "    def generate_question_from_context(self, context: str, answer_text: str) -> str:\n",
-        "        \"\"\"Generate a question given context and answer.\"\"\"\n",
-        "        # Highlight the answer in the context for T5\n",
-        "        highlighted_context = context.replace(answer_text, f\"<hl>{answer_text}<hl>\")\n",
-        "        input_text = f\"generate question: {highlighted_context}\"\n",
-        "        inputs = self.qg_tokenizer.encode_plus(input_text,max_length=512,truncation=True,padding=True,return_tensors=\"pt\").to(self.device)\n",
-        "\n",
-        "        with torch.no_grad():\n",
-        "            outputs = self.qg_model.generate(inputs[\"input_ids\"],attention_mask=inputs[\"attention_mask\"],max_length=64,num_beams=4,temperature=0.8,do_sample=True,early_stopping=True)\n",
-        "\n",
-        "        question = self.qg_tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
-        "        return question\n",
-        "\n",
-        "    def generate_distractors_semantic(self, correct_answer: str, context: str, num_distractors: int = 3) -> List[str]:\n",
-        "        \"\"\"Generate distractors using semantic similarity and context understanding.\"\"\"\n",
-        "        distractors = []\n",
-        "\n",
-        "        # Method 1: Use fill-mask to generate contextually similar options\n",
-        "        try:\n",
-        "            # Replace answer with mask in context\n",
-        "            masked_context = context.replace(correct_answer, \"<mask>\")\n",
-        "            if \"<mask>\" in masked_context:\n",
-        "                predictions = self.fill_mask(masked_context, top_k=20)\n",
-        "                for pred in predictions:\n",
-        "                    candidate = pred['token_str'].strip()\n",
-        "                    if (candidate != correct_answer and\n",
-        "                        candidate.lower() != correct_answer.lower() and\n",
-        "                        len(candidate) > 1 and\n",
-        "                        candidate not in distractors):\n",
-        "                        distractors.append(candidate)\n",
-        "                        if len(distractors) >= num_distractors:\n",
-        "                            break\n",
-        "        except:\n",
-        "            pass\n",
-        "\n",
-        "        # Method 2: Extract similar entities from context\n",
-        "        if self.nlp and len(distractors) < num_distractors:\n",
-        "            doc = self.nlp(context)\n",
-        "            answer_doc = self.nlp(correct_answer)\n",
-        "\n",
-        "            # Get answer entity type\n",
-        "            answer_label = None\n",
-        "            for ent in answer_doc.ents:\n",
-        "                answer_label = ent.label_\n",
-        "                break\n",
-        "\n",
-        "            # Find similar entities\n",
-        "            for ent in doc.ents:\n",
-        "                if (ent.label_ == answer_label and ent.text != correct_answer and ent.text not in distractors):\n",
-        "                    distractors.append(ent.text)\n",
-        "                    if len(distractors) >= num_distractors:\n",
-        "                        break\n",
-        "\n",
-        "        # Method 3: Generate using WordNet synonyms and related words\n",
-        "        if len(distractors) < num_distractors:\n",
-        "            try:\n",
-        "                words = correct_answer.split()\n",
-        "                for word in words:\n",
-        "                    synsets = wordnet.synsets(word)\n",
-        "                    for synset in synsets[:3]:\n",
-        "                        for lemma in synset.lemmas()[:2]:\n",
-        "                            candidate = lemma.name().replace('_', ' ')\n",
-        "                            if (candidate != correct_answer and\n",
-        "                                candidate.lower() != correct_answer.lower() and\n",
-        "                                candidate not in distractors):\n",
-        "                                distractors.append(candidate)\n",
-        "                                if len(distractors) >= num_distractors:\n",
-        "                                    break\n",
-        "                        if len(distractors) >= num_distractors:\n",
-        "                            break\n",
-        "                    if len(distractors) >= num_distractors:\n",
-        "                        break\n",
-        "            except:\n",
-        "                pass\n",
-        "\n",
-        "        # Method 4: Generate plausible distractors based on answer type\n",
-        "        if len(distractors) < num_distractors:\n",
-        "            distractors.extend(self.generate_type_based_distractors(correct_answer, context))\n",
-        "\n",
-        "        # Remove duplicates and return\n",
-        "        unique_distractors = []\n",
-        "        seen = set()\n",
-        "        for d in distractors:\n",
-        "            if d.lower() not in seen and d.lower() != correct_answer.lower():\n",
-        "                seen.add(d.lower())\n",
-        "                unique_distractors.append(d)\n",
-        "        return unique_distractors[:num_distractors]\n",
-        "\n",
-        "    def validate_mcq_quality(self, question: str, correct_answer: str, distractors: List[str], context: str) -> Dict:\n",
-        "        \"\"\"Validate the quality of generated MCQ.\"\"\"\n",
-        "        # Check if the question can be answered correctly\n",
-        "        try:\n",
-        "            qa_result = self.qa_pipeline(question=question, context=context)\n",
-        "            predicted_answer = qa_result['answer']\n",
-        "            confidence = qa_result['score']\n",
-        "\n",
-        "            # Check if predicted answer matches or is similar to correct answer\n",
-        "            similarity_threshold = 0.7\n",
-        "            correct_embedding = self.sentence_model.encode([correct_answer])\n",
-        "            predicted_embedding = self.sentence_model.encode([predicted_answer])\n",
-        "            similarity = cosine_similarity(correct_embedding, predicted_embedding)[0][0]\n",
-        "            is_answerable = similarity > similarity_threshold or correct_answer.lower() in predicted_answer.lower()\n",
-        "\n",
-        "        except:\n",
-        "            is_answerable = False\n",
-        "            confidence = 0.0\n",
-        "            similarity = 0.0\n",
-        "\n",
-        "        # Check distractor quality\n",
-        "        if len(distractors) > 0:\n",
-        "            distractor_embeddings = self.sentence_model.encode(distractors)\n",
-        "            correct_embedding = self.sentence_model.encode([correct_answer])\n",
-        "\n",
-        "            # Calculate similarity between distractors and correct answer\n",
-        "            similarities = cosine_similarity(correct_embedding, distractor_embeddings)[0]\n",
-        "            avg_distractor_similarity = np.mean(similarities)\n",
-        "\n",
-        "            # Good distractors should be somewhat similar but not too similar\n",
-        "            distractor_quality = \"good\" if 0.3 < avg_distractor_similarity < 0.8 else \"poor\"\n",
-        "        else:\n",
-        "            distractor_quality = \"poor\"\n",
-        "            avg_distractor_similarity = 0.0\n",
-        "\n",
-        "        return {\"is_answerable\": is_answerable,\"confidence\": confidence,\"answer_similarity\": similarity,\"distractor_quality\": distractor_quality,\"avg_distractor_similarity\": avg_distractor_similarity }\n",
-        "\n",
-        "    def generate_mcq(self, context: str, num_questions: int = 5) -> List[Dict]:\n",
-        "        \"\"\"Generate multiple choice questions from context.\"\"\"\n",
-        "        mcqs = []\n",
-        "\n",
-        "        # Extract key information\n",
-        "        key_info = self.extract_key_information(context)\n",
-        "\n",
-        "        # Generate questions from entities\n",
-        "        for entity in key_info[\"entities\"][:num_questions]:\n",
-        "            correct_answer = entity[\"text\"]\n",
-        "\n",
-        "            # Generate question\n",
-        "            question = self.generate_question_from_context(context, correct_answer)\n",
-        "\n",
-        "            # Generate distractors\n",
-        "            distractors = self.generate_distractors_semantic(correct_answer, context, 3)\n",
-        "\n",
-        "            # Skip if not enough distractors\n",
-        "            if len(distractors) < 2:\n",
-        "                continue\n",
-        "\n",
-        "            # Validate quality\n",
-        "            quality = self.validate_mcq_quality(question, correct_answer, distractors, context)\n",
-        "\n",
-        "            # Create options and shuffle\n",
-        "            options = [correct_answer] + distractors[:3]\n",
-        "            random.shuffle(options)\n",
-        "            correct_option = chr(65 + options.index(correct_answer))  # A, B, C, D\n",
-        "\n",
-        "            mcq = {\n",
-        "                \"question\": question,\n",
-        "                \"options\": {\"A\": options[0],\"B\": options[1],\"C\": options[2] if len(options) > 2 else \"None of the above\",\"D\": options[3] if len(options) > 3 else \"All of the above\"},\n",
-        "                \"correct_answer\": correct_option,\n",
-        "                \"correct_text\": correct_answer,\n",
-        "                \"entity_type\": entity[\"label\"],\n",
-        "                \"quality_score\": quality[\"confidence\"],\n",
-        "                \"is_answerable\": quality[\"is_answerable\"]\n",
-        "            }\n",
-        "\n",
-        "            # Only include high-quality MCQs\n",
-        "            if quality[\"is_answerable\"] and quality[\"confidence\"] > 0.3:\n",
-        "                mcqs.append(mcq)\n",
-        "\n",
-        "        # Generate additional questions from noun chunks if needed\n",
-        "        if len(mcqs) < num_questions:\n",
-        "            for chunk in key_info[\"noun_chunks\"][:num_questions - len(mcqs)]:\n",
-        "                question = self.generate_question_from_context(context, chunk)\n",
-        "                distractors = self.generate_distractors_semantic(chunk, context, 3)\n",
-        "\n",
-        "                if len(distractors) >= 2:\n",
-        "                    quality = self.validate_mcq_quality(question, chunk, distractors, context)\n",
-        "\n",
-        "                    if quality[\"is_answerable\"] and quality[\"confidence\"] > 0.2:\n",
-        "                        options = [chunk] + distractors[:3]\n",
-        "                        random.shuffle(options)\n",
-        "                        correct_option = chr(65 + options.index(chunk))\n",
-        "\n",
-        "                        mcq = {\n",
-        "                            \"question\": question,\n",
-        "                            \"options\": {\"A\": options[0],\"B\": options[1],\"C\": options[2] if len(options) > 2 else \"None of the above\",\"D\": options[3] if len(options) > 3 else \"All of the above\"},\n",
-        "                            \"correct_answer\": correct_option,\n",
-        "                            \"correct_text\": chunk,\n",
-        "                            \"entity_type\": \"NOUN_CHUNK\",\n",
-        "                            \"quality_score\": quality[\"confidence\"],\n",
-        "                            \"is_answerable\": quality[\"is_answerable\"]\n",
-        "                        }\n",
-        "                        mcqs.append(mcq)\n",
-        "\n",
-        "        # Sort by quality score and return\n",
-        "        mcqs.sort(key=lambda x: x[\"quality_score\"], reverse=True)\n",
-        "        return mcqs[:num_questions]\n",
-        "\n",
-        "def main():\n",
-        "    \"\"\"Main function to demonstrate the MCQ generator.\"\"\"\n",
-        "    generator = MultipleChoiceQuestionGenerator()\n",
-        "    print(\"Multiple Choice Question Generator\")\n",
-        "\n",
-        "    # Get user input\n",
-        "    user_context = input(\"Enter your context: \").strip()\n",
-        "    try:\n",
-        "        num_questions = int(input(\"Number of MCQs to generate (default 5): \") or \"5\")\n",
-        "    except ValueError:\n",
-        "        num_questions = 5\n",
-        "    print(f\"\\nGenerating {num_questions} multiple choice questions...\")\n",
-        "\n",
-        "    # Generate MCQs\n",
-        "    mcqs = generator.generate_mcq(user_context, num_questions)\n",
-        "    # Display results\n",
-        "    if mcqs:\n",
-        "        for i, mcq in enumerate(mcqs, 1):\n",
-        "            print(f\"\\nQuestion {i}: \")\n",
-        "            print(f\"Q: {mcq['question']}\")\n",
-        "            print()\n",
-        "            for option, text in mcq['options'].items():\n",
-        "                print(f\"{option}) {text}\")\n",
-        "            print(f\"\\nCorrect Answer: {mcq['correct_answer']}) {mcq['correct_text']}\")\n",
-        "    else:\n",
-        "        print(\"No high-quality MCQs could be generated from the provided context.\")\n",
-        "        print(\"Try providing a longer, more detailed context with specific facts and entities.\")\n",
-        "\n",
-        "    print(\"\\nGeneration complete!\")\n",
-        "\n",
-        "if __name__ == \"__main__\":\n",
-        "    main()"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "o1ic84jCGc-u",
-        "outputId": "82f5601f-0e8f-4ca7-d9a4-b514a58df793"
-      },
-      "execution_count": null,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "Device set to use cpu\n",
-            "Device set to use cpu\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Multiple Choice Question Generator\n",
-            "Enter your context (or press Enter to use sample): India has numerous national parks dedicated to preserving wildlife and biodiversity. Some of the most famous include Jim Corbett National Park in Uttarakhand, known for tigers; Kaziranga National Park in Assam, home to the one-horned rhinoceros; and Sundarbans in West Bengal, famous for mangrove forests and Royal Bengal Tigers. These parks also support eco-tourism and help protect endangered species and fragile ecosystems.\n",
-            "Number of MCQs to generate (default 5): 4\n",
-            "\n",
-            "Generating 4 multiple choice questions...\n",
-            "\n",
-            "Question 1: \n",
-            "Q: What country has numerous national parks dedicated to preserving wildlife and biodiversity?\n",
-            "\n",
-            "A) Asia\n",
-            "B) India\n",
-            "C) Indian\n",
-            "D) Pakistan\n",
-            "\n",
-            "Correct Answer: B) India\n",
-            "\n",
-            "Question 2: \n",
-            "Q: What national park in Uttarakhand is known for tigers?\n",
-            "\n",
-            "A) Sanctuary\n",
-            "B) Leh\n",
-            "C) Jim Corbett National Park\n",
-            "D) Gir\n",
-            "\n",
-            "Correct Answer: C) Jim Corbett National Park\n",
-            "\n",
-            "Question 3: \n",
-            "Q: Where is Jim Corbett National Park located?\n",
-            "\n",
-            "A) Uttarakhand\n",
-            "B) Maharashtra\n",
-            "C) Kerala\n",
-            "D) Bengal\n",
-            "\n",
-            "Correct Answer: A) Uttarakhand\n",
-            "\n",
-            "Question 4: \n",
-            "Q: How many horned rhinoceros live in Kaziranga National Park?\n",
-            "\n",
-            "A) big\n",
-            "B) one\n",
-            "C) great\n",
-            "D) two\n",
-            "\n",
-            "Correct Answer: B) one\n",
-            "\n",
-            "Generation complete!\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [],
-      "metadata": {
-        "id": "cR-tHf45INso"
-      },
-      "execution_count": null,
-      "outputs": []
-    }
-  ]
-}

quiz_logic.py

@@ -0,0 +1,78 @@
+# quiz_logic.py
+import random
+import nltk
+from transformers import pipeline
+from nltk.tokenize import sent_tokenize
+
+# Download required tokenizer
+nltk.download('punkt', quiet=True)
+
+# Load NLI model
+nli = pipeline("text-classification", model="facebook/bart-large-mnli")
+
+def validate_inputs(context, num_questions, difficulty):
+    if not context.strip():
+        return False, "Context cannot be empty."
+    sentences = sent_tokenize(context)
+    if len(sentences) < num_questions:
+        return False, f"Context has only {len(sentences)} sentences, but {num_questions} questions requested."
+    if difficulty not in ["easy", "medium", "hard"]:
+        return False, "Difficulty must be 'easy', 'medium', or 'hard'."
+    return True, sentences
+
+def apply_noise(sentence: str, level: str) -> str:
+    if level == "easy":
+        return sentence
+    elif level == "medium":
+        if "Sun" in sentence:
+            return sentence.replace("Sun", "Moon")
+        return sentence.replace("is", "is not") if "is" in sentence else sentence
+    elif level == "hard":
+        if "eight" in sentence:
+            return sentence.replace("eight", "ten")
+        return sentence.replace("planets", "stars") if "planets" in sentence else sentence
+    return sentence
+
+def generate_statements(context, n, difficulty, sentences):
+    random.seed(42)
+    selected = random.sample(sentences, min(n * 2, len(sentences)))
+    final = []
+    for s in selected:
+        clean = s.strip()
+        modified = apply_noise(clean, difficulty)
+        label = "ENTAILMENT" if clean == modified else "CONTRADICTION"
+        final.append({"statement": modified, "actual_label": label})
+        if len(final) >= n:
+            break
+    return final
+
+def score_answers(context, answers):
+    score = 0
+    results = []
+    for answer in answers:
+        statement = answer.get('statement')
+        user_answer = answer.get('user_answer', '').strip().lower()
+        if user_answer not in ['true', 'false']:
+            results.append({
+                "statement": statement,
+                "result": "Invalid answer. Please use 'true' or 'false'."
+            })
+            continue
+        input_text = f"{context} [SEP] {statement}"
+        result = nli(input_text)[0]
+        if result["label"] == "neutral":
+            results.append({
+                "statement": statement,
+                "result": "Skipped due to ambiguous statement."
+            })
+            continue
+        model_label = "ENTAILMENT" if result["label"] == "entailment" else "CONTRADICTION"
+        is_correct = (model_label == "ENTAILMENT" and user_answer == "true") or \
+                     (model_label == "CONTRADICTION" and user_answer == "false")
+        results.append({
+            "statement": statement,
+            "result": "Correct" if is_correct else f"Incorrect (Correct answer: {'True' if model_label == 'ENTAILMENT' else 'False'})"
+        })
+        if is_correct:
+            score += 1
+    return score, results

short_answer_generator.ipynb

@@ -1,603 +0,0 @@
-{
-  "nbformat": 4,
-  "nbformat_minor": 0,
-  "metadata": {
-    "colab": {
-      "provenance": [],
-      "authorship_tag": "ABX9TyP9geFhx2LxpKcLjq1rwpK/",
-      "include_colab_link": true
-    },
-    "kernelspec": {
-      "name": "python3",
-      "display_name": "Python 3"
-    },
-    "language_info": {
-      "name": "python"
-    }
-  },
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "view-in-github",
-        "colab_type": "text"
-      },
-      "source": [
-        "<a href=\"https://colab.research.google.com/github/DishaKushwah/custom-quiz-generator/blob/main/short_answer_generator.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": 2,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "M8kqiMR4-nfk",
-        "outputId": "aef8799d-e2d0-4868-a31a-23f9f58d7bd7"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Requirement already satisfied: transformers in /usr/local/lib/python3.11/dist-packages (4.53.1)\n",
-            "Collecting transformers\n",
-            "  Downloading transformers-4.53.2-py3-none-any.whl.metadata (40 kB)\n",
-            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m40.9/40.9 kB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25hRequirement already satisfied: filelock in /usr/local/lib/python3.11/dist-packages (from transformers) (3.18.0)\n",
-            "Requirement already satisfied: huggingface-hub<1.0,>=0.30.0 in /usr/local/lib/python3.11/dist-packages (from transformers) (0.33.2)\n",
-            "Requirement already satisfied: numpy>=1.17 in /usr/local/lib/python3.11/dist-packages (from transformers) (2.0.2)\n",
-            "Requirement already satisfied: packaging>=20.0 in /usr/local/lib/python3.11/dist-packages (from transformers) (24.2)\n",
-            "Requirement already satisfied: pyyaml>=5.1 in /usr/local/lib/python3.11/dist-packages (from transformers) (6.0.2)\n",
-            "Requirement already satisfied: regex!=2019.12.17 in /usr/local/lib/python3.11/dist-packages (from transformers) (2024.11.6)\n",
-            "Requirement already satisfied: requests in /usr/local/lib/python3.11/dist-packages (from transformers) (2.32.3)\n",
-            "Requirement already satisfied: tokenizers<0.22,>=0.21 in /usr/local/lib/python3.11/dist-packages (from transformers) (0.21.2)\n",
-            "Requirement already satisfied: safetensors>=0.4.3 in /usr/local/lib/python3.11/dist-packages (from transformers) (0.5.3)\n",
-            "Requirement already satisfied: tqdm>=4.27 in /usr/local/lib/python3.11/dist-packages (from transformers) (4.67.1)\n",
-            "Requirement already satisfied: fsspec>=2023.5.0 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub<1.0,>=0.30.0->transformers) (2025.3.2)\n",
-            "Requirement already satisfied: typing-extensions>=3.7.4.3 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub<1.0,>=0.30.0->transformers) (4.14.1)\n",
-            "Requirement already satisfied: hf-xet<2.0.0,>=1.1.2 in /usr/local/lib/python3.11/dist-packages (from huggingface-hub<1.0,>=0.30.0->transformers) (1.1.5)\n",
-            "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.11/dist-packages (from requests->transformers) (3.4.2)\n",
-            "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.11/dist-packages (from requests->transformers) (3.10)\n",
-            "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.11/dist-packages (from requests->transformers) (2.4.0)\n",
-            "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.11/dist-packages (from requests->transformers) (2025.7.9)\n",
-            "Downloading transformers-4.53.2-py3-none-any.whl (10.8 MB)\n",
-            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.8/10.8 MB\u001b[0m \u001b[31m105.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
-            "\u001b[?25hInstalling collected packages: transformers\n",
-            "  Attempting uninstall: transformers\n",
-            "    Found existing installation: transformers 4.53.1\n",
-            "    Uninstalling transformers-4.53.1:\n",
-            "      Successfully uninstalled transformers-4.53.1\n",
-            "Successfully installed transformers-4.53.2\n"
-          ]
-        }
-      ],
-      "source": [
-        "## SHORT ANSWERS\n",
-        "%pip install --upgrade transformers\n",
-        "import torch\n",
-        "from transformers import (AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForQuestionAnswering, pipeline, T5ForConditionalGeneration, T5Tokenizer)\n",
-        "import spacy\n",
-        "import numpy as np\n",
-        "from sentence_transformers import SentenceTransformer\n",
-        "import re\n",
-        "import nltk\n",
-        "from nltk.tokenize import sent_tokenize\n",
-        "from typing import List, Dict, Tuple, Optional\n",
-        "import random\n",
-        "from dataclasses import dataclass\n",
-        "import json"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [
-        "@dataclass\n",
-        "class ShortAnswerQuestion:\n",
-        "    question: str\n",
-        "    answer: str\n",
-        "    context_sentence: str\n",
-        "    question_type: str\n",
-        "    difficulty: str\n",
-        "    confidence: float\n",
-        "    keywords: List[str]\n",
-        "    expected_length: str\n",
-        "\n",
-        "class AdvancedShortAnswerGenerator:\n",
-        "    def __init__(self):\n",
-        "        \"\"\"Initialize with state-of-the-art models for question generation.\"\"\"\n",
-        "        self.device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\n",
-        "        # Load the best question generation model - T5-large fine-tuned for QG\n",
-        "        self.qg_model_name = \"valhalla/t5-base-qg-hl\"\n",
-        "\n",
-        "        # Use AutoTokenizer and AutoModelForSeq2SeqLM for broader compatibility\n",
-        "        self.qg_tokenizer = AutoTokenizer.from_pretrained(self.qg_model_name)\n",
-        "        self.qg_model = AutoModelForSeq2SeqLM.from_pretrained(self.qg_model_name).to(self.device)\n",
-        "\n",
-        "        # Load FLAN-T5 for better question generation\n",
-        "        self.flan_model_name = \"google/flan-t5-base\"\n",
-        "        self.flan_tokenizer = AutoTokenizer.from_pretrained(self.flan_model_name)\n",
-        "        self.flan_model = AutoModelForSeq2SeqLM.from_pretrained(self.flan_model_name).to(self.device)\n",
-        "\n",
-        "        # Load DeBERta for high-quality answer extraction\n",
-        "        self.qa_model_name = \"deepset/roberta-base-squad2\"\n",
-        "        self.qa_tokenizer = AutoTokenizer.from_pretrained(self.qa_model_name)\n",
-        "        self.qa_model = AutoModelForQuestionAnswering.from_pretrained(self.qa_model_name).to(self.device)\n",
-        "\n",
-        "        # Load sentence transformer for semantic analysis\n",
-        "        self.sentence_model = SentenceTransformer('all-mpnet-base-v2')\n",
-        "\n",
-        "        # Load spaCy for advanced NLP\n",
-        "        try:\n",
-        "            self.nlp = spacy.load(\"en_core_web_sm\")\n",
-        "        except OSError:\n",
-        "            print(\"Please install spaCy English model: python -m spacy download en_core_web_sm\")\n",
-        "            self.nlp = None\n",
-        "        try:\n",
-        "            nltk.download('punkt', quiet=True)\n",
-        "            nltk.download('stopwords', quiet=True)\n",
-        "            nltk.download('averaged_perceptron_tagger', quiet=True)\n",
-        "            nltk.download('punkt_tab', quiet=True) # Added download for punkt_tab\n",
-        "        except:\n",
-        "            pass\n",
-        "        # Question type templates\n",
-        "        self.question_templates = {\n",
-        "            'factual': [\"What is {}?\",\"What does {} mean?\",\"What are the characteristics of {}?\",\"Define {}.\",\"Explain {}.\"],\n",
-        "            'analytical': [\"How does {} work?\",\"Why is {} important?\",\"What is the significance of {}?\",\"How does {} relate to {}?\",\"What are the implications of {}?\"],\n",
-        "            'comparative': [\"Compare {} and {}.\",\"What are the differences between {} and {}?\",\"How does {} differ from {}?\",\"What are the similarities between {} and {}?\"],\n",
-        "            'causal': [\"What caused {}?\",\"What are the effects of {}?\",\"How did {} lead to {}?\",\"What resulted from {}?\"],\n",
-        "            'procedural': [\"How do you {}?\",\"What are the steps to {}?\",\"Describe the process of {}.\",\"What is the procedure for {}?\"]}\n",
-        "\n",
-        "    def extract_key_concepts(self, text: str) -> Dict:\n",
-        "        \"\"\"Extract key concepts and entities from text.\"\"\"\n",
-        "        if not self.nlp:\n",
-        "            return {\"entities\": [], \"concepts\": [], \"sentences\": []}\n",
-        "        doc = self.nlp(text)\n",
-        "\n",
-        "        entities = []\n",
-        "        for ent in doc.ents:\n",
-        "            # Include more entity types for broader question generation\n",
-        "            if ent.label_ in ['PERSON', 'ORG', 'GPE', 'EVENT', 'WORK_OF_ART', 'LAW', 'LANGUAGE', 'DATE', 'CARDINAL', 'ORDINAL', 'NORP', 'LOC', 'PRODUCT']:\n",
-        "                entities.append({'text': ent.text,'label': ent.label_,'start': ent.start_char,'end': ent.end_char})\n",
-        "\n",
-        "        # Extract key concepts (noun phrases)\n",
-        "        concepts = []\n",
-        "        for chunk in doc.noun_chunks:\n",
-        "            # Adjust length for slightly longer concepts\n",
-        "            if 2 <= len(chunk.text.split()) <= 5:\n",
-        "                concepts.append({'text': chunk.text,'pos': chunk.root.pos_,'start': chunk.start_char,'end': chunk.end_char})\n",
-        "\n",
-        "        # Extract sentences\n",
-        "        sentences = [sent.text.strip() for sent in doc.sents if len(sent.text.split()) >= 10] # Increased minimum sentence length\n",
-        "        return {\"entities\": entities,\"concepts\": concepts,\"sentences\": sentences}\n",
-        "\n",
-        "    def generate_question_with_t5(self, context: str, answer: str, difficulty: str = \"medium\", question_type: str = \"factual\") -> str:\n",
-        "        \"\"\"Generate question using T5 model with prepend approach, considering difficulty.\"\"\"\n",
-        "        # Incorporate difficulty into the prompt\n",
-        "        prompt_prefix = f\"generate {difficulty} {question_type} question:\"\n",
-        "        input_text = f\"{prompt_prefix} context: {context} \\\\n {answer}\"\n",
-        "        inputs = self.qg_tokenizer.encode_plus(input_text,max_length=512,truncation=True,padding=True,return_tensors=\"pt\").to(self.device)\n",
-        "\n",
-        "        # Adjust generation parameters based on difficulty (simple heuristic)\n",
-        "        max_length = 100\n",
-        "        num_beams = 5\n",
-        "        temperature = 0.7\n",
-        "        if difficulty == \"easy\":\n",
-        "            max_length = 80\n",
-        "            temperature = 0.6\n",
-        "        elif difficulty == \"hard\":\n",
-        "            max_length = 120\n",
-        "            temperature = 0.9\n",
-        "            num_beams = 8\n",
-        "\n",
-        "        with torch.no_grad():\n",
-        "            outputs = self.qg_model.generate(inputs[\"input_ids\"],attention_mask=inputs[\"attention_mask\"],max_length=max_length,num_beams=num_beams,temperature=temperature,do_sample=True,early_stopping=True,no_repeat_ngram_size=2)\n",
-        "        question = self.qg_tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
-        "        return question.strip()\n",
-        "\n",
-        "    def generate_question_with_flan(self, context: str, answer: str, difficulty: str = \"medium\", question_type: str = \"factual\") -> str:\n",
-        "        \"\"\"Generate question using FLAN-T5 model, considering difficulty.\"\"\"\n",
-        "        # Incorporate difficulty into the prompt\n",
-        "        prompt = f\"\"\"Given the following context, generate a concise {difficulty}-level short answer question where the answer is '{answer}':\n",
-        "Context: {context}\n",
-        "Question:\"\"\"\n",
-        "        inputs = self.flan_tokenizer(prompt,max_length=512,truncation=True,padding=True,return_tensors=\"pt\").to(self.device)\n",
-        "\n",
-        "        # Adjust generation parameters based on difficulty (simple heuristic)\n",
-        "        max_length = 150\n",
-        "        num_beams = 4\n",
-        "        temperature = 0.8\n",
-        "        if difficulty == \"easy\":\n",
-        "            max_length = 100\n",
-        "            temperature = 0.6\n",
-        "        elif difficulty == \"hard\":\n",
-        "            max_length = 200\n",
-        "            temperature = 0.9\n",
-        "            num_beams = 6\n",
-        "        with torch.no_grad():\n",
-        "            outputs = self.flan_model.generate(inputs[\"input_ids\"],attention_mask=inputs[\"attention_mask\"],max_length=max_length,num_beams=num_beams,temperature=temperature,do_sample=True,early_stopping=True)\n",
-        "\n",
-        "        question = self.flan_tokenizer.decode(outputs[0], skip_special_tokens=True)\n",
-        "        return question.strip()\n",
-        "\n",
-        "    def classify_question_difficulty(self, question: str, answer: str, context: str) -> str:\n",
-        "        \"\"\"Classify question difficulty based on complexity and context.\"\"\"\n",
-        "        if not self.nlp:\n",
-        "            return \"medium\" # Default to medium if spaCy is not loaded\n",
-        "\n",
-        "        question_lower = question.lower()\n",
-        "        question_words = question_lower.split()\n",
-        "        answer_words = answer.lower().split()\n",
-        "\n",
-        "        # Keyword indicators\n",
-        "        easy_keywords = ['what', 'who', 'when', 'where', 'name', 'list', 'define']\n",
-        "        medium_keywords = ['how', 'why', 'explain', 'describe', 'role', 'purpose']\n",
-        "        hard_keywords = ['analyze', 'evaluate', 'synthesize', 'impact', 'implication', 'relationship']\n",
-        "        easy_score = sum(1 for word in easy_keywords if word in question_words)\n",
-        "        medium_score = sum(1 for word in medium_keywords if word in question_words)\n",
-        "        hard_score = sum(1 for word in hard_keywords if word in question_words)\n",
-        "\n",
-        "        # Answer length\n",
-        "        answer_length_score = 0\n",
-        "        if len(answer_words) > 15:\n",
-        "            answer_length_score = 3\n",
-        "        elif len(answer_words) > 8:\n",
-        "            answer_length_score = 2\n",
-        "        elif len(answer_words) > 3:\n",
-        "            answer_length_score = 1\n",
-        "\n",
-        "        # Context complexity (simple measure: average sentence length)\n",
-        "        sentences = sent_tokenize(context)\n",
-        "        avg_sentence_length = np.mean([len(s.split()) for s in sentences]) if sentences else 0\n",
-        "\n",
-        "        context_complexity_score = 0\n",
-        "        if avg_sentence_length > 25:\n",
-        "            context_complexity_score = 2\n",
-        "        elif avg_sentence_length > 18:\n",
-        "            context_complexity_score = 1\n",
-        "        if self.nlp:\n",
-        "            doc_question = self.nlp(question)\n",
-        "            doc_answer = self.nlp(answer)\n",
-        "            # 1. Part-of-speech tagging (weights based on complexity)\n",
-        "            # Corrected way to get POS counts\n",
-        "            pos_counts_question = {}\n",
-        "            for token in doc_question:\n",
-        "                pos_counts_question[token.pos_] = pos_counts_question.get(token.pos_, 0) +1\n",
-        "            pos_counts_answer = {}\n",
-        "            for token in doc_answer:\n",
-        "                 pos_counts_answer[token.pos_] = pos_counts_answer.get(token.pos_, 0) +1\n",
-        "            pos_score = (\n",
-        "                pos_counts_question.get(spacy.parts_of_speech.ADJ, 0) * 0.6 + # Further Increased weight for Adjectives\n",
-        "                pos_counts_question.get(spacy.parts_of_speech.ADV, 0) * 0.7 + # Further Increased weight for Adverbs\n",
-        "                pos_counts_question.get(spacy.parts_of_speech.VERB, 0) * 0.5 + # Further Increased weight for Verbs\n",
-        "                pos_counts_answer.get(spacy.parts_of_speech.ADJ, 0) * 0.5 +\n",
-        "                pos_counts_answer.get(spacy.parts_of_speech.NOUN, 0) * 0.4 )# Further Increased weight for Nouns in answer\n",
-        "\n",
-        "            # 2. Dependency parsing complexity (simple measure: average dependency depth) - Higher depth means more complex syntax\n",
-        "            dep_depths_question = [len(list(token.ancestors)) for token in doc_question]\n",
-        "            avg_dep_depth_question = np.mean(dep_depths_question) if dep_depths_question else 0\n",
-        "            dep_score = avg_dep_depth_question * 1.2 # Significantly increased weigh\n",
-        "\n",
-        "                                  # 3. Named entity recognition - More entities can indicate more specific/complex questions\n",
-        "            num_entities_question = len(doc_question.ents)\n",
-        "            num_entities_answer = len(doc_answer.ents)\n",
-        "            entity_score = (num_entities_question * 1.2 + num_entities_answer * 1.5) # Significantly increased weight for entitie\n",
-        "\n",
-        "                                  # 4. Lexical diversity (Type-Token Ratio) - Lower TTR might indicate simpler language, higher TTR more complex\n",
-        "            question_tokens = [token.text.lower() for token in doc_question if token.is_alpha]\n",
-        "            answer_tokens = [token.text.lower() for token in doc_answer if token.is_alpha]\n",
-        "            question_ttr = len(set(question_tokens)) / len(question_tokens) if question_tokens else 0\n",
-        "            answer_ttr = len(set(answer_tokens)) / len(answer_tokens) if answer_tokens else 0\n",
-        "\n",
-        "            # Inverse TTR for scoring (lower TTR = higher score for easy, higher TTR = higher score for hard)\n",
-        "            ttr_score = (question_ttr * 3.0 + answer_ttr * 2.5) # Significantly increased weigh\n",
-        "            # Combine linguistic features into a single score\n",
-        "            linguistic_score = pos_score + dep_score + entity_score + ttr_score\n",
-        "        else:\n",
-        "            linguistic_score = 0\n",
-        "\n",
-        "        # Combine all scores with adjusted weights\n",
-        "        total_score = (hard_score * 7 + medium_score * 4 + easy_score * 1.5 + answer_length_score * 3.0 + context_complexity_score * 3.0 + linguistic_score * 2.5 )\n",
-        "\n",
-        "        # Refined thresholds based on adjusted scoring\n",
-        "        # These thresholds will likely need tuning based on testing\n",
-        "        if total_score > 28: # Adjusted thresholds slightly down\n",
-        "            return \"hard\"\n",
-        "        elif total_score > 14: # Adjusted thresholds slightly down\n",
-        "            return \"medium\"\n",
-        "        else:\n",
-        "            return \"easy\"\n",
-        "\n",
-        "    def determine_question_type(self, question: str) -> str:\n",
-        "        \"\"\"Determine the type of question based on its content.\"\"\"\n",
-        "        question_lower = question.lower()\n",
-        "\n",
-        "        if any(word in question_lower for word in ['what is', 'what are', 'define', 'who is', 'who are', 'when is', 'when did', 'where is', 'where are']):\n",
-        "            return \"factual\"\n",
-        "        elif any(word in question_lower for word in ['how does', 'how to', 'why is', 'why do', 'explain', 'describe']):\n",
-        "            return \"analytical\"\n",
-        "        elif any(word in question_lower for word in ['compare', 'contrast', 'differ', 'similarities', 'differences']):\n",
-        "            return \"comparative\"\n",
-        "        elif any(word in question_lower for word in ['cause', 'effect', 'result', 'lead to', 'consequence']):\n",
-        "            return \"causal\"\n",
-        "        elif any(word in question_lower for word in ['steps', 'process', 'procedure', 'how to']):\n",
-        "            return \"procedural\"\n",
-        "        else:\n",
-        "            return \"factual\"\n",
-        "\n",
-        "    def extract_keywords(self, text: str) -> List[str]:\n",
-        "        \"\"\"Extract keywords from text using NLP.\"\"\"\n",
-        "        if not self.nlp:\n",
-        "            return []\n",
-        "\n",
-        "        doc = self.nlp(text)\n",
-        "        keywords = []\n",
-        "        stopwords = set(nltk.corpus.stopwords.words('english'))\n",
-        "\n",
-        "        for token in doc:\n",
-        "            if (token.pos_ in ['NOUN', 'PROPN', 'ADJ', 'VERB'] and token.text.lower() not in stopwords and not token.is_punct and len(token.text) > 2):\n",
-        "                keywords.append(token.text)\n",
-        "\n",
-        "        # Prioritize multi-word concepts if they exist\n",
-        "        multi_word_keywords = [chunk.text for chunk in doc.noun_chunks if len(chunk.text.split()) > 1 and len(chunk.text.split()) <= 3]\n",
-        "        keywords = multi_word_keywords + keywords\n",
-        "        return list(set(keywords))\n",
-        "\n",
-        "    def validate_question_answer_pair(self, question: str, expected_answer: str, context: str) -> Dict:\n",
-        "        \"\"\"Validate if the question can be answered correctly from the context using the QA model.\"\"\"\n",
-        "        try:\n",
-        "            # Use QA model and tokenizer explicitly\n",
-        "            inputs = self.qa_tokenizer(question, context, add_special_tokens=True, return_tensors=\"pt\", truncation=True, max_length=512)\n",
-        "            input_ids = inputs[\"input_ids\"].to(self.device)\n",
-        "            attention_mask = inputs[\"attention_mask\"].to(self.device)\n",
-        "\n",
-        "            with torch.no_grad():\n",
-        "                outputs = self.qa_model(input_ids=input_ids, attention_mask=inputs[\"attention_mask\"])\n",
-        "\n",
-        "            answer_start_scores = outputs.start_logits\n",
-        "            answer_end_scores = outputs.end_logits\n",
-        "\n",
-        "            # Get the most likely answer span\n",
-        "            answer_start = torch.argmax(answer_start_scores)\n",
-        "            answer_end = torch.argmax(answer_end_scores) + 1\n",
-        "\n",
-        "            # Convert tokens to predicted answer string\n",
-        "            predicted_answer = self.qa_tokenizer.decode(input_ids[0, answer_start:answer_end], skip_special_tokens=True)\n",
-        "\n",
-        "            # Calculate a confidence score (using max of start and end logits)\n",
-        "            confidence = (torch.max(torch.softmax(answer_start_scores, dim=-1)) + torch.max(torch.softmax(answer_end_scores, dim=-1))) / 2.0\n",
-        "\n",
-        "            # Calculate semantic similarity between expected and predicted answers\n",
-        "            # Handle potential errors if encoding fails\n",
-        "            try:\n",
-        "                expected_embedding = self.sentence_model.encode([expected_answer])\n",
-        "                predicted_embedding = self.sentence_model.encode([predicted_answer])\n",
-        "                similarity = np.dot(expected_embedding[0], predicted_embedding[0]) / (np.linalg.norm(expected_embedding[0]) * np.linalg.norm(predicted_embedding[0]))\n",
-        "            except Exception as e:\n",
-        "                print(f\"Error encoding answers for similarity: {e}\")\n",
-        "                similarity = 0.0 # Default to 0 similarity on error\n",
-        "\n",
-        "            # Check if answers are semantically similar or one contains the other\n",
-        "            contains_check = (expected_answer.lower().strip() in predicted_answer.lower().strip() or predicted_answer.lower().strip() in expected_answer.lower().strip())\n",
-        "\n",
-        "            # Consider similarity and containment for validation\n",
-        "            is_valid = (similarity > 0.7 and confidence > 0.4) or (contains_check and confidence > 0.5)\n",
-        "            return {\"is_valid\": is_valid,\"confidence\": confidence.item(),\"similarity\": similarity,\"predicted_answer\": predicted_answer,\"expected_answer\": expected_answer}\n",
-        "\n",
-        "        except Exception as e:\n",
-        "            # Catch specific errors from pipeline if possible\n",
-        "            print(f\"Error during QA validation: {e}\")\n",
-        "            return {\"is_valid\": False,\"confidence\": 0.0,\"similarity\": 0.0,\"predicted_answer\": \"\",\"expected_answer\": expected_answer,\"error\": str(e)}\n",
-        "\n",
-        "    def determine_expected_length(self, answer: str) -> str:\n",
-        "        \"\"\"Determine expected answer length category based on word count.\"\"\"\n",
-        "        word_count = len(answer.split())\n",
-        "\n",
-        "        if word_count <= 5:\n",
-        "            return \"brief (few words)\"\n",
-        "        elif word_count <= 15:\n",
-        "            return \"short (1-2 sentences)\"\n",
-        "        elif word_count <= 30:\n",
-        "            return \"medium (2-4 sentences)\"\n",
-        "        else:\n",
-        "            return \"long (paragraph+)\"\n",
-        "\n",
-        "    def generate_comprehensive_questions(self, context: str, num_questions: int = 8, difficulty: str = \"medium\") -> List[ShortAnswerQuestion]:\n",
-        "        \"\"\"Generate comprehensive set of short answer questions, considering difficulty.\"\"\"\n",
-        "        questions = []\n",
-        "        generated_pairs = set() # To avoid duplicate question-answer pairs\n",
-        "\n",
-        "        # Extract key information\n",
-        "        key_info = self.extract_key_concepts(context)\n",
-        "\n",
-        "        # Combine potential answers from entities and concepts\n",
-        "        potential_answers = [e['text'] for e in key_info['entities']] + [c['text'] for c in key_info['concepts']]\n",
-        "        random.shuffle(potential_answers) # Shuffle to mix entity and concept based questions\n",
-        "\n",
-        "        # Determine number of attempts per answer based on difficulty\n",
-        "        attempts_per_answer_map = {\"easy\": 4, \"medium\": 8, \"hard\": 12} # Increased attempts for all difficulties again\n",
-        "        attempts_per_answer = attempts_per_answer_map.get(difficulty, 8)\n",
-        "\n",
-        "        answers_processed = 0\n",
-        "        for answer in potential_answers:\n",
-        "            if len(questions) >= num_questions:\n",
-        "                break\n",
-        "            answers_processed += 1\n",
-        "            if answers_processed > num_questions * 20: # Further increased limit to try more answers\n",
-        "                 print(f\"Reached maximum answer processing attempts ({num_questions * 20}). Stopping.\")\n",
-        "                 break\n",
-        "            for attempt in range(attempts_per_answer):\n",
-        "                if len(questions) >= num_questions:\n",
-        "                    break\n",
-        "\n",
-        "                # Choose which model to use (can alternate or use both)\n",
-        "                if attempt % 2 == 0:\n",
-        "                    question = self.generate_question_with_t5(context, answer, difficulty=difficulty)\n",
-        "                else:\n",
-        "                    question = self.generate_question_with_flan(context, answer, difficulty=difficulty)\n",
-        "\n",
-        "                # Basic cleaning and validation before full QA check\n",
-        "                question = question.strip()\n",
-        "                if not question or not question.endswith('?') or len(question.split()) < 5:\n",
-        "                    continue\n",
-        "\n",
-        "                # Ensure question is unique\n",
-        "                q_a_pair = (question, answer)\n",
-        "                if q_a_pair in generated_pairs:\n",
-        "                    continue\n",
-        "\n",
-        "                # Validate question-answer pair\n",
-        "                validation = self.validate_question_answer_pair(question, answer, context)\n",
-        "\n",
-        "                # Filtering based on difficulty and validation confidence\n",
-        "                confidence_threshold = 0.3 # Base threshold\n",
-        "\n",
-        "                # Adjust confidence threshold based on requested difficulty\n",
-        "                if difficulty == \"easy\":\n",
-        "                    confidence_threshold = 0.25 #lower threshold for easy questions\n",
-        "                elif difficulty == \"hard\":\n",
-        "                     confidence_threshold = 0.35 #higher threshold for hard questions\n",
-        "\n",
-        "\n",
-        "                if validation[\"is_valid\"] and validation[\"confidence\"] > confidence_threshold: # confidence threshold\n",
-        "                    #type and classified difficulty\n",
-        "                    question_type = self.determine_question_type(question)\n",
-        "                    # Check if nlp is loaded before classifying difficulty\n",
-        "                    if self.nlp:\n",
-        "                        classified_difficulty = self.classify_question_difficulty(question, answer, context) # Classify generated question's actual difficulty\n",
-        "                    else:\n",
-        "                        classified_difficulty = \"medium\" # Default to medium if spaCy not loaded\n",
-        "\n",
-        "                    # Add the question if its classified difficulty is the requested one or one level below\n",
-        "                    # This allows some flexibility while aiming for the target difficulty\n",
-        "                    difficulty_levels = [\"easy\", \"medium\", \"hard\"]\n",
-        "                    requested_index = difficulty_levels.index(difficulty)\n",
-        "                    classified_index = difficulty_levels.index(classified_difficulty)\n",
-        "\n",
-        "                    # Accept if classified difficulty is at or one level below requested difficulty\n",
-        "                    if classified_index >= requested_index or (requested_index > 0 and classified_index == requested_index - 1):\n",
-        "\n",
-        "                        keywords = self.extract_keywords(f\"{question} {answer}\")\n",
-        "                        expected_length = self.determine_expected_length(answer)\n",
-        "\n",
-        "                        saq = ShortAnswerQuestion(question=question,answer=answer,context_sentence=context[:200] + \"...\" if len(context) > 200 else context,question_type=question_type,difficulty=classified_difficulty,confidence=validation[\"confidence\"],keywords=keywords[:5],expected_length=expected_length)\n",
-        "                        questions.append(saq)\n",
-        "                        generated_pairs.add(q_a_pair) # Add to history\n",
-        "                        # If we found a question of the requested difficulty, move to the next answer\n",
-        "                        if classified_difficulty == difficulty:\n",
-        "                            break\n",
-        "        # Fallback: Generate questions directly from sentences if not enough generated\n",
-        "        if len(questions) < num_questions:\n",
-        "             print(f\"Warning: Could not generate {num_questions} questions of the requested difficulty. Adding fallback questions.\")\n",
-        "             for sentence in key_info[\"sentences\"]:\n",
-        "                 if len(questions) >= num_questions:\n",
-        "                     break\n",
-        "\n",
-        "                 # Generate a question based on the sentence (can use template or model)\n",
-        "                 # Simple template fallback\n",
-        "                 question = f\"What is discussed in the sentence: \\\"{sentence[:50]}...\\\"?\"\n",
-        "                 answer = sentence # The sentence itself is the \"answer\" in this case\n",
-        "\n",
-        "                 # Validate (less strict for fallback)\n",
-        "                 validation = self.validate_question_answer_pair(question, answer, context)\n",
-        "\n",
-        "                 # Even if not perfectly valid, added as a fallback if needed and unique\n",
-        "                 q_a_pair = (question, answer)\n",
-        "                 if q_a_pair not in generated_pairs:\n",
-        "                     difficulty = \"easy\" # Fallback questions are usually easy\n",
-        "                     question_type = \"factual\"\n",
-        "                     keywords = self.extract_keywords(sentence)[:5]\n",
-        "                     expected_length = self.determine_expected_length(answer)\n",
-        "\n",
-        "                     saq = ShortAnswerQuestion( question=question, answer=\"Key points from the sentence.\", context_sentence=sentence, question_type=question_type, difficulty=difficulty, confidence=validation[\"confidence\"] if validation[\"is_valid\"] else 0.1, keywords=keywords, expected_length=\"short (1-2 sentences)\")\n",
-        "                     questions.append(saq)\n",
-        "                     generated_pairs.add(q_a_pair)\n",
-        "\n",
-        "        # Sort by confidence (or potentially by classified difficulty later) and return\n",
-        "        questions.sort(key=lambda x: x.confidence, reverse=True)\n",
-        "        return questions[:num_questions]\n",
-        "\n",
-        "def main():\n",
-        "    \"\"\"Main function to demonstrate the advanced SAQ generator.\"\"\"\n",
-        "    generator = AdvancedShortAnswerGenerator()\n",
-        "\n",
-        "    print(\" Short Answer Question Generator\")\n",
-        "    # Get user input\n",
-        "    user_context = input(\"Enter your context (or press Enter to use sample): \").strip()\n",
-        "\n",
-        "    try:\n",
-        "        num_questions = int(input(\"Number of questions to generate (default 6): \") or \"6\")\n",
-        "    except ValueError:\n",
-        "        num_questions = 6\n",
-        "    print(f\"\\nGenerating {num_questions} short answer questions...\")\n",
-        "\n",
-        "    # Generate questions, passing the difficulty\n",
-        "    questions = generator.generate_comprehensive_questions(user_context, num_questions)\n",
-        "\n",
-        "    # Display results\n",
-        "    if questions:\n",
-        "        for i, q in enumerate(questions, 1):\n",
-        "            print(f\"\\nQuestion {i}: [CLASSIFIED: {q.difficulty.upper()}] ({q.question_type})\") # Display classified difficulty\n",
-        "            print(f\"Q: {q.question}\")\n",
-        "            print(f\"A: {q.answer}\")\n",
-        "            print(f\"Expected Length: {q.expected_length}\")\n",
-        "    else:\n",
-        "        print(\"No high-quality questions could be generated from the provided context.\")\n",
-        "        print(\"Try providing a longer, more detailed context with specific information.\")\n",
-        "\n",
-        "    print(\"\\nGeneration complete!\")\n",
-        "\n",
-        "if __name__ == \"__main__\":\n",
-        "    main()"
-      ],
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "VkkPD9QA-2Z8",
-        "outputId": "4533385c-10e3-474e-bba3-51d40466b07c"
-      },
-      "execution_count": 5,
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            " Short Answer Question Generator\n",
-            "Enter your context (or press Enter to use sample): India has numerous national parks dedicated to preserving wildlife and biodiversity. Some of the most famous include Jim Corbett National Park in Uttarakhand, known for tigers; Kaziranga National Park in Assam, home to the one-horned rhinoceros; and Sundarbans in West Bengal, famous for mangrove forests and Royal Bengal Tigers. These parks also support eco-tourism and help protect endangered species and fragile ecosystems.\n",
-            "Number of questions to generate (default 6): 3\n",
-            "\n",
-            "Generating 3 short answer questions...\n",
-            "\n",
-            "Question 1: [CLASSIFIED: HARD] (factual)\n",
-            "Q: What national park in Assam is home to the one-horned rhinoceros?\n",
-            "A: Kaziranga National Park\n",
-            "Expected Length: brief (few words)\n",
-            "\n",
-            "Question 2: [CLASSIFIED: HARD] (factual)\n",
-            "Q: What national park is home to the one-horned rhinoceros?\n",
-            "A: Kaziranga National Park\n",
-            "Expected Length: brief (few words)\n",
-            "\n",
-            "Question 3: [CLASSIFIED: MEDIUM] (factual)\n",
-            "Q: Which type of ecosystems are protected by national parks?\n",
-            "A: fragile ecosystems\n",
-            "Expected Length: brief (few words)\n",
-            "\n",
-            "Generation complete!\n"
-          ]
-        }
-      ]
-    },
-    {
-      "cell_type": "code",
-      "source": [],
-      "metadata": {
-        "id": "EFvGMWctDueq"
-      },
-      "execution_count": null,
-      "outputs": []
-    }
-  ]
-}

true_false_generator.ipynb

@@ -1,250 +0,0 @@
-{
-  "nbformat": 4,
-  "nbformat_minor": 0,
-  "metadata": {
-    "colab": {
-      "provenance": [],
-      "gpuType": "T4",
-      "authorship_tag": "ABX9TyPvN5XJaoOJQM9ow757H9XQ",
-      "include_colab_link": true
-    },
-    "kernelspec": {
-      "name": "python3",
-      "display_name": "Python 3"
-    },
-    "language_info": {
-      "name": "python"
-    },
-    "accelerator": "GPU"
-  },
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {
-        "id": "view-in-github",
-        "colab_type": "text"
-      },
-      "source": [
-        "<a href=\"https://colab.research.google.com/github/DishaKushwah/custom-quiz-generator/blob/main/true_false_generator.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
-      ]
-    },
-    {
-      "cell_type": "code",
-      "execution_count": null,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/"
-        },
-        "id": "nq6K-9RY_KQa",
-        "outputId": "4ad2a243-b1b1-482d-88ae-da17878ae13c"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stderr",
-          "text": [
-            "Device set to use cpu\n"
-          ]
-        },
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Enter the context for true/false generation: Currency is a system of money used for buying and selling goods and services. It has evolved from the barter system to coins, paper money, and now digital payments. International trade allows countries to exchange resources, goods, and services, often using foreign currencies like the US Dollar or Euro. Exchange rates determine how much one currency is worth compared to another. Organizations like the World Trade Organization (WTO) regulate global trade practices.\n",
-            "Number of questions to generate (default 5): 5\n",
-            "Generating 5 questions from context...\n",
-            "\n",
-            "--- Generated Questions ---\n",
-            "TRUE/FALSE QUESTIONS\n",
-            "\n",
-            "1. Exchange rates do not determine how much one currency is worth compared to another.\n",
-            "   Answer: FALSE\n",
-            "   Explanation: According to the context, the correct statement is: Exchange rates determine how much one currency is worth compared to another.\n",
-            "\n",
-            "2. It has not evolved from the barter system to coins, paper money, and now digital payments.\n",
-            "   Answer: FALSE\n",
-            "   Explanation: According to the context, the correct statement is: It has evolved from the barter system to coins, paper money, and now digital payments.\n",
-            "\n",
-            "3. It has evolved from the barter system to coins, paper money, and now digital payments.\n",
-            "   Answer: TRUE\n",
-            "   Explanation: Based on the context: It has evolved from the barter system to coins, paper money, and now digital payments.\n",
-            "\n",
-            "4. A currency is a system of money used for buying and selling goods and services.\n",
-            "   Answer: FALSE\n",
-            "   Explanation: According to the context, the correct statement is: Currency is a system of money used for buying and selling goods and services.\n",
-            "\n",
-            "5. True or False: Currency is a system of money used for buying and selling goods and services.\n",
-            "   Answer: TRUE\n",
-            "   Explanation: Based on the context: Currency is a system of money used for buying and selling goods and services.\n",
-            "Questions saved to questions.json\n"
-          ]
-        }
-      ],
-      "source": [
-        "#true false\n",
-        "import torch\n",
-        "from transformers import (AutoTokenizer, AutoModelForCausalLM, T5Tokenizer, T5ForConditionalGeneration, pipeline)\n",
-        "import nltk\n",
-        "import random\n",
-        "import re\n",
-        "import json\n",
-        "from typing import List, Dict, Tuple\n",
-        "import warnings\n",
-        "warnings.filterwarnings('ignore')\n",
-        "\n",
-        "class TrueFalseQuestionGenerator:\n",
-        "    def __init__(self, model_name: str = \"google/flan-t5-large\"):\n",
-        "        self.model_name = model_name\n",
-        "        self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
-        "        # Load tokenizer and model\n",
-        "        if \"t5\" in model_name.lower():\n",
-        "            self.tokenizer = T5Tokenizer.from_pretrained(model_name)\n",
-        "            self.model = T5ForConditionalGeneration.from_pretrained(model_name)\n",
-        "        else:\n",
-        "            self.tokenizer = AutoTokenizer.from_pretrained(model_name)\n",
-        "            self.model = AutoModelForCausalLM.from_pretrained(model_name)\n",
-        "        self.model.to(self.device)\n",
-        "        self.model.eval()\n",
-        "\n",
-        "        # Initialize question generation pipeline\n",
-        "        self.question_pipeline = pipeline(\n",
-        "            \"text2text-generation\",\n",
-        "            model=self.model,\n",
-        "            tokenizer=self.tokenizer,\n",
-        "            device=0 if torch.cuda.is_available() else -1)\n",
-        "\n",
-        "    def extract_key_facts(self, context: str) -> List[str]:\n",
-        "        # Split the context into sentences using regex based on common punctuation\n",
-        "        sentences = re.split(r'(?<=[.!?])\\s+', context)\n",
-        "        # Filter sentences that are likely to contain factual information\n",
-        "        factual_sentences = []\n",
-        "        for sentence in sentences:\n",
-        "            # Look for sentences with specific patterns that indicate facts\n",
-        "            if (len(sentence.split()) > 5 and\n",
-        "                any(keyword in sentence.lower() for keyword in\n",
-        "                    ['is', 'are', 'was', 'were', 'has', 'have', 'can', 'will','does', 'did', 'contains', 'includes', 'located', 'founded','established', 'invented', 'discovered', 'developed', 'used', 'use'])):\n",
-        "                factual_sentences.append(sentence.strip())\n",
-        "        return factual_sentences[:10]  # Limit to 10 key facts\n",
-        "\n",
-        "    def generate_true_questions(self, context: str, num_questions: int = 5) -> List[Dict]:\n",
-        "        facts = self.extract_key_facts(context)\n",
-        "        true_questions = []\n",
-        "        # Ensure we don't try to generate more questions than available facts\n",
-        "        num_to_generate = min(num_questions, len(facts))\n",
-        "        for i, fact in enumerate(facts[:num_to_generate]):\n",
-        "            # Create prompts for generating true/false questions\n",
-        "            prompts = [f\"Create a statement that can be answered true or false based on: {fact}\"]\n",
-        "            prompt = random.choice(prompts)\n",
-        "\n",
-        "            try:\n",
-        "                # Generate question using the model\n",
-        "                response = self.question_pipeline(prompt, max_new_tokens=100, num_return_sequences=1, temperature=0.7, do_sample=True, pad_token_id=self.tokenizer.eos_token_id)\n",
-        "                generated_text = response[0]['generated_text'].strip()\n",
-        "                question = self.clean_question(generated_text)\n",
-        "                if question:\n",
-        "                    true_questions.append({'question': question,'answer': True,'explanation': f\"Based on the context: {fact}\",'source_fact': fact })\n",
-        "            except Exception as e:\n",
-        "                print(f\"Error generating question {i+1}: {str(e)}\")\n",
-        "                continue\n",
-        "        return true_questions\n",
-        "\n",
-        "    def generate_false_questions(self, context: str, num_questions: int = 5) -> List[Dict]:\n",
-        "        \"\"\"\n",
-        "        Generate FALSE questions by modifying facts from the context\n",
-        "        \"\"\"\n",
-        "        facts = self.extract_key_facts(context)\n",
-        "        false_questions = []\n",
-        "        num_to_generate = min(num_questions, len(facts))\n",
-        "\n",
-        "        for i, fact in enumerate(facts[:num_to_generate]):\n",
-        "            # Create prompts for generating false statements that are plausible but contradict the fact\n",
-        "            prompts = [f\"Create a plausible false statement based on this fact: {fact}\",f\"Make this statement false by changing a key detail: {fact}\"]\n",
-        "            prompt = random.choice(prompts)\n",
-        "\n",
-        "            try:\n",
-        "                response = self.question_pipeline(prompt,max_new_tokens=100,num_return_sequences=1,temperature=0.8, do_sample=True,pad_token_id=self.tokenizer.eos_token_id)\n",
-        "                generated_text = response[0]['generated_text'].strip()\n",
-        "                question = self.clean_question(generated_text)\n",
-        "                if question:\n",
-        "                    false_questions.append({'question': question,'answer': False,'explanation': f\"According to the context, the correct statement is: {fact}\",'source_fact': fact})\n",
-        "            except Exception as e:\n",
-        "                print(f\"Error generating false question {i+1}: {str(e)}\")\n",
-        "                continue\n",
-        "        return false_questions\n",
-        "\n",
-        "    def clean_question(self, text: str) -> str:\n",
-        "        # Remove common prefixes\n",
-        "        text = re.sub(r'^(Question:|Q:|True/False:|Statement:)\\s*', '', text, flags=re.IGNORECASE)\n",
-        "\n",
-        "        # Ensure the question ends with proper punctuation\n",
-        "        text = text.strip()\n",
-        "        if not text.endswith(('.', '!', '?')):\n",
-        "            text += '.'\n",
-        "\n",
-        "        # Capitalize first letter\n",
-        "        if text:\n",
-        "            text = text[0].upper() + text[1:]\n",
-        "\n",
-        "        # Remove standalone \"True\" or \"False\" if it appears at the beginning\n",
-        "        text = re.sub(r'^(True|False)\\.\\s*', '', text, flags=re.IGNORECASE)\n",
-        "        text = re.sub(r'^(True|False)\\?\\s*', '', text, flags=re.IGNORECASE)\n",
-        "        return text if len(text) > 10 else None\n",
-        "\n",
-        "    def generate_questions(self, context: str, num_questions: int = 10) -> List[Dict]:\n",
-        "        if not context.strip():\n",
-        "            raise ValueError(\"Context cannot be empty\")\n",
-        "        print(f\"Generating {num_questions} questions from context...\")\n",
-        "\n",
-        "        # Split questions evenly between true and false\n",
-        "        num_true = num_questions // 2\n",
-        "        num_false = num_questions - num_true\n",
-        "\n",
-        "        true_questions = self.generate_true_questions(context, num_true)\n",
-        "        false_questions = self.generate_false_questions(context, num_false)\n",
-        "\n",
-        "        # Combine and shuffle questions\n",
-        "        all_questions = true_questions + false_questions\n",
-        "        random.shuffle(all_questions)\n",
-        "\n",
-        "        # Add question numbers\n",
-        "        for i, question in enumerate(all_questions, 1):\n",
-        "            question['id'] = i\n",
-        "        return all_questions\n",
-        "\n",
-        "    def display_questions(self, questions: List[Dict], show_answers: bool = False):\n",
-        "        print(\"TRUE/FALSE QUESTIONS\")\n",
-        "        for q in questions:\n",
-        "            print(f\"\\n{q['id']}. {q['question']}\")\n",
-        "            if show_answers:\n",
-        "                answer_text = \"TRUE\" if q['answer'] else \"FALSE\"\n",
-        "                print(f\"   Answer: {answer_text}\")\n",
-        "                print(f\"   Explanation: {q['explanation']}\")\n",
-        "\n",
-        "    def save_questions(self, questions: List[Dict], filename: str = \"questions.json\"):\n",
-        "        with open(filename.strip(), 'w', encoding='utf-8') as f:\n",
-        "            json.dump(questions, f, indent=2, ensure_ascii=False)\n",
-        "        print(f\"Questions saved to {filename.strip()}\")\n",
-        "\n",
-        "# Example usage and testing\n",
-        "def main():\n",
-        "    # Initialize the generator\n",
-        "    generator = TrueFalseQuestionGenerator()\n",
-        "     # Sample context for testing\n",
-        "    sample_context =input(\"Enter the context for true/false generation: \")\n",
-        "    try:\n",
-        "        num_questions = int(input(\"Number of questions to generate (default 5): \") or \"5\")\n",
-        "    except ValueError:\n",
-        "        num_questions = 5\n",
-        "    # Generate questions\n",
-        "    questions = generator.generate_questions(sample_context, num_questions)\n",
-        "    # Display questions\n",
-        "    generator.display_questions(questions, show_answers=True)\n",
-        "    # Save questions\n",
-        "    generator.save_questions(questions, \"questions.json\")\n",
-        "\n",
-        "if __name__ == \"__main__\":\n",
-        "    main()"
-      ]
-    }
-  ]
-}

true_false_generator.py

@@ -1 +0,0 @@
-#true and false logic

truefalse_quiz.py

@@ -0,0 +1,98 @@
+import random
+import nltk
+from transformers import pipeline
+from nltk.tokenize import sent_tokenize
+
+# Download required tokenizer
+nltk.download('punkt_tab', quiet=True)
+
+# Load NLI model
+nli = pipeline("text-classification", model="facebook/bart-large-mnli")
+
+# Input validation
+def validate_inputs(context, num_questions, difficulty):
+    if not context.strip():
+        raise ValueError("Context cannot be empty.")
+    sentences = sent_tokenize(context)
+    if len(sentences) < num_questions:
+        raise ValueError(f"Context has only {len(sentences)} sentences, but {num_questions} questions requested.")
+    if difficulty not in ["easy", "medium", "hard"]:
+        raise ValueError("Difficulty must be 'easy', 'medium', or 'hard'.")
+    return sentences
+
+# Difficulty-based sentence modifier
+def apply_noise(sentence: str, level: str) -> str:
+    if level == "easy":
+        return sentence
+    elif level == "medium":
+        if "Sun" in sentence:
+            return sentence.replace("Sun", "Moon")
+        return sentence.replace("is", "is not") if "is" in sentence else sentence
+    elif level == "hard":
+        if "eight" in sentence:
+            return sentence.replace("eight", "ten")
+        return sentence.replace("planets", "stars") if "planets" in sentence else sentence
+    return sentence
+
+# Statement generator
+def generate_statements(context, n, difficulty, sentences):
+    random.seed(42)
+    selected = random.sample(sentences, min(n * 2, len(sentences)))
+    final = []
+    for s in selected:
+        clean = s.strip()
+        modified = apply_noise(clean, difficulty)
+        label = "ENTAILMENT" if clean == modified else "CONTRADICTION"
+        final.append((modified, label))
+        if len(final) >= n:
+            break
+    return final
+
+# Get valid user answer
+def get_user_answer():
+    while True:
+        user = input("True or False? ").strip().lower()
+        if user in ["true", "false"]:
+            return user
+        print("Please enter 'true' or 'false'.")
+
+# Main logic
+try:
+    context = input(">> Enter context text: ")
+    num_questions = int(input("\n>> How many questions do you want to generate? "))
+    difficulty = input("\n>> Enter difficulty level (easy/medium/hard): ").strip().lower()
+    
+    sentences = validate_inputs(context, num_questions, difficulty)
+    questions = generate_statements(context, num_questions, difficulty, sentences)
+    
+    if len(questions) < num_questions:
+        print(f"Warning: Only {len(questions)} questions generated due to limited context.")
+    
+    print("\n--- QUIZ STARTS ---\n")
+    score = 0
+    
+    for idx, (statement, actual_label) in enumerate(questions, 1):
+        print(f"Q{idx}: {statement}")
+        user = get_user_answer()
+        
+        # Format input for facebook/bart-large-mnli
+        input_text = f"{context} [SEP] {statement}"
+        result = nli(input_text)[0]
+        if result["label"] == "neutral":
+            print("Skipping ambiguous statement.\n")
+            continue
+        model_label = "ENTAILMENT" if result["label"] == "entailment" else "CONTRADICTION"
+        
+        if model_label == "ENTAILMENT" and user == "true":
+            print("Correct!\n")
+            score += 1
+        elif model_label == "CONTRADICTION" and user == "false":
+            print("Correct!\n")
+            score += 1
+        else:
+            print(f"Incorrect! (Correct answer: {'True' if model_label == 'ENTAILMENT' else 'False'})\n")
+    
+    print(f"\n--- Final Score: {score}/{len(questions)} ---")
+
+except ValueError as e:
+    print(f"Error: {e}")