Upload 4 files

app.py

@@ -1,196 +1,153 @@
-# app.py  ── Math-solution classifier on HF Spaces (Zero-GPU-safe)
-#
-# Pin in requirements.txt:
-#   gradio==4.44.0 torch==2.1.0 transformers==4.35.0 peft==0.7.1 accelerate==0.25.0 spaces
-
-import os
-import json
-import logging
-from typing import Tuple
+# app.py - Gradio version (much simpler for HF Spaces)
 
 import gradio as gr
-import spaces  # <- Hugging Face Spaces SDK (Zero)
-
-# ──────────────────────────────────────────────────────────────────────────────
-# CONSTANTS (no CUDA use here)
-# ──────────────────────────────────────────────────────────────────────────────
-ADAPTER_PATH   = os.getenv("ADAPTER_PATH", "./lora_adapter")  # dir or Hub repo
-FALLBACK_MODEL = "distilbert-base-uncased"
-LABELS         = {0: "✅ Correct",
-                  1: "🤔 Conceptual Error",
-                  2: "🔢 Computational Error"}
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import logging
 
+# Set up logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Globals that will live **inside the GPU worker**
-model     = None
+# Global variables for model and tokenizer
+model = None
 tokenizer = None
-model_ty  = None          # "classification" | "causal_lm" | "baseline"
-
-# ──────────────────────────────────────────────────────────────────────────────
-# GPU-SIDE INITIALISATION & INFERENCE
-# ──────────────────────────────────────────────────────────────────────────────
-def _load_model_gpu():
-    """
-    Runs **inside the GPU worker**.
-    Tries LoRA classification adapter → LoRA causal-LM adapter → plain baseline.
-    """
-    global model, tokenizer, model_ty
-    import torch
-    from transformers import (
-        AutoTokenizer,
-        AutoModelForSequenceClassification,
-    )
-    from peft.auto import (
-        AutoPeftModelForSequenceClassification,
-        AutoPeftModelForCausalLM,
-    )
-
-    dtype = torch.float16
-    if os.path.isdir(ADAPTER_PATH):
-        logger.info(f"[GPU] Loading adapter from {ADAPTER_PATH}")
-
-        try:  # 1) classification adapter
-            model = AutoPeftModelForSequenceClassification.from_pretrained(
-                ADAPTER_PATH, torch_dtype=dtype, device_map="auto"
-            )
-            model_ty = "classification"
-        except ValueError:
-            logger.info("[GPU] Not a classifier, trying causal-LM")
-            model = AutoPeftModelForCausalLM.from_pretrained(
-                ADAPTER_PATH, torch_dtype=dtype, device_map="auto"
-            )
-            model_ty = "causal_lm"
-
-        tokenizer = AutoTokenizer.from_pretrained(ADAPTER_PATH)
-
-    else:
-        logger.warning("[GPU] No adapter found – using baseline DistilBERT")
-        tokenizer = AutoTokenizer.from_pretrained(FALLBACK_MODEL)
-        model     = AutoModelForSequenceClassification.from_pretrained(
-            FALLBACK_MODEL, num_labels=3, ignore_mismatched_sizes=True
-        )
-        model_ty = "baseline"
-
-    if tokenizer.pad_token is None:
-        tokenizer.pad_token = tokenizer.eos_token or tokenizer.sep_token
-
-    model.eval()
-    logger.info(f"[GPU] Model ready ({model_ty})")
-
-
-def _classify_logits(question: str, solution: str) -> Tuple[str, str, str]:
-    import torch
-    text = f"Question: {question}\n\nSolution:\n{solution}"
-    inputs = tokenizer(
-        text, return_tensors="pt", padding=True, truncation=True, max_length=512
-    ).to("cuda")
-
-    with torch.no_grad():
-        logits = model(**inputs).logits
-        probs  = torch.softmax(logits, dim=-1)[0]
-        pred   = int(torch.argmax(probs))
-        conf   = f"{probs[pred].item():.3f}"
-
-    return LABELS[pred], conf, "—"
-
+label_mapping = {0: "✅ Correct", 1: "🤔 Conceptually Flawed", 2: "🔢 Computationally Flawed"}
 
-def _classify_generate(question: str, solution: str) -> Tuple[str, str, str]:
-    import torch
-    prompt = (
-        "You are a mathematics tutor.\n"
-        "You are given a math word problem and a student's solution. Decide whether the solution is correct.\n\n"
-        "- Correct            = all reasoning and calculations are correct.\n"
-        "- Conceptual Error   = reasoning is wrong.\n"
-        "- Computational Error= reasoning okay but arithmetic off.\n\n"
-        "Reply with ONLY one of these JSON lines:\n"
-        '{"verdict": "correct"}\n'
-        '{"verdict": "conceptual"}\n'
-        '{"verdict": "computational"}\n\n'
-        f"Question: {question}\n\nSolution:\n{solution}\n\nAnswer:"
-    )
-
-    inputs = tokenizer(prompt, return_tensors="pt").to("cuda")
-    with torch.no_grad():
-        out_ids = model.generate(
-            **inputs,
-            max_new_tokens=32,
-            pad_token_id=tokenizer.eos_token_id,
-        )
-    generated = tokenizer.decode(
-        out_ids[0][inputs["input_ids"].shape[1]:],
-        skip_special_tokens=True,
-    ).strip()
-
-    verdict = "Unparsed"
+def load_model():
+    """Load your trained model here"""
+    global model, tokenizer
+    
     try:
-        data = json.loads(generated.splitlines()[-1])
-        v = data.get("verdict", "").lower()
-        if v.startswith("corr"):
-            verdict = LABELS[0]
-        elif v.startswith("conc"):
-            verdict = LABELS[1]
-        elif v.startswith("comp"):
-            verdict = LABELS[2]
-    except Exception:
-        pass
-
-    return verdict, "", generated
-
-
-@spaces.GPU                         # <-- every CUDA op happens inside here
-def gpu_classify(question: str, solution: str):
+        # Replace these with your actual model path/name
+        # Option 1: Load from local files
+        # model = AutoModelForSequenceClassification.from_pretrained("./your_model_directory")
+        # tokenizer = AutoTokenizer.from_pretrained("./your_model_directory")
+        
+        # Option 2: Load from Hugging Face Hub (if you upload your model there)
+        # model = AutoModelForSequenceClassification.from_pretrained("your-username/your-model-name")
+        # tokenizer = AutoTokenizer.from_pretrained("your-username/your-model-name")
+        
+        # For now, we'll use a placeholder - replace this with your actual model loading
+        logger.warning("Using placeholder model loading - replace with your actual model!")
+        
+        # Placeholder model loading (replace this!)
+        model_name = "distilbert-base-uncased"  # Replace with your model
+        tokenizer = AutoTokenizer.from_pretrained(model_name)
+        model = AutoModelForSequenceClassification.from_pretrained(
+            model_name, 
+            num_labels=3,
+            ignore_mismatched_sizes=True
+        )
+        
+        logger.info("Model loaded successfully")
+        return "Model loaded successfully!"
+        
+    except Exception as e:
+        logger.error(f"Error loading model: {e}")
+        return f"Error loading model: {e}"
+
+def classify_solution(question: str, solution: str):
     """
-    Proxy target for Gradio. Executed in the GPU worker so CUDA is allowed.
-    Returns (verdict, confidence, raw_output)
+    Classify the math solution
+    Returns: (classification_label, confidence_score, explanation)
     """
-    if model is None:
-        _load_model_gpu()
-
     if not question.strip() or not solution.strip():
-        return "Please fill both fields.", "", ""
-
-    if model_ty in ("classification", "baseline"):
-        return _classify_logits(question, solution)
-    else:  # causal_lm
-        return _classify_generate(question, solution)
-
-# ──────────────────────────────────────────────────────────────────────────────
-# CPU-SIDE UI (no torch.cuda here)
-# ──────────────────────────────────────────────────────────────────────────────
-def classify_proxy(q, s):
-    """Simple wrapper so Gradio can call the GPU function."""
-    return gpu_classify(q, s)
-
-with gr.Blocks(title="Math Solution Classifier") as demo:
+        return "Please fill in both fields", 0.0, ""
+    
+    if not model or not tokenizer:
+        return "Model not loaded", 0.0, ""
+    
+    try:
+        # Combine question and solution for input
+        text_input = f"Question: {question}\nSolution: {solution}"
+        
+        # Tokenize input
+        inputs = tokenizer(
+            text_input,
+            return_tensors="pt",
+            truncation=True,
+            padding=True,
+            max_length=512
+        )
+        
+        # Get model prediction
+        with torch.no_grad():
+            outputs = model(**inputs)
+            predictions = torch.nn.functional.softmax(outputs.logits, dim=-1)
+            predicted_class = torch.argmax(predictions, dim=-1).item()
+            confidence = predictions[0][predicted_class].item()
+        
+        classification = label_mapping[predicted_class]
+        
+        # Create explanation based on classification
+        explanations = {
+            0: "The mathematical approach and calculations are both sound.",
+            1: "The approach or understanding has fundamental issues.",
+            2: "The approach is correct, but there are calculation errors."
+        }
+        
+        explanation = explanations[predicted_class]
+        
+        return classification, f"{confidence:.2%}", explanation
+        
+    except Exception as e:
+        logger.error(f"Error during classification: {e}")
+        return f"Classification error: {str(e)}", "0%", ""
+
+# Load model on startup
+load_model()
+
+# Create Gradio interface
+with gr.Blocks(title="Math Solution Classifier", theme=gr.themes.Soft()) as app:
     gr.Markdown("# 🧮 Math Solution Classifier")
-    gr.Markdown(
-        "Classify a student's math solution as **correct**, **conceptually flawed**, "
-        "or **computationally flawed**."
-    )
-
+    gr.Markdown("Classify math solutions as correct, conceptually flawed, or computationally flawed.")
+    
     with gr.Row():
         with gr.Column():
-            q_in = gr.Textbox(label="Math Question", lines=3)
-            s_in = gr.Textbox(label="Proposed Solution", lines=6)
-            btn  = gr.Button("Classify", variant="primary")
+            question_input = gr.Textbox(
+                label="Math Question",
+                placeholder="e.g., Solve for x: 2x + 5 = 13",
+                lines=3
+            )
+            
+            solution_input = gr.Textbox(
+                label="Proposed Solution", 
+                placeholder="e.g., 2x + 5 = 13\n2x = 13 - 5\n2x = 8\nx = 4",
+                lines=5
+            )
+            
+            classify_btn = gr.Button("Classify Solution", variant="primary")
+        
         with gr.Column():
-            verdict = gr.Textbox(label="Verdict", interactive=False)
-            conf    = gr.Textbox(label="Confidence", interactive=False)
-            raw     = gr.Textbox(label="Model Output", interactive=False)
-
-    btn.click(classify_proxy, [q_in, s_in], [verdict, conf, raw])
-
+            classification_output = gr.Textbox(label="Classification", interactive=False)
+            confidence_output = gr.Textbox(label="Confidence", interactive=False)
+            explanation_output = gr.Textbox(label="Explanation", interactive=False, lines=3)
+    
+    # Examples
     gr.Examples(
-        [
-            ["Solve for x: 2x + 5 = 13", "2x + 5 = 13\n2x = 8\nx = 4"],
-            ["Find the derivative of f(x)=x²", "f'(x)=2x+1"],
-            ["What is 15% of 200?", "0.15 × 200 = 30"],
+        examples=[
+            [
+                "Solve for x: 2x + 5 = 13",
+                "2x + 5 = 13\n2x = 13 - 5\n2x = 8\nx = 4"
+            ],
+            [
+                "Find the derivative of f(x) = x²", 
+                "f'(x) = 2x + 1"  # This should be computationally flawed
+            ],
+            [
+                "What is 15% of 200?",
+                "15% = 15/100 = 0.15\n0.15 × 200 = 30"
+            ]
         ],
-        inputs=[q_in, s_in],
+        inputs=[question_input, solution_input]
+    )
+    
+    classify_btn.click(
+        fn=classify_solution,
+        inputs=[question_input, solution_input],
+        outputs=[classification_output, confidence_output, explanation_output]
     )
-app = demo     # Gradio SDK looks for “app”
-
-
 
+if __name__ == "__main__":
+    app.launch()