feat: switch to single model with dropdown selection

app.py

@@ -5,8 +5,10 @@ import numpy as np
 from monitoring import PerformanceMonitor, measure_time
 
 # Model IDs
-BASE_MODEL_ID = "HuggingFaceTB/SmolLM2-1.7B-Instruct"  # Base model
-FINETUNED_MODEL_ID = "Joash2024/Math-SmolLM2-1.7B"     # Our fine-tuned model
+MODEL_OPTIONS = {
+    "Base Model": "HuggingFaceTB/SmolLM2-1.7B-Instruct",
+    "Fine-tuned Model": "Joash2024/Math-SmolLM2-1.7B"
+}
 
 # Initialize performance monitor
 monitor = PerformanceMonitor()
@@ -43,10 +45,10 @@ def get_model_response(problem, model_id):
     except Exception as e:
         return f"Error: {str(e)}"
 
-def solve_problem(problem, problem_type):
-    """Solve a math problem using both models"""
+def solve_problem(problem, problem_type, model_type):
+    """Solve a math problem using the selected model"""
     if not problem:
-        return "Please enter a problem", "Please enter a problem", None
+        return "Please enter a problem", None
     
     # Record problem type
     monitor.record_problem_type(problem_type)
@@ -55,30 +57,21 @@ def solve_problem(problem, problem_type):
     if problem_type != "Custom":
         problem = f"{problem_type}: {problem}"
     
-    # Get responses from both models with timing
-    base_response, base_time = get_model_response(problem, BASE_MODEL_ID)
-    finetuned_response, finetuned_time = get_model_response(problem, FINETUNED_MODEL_ID)
+    # Get response from selected model
+    model_id = MODEL_OPTIONS[model_type]
+    response, time_taken = get_model_response(problem, model_id)
     
-    # Format responses with steps
-    base_output = f"""Solution: {base_response}
+    # Format response with steps
+    output = f"""Solution: {response}
 
 Let's verify this step by step:
 1. Starting with f(x) = {problem}
 2. Applying differentiation rules
-3. We get f'(x) = {base_response}"""
-
-    finetuned_output = f"""Solution: {finetuned_response}
-
-Let's verify this step by step:
-1. Starting with f(x) = {problem}
-2. Applying differentiation rules
-3. We get f'(x) = {finetuned_response}"""
+3. We get f'(x) = {response}"""
     
     # Record metrics
-    monitor.record_response_time("base", base_time)
-    monitor.record_response_time("finetuned", finetuned_time)
-    monitor.record_success("base", not base_response.startswith("Error"))
-    monitor.record_success("finetuned", not finetuned_response.startswith("Error"))
+    monitor.record_response_time(model_type, time_taken)
+    monitor.record_success(model_type, not response.startswith("Error"))
     
     # Get updated statistics
     stats = monitor.get_statistics()
@@ -88,24 +81,22 @@ Let's verify this step by step:
 ### Performance Metrics
 
 #### Response Times (seconds)
-- Base Model: {stats.get('base_avg_response_time', 0):.2f} avg
-- Fine-tuned Model: {stats.get('finetuned_avg_response_time', 0):.2f} avg
+- {model_type}: {stats.get(f'{model_type}_avg_response_time', 0):.2f} avg
 
 #### Success Rates
-- Base Model: {stats.get('base_success_rate', 0):.1f}%
-- Fine-tuned Model: {stats.get('finetuned_success_rate', 0):.1f}%
+- {model_type}: {stats.get(f'{model_type}_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 base_output, finetuned_output, stats_display
+    return output, stats_display
 
 # Create Gradio interface
 with gr.Blocks(title="Mathematics Problem Solver") as demo:
     gr.Markdown("# Mathematics Problem Solver")
-    gr.Markdown("Compare solutions between base and fine-tuned models")
+    gr.Markdown("Test our models on mathematical problems")
     
     with gr.Row():
         with gr.Column():
@@ -114,6 +105,11 @@ with gr.Blocks(title="Mathematics Problem Solver") as demo:
                 value="Derivative",
                 label="Problem Type"
             )
+            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"
@@ -121,13 +117,7 @@ with gr.Blocks(title="Mathematics Problem Solver") as demo:
             solve_btn = gr.Button("Solve", variant="primary")
     
     with gr.Row():
-        with gr.Column():
-            gr.Markdown("### Base Model")
-            base_output = gr.Textbox(label="Base Model Solution", lines=5)
-        
-        with gr.Column():
-            gr.Markdown("### Fine-tuned Model")
-            finetuned_output = gr.Textbox(label="Fine-tuned Model Solution", lines=5)
+        solution_output = gr.Textbox(label="Solution", lines=5)
     
     # Performance metrics display
     with gr.Row():
@@ -136,17 +126,17 @@ with gr.Blocks(title="Mathematics Problem Solver") as demo:
     # Example problems
     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 + 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"]
         ],
-        inputs=[problem_input, problem_type],
-        outputs=[base_output, finetuned_output, metrics_display],
+        inputs=[problem_input, problem_type, model_type],
+        outputs=[solution_output, metrics_display],
         fn=solve_problem,
         cache_examples=True,
     )
@@ -154,8 +144,8 @@ with gr.Blocks(title="Mathematics Problem Solver") as demo:
     # Connect the interface
     solve_btn.click(
         fn=solve_problem,
-        inputs=[problem_input, problem_type],
-        outputs=[base_output, finetuned_output, metrics_display]
+        inputs=[problem_input, problem_type, model_type],
+        outputs=[solution_output, metrics_display]
     )
 
 if __name__ == "__main__":