Upload app.py with huggingface_hub

app.py

@@ -1,68 +1,93 @@
 import gradio as gr
-import openai
 import time
 import os
 from typing import List, Dict
+from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
 
 class ChatbotHandler:
     def __init__(self):
-        self.client = None
-        self.model = "gpt-4o-mini"  # Using a cost-effective model
-        self.max_tokens = 500
+        self.model_name = "microsoft/DialoGPT-large"  # Large conversational model
+        self.tokenizer = None
+        self.model = None
+        self.chat_pipeline = None
+        self.max_length = 1000
         self.temperature = 0.7
         self.system_prompt = """You are a helpful, friendly, and knowledgeable AI assistant. 
         You provide clear, accurate, and thoughtful responses. You are engaging and try to be 
         helpful while being honest about your limitations. Always maintain a positive and 
         supportive tone in your conversations."""
         
-        # Initialize with API key from environment variable
-        api_key = os.getenv("OPENAI_API_KEY")
-        if api_key:
-            self.initialize_client(api_key)
+        # Initialize the model
+        self.initialize_model()
     
-    def initialize_client(self, api_key: str):
-        """Initialize the OpenAI client with the provided API key."""
+    def initialize_model(self):
+        """Initialize the Hugging Face model."""
         try:
-            self.client = openai.OpenAI(api_key=api_key)
+            print("Loading model... This may take a few minutes.")
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForCausalLM.from_pretrained(self.model_name)
+            
+            # Set pad token if not present
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
+            
+            # Create pipeline for text generation
+            self.chat_pipeline = pipeline(
+                "text-generation",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                device=0 if os.getenv("CUDA_VISIBLE_DEVICES") else -1,  # Use GPU if available
+                max_length=self.max_length,
+                temperature=self.temperature,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+            print("Model loaded successfully!")
             return True
         except Exception as e:
-            print(f"Error initializing OpenAI client: {str(e)}")
+            print(f"Error loading model: {str(e)}")
             return False
     
     def get_response(self, message: str, history: List[Dict]) -> str:
         """Get response from the model."""
-        if not self.client:
-            return "OpenAI API key not configured. Please contact the administrator."
+        if not self.chat_pipeline:
+            return "Model not loaded. Please try again later."
         
         try:
-            # Prepare conversation history
-            messages = [{"role": "system", "content": self.system_prompt}]
+            # Prepare conversation history as a single string
+            conversation = self.system_prompt + "\n"
             
-            # Add history (limit to last 10 messages to avoid context limit)
-            for msg in history[-10:]:
+            # Add recent history (limit to last 5 exchanges to avoid context limits)
+            for msg in history[-5:]:
                 if msg["role"] == "user":
-                    messages.append({"role": "user", "content": msg["content"]})
+                    conversation += f"User: {msg['content']}\n"
                 elif msg["role"] == "assistant":
-                    messages.append({"role": "assistant", "content": msg["content"]})
+                    conversation += f"Assistant: {msg['content']}\n"
             
             # Add current message
-            messages.append({"role": "user", "content": message})
+            conversation += f"User: {message}\nAssistant:"
             
-            # Get response from OpenAI
-            response = self.client.chat.completions.create(
-                model=self.model,
-                messages=messages,
-                max_tokens=self.max_tokens,
-                temperature=self.temperature,
-                stream=True
+            # Generate response
+            outputs = self.chat_pipeline(
+                conversation,
+                max_new_tokens=150,  # Limit response length
+                num_return_sequences=1,
+                return_full_text=False
             )
             
-            # Stream the response
-            full_response = ""
-            for chunk in response:
-                if chunk.choices[0].delta.content is not None:
-                    full_response += chunk.choices[0].delta.content
-                    yield full_response
+            response = outputs[0]['generated_text'].strip()
+            
+            # Clean up response (remove any unwanted prefixes)
+            if response.startswith("Assistant:"):
+                response = response[10:].strip()
+            
+            # Simulate streaming by yielding chunks
+            words = response.split()
+            current_response = ""
+            for word in words:
+                current_response += word + " "
+                yield current_response.strip()
+                time.sleep(0.05)  # Small delay for streaming effect
                     
         except Exception as e:
             yield f"Error generating response: {str(e)}"
@@ -75,8 +100,8 @@ def respond_stream(message: str, history: List[Dict]):
     if not message.strip():
         return "", history
     
-    # Check if API is initialized
-    if not chat_handler.client:
+    # Check if model is initialized
+    if not chat_handler.chat_pipeline:
         return "", history + [{"role": "assistant", "content": "The chatbot is not properly configured. Please try again later."}]
     
     # Add user message
@@ -97,30 +122,29 @@ def clear_history():
     """Clear the chat history."""
     return []
 
-def update_model_settings(model, temp, tokens):
+def update_model_settings(temp, max_len):
     """Update model settings."""
-    chat_handler.model = model
     chat_handler.temperature = temp
-    chat_handler.max_tokens = tokens
-    return f"Settings updated: {model}, temp={temp}, max_tokens={tokens}"
+    chat_handler.max_length = max_len
+    return f"Settings updated: temp={temp}, max_length={max_len}"
 
 # Create the interface
-with gr.Blocks(theme=gr.themes.Soft(), title="AI Chatbot with OpenAI") as demo:
+with gr.Blocks(theme=gr.themes.Soft(), title="AI Chatbot with DialoGPT") as demo:
     
     # Header
     gr.HTML("""
     <div style='text-align: center; padding: 20px;'>
         <h1>🤖 AI Chatbot</h1>
-        <p style='color: #666;'>Powered by OpenAI GPT-4o-mini • Built with <a href='https://huggingface.co/spaces/akhaliq/anycoder' target='_blank' style='color: #007bff; text-decoration: none;'>anycoder</a></p>
+        <p style='color: #666;'>Powered by DialoGPT-Large • Built with <a href='https://huggingface.co/spaces/akhaliq/anycoder' target='_blank' style='color: #007bff; text-decoration: none;'>anycoder</a></p>
     </div>
     """)
     
     # Status indicator
-    if chat_handler.client:
+    if chat_handler.chat_pipeline:
         status_msg = "✅ Chatbot is ready! Start chatting below."
         status_color = "#28a745"
     else:
-        status_msg = "❌ Chatbot configuration error. Please check API key."
+        status_msg = "❌ Model loading error. Please refresh the page."
         status_color = "#dc3545"
     
     gr.HTML(f"""
@@ -132,27 +156,21 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI Chatbot with OpenAI") as demo:
     # Model settings
     with gr.Accordion("Settings", open=False):
         with gr.Row():
-            model_choice = gr.Dropdown(
-                choices=["gpt-4o-mini", "gpt-4o", "gpt-4-turbo", "gpt-4"],
-                value="gpt-4o-mini",
-                label="Model",
-                info="Choose your preferred GPT model"
-            )
             temperature = gr.Slider(
-                minimum=0.0,
+                minimum=0.1,
                 maximum=2.0,
                 value=0.7,
                 step=0.1,
                 label="Temperature",
                 info="Higher values make responses more creative"
             )
-            max_tokens = gr.Slider(
-                minimum=100,
+            max_length = gr.Slider(
+                minimum=500,
                 maximum=2000,
-                value=500,
-                step=50,
-                label="Max Tokens",
-                info="Maximum length of response"
+                value=1000,
+                step=100,
+                label="Max Length",
+                info="Maximum context length"
             )
     
     # Chatbot component
@@ -198,7 +216,7 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI Chatbot with OpenAI") as demo:
     # Footer
     gr.HTML("""
     <div style='text-align: center; padding: 10px; color: #888; font-size: 0.9em;'>
-        <p>This chatbot uses OpenAI's GPT models. Usage may incur costs based on OpenAI's pricing.</p>
+        <p>This chatbot uses Microsoft's DialoGPT-Large model from Hugging Face. It's completely free to use!</p>
     </div>
     """)
     
@@ -220,25 +238,20 @@ with gr.Blocks(theme=gr.themes.Soft(), title="AI Chatbot with OpenAI") as demo:
     clear_btn.click(clear_history, outputs=chatbot)
     
     # Update model settings
-    model_choice.change(
-        update_model_settings,
-        inputs=[model_choice, temperature, max_tokens],
-        outputs=[]
-    )
     temperature.change(
         update_model_settings,
-        inputs=[model_choice, temperature, max_tokens],
+        inputs=[temperature, max_length],
         outputs=[]
     )
-    max_tokens.change(
+    max_length.change(
         update_model_settings,
-        inputs=[model_choice, temperature, max_tokens],
+        inputs=[temperature, max_length],
         outputs=[]
     )
     
     # Refresh settings (useful for debugging)
     refresh_btn.click(
-        lambda: f"Settings: {chat_handler.model}, temp={chat_handler.temperature}, max_tokens={chat_handler.max_tokens}",
+        lambda: f"Settings: temp={chat_handler.temperature}, max_length={chat_handler.max_length}",
         outputs=[]
     )