Update app.py

app.py

@@ -1,72 +1,312 @@
 import streamlit as st
-from transformers import pipeline
+import torch
+from transformers import pipeline, AutoTokenizer
 import random
+import time
+
+# Configure page
+st.set_page_config(
+    page_title="Text-to-Quiz Generator",
+    page_icon="🧠",
+    layout="wide"
+)
 
 # Load the pipeline with caching
 @st.cache_resource
-def load_pipeline():
-    return pipeline("text2text-generation", model="valhalla/t5-small-e2e-qg")
-
-# Initialize the pipeline
-qg_pipeline = load_pipeline()
-
-# UI Header
-st.markdown("# Text-to-Quiz Generator")
-st.markdown("Enter a passage below and let AI create an interactive quiz for you!")
-st.markdown("---")
+def load_model():
+    try:
+        # Check if PyTorch is available
+        print(f"PyTorch version: {torch.__version__}")
+        print(f"CUDA available: {torch.cuda.is_available()}")
+        
+        # Using a smaller, more efficient model that works well for question generation
+        model_name = "valhalla/t5-small-e2e-qg"
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        
+        # Set device
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {device}")
+        
+        # Load pipeline
+        qg_pipeline = pipeline(
+            "text2text-generation", 
+            model=model_name, 
+            tokenizer=tokenizer,
+            device=device
+        )
+        
+        return qg_pipeline
+    except Exception as e:
+        st.error(f"Error loading model: {str(e)}")
+        print(f"Error details: {str(e)}")
+        return None
 
-# Input section
-passage = st.text_area("Paste your text here:", height=150)
+# Custom CSS
+def load_css():
+    st.markdown("""
+    <style>
+        .main {
+            padding: 2rem;
+        }
+        .question-box {
+            background-color: #f0f7ff;
+            padding: 1.5rem;
+            border-radius: 10px;
+            margin-bottom: 1rem;
+            border-left: 5px solid #4361ee;
+        }
+        .stButton button {
+            background-color: #4361ee;
+            color: white;
+            padding: 0.5rem 1rem;
+            border-radius: 5px;
+            border: none;
+            font-weight: bold;
+        }
+        .title-box {
+            padding: 1rem;
+            border-radius: 5px;
+            margin-bottom: 2rem;
+            text-align: center;
+            background: linear-gradient(90deg, #4361ee 0%, #3a0ca3 100%);
+            color: white;
+        }
+        .score-box {
+            font-size: 1.5rem;
+            padding: 1rem;
+            border-radius: 5px;
+            text-align: center;
+            font-weight: bold;
+        }
+        .feedback {
+            padding: 1rem;
+            border-radius: 5px;
+            margin: 1rem 0;
+        }
+    </style>
+    """, unsafe_allow_html=True)
 
-if st.button("Generate Quiz"):
-    with st.spinner("Generating your quiz..."):
-        # Generate question-answer pairs (adjust based on actual model output format)
-        generated = qg_pipeline(passage, max_length=512)
+# Function to generate questions from a passage
+def generate_questions(pipeline, text, num_questions=5):
+    try:
+        # Make sure text is not too long
+        max_length = 1024
+        if len(text) > max_length:
+            text = text[:max_length]
         
-        # For this example, assume the model outputs a list of strings like "Q: ... A: ..."
-        # Parse the output into questions and answers (modify this based on your model's actual output)
-        quiz_data = []
-        for item in generated:
-            if "Q:" in item["generated_text"] and "A:" in item["generated_text"]:
-                q, a = item["generated_text"].split("A:")
-                question = q.replace("Q:", "").strip()
-                answer = a.strip()
-                quiz_data.append({"question": question, "answer": answer})
+        # Generate questions
+        result = pipeline(
+            text, 
+            max_length=128, 
+            num_return_sequences=num_questions,
+            clean_up_tokenization_spaces=True
+        )
         
-        if not quiz_data:
-            st.error("No valid questions generated. Please try a different passage.")
-        else:
-            # Store quiz data in session state
-            st.session_state["quiz_data"] = quiz_data
-            st.session_state["user_answers"] = {}
+        # Process and extract questions and answers
+        questions_answers = []
+        for item in result:
+            generated_text = item["generated_text"]
+            
+            # Handle different potential formats
+            if "?" in generated_text:
+                # Try to find question and answer
+                parts = generated_text.split("?", 1)
+                if len(parts) > 1:
+                    question = parts[0].strip() + "?"
+                    answer = parts[1].strip()
+                    
+                    # Clean up answer if it starts with common patterns
+                    for prefix in ["answer:", "a:", " - "]:
+                        if answer.lower().startswith(prefix):
+                            answer = answer[len(prefix):].strip()
+                    
+                    if question and answer and len(question) > 10:
+                        questions_answers.append({
+                            "question": question,
+                            "answer": answer
+                        })
+        
+        return questions_answers
+    except Exception as e:
+        st.error(f"Error generating questions: {str(e)}")
+        return []
 
-    # Display quiz
-    if "quiz_data" in st.session_state:
-        st.markdown("### Your Quiz")
-        questions = [item["question"] for item in st.session_state["quiz_data"]]
-        answers = [item["answer"] for item in st.session_state["quiz_data"]]
+# Function to create quiz from generated Q&A pairs
+def create_quiz(questions_answers, num_options=4):
+    quiz_items = []
+    
+    # First filter out very short answers and duplicates
+    filtered_qa = []
+    seen_questions = set()
+    
+    for qa in questions_answers:
+        q = qa["question"].strip()
+        a = qa["answer"].strip()
         
-        # Generate distractors for each question
-        for i, question in enumerate(questions):
-            correct_answer = answers[i]
-            distractors = [a for j, a in enumerate(answers) if j != i]
-            options = [correct_answer] + random.sample(distractors, min(3, len(distractors)))
+        # Skip very short answers
+        if len(a) < 2 or len(q) < 10:
+            continue
+            
+        # Skip duplicate questions
+        q_lower = q.lower()
+        if q_lower in seen_questions:
+            continue
+            
+        seen_questions.add(q_lower)
+        filtered_qa.append({"question": q, "answer": a})
+    
+    # Use the filtered Q&A pairs
+    all_answers = [qa["answer"] for qa in filtered_qa]
+    
+    for i, qa in enumerate(filtered_qa):
+        correct_answer = qa["answer"]
+        
+        # Create distractors by selecting random answers from other questions
+        other_answers = [a for a in all_answers if a != correct_answer]
+        if other_answers:
+            # Select random distractors
+            num_distractors = min(num_options - 1, len(other_answers))
+            distractors = random.sample(other_answers, num_distractors)
+            
+            # Combine correct answer and distractors
+            options = [correct_answer] + distractors
             random.shuffle(options)
             
-            st.write(f"**Question {i+1}:** {question}")
-            st.session_state["user_answers"][question] = st.radio(
-                "Select your answer:", options, key=f"q{i}"
-            )
+            quiz_items.append({
+                "id": i,
+                "question": qa["question"],
+                "correct_answer": correct_answer,
+                "options": options
+            })
+    
+    return quiz_items
+
+# Main app
+def main():
+    load_css()
+    
+    # App title
+    st.markdown('<div class="title-box"><h1>🧠 Text-to-Quiz Generator</h1></div>', unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([2, 1])
+    
+    with col1:
+        st.markdown("### Enter a passage to generate quiz questions")
+        passage = st.text_area(
+            "Paste your text here:", 
+            height=200,
+            placeholder="Enter a paragraph or article here to generate quiz questions..."
+        )
+    
+    with col2:
+        st.markdown("### Settings")
+        num_questions = st.slider("Number of questions to generate", 3, 10, 5)
+        st.markdown("---")
+        st.markdown("""
+        **Tips for best results:**
+        - Use clear, factual content
+        - Include specific details
+        - Text length: 100-500 words works best
+        - Educational content works better than narrative
+        """)
+    
+    # Generate Quiz button
+    if st.button("🧠 Generate Quiz"):
+        if passage and len(passage) > 50:
+            # Loading the model (with the cached resource)
+            with st.spinner("Loading AI model..."):
+                qg_pipeline = load_model()
+            
+            if qg_pipeline:
+                # Generate questions
+                with st.spinner("Generating questions..."):
+                    # Add a small delay for UX
+                    time.sleep(1)
+                    questions_answers = generate_questions(qg_pipeline, passage, num_questions)
+                
+                if questions_answers:
+                    # Create quiz
+                    quiz_items = create_quiz(questions_answers)
+                    
+                    if quiz_items:
+                        # Store in session state
+                        st.session_state.quiz_items = quiz_items
+                        st.session_state.user_answers = {}
+                        st.session_state.quiz_submitted = False
+                        st.session_state.show_explanations = False
+                        st.experimental_rerun()
+                    else:
+                        st.error("Couldn't create valid quiz questions. Please try a different text or add more content.")
+                else:
+                    st.error("Failed to generate questions. Please try a different passage.")
+            else:
+                st.error("Failed to load the question generation model. Please try again.")
+        else:
+            st.warning("Please enter a longer passage (at least 50 characters).")
+    
+    # Display quiz if available in session state
+    if "quiz_items" in st.session_state and st.session_state.quiz_items:
+        st.markdown("---")
+        st.markdown("## Your Quiz")
+        
+        quiz_items = st.session_state.quiz_items
+        
+        # Create a form for the quiz
+        with st.form("quiz_form"):
+            for i, item in enumerate(quiz_items):
+                st.markdown(f'<div class="question-box"><h3>Question {i+1}</h3><p>{item["question"]}</p></div>', unsafe_allow_html=True)
+                
+                key = f"question_{item['id']}"
+                st.session_state.user_answers[key] = st.radio(
+                    "Select your answer:",
+                    options=item["options"],
+                    key=key
+                )
+            
+            submit_button = st.form_submit_button("Submit Answers")
+            
+            if submit_button:
+                st.session_state.quiz_submitted = True
         
-        # Submit button
-        if st.button("Submit Answers"):
+        # Show results if quiz was submitted
+        if st.session_state.quiz_submitted:
             score = 0
-            for i, question in enumerate(questions):
-                user_answer = st.session_state["user_answers"][question]
-                correct_answer = answers[i]
-                if user_answer == correct_answer:
-                    st.success(f"**Question {i+1}:** Correct! The answer is '{correct_answer}'.")
+            
+            st.markdown("## Quiz Results")
+            
+            for i, item in enumerate(quiz_items):
+                key = f"question_{item['id']}"
+                user_answer = st.session_state.user_answers[key]
+                correct = user_answer == item["correct_answer"]
+                
+                if correct:
                     score += 1
+                    st.markdown(f'<div class="feedback" style="background-color: #d4edda; border-left: 5px solid #28a745;"><h4>Question {i+1}: Correct! ✅</h4><p><strong>Your answer:</strong> {user_answer}</p></div>', unsafe_allow_html=True)
                 else:
-                    st.error(f"**Question {i+1}:** Incorrect. The correct answer is '{correct_answer}', not '{user_answer}'.")
-            st.markdown(f"### Your Score: {score}/{len(questions)}")
+                    st.markdown(f'<div class="feedback" style="background-color: #f8d7da; border-left: 5px solid #dc3545;"><h4>Question {i+1}: Incorrect ❌</h4><p><strong>Your answer:</strong> {user_answer}<br><strong>Correct answer:</strong> {item["correct_answer"]}</p></div>', unsafe_allow_html=True)
+            
+            # Show score
+            percentage = (score / len(quiz_items)) * 100
+            
+            if percentage >= 80:
+                color = "#28a745"  # Green
+                message = "Excellent! 🏆"
+            elif percentage >= 60:
+                color = "#17a2b8"  # Blue
+                message = "Good job! 👍"
+            else:
+                color = "#ffc107"  # Yellow
+                message = "Keep practicing! 📚"
+                
+            st.markdown(f'<div class="score-box" style="background-color: {color}15; border-left: 5px solid {color};">{message}<br>Your Score: {score}/{len(quiz_items)} ({percentage:.1f}%)</div>', unsafe_allow_html=True)
+            
+            # Restart button
+            if st.button("Generate Another Quiz"):
+                # Clear session state and rerun
+                for key in ["quiz_items", "user_answers", "quiz_submitted", "show_explanations"]:
+                    if key in st.session_state:
+                        del st.session_state[key]
+                st.experimental_rerun()
+
+if __name__ == "__main__":
+    main()