Update app.py

app.py

@@ -1,24 +1,21 @@
 import random
 import gradio as gr
-import torch
-from transformers import pipeline
+from transformers import T5ForConditionalGeneration, T5Tokenizer, pipeline
 
 # -----------------------------
-# 1. Load the Question Generation Pipeline
+# 1. Load the Model & Slow Tokenizer
+#    We explicitly disable the fast tokenizer by setting use_fast=False.
 # -----------------------------
-# Model reference: https://huggingface.co/valhalla/t5-small-qg-hl
+tokenizer = T5Tokenizer.from_pretrained("valhalla/t5-small-qg-hl", use_fast=False)
+model = T5ForConditionalGeneration.from_pretrained("valhalla/t5-small-qg-hl")
 qg_pipeline = pipeline(
     "text2text-generation",
-    model="valhalla/t5-small-qg-hl",
-    tokenizer="valhalla/t5-small-qg-hl",
-    use_fast=False  # disable the fast tokenizer to avoid tiktoken conversion issues
+    model=model,
+    tokenizer=tokenizer
 )
 
 # -----------------------------
-# 2. Prepare Passages (with <hl> tags)
-#    We'll store a few short passages at different difficulty levels.
-#    The <hl> tags highlight the answer, which helps the QG pipeline
-#    know which part to form a question about.
+# 2. Define Passages by Difficulty
 # -----------------------------
 passages = {
     "easy": [
@@ -39,12 +36,7 @@ passages = {
 }
 
 # -----------------------------
-# 3. Session State Setup
-#    We'll track:
-#      - difficulty: "easy", "medium", or "hard"
-#      - score: integer, increments when correct, decrements when wrong
-#      - question: the last generated question text
-#      - answer: the correct answer for the last question
+# 3. Session State Initialization
 # -----------------------------
 def init_state():
     return {
@@ -55,62 +47,50 @@ def init_state():
     }
 
 # -----------------------------
-# 4. Difficulty Adjustment Rules
-#    - If score >= +2, increase difficulty (up to "hard").
-#    - If score <= -2, decrease difficulty (down to "easy").
+# 4. Adjust Difficulty Based on Score
 # -----------------------------
 def adjust_difficulty(state):
     diff_order = ["easy", "medium", "hard"]
     idx = diff_order.index(state["difficulty"])
 
     if state["score"] >= 2 and idx < len(diff_order) - 1:
-        # Increase difficulty
         state["difficulty"] = diff_order[idx + 1]
-        state["score"] = 0  # reset score so we can re-check for next threshold
+        state["score"] = 0  # Reset score upon difficulty change
         return "Difficulty increased to: " + state["difficulty"]
     elif state["score"] <= -2 and idx > 0:
-        # Decrease difficulty
         state["difficulty"] = diff_order[idx - 1]
-        state["score"] = 0  # reset score
+        state["score"] = 0  # Reset score upon difficulty change
         return "Difficulty decreased to: " + state["difficulty"]
     else:
-        return f"Difficulty remains: {state['difficulty']}"
+        return f"Difficulty remains: {state['difficulty']} (Score: {state['score']})"
 
 # -----------------------------
 # 5. Generate a Question from a Passage
-#    We'll pick a random passage from the current difficulty level,
-#    pass it to the QG pipeline, and store the result in the state.
 # -----------------------------
 def generate_question(state):
-    # Pick a random passage from the current difficulty
+    # Select a random passage from the current difficulty level
     passage_list = passages[state["difficulty"]]
     chosen_passage = random.choice(passage_list)
 
-    # The correct answer is the text between <hl> tags
-    # We'll extract it to compare with user input later
-    # Example: "The capital of <hl>France<hl> is Paris." -> answer = "France"
+    # Extract the answer from text between <hl> tags.
     parts = chosen_passage.split("<hl>")
     if len(parts) == 3:
-        # e.g., ["The capital of ", "France", " is Paris."]
         answer = parts[1].strip()
     else:
         answer = "N/A"
 
-    # The QG pipeline expects the passage with <hl> tokens
-    # We'll feed that directly
+    # Generate a question using the QG pipeline.
     result = qg_pipeline(chosen_passage, max_length=64)
     question_text = result[0]["generated_text"]
 
-    # Update state
+    # Update the state with the generated question and correct answer.
     state["question"] = question_text
     state["answer"] = answer
 
-    # Return question to display
     return question_text
 
 # -----------------------------
 # 6. Check the User's Answer
-#    We do a simple string comparison (case-insensitive).
 # -----------------------------
 def check_answer(state, user_answer):
     correct_answer = state["answer"].lower().strip()
@@ -118,77 +98,59 @@ def check_answer(state, user_answer):
 
     if user_answer_clean == correct_answer:
         state["score"] += 1
-        result = "Correct!"
+        result_text = "Correct!"
     else:
         state["score"] -= 1
-        result = f"Incorrect! The correct answer was: {state['answer']}"
+        result_text = f"Incorrect! The correct answer was: {state['answer']}"
 
-    # Possibly adjust difficulty
+    # Adjust the difficulty based on updated score.
     difficulty_update = adjust_difficulty(state)
-    return result + "\n" + difficulty_update
+    return result_text + "\n" + difficulty_update
 
 # -----------------------------
-# 7. Gradio Interface
-#    We'll build a small flow:
-#    - Show current difficulty
-#    - "Generate Question" button
-#    - Show question
-#    - Text input for answer
-#    - "Submit Answer" button
-#    - Show result
+# 7. Build the Gradio Interface
 # -----------------------------
 with gr.Blocks() as demo:
-    # We need a state object that persists across user interactions
+    # Persistent state for the session.
     state = gr.State(init_state())
 
     gr.Markdown("# Adaptive Language Tutor")
-    gr.Markdown("This demo uses a T5-based model to generate questions. "
-                "Difficulty automatically adjusts based on your answers.")
+    gr.Markdown(
+        "This demo uses a T5-based model to generate questions from a passage. "
+        "Difficulty will automatically adjust based on your performance."
+    )
 
-    # Display current difficulty
+    # Display current difficulty and score.
     difficulty_label = gr.Markdown("**Difficulty**: (will be updated)")
 
-    # Button + output area for generating question
     with gr.Row():
         generate_button = gr.Button("Generate Question")
         question_output = gr.Textbox(label="Question", interactive=False)
 
-    # Text input + button to submit answer
     user_answer = gr.Textbox(label="Your Answer")
     submit_button = gr.Button("Submit Answer")
-
-    # Result output
     result_output = gr.Textbox(label="Result", interactive=False)
 
-    # -- Define event functions --
     def update_difficulty_label(state):
         return f"**Difficulty**: {state['difficulty']} (Score: {state['score']})"
 
-    # 1) On load, update difficulty label
+    # Update the difficulty label when the interface loads.
     demo.load(fn=update_difficulty_label, inputs=state, outputs=difficulty_label)
 
-    # 2) Generate question
+    # Event: Generate a new question.
     def on_generate_question(state):
         question = generate_question(state)
         difficulty_text = update_difficulty_label(state)
         return question, difficulty_text
 
-    generate_button.click(
-        fn=on_generate_question,
-        inputs=state,
-        outputs=[question_output, difficulty_label]
-    )
+    generate_button.click(fn=on_generate_question, inputs=state, outputs=[question_output, difficulty_label])
 
-    # 3) Submit answer
+    # Event: Submit the answer and check correctness.
     def on_submit_answer(user_answer, state):
         feedback = check_answer(state, user_answer)
         difficulty_text = update_difficulty_label(state)
         return feedback, difficulty_text
 
-    submit_button.click(
-        fn=on_submit_answer,
-        inputs=[user_answer, state],
-        outputs=[result_output, difficulty_label]
-    )
+    submit_button.click(fn=on_submit_answer, inputs=[user_answer, state], outputs=[result_output, difficulty_label])
 
 demo.launch()