Upload 2 files

README.md

@@ -1,8 +1,32 @@
+# README.md for your Hugging Face Space
+---
 title: Math Solution Classifier
 emoji: 🧮
 colorFrom: blue
 colorTo: purple
 sdk: gradio
-sdk_version: 4.7.1
+sdk_version: 4.44.0
 app_file: app.py
-pinned: false
+pinned: false
+---
+
+# Math Solution Classifier
+
+This application classifies math solutions into three categories:
+- **Correct**: Solution is mathematically sound
+- **Conceptually Flawed**: Wrong approach or understanding  
+- **Computationally Flawed**: Right approach, calculation errors
+
+## Usage
+
+1. Enter a math question
+2. Enter the proposed solution
+3. Click "Classify Solution"
+4. Get instant feedback on the solution quality
+
+Built with Gradio and your custom trained model.
+
+# requirements.txt
+gradio==4.44.0
+torch==2.1.0
+transformers==4.35.0

app.py

@@ -1,10 +1,6 @@
-# app.py - FastAPI backend for Math Solution Classifier
+# app.py - Gradio version (much simpler for HF Spaces)
 
-from fastapi import FastAPI, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.staticfiles import StaticFiles
-from fastapi.responses import FileResponse
-from pydantic import BaseModel
+import gradio as gr
 import torch
 from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import logging
@@ -13,29 +9,10 @@ import logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-app = FastAPI(title="Math Solution Classifier API")
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
 # Global variables for model and tokenizer
 model = None
 tokenizer = None
-label_mapping = {0: "correct", 1: "conceptually-flawed", 2: "computationally-flawed"}
-
-class ClassificationRequest(BaseModel):
-    question: str
-    solution: str
-
-class ClassificationResponse(BaseModel):
-    classification: str
-    confidence: float
+label_mapping = {0: "✅ Correct", 1: "🤔 Conceptually Flawed", 2: "🔢 Computationally Flawed"}
 
 def load_model():
     """Load your trained model here"""
@@ -64,16 +41,23 @@ def load_model():
         )
         
         logger.info("Model loaded successfully")
+        return "Model loaded successfully!"
         
     except Exception as e:
         logger.error(f"Error loading model: {e}")
-        raise
+        return f"Error loading model: {e}"
 
-def classify_solution(question: str, solution: str) -> tuple:
+def classify_solution(question: str, solution: str):
     """
     Classify the math solution
-    Returns: (classification_label, confidence_score)
+    Returns: (classification_label, confidence_score, explanation)
     """
+    if not question.strip() or not solution.strip():
+        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}"
@@ -96,53 +80,74 @@ def classify_solution(question: str, solution: str) -> tuple:
         
         classification = label_mapping[predicted_class]
         
-        return classification, confidence
+        # 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}")
-        raise HTTPException(status_code=500, detail=f"Classification error: {str(e)}")
+        return f"Classification error: {str(e)}", "0%", ""
 
-@app.on_event("startup")
-async def startup_event():
-    """Load model on startup"""
-    logger.info("Loading model...")
-    load_model()
+# Load model on startup
+load_model()
 
-@app.post("/classify", response_model=ClassificationResponse)
-async def classify_math_solution(request: ClassificationRequest):
-    """
-    Classify a math solution as correct, conceptually flawed, or computationally flawed
-    """
-    if not model or not tokenizer:
-        raise HTTPException(status_code=503, detail="Model not loaded")
-    
-    if not request.question.strip() or not request.solution.strip():
-        raise HTTPException(status_code=400, detail="Both question and solution are required")
+# Create Gradio interface
+with gr.Blocks(title="Math Solution Classifier", theme=gr.themes.Soft()) as app:
+    gr.Markdown("# 🧮 Math Solution Classifier")
+    gr.Markdown("Classify math solutions as correct, conceptually flawed, or computationally flawed.")
     
-    try:
-        classification, confidence = classify_solution(request.question, request.solution)
+    with gr.Row():
+        with gr.Column():
+            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")
         
-        return ClassificationResponse(
-            classification=classification,
-            confidence=confidence
-        )
-        
-    except Exception as e:
-        logger.error(f"Classification failed: {e}")
-        raise HTTPException(status_code=500, detail="Classification failed")
-
-@app.get("/health")
-async def health_check():
-    """Health check endpoint"""
-    return {"status": "healthy", "model_loaded": model is not None}
-
-# Serve the frontend (for Hugging Face Spaces)
-app.mount("/static", StaticFiles(directory="static"), name="static")
-
-@app.get("/")
-async def serve_frontend():
-    return FileResponse("static/index.html")
+        with gr.Column():
+            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(
+        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=[question_input, solution_input]
+    )
+    
+    classify_btn.click(
+        fn=classify_solution,
+        inputs=[question_input, solution_input],
+        outputs=[classification_output, confidence_output, explanation_output]
+    )
 
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)  # Port 7860 is standard for HF Spaces
+    app.launch()