Update app.py

app.py

@@ -1,219 +1,111 @@
-import gradio as gr
 import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import gradio as gr
 import time
 import matplotlib.pyplot as plt
 import numpy as np
-import re
-import sympy as sp
 from io import BytesIO
 import base64
 
-# ===== MATH ENGINE =====
-def solve_math(expression):
-    """Advanced math solver with steps"""
-    try:
-        x = sp.symbols('x')
-        if '=' in expression:  # Equation solving
-            eq = sp.sympify(expression.split('=')[0] + '-(' + expression.split('=')[1] + ')')
-            solution = sp.solve(eq, x)
-            steps = [
-                f"Original equation: {expression}",
-                f"Rearranged: {eq} = 0",
-                f"Solution: x = {solution}"
-            ]
-            return {'answer': str(solution), 'steps': steps}
-        else:  # Direct calculation
-            expr = sp.sympify(expression)
-            steps = [
-                f"Calculation: {expression}",
-                f"Simplified: {expr}",
-                f"Result: {expr.evalf()}"
-            ]
-            return {'answer': str(expr.evalf()), 'steps': steps}
-    except:
-        return None
+# Check for GPU availability and set device
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Using device: {device}")
 
-# ===== GRAPH ENGINE =====
-def create_graph(data_type, values=None):
-    """Generate multiple graph types"""
+# Load model and tokenizer with error handling
+try:
+    tokenizer = AutoTokenizer.from_pretrained("google/gemma-2-2b-it")
+    model = AutoModelForCausalLM.from_pretrained(
+        "google/gemma-2-2b-it",
+        torch_dtype=torch.float16 if device.type == "cuda" else torch.float32,
+        device_map="auto"
+    )
+    print("Model and tokenizer loaded successfully")
+except Exception as e:
+    print(f"Error loading model: {e}")
+    raise
+
+def generate_response(prompt):
     try:
-        plt.figure(figsize=(8,4))
+        start_time = time.time()
         
-        if data_type == "sales":
-            days = ['Yesterday', 'Today']
-            sales = [values['yesterday'], values['today']]
-            plt.bar(days, sales, color=['blue', 'green'])
-            plt.title("Sales Comparison")
-            plt.ylabel("Number of Sales")
-        elif data_type == "shopping":
-            items = ['Notebooks', 'Pens']
-            costs = [values['notebooks']*values['n_count'], values['pens']*values['p_count']]
-            plt.bar(items, costs, color=['red', 'blue'])
-            plt.title("Shopping Cost Breakdown")
-            plt.ylabel("Total Cost (Rs.)")
-        elif data_type == "function":
-            x = np.linspace(-10, 10, 100)
-            if values['type'] == 'linear':
-                y = 2*x + 3
-                plt.plot(x, y)
-                plt.title("Linear Function: y = 2x + 3")
-            elif values['type'] == 'quadratic':
-                y = x**2 - 4
-                plt.plot(x, y)
-                plt.title("Quadratic Function: y = x² - 4")
+        # Format the prompt for step-by-step explanation
+        formatted_prompt = f"📝 Provide a detailed, step-by-step solution to the following:\n{prompt}\n\nStep-by-Step Solution:"
         
-        plt.grid(True)
-        buf = BytesIO()
-        plt.savefig(buf, format='png')
-        plt.close()
-        return f"data:image/png;base64,{base64.b64encode(buf.getvalue()).decode('utf-8')}"
-    except:
-        return None
-
-# ===== QUESTION PROCESSOR =====
-def process_question(prompt):
-    start_time = time.time()
-    
-    # 1. Basic arithmetic
-    if re.match(r"^[Ww]hat is \d+[\+\-\*\/]\d+\??$", prompt):
-        math_result = solve_math(prompt.replace("What is", "").replace("?", ""))
-        if math_result:
-            steps = "\n".join([f"• {step}" for step in math_result['steps']])
-            return {
-                'answer': f"🧮 Math Solution:\n\n{steps}",
-                'graph': None
-            }
-    
-    # 2. Shopping problem
-    elif "notebook" in prompt.lower() and "pen" in prompt.lower():
-        try:
-            n_count = int(re.search(r"(\d+) notebook", prompt).group(1))
-            p_count = int(re.search(r"(\d+) pen", prompt).group(1))
-            n_price = int(re.search(r"notebook costs Rs\.(\d+)", prompt).group(1))
-            p_price = int(re.search(r"pen costs Rs\.(\d+)", prompt).group(1))
-            
-            total = n_count*n_price + p_count*p_price
-            steps = [
-                f"• Notebooks: {n_count} × Rs.{n_price} = Rs.{n_count*n_price}",
-                f"• Pens: {p_count} × Rs.{p_price} = Rs.{p_count*p_price}",
-                f"• Total: Rs.{n_count*n_price} + Rs.{p_count*p_price} = Rs.{total}"
-            ]
-            
-            graph = create_graph("shopping", {
-                'notebooks': n_price,
-                'n_count': n_count,
-                'pens': p_price,
-                'p_count': p_count
-            })
-            
-            return {
-                'answer': f"🛍️ Shopping Calculation:\n\n" + "\n".join(steps),
-                'graph': graph
-            }
-        except:
-            pass
-    
-    # 3. Complex numbers
-    elif "complex number" in prompt.lower() or "i =" in prompt.lower():
-        try:
-            eq = re.search(r"(z\^2.*?=.*?\d+)", prompt).group(1)
-            z = sp.symbols('z')
-            solution = sp.solve(sp.sympify(eq), z)
-            steps = [
-                f"• Original equation: {eq}",
-                f"• Solutions:",
-                f"  z₁ = {solution[0]}",
-                f"  z₂ = {solution[1]}"
-            ]
-            return {
-                'answer': f"ℂ Complex Number Solution:\n\n" + "\n".join(steps),
-                'graph': None
-            }
-        except:
-            pass
-    
-    # 4. Sales comparison
-    elif "sales" in prompt.lower() and "difference" in prompt.lower():
-        try:
-            today = int(re.search(r"today.*?(\d+) sales", prompt).group(1))
-            yesterday = int(re.search(r"yesterday.*?(\d+) sales", prompt).group(1))
-            diff = today - yesterday
-            
-            steps = [
-                f"• Today's sales: {today}",
-                f"• Yesterday's sales: {yesterday}",
-                f"• Difference: {today} - {yesterday} = {diff}"
-            ]
-            
-            graph = create_graph("sales", {
-                'today': today,
-                'yesterday': yesterday
-            })
-            
-            return {
-                'answer': f"📊 Sales Analysis:\n\n" + "\n".join(steps),
-                'graph': graph
-            }
-        except:
-            pass
-    
-    # 5. Default case - simple explanation
-    return {
-        'answer': "Here's a step-by-step explanation:\n1. First step\n2. Second step\n3. Final conclusion",
-        'graph': None
-    }
-
-# ===== GRADIO INTERFACE =====
-with gr.Blocks(theme=gr.themes.Soft(), title="🧠 Ultimate Problem Solver") as demo:
-    gr.Markdown("""<h1><center>Math + Shopping + Sales + Complex Numbers</center></h1>""")
-    
-    with gr.Row():
-        question = gr.Textbox(
-            label="Your Question",
-            placeholder="Try: 'What is 2+2?' or 'Sara bought 3 notebooks...'",
-            lines=3
+        input_ids = tokenizer(formatted_prompt, return_tensors="pt").to(device)
+        
+        # Generate response with optimized parameters for speed
+        outputs = model.generate(
+            **input_ids,
+            max_new_tokens=1000,
+            temperature=0.7,
+            do_sample=True,
+            top_k=50,
+            top_p=0.95,
+            pad_token_id=tokenizer.eos_token_id
         )
+        
+        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        
+        # Remove the input prompt from the response
+        response = response.replace(formatted_prompt, "").strip()
+        
+        # Generate time measurement
+        gen_time = time.time() - start_time
+        
+        # Add visualization for numerical comparisons
+        if "difference between" in prompt.lower() or "compare" in prompt.lower():
+            try:
+                # Extract numbers from prompt
+                numbers = [int(s) for s in prompt.split() if s.isdigit()]
+                if len(numbers) >= 2:
+                    labels = ['Today', 'Yesterday'] if 'today' in prompt.lower() else ['Value 1', 'Value 2']
+                    plt.figure(figsize=(6,4))
+                    plt.bar(labels, numbers, color=['blue', 'orange'])
+                    plt.title("Comparison Visualization")
+                    plt.ylabel("Count")
+                    
+                    # Save plot to bytes
+                    buf = BytesIO()
+                    plt.savefig(buf, format='png')
+                    buf.seek(0)
+                    img_str = base64.b64encode(buf.read()).decode('utf-8')
+                    plt.close()
+                    
+                    # Add image to response
+                    response += f"\n\n![Comparison Chart](data:image/png;base64,{img_str})"
+            except:
+                pass
+        
+        return f"{response}\n\n⏱️ Generated in {gen_time:.2f} seconds"
     
-    with gr.Row():
-        submit_btn = gr.Button("Get Answer", variant="primary")
+    except Exception as e:
+        return f"Error generating response: {str(e)}"
+
+# Example questions
+examples = [
+    "What is 2+2? Give answer step by step.",
+    "Sara bought 3 notebooks and two pens. Each notebook costs Rs.120 and each pen costs Rs.30. How much money did Sara spend in total?",
+    "Find the value of z in the equation z^2 + 16 - 30i = 0, where z is a complex number in the form a + bi.",
+    "If today a company makes 2000 sales and yesterday it made 1455 sales, what is the difference between them? Explain with a graph."
+]
+
+# Create Gradio interface
+with gr.Blocks(title="Step-by-Step Problem Solver") as demo:
+    gr.Markdown("# 📝 Step-by-Step Problem Solver")
+    gr.Markdown("Get detailed, step-by-step solutions to math, word, and complex problems.")
     
     with gr.Row():
-        answer = gr.Textbox(
-            label="Step-by-Step Answer",
-            lines=10,
-            interactive=False
-        )
+        input_prompt = gr.Textbox(label="Enter your problem", placeholder="Type your question here...", lines=3)
+        output_response = gr.Markdown(label="Step-by-Step Solution")
     
     with gr.Row():
-        graph = gr.Image(
-            label="Visualization",
-            visible=False
-        )
+        submit_btn = gr.Button("Generate Solution", variant="primary")
+        clear_btn = gr.Button("Clear")
     
-    # Pre-tested examples
-    gr.Examples(
-        examples=[
-            "What is 2+2?",
-            "Sara bought 3 notebooks and 2 pens. Each notebook costs Rs.120 and each pen costs Rs.30. How much did she spend?",
-            "Find z in z^2 + 16 - 30i = 0",
-            "Today sales: 2000, yesterday: 1455. What's the difference?"
-        ],
-        inputs=question
-    )
-    
-    def update_ui(result):
-        show_graph = result['graph'] is not None
-        return result['answer'], gr.update(visible=show_graph, value=result['graph'])
+    gr.Examples(examples=examples, inputs=input_prompt, label="Example Questions")
     
-    submit_btn.click(
-        fn=process_question,
-        inputs=question,
-        outputs={'answer': answer, 'graph': graph}
-    ).then(
-        fn=update_ui,
-        inputs=None,
-        outputs=[answer, graph]
-    )
+    submit_btn.click(fn=generate_response, inputs=input_prompt, outputs=output_response)
+    clear_btn.click(lambda: ("", ""), outputs=[input_prompt, output_response])
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0")
+    demo.launch(server_name="0.0.0.0", server_port=7860)