fix: revert to working version

app.py

@@ -2,15 +2,11 @@ import gradio as gr
 import torch
 from transformers import AutoModelForCausalLM, AutoTokenizer
 from peft import PeftModel
-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
@@ -26,29 +22,17 @@ print("Loading LoRA adapter...")
 model = PeftModel.from_pretrained(model, ADAPTER_MODEL)
 model.eval()
 
-def format_prompt(problem: str, problem_type: str) -> str:
+def format_prompt(function: str) -> str:
     """Format input prompt for the model"""
-    if problem_type == "Derivative":
-        return f"""Given a mathematical function, find its derivative.
+    return f"""Given a mathematical function, find its derivative.
 
-Function: {problem}
+Function: {function}
 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 derivative of this function.
 
-Function: {problem}
-The derivative is:"""
-
-@measure_time
-def generate_derivative(problem: str, problem_type: str, max_length: int = 200) -> str:
+def generate_derivative(function: str, max_length: int = 200) -> str:
     """Generate derivative for a given function"""
     # Format the prompt
-    prompt = format_prompt(problem, problem_type)
+    prompt = format_prompt(function)
     
     # Tokenize
     inputs = tokenizer(prompt, return_tensors="pt").to(model.device)
@@ -70,101 +54,66 @@ def generate_derivative(problem: str, problem_type: str, max_length: int = 200)
     
     return derivative
 
-def solve_problem(problem: str, problem_type: str) -> tuple:
-    """Solve problem and format output"""
-    if not problem:
-        return "Please enter a problem", None
-    
-    # Record problem type
-    monitor.record_problem_type(problem_type)
+def solve_derivative(function: str) -> str:
+    """Solve derivative and format output"""
+    if not function:
+        return "Please enter a function"
     
-    # Generate solution
-    print(f"\nGenerating solution for: {problem}")
-    solution, time_taken = generate_derivative(problem, problem_type)
-    
-    # Record metrics
-    monitor.record_response_time("model", time_taken)
-    monitor.record_success("model", not solution.startswith("Error"))
+    print(f"\nGenerating derivative for: {function}")
+    derivative = generate_derivative(function)
     
     # Format output with step-by-step explanation
-    output = f"""Generated solution: {solution}
+    output = f"""Generated derivative: {derivative}
 
 Let's verify this step by step:
-1. Starting with f(x) = {problem}
+1. Starting with f(x) = {function}
 2. Applying differentiation rules
-3. We get f'(x) = {solution}"""
-    
-    # Get updated statistics
-    stats = monitor.get_statistics()
+3. We get f'(x) = {derivative}"""
     
-    # 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
+    return output
 
 # Create Gradio interface
-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.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"
             )
-            problem_input = gr.Textbox(
-                label="Enter your 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(
+        output = gr.Textbox(
             label="Solution with Steps",
             lines=6
         )
     
-    # Performance metrics display
-    with gr.Row():
-        metrics_display = gr.Markdown("### Performance Metrics\n*Solve a problem to see metrics*")
-    
-    # Example problems
+    # Example functions
     gr.Examples(
         examples=[
-            ["x^2 + 3x", "Derivative"],
-            ["144", "Root Finding"],
-            ["235 + 567", "Addition"],
-            ["\\sin{\\left(x\\right)}", "Derivative"],
-            ["e^x", "Derivative"],
-            ["\\frac{1}{x}", "Derivative"],
-            ["x^3 + 2x", "Derivative"],
-            ["\\cos{\\left(x^2\\right)}", "Derivative"]
+            ["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],
-        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],
-        outputs=[solution_output, metrics_display]
+        fn=solve_derivative,
+        inputs=[function_input],
+        outputs=output
     )
 
 if __name__ == "__main__":