Update app.py

app.py

@@ -1,99 +1,46 @@
 import streamlit as st
-from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForQuestionAnswering
-import torch
+from transformers import pipeline
 import random
 
-# Cache the model loading to speed up the app
-@st.cache(allow_output_mutation=True)
-def load_models():
-    # Load NER pipeline
-    ner = pipeline("ner", model="dbmdz/bert-large-cased-finetuned-conll03-english", tokenizer="dbmdz/bert-large-cased-finetuned-conll03-english")
-    # Load question generation model
-    qg_tokenizer = AutoTokenizer.from_pretrained("valhalla/t5-small-e2e-qg")
-    qg_model = AutoModelForSeq2SeqLM.from_pretrained("valhalla/t5-small-e2e-qg")
-    # Load question answering model
-    qa_tokenizer = AutoTokenizer.from_pretrained("deepset/roberta-base-squad2")
-    qa_model = AutoModelForQuestionAnswering.from_pretrained("deepset/roberta-base-squad2")
-    return ner, qg_tokenizer, qg_model, qa_tokenizer, qa_model
+st.set_page_config(page_title="Text-to-Quiz Generator", layout="centered")
 
-ner, qg_tokenizer, qg_model, qa_tokenizer, qa_model = load_models()
+st.title("📘 Text-to-Quiz Generator")
+st.write("Enter a passage below and let AI generate a quiz for you!")
 
-def generate_questions(text, num_questions=5):
-    # Generate questions using the question generation model
-    input_text = f"generate questions: {text}"
-    input_ids = qg_tokenizer.encode(input_text, return_tensors="pt")
-    outputs = qg_model.generate(input_ids, max_length=256, num_return_sequences=num_questions)
-    questions = [qg_tokenizer.decode(output, skip_special_tokens=True) for output in outputs]
-    return questions
+# Text input
+text_input = st.text_area("Paste your text here:", height=200)
 
-def get_answer(question, context):
-    # Get the answer using the question answering model
-    inputs = qa_tokenizer.encode_plus(question, context, return_tensors="pt")
-    with torch.no_grad():
-        outputs = qa_model(**inputs)
-    answer_start = torch.argmax(outputs.start_logits)
-    answer_end = torch.argmax(outputs.end_logits) + 1
-    answer = qa_tokenizer.convert_tokens_to_string(qa_tokenizer.convert_ids_to_tokens(inputs["input_ids"][0][answer_start:answer_end]))
-    return answer
+# Load model pipeline from Hugging Face
+@st.cache_resource
+def load_pipeline():
+    return pipeline("e2e-qg")  # End-to-End Question Generation (QG)
 
-def get_entities(text):
-    # Extract entities using NER
-    entities = ner(text)
-    entity_dict = {}
-    for entity in entities:
-        word = entity['word']
-        entity_type = entity['entity']
-        if entity_type not in entity_dict:
-            entity_dict[entity_type] = set()
-        entity_dict[entity_type].add(word)
-    return entity_dict
+qg_pipeline = load_pipeline()
 
-def generate_distractors(answer, entity_dict, answer_type, num_distractors=3):
-    if answer_type in entity_dict and len(entity_dict[answer_type]) > 1:
-        distractors = list(entity_dict[answer_type] - {answer})
-        if len(distractors) >= num_distractors:
-            return random.sample(distractors, num_distractors)
-    # Fallback: select random words from the text
-    words = text.split()
-    distractors = random.sample(words, min(len(words), num_distractors))
-    return [d for d in distractors if d != answer][:num_distractors]
+if st.button("Generate Quiz") and text_input:
+    st.subheader("📝 Generated Quiz")
 
-# Streamlit app
-st.title("Text-to-Quiz Generator")
+    try:
+        questions = qg_pipeline(text_input)
+
+        for i, item in enumerate(questions):
+            question = item['question']
+            correct_answer = item['answer']
+            # Generate fake choices
+            choices = [correct_answer] + [f"Option {chr(66 + j)}" for j in range(3)]
+            random.shuffle(choices)
+
+            st.markdown(f"**Q{i+1}. {question}**")
+            user_answer = st.radio("Choose an answer:", choices, key=i)
+
+            if user_answer == correct_answer:
+                st.success("✅ Correct!")
+            else:
+                st.error(f"❌ Incorrect. Correct answer: **{correct_answer}**")
+            st.markdown("---")
+
+    except Exception as e:
+        st.error(f"Something went wrong: {e}")
+else:
+    st.info("👆 Paste some text and click 'Generate Quiz'")
 
-text = st.text_area("Enter the text to generate a quiz from:", height=200)
-if st.button("Generate Quiz"):
-    if text:
-        # Extract entities
-        entity_dict = get_entities(text)
-        # Generate questions
-        questions = generate_questions(text)
-        quiz = []
-        for question in questions:
-            answer = get_answer(question, text)
-            # Determine answer type
-            answer_type = None
-            for ent_type, ents in entity_dict.items():
-                if answer in ents:
-                    answer_type = ent_type
-                    break
-            if answer_type:
-                distractors = generate_distractors(answer, entity_dict, answer_type)
-                options = [answer] + distractors
-                random.shuffle(options)
-                quiz.append({"question": question, "options": options, "answer": answer})
-        
-        if quiz:
-            st.subheader("Generated Quiz")
-            for i, q in enumerate(quiz, 1):
-                st.write(f"**Question {i}:** {q['question']}")
-                user_answer = st.radio("Choose an answer:", q['options'], key=f"q{i}")
-                if st.button("Check Answer", key=f"check{i}"):
-                    if user_answer == q['answer']:
-                        st.success("Correct!")
-                    else:
-                        st.error(f"Incorrect. The correct answer is: {q['answer']}")
-        else:
-            st.warning("Could not generate enough questions. Try with a different text.")
-    else:
-        st.warning("Please enter some text to generate the quiz.")