Automatic MCQs Generation using GEMINI LLM.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "0473de43-0663-4fc4-9753-e0e501d13e0f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q: Q1: What is the primary difference between artificial intelligence (AI) and natural intelligence?\n",
      "A: AI is based on biological processes while natural intelligence is based on technology.\n",
      "B: AI is demonstrated by machines while natural intelligence is displayed by humans and animals.\n",
      "C: AI is focused on problem-solving while natural intelligence is focused on creativity.\n",
      "D: AI is concerned with emotions while natural intelligence is driven by logic.\n",
      "Correct Answer: B\n",
      "\n",
      "Q: Q2: According to leading AI textbooks, what is the central focus of the field?\n",
      "A: The development of advanced robots capable of complex tasks.\n",
      "B: The creation of machines that can mimic human emotions and thoughts.\n",
      "C: The study of 'intelligent agents' that perceive their environment and act to achieve goals.\n",
      "D: The exploration of the ethical implications of artificial intelligence.\n",
      "Correct Answer: C\n",
      "\n",
      "Q: Q3: Which of the following is NOT a characteristic of an 'intelligent agent' as defined in AI textbooks?\n",
      "A: Perceiving its environment.\n",
      "B: Taking actions to achieve goals.\n",
      "C: Demonstrating self-awareness and consciousness.\n",
      "D: Maximizing the chance of successful goal achievement.\n",
      "Correct Answer: C\n"
     ]
    }
   ],
   "source": [
    "#MCQ generation using gemini llm with Text input\n",
    "import google.generativeai as genai\n",
    "import time\n",
    "\n",
    "# Configure API key for Google Generative AI\n",
    "apikey = \"api key\"\n",
    "genai.configure(api_key=apikey)\n",
    "\n",
    "def generate_mcqs(text, num_mcqs=3, retry_attempts=3):\n",
    "    \"\"\"\n",
    "    Generate multiple-choice questions (MCQs) from a text input and return cleaned output.\n",
    "\n",
    "    Parameters:\n",
    "    - text (str): The text to generate MCQs from.\n",
    "    - num_mcqs (int): The number of MCQs to generate.\n",
    "    - retry_attempts (int): Number of retry attempts in case of API failure.\n",
    "\n",
    "    Returns:\n",
    "    - str: The cleaned MCQs output.\n",
    "    \"\"\"\n",
    "    if not isinstance(num_mcqs, int) or num_mcqs <= 0:\n",
    "        raise ValueError(\"num_mcqs must be a positive integer.\")\n",
    "\n",
    "    attempts = 0\n",
    "    while attempts < retry_attempts:\n",
    "        try:\n",
    "            # Create the GenerativeModel instance\n",
    "            model = genai.GenerativeModel('gemini-1.5-flash')\n",
    "\n",
    "            # Generate MCQs with the specified prompt\n",
    "            prompt = (f\"Generate {num_mcqs} unique multiple-choice questions (MCQs) from the following text. \"\n",
    "                      f\"Each MCQ should have a question and four options (A, B, C, D), with one correct answer. \"\n",
    "                      f\"Ensure that there are no duplicates in the questions and answers. \"\n",
    "                      f\"Provide the output in the form Q: question text\\nA: option A text\\nB: option B text\\nC: option C text\\nD: option D text\\nCorrect Answer: option letter\\n\\nText: {text}\")\n",
    "            response = model.generate_content(prompt)\n",
    "\n",
    "            # Clean up the generated content\n",
    "            output = response.text.strip().replace('*', '').replace('#', '')\n",
    "\n",
    "            # Split the output into MCQs\n",
    "            mcqs = [mcq.strip() for mcq in output.split('\\n\\n') if mcq.strip()]\n",
    "            \n",
    "            # Remove duplicates and format the output\n",
    "            unique_mcqs = []\n",
    "            seen_questions = set()  # Track questions to avoid duplicates\n",
    "            for mcq in mcqs:\n",
    "                parts = mcq.split('\\n')\n",
    "                if len(parts) >= 6:  # Check for at least 6 lines (Q + 4 options + Correct Answer)\n",
    "                    question = parts[0].replace('Q:', '').strip()\n",
    "                    if question not in seen_questions:\n",
    "                        seen_questions.add(question)\n",
    "                        options = \"\\n\".join([line for line in parts[1:5]])\n",
    "                        correct_answer = parts[5].replace('Correct Answer:', '').strip()\n",
    "                        unique_mcqs.append(f\"Q: {question}\\n{options}\\nCorrect Answer: {correct_answer}\")\n",
    "\n",
    "            # Select the required number of MCQs\n",
    "            unique_mcqs = unique_mcqs[:num_mcqs]\n",
    "\n",
    "            # Format the cleaned output\n",
    "            formatted_output = \"\\n\\n\".join(unique_mcqs)\n",
    "\n",
    "            # Print the cleaned output\n",
    "            return formatted_output\n",
    "\n",
    "        except Exception as e:\n",
    "            attempts += 1\n",
    "            print(f\"Attempt {attempts} failed: {e}\")\n",
    "            if attempts < retry_attempts:\n",
    "                time.sleep(2)  # Wait before retrying\n",
    "\n",
    "    return \"Failed to generate MCQs after several attempts.\"\n",
    "\n",
    "# Example usage\n",
    "text_input = \"\"\"Artificial intelligence (AI) is intelligence demonstrated by machines, in contrast to the natural intelligence displayed by humans and animals. Leading AI textbooks define the field as the study of 'intelligent agents': any device that perceives its environment and takes actions that maximize its chance of successfully achieving its goals.\"\"\"\n",
    "num_mcqs = 3\n",
    "\n",
    "# Generate and print cleaned MCQs\n",
    "mcqs_output = generate_mcqs(text_input, num_mcqs)\n",
    "print(mcqs_output)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "9bdafdfd-23c9-43a4-bac3-5356f4d1670c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q: What is the primary function of the \"lmqg\" Python package?\n",
      "A: To fine-tune language models for question answering.\n",
      "B: To generate synthetic data for question answering tasks.\n",
      "C: To evaluate the performance of pre-trained language models.\n",
      "D: To develop interactive question answering interfaces.\n",
      "Correct Answer: A\n",
      "\n",
      "Q: What is the main difference between the \"QAAligned BS\" and \"QAAligned MS\" evaluation metrics used in the paper?\n",
      "A: \"QAAligned BS\" uses BERTScore as the underlying metric, while \"QAAligned MS\" uses MoverScore.\n",
      "B: \"QAAligned BS\" focuses on the semantic similarity of questions, while \"QAAligned MS\" focuses on the syntactic structure.\n",
      "C: \"QAAligned BS\" is designed for monolingual evaluation, while \"QAAligned MS\" is designed for multilingual evaluation.\n",
      "D: \"QAAligned BS\" measures question quality, while \"QAAligned MS\" measures answer quality.\n",
      "Correct Answer: A\n",
      "\n",
      "Q: Which of the following is NOT a limitation of the QAG models and evaluation metrics discussed in the paper?\n",
      "A: The models are not able to handle documents longer than 500 tokens.\n",
      "B: The models are not able to generate questions that require multi-hop reasoning.\n",
      "C: The evaluation metrics are not sensitive to the fluency of generated questions.\n",
      "D: The models are not able to generate toxic text due to the underlying language models.\n",
      "Correct Answer: D\n"
     ]
    }
   ],
   "source": [
    "#MCQ generation using gemini llm with PDF input\n",
    "import google.generativeai as genai\n",
    "import fitz  # PyMuPDF\n",
    "import time\n",
    "\n",
    "# Configure API key for Google Generative AI\n",
    "apikey = \"api key\"  # Replace with your actual API key\n",
    "genai.configure(api_key=apikey)\n",
    "\n",
    "def extract_text_from_pdf(pdf_path):\n",
    "    \"\"\"\n",
    "    Extract text from a PDF file.\n",
    "\n",
    "    Parameters:\n",
    "    - pdf_path (str): The path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "    - str: The extracted text from the PDF.\n",
    "    \"\"\"\n",
    "    text = \"\"\n",
    "    try:\n",
    "        pdf_document = fitz.open(pdf_path)\n",
    "        for page_num in range(len(pdf_document)):\n",
    "            page = pdf_document.load_page(page_num)\n",
    "            text += page.get_text()\n",
    "        pdf_document.close()\n",
    "    except Exception as e:\n",
    "        print(f\"Error reading PDF: {e}\")\n",
    "    return text\n",
    "\n",
    "def generate_mcqs(text, num_mcqs=3, retry_attempts=3):\n",
    "    \"\"\"\n",
    "    Generate multiple-choice questions (MCQs) from a text input and return cleaned output.\n",
    "\n",
    "    Parameters:\n",
    "    - text (str): The text to generate MCQs from.\n",
    "    - num_mcqs (int): The number of MCQs to generate.\n",
    "    - retry_attempts (int): Number of retry attempts in case of API failure.\n",
    "\n",
    "    Returns:\n",
    "    - str: The cleaned MCQs output.\n",
    "    \"\"\"\n",
    "    if not isinstance(num_mcqs, int) or num_mcqs <= 0:\n",
    "        raise ValueError(\"num_mcqs must be a positive integer.\")\n",
    "\n",
    "    attempts = 0\n",
    "    while attempts < retry_attempts:\n",
    "        try:\n",
    "            # Create the GenerativeModel instance\n",
    "            model = genai.GenerativeModel('gemini-1.5-flash')\n",
    "\n",
    "            # Generate MCQs with the specified prompt\n",
    "            prompt = (f\"Generate {num_mcqs} unique multiple-choice questions (MCQs) from the following text. \"\n",
    "                      f\"Each MCQ should have a question and four options (A, B, C, D), with one correct answer. \"\n",
    "                      f\"Ensure that there are no duplicates in the questions and answers. \"\n",
    "                      f\"Provide the output in the form Q: question text\\nA: option A text\\nB: option B text\\nC: option C text\\nD: option D text\\nCorrect Answer: option letter\\n\\nText: {text}\")\n",
    "            response = model.generate_content(prompt)\n",
    "\n",
    "            # Clean up the generated content\n",
    "            output = response.text.strip().replace('*', '').replace('#', '')\n",
    "\n",
    "            # Split the output into MCQs\n",
    "            mcqs = [mcq.strip() for mcq in output.split('\\n\\n') if mcq.strip()]\n",
    "            \n",
    "            # Remove duplicates and format the output\n",
    "            unique_mcqs = []\n",
    "            seen_questions = set()  # Track questions to avoid duplicates\n",
    "            for mcq in mcqs:\n",
    "                parts = mcq.split('\\n')\n",
    "                if len(parts) >= 6:  # Check for at least 6 lines (Q + 4 options + Correct Answer)\n",
    "                    question = parts[0].replace('Q:', '').strip()\n",
    "                    if question not in seen_questions:\n",
    "                        seen_questions.add(question)\n",
    "                        options = \"\\n\".join([line for line in parts[1:5]])\n",
    "                        correct_answer = parts[5].replace('Correct Answer:', '').strip()\n",
    "                        unique_mcqs.append(f\"Q: {question}\\n{options}\\nCorrect Answer: {correct_answer}\")\n",
    "\n",
    "            # Select the required number of MCQs\n",
    "            unique_mcqs = unique_mcqs[:num_mcqs]\n",
    "\n",
    "            # Format the cleaned output\n",
    "            formatted_output = \"\\n\\n\".join(unique_mcqs)\n",
    "\n",
    "            return formatted_output\n",
    "\n",
    "        except Exception as e:\n",
    "            attempts += 1\n",
    "            print(f\"Attempt {attempts} failed: {e}\")\n",
    "            if attempts < retry_attempts:\n",
    "                time.sleep(2)  # Wait before retrying\n",
    "\n",
    "    return \"Failed to generate MCQs after several attempts.\"\n",
    "\n",
    "# Example usage\n",
    "pdf_path = r\"C:\\Users\\pavan\\OneDrive\\Desktop\\QAG\\NEW DATA\\Literature survey papers\\A Practical Toolkit for Multilingual Question and Answer Generation.pdf\"  # Replace with your PDF file path\n",
    "text_input = extract_text_from_pdf(pdf_path)\n",
    "\n",
    "if text_input:\n",
    "    num_mcqs = 3\n",
    "    mcqs_output = generate_mcqs(text_input, num_mcqs)\n",
    "    print(mcqs_output)\n",
    "else:\n",
    "    print(\"No text extracted from the PDF.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "fe97b054-3edc-4c4d-9aee-964515febc24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MCQs saved to C:\\Users\\pavan\\OneDrive\\Desktop\\mcqs_output.txt\n"
     ]
    }
   ],
   "source": [
    "#save the generated MCQs in text file\n",
    "import google.generativeai as genai\n",
    "import fitz  # PyMuPDF\n",
    "import time\n",
    "\n",
    "# Configure API key for Google Generative AI\n",
    "apikey = \"api key\"  # Replace with your actual API key\n",
    "genai.configure(api_key=apikey)\n",
    "\n",
    "def extract_text_from_pdf(pdf_path):\n",
    "    \"\"\"\n",
    "    Extract text from a PDF file.\n",
    "\n",
    "    Parameters:\n",
    "    - pdf_path (str): The path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "    - str: The extracted text from the PDF.\n",
    "    \"\"\"\n",
    "    text = \"\"\n",
    "    try:\n",
    "        pdf_document = fitz.open(pdf_path)\n",
    "        for page_num in range(len(pdf_document)):\n",
    "            page = pdf_document.load_page(page_num)\n",
    "            text += page.get_text()\n",
    "        pdf_document.close()\n",
    "    except Exception as e:\n",
    "        print(f\"Error reading PDF: {e}\")\n",
    "    return text\n",
    "\n",
    "def generate_mcqs(text, num_mcqs=3, retry_attempts=3):\n",
    "    \"\"\"\n",
    "    Generate multiple-choice questions (MCQs) from a text input and return cleaned output.\n",
    "\n",
    "    Parameters:\n",
    "    - text (str): The text to generate MCQs from.\n",
    "    - num_mcqs (int): The number of MCQs to generate.\n",
    "    - retry_attempts (int): Number of retry attempts in case of API failure.\n",
    "\n",
    "    Returns:\n",
    "    - str: The cleaned MCQs output.\n",
    "    \"\"\"\n",
    "    if not isinstance(num_mcqs, int) or num_mcqs <= 0:\n",
    "        raise ValueError(\"num_mcqs must be a positive integer.\")\n",
    "\n",
    "    attempts = 0\n",
    "    while attempts < retry_attempts:\n",
    "        try:\n",
    "            # Create the GenerativeModel instance\n",
    "            model = genai.GenerativeModel('gemini-1.5-flash')\n",
    "\n",
    "            # Generate MCQs with the specified prompt\n",
    "            prompt = (f\"Generate {num_mcqs} unique multiple-choice questions (MCQs) from the following text. \"\n",
    "                      f\"Each MCQ should have a question and four options (A, B, C, D), with one correct answer. \"\n",
    "                      f\"Ensure that there are no duplicates in the questions and answers. \"\n",
    "                      f\"Provide the output in the form Q: question text\\nA: option A text\\nB: option B text\\nC: option C text\\nD: option D text\\nCorrect Answer: option letter\\n\\nText: {text}\")\n",
    "            response = model.generate_content(prompt)\n",
    "\n",
    "            # Clean up the generated content\n",
    "            output = response.text.strip().replace('*', '').replace('#', '')\n",
    "\n",
    "            # Split the output into MCQs\n",
    "            mcqs = [mcq.strip() for mcq in output.split('\\n\\n') if mcq.strip()]\n",
    "            \n",
    "            # Remove duplicates and format the output\n",
    "            unique_mcqs = []\n",
    "            seen_questions = set()  # Track questions to avoid duplicates\n",
    "            for mcq in mcqs:\n",
    "                parts = mcq.split('\\n')\n",
    "                if len(parts) >= 6:  # Check for at least 6 lines (Q + 4 options + Correct Answer)\n",
    "                    question = parts[0].replace('Q:', '').strip()\n",
    "                    if question not in seen_questions:\n",
    "                        seen_questions.add(question)\n",
    "                        options = \"\\n\".join([line for line in parts[1:5]])\n",
    "                        correct_answer = parts[5].replace('Correct Answer:', '').strip()\n",
    "                        unique_mcqs.append(f\"Q: {question}\\n{options}\\nCorrect Answer: {correct_answer}\")\n",
    "\n",
    "            # Select the required number of MCQs\n",
    "            unique_mcqs = unique_mcqs[:num_mcqs]\n",
    "\n",
    "            # Format the cleaned output\n",
    "            formatted_output = \"\\n\\n\".join(unique_mcqs)\n",
    "\n",
    "            return formatted_output\n",
    "\n",
    "        except Exception as e:\n",
    "            attempts += 1\n",
    "            print(f\"Attempt {attempts} failed: {e}\")\n",
    "            if attempts < retry_attempts:\n",
    "                time.sleep(2)  # Wait before retrying\n",
    "\n",
    "    return \"Failed to generate MCQs after several attempts.\"\n",
    "\n",
    "def save_mcqs_to_file(mcqs, file_path):\n",
    "    \"\"\"\n",
    "    Save the MCQs to a text file.\n",
    "\n",
    "    Parameters:\n",
    "    - mcqs (str): The MCQs content to save.\n",
    "    - file_path (str): The path to the file where MCQs will be saved.\n",
    "    \"\"\"\n",
    "    try:\n",
    "        with open(file_path, 'w') as file:\n",
    "            file.write(mcqs)\n",
    "        print(f\"MCQs saved to {file_path}\")\n",
    "    except Exception as e:\n",
    "        print(f\"Error saving MCQs to file: {e}\")\n",
    "\n",
    "# Example usage\n",
    "pdf_path = r\"C:\\Users\\pavan\\OneDrive\\Desktop\\QAG\\NEW DATA\\Literature survey papers\\A Practical Toolkit for Multilingual Question and Answer Generation.pdf\"  # Replace with your PDF file path\n",
    "output_file_path = r\"C:\\Users\\pavan\\OneDrive\\Desktop\\mcqs_output.txt\"  # Replace with your desired output file path\n",
    "\n",
    "text_input = extract_text_from_pdf(pdf_path)\n",
    "\n",
    "if text_input:\n",
    "    num_mcqs = 3\n",
    "    mcqs_output = generate_mcqs(text_input, num_mcqs)\n",
    "    save_mcqs_to_file(mcqs_output, output_file_path)\n",
    "else:\n",
    "    print(\"No text extracted from the PDF.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4b6109f5-dfe7-4608-b1fd-547c194d7c88",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\n",
      "    {\n",
      "        \"question\": \"What is the primary goal of Question and Answer Generation (QAG)?\",\n",
      "        \"options\": {\n",
      "            \"A\": \"To create a list of question-answer pairs based on a given text.\",\n",
      "            \"B\": \"To generate a single, comprehensive answer to a given question.\",\n",
      "            \"C\": \"To identify the most important information in a text.\",\n",
      "            \"D\": \"To translate text from one language to another.\"\n",
      "        },\n",
      "        \"correct_answer\": \"A\"\n",
      "    },\n",
      "    {\n",
      "        \"question\": \"Which of the following is NOT a publicly available resource introduced in the paper for multilingual QAG?\",\n",
      "        \"options\": {\n",
      "            \"A\": \"lmqg, a Python package for QAG model fine-tuning and inference.\",\n",
      "            \"B\": \"AutoQG, an online service for multilingual QAG.\",\n",
      "            \"C\": \"QAG models in eight languages, fine-tuned on QG-Bench.\",\n",
      "            \"D\": \"A dedicated software system for in-house use, integrating QAG into various applications.\"\n",
      "        },\n",
      "        \"correct_answer\": \"D\"\n",
      "    },\n",
      "    {\n",
      "        \"question\": \"What is the main purpose of using a lexical overlap score in AutoQG for non-English generations?\",\n",
      "        \"options\": {\n",
      "            \"A\": \"To rank generations based on their perplexity, as a computationally-light alternative.\",\n",
      "            \"B\": \"To identify and remove any toxic content generated by the QAG model.\",\n",
      "            \"C\": \"To improve the fluency and grammatical accuracy of the generated text.\",\n",
      "            \"D\": \"To ensure that the generated questions are specific and relevant to the context.\"\n",
      "        },\n",
      "        \"correct_answer\": \"A\"\n",
      "    }\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "#display the output in json format\n",
    "import google.generativeai as genai\n",
    "import fitz  # PyMuPDF\n",
    "import json\n",
    "import time\n",
    "\n",
    "# Configure API key for Google Generative AI\n",
    "apikey = \"api key\"  # Replace with your actual API key\n",
    "genai.configure(api_key=apikey)\n",
    "\n",
    "def extract_text_from_pdf(pdf_path):\n",
    "    \"\"\"\n",
    "    Extract text from a PDF file.\n",
    "\n",
    "    Parameters:\n",
    "    - pdf_path (str): The path to the PDF file.\n",
    "\n",
    "    Returns:\n",
    "    - str: The extracted text from the PDF.\n",
    "    \"\"\"\n",
    "    text = \"\"\n",
    "    try:\n",
    "        pdf_document = fitz.open(pdf_path)\n",
    "        for page_num in range(len(pdf_document)):\n",
    "            page = pdf_document.load_page(page_num)\n",
    "            text += page.get_text()\n",
    "        pdf_document.close()\n",
    "    except Exception as e:\n",
    "        print(f\"Error reading PDF: {e}\")\n",
    "    return text\n",
    "\n",
    "def generate_mcqs(text, num_mcqs=3, retry_attempts=3):\n",
    "    \"\"\"\n",
    "    Generate multiple-choice questions (MCQs) from a text input and return them in JSON format.\n",
    "\n",
    "    Parameters:\n",
    "    - text (str): The text to generate MCQs from.\n",
    "    - num_mcqs (int): The number of MCQs to generate.\n",
    "    - retry_attempts (int): Number of retry attempts in case of API failure.\n",
    "\n",
    "    Returns:\n",
    "    - dict: The MCQs formatted in JSON.\n",
    "    \"\"\"\n",
    "    if not isinstance(num_mcqs, int) or num_mcqs <= 0:\n",
    "        raise ValueError(\"num_mcqs must be a positive integer.\")\n",
    "\n",
    "    attempts = 0\n",
    "    while attempts < retry_attempts:\n",
    "        try:\n",
    "            # Create the GenerativeModel instance\n",
    "            model = genai.GenerativeModel('gemini-1.5-flash')\n",
    "\n",
    "            # Generate MCQs with the specified prompt\n",
    "            prompt = (f\"Generate {num_mcqs} unique multiple-choice questions (MCQs) from the following text. \"\n",
    "                      f\"Each MCQ should have a question and four options (A, B, C, D), with one correct answer. \"\n",
    "                      f\"Ensure that there are no duplicates in the questions and answers. \"\n",
    "                      f\"Provide the output in the form Q: question text\\nA: option A text\\nB: option B text\\nC: option C text\\nD: option D text\\nCorrect Answer: option letter\\n\\nText: {text}\")\n",
    "            response = model.generate_content(prompt)\n",
    "\n",
    "            # Clean up the generated content\n",
    "            output = response.text.strip().replace('*', '').replace('#', '')\n",
    "\n",
    "            # Split the output into MCQs\n",
    "            mcqs = [mcq.strip() for mcq in output.split('\\n\\n') if mcq.strip()]\n",
    "            \n",
    "            # Remove duplicates and format the output\n",
    "            unique_mcqs = []\n",
    "            seen_questions = set()  # Track questions to avoid duplicates\n",
    "            for mcq in mcqs:\n",
    "                parts = mcq.split('\\n')\n",
    "                if len(parts) >= 6:  # Check for at least 6 lines (Q + 4 options + Correct Answer)\n",
    "                    question = parts[0].replace('Q:', '').strip()\n",
    "                    if question not in seen_questions:\n",
    "                        seen_questions.add(question)\n",
    "                        options = {\n",
    "                            'A': parts[1].replace('A:', '').strip(),\n",
    "                            'B': parts[2].replace('B:', '').strip(),\n",
    "                            'C': parts[3].replace('C:', '').strip(),\n",
    "                            'D': parts[4].replace('D:', '').strip()\n",
    "                        }\n",
    "                        correct_answer = parts[5].replace('Correct Answer:', '').strip()\n",
    "                        unique_mcqs.append({\n",
    "                            'question': question,\n",
    "                            'options': options,\n",
    "                            'correct_answer': correct_answer\n",
    "                        })\n",
    "\n",
    "            # Select the required number of MCQs\n",
    "            unique_mcqs = unique_mcqs[:num_mcqs]\n",
    "\n",
    "            # Return the MCQs formatted in JSON\n",
    "            return unique_mcqs\n",
    "\n",
    "        except Exception as e:\n",
    "            attempts += 1\n",
    "            print(f\"Attempt {attempts} failed: {e}\")\n",
    "            if attempts < retry_attempts:\n",
    "                time.sleep(2)  # Wait before retrying\n",
    "\n",
    "    return []\n",
    "\n",
    "# Example usage\n",
    "pdf_path = r\"C:\\Users\\pavan\\OneDrive\\Desktop\\QAG\\NEW DATA\\Literature survey papers\\A Practical Toolkit for Multilingual Question and Answer Generation.pdf\"  # Replace with your PDF file path # Replace with your PDF file path\n",
    "\n",
    "text_input = extract_text_from_pdf(pdf_path)\n",
    "\n",
    "if text_input:\n",
    "    num_mcqs = 3\n",
    "    mcqs_output = generate_mcqs(text_input, num_mcqs)\n",
    "    # Print MCQs in JSON format\n",
    "    print(json.dumps(mcqs_output, indent=4))\n",
    "else:\n",
    "    print(\"No text extracted from the PDF.\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "dfc49af2-5833-4ac6-9d8f-abfb78a9e932",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[\n",
      "    {\n",
      "        \"question\": \"Q1: What is the primary difference between AI and natural intelligence?\",\n",
      "        \"options\": {\n",
      "            \"A\": \"AI is more intelligent than natural intelligence.\",\n",
      "            \"B\": \"AI is created by humans, while natural intelligence is inherent in living beings.\",\n",
      "            \"C\": \"AI is only found in machines, while natural intelligence is found in both machines and living beings.\",\n",
      "            \"D\": \"AI is based on human intelligence, while natural intelligence is based on animal instincts.\"\n",
      "        },\n",
      "        \"correct_answer\": \"B\"\n",
      "    },\n",
      "    {\n",
      "        \"question\": \"Q2: What is the main focus of AI research?\",\n",
      "        \"options\": {\n",
      "            \"A\": \"Studying the human brain.\",\n",
      "            \"B\": \"Developing machines that can replicate human emotions.\",\n",
      "            \"C\": \"Creating intelligent agents that can interact with their environment.\",\n",
      "            \"D\": \"Replacing human workers with AI-powered machines.\"\n",
      "        },\n",
      "        \"correct_answer\": \"C\"\n",
      "    },\n",
      "    {\n",
      "        \"question\": \"Q3: Which of the following is an accurate definition of Artificial Intelligence (AI)?\",\n",
      "        \"options\": {\n",
      "            \"A\": \"The ability of machines to perform complex mathematical calculations.\",\n",
      "            \"B\": \"The simulation of human intelligence in machines designed to think and act like humans.\",\n",
      "            \"C\": \"The study of the human brain and its functions.\",\n",
      "            \"D\": \"The development of robots that can perform household tasks.\"\n",
      "        },\n",
      "        \"correct_answer\": \"B\"\n",
      "    }\n",
      "]\n"
     ]
    }
   ],
   "source": [
    "#generate MCQs with text input and JSON output\n",
    "import google.generativeai as genai\n",
    "import json\n",
    "import time\n",
    "\n",
    "# Configure API key for Google Generative AI\n",
    "apikey = \"api key\"  # Replace with your actual API key\n",
    "genai.configure(api_key=apikey)\n",
    "\n",
    "def generate_mcqs(text, num_mcqs=3, retry_attempts=3):\n",
    "    \"\"\"\n",
    "    Generate multiple-choice questions (MCQs) from a text input and return them in JSON format.\n",
    "\n",
    "    Parameters:\n",
    "    - text (str): The text to generate MCQs from.\n",
    "    - num_mcqs (int): The number of MCQs to generate.\n",
    "    - retry_attempts (int): Number of retry attempts in case of API failure.\n",
    "\n",
    "    Returns:\n",
    "    - list: The MCQs formatted as a list of dictionaries.\n",
    "    \"\"\"\n",
    "    if not isinstance(num_mcqs, int) or num_mcqs <= 0:\n",
    "        raise ValueError(\"num_mcqs must be a positive integer.\")\n",
    "\n",
    "    attempts = 0\n",
    "    while attempts < retry_attempts:\n",
    "        try:\n",
    "            # Create the GenerativeModel instance\n",
    "            model = genai.GenerativeModel('gemini-1.5-flash')\n",
    "\n",
    "            # Generate MCQs with the specified prompt\n",
    "            prompt = (f\"Generate {num_mcqs} unique multiple-choice questions (MCQs) from the following text. \"\n",
    "                      f\"Each MCQ should have a question and four options (A, B, C, D), with one correct answer. \"\n",
    "                      f\"Ensure that there are no duplicates in the questions and answers. \"\n",
    "                      f\"Provide the output in the form Q: question text\\nA: option A text\\nB: option B text\\nC: option C text\\nD: option D text\\nCorrect Answer: option letter\\n\\nText: {text}\")\n",
    "            response = model.generate_content(prompt)\n",
    "\n",
    "            # Clean up the generated content\n",
    "            output = response.text.strip().replace('*', '').replace('#', '')\n",
    "\n",
    "            # Split the output into MCQs\n",
    "            mcqs = [mcq.strip() for mcq in output.split('\\n\\n') if mcq.strip()]\n",
    "            \n",
    "            # Remove duplicates and format the output\n",
    "            unique_mcqs = []\n",
    "            seen_questions = set()  # Track questions to avoid duplicates\n",
    "            for mcq in mcqs:\n",
    "                parts = mcq.split('\\n')\n",
    "                if len(parts) >= 6:  # Check for at least 6 lines (Q + 4 options + Correct Answer)\n",
    "                    question = parts[0].replace('Q:', '').strip()\n",
    "                    if question not in seen_questions:\n",
    "                        seen_questions.add(question)\n",
    "                        options = {\n",
    "                            'A': parts[1].replace('A:', '').strip(),\n",
    "                            'B': parts[2].replace('B:', '').strip(),\n",
    "                            'C': parts[3].replace('C:', '').strip(),\n",
    "                            'D': parts[4].replace('D:', '').strip()\n",
    "                        }\n",
    "                        correct_answer = parts[5].replace('Correct Answer:', '').strip()\n",
    "                        unique_mcqs.append({\n",
    "                            'question': question,\n",
    "                            'options': options,\n",
    "                            'correct_answer': correct_answer\n",
    "                        })\n",
    "\n",
    "            # Select the required number of MCQs\n",
    "            unique_mcqs = unique_mcqs[:num_mcqs]\n",
    "\n",
    "            # Return the MCQs formatted in JSON\n",
    "            return unique_mcqs\n",
    "\n",
    "        except Exception as e:\n",
    "            attempts += 1\n",
    "            print(f\"Attempt {attempts} failed: {e}\")\n",
    "            if attempts < retry_attempts:\n",
    "                time.sleep(2)  # Wait before retrying\n",
    "\n",
    "    return []\n",
    "\n",
    "# Example usage\n",
    "text_input = \"\"\"Artificial Intelligence (AI) refers to the simulation of human intelligence in machines that are designed to think and act like humans. The primary distinction between AI and natural intelligence is that AI is a product of human creation, whereas natural intelligence is inherent in living beings. AI research is primarily focused on studying 'intelligent agents' that can interact with their environment and achieve their objectives with the highest probability of success.\"\"\"\n",
    "\n",
    "num_mcqs = 3\n",
    "mcqs_output = generate_mcqs(text_input, num_mcqs)\n",
    "\n",
    "# Print MCQs in JSON format\n",
    "print(json.dumps(mcqs_output, indent=4))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "442f22c1-5c2e-48fc-876d-e765d5c07160",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Questions:\n",
      "Q1: What is the primary difference between Artificial Intelligence (AI) and natural intelligence?\n",
      "A: AI is a product of human creation, while natural intelligence is inherent in living beings.\n",
      "B: AI is based on algorithms, while natural intelligence is based on emotions.\n",
      "C: AI is faster than natural intelligence, while natural intelligence is more creative.\n",
      "D: AI can learn from data, while natural intelligence learns from experience.\n",
      "\n",
      "Q2: What is the main focus of AI research?\n",
      "A: Developing machines that can surpass human intelligence.\n",
      "B: Creating machines that can understand human emotions.\n",
      "C: Studying 'intelligent agents' that can interact with their environment and achieve objectives.\n",
      "D: Building machines that can replicate the human brain.\n",
      "\n",
      "Q3: Which of the following is NOT a characteristic of Artificial Intelligence?\n",
      "A: The ability to learn and adapt.\n",
      "B: The capacity for self-awareness.\n",
      "C: The potential to solve complex problems.\n",
      "D: The potential to enhance human capabilities.\n",
      "\n",
      "Answers:\n",
      "Correct Answer: A\n",
      "Correct Answer: C\n",
      "Correct Answer: B\n"
     ]
    }
   ],
   "source": [
    "#questions seperate and answers seperate\n",
    "import google.generativeai as genai\n",
    "import time\n",
    "\n",
    "# Configure API key for Google Generative AI\n",
    "apikey = \"api key\"  # Replace with your actual API key\n",
    "genai.configure(api_key=apikey)\n",
    "\n",
    "def generate_mcqs(text, num_mcqs=3, retry_attempts=3):\n",
    "    \"\"\"\n",
    "    Generate multiple-choice questions (MCQs) from a text input and return them in a plain format\n",
    "    with questions and answers separated.\n",
    "\n",
    "    Parameters:\n",
    "    - text (str): The text to generate MCQs from.\n",
    "    - num_mcqs (int): The number of MCQs to generate.\n",
    "    - retry_attempts (int): Number of retry attempts in case of API failure.\n",
    "\n",
    "    Returns:\n",
    "    - tuple: Two lists - one containing questions and the other containing answers.\n",
    "    \"\"\"\n",
    "    if not isinstance(num_mcqs, int) or num_mcqs <= 0:\n",
    "        raise ValueError(\"num_mcqs must be a positive integer.\")\n",
    "\n",
    "    attempts = 0\n",
    "    while attempts < retry_attempts:\n",
    "        try:\n",
    "            # Create the GenerativeModel instance\n",
    "            model = genai.GenerativeModel('gemini-1.5-flash')\n",
    "\n",
    "            # Generate MCQs with the specified prompt\n",
    "            prompt = (f\"Generate {num_mcqs} unique multiple-choice questions (MCQs) from the following text. \"\n",
    "                      f\"Each MCQ should have a question and four options (A, B, C, D), with one correct answer. \"\n",
    "                      f\"Ensure that there are no duplicates in the questions and answers. \"\n",
    "                      f\"Provide the output in the form Q: question text\\nA: option A text\\nB: option B text\\nC: option C text\\nD: option D text\\nCorrect Answer: option letter\\n\\nText: {text}\")\n",
    "            response = model.generate_content(prompt)\n",
    "\n",
    "            # Clean up the generated content\n",
    "            output = response.text.strip().replace('*', '').replace('#', '')\n",
    "\n",
    "            # Split the output into MCQs\n",
    "            mcqs = [mcq.strip() for mcq in output.split('\\n\\n') if mcq.strip()]\n",
    "            \n",
    "            # Remove duplicates and format the output\n",
    "            questions = []\n",
    "            answers = []\n",
    "            seen_questions = set()  # Track questions to avoid duplicates\n",
    "            for mcq in mcqs:\n",
    "                parts = mcq.split('\\n')\n",
    "                if len(parts) >= 6:  # Check for at least 6 lines (Q + 4 options + Correct Answer)\n",
    "                    question = parts[0].replace('Q:', '').strip()\n",
    "                    if question not in seen_questions:\n",
    "                        seen_questions.add(question)\n",
    "                        options = {\n",
    "                            'A': parts[1].replace('A:', '').strip(),\n",
    "                            'B': parts[2].replace('B:', '').strip(),\n",
    "                            'C': parts[3].replace('C:', '').strip(),\n",
    "                            'D': parts[4].replace('D:', '').strip()\n",
    "                        }\n",
    "                        correct_answer = parts[5].replace('Correct Answer:', '').strip()\n",
    "\n",
    "                        # Append to questions and answers lists\n",
    "                        questions.append(f\"{question}\\nA: {options['A']}\\nB: {options['B']}\\nC: {options['C']}\\nD: {options['D']}\")\n",
    "                        answers.append(f\"Correct Answer: {correct_answer}\")\n",
    "            \n",
    "            # Select the required number of MCQs\n",
    "            questions = questions[:num_mcqs]\n",
    "            answers = answers[:num_mcqs]\n",
    "\n",
    "            # Return questions and answers\n",
    "            return questions, answers\n",
    "\n",
    "        except Exception as e:\n",
    "            attempts += 1\n",
    "            print(f\"Attempt {attempts} failed: {e}\")\n",
    "            if attempts < retry_attempts:\n",
    "                time.sleep(2)  # Wait before retrying\n",
    "\n",
    "    return [], []\n",
    "\n",
    "# Example usage\n",
    "text_input = \"\"\"Artificial Intelligence (AI) refers to the simulation of human intelligence in machines that are designed to think and act like humans. The primary distinction between AI and natural intelligence is that AI is a product of human creation, whereas natural intelligence is inherent in living beings. AI research is primarily focused on studying 'intelligent agents' that can interact with their environment and achieve their objectives with the highest probability of success.\"\"\"\n",
    "\n",
    "num_mcqs = 3\n",
    "questions_output, answers_output = generate_mcqs(text_input, num_mcqs)\n",
    "\n",
    "# Print questions and answers\n",
    "print(\"Questions:\")\n",
    "for question in questions_output:\n",
    "    print(question + \"\\n\")\n",
    "\n",
    "print(\"Answers:\")\n",
    "for answer in answers_output:\n",
    "    print(answer)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd9cce06-1e47-4d65-85f4-706f44acdce9",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}