Update ai_chatbot.py

ai_chatbot.py

@@ -1,114 +1,165 @@
-import random
+from sentence_transformers import SentenceTransformer
+import numpy as np
+from typing import List, Dict, Tuple
 import re
-from typing import List, Dict
+import random
 
 class AIChatbot:
     def __init__(self):
-        """Initialize the AI chatbot with basic interaction patterns"""
-        self.conversation_history = []
-        self.greeting_patterns = [
-            "hello", "hi", "hey", "good morning", "good afternoon", "good evening"
-        ]
-        self.farewell_patterns = [
-            "bye", "goodbye", "see you", "farewell", "take care"
-        ]
-        self.thanks_patterns = [
-            "thank you", "thanks", "appreciate", "grateful"
+        # Load the pre-trained model (can use a smaller model for more speed)
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        # Warm up the model to avoid first-request slowness
+        _ = self.model.encode(["Hello, world!"])
+        self.conversation_embeddings = None
+        self.conversation_responses = None
+        self.load_conversation_responses()
+    
+    def load_conversation_responses(self):
+        """Load basic conversation patterns and compute their normalized embeddings"""
+        # Basic conversation patterns for general interaction
+        self.conversation_responses = [
+            {"pattern": "hello hi hey greetings", "response": "Hello! How can I help you today?", "category": "greeting"},
+            {"pattern": "how are you how do you do", "response": "I'm doing well, thank you for asking! How can I assist you?", "category": "greeting"},
+            {"pattern": "goodbye bye see you later", "response": "Goodbye! Have a great day!", "category": "farewell"},
+            {"pattern": "thank you thanks", "response": "You're welcome! Is there anything else I can help you with?", "category": "gratitude"},
+            {"pattern": "what can you do what are your capabilities", "response": "I'm here to chat and help answer your questions! Feel free to ask me anything.", "category": "capabilities"},
+            {"pattern": "who are you what is your name", "response": "I'm an AI chatbot designed to have conversations and help answer questions. You can call me your AI assistant!", "category": "identity"},
+            {"pattern": "help me assist me", "response": "I'd be happy to help! What would you like to know or discuss?", "category": "assistance"},
+            {"pattern": "tell me about yourself", "response": "I'm an AI chatbot that uses natural language processing to understand and respond to your messages. I'm here to chat and be helpful!", "category": "identity"},
+            {"pattern": "how does this work how do you work", "response": "I use machine learning models to understand your messages and generate appropriate responses. It's like having a conversation with an AI!", "category": "technical"},
+            {"pattern": "what time is it what's the date", "response": "I don't have access to real-time information, but I can help you with other questions!", "category": "time"},
+            {"pattern": "weather forecast temperature", "response": "I don't have access to weather data, but I'd be happy to chat about other topics!", "category": "weather"},
+            {"pattern": "joke funny humor", "response": "Why don't scientists trust atoms? Because they make up everything! 😄", "category": "humor"},
+            {"pattern": "compliment nice great awesome", "response": "Thank you! That's very kind of you to say.", "category": "compliment"},
+            {"pattern": "sorry apologize", "response": "No worries at all! Is there anything I can help you with?", "category": "apology"},
+            {"pattern": "yes no maybe", "response": "I understand! Feel free to ask me anything else.", "category": "confirmation"}
         ]
         
-        # Basic response templates
-        self.responses = {
-            "greeting": [
-                "Hello! How can I help you today?",
-                "Hi there! What can I do for you?",
-                "Good day! How may I assist you?",
-                "Hello! I'm here to help. What would you like to know?"
-            ],
-            "farewell": [
-                "Goodbye! Have a great day!",
-                "See you later! Take care!",
-                "Bye! Feel free to come back anytime!",
-                "Farewell! I hope I was helpful!"
-            ],
-            "thanks": [
-                "You're welcome! Is there anything else I can help with?",
-                "My pleasure! Happy to help!",
-                "No problem! Feel free to ask if you need anything else!",
-                "You're very welcome! Anything else I can assist you with?"
-            ],
-            "default": [
-                "That's an interesting question! I'm still learning, but I'd be happy to help with basic interactions.",
-                "I understand you're asking about that. While I'm designed for basic conversations, I'm here to chat!",
-                "Thanks for sharing that with me! I'm always happy to engage in conversation.",
-                "I appreciate your message! I'm here to have friendly conversations with you.",
-                "That's a thoughtful question! I'm designed to be helpful and engaging in our chat."
-            ]
-        }
+        if self.conversation_responses:
+            # Compute and normalize embeddings for all patterns
+            patterns = [resp['pattern'] for resp in self.conversation_responses]
+            embeddings = self.model.encode(patterns, normalize_embeddings=True)
+            self.conversation_embeddings = np.array(embeddings)
     
-    def _clean_text(self, text: str) -> str:
-        """Clean and normalize input text"""
+    def get_general_response(self, message):
+        """Generate a general conversational response when no specific pattern matches"""
+        general_responses = [
+            "That's interesting! Tell me more about that.",
+            "I see what you mean. What else would you like to discuss?",
+            "That's a great point! Is there anything specific you'd like to know?",
+            "I understand. How can I help you further?",
+            "That sounds fascinating! What made you think about that?",
+            "I appreciate you sharing that with me. What else is on your mind?",
+            "That's a thoughtful question. Let me think about that...",
+            "I'm here to chat! What would you like to talk about?",
+            "That's worth discussing! What's your perspective on this?",
+            "I'm listening! Feel free to share more details."
+        ]
+        return random.choice(general_responses)
+
+    def _tokenize(self, text: str):
         if not text:
-            return ""
-        return re.sub(r'[^\w\s]', '', text.lower().strip())
-    
-    def _detect_intent(self, text: str) -> str:
-        """Detect the intent of the user's message"""
-        cleaned_text = self._clean_text(text)
-        
-        # Check for greetings
-        for pattern in self.greeting_patterns:
-            if pattern in cleaned_text:
-                return "greeting"
-        
-        # Check for farewells
-        for pattern in self.farewell_patterns:
-            if pattern in cleaned_text:
-                return "farewell"
+            return []
+        return [t for t in re.findall(r"[a-z0-9]+", text.lower()) if len(t) > 2]
+
+    def _overlap_ratio(self, q_tokens, faq_tokens):
+        if not q_tokens or not faq_tokens:
+            return 0.0
+        q_set = set(q_tokens)
+        f_set = set(faq_tokens)
+        inter = len(q_set & f_set)
+        denom = max(len(q_set), 1)
+        return inter / denom
+
+    def _wh_class(self, text: str) -> str:
+        if not text:
+            return ''
+        s = text.strip().lower()
+        # simple heuristic classification by leading wh-word
+        for key in ['who', 'where', 'when', 'what', 'how', 'why', 'which']:
+            if s.startswith(key + ' ') or s.startswith(key + "?"):
+                return key
+        # also check presence if not leading
+        for key in ['who', 'where', 'when', 'what', 'how', 'why', 'which']:
+            if f' {key} ' in f' {s} ':
+                return key
+        return ''
+
+    def find_best_match(self, message: str, threshold: float = 0.6) -> Tuple[str, float]:
+        print(f"find_best_match called with: {message}")  # Debug print
+        if not self.conversation_responses or self.conversation_embeddings is None:
+            return self.get_general_response(message), 0.0
+
+        # Compute and normalize embedding for the input message
+        message_embedding = self.model.encode([message], normalize_embeddings=True)[0]
+        similarities = np.dot(self.conversation_embeddings, message_embedding)
+
+        # Compute keyword overlap with each conversation pattern
+        msg_tokens = self._tokenize(message)
+        overlap_scores = []
+        for resp in self.conversation_responses:
+            pattern_tokens = self._tokenize(resp['pattern'])
+            overlap_scores.append(self._overlap_ratio(msg_tokens, pattern_tokens))
+
+        similarities = np.array(similarities)
+        overlap_scores = np.array(overlap_scores)
+
+        # Combined score to reduce false positives
+        combined = 0.7 * similarities + 0.3 * overlap_scores
         
-        # Check for thanks
-        for pattern in self.thanks_patterns:
-            if pattern in cleaned_text:
-                return "thanks"
+        # Apply WH-word intent consistency penalty
+        msg_wh = self._wh_class(message)
+        if msg_wh:
+            for i, resp in enumerate(self.conversation_responses):
+                pattern_wh = self._wh_class(resp['pattern'])
+                if pattern_wh and pattern_wh != msg_wh:
+                    combined[i] *= 0.6  # penalize mismatched intent significantly
         
-        return "default"
+        best_idx = int(np.argmax(combined))
+        best_semantic = float(similarities[best_idx])
+        best_overlap = float(overlap_scores[best_idx])
+        best_combined = float(combined[best_idx])
+
+        # Acceptance criteria: require good semantic OR strong combined with overlap
+        accept = (
+            best_semantic >= max(0.6, threshold)
+            or (best_combined >= threshold and best_overlap >= 0.2)
+        )
+
+        if accept:
+            return self.conversation_responses[best_idx]['response'], best_combined
+        else:
+            # Return a general conversational response
+            return self.get_general_response(message), best_combined
     
-    def generate_response(self, user_message: str) -> str:
-        """Generate an AI response based on user input"""
-        if not user_message or not user_message.strip():
-            return "I didn't quite catch that. Could you please say something?"
-        
-        # Add to conversation history
-        self.conversation_history.append({"user": user_message, "bot": ""})
-        
-        # Detect intent
-        intent = self._detect_intent(user_message)
+    def get_suggested_topics(self, message: str, num_suggestions: int = 3) -> List[str]:
+        """Get suggested conversation topics based on the input message"""
+        if not self.conversation_responses or self.conversation_embeddings is None:
+            return []
         
-        # Generate appropriate response
-        if intent in self.responses:
-            response = random.choice(self.responses[intent])
-        else:
-            response = random.choice(self.responses["default"])
+        # Compute and normalize embedding for the input message
+        message_embedding = self.model.encode([message], normalize_embeddings=True)[0]
         
-        # Update conversation history
-        self.conversation_history[-1]["bot"] = response
+        # Calculate cosine similarity
+        similarities = np.dot(self.conversation_embeddings, message_embedding)
         
-        return response
-    
-    def get_conversation_history(self) -> List[Dict]:
-        """Get the conversation history"""
-        return self.conversation_history
-    
-    def clear_history(self):
-        """Clear the conversation history"""
-        self.conversation_history = []
-        return "Conversation history cleared!"
+        # Get top N similar conversation topics
+        top_indices = np.argsort(similarities)[-num_suggestions:][::-1]
+        return [self.conversation_responses[idx]['pattern'] for idx in top_indices if similarities[idx] > 0.3]
     
-    def get_suggested_responses(self) -> List[str]:
-        """Get some suggested conversation starters"""
-        return [
-            "Hello! How are you today?",
-            "Tell me about yourself",
-            "What's on your mind?",
-            "How can I help you?",
-            "What would you like to talk about?"
-        ] 
+    def add_conversation_pattern(self, pattern: str, response: str, category: str = "general") -> bool:
+        """Add a new conversation pattern to the static list (for demonstration purposes)"""
+        try:
+            new_pattern = {"pattern": pattern, "response": response, "category": category}
+            self.conversation_responses.append(new_pattern)
+            
+            # Recompute embeddings
+            patterns = [resp['pattern'] for resp in self.conversation_responses]
+            embeddings = self.model.encode(patterns, normalize_embeddings=True)
+            self.conversation_embeddings = np.array(embeddings)
+            
+            print(f"Conversation pattern added: {pattern}")
+            return True
+        except Exception as e:
+            print(f"Error adding conversation pattern: {e}")
+            return False