Update app.py

app.py

@@ -5,7 +5,6 @@ import matplotlib.pyplot as plt
 import numpy as np
 import re
 import sympy as sp
-from transformers import pipeline
 from io import BytesIO
 import base64
 
@@ -14,10 +13,15 @@ def solve_math(expression):
     """Bulletproof math solver using SymPy"""
     try:
         expr = sp.sympify(expression)
-        steps = sp.working(expr)
+        steps = []
+        if isinstance(expr, sp.Add):
+            steps.append(f"Addition: {expr.args[0]} + {expr.args[1]}")
+        elif isinstance(expr, sp.Mul):
+            steps.append(f"Multiplication: {expr.args[0]} × {expr.args[1]}")
+        steps.append(f"Final result: {expr.evalf()}")
         return {
             'answer': str(expr.evalf()),
-            'steps': steps if steps else [f"Direct evaluation: {expression} = {expr}"]
+            'steps': steps
         }
     except:
         return None
@@ -44,7 +48,6 @@ def create_graph(graph_type):
         
         plt.title(title)
         plt.grid(True)
-        
         buf = BytesIO()
         plt.savefig(buf, format='png')
         plt.close()
@@ -53,78 +56,77 @@ def create_graph(graph_type):
         return None
 
 # ===== AI SYSTEM =====
-class UltimateAISystem:
+class LocalAISystem:
     def __init__(self):
         self.device = 0 if torch.cuda.is_available() else -1
         self.dtype = torch.float16 if self.device == 0 else torch.float32
-        self.model = pipeline(
-            "text-generation",
-            model="mistralai/Mistral-7B-Instruct-v0.1",
-            device=self.device,
-            torch_dtype=self.dtype
-        )
-    
-    def generate_answer(self, prompt):
-        """Handle all question types with guaranteed response"""
-        start_time = time.time()
-        
-        # 1. Check for basic math
-        math_match = re.match(r"^(?:[Ww]hat is|Calculate|Solve) ([0-9\+\-\*\/\^\(\) ]+)\??$", prompt)
-        if math_match:
-            math_result = solve_math(math_match.group(1))
-            if math_result:
-                steps = "\n".join([f"• {step}" for step in math_result['steps']])
-                return {
-                    'answer': f"Answer: {math_result['answer']}\n\nSteps:\n{steps}",
-                    'graph': None,
-                    'time': time.time() - start_time
-                }
-        
-        # 2. Check for graph requests
-        graph_type = None
-        if any(kw in prompt.lower() for kw in ["graph", "plot", "chart"]):
-            if "linear" in prompt.lower():
-                graph_type = "linear"
-            elif "quadratic" in prompt.lower():
-                graph_type = "quadratic"
-            elif any(kw in prompt.lower() for kw in ["sin", "cos", "tan", "trig"]):
-                graph_type = "trigonometric"
+        try:
+            self.model = pipeline(
+                "text-generation",
+                model="facebook/opt-1.3b",  # Open-access model
+                device=self.device,
+                torch_dtype=self.dtype
+            )
+        except:
+            self.model = None
+
+    def generate_explanation(self, prompt):
+        """Local generation with fallback"""
+        if not self.model:
+            return "System is initializing..."
         
-        # 3. Generate AI response
         try:
             response = self.model(
-                f"""Provide a detailed step-by-step explanation. Include mathematical working where applicable.
-
-Question: {prompt}
-
-Answer in clear steps:
-1.""",
-                max_new_tokens=300,
-                temperature=0.3,
-                do_sample=True
+                f"Explain step-by-step: {prompt}",
+                max_new_tokens=200,
+                temperature=0.5
             )[0]['generated_text']
-            
-            answer = response.split("Answer in clear steps:")[-1].strip()
-            if not answer:
-                answer = "I couldn't generate a response. Please try again."
-            
-            # 4. Generate graph if requested
-            graph = create_graph(graph_type) if graph_type else None
-            
-            return {
-                'answer': f"Step-by-Step Explanation:\n\n{answer}",
-                'graph': graph,
-                'time': time.time() - start_time
-            }
+            return response.split(":")[-1].strip()
         except:
-            return {
-                'answer': "System error. Please try again.",
-                'graph': None,
-                'time': time.time() - start_time
-            }
+            return "Could not generate explanation."
 
-# Initialize system
-ai_system = UltimateAISystem()
+# Initialize systems
+ai_system = LocalAISystem()
+
+# ===== MAIN PROCESSING =====
+def process_query(prompt):
+    start_time = time.time()
+    
+    # 1. Handle empty input
+    if not prompt.strip():
+        return "Please enter a question", None
+    
+    # 2. Check for math
+    math_match = re.match(r"^(?:[Ww]hat is|Calculate|Solve) ([0-9\+\-\*\/\^\(\) ]+)\??$", prompt)
+    if math_match:
+        math_result = solve_math(math_match.group(1))
+        if math_result:
+            steps = "\n".join([f"• {step}" for step in math_result['steps']])
+            return f"Answer: {math_result['answer']}\n\nSteps:\n{steps}", None
+    
+    # 3. Check for graphs
+    graph_type = None
+    if any(kw in prompt.lower() for kw in ["graph", "plot", "chart"]):
+        if "linear" in prompt.lower():
+            graph_type = "linear"
+        elif "quadratic" in prompt.lower():
+            graph_type = "quadratic"
+        elif any(kw in prompt.lower() for kw in ["sin", "cos", "tan", "trig"]):
+            graph_type = "trigonometric"
+    
+    # 4. Generate response
+    response = ai_system.generate_explanation(prompt)
+    graph = create_graph(graph_type) if graph_type else None
+    
+    # Format output
+    gen_time = time.time() - start_time
+    formatted_response = f"""📝 Step-by-Step Explanation:
+
+{response}
+
+⏱️ Generated in {gen_time:.2f} seconds"""
+    
+    return formatted_response, graph
 
 # ===== GRADIO INTERFACE =====
 with gr.Blocks(theme=gr.themes.Soft(), title="🧠 Ultimate AI Assistant") as demo:
@@ -132,8 +134,8 @@ with gr.Blocks(theme=gr.themes.Soft(), title="🧠 Ultimate AI Assistant") as de
     
     with gr.Row():
         question = gr.Textbox(
-            label="Ask anything",
-            placeholder="E.g. 'What is 2+2?' or 'Explain quantum physics with a graph'",
+            label="Your Question",
+            placeholder="Try: 'What is 2+2?' or 'Show a quadratic graph'",
             lines=3
         )
     
@@ -157,25 +159,24 @@ with gr.Blocks(theme=gr.themes.Soft(), title="🧠 Ultimate AI Assistant") as de
     gr.Examples(
         examples=[
             "What is (15*3)+(40/2)?",
-            "Explain the photoelectric effect with a graph",
-            "Solve x² - 5x + 6 = 0 step by step",
-            "Show a trigonometric function plot"
+            "Explain linear relationships with a graph",
+            "Solve 3x + 5 = 20 step by step"
         ],
         inputs=question
     )
     
-    def process_question(prompt):
-        result = ai_system.generate_answer(prompt)
-        show_graph = result['graph'] is not None
-        output_text = f"""{result['answer']}
-
-⏱️ Generated in {result['time']:.2f} seconds"""
-        return output_text, gr.update(visible=show_graph, value=result['graph'])
+    def update_ui(response, img):
+        show_graph = img is not None
+        return response, gr.update(visible=show_graph, value=img)
     
     submit_btn.click(
-        fn=process_question,
+        fn=process_query,
         inputs=question,
         outputs=[answer, graph]
+    ).then(
+        fn=update_ui,
+        inputs=[answer, graph],
+        outputs=[answer, graph]
     )
 
 if __name__ == "__main__":