Update app.py

app.py

@@ -3,137 +3,137 @@ import torch
 import time
 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
-from transformers import pipeline
 
-# ===== FAILSAFE SYSTEM =====
-class RobustAISystem:
+# ===== MATH ENGINE =====
+def solve_math(expression):
+    """Bulletproof math solver using SymPy"""
+    try:
+        expr = sp.sympify(expression)
+        steps = sp.working(expr)
+        return {
+            'answer': str(expr.evalf()),
+            'steps': steps if steps else [f"Direct evaluation: {expression} = {expr}"]
+        }
+    except:
+        return None
+
+# ===== GRAPH ENGINE =====
+def create_graph(graph_type):
+    """Guaranteed graph generation"""
+    try:
+        plt.figure(figsize=(8,4))
+        x = np.linspace(-10, 10, 100)
+        
+        if graph_type == "linear":
+            y = 2*x + 3
+            plt.plot(x, y)
+            title = "Linear Graph: y = 2x + 3"
+        elif graph_type == "quadratic":
+            y = x**2 - 4
+            plt.plot(x, y)
+            title = "Quadratic Graph: y = x² - 4"
+        elif graph_type == "trigonometric":
+            y = np.sin(x)
+            plt.plot(x, y)
+            title = "Trigonometric Graph: y = sin(x)"
+        
+        plt.title(title)
+        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
+
+# ===== AI SYSTEM =====
+class UltimateAISystem:
     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 = None
-        self.load_model()
-
-    def load_model(self):
-        """Ultra-reliable model loading"""
-        try:
-            self.model = pipeline(
-                "text-generation",
-                model="mistralai/Mistral-7B-v0.1",  # Always works
-                device=self.device,
-                torch_dtype=self.dtype
-            )
-            # Verify working
-            test = self.generate("Test", simple=True)
-            if not test.strip():
-                raise RuntimeError("Blank response")
-        except Exception as e:
-            print(f"Model load failed: {str(e)}")
-            self.model = None
-
-    def generate(self, prompt, simple=False):
-        """Guaranteed to return a response"""
-        if not self.model:
-            return "System is initializing... Please wait"
+        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"
         
+        # 3. Generate AI response
         try:
-            full_prompt = prompt if simple else f"""
-            Provide a detailed, step-by-step answer. If the question involves data or relationships, 
-            describe what kind of graph would best represent it.
+            response = self.model(
+                f"""Provide a detailed step-by-step explanation. Include mathematical working where applicable.
 
-            Question: {prompt}
+Question: {prompt}
 
-            Answer:
-            1."""
-            
-            output = self.model(
-                full_prompt,
+Answer in clear steps:
+1.""",
                 max_new_tokens=300,
-                temperature=0.7,
-                do_sample=True,
-                pad_token_id=self.model.tokenizer.eos_token_id
+                temperature=0.3,
+                do_sample=True
             )[0]['generated_text']
             
-            return output.split("Answer:")[-1].strip() or "I couldn't generate a response. Please try again."
-        except Exception:
-            return "Error generating response. Please rephrase your question."
-
-    def create_graph(self, graph_type):
-        """Always returns a graph image"""
-        try:
-            plt.figure(figsize=(8,4))
-            x = np.linspace(0, 10, 50)
-            
-            if graph_type == "linear":
-                y = x
-                plt.plot(x, y, 'b-')
-                plt.title("Linear Relationship (y = x)")
-            elif graph_type == "quadratic":
-                y = x**2
-                plt.plot(x, y, 'r-')
-                plt.title("Quadratic Relationship (y = x²)")
-            else:  # Default case
-                y = np.sin(x)
-                plt.plot(x, y, 'g-')
-                plt.title("Periodic Relationship (y = sin(x))")
+            answer = response.split("Answer in clear steps:")[-1].strip()
+            if not answer:
+                answer = "I couldn't generate a response. Please try again."
             
-            plt.xlabel("X-axis")
-            plt.ylabel("Y-axis")
-            plt.grid(True)
+            # 4. Generate graph if requested
+            graph = create_graph(graph_type) if graph_type else None
             
-            buf = BytesIO()
-            plt.savefig(buf, format='png', dpi=100)
-            plt.close()
-            return base64.b64encode(buf.getvalue()).decode('utf-8')
-        except Exception:
-            return None
+            return {
+                'answer': f"Step-by-Step Explanation:\n\n{answer}",
+                'graph': graph,
+                'time': time.time() - start_time
+            }
+        except:
+            return {
+                'answer': "System error. Please try again.",
+                'graph': None,
+                'time': time.time() - start_time
+            }
 
-# Initialize with retries
-ai_system = None
-for _ in range(3):  # Try 3 times
-    try:
-        ai_system = RobustAISystem()
-        if ai_system.model:
-            break
-    except Exception as e:
-        print(f"Initialization attempt failed: {str(e)}")
-    time.sleep(2)
+# Initialize system
+ai_system = UltimateAISystem()
 
 # ===== GRADIO INTERFACE =====
-def process_request(prompt):
-    start_time = time.time()
-    
-    if not prompt.strip():
-        return "Please enter a question", None
-    
-    # Generate response
-    response = ai_system.generate(prompt) if ai_system else "System starting up... Try again in 30 seconds"
-    
-    # Check for graph-related keywords
-    graph_img = None
-    graph_triggers = ["graph", "plot", "chart", "visualize", "diagram"]
-    if any(keyword in prompt.lower() for keyword in graph_triggers):
-        graph_type = "quadratic" if "quadratic" in prompt.lower() else "linear"
-        graph_b64 = ai_system.create_graph(graph_type) if ai_system else None
-        if graph_b64:
-            graph_img = f"data:image/png;base64,{graph_b64}"
-    
-    # Format output
-    gen_time = time.time() - start_time
-    formatted_response = f"""{response}
-
-⏱️ Generated in {gen_time:.2f} seconds"""
-    
-    return formatted_response, graph_img
-
-with gr.Blocks(theme=gr.themes.Default(), title="🔍 AI Assistant") as demo:
-    gr.Markdown("""<h1><center>Intelligent Q&A with Visualizations</center></h1>""")
+with gr.Blocks(theme=gr.themes.Soft(), title="🧠 Ultimate AI Assistant") as demo:
+    gr.Markdown("""<h1><center>Math + Graphs + Explanations</center></h1>""")
     
     with gr.Row():
         question = gr.Textbox(
-            label="Your Question",
-            placeholder="Ask anything... (e.g. 'Explain photosynthesis and show a linear graph')",
+            label="Ask anything",
+            placeholder="E.g. 'What is 2+2?' or 'Explain quantum physics with a graph'",
             lines=3
         )
     
@@ -142,45 +142,44 @@ with gr.Blocks(theme=gr.themes.Default(), title="🔍 AI Assistant") as demo:
     
     with gr.Row():
         answer = gr.Textbox(
-            label="Detailed Explanation",
+            label="Detailed Answer",
             lines=10,
             interactive=False
         )
     
     with gr.Row():
         graph = gr.Image(
-            label="Relevant Graph",
+            label="Generated Visualization",
             visible=False
         )
     
     # Pre-tested examples
     gr.Examples(
         examples=[
-            "Explain the relationship between force and acceleration with a graph",
-            "Show a quadratic graph and explain its applications",
-            "Describe population growth with a visual diagram"
+            "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"
         ],
         inputs=question
     )
     
-    def update_outputs(response, img):
-        show_graph = img is not None
-        return response, gr.update(visible=show_graph, value=img)
+    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'])
     
     submit_btn.click(
-        fn=process_request,
+        fn=process_question,
         inputs=question,
         outputs=[answer, graph]
-    ).then(
-        fn=update_outputs,
-        inputs=[answer, graph],
-        outputs=[answer, graph]
     )
 
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
-        server_port=7860,
-        show_error=True
-    )
-    
+        server_port=7860
+    )