Update app.py

app.py

@@ -1,179 +1,139 @@
 from transformers import pipeline, AutoTokenizer
 import gradio as gr
 import torch
-import os
 import time
-from functools import lru_cache
+import os
 
 # ===== BULLETPROOF INITIALIZATION =====
-def get_device_config():
-    """Automatically configure the best available device"""
-    try:
-        if torch.cuda.is_available():
-            torch.backends.cudnn.benchmark = True
-            return 0, torch.float16  # GPU with half precision
-        return -1, torch.float32  # CPU fallback
-    except:
-        return -1, torch.float32  # Ultimate fallback
-
-device, dtype = get_device_config()
-device_name = "GPU" if device == 0 else "CPU"
-
-# ===== MODEL LOADING WITH MULTI-LAYER ERROR PROTECTION =====
-@lru_cache(maxsize=1)  # Cache loaded model
-def load_model():
-    """Triple-protected model loading"""
-    model_name = "mistralai/Mistral-7B-v0.1"  # Default open model
+def initialize_model():
+    """Safe model loading with multiple fallbacks"""
+    device = 0 if torch.cuda.is_available() else -1
+    dtype = torch.float16 if device == 0 else torch.float32
     
-    # Attempt authenticated model if token exists
-    if os.environ.get("HF_TOKEN"):
-        try:
-            from huggingface_hub import login
-            login(token=os.environ.get("HF_TOKEN"))
-            model_name = "google/gemma-2b-it"
-        except:
-            pass  # Silently fallback to open model
+    models_to_try = [
+        "mistralai/Mistral-7B-v0.1",  # Open-access
+        "google/gemma-2b-it"           # Gated (will fail without auth)
+    ]
     
-    try:
-        # First try optimized loading
-        tokenizer = AutoTokenizer.from_pretrained(model_name)
-        model = pipeline(
-            "text-generation",
-            model=model_name,
-            tokenizer=tokenizer,
-            device=device,
-            torch_dtype=dtype,
-            model_kwargs={
-                "low_cpu_mem_usage": True,
-                "trust_remote_code": False  # Safer option
-            }
-        )
-        
-        # Warm-up with timeout protection
+    for model_name in models_to_try:
         try:
-            with time.timeout(5):  # Prevent infinite hangs
-                model("Warmup", max_new_tokens=1)
-        except:
-            pass
-            
-        return model
-    except Exception as e:
-        # Final fallback to tiny model
-        return pipeline(
-            "text-generation",
-            model="gpt2",
-            device=device,
-            torch_dtype=dtype
-        )
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            model = pipeline(
+                "text-generation",
+                model=model_name,
+                tokenizer=tokenizer,
+                device=device,
+                torch_dtype=dtype,
+                model_kwargs={"low_cpu_mem_usage": True}
+            )
+            # Warm-up
+            model("Warmup", max_new_tokens=1)
+            print(f"✅ Loaded {model_name} on {'GPU' if device == 0 else 'CPU'}")
+            return model, tokenizer
+        except Exception as e:
+            print(f"⚠️ Failed {model_name}: {str(e)}")
+            continue
+    
+    raise RuntimeError("Could not load any model")
 
-model = load_model()
+# ===== SAFE EXECUTION =====
+try:
+    model, tokenizer = initialize_model()
+except Exception as e:
+    model = None
+    print(f"🔴 Critical failure: {str(e)}")
 
-# ===== ULTRA-RELIABLE GENERATION =====
-def generate_with_explanation(prompt):
-    """Quadruple-protected generation"""
-    start_time = time.time()
+# ===== ENHANCED GENERATION =====
+def generate_response(prompt):
+    """Full error-proof generation with metrics"""
+    if model is None:
+        return "System offline - please check server logs"
     
     try:
-        # Enhanced prompt engineering
-        enhanced_prompt = f"""Provide a detailed step-by-step explanation:
+        start_time = time.time()
+        
+        # Enhanced prompt for step-by-step answers
+        full_prompt = f"""Provide a detailed, step-by-step explanation:
 
 Question: {prompt}
 
-Answer in bullet points:
--"""
+Answer in clear steps:"""
         
-        # Generation with multiple fallbacks
-        try:
-            output = model(
-                enhanced_prompt,
-                max_new_tokens=100,
-                temperature=0.3,
-                top_k=40,
-                do_sample=False,
-                pad_token_id=model.tokenizer.eos_token_id if hasattr(model, 'tokenizer') else 50256
-            )
-            response = output[0]['generated_text'].split("Answer in bullet points:")[-1].strip()
-        except:
-            # Simplified fallback
-            output = model(prompt, max_new_tokens=80)
-            response = output[0]['generated_text']
+        output = model(
+            full_prompt,
+            max_new_tokens=150,
+            temperature=0.4,
+            top_k=40,
+            do_sample=True,
+            pad_token_id=tokenizer.eos_token_id
+        )
         
-        # Formatting protection
-        try:
-            if "- " not in response:  # Ensure bullet points
-                response = "- " + response.replace("\n", "\n- ")
-        except:
-            pass
-            
+        # Extract and format response
+        response = output[0]['generated_text'].split("Answer in clear steps:")[-1]
+        response = response.strip().replace("\n\n", "\n• ")
+        
+        # Performance metrics
         gen_time = time.time() - start_time
-        return f"""📝 Explanation:
-
-{response}
-
-⏱️ Generated in {gen_time:.2f}s | Using {device_name}"""
+        speed = len(response.split()) / gen_time
         
+        return f"""📝 Step-by-Step Explanation:
+        
+• {response}
+
+⏱️ Generated in {gen_time:.2f}s ({speed:.1f} words/sec)"""
+    
     except Exception as e:
-        return f"""🛡️ System Protected: The AI encountered an error but recovered.
-Please try rephrasing your question. Technical details: {str(e)}"""
+        return f"⚠️ Generation error: {str(e)}"
 
-# ===== INDUSTRIAL-STRENGTH INTERFACE =====
-with gr.Blocks(theme=gr.themes.Soft(), title="🔒 Bulletproof AI Tutor") as demo:
+# ===== COMPLETE UI =====
+with gr.Blocks(theme=gr.themes.Soft(), title="🧠 AI Expert Assistant") as demo:
     # Header
-    gr.Markdown("""<h1><center>Ultra-Reliable Step-by-Step Tutor</center></h1>""")
+    gr.Markdown("""<h1><center>Step-by-Step Problem Solver</center></h1>""")
     
     # Input Section
     with gr.Row():
-        input_box = gr.Textbox(
-            label="Ask anything",
-            placeholder="Explain quantum physics like I'm 5...",
-            lines=3,
-            max_lines=5
+        user_input = gr.Textbox(
+            label="Your Question",
+            placeholder="Explain quantum computing basics step by step...",
+            lines=3
         )
     
     # Control Panel
     with gr.Row():
-        submit_btn = gr.Button("Generate", variant="primary")
+        submit_btn = gr.Button("Generate Explanation", variant="primary")
         clear_btn = gr.Button("Clear")
     
     # Output Section
     with gr.Row():
         output_box = gr.Textbox(
-            label="Step-by-Step Explanation",
-            lines=8,
+            label="Detailed Explanation",
+            lines=10,
             interactive=False
         )
     
     # Examples
     gr.Examples(
         examples=[
-            "Explain how neural networks work step by step",
-            "Solve 2x + 5 = 15 showing each step",
-            "Describe photosynthesis in simple terms"
+            "Explain how photosynthesis works in plants",
+            "Solve 3x + 7 = 22 showing all steps",
+            "Describe the water cycle with bullet points"
         ],
-        inputs=input_box
+        inputs=user_input
     )
     
-    # Event Handlers with Error Protection
-    def safe_generate(prompt):
-        try:
-            return generate_with_explanation(prompt)
-        except:
-            return "🛡️ System Protected: Please try again or rephrase your question"
-    
+    # Event Handlers
     submit_btn.click(
-        fn=safe_generate,
-        inputs=input_box,
-        outputs=output_box,
-        api_name="generate"
+        fn=generate_response,
+        inputs=user_input,
+        outputs=output_box
     )
-    
     clear_btn.click(
         fn=lambda: ("", ""),
         inputs=None,
-        outputs=[input_box, output_box]
+        outputs=[user_input, output_box]
     )
 
-# ===== NUCLEAR-PROOF LAUNCH =====
+# ===== FAILSAFE LAUNCH =====
 if __name__ == "__main__":
     try:
         demo.launch(
@@ -182,6 +142,6 @@ if __name__ == "__main__":
             show_error=True
         )
     except Exception as e:
-        print(f"🚨 Critical error: {str(e)}")
+        print(f"🚨 Server crashed: {str(e)}")
         print("Attempting to restart...")
-        demo.launch(server_name="0.0.0.0", share=True)
+        demo.launch(share=True)