Update app.py

app.py

@@ -1,340 +1,157 @@
-# app.py
-# Gradio web app for Hugging Face Spaces: Bloom's Taxonomy Classifier, Generator, and Rewriter
-# No external model downloads; purely rule-based and reproducible.
-
-import re
-import random
-from typing import Dict, List, Tuple
-
 import gradio as gr
-
-BLOOMS_LEVELS = [
-    "Remember",
-    "Understand",
-    "Apply",
-    "Analyze",
-    "Evaluate",
-    "Create",
-]
-
-# Seed for reproducibility across runs
-random.seed(42)
-
-# ---- Heuristic resources -----------------------------------------------------
-
-VERBS = {
-    "Remember": [
-        "define", "list", "name", "recall", "state", "identify", "label",
-        "match", "enumerate", "select", "recognize", "who", "what", "when",
-    ],
-    "Understand": [
-        "explain", "describe", "summarize", "paraphrase", "interpret", "classify",
-        "outline", "illustrate", "give an example", "why", "how does", "compare (basic)",
-    ],
-    "Apply": [
-        "apply", "use", "compute", "calculate", "solve", "demonstrate", "implement",
-        "show how", "execute", "perform",
-    ],
-    "Analyze": [
-        "analyze", "compare", "contrast", "differentiate", "examine", "categorize",
-        "diagram", "break down", "distinguish", "investigate", "what is the relationship",
-        "cause", "effect", "why (multi-part)",
-    ],
-    "Evaluate": [
-        "evaluate", "argue", "assess", "justify", "critique", "defend", "appraise",
-        "prioritize", "recommend", "debate", "which is better", "to what extent",
-    ],
-    "Create": [
-        "create", "design", "develop", "compose", "formulate", "invent", "propose",
-        "construct", "devise", "generate", "plan", "produce", "draft",
-    ],
+from transformers import pipeline, AutoTokenizer, AutoModelForSeq2SeqLM
+
+TITLE = "Bloom’s Taxonomy Helper (Classify + Generate + Rewrite)"
+
+# ------------------ Bloom labels ------------------
+LABELS = ["Remember", "Understand", "Apply", "Analyze", "Evaluate", "Create"]
+
+# ------------------ Generation templates by Bloom ------------------
+PROMPT_TEMPLATES = {
+    "Remember": (
+        "Write {n} distinct factual recall questions for college students.\n"
+        "Topic: {topic}\n"
+        "Cognitive focus: Remember (recognize/recall facts and terms).\n"
+        "Style: Use 'What', 'When', 'Define', or 'List'.\n"
+        "Do not include answers. Number each on its own line."
+    ),
+    "Understand": (
+        "Write {n} distinct comprehension questions for college students.\n"
+        "Topic: {topic}\n"
+        "Cognitive focus: Understand (explain, summarize, interpret).\n"
+        "Style: Use 'Explain', 'Summarize', 'Describe', or 'Give an example of'.\n"
+        "Do not include answers. Number each on its own line."
+    ),
+    "Apply": (
+        "Write {n} distinct application questions for college students.\n"
+        "Topic: {topic}\n"
+        "Cognitive focus: Apply (use procedures, compute, demonstrate use).\n"
+        "Style: Ask students to calculate, implement, or solve with concrete data.\n"
+        "Avoid 'define' or 'explain' prompts. Do not include answers. Number each on its own line."
+    ),
+    "Analyze": (
+        "Write {n} distinct analysis questions for college students.\n"
+        "Topic: {topic}\n"
+        "Cognitive focus: Analyze (compare/contrast, break down relationships, cause–effect).\n"
+        "Style: Use 'Compare', 'Differentiate', 'Explain why', 'Break down', or 'Trace'.\n"
+        "Do not include answers. Number each on its own line."
+    ),
+    "Evaluate": (
+        "Write {n} distinct evaluation questions for college students.\n"
+        "Topic: {topic}\n"
+        "Cognitive focus: Evaluate (judge, critique, justify with criteria and evidence).\n"
+        "Style: Use 'Argue', 'Defend', 'Critique', 'Which is better and why', or 'Assess'.\n"
+        "Do not include answers. Number each on its own line."
+    ),
+    "Create": (
+        "Write {n} distinct creation/synthesis tasks for college students.\n"
+        "Topic: {topic}\n"
+        "Cognitive focus: Create (design, plan, invent, propose, produce a novel artifact).\n"
+        "Style: Use 'Design', 'Propose', 'Develop', 'Compose', or 'Build'. Include realistic constraints.\n"
+        "Do not include answers. Number each on its own line."
+    ),
 }
 
-# Templates to generate or rewrite questions by Bloom level.
-TEMPLATES = {
-    "Remember": [
-        "Define {topic}.",
-        "List three key facts about {topic}.",
-        "Identify the primary purpose of {topic}.",
-        "State the meaning of {topic} in one sentence.",
-        "Name two examples related to {topic}.",
-    ],
-    "Understand": [
-        "Explain {topic} in your own words.",
-        "Describe how {topic} works to a beginner.",
-        "Summarize the main idea behind {topic}.",
-        "Classify {topic} into an appropriate category and explain why.",
-        "Illustrate {topic} with a simple, concrete example.",
-    ],
-    "Apply": [
-        "Apply {topic} to solve a real-world problem; show the steps.",
-        "Use {topic} to compute the result for this scenario: [add numbers/conditions].",
-        "Demonstrate {topic} on a new example you devise.",
-        "Solve a practical case where {topic} is required; justify each step.",
-        "Implement a basic procedure using {topic} and report the outcome.",
-    ],
-    "Analyze": [
-        "Compare and contrast {topic} with a closely related concept; highlight key differences.",
-        "Analyze the components of {topic} and explain how they interact.",
-        "Examine the causes and effects involved in {topic}.",
-        "Categorize elements of {topic} into meaningful groups and justify your grouping.",
-        "Break down {topic} into sub-problems and explain each part.",
-    ],
-    "Evaluate": [
-        "Evaluate the strengths and weaknesses of {topic}; provide criteria and evidence.",
-        "Argue for or against the use of {topic} in a specific context.",
-        "Assess the effectiveness of {topic} using clear metrics.",
-        "Justify a recommendation regarding {topic}, noting trade-offs.",
-        "Critique a common approach to {topic} and suggest improvements.",
-    ],
-    "Create": [
-        "Design a novel solution that uses {topic}; outline the key steps.",
-        "Develop a project plan that incorporates {topic} with milestones and deliverables.",
-        "Propose an original framework that extends {topic}.",
-        "Formulate a research question involving {topic} and sketch a method to investigate it.",
-        "Compose a scenario or case study that requires {topic} to resolve.",
-    ],
-}
-
-# Light penalties/bonuses to help disambiguate borderline levels
-STRUCTURE_HINTS = {
-    "Remember": ["define", "list", "identify", "name", "state"],
-    "Understand": ["explain", "describe", "summarize", "illustrate", "classify"],
-    "Apply": ["solve", "compute", "calculate", "apply", "use", "demonstrate"],
-    "Analyze": ["compare", "contrast", "analyze", "why", "cause", "effect", "break down"],
-    "Evaluate": ["evaluate", "assess", "justify", "which is better", "argue", "critique"],
-    "Create": ["design", "develop", "propose", "create", "formulate", "invent", "plan"],
-}
-
-def normalize(text: str) -> str:
-    return re.sub(r"\s+", " ", text.strip().lower())
-
-def score_levels(question: str) -> Dict[str, float]:
-    """Keyword scoring with mild normalization and overlap handling."""
-    q = normalize(question)
-    scores = {lvl: 0.0 for lvl in BLOOMS_LEVELS}
-    # Count verb hits (phrase -> weight)
-    for lvl, words in VERBS.items():
-        for w in words:
-            # phrase-aware search; word boundary for single words
-            if " " in w:
-                if w in q:
-                    scores[lvl] += 1.5
-            else:
-                # word-boundary with stemming-ish match for simple endings
-                if re.search(rf"\b{re.escape(w)}(e|ed|ing|s)?\b", q):
-                    scores[lvl] += 1.0
-
-    # Structural hints get a small bonus
-    for lvl, hints in STRUCTURE_HINTS.items():
-        for h in hints:
-            if h in q:
-                scores[lvl] += 0.25
-
-    # Heuristic nudges
-    # Longer, multi-part questions tend to be higher-order
-    tokens = len(q.split())
-    if tokens >= 25:
-        scores["Analyze"] += 0.3
-        scores["Evaluate"] += 0.3
-        scores["Create"] += 0.3
-
-    # Presence of "design", "propose", etc. strongly suggests Create
-    if any(k in q for k in ["design", "develop", "propose", "invent", "formulate", "plan"]):
-        scores["Create"] += 1.2
-
-    # Presence of justification language boosts Evaluate
-    if any(k in q for k in ["justify", "assess", "evaluate", "argue", "critique", "recommend"]):
-        scores["Evaluate"] += 1.2
-
-    # "compare/contrast" and "why" boost Analyze
-    if any(k in q for k in ["compare", "contrast", "analyze", "why", "cause", "effect"]):
-        scores["Analyze"] += 0.8
-
-    # Basic who/what/when/where—if no other signal—leans Remember/Understand
-    if re.search(r"\b(who|what|when|where)\b", q):
-        scores["Remember"] += 0.4
-        scores["Understand"] += 0.2
-
-    return scores
-
-def classify_question(question: str) -> Tuple[str, Dict[str, float], str]:
-    if not question or not question.strip():
-        return "", {}, "Please enter a question to classify."
-    scores = score_levels(question)
-    # pick max; tie-break by deeper levels if scores equal (to avoid under-classification)
-    best_level = max(BLOOMS_LEVELS, key=lambda lvl: (scores[lvl], BLOOMS_LEVELS.index(lvl)))
-    # Rationale: top 2 contributors
-    top = sorted(scores.items(), key=lambda x: x[1], reverse=True)[:2]
-    rationale = "Top signals → " + ", ".join(f"{k}: {v:.2f}" for k, v in top)
-    return best_level, scores, rationale
-
-def extract_topic_from_question(q: str) -> str:
-    """Very lightweight topic guesser for rewrite; falls back to original content."""
-    text = normalize(q).rstrip("?.")
-
-    # Prefer phrases after 'about/on/of'
-    m = re.search(r"\b(?:about|on|of)\s+(.+)", text)
-    if m:
-        topic = m.group(1)
-        # trim trailing question cues
-        topic = re.sub(r"\b(why|how|what|when|where|who)\b.*$", "", topic).strip()
-        if topic:
-            return topic
-
-    # Remove leading command verbs
-    command_verbs = sum(VERBS.values(), [])
-    pattern = r"^(" + "|".join(re.escape(v) for v in sorted(set(command_verbs), key=len, reverse=True)) + r")\b"
-    text2 = re.sub(pattern, "", text).strip(",.:- ").strip()
-    if text2:
-        return text2
-
-    # Fallback: keep original question minus punctuation
-    return re.sub(r"[?.!]+$", "", q).strip()
-
-def generate_questions(topic: str, level: str, n: int) -> str:
-    topic = topic.strip()
+# ------------------ Pipelines ------------------
+# Zero-shot classifier (no training)
+clf = pipeline("zero-shot-classification", model="typeform/distilbert-base-uncased-mnli")
+
+# Higher-quality generator (CPU-friendly but better than *small*)
+GEN_MODEL = "google/flan-t5-base"
+gen_tok = AutoTokenizer.from_pretrained(GEN_MODEL)
+gen_mdl = AutoModelForSeq2SeqLM.from_pretrained(GEN_MODEL)
+gen = pipeline("text2text-generation", model=gen_mdl, tokenizer=gen_tok)
+
+# ------------------ Helpers ------------------
+def clean_numbering(text: str, n: int) -> str:
+    """Force clean 1..n numbering, each on its own line."""
+    lines = [ln.strip(" -*\t") for ln in text.splitlines() if ln.strip()]
+    # If model returned a paragraph, split by sentence end
+    if len(lines) == 1 and "1." not in lines[0]:
+        import re
+        parts = [p.strip() for p in re.split(r"(?<=[.?!])\s+", lines[0]) if p.strip()]
+        lines = parts
+    lines = [ln for ln in lines if any(c.isalpha() for c in ln)]
+    lines = lines[:max(1, n)]
+    return "\n".join(f"{i+1}. {ln.lstrip('0123456789. ').strip()}" for i, ln in enumerate(lines))
+
+# ------------------ Functions ------------------
+def classify_bloom(question: str):
+    question = (question or "").strip()
+    if not question:
+        return "", ""
+    res = clf(question, LABELS)
+    labels = res["labels"]
+    scores = [round(float(s), 3) for s in res["scores"]]
+    top = labels[0] if labels else ""
+    table = "\n".join(f"{l}: {s}" for l, s in zip(labels, scores))
+    return top, table
+
+def generate_questions(topic: str, level: str, n: int, creativity: float):
+    topic = (topic or "").strip()
     if not topic:
-        return "Please provide a topic."
-    if level not in BLOOMS_LEVELS:
-        return "Please choose a valid Bloom’s level."
-    n = max(1, min(int(n), 20))  # keep it reasonable
-    templates = TEMPLATES[level][:]
-    out: List[str] = []
-    used: set = set()
-
-    # Slight variations to avoid duplicates: add extra cues or contexts
-    extras = [
-        "",
-        " Include one concrete example.",
-        " Keep your response concise.",
-        " Explain your reasoning.",
-        " Use no more than 3 sentences.",
-        " Include assumptions you make.",
-        " Relate this to a real-world case.",
-        " Provide step-by-step reasoning.",
-    ]
-
-    attempts = 0
-    while len(out) < n and attempts < n * 10:
-        attempts += 1
-        template = random.choice(templates)
-        extra = random.choice(extras)
-        q = (template.format(topic=topic) + extra).strip()
-        if q not in used:
-            used.add(q)
-            out.append(q)
-
-    # Ensure numbering and distinctness
-    lines = [f"{i+1}. {q}" for i, q in enumerate(out)]
-    return "\n".join(lines)
-
-def rewrite_question_to_level(question: str, new_level: str) -> str:
-    question = question.strip()
+        return "Please enter a topic."
+    template = PROMPT_TEMPLATES.get(level, PROMPT_TEMPLATES["Understand"])
+    prompt = template.format(n=int(n), topic=topic)
+
+    out = gen(
+        prompt,
+        max_new_tokens=180,
+        do_sample=(creativity > 0.01),
+        temperature=max(0.01, min(1.2, creativity)),
+        top_p=0.9,
+        num_beams=1,
+    )[0]["generated_text"]
+
+    return clean_numbering(out, int(n))
+
+def rewrite_level(question: str, target_level: str):
+    question = (question or "").strip()
     if not question:
-        return "Please paste a question to rewrite."
-    if new_level not in BLOOMS_LEVELS:
-        return "Please choose a valid Bloom’s level."
-
-    topic_guess = extract_topic_from_question(question)
-    # Select a template that best preserves meaning while switching the cognitive demand
-    # Prefer more general templates for rewrite
-    candidates = TEMPLATES[new_level]
-    # avoid extremely specific ones when the source already contains constraints
-    generic_first = sorted(candidates, key=lambda s: len(s))
-    template = generic_first[0] if generic_first else "{topic}"
-
-    rewritten = template.format(topic=topic_guess)
-    # Add helpful adaptation notes for higher levels
-    if new_level in ["Analyze", "Evaluate", "Create"]:
-        # Encourage depth without changing grading rubric here
-        rewritten += " Be explicit about your reasoning."
-
-    return rewritten
-
-# ---- Gradio UI ---------------------------------------------------------------
-
-EXAMPLES = [
-    ["What is photosynthesis and when does it occur?",],
-    ["Design a simple experiment to test the effect of sunlight on plant growth.",],
-    ["Compare and contrast arrays and linked lists.",],
-    ["Justify whether encryption should be mandatory on consumer devices.",],
-]
-
-with gr.Blocks(title="Bloom's Taxonomy Helper", theme=gr.themes.Soft()) as demo:
-    gr.Markdown(
-        """
-        # Bloom’s Taxonomy Helper
-        A compact tool to **classify**, **generate**, and **rewrite** exam questions by Bloom’s level:
-        **Remember · Understand · Apply · Analyze · Evaluate · Create**
-        """
+        return "Paste a question to rewrite."
+    # Leverage the template for target level to steer rewriting
+    template = PROMPT_TEMPLATES.get(target_level, PROMPT_TEMPLATES["Understand"])
+    prompt = (
+        f"{template}\n\n"
+        f"Transform the following single question to match the level above. Keep it concise and do not include the answer.\n"
+        f"Original: {question}\n"
+        f"Return exactly 1 numbered question."
     )
+    out = gen(prompt, max_new_tokens=100, do_sample=False)[0]["generated_text"]
+    return clean_numbering(out, 1)
 
-    with gr.Tabs():
-        # --- Tab 1: Classify ---------------------------------------------------
-        with gr.TabItem("Classify"):
-            gr.Markdown("### Paste or type a question. I’ll guess its Bloom’s level.")
-            q_in = gr.Textbox(label="Question", placeholder="e.g., Compare and contrast stack and queue operations.", lines=3)
-            classify_btn = gr.Button("Classify")
-            level_out = gr.Label(label="Predicted Bloom’s level")
-            scores_out = gr.JSON(label="Scores by level (higher = stronger signal)")
-            rationale_out = gr.Markdown()
-
-            def on_classify(q):
-                lvl, scores, rationale = classify_question(q)
-                # Format Label expects mapping; we provide {'label': score}
-                if lvl:
-                    return {lvl: 1.0}, scores, f"**Rationale:** {rationale}"
-                else:
-                    return {}, {}, rationale
-
-            classify_btn.click(on_classify, inputs=[q_in], outputs=[level_out, scores_out, rationale_out])
-
-            gr.Examples(
-                examples=EXAMPLES,
-                inputs=[q_in],
-                label="Try examples",
-            )
-
-        # --- Tab 2: Generate ---------------------------------------------------
-        with gr.TabItem("Generate"):
-            gr.Markdown("### Enter a topic, choose a Bloom’s level, and how many questions to create.")
-            topic_in = gr.Textbox(label="Topic", placeholder="e.g., Dynamic programming, photosynthesis, supply and demand", lines=2)
-            level_in = gr.Dropdown(choices=BLOOMS_LEVELS, value="Understand", label="Bloom’s level")
-            num_in = gr.Slider(1, 20, value=5, step=1, label="Number of questions")
-            gen_btn = gr.Button("Generate")
-            gen_out = gr.Textbox(label="Generated Questions", lines=12)
-
-            gen_btn.click(
-                fn=lambda topic, level, n: generate_questions(topic, level, int(n)),
-                inputs=[topic_in, level_in, num_in],
-                outputs=[gen_out],
-            )
-
-        # --- Tab 3: Rewrite ----------------------------------------------------
-        with gr.TabItem("Rewrite"):
-            gr.Markdown("### Paste a question and choose a new Bloom’s level. I’ll rewrite it for that cognitive level.")
-            rewrite_in = gr.Textbox(label="Original Question", placeholder="e.g., List the steps of cellular respiration.", lines=3)
-            rewrite_level = gr.Dropdown(choices=BLOOMS_LEVELS, value="Analyze", label="Target Bloom’s level")
-            rewrite_btn = gr.Button("Rewrite")
-            rewrite_out = gr.Textbox(label="Rewritten Question", lines=5)
-
-            rewrite_btn.click(
-                fn=rewrite_question_to_level,
-                inputs=[rewrite_in, rewrite_level],
-                outputs=[rewrite_out],
-            )
-
+# ------------------ UI ------------------
+with gr.Blocks(title=TITLE) as demo:
+    gr.Markdown(f"# {TITLE}")
     gr.Markdown(
-        """
-        ---
-        **Notes**
-        - This app uses lightweight heuristics (keyword signals and structure cues) rather than a trained model.
-        - Generation ensures questions are distinct and clearly numbered.
-        - Rewriting keeps the topic while shifting cognitive demand to the selected Bloom’s level.
-        """
+        "Classify questions by Bloom level, generate new questions aligned to a level, "
+        "and rewrite a question to a different level. Runs fully on open models."
     )
 
-if __name__ == "__main__":
-    # For local testing; on Spaces you don't need to set server params explicitly.
-    demo.launch()
+    with gr.Tab("Classify"):
+        q = gr.Textbox(
+            label="Enter a question",
+            lines=4,
+            placeholder="e.g., Explain why randomized controlled trials reduce bias."
+        )
+        top = gr.Textbox(label="Predicted Bloom level", interactive=False)
+        scores = gr.Textbox(label="All scores", interactive=False)
+        gr.Button("Classify").click(classify_bloom, [q], [top, scores])
+
+    with gr.Tab("Generate"):
+        with gr.Row():
+            topic = gr.Textbox(label="Topic", value="binary numbers in computer science")
+            level = gr.Dropdown(LABELS, value="Apply", label="Bloom level")
+        with gr.Row():
+            n = gr.Slider(1, 10, value=5, step=1, label="How many questions")
+            creativity = gr.Slider(0.0, 1.2, value=0.6, step=0.1, label="Creativity (temperature)")
+        out = gr.Textbox(label="Generated questions", lines=12)
+        gr.Button("Generate").click(generate_questions, [topic, level, n, creativity], out)
+
+    with gr.Tab("Rewrite"):
+        q2 = gr.Textbox(label="Original question", lines=4, value="Define binary number.")
+        target = gr.Dropdown(LABELS, value="Analyze", label="Target Bloom level")
+        out2 = gr.Textbox(label="Rewritten question", lines=4)
+        gr.Button("Rewrite").click(rewrite_level, [q2, target], out2)
+
+demo.launch()