app updated

app.py

@@ -1,92 +1,135 @@
-from transformers import AutoModelForCausalLM, AutoTokenizer
+import psutil
 import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
 import gradio as gr
+import os
+from typing import List, Tuple
 
 class CustomerSupportBot:
     def __init__(self, model_path="models/customer_support_gpt"):
-        """
-        Initialize the customer support bot with the fine-tuned model.
-        
-        Args:
-            model_path (str): Path to the saved model and tokenizer
-        """
+        self.process = psutil.Process(os.getpid())
         self.tokenizer = AutoTokenizer.from_pretrained(model_path)
         self.model = AutoModelForCausalLM.from_pretrained(model_path)
-        
-        # Move model to GPU if available
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
         self.model = self.model.to(self.device)
-        
-    def generate_response(self, instruction, max_length=100, temperature=0.7):
-        """
-        Generate a response for a given customer support instruction/query.
-        
-        Args:
-            instruction (str): Customer's query or instruction
-            max_length (int): Maximum length of the generated response
-            temperature (float): Controls randomness in generation (higher = more random)
+
+    def generate_response(self, message: str) -> str:
+        try:
+            input_text = f"Instruction: {message}\nResponse:"
+            inputs = self.tokenizer(input_text, return_tensors="pt").to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    **inputs,
+                    max_length=50,
+                    temperature=0.7,
+                    num_return_sequences=1,
+                    pad_token_id=self.tokenizer.pad_token_id,
+                    eos_token_id=self.tokenizer.eos_token_id,
+                    do_sample=True,
+                    top_p=0.95,
+                    top_k=50
+                )
             
-        Returns:
-            str: Generated response
-        """
-        # Format input text the same way as during training
-        input_text = f"Instruction: {instruction}\nResponse:"
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            return response.split("Response:")[-1].strip()
+        except Exception as e:
+            return f"An error occurred: {str(e)}"
+
+    def monitor_resources(self) -> dict:
+        usage = {
+            "CPU (%)": self.process.cpu_percent(interval=1),
+            "RAM (GB)": self.process.memory_info().rss / (1024 ** 3)
+        }
+        if torch.cuda.is_available():
+            usage["GPU (GB)"] = torch.cuda.memory_allocated(0) / (1024 ** 3)
+        return usage
+
+def create_chat_interface():
+    bot = CustomerSupportBot()
+    
+    def predict(message: str, history: List[Tuple[str, str]]) -> Tuple[str, List[Tuple[str, str]]]:
+        if not message:
+            return "", history
         
-        # Tokenize input
-        inputs = self.tokenizer(input_text, return_tensors="pt")
-        inputs = inputs.to(self.device)
+        bot_response = bot.generate_response(message)
         
-        # Generate response
-        with torch.no_grad():
-            outputs = self.model.generate(
-                **inputs,
-                max_length=50,
-                temperature=temperature,
-                num_return_sequences=1,
-                pad_token_id=self.tokenizer.pad_token_id,
-                eos_token_id=self.tokenizer.eos_token_id,
-                do_sample=True,
-                top_p=0.95,
-                top_k=50
-            )
+        # Log resource usage
+        usage = bot.monitor_resources()
+        print("Resource Usage:", usage)
         
-        # Decode and format response
-        response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+        history.append((message, bot_response))
+        return "", history
+
+    # Create the Gradio interface with custom CSS
+    with gr.Blocks(css="""
+        .message-box {
+            margin-bottom: 10px;
+        }
+        .button-row {
+            display: flex;
+            gap: 10px;
+            margin-top: 10px;
+        }
+    """) as interface:
+        gr.Markdown("# Customer Support Chatbot")
+        gr.Markdown("Welcome! How can I assist you today?")
         
-        # Extract only the response part
-        response = response.split("Response:")[-1].strip()
+        chatbot = gr.Chatbot(
+            label="Chat History",
+            height=400,
+            elem_classes="message-box"
+        )
+        
+        with gr.Row():
+            msg = gr.Textbox(
+                label="Your Message",
+                placeholder="Type your message here...",
+                lines=2,
+                elem_classes="message-box"
+            )
         
-        return response
+        with gr.Row(elem_classes="button-row"):
+            submit = gr.Button("Send Message", variant="primary")
+            clear = gr.ClearButton([msg, chatbot], value="Clear Chat")
 
-# Initialize the chatbot
-bot = CustomerSupportBot()
+        # Add example queries in a separate row
+        with gr.Row():
+            gr.Examples(
+                examples=[
+                    "How do I reset my password?",
+                    "What are your shipping policies?",
+                    "I want to return a product.",
+                    "How can I track my order?",
+                    "What payment methods do you accept?"
+                ],
+                inputs=msg,
+                label="Example Questions"
+            )
 
-# Define the Gradio interface function
-def chatbot_response(message, history):
-    """
-    Generate bot response for the Gradio interface.
-    
-    Args:
-        message (str): User's input message
-        history (list): Chat history
-    """
-    bot_response = bot.generate_response(message)
-    history.append((bot_response))
-    return history
+        # Set up event handlers
+        submit_click = submit.click(
+            predict,
+            inputs=[msg, chatbot],
+            outputs=[msg, chatbot]
+        )
+        
+        msg.submit(
+            predict,
+            inputs=[msg, chatbot],
+            outputs=[msg, chatbot]
+        )
+        
+        # Add keyboard shortcut for submit
+        msg.change(lambda x: gr.update(interactive=bool(x.strip())), inputs=[msg], outputs=[submit])
 
-# Create the Gradio interface
-iface = gr.ChatInterface(
-    fn=chatbot_response,
-    title="Customer Support Chatbot",
-    description="Ask your questions to the customer support bot!",
-    examples=["How do I reset my password?", 
-             "What are your shipping policies?", 
-             "I want to return a product."],
-    # retry_btn=None,
-    # undo_btn="Remove Last",
-    # clear_btn="Clear",
-)
+    return interface
 
-# Launch the interface
 if __name__ == "__main__":
-    iface.launch(share=False)  # Set share=True if you want to create a public link
+    demo = create_chat_interface()
+    demo.launch(
+        share=False,
+        server_name="0.0.0.0",  # Makes the server accessible from other machines
+        server_port=7860,  # Specify the port
+        debug=True
+    )

requirements.txt

@@ -7,3 +7,4 @@ boto3
 pytest
 pydantic
 datasets
+psutil