Implement response generation and chat interface for DialoGPT model; update Gradio version in requirements

app.py

@@ -24,15 +24,178 @@ except Exception as e:
     model = None
     tokenizer = None
 
+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."
+    
+    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
+
+def clear_chat():
+    """Clear chat history"""
+    return [], []
+
+# Example conversation starters
+example_questions = [
+    "Hello! How are you today?",
+    "What can you help me with?",
+    "Tell me about artificial intelligence",
+    "What's your favorite programming language?",
+    "Can you explain machine learning?",
+    "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"
+) as demo:
+    
+    gr.Markdown("# 💬 GihonTech AI Conversation Assistant")
+    gr.Markdown("Chat with an AI powered by Microsoft's DialoGPT-medium model")
+    
+    with gr.Row():
+        with gr.Column(scale=3):
+            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
+                )
+                submit_btn = gr.Button("Send", variant="primary", scale=1)
+            
+            with gr.Row():
+                clear_btn = 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("---")
+            gr.Markdown("### 🔧 Model Information")
+            
+            model_status = "✅ Loaded" if model is not None else "❌ Failed"
+            gr.Textbox(
+                value=f"DialoGPT-medium: {model_status}",
+                label="Model Status",
+                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]
+    )
+
+# Alternative simple version using the older ChatInterface format
+# Uncomment below if you prefer the simpler interface
+
+"""
 def respond(message, chat_history):
-    """Respond to user message using DialoGPT"""
     if model is None or tokenizer is None:
         return "Model not loaded. Please try again later."
     
     # Build conversation history
     conversation = ""
-    for turn in chat_history:
-        conversation += f"User: {turn[0]}\nBot: {turn[1]}\n"
+    for user, bot in chat_history:
+        conversation += f"User: {user}\nBot: {bot}\n"
     
     conversation += f"User: {message}\nBot:"
     
@@ -54,33 +217,49 @@ def respond(message, chat_history):
     response = tokenizer.decode(outputs[0], skip_special_tokens=True)
     response = response.split("Bot:")[-1].strip()
     
-    # Clean response
     if "\nUser:" in response:
         response = response.split("\nUser:")[0]
     
     chat_history.append((message, response))
-    return "", chat_history
+    return chat_history
 
-# Create the chat interface
+# Simple ChatInterface version
 demo = gr.ChatInterface(
-    fn=respond,
+    respond,
     title="💬 GihonTech AI Conversation Assistant",
-    description="Chat with an AI powered by Microsoft's DialoGPT-medium model",
-    examples=[
-        "Hello! How are you today?",
-        "What can you help me with?",
-        "Tell me about artificial intelligence",
-        "What's your favorite programming language?",
-    ],
-    cache_examples=False,
-    retry_btn=None,
-    undo_btn="↩️ Undo",
-    clear_btn="🗑️ Clear"
+    description="Chat with an AI powered by Microsoft's DialoGPT-medium model"
 )
+"""
+
+# 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}")
+
+# Run test if model is loaded
+if model is not None:
+    test_model()
 
 if __name__ == "__main__":
     demo.launch(
         server_name="0.0.0.0",
         server_port=7860,
-        share=False
+        share=False,
+        show_error=True
     )

requirements.txt

@@ -1,4 +1,4 @@
 torch>=2.0.0
 transformers>=4.30.0
-gradio>=4.0.0
+gradio>=3.50.0
 accelerate>=0.20.0