olala

app.py

@@ -1,96 +1,68 @@
 import gradio as gr
 import torch
 from transformers import AutoTokenizer, AutoModelForCausalLM
+from fastapi import FastAPI, Request
 
-# Initialize model and tokenizer
-model = None
-tokenizer = None
+# -------------------------------------------------
+# 1. Load model (same as your old code)
+# -------------------------------------------------
+print("Initializing DialoGPT-medium model...")
+model_name = "microsoft/DialoGPT-medium"
+tokenizer = AutoTokenizer.from_pretrained(model_name)
+model = AutoModelForCausalLM.from_pretrained(model_name)
 
-print("🚀 Initializing DialoGPT-medium model...")
+if tokenizer.pad_token is None:
+    tokenizer.pad_token = tokenizer.eos_token
 
-try:
-    print("📥 Loading DialoGPT-medium model...")
-    model_name = "microsoft/DialoGPT-medium"
-    tokenizer = AutoTokenizer.from_pretrained(model_name)
-    model = AutoModelForCausalLM.from_pretrained(model_name)
-    print("✅ DialoGPT-medium model loaded successfully!")
-    
-    # Add padding token if it doesn't exist
-    if tokenizer.pad_token is None:
-        tokenizer.pad_token = tokenizer.eos_token
-    
-except Exception as e:
-    print(f"❌ Failed to load DialoGPT-medium model: {e}")
-    model = None
-    tokenizer = None
+print("DialoGPT-medium loaded!")
 
-def generate_response(message, chat_history):
-    """Generate response using DialoGPT model"""
-    if model is None or tokenizer is None:
-        return "Model not loaded. Please try again later."
-    
+# -------------------------------------------------
+# 2. Generation helper (your old logic, cleaned up)
+# -------------------------------------------------
+def generate_response(message: str, chat_history: list):
     if not message.strip():
         return "Please enter a message."
-    
-    try:
-        # Format the conversation history for the model
-        conversation_history = ""
-        for user_msg, bot_msg in chat_history:
-            conversation_history += f"User: {user_msg}\nBot: {bot_msg}\n"
-        
-        # Add current user message
-        conversation_history += f"User: {message}\nBot:"
-        
-        # Encode the input
-        inputs = tokenizer.encode(conversation_history, return_tensors='pt', max_length=1024, truncation=True)
-        
-        # Generate response
-        with torch.no_grad():
-            outputs = model.generate(
-                inputs,
-                max_length=len(inputs[0]) + 128,  # Generate up to 128 new tokens
-                pad_token_id=tokenizer.eos_token_id,
-                do_sample=True,
-                temperature=0.7,
-                top_k=50,
-                top_p=0.95,
-                repetition_penalty=1.2,
-                num_return_sequences=1
-            )
-        
-        # Decode the response
-        response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-        
-        # Extract only the new response (remove the input)
-        response = response.split("Bot:")[-1].strip()
-        
-        # Clean up any extra text after the first complete response
-        if "\nUser:" in response:
-            response = response.split("\nUser:")[0]
-        
-        return response
-        
-    except Exception as e:
-        print(f"Error generating response: {e}")
-        return f"I encountered an error: {str(e)[:100]}"
 
-def chat_interface(message, history):
-    """Interface function for Gradio chat"""
-    history = history or []
-    
-    # Get bot response
-    response = generate_response(message, history)
-    
-    # Append to history
-    history.append((message, response))
-    
-    return "", history
+    # Build conversation string
+    conv = ""
+    for user, bot in chat_history:
+        conv += f"User: {user}\nBot: {bot}\n"
+    conv += f"User: {message}\nBot:"
+
+    # Encode
+    inputs = tokenizer.encode(conv, return_tensors="pt", max_length=1024, truncation=True)
+
+    # Generate
+    with torch.no_grad():
+        outputs = model.generate(
+            inputs,
+            max_length=inputs.shape[1] + 128,
+            pad_token_id=tokenizer.eos_token_id,
+            do_sample=True,
+            temperature=0.7,
+            top_k=50,
+            top_p=0.95,
+            repetition_penalty=1.2,
+        )
 
-def clear_chat():
-    """Clear chat history"""
-    return [], []
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    response = response.split("Bot:")[-1].strip()
+    if "\nUser:" in response:
+        response = response.split("\nUser:")[0]
+
+    return response
 
-# Example conversation starters
+# -------------------------------------------------
+# 3. Gradio chat function (used by /run/predict)
+# -------------------------------------------------
+def chat_fn(message: str, history: list):
+    response = generate_response(message, history or [])
+    history.append((message, response))
+    return "", history   # clear textbox, update chat
+
+# -------------------------------------------------
+# 4. Build the UI (your Blocks layout)
+# -------------------------------------------------
 example_questions = [
     "Hello! How are you today?",
     "What can you help me with?",
@@ -100,166 +72,82 @@ example_questions = [
     "How does a neural network work?"
 ]
 
-# Create Gradio interface using Blocks (more compatible)
 with gr.Blocks(
-    theme=gr.themes.Soft(
-        primary_hue="blue",
-        secondary_hue="green"
-    ),
-    title="💬 GihonTech - AI Conversation Assistant"
+    theme=gr.themes.Soft(primary_hue="blue", secondary_hue="green"),
+    title="GihonTech - AI Conversation Assistant"
 ) as demo:
-    
-    gr.Markdown("# 💬 GihonTech AI Conversation Assistant")
-    gr.Markdown("Chat with an AI powered by Microsoft's DialoGPT-medium model")
-    
+
+    gr.Markdown("# GihonTech AI Conversation Assistant")
+    gr.Markdown("Chat with an AI powered by **DialoGPT-medium**")
+
     with gr.Row():
         with gr.Column(scale=3):
-            chatbot = gr.Chatbot(
-                label="Conversation",
-                height=500
-            )
-            
+            chatbot = gr.Chatbot(label="Conversation", height=500)
+
             with gr.Row():
                 msg = gr.Textbox(
                     label="Your Message",
                     placeholder="Type your message here...",
                     lines=2,
-                    scale=4
+                    scale=4,
                 )
-                submit_btn = gr.Button("Send", variant="primary", scale=1)
-            
-            with gr.Row():
-                clear_btn = gr.Button("Clear Chat", variant="secondary")
-        
+                send = gr.Button("Send", variant="primary", scale=1)
+
+            clear = gr.Button("Clear Chat", variant="secondary")
+
         with gr.Column(scale=1):
-            gr.Markdown("### 💡 Example Questions")
-            
-            for example in example_questions:
-                gr.Button(
-                    example[:40] + "..." if len(example) > 40 else example,
-                    size="sm"
-                ).click(
-                    lambda x=example: x,
-                    outputs=msg
+            gr.Markdown("### Example Questions")
+            for q in example_questions:
+                gr.Button(q[:40] + ("..." if len(q) > 40 else ""), size="sm").click(
+                    lambda x=q: x, outputs=msg
                 )
-            
             gr.Markdown("---")
-            gr.Markdown("### 🔧 Model Information")
-            
-            model_status = "✅ Loaded" if model is not None else "❌ Failed"
+            gr.Markdown("### Model Info")
             gr.Textbox(
-                value=f"DialoGPT-medium: {model_status}",
+                value="DialoGPT-medium: Loaded",
                 label="Model Status",
-                interactive=False
+                interactive=False,
             )
-            
-            gr.Markdown("""
-            **Features:**
-            - Conversational AI using Microsoft DialoGPT-medium
-            - Context-aware responses
-            - Natural conversation flow
-            - Memory of conversation history
-            
-            **Tips:**
-            - Ask clear, specific questions
-            - The AI remembers conversation context
-            - Use the clear button to start fresh
-            """)
-    
-    # Event handlers
-    submit_btn.click(
-        chat_interface,
-        inputs=[msg, chatbot],
-        outputs=[msg, chatbot]
-    )
-    
-    msg.submit(
-        chat_interface,
-        inputs=[msg, chatbot],
-        outputs=[msg, chatbot]
-    )
-    
-    clear_btn.click(
-        clear_chat,
-        outputs=[chatbot, msg]
-    )
+            gr.Markdown(
+                """
+                **Features**  
+                - Context-aware replies  
+                - Conversation memory  
 
-# Alternative simple version using the older ChatInterface format
-# Uncomment below if you prefer the simpler interface
+                **Tips**  
+                - Ask clear questions  
+                - Use *Clear Chat* to start over
+                """
+            )
 
-"""
-def respond(message, chat_history):
-    if model is None or tokenizer is None:
-        return "Model not loaded. Please try again later."
-    
-    # Build conversation history
-    conversation = ""
-    for user, bot in chat_history:
-        conversation += f"User: {user}\nBot: {bot}\n"
-    
-    conversation += f"User: {message}\nBot:"
-    
-    # Encode and generate
-    inputs = tokenizer.encode(conversation, return_tensors='pt', max_length=1024, truncation=True)
-    
-    with torch.no_grad():
-        outputs = model.generate(
-            inputs,
-            max_length=len(inputs[0]) + 128,
-            pad_token_id=tokenizer.eos_token_id,
-            do_sample=True,
-            temperature=0.7,
-            top_k=50,
-            top_p=0.95,
-            repetition_penalty=1.2
-        )
-    
-    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
-    response = response.split("Bot:")[-1].strip()
-    
-    if "\nUser:" in response:
-        response = response.split("\nUser:")[0]
-    
-    chat_history.append((message, response))
-    return chat_history
+    # Event wiring
+    send.click(chat_fn, inputs=[msg, chatbot], outputs=[msg, chatbot])
+    msg.submit(chat_fn, inputs=[msg, chatbot], outputs=[msg, chatbot])
+    clear.click(lambda: ([], ""), outputs=[chatbot, msg])
 
-# Simple ChatInterface version
-demo = gr.ChatInterface(
-    respond,
-    title="💬 GihonTech AI Conversation Assistant",
-    description="Chat with an AI powered by Microsoft's DialoGPT-medium model"
-)
-"""
+# -------------------------------------------------
+# 5. OPTIONAL: expose /lambda (same JSON format)
+# -------------------------------------------------
+fastapi_app = FastAPI()
 
-# Test the model on startup
-def test_model():
-    if model is None:
-        print("❌ No model available for testing")
-        return
-    
-    print("🧪 Testing DialoGPT model...")
-    
-    test_messages = [
-        "Hello, how are you?",
-        "What is artificial intelligence?",
-        "Can you tell me a joke?"
-    ]
-    
-    for message in test_messages:
-        try:
-            response = generate_response(message, [])
-            print(f"✅ Test: '{message}' → '{response}'")
-        except Exception as e:
-            print(f"❌ Test failed for '{message}': {e}")
+@fastapi_app.post("/lambda")
+async def lambda_endpoint(req: Request):
+    payload = await req.json()
+    # Gradio sends {"data": [...]} ; we accept anything
+    user_msg = payload.get("data", [""])[0]
+    # Use the same generation logic (no history for this endpoint)
+    resp = generate_response(user_msg, [])
+    return {"data": [resp]}
 
-# Run test if model is loaded
-if model is not None:
-    test_model()
+demo.mount_app(fastapi_app)   # makes /lambda reachable
 
+# -------------------------------------------------
+# 6. Launch with queue (critical for API!)
+# -------------------------------------------------
 if __name__ == "__main__":
-    demo.launch(
+    demo.queue().launch(
         server_name="0.0.0.0",
         server_port=7860,
         share=False,
-        show_error=True
+        show_error=True,
     )