fix: use working test space code with A100

README.md

@@ -1,5 +1,5 @@
 ---
-title: Mathematics Problem Solver
+title: Mathematics Derivative Solver
 emoji: 🧮
 colorFrom: blue
 colorTo: green
@@ -18,29 +18,16 @@ python_packages:
   - "numpy>=1.21.0"
 ---
 
-# Mathematics Problem Solver
+# Mathematics Derivative Solver
 
-This Space demonstrates our fine-tuned math model for solving various mathematical problems, with a focus on derivatives. Compare solutions between:
+This Space demonstrates our fine-tuned math model for solving derivatives. We use:
 
 1. Base Model: HuggingFaceTB/SmolLM2-1.7B-Instruct
 2. Our Fine-tuned Model: Joash2024/Math-SmolLM2-1.7B
 
 ## Features
 
-- Side-by-side comparison of base and fine-tuned models
-- Performance monitoring:
-  - Response times
-  - Success rates
-  - Problem type distribution
-- Support for various problems:
-  - Derivatives
-  - Addition
-  - Roots
-  - Custom problems
-
-## Technical Details
-
+- Step-by-step derivative solutions
+- LaTeX notation support
 - A100 GPU acceleration
 - Float16 precision for efficient inference
-- LaTeX notation support
-- Real-time performance tracking

app.py

@@ -1,151 +1,119 @@
 import gradio as gr
-from transformers import pipeline
 import torch
-import numpy as np
-from monitoring import PerformanceMonitor, measure_time
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from peft import PeftModel
 
-# Model IDs
-MODEL_OPTIONS = {
-    "Base Model": "HuggingFaceTB/SmolLM2-1.7B-Instruct",
-    "Fine-tuned Model": "Joash2024/Math-SmolLM2-1.7B"
-}
+# Model configurations
+BASE_MODEL = "HuggingFaceTB/SmolLM2-1.7B-Instruct"  # Base model
+ADAPTER_MODEL = "Joash2024/Math-SmolLM2-1.7B"       # Our LoRA adapter
 
-# Initialize performance monitor
-monitor = PerformanceMonitor()
+print("Loading tokenizer...")
+tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL)
+tokenizer.pad_token = tokenizer.eos_token
 
-def format_prompt(problem):
-    """Format the input problem according to the model's expected format"""
-    return f"Given a mathematical function, find its derivative.\n\nFunction: {problem}\nThe derivative of this function is:"
+print("Loading base model...")
+model = AutoModelForCausalLM.from_pretrained(
+    BASE_MODEL,
+    device_map="auto",
+    torch_dtype=torch.float16
+)
 
-@measure_time
-def get_model_response(problem, model_id):
-    """Get response from a specific model"""
-    try:
-        # Initialize pipeline for each request
-        pipe = pipeline(
-            "text-generation",
-            model=model_id,
-            torch_dtype=torch.float16,
-            device_map="auto",
-            model_kwargs={"low_cpu_mem_usage": True}
-        )
-        
-        # Format prompt and generate response
-        prompt = format_prompt(problem)
-        response = pipe(
-            prompt,
-            max_new_tokens=50,  # Shorter response
-            temperature=0.1,
-            do_sample=False,  # Deterministic
-            num_return_sequences=1,
-            return_full_text=False  # Only return new text
-        )[0]["generated_text"]
-        
-        return response.strip()
-    except Exception as e:
-        return f"Error: {str(e)}"
+print("Loading LoRA adapter...")
+model = PeftModel.from_pretrained(model, ADAPTER_MODEL)
+model.eval()
+
+def format_prompt(function: str) -> str:
+    """Format input prompt for the model"""
+    return f"""Given a mathematical function, find its derivative.
+
+Function: {function}
+The derivative of this function is:"""
 
-def solve_problem(problem, problem_type, model_type):
-    """Solve a math problem using the selected model"""
-    if not problem:
-        return "Please enter a problem", None
+def generate_derivative(function: str, max_length: int = 200) -> str:
+    """Generate derivative for a given function"""
+    # Format the prompt
+    prompt = format_prompt(function)
     
-    # Record problem type
-    monitor.record_problem_type(problem_type)
+    # Tokenize
+    inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
     
-    # Add problem type context if provided
-    if problem_type != "Custom":
-        problem = f"{problem_type}: {problem}"
+    # Generate
+    with torch.no_grad():
+        outputs = model.generate(
+            **inputs,
+            max_length=max_length,
+            num_return_sequences=1,
+            temperature=0.1,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id
+        )
     
-    # Get response from selected model
-    model_id = MODEL_OPTIONS[model_type]
-    response, time_taken = get_model_response(problem, model_id)
+    # Decode and extract derivative
+    generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    derivative = generated[len(prompt):].strip()
     
-    # Format response with steps
-    output = f"""Solution: {response}
+    return derivative
 
-Let's verify this step by step:
-1. Starting with f(x) = {problem}
-2. Applying differentiation rules
-3. We get f'(x) = {response}"""
+def solve_derivative(function: str) -> str:
+    """Solve derivative and format output"""
+    if not function:
+        return "Please enter a function"
     
-    # Record metrics
-    monitor.record_response_time(model_type, time_taken)
-    monitor.record_success(model_type, not response.startswith("Error"))
+    print(f"\nGenerating derivative for: {function}")
+    derivative = generate_derivative(function)
     
-    # Get updated statistics
-    stats = monitor.get_statistics()
-    
-    # Format statistics for display
-    stats_display = f"""
-### Performance Metrics
-
-#### Response Times (seconds)
-- {model_type}: {stats.get(f'{model_type}_avg_response_time', 0):.2f} avg
-
-#### Success Rates
-- {model_type}: {stats.get(f'{model_type}_success_rate', 0):.1f}%
+    # Format output with step-by-step explanation
+    output = f"""Generated derivative: {derivative}
 
-#### Problem Types Used
-"""
-    for ptype, percentage in stats.get('problem_type_distribution', {}).items():
-        stats_display += f"- {ptype}: {percentage:.1f}%\n"
+Let's verify this step by step:
+1. Starting with f(x) = {function}
+2. Applying differentiation rules
+3. We get f'(x) = {derivative}"""
     
-    return output, stats_display
+    return output
 
 # Create Gradio interface
-with gr.Blocks(title="Mathematics Problem Solver") as demo:
-    gr.Markdown("# Mathematics Problem Solver")
-    gr.Markdown("Test our models on mathematical problems")
+with gr.Blocks(title="Mathematics Derivative Solver") as demo:
+    gr.Markdown("# Mathematics Derivative Solver")
+    gr.Markdown("Using our fine-tuned model to solve derivatives")
     
     with gr.Row():
         with gr.Column():
-            problem_type = gr.Dropdown(
-                choices=["Addition", "Root Finding", "Derivative", "Custom"],
-                value="Derivative",
-                label="Problem Type"
+            function_input = gr.Textbox(
+                label="Enter a function",
+                placeholder="Example: x^2, sin(x), e^x"
             )
-            model_type = gr.Dropdown(
-                choices=list(MODEL_OPTIONS.keys()),
-                value="Fine-tuned Model",
-                label="Model to Use"
-            )
-            problem_input = gr.Textbox(
-                label="Enter your math problem",
-                placeholder="Example: x^2 + 3x"
-            )
-            solve_btn = gr.Button("Solve", variant="primary")
+            solve_btn = gr.Button("Find Derivative", variant="primary")
     
     with gr.Row():
-        solution_output = gr.Textbox(label="Solution", lines=5)
-    
-    # Performance metrics display
-    with gr.Row():
-        metrics_display = gr.Markdown("### Performance Metrics\n*Solve a problem to see metrics*")
+        output = gr.Textbox(
+            label="Solution with Steps",
+            lines=6
+        )
     
-    # Example problems
+    # Example functions
     gr.Examples(
         examples=[
-            ["x^2 + 3x", "Derivative", "Fine-tuned Model"],
-            ["144", "Root Finding", "Fine-tuned Model"],
-            ["235 + 567", "Addition", "Fine-tuned Model"],
-            ["\\sin{\\left(x\\right)}", "Derivative", "Fine-tuned Model"],
-            ["e^x", "Derivative", "Fine-tuned Model"],
-            ["\\frac{1}{x}", "Derivative", "Fine-tuned Model"],
-            ["x^3 + 2x", "Derivative", "Fine-tuned Model"],
-            ["\\cos{\\left(x^2\\right)}", "Derivative", "Fine-tuned Model"]
+            ["x^2"],
+            ["\\sin{\\left(x\\right)}"],
+            ["e^x"],
+            ["\\frac{1}{x}"],
+            ["x^3 + 2x"],
+            ["\\cos{\\left(x^2\\right)}"],
+            ["\\log{\\left(x\\right)}"],
+            ["x e^{-x}"]
         ],
-        inputs=[problem_input, problem_type, model_type],
-        outputs=[solution_output, metrics_display],
-        fn=solve_problem,
+        inputs=function_input,
+        outputs=output,
+        fn=solve_derivative,
         cache_examples=True,
     )
     
     # Connect the interface
     solve_btn.click(
-        fn=solve_problem,
-        inputs=[problem_input, problem_type, model_type],
-        outputs=[solution_output, metrics_display]
+        fn=solve_derivative,
+        inputs=[function_input],
+        outputs=[output]
     )
 
 if __name__ == "__main__":