Create app.py

app.py

@@ -0,0 +1,99 @@
+import streamlit as st
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM, AutoModelForQuestionAnswering
+import torch
+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
+
+ner, qg_tokenizer, qg_model, qa_tokenizer, qa_model = load_models()
+
+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
+
+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
+
+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
+
+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]
+
+# Streamlit app
+st.title("Text-to-Quiz Generator")
+
+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.")