Update app.py

app.py

@@ -3,9 +3,9 @@ import gradio as gr
 from transformers import T5ForConditionalGeneration, T5Tokenizer, pipeline
 
 # -----------------------------
-# 1. Load a Better Model & Slow Tokenizer
-#    Using the "valhalla/t5-base-qg-hl" model (a step up from the small version)
-#    and disabling the fast tokenizer.
+# 1. Load the Models
+#    a) For question generation (using T5-base QG model with slow tokenizer)
+#    b) For passage generation (using GPT-2 for dynamic passage creation)
 # -----------------------------
 tokenizer = T5Tokenizer.from_pretrained("valhalla/t5-base-qg-hl", use_fast=False)
 model = T5ForConditionalGeneration.from_pretrained("valhalla/t5-base-qg-hl")
@@ -15,26 +15,54 @@ qg_pipeline = pipeline(
     tokenizer=tokenizer
 )
 
+# Pipeline for text generation (passage generation)
+tg_pipeline = pipeline(
+    "text-generation",
+    model="gpt2",
+    max_length=100,
+    do_sample=True
+)
+
 # -----------------------------
-# 2. Define Passages by Difficulty
+# 2. Dynamically Generate a Passage Based on Difficulty
+#    The generated passage should include <hl> tokens to mark the key fact (answer).
 # -----------------------------
-passages = {
-    "easy": [
-        "The capital of <hl>France<hl> is Paris.",
-        "A cat is a small <hl>domesticated<hl> feline.",
-        "<hl>Water<hl> is essential for all known forms of life.",
-    ],
-    "medium": [
-        "Albert Einstein was born in <hl>Germany<hl> in 1879.",
-        "The process of <hl>photosynthesis<hl> occurs in plants and algae.",
-        "In 1492, <hl>Christopher Columbus<hl> sailed across the Atlantic Ocean.",
-    ],
-    "hard": [
-        "The <hl>Renaissance<hl> was a fervent period of European cultural, artistic, political, and economic rebirth.",
-        "<hl>Quantum mechanics<hl> is a fundamental theory in physics describing nature at the smallest scales.",
-        "The <hl>Constitution<hl> of the United States was ratified in 1788, establishing the framework of government.",
-    ],
-}
+def generate_passage(difficulty):
+    if difficulty == "easy":
+        prompt = (
+            "Write a simple, short informative passage about a common fact. "
+            "Enclose one key fact with <hl> and <hl> to highlight it. "
+            "Keep it easy to understand."
+        )
+    elif difficulty == "medium":
+        prompt = (
+            "Write a medium-difficulty informative passage on a historical or scientific topic. "
+            "Enclose one key fact with <hl> and <hl> to highlight it. "
+            "The passage should be moderately challenging."
+        )
+    elif difficulty == "hard":
+        prompt = (
+            "Write a challenging, detailed informative passage on a complex topic. "
+            "Enclose one key fact with <hl> and <hl> to highlight it. "
+            "The passage should be thought-provoking and detailed."
+        )
+    else:
+        prompt = (
+            "Write an informative passage and enclose one key fact with <hl> and <hl> to highlight it."
+        )
+    
+    # Generate a passage using the text-generation pipeline.
+    generated = tg_pipeline(prompt, num_return_sequences=1)[0]["generated_text"]
+    
+    # If the generated passage does not include the <hl> tokens, insert them manually.
+    if "<hl>" not in generated:
+        words = generated.split()
+        if len(words) > 10:
+            insert_pos = len(words) // 2
+            words.insert(insert_pos, "<hl>")
+            words.insert(insert_pos + 2, "<hl>")
+            generated = " ".join(words)
+    return generated
 
 # -----------------------------
 # 3. Session State Initialization
@@ -45,6 +73,7 @@ def init_state():
         "score": 0,
         "question": "",
         "answer": "",
+        "passage": ""
     }
 
 # -----------------------------
@@ -53,41 +82,38 @@ def init_state():
 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:
         state["difficulty"] = diff_order[idx + 1]
-        state["score"] = 0  # Reset score upon difficulty change
-        return "Difficulty increased to: " + state["difficulty"]
+        state["score"] = 0  # reset score when leveling up
+        return "Level up! Difficulty increased to: " + state["difficulty"]
     elif state["score"] <= -2 and idx > 0:
         state["difficulty"] = diff_order[idx - 1]
-        state["score"] = 0  # Reset score upon difficulty change
-        return "Difficulty decreased to: " + state["difficulty"]
+        state["score"] = 0  # reset score when leveling down
+        return "Don't worry! Difficulty decreased to: " + state["difficulty"]
     else:
-        return f"Difficulty remains: {state['difficulty']} (Score: {state['score']})"
+        return f"Keep going! Current level: {state['difficulty']} (Score: {state['score']})"
 
 # -----------------------------
-# 5. Generate a Question from a Passage
+# 5. Generate a Question from a Dynamically Generated Passage
 # -----------------------------
 def generate_question(state):
-    # Select a random passage from the current difficulty level
-    passage_list = passages[state["difficulty"]]
-    chosen_passage = random.choice(passage_list)
-
-    # Extract the answer from text between <hl> tags.
-    parts = chosen_passage.split("<hl>")
-    if len(parts) == 3:
+    # Dynamically generate a passage based on current difficulty.
+    passage = generate_passage(state["difficulty"])
+    state["passage"] = passage
+    
+    # Extract the answer from the passage (text between <hl> tokens).
+    parts = passage.split("<hl>")
+    if len(parts) >= 3:
         answer = parts[1].strip()
     else:
         answer = "N/A"
-
-    # Generate a question using the QG pipeline.
-    result = qg_pipeline(chosen_passage, max_length=64)
+    
+    # Use the question generation pipeline on the generated passage.
+    result = qg_pipeline(passage, max_length=64)
     question_text = result[0]["generated_text"]
-
-    # Update the state with the generated question and correct answer.
+    
     state["question"] = question_text
     state["answer"] = answer
-
     return question_text
 
 # -----------------------------
@@ -96,85 +122,80 @@ def generate_question(state):
 def check_answer(state, user_answer):
     correct_answer = state["answer"].lower().strip()
     user_answer_clean = user_answer.lower().strip()
-
     if user_answer_clean == correct_answer:
         state["score"] += 1
-        result_text = "Correct!"
+        result_text = "Correct! Nice work!"
     else:
         state["score"] -= 1
-        result_text = f"Incorrect! The correct answer was: {state['answer']}"
-
-    # Adjust the difficulty based on updated score.
+        result_text = f"Oops! The correct answer was: {state['answer']}"
     difficulty_update = adjust_difficulty(state)
     return result_text + "\n" + difficulty_update
 
 # -----------------------------
-# 7. Build the Gradio Interface with Custom CSS for a More Colorful UI
+# 7. Build the Gradio Interface with a Hip, Rainbow Theme
 # -----------------------------
 custom_css = """
 body {
-    background: linear-gradient(135deg, #e0c3fc, #8ec5fc);
-    font-family: 'Helvetica', sans-serif;
+    background: linear-gradient(135deg, #ff0000, #ff7f00, #ffff00, #00ff00, #0000ff, #4b0082, #8f00ff);
+    font-family: 'Poppins', sans-serif;
 }
 .gradio-container {
-    background-color: #ffffff;
-    border-radius: 15px;
-    padding: 20px;
-    box-shadow: 0 4px 12px rgba(0,0,0,0.15);
+    background-color: rgba(255, 255, 255, 0.95);
+    border-radius: 20px;
+    padding: 30px;
+    box-shadow: 0 8px 20px rgba(0, 0, 0, 0.3);
 }
 .gradio-markdown h1 {
-    color: #4b0082;
+    color: #ff1493;
+    text-shadow: 2px 2px 4px #000000;
 }
 .gradio-markdown p, .gradio-markdown li {
-    font-size: 16px;
+    font-size: 18px;
     color: #333333;
 }
 .gradio-button, .gradio-textbox {
     font-size: 16px;
+    border-radius: 10px;
 }
 """
 
 with gr.Blocks(css=custom_css) as demo:
-    # Persistent state for the session.
     state = gr.State(init_state())
-
-    gr.Markdown("# Adaptive Language Tutor")
+    
+    gr.Markdown("# Lingo Quest: The Ultimate Word Adventure")
     gr.Markdown(
-        "This demo uses a T5-based model to generate questions from a passage. "
-        "The difficulty will automatically adjust based on your performance."
+        "Welcome to **Lingo Quest**! Embark on a vibrant journey where every challenge is a step toward mastering language. "
+        "Answer questions correctly to level up and unlock new challenges. Get ready to flex your word skills and become a language legend!"
     )
-
-    # Display current difficulty and score.
-    difficulty_label = gr.Markdown("**Difficulty**: (will be updated)")
-
+    
+    # Display current level and score.
+    difficulty_label = gr.Markdown("**Current Level**: (will be updated)")
+    
     with gr.Row():
-        generate_button = gr.Button("Generate Question")
-        question_output = gr.Textbox(label="Question", interactive=False)
-
+        generate_button = gr.Button("Start Challenge!")
+        question_output = gr.Textbox(label="Challenge Question", interactive=False)
+    
     user_answer = gr.Textbox(label="Your Answer")
     submit_button = gr.Button("Submit Answer")
     result_output = gr.Textbox(label="Result", interactive=False)
-
+    
     def update_difficulty_label(state):
-        return f"**Difficulty**: {state['difficulty']} (Score: {state['score']})"
-
-    # Update the difficulty label when the interface loads.
+        return f"**Current Level**: {state['difficulty']} (Score: {state['score']})"
+    
     demo.load(fn=update_difficulty_label, inputs=state, outputs=difficulty_label)
-
-    # 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])
-
-    # 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])
-
+    
 demo.launch()