feat: add problem types and monitoring

app.py

@@ -3,11 +3,15 @@ import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer
 from peft import PeftModel
 import spaces
+from monitoring import PerformanceMonitor, measure_time
 
 # 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
@@ -30,18 +34,30 @@ model = PeftModel.from_pretrained(
 )
 model.eval()
 
-def format_prompt(function: str) -> str:
+def format_prompt(problem: str, problem_type: str) -> str:
     """Format input prompt for the model"""
-    return f"""Given a mathematical function, find its derivative.
+    if problem_type == "Derivative":
+        return f"""Given a mathematical function, find its derivative.
 
-Function: {function}
+Function: {problem}
 The derivative of this function is:"""
+    elif problem_type == "Addition":
+        return f"""Solve this addition problem.
+
+Problem: {problem}
+The solution is:"""
+    else:  # Roots or Custom
+        return f"""Find the roots of this equation.
+
+Equation: {problem}
+The roots are:"""
 
 @spaces.GPU
-def generate_derivative(function: str, max_length: int = 100) -> str:
-    """Generate derivative for a given function"""
+@measure_time
+def get_model_response(problem: str, problem_type: str) -> str:
+    """Generate response from model"""
     # Format prompt
-    prompt = format_prompt(function)
+    prompt = format_prompt(problem, problem_type)
     
     # Tokenize
     inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
@@ -50,75 +66,127 @@ def generate_derivative(function: str, max_length: int = 100) -> str:
     with torch.no_grad():
         outputs = model.generate(
             **inputs,
-            max_length=max_length,
+            max_length=100,
             num_return_sequences=1,
             temperature=0.1,
             do_sample=False,  # Deterministic generation
             pad_token_id=tokenizer.eos_token_id
         )
     
-    # Decode and extract derivative
+    # Decode and extract response
     generated = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    derivative = generated[len(prompt):].strip()
+    response = generated[len(prompt):].strip()
     
-    return derivative
+    return response
 
 @spaces.GPU
-def solve_derivative(function: str) -> str:
-    """Solve derivative and format output"""
-    if not function:
-        return "Please enter a function"
+def solve_problem(problem: str, problem_type: str) -> tuple:
+    """Solve math problem and track performance"""
+    if not problem:
+        return "Please enter a problem", None
     
-    print(f"\nGenerating derivative for: {function}")
-    derivative = generate_derivative(function)
+    # Record problem type
+    monitor.record_problem_type(problem_type)
     
-    # Format output with step-by-step explanation
-    output = f"""Generated derivative: {derivative}
+    # Get model response with timing
+    response, time_taken = get_model_response(problem, problem_type)
+    
+    # Format output with steps
+    if problem_type == "Derivative":
+        output = f"""Generated derivative: {response}
 
 Let's verify this step by step:
-1. Starting with f(x) = {function}
+1. Starting with f(x) = {problem}
 2. Applying differentiation rules
-3. We get f'(x) = {derivative}"""
+3. We get f'(x) = {response}"""
+    elif problem_type == "Addition":
+        output = f"""Solution: {response}
+
+Let's verify this step by step:
+1. Starting with: {problem}
+2. Adding the numbers
+3. We get: {response}"""
+    else:  # Roots
+        output = f"""Found roots: {response}
+
+Let's verify this step by step:
+1. Starting with equation: {problem}
+2. Solving for x
+3. Roots are: {response}"""
+    
+    # Record metrics
+    monitor.record_response_time("model", time_taken)
+    monitor.record_success("model", not response.startswith("Error"))
     
-    return output
+    # Get updated statistics
+    stats = monitor.get_statistics()
+    
+    # Format statistics for display
+    stats_display = f"""
+### Performance Metrics
+
+#### Response Times
+- Average: {stats.get('model_avg_response_time', 0):.2f} seconds
+
+#### Success Rate
+- {stats.get('model_success_rate', 0):.1f}%
+
+#### Problem Types Used
+"""
+    for ptype, percentage in stats.get('problem_type_distribution', {}).items():
+        stats_display += f"- {ptype}: {percentage:.1f}%\n"
+    
+    return output, stats_display
 
 # Create Gradio interface
-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.Blocks(title="Mathematics Problem Solver") as demo:
+    gr.Markdown("# Mathematics Problem Solver")
+    gr.Markdown("Using our fine-tuned model to solve mathematical problems")
     
     with gr.Row():
         with gr.Column():
-            function_input = gr.Textbox(
-                label="Enter a function",
-                placeholder="Example: x^2, sin(x), e^x"
+            problem_type = gr.Dropdown(
+                choices=["Derivative", "Addition", "Roots"],
+                value="Derivative",
+                label="Problem Type"
+            )
+            problem_input = gr.Textbox(
+                label="Enter your problem",
+                placeholder="Example: x^2 + 3x"
             )
-            solve_btn = gr.Button("Find Derivative", variant="primary")
+            solve_btn = gr.Button("Solve", variant="primary")
     
     with gr.Row():
-        output = gr.Textbox(
+        solution_output = gr.Textbox(
             label="Solution with Steps",
             lines=6
         )
     
-    # Example functions (reduced)
+    # Performance metrics display
+    with gr.Row():
+        metrics_display = gr.Markdown("### Performance Metrics\n*Solve a problem to see metrics*")
+    
+    # Example problems
     gr.Examples(
         examples=[
-            ["x^2"],
-            ["\\sin{\\left(x\\right)}"],
-            ["e^x"]
+            ["x^2 + 3x", "Derivative"],
+            ["235 + 567", "Addition"],
+            ["x^2 - 4", "Roots"],
+            ["\\sin{\\left(x\\right)}", "Derivative"],
+            ["e^x", "Derivative"],
+            ["\\frac{1}{x}", "Derivative"]
         ],
-        inputs=function_input,
-        outputs=output,
-        fn=solve_derivative,
+        inputs=[problem_input, problem_type],
+        outputs=[solution_output, metrics_display],
+        fn=solve_problem,
         cache_examples=False  # Disable caching
     )
     
     # Connect the interface
     solve_btn.click(
-        fn=solve_derivative,
-        inputs=[function_input],
-        outputs=output
+        fn=solve_problem,
+        inputs=[problem_input, problem_type],
+        outputs=[solution_output, metrics_display]
     )
 
 if __name__ == "__main__":

monitoring.py

@@ -0,0 +1,63 @@
+import time
+from functools import wraps
+from collections import defaultdict
+import numpy as np
+
+class PerformanceMonitor:
+    def __init__(self):
+        self.response_times = defaultdict(list)
+        self.success_counts = defaultdict(int)
+        self.total_counts = defaultdict(int)
+        self.problem_types = defaultdict(int)
+        self.total_problems = 0
+    
+    def record_response_time(self, model_type: str, time: float):
+        """Record response time for a model"""
+        self.response_times[model_type].append(time)
+    
+    def record_success(self, model_type: str, success: bool):
+        """Record success/failure for a model"""
+        self.total_counts[model_type] += 1
+        if success:
+            self.success_counts[model_type] += 1
+    
+    def record_problem_type(self, problem_type: str):
+        """Record problem type"""
+        self.problem_types[problem_type] += 1
+        self.total_problems += 1
+    
+    def get_statistics(self) -> dict:
+        """Get current performance statistics"""
+        stats = {}
+        
+        # Calculate average response times
+        for model_type, times in self.response_times.items():
+            if times:
+                stats[f'{model_type}_avg_response_time'] = np.mean(times)
+        
+        # Calculate success rates
+        for model_type in self.total_counts.keys():
+            total = self.total_counts[model_type]
+            if total > 0:
+                success_rate = (self.success_counts[model_type] / total) * 100
+                stats[f'{model_type}_success_rate'] = success_rate
+        
+        # Calculate problem type distribution
+        if self.total_problems > 0:
+            distribution = {
+                ptype: (count / self.total_problems) * 100
+                for ptype, count in self.problem_types.items()
+            }
+            stats['problem_type_distribution'] = distribution
+        
+        return stats
+
+def measure_time(func):
+    """Decorator to measure function execution time"""
+    @wraps(func)
+    def wrapper(*args, **kwargs):
+        start_time = time.time()
+        result = func(*args, **kwargs)
+        end_time = time.time()
+        return result, end_time - start_time
+    return wrapper