Merge pull request #12 from DishaKushwah/main

app.py

@@ -19,7 +19,10 @@ question_type = col1.selectbox("Question Type", ["Multiple Choice", "Short Answe
 difficulty = col2.selectbox("Difficulty", ["easy", "medium", "hard"])
 
 num_questions = st.slider("🔢 Number of Questions", min_value=1, max_value=10, value=3)
+#<<<<<<< main
+#=======
 
+#>>>>>>> main
 
 # Generate button
 if st.button("⚡ Generate Quiz"):
@@ -82,3 +85,7 @@ if st.button("⚡ Generate Quiz"):
             if questions:
                 st.download_button("⬇️ Download Quiz as PDF", output.getvalue(), file_name="quizcraft_quiz.pdf")
 
+#<<<<<<< main
+
+#=======
+#>>>>>>> main

mcq_generator.py

@@ -1,171 +1,136 @@
-import torch
+
 import random
 import nltk
-import re
-from transformers import (pipeline, AutoModelForQuestionAnswering, AutoTokenizer)
-from sentence_transformers import SentenceTransformer
-from sklearn.feature_extraction.text import TfidfVectorizer
-from typing import List, Dict, Any
-nltk.download('punkt')
-nltk.download('stopwords')
+from nltk.corpus import stopwords
+from nltk.tokenize import sent_tokenize, word_tokenize
+from transformers import pipeline
 
 class AdvancedMCQGenerator:
     def __init__(self):
-        """Advanced Multiple Choice Question Generator with Intelligent Distractor Strategy"""
-        # Question Answering Model
-        qa_model_name = "deepset/roberta-base-squad2"
-        self.qa_tokenizer = AutoTokenizer.from_pretrained(qa_model_name)
-        self.qa_pipeline = pipeline("question-answering", model=qa_model_name,device=0 if torch.cuda.is_available() else -1)
-        self.sentence_embedder = SentenceTransformer('all-mpnet-base-v2')
-        self.tfidf_vectorizer = TfidfVectorizer(stop_words='english', ngram_range=(1, 2))
-        self.sentence_tokenizer = nltk.sent_tokenize
-        self.generated_questions = set()
+        nltk.download('punkt', quiet=True)
+        nltk.download('stopwords', quiet=True)
+        
+        # Initialize NLP models
+        self.qa_pipeline = pipeline("question-answering")
+        self.stop_words = set(stopwords.words('english'))
 
-    def _extract_context_features(self, context: str) -> Dict[str, Any]:
-        """Advanced context feature extraction"""
-        sentences = self.sentence_tokenizer(context)
-        try:
-            tfidf_matrix = self.tfidf_vectorizer.fit_transform(sentences)
-            feature_names = self.tfidf_vectorizer.get_feature_names_out()
-            top_keywords = []
-            for i, sentence in enumerate(sentences):
-                feature_indices = tfidf_matrix[i].nonzero()[1]                # Get top TF-IDF scores for each sentence
-                top_sentence_keywords = [feature_names[idx] for idx in feature_indices][:3]
-                top_keywords.extend(top_sentence_keywords)
-            return {'sentences': sentences,'keywords': list(set(top_keywords)),'total_sentences': len(sentences)}
-        except Exception as e:
-            print(f"Context feature extraction error: {e}")
-            return {'sentences': sentences,'keywords': context.split()[:10],'total_sentences': len(sentences)}
+    def extract_key_concepts(self, context):
+        """Extract key concepts and important phrases"""
+        # Tokenize sentences
+        sentences = sent_tokenize(context)
+        
+        # Extract potential key concepts
+        key_concepts = []
+        for sentence in sentences:
+            # Look for sentences with unique, meaningful content
+            words = word_tokenize(sentence)
+            filtered_words = [word.lower() for word in words if word.isalnum() and word.lower() not in self.stop_words and len(word) > 2]
+            # Prioritize sentences with named entities or specific concepts
+            if len(filtered_words) > 3:
+                key_concepts.append(sentence)
+        return key_concepts[:5]  # Return top 5 key concepts
 
-    def _generate_smart_distractors(self, correct_answer: str, context_features: Dict[str, Any], num_distractors: int = 3) -> List[str]:
-        """Intelligent Distractor Generation Strategy"""
-        distractors = []
-        used_options = set([correct_answer.lower()])
-        sentences = context_features['sentences']
-        keywords = context_features['keywords']
-        # Semantic similarity-based distractor generation
-        for _ in range(num_distractors):
-            try:
-                semantic_candidates = [sent for sent in sentences if sent.lower() not in used_options and len(sent.split()) > 3]
-                if semantic_candidates:
-                    candidate_similarities = [(sent, self._calculate_semantic_similarity(correct_answer, sent)) for sent in semantic_candidates]
-                    candidate_similarities.sort(key=lambda x: abs(0.5 - x[1]))
-                    if candidate_similarities:
-                        best_distractor = candidate_similarities[0][0]
-                        distractors.append(best_distractor)
-                        used_options.add(best_distractor.lower())
-                        continue
-                
-                if keywords:
-                    keyword_distractor = f"A key aspect related to {random.choice(keywords)}"
-                    distractors.append(keyword_distractor)
-                    used_options.add(keyword_distractor.lower())
-                    continue
-                fallback_distractors = ["A related contextual detail","An alternative interpretation","A supplementary concept"]
-                distractor = random.choice(fallback_distractors)
-                distractors.append(distractor)
-                used_options.add(distractor.lower())
-            
-            except Exception as e:
-                print(f"Distractor generation error: {e}")
-                distractors.append("A contextual detail")
-        return distractors[:num_distractors]
+    def generate_intelligent_question(self, concept, context, difficulty):
+            if difficulty == 'easy':
+                templates = [
+                    f"What is {concept}?",
+                    f"Describe {concept}.",
+                    f"Define {concept}.",
+                    f"What do you understand by {concept}?",
+                    f"Give a simple explanation of {concept}."
+                ]
+            elif difficulty == 'hard':
+                templates = [
+                    f"In what way does {concept} reflect a broader implication?",
+                    f"Critically analyze the role of {concept} in the given context.",
+                    f"How can {concept} be interpreted in complex scenarios?",
+                    f"What deeper insights does {concept} provide?",
+                    f"Discuss the nuanced impact of {concept} in this context."
+                ]
+            else:  # medium
+                templates = [
+                    f"What is the primary significance of {concept}?",
+                    f"How does {concept} impact the broader context?",
+                    f"What key role does {concept} play in the narrative?",
+                    f"Explain the importance of {concept} in this context.",
+                    f"What makes {concept} crucial to understanding the situation?"
+                ]
+            return random.choice(templates)
 
-    def _calculate_semantic_similarity(self, text1: str, text2: str) -> float:
-        """Calculate semantic similarity between two texts"""
-        try:
-            # Embed texts
-            embedding1 = self.sentence_embedder.encode(text1)
-            embedding2 = self.sentence_embedder.encode(text2)
-            
-            # Calculate cosine similarity
-            similarity = torch.nn.functional.cosine_similarity(torch.tensor(embedding1), torch.tensor(embedding2)).item()
-            return abs(similarity)
-        except Exception:
-            return 0.0
+    def generate_contextual_distractors(self, correct_answer, context, difficulty):
+        """Create semantically related but incorrect distractors"""
+        sentences = sent_tokenize(context)
+        distractors = []
+        potential_distractors = [sent for sent in sentences if correct_answer.lower() not in sent.lower() and len(sent.split()) > 3]
+        fallback_distractors = ["A partially related historical context","An alternative interpretation","A peripheral aspect of the main theme"]
+        # Generating diverse distractors
+        while len(distractors) < 3:
+            if potential_distractors:
+                distractor = random.choice(potential_distractors)
+                potential_distractors.remove(distractor)
+                words = word_tokenize(distractor)
+                if difficulty == 'easy':
+                    phrase = ' '.join([w for w in words if w.lower() not in self.stop_words][:2])
+                elif difficulty == 'hard':
+                    phrase = ' '.join([w for w in words if w.lower() not in self.stop_words][:5])
+                else:  # medium
+                    phrase = ' '.join([w for w in words if w.lower() not in self.stop_words][:3])
+                distractors.append(phrase.strip())
+            else:
+                distractors.append(random.choice(fallback_distractors))
+        return distractors
 
-    def generate_mcq(self, context: str, num_questions: int = 5, difficulty: str = "medium") -> List[Dict[str, Any]]:
-        """
-        Generate Multiple Choice Questions
-        """
-        context = self._preprocess_context(context)        # Preprocess context
-        context_features = self._extract_context_features(context)        # Extract context features
-        self.generated_questions.clear()        # Reset generated questions
+    def generate_mcq(self, context, num_questions=3, difficulty='medium'):
+        """Generate Multiple Choice Questions"""
+        # Validate context
+        if not context or len(context.split()) < 30:
+            raise ValueError("Context is too short. Provide more detailed text.")
+        
         mcq_questions = []
+        key_concepts = self.extract_key_concepts(context)
         
-        for _ in range(num_questions):
+        for concept in key_concepts[:num_questions]:
             try:
-                keywords = context_features['keywords']
-                subject = random.choice(keywords)
-                        # Question templates
-                templates = [f"What is the significance of {subject} in this context?",f"Explain the role of {subject}.",f"How does {subject} contribute to the overall understanding?"]
-                question = random.choice(templates)
-                answer_result = self.qa_pipeline(question=question, context=context)      # Extract answer using QA pipeline
-                correct_answer = answer_result['answer']       # Get correct answer
-                distractors = self._generate_smart_distractors(correct_answer, context_features)      # Generate contextually relevant distractors
-                all_options = [correct_answer] + distractors                # Combine options
+                question = self.generate_intelligent_question(concept, context, difficulty)
+                answer_result = self.qa_pipeline(question=question, context=context)
+                correct_answer = answer_result['answer']
+                distractors = self.generate_contextual_distractors(correct_answer, context, difficulty)
+                all_options = [correct_answer] + distractors
                 random.shuffle(all_options)
-                correct_index = all_options.index(correct_answer)                # Determine correct option index
-                mcq_questions.append({"question": question,"options": all_options,"correct_answer": correct_index,"explanation": f"Correct answer based on the context: {correct_answer}"})
+                correct_index = all_options.index(correct_answer)  # Determine correct option index
+                mcq_questions.append({"question": question,"options": all_options,"correct_answer": correct_index})     # Create MCQ
             except Exception as e:
-                print(f"MCQ generation error: {e}")
+                print(f"Error generating question: {e}")
         return mcq_questions
-
-    def _preprocess_context(self, context: str) -> str:
-        """Advanced context preprocessing"""
-        context = re.sub(r'\s+', ' ', context).strip()        # Remove extra whitespaces and special characters
-        context = ''.join(char for char in context if char.isprintable())        # Remove non-printable characters
-        if len(context.split()) < 20:        # Append context if too short
-            context += " Additional context to enhance question generation."
-        return context
-
 def main():
+    # Create generator instance
     generator = AdvancedMCQGenerator()
-    print(" -------------Multiple Choice Question Generator-------------")
-    context = input("\n>> Enter context text: ")
-    while True:
-        try:
-            num_questions = int(input("\n>> How many questions do you want to generate? "))
-            break
-        except ValueError:
-            print("Please enter a valid number.")
-    
-    while True:
-        difficulty = input("\n>> Enter difficulty level (easy/medium/hard): ").lower()
-        if difficulty in ['easy', 'medium', 'hard']:
-            break
-        print("Invalid difficulty level. Please choose easy, medium, or hard.")
-    questions = generator.generate_mcq(context, num_questions, difficulty)
-    if questions:
-        print("\n--- Multiple Choice Quiz ---")
-        correct_answers = 0        # Simple score tracking
-        total_questions = len(questions)
+    context = input("Enter context text: ")
+    num_questions = int(input("How many questions do you want? "))
+    difficulty = input("Choose difficulty (easy / medium / hard): ").lower().strip()
 
-        for i, q in enumerate(questions, 1):
-            print(f"\nQuestion {i}: {q['question']}")
-            print("Options:")
-            for j, option in enumerate(q['options']):
-                print(f"{chr(65+j)}. {option}")
-            
-            while True:
-                user_input = input("\nYour Answer (A/B/C/D): ").upper()
-                if user_input in ['A', 'B', 'C', 'D']:
-                    break
-                print("Invalid input. Please enter A, B, C, or D.")
-            
-            user_answer_index = ord(user_input) - 65
-            if user_answer_index == q['correct_answer']:
-                print("✅ Correct!")
-                correct_answers += 1
-            else:
-                print(f"❌ Incorrect. Correct Answer: {chr(65+q['correct_answer'])}")
+    questions = generator.generate_mcq(context, num_questions, difficulty)
+    # Display and solve quiz
+    print("\n--- Quiz Started ---")
+    score = 0
+    for i, q in enumerate(questions, 1):
+        print(f"\nQuestion {i}: {q['question']}")
+        for j, option in enumerate(q['options']):
+            print(f"{chr(65+j)}. {option}")
         
-        # Simple score display
-        print(f"\n-----Score: {correct_answers}/{total_questions}-----")
-
-    else:
-        print("\nNo multiple choice questions were generated.")
+        while True:
+            user_answer = input("\nYour Answer (A/B/C/D): ").upper()
+            if user_answer in ['A', 'B', 'C', 'D']:
+                break
+            print("Invalid input. Please enter A, B, C, or D.")
+        
+        user_index = ord(user_answer) - 65
+        if user_index == q['correct_answer']:
+            print("Correct!")
+            score += 1
+        else:
+            print(f"Incorrect. Correct answer was: {chr(65 + q['correct_answer'])}")
+    print(f"\nFinal Score: {score}/{len(questions)}")
 
 if __name__ == "__main__":
     main()
-# SAMPLE CONTEXT- The French Revolution began in 1789 and marked a significant turning point in European history. It was fueled by widespread social inequality, financial crisis, and the rise of Enlightenment ideas. The French monarchy was overthrown, and King Louis XVI was executed. The revolution introduced the ideals of liberty, equality, and fraternity. It led to the rise of Napoleon Bonaparte and had a lasting impact on modern democracy and human rights movements around the world.

truefalse_quiz.py

@@ -2,66 +2,102 @@ import random
 import nltk
 from transformers import pipeline
 from nltk.tokenize import sent_tokenize
-
-# Download required tokenizer
-nltk.download('punkt', quiet=True)
-
+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
+class generate_true_false:
+    def __init__(self):
+        pass
+    def validate_inputs(self, context, num_questions, difficulty):
+        if not context.strip():
+            raise ValueError("Context cannot be empty.")
+        sentences = sent_tokenize(context)
+        return sentences
 
-# Difficulty-based sentence modifier
-def apply_noise(sentence: str, level: str) -> str:
-    if level == "easy":
+    def apply_noise(self, 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
-    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
+    # Statement generator
+    def generate_statements(self, 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 = self.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(self):
+        while True:
+            user = input("True or False? ").strip().lower()
+            if user in ["true", "false"]:
+                return user
+            print("Please enter 'true' or 'false'.")
 
-# ✅ MAIN BACKEND FUNCTION
-def generate_true_false(context, num_questions, difficulty):
-    """
-    Returns a list of (statement, label) pairs for Streamlit frontend.
-    label: 'ENTAILMENT' (True) or 'CONTRADICTION' (False)
-    """
-    sentences = validate_inputs(context, num_questions, difficulty)
-    questions = generate_statements(context, num_questions, difficulty, sentences)
-    result = []
+    # Main quiz logic
+    def run_quiz(self, context, num_questions, difficulty):
+        try:
+            sentences = self.validate_inputs(context, num_questions, difficulty)
+            questions = self.generate_statements(context, num_questions, difficulty, sentences)
+            
+            print("\n--- QUIZ STARTS ---\n")
+            score = 0
+            
+            for idx, (statement, actual_label) in enumerate(questions, 1):
+                print(f"Q{idx}: {statement}")
+                user = self.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}")
+
+def main():
+    context = input(">> Enter context text: ").strip()
+    try:
+        num_questions = int(input(">> How many questions do you want to generate? ").strip())
+    except ValueError:
+        print("Please enter a valid integer for number of questions.")
+        return
+
+    difficulty = input(">> Enter difficulty level (easy / medium / hard): ").strip().lower()
+    if difficulty not in ["easy", "medium", "hard"]:
+        print("Invalid difficulty level.")
+        return
+    quiz_generator = generate_true_false()
+    quiz_generator.run_quiz(context, num_questions, difficulty)
 
-    for statement, _ in questions:
-        input_text = f"{context} [SEP] {statement}"
-        nli_result = nli(input_text)[0]
-        label = "ENTAILMENT" if nli_result["label"] == "entailment" else "CONTRADICTION"
-        result.append((statement, label))
-    
-    return result
+if __name__ == "__main__":
+    main()