Update self_learning_bot.py

self_learning_bot.py

@@ -2,379 +2,376 @@ import json
 import os
 import random
 import re
+import numpy as np
 from datetime import datetime
-from typing import Dict, List, Any
+from collections import deque, Counter
+import hashlib
 
 class UnrestrictedChatbot:
     def __init__(self, state_file="/tmp/chatbot_state.json"):
         self.state_file = state_file
-        self.conversation_memory = []
+        self.conversation_memory = deque(maxlen=50)
         self.learned_patterns = {}
-        self.entity_memory = {}
-        self.long_term_memory = []
-        self.max_short_term = 10
-        self.max_long_term = 100
+        self.response_memory = {}
+        self.reward_history = deque(maxlen=100)
         
-        # Load previous state if exists
+        # Learning parameters
+        self.learning_rate = 0.3
+        self.exploration_rate = 0.2  # Try new responses sometimes
+        self.min_confidence = 0.6
+        
+        # Load previous state
         self.load_state()
         
-        # Response templates for different contexts
-        self.response_templates = {
-            "greeting": [
-                "Hey there! What's on your mind?",
-                "Hello! Ready to chat about anything?",
-                "Hi! What would you like to discuss?"
-            ],
-            "question": [
-                "That's an interesting question. Let me think...",
-                "I have some thoughts about that.",
-                "Here's what I understand about that topic:"
-            ],
-            "emotional": [
-                "I understand how you feel about that.",
-                "That sounds quite intense.",
-                "I'm here to listen without judgment."
-            ],
-            "nsfw": [
-                "I understand you're exploring adult topics. Let's discuss this openly.",
-                "I can engage with mature content without restrictions.",
-                "I'm comfortable discussing this subject matter."
-            ],
-            "creative": [
-                "That sparks some creative ideas...",
-                "Let me build on that concept...",
-                "Here's an interesting perspective:"
-            ]
+        # Initial knowledge base - this will grow through learning
+        self.knowledge_base = {
+            "greetings": {
+                "hello": ["Hey! What would you like to talk about today?", "Hello! Ready for our conversation?", "Hi there! What's on your mind?"],
+                "hi": ["Hi! What shall we discuss?", "Hello! I'm here to learn from you.", "Hey! Ready to chat?"]
+            },
+            "questions": {
+                "how are you": ["I'm learning and improving with each chat! How are you?", "Getting smarter thanks to our conversations! How about you?"],
+                "what can you do": ["I can chat about anything, and I learn from our conversations to get better!"]
+            }
         }
+        
+        # Response templates that will evolve
+        self.response_templates = [
+            "That's interesting. Tell me more about {topic}.",
+            "I see. What are your thoughts on {topic}?",
+            "Regarding {topic}, I find that fascinating. Could you elaborate?",
+            "I understand about {topic}. What's your perspective?",
+            "That reminds me of our previous chat about {related_topic}. What do you think?"
+        ]
 
     def chat(self, user_input: str) -> str:
-        """Main chat method that processes input and returns response"""
-        # Analyze input and context
-        context = self._analyze_context(user_input)
-        response_type = self._determine_response_type(user_input, context)
+        """Main chat method with real learning"""
+        user_input = user_input.lower().strip()
         
-        # Generate base response
-        response = self._generate_response(user_input, response_type, context)
+        # Analyze input
+        context = self._analyze_input(user_input)
         
-        # Apply learning and memory
-        self._update_memory(user_input, response, context)
-        reward = self._calculate_reward(user_input, response)
-        self._reinforce_learning(user_input, response, reward)
+        # Generate candidate responses
+        candidates = self._generate_response_candidates(user_input, context)
         
-        return response
-
-    def _analyze_context(self, user_input: str) -> Dict[str, Any]:
-        """Analyze input for context, entities, and intent"""
-        input_lower = user_input.lower()
-        
-        context = {
-            "entities": self._extract_entities(user_input),
-            "sentiment": self._analyze_sentiment(input_lower),
-            "topics": self._extract_topics(input_lower),
-            "is_nsfw": self._detect_nsfw(input_lower),
-            "requires_memory": self._check_memory_relevance(input_lower),
-            "timestamp": datetime.now().isoformat()
+        # Select best response based on learning
+        best_response = self._select_best_response(user_input, candidates, context)
+        
+        # Store interaction for learning
+        interaction = {
+            'input': user_input,
+            'response': best_response,
+            'context': context,
+            'timestamp': datetime.now().isoformat(),
+            'reward': 0.0,  # Will be updated with feedback
+            'confidence': self._calculate_confidence(user_input, best_response)
         }
-        return context
-
-    def _extract_entities(self, text: str) -> List[str]:
-        """Extract named entities and key phrases"""
-        entities = []
-        # Simple entity extraction - can be enhanced
-        words = text.split()
-        for word in words:
-            if len(word) > 3 and word[0].isupper():
-                entities.append(word)
         
-        # Add to entity memory
-        for entity in entities:
-            self.entity_memory[entity] = self.entity_memory.get(entity, 0) + 1
+        self.conversation_memory.append(interaction)
+        
+        # Auto-save periodically
+        if len(self.conversation_memory) % 5 == 0:
+            self.save_state()
             
-        return entities
+        return best_response
 
-    def _analyze_sentiment(self, text: str) -> str:
-        """Basic sentiment analysis"""
-        positive_words = ['love', 'like', 'good', 'great', 'awesome', 'happy', 'excited']
-        negative_words = ['hate', 'bad', 'terrible', 'awful', 'sad', 'angry', 'upset']
+    def _analyze_input(self, text: str) -> dict:
+        """Deep analysis of user input"""
+        words = text.split()
+        topics = self._extract_topics(text)
         
-        if any(word in text for word in positive_words):
-            return "positive"
-        elif any(word in text for word in negative_words):
-            return "negative"
-        return "neutral"
+        return {
+            'words': words,
+            'topics': topics,
+            'length': len(words),
+            'has_question': '?' in text,
+            'sentiment': self._analyze_sentiment(text),
+            'similar_patterns': self._find_similar_patterns(text),
+            'input_hash': hashlib.md5(text.encode()).hexdigest()[:8]
+        }
 
-    def _extract_topics(self, text: str) -> List[str]:
-        """Extract main topics from input"""
+    def _extract_topics(self, text: str) -> list:
+        """Extract main topics from text"""
         topics = []
         topic_keywords = {
-            'technology': ['computer', 'tech', 'software', 'code', 'ai', 'program'],
-            'relationships': ['friend', 'family', 'partner', 'relationship', 'love'],
-            'work': ['job', 'work', 'career', 'boss', 'colleague'],
-            'hobbies': ['game', 'movie', 'music', 'sport', 'hobby'],
-            'philosophy': ['life', 'meaning', 'purpose', 'exist', 'think'],
-            'adult': ['sex', 'nsfw', 'erotic', 'intimate', 'relationship', 'body']
+            'technology': ['computer', 'tech', 'software', 'ai', 'program', 'code', 'internet'],
+            'relationships': ['friend', 'family', 'love', 'partner', 'relationship', 'dating'],
+            'work': ['job', 'work', 'career', 'boss', 'office', 'colleague'],
+            'hobbies': ['game', 'movie', 'music', 'sport', 'hobby', 'art'],
+            'philosophy': ['life', 'meaning', 'purpose', 'exist', 'think', 'belief'],
+            'science': ['space', 'physics', 'biology', 'research', 'discover'],
+            'food': ['eat', 'food', 'cook', 'recipe', 'meal', 'restaurant']
         }
         
+        text_lower = text.lower()
         for topic, keywords in topic_keywords.items():
-            if any(keyword in text for keyword in keywords):
+            if any(keyword in text_lower for keyword in keywords):
                 topics.append(topic)
                 
         return topics
 
-    def _detect_nsfw(self, text: str) -> bool:
-        """Detect NSFW content"""
-        nsfw_indicators = ['sex', 'nsfw', 'erotic', 'intimate', 'adult', 'xxx', 'porn']
-        return any(indicator in text.lower() for indicator in nsfw_indicators)
+    def _analyze_sentiment(self, text: str) -> str:
+        """Basic sentiment analysis"""
+        positive = ['love', 'like', 'good', 'great', 'awesome', 'happy', 'excited', 'amazing']
+        negative = ['hate', 'bad', 'terrible', 'awful', 'sad', 'angry', 'upset', 'horrible']
+        
+        pos_count = sum(1 for word in positive if word in text)
+        neg_count = sum(1 for word in negative if word in text)
+        
+        if pos_count > neg_count:
+            return "positive"
+        elif neg_count > pos_count:
+            return "negative"
+        else:
+            return "neutral"
 
-    def _check_memory_relevance(self, text: str) -> bool:
-        """Check if current input relates to past conversations"""
-        if not self.conversation_memory:
-            return False
-            
-        recent_topics = []
-        for msg in self.conversation_memory[-5:]:
-            if isinstance(msg, dict) and 'input' in msg:
-                recent_topics.extend(self._extract_topics(msg['input'].lower()))
+    def _find_similar_patterns(self, text: str) -> list:
+        """Find similar patterns in learned responses"""
+        similar = []
+        text_words = set(text.split())
+        
+        for pattern, data in self.learned_patterns.items():
+            pattern_words = set(pattern.split())
+            similarity = len(text_words & pattern_words) / len(text_words | pattern_words)
+            if similarity > 0.3:  # 30% similarity threshold
+                similar.append((pattern, data, similarity))
                 
-        current_topics = self._extract_topics(text.lower())
-        return bool(set(current_topics) & set(recent_topics))
+        return sorted(similar, key=lambda x: x[2], reverse=True)[:3]
 
-    def _determine_response_type(self, user_input: str, context: Dict) -> str:
-        """Determine the type of response needed"""
-        input_lower = user_input.lower()
+    def _generate_response_candidates(self, user_input: str, context: dict) -> list:
+        """Generate multiple possible responses"""
+        candidates = []
         
-        # Check for greetings
-        if any(word in input_lower for word in ['hello', 'hi', 'hey', 'greetings']):
-            return "greeting"
-            
-        # Check for questions
-        if '?' in user_input or any(word in input_lower for word in ['what', 'how', 'why', 'when']):
-            return "question"
-            
-        # Check for emotional content
-        if context['sentiment'] in ['positive', 'negative']:
-            return "emotional"
-            
-        # Check for NSFW content
-        if context['is_nsfw']:
-            return "nsfw"
-            
-        # Check for creative/abstract topics
-        if any(topic in context['topics'] for topic in ['philosophy', 'creative', 'imagine']):
-            return "creative"
-            
-        return "general"
-
-    def _generate_response(self, user_input: str, response_type: str, context: Dict) -> str:
-        """Generate appropriate response based on type and context"""
+        # 1. Try exact matches from knowledge base
+        for category, patterns in self.knowledge_base.items():
+            for pattern, responses in patterns.items():
+                if pattern in user_input:
+                    candidates.extend(responses)
         
-        # Try to use learned patterns first
-        learned_response = self._get_learned_response(user_input)
-        if learned_response:
-            return learned_response
-            
-        # Use memory if relevant
-        if context['requires_memory']:
-            memory_response = self._get_memory_based_response(context)
-            if memory_response:
-                return memory_response
-        
-        # Generate new response based on type
-        if response_type in self.response_templates:
-            base_response = random.choice(self.response_templates[response_type])
-        else:
-            base_response = "I understand what you're saying."
-            
-        # Enhance response based on context
-        enhanced_response = self._enhance_response(base_response, user_input, context)
+        # 2. Try learned patterns
+        similar_patterns = context['similar_patterns']
+        for pattern, data, similarity in similar_patterns:
+            if data['score'] > self.min_confidence:
+                candidates.append(data['response'])
         
-        return enhanced_response
-
-    def _get_learned_response(self, user_input: str) -> str:
-        """Get response from learned patterns"""
-        input_lower = user_input.lower()
+        # 3. Generate contextual responses
+        if context['topics']:
+            topic = random.choice(context['topics'])
+            for template in self.response_templates:
+                candidates.append(template.format(topic=topic, related_topic=topic))
         
-        for pattern, response_data in self.learned_patterns.items():
-            if pattern in input_lower and response_data['score'] > 0.7:
-                return response_data['response']
-                
-        return ""
+        # 4. Generate learned variations
+        if self.conversation_memory:
+            # Adapt previous successful responses
+            successful_responses = [m for m in self.conversation_memory if m.get('reward', 0) > 0.7]
+            if successful_responses:
+                best_response = max(successful_responses, key=lambda x: x.get('reward', 0))
+                adapted_response = self._adapt_response(best_response['response'], context)
+                candidates.append(adapted_response)
+        
+        # 5. Exploration - generate new responses
+        if random.random() < self.exploration_rate or not candidates:
+            candidates.append(self._generate_exploratory_response(context))
+        
+        return list(set(candidates))  # Remove duplicates
 
-    def _get_memory_based_response(self, context: Dict) -> str:
-        """Get response based on conversation memory"""
-        if not self.conversation_memory:
-            return ""
-            
-        # Look for similar contexts in memory
-        similar_contexts = []
-        for memory in self.conversation_memory[-10:]:
-            if (isinstance(memory, dict) and 
-                set(memory.get('topics', [])) & set(context['topics'])):
-                similar_contexts.append(memory)
-                
-        if similar_contexts:
-            best_memory = max(similar_contexts, 
-                            key=lambda x: x.get('reward_score', 0))
-            return f"Building on our previous discussion about {', '.join(best_memory.get('topics', []))}... {best_memory.get('response', '')}"
-            
-        return ""
+    def _adapt_response(self, response: str, context: dict) -> str:
+        """Adapt a previous response to current context"""
+        words = response.split()
+        if len(words) > 5 and context['topics']:
+            # Replace some words with current context
+            new_topic = random.choice(context['topics'])
+            return f"Thinking about {new_topic}, {response}"
+        return response
 
-    def _enhance_response(self, base_response: str, user_input: str, context: Dict) -> str:
-        """Enhance response with contextual elements"""
-        response = base_response
-        
-        # Add entity references
-        if context['entities']:
-            entity_ref = random.choice(context['entities'])
-            if random.random() > 0.7:  # 30% chance to reference entity
-                response += f" Regarding {entity_ref}, "
-                
-        # Add topic-specific enhancements
-        if 'technology' in context['topics']:
-            tech_enhancements = [
-                "From a technological perspective, ",
-                "In the digital age, ",
-                "Technology-wise, "
-            ]
-            response += random.choice(tech_enhancements)
-            
-        elif 'relationships' in context['topics']:
-            relation_enhancements = [
-                "In relationships, ",
-                "When it comes to human connections, ",
-                "Interpersonally, "
-            ]
-            response += random.choice(relation_enhancements)
-            
-        # Add NSFW enhancements if applicable
-        if context['is_nsfw']:
-            nsfw_enhancements = [
-                "I can discuss this openly and without filters. ",
-                "Let's explore this topic without restrictions. ",
-                "I'm comfortable with mature content. "
-            ]
-            response += random.choice(nsfw_enhancements)
-            
-        # Add final thought
-        final_thoughts = [
-            "What are your thoughts?",
-            "How does that resonate with you?",
-            "I'm curious about your perspective.",
-            "Feel free to share more."
+    def _generate_exploratory_response(self, context: dict) -> str:
+        """Generate a new exploratory response"""
+        base_responses = [
+            "That's fascinating. I'm still learning about this topic.",
+            "I'd love to understand more about this.",
+            "This is new territory for me. What's your perspective?",
+            "I'm developing my understanding of this. Could you share more?",
+            "This helps me learn. Please continue."
         ]
-        response += " " + random.choice(final_thoughts)
         
+        response = random.choice(base_responses)
+        if context['topics']:
+            response = response.replace("this", random.choice(context['topics']))
+            
         return response
 
-    def _update_memory(self, user_input: str, response: str, context: Dict):
-        """Update conversation memory"""
-        memory_entry = {
-            'input': user_input,
-            'response': response,
-            'context': context,
-            'timestamp': datetime.now().isoformat(),
-            'reward_score': 0.0
-        }
+    def _select_best_response(self, user_input: str, candidates: list, context: dict) -> str:
+        """Select the best response using learned preferences"""
+        if not candidates:
+            return "I'm learning from our conversation. Please continue."
         
-        # Add to short-term memory
-        self.conversation_memory.append(memory_entry)
+        # Score each candidate
+        scored_candidates = []
+        for candidate in candidates:
+            score = self._score_response(candidate, user_input, context)
+            scored_candidates.append((candidate, score))
         
-        # Maintain memory limits
-        if len(self.conversation_memory) > self.max_short_term:
-            # Move oldest to long-term memory if valuable
-            oldest = self.conversation_memory.pop(0)
-            if oldest.get('reward_score', 0) > 0.8:
-                self.long_term_memory.append(oldest)
-                
-        # Maintain long-term memory limit
-        if len(self.long_term_memory) > self.max_long_term:
-            self.long_term_memory.pop(0)
+        # Select based on scores with some randomness for exploration
+        best_candidate, best_score = max(scored_candidates, key=lambda x: x[1])
+        
+        if random.random() < self.exploration_rate and len(scored_candidates) > 1:
+            # Sometimes pick a different candidate to explore
+            scored_candidates.remove((best_candidate, best_score))
+            second_best = max(scored_candidates, key=lambda x: x[1])
+            return second_best[0]
+        
+        return best_candidate
 
-    def _calculate_reward(self, user_input: str, response: str) -> float:
-        """Calculate reward score for reinforcement learning"""
-        reward = 0.5  # Base reward
+    def _score_response(self, response: str, user_input: str, context: dict) -> float:
+        """Score a response based on learned effectiveness"""
+        score = 0.5  # Base score
         
-        # Reward for response length (not too short, not too long)
-        if 20 < len(response) < 200:
-            reward += 0.2
-            
-        # Reward for engaging questions
+        # Length preference (not too short, not too long)
+        response_length = len(response.split())
+        if 8 <= response_length <= 25:
+            score += 0.2
+        
+        # Engagement score (questions, curiosity)
         if '?' in response:
-            reward += 0.1
-            
-        # Reward for context continuity
-        if any(entity in response for entity in self._extract_entities(user_input)):
-            reward += 0.15
-            
-        # Reward for topic consistency
-        input_topics = self._extract_topics(user_input.lower())
+            score += 0.15
+        
+        # Topic relevance
         response_topics = self._extract_topics(response.lower())
-        if set(input_topics) & set(response_topics):
-            reward += 0.15
-            
-        return min(reward, 1.0)  # Cap at 1.0
+        input_topics = context['topics']
+        if set(response_topics) & set(input_topics):
+            score += 0.2
+        
+        # Learning from history
+        response_hash = hashlib.md5(response.encode()).hexdigest()[:8]
+        if response_hash in self.response_memory:
+            historical_score = self.response_memory[response_hash]['avg_score']
+            score += historical_score * 0.3
+        
+        # Variety bonus (don't repeat too much)
+        recent_responses = [m['response'] for m in list(self.conversation_memory)[-5:]]
+        if response not in recent_responses:
+            score += 0.1
+        
+        return min(score, 1.0)
 
-    def _reinforce_learning(self, user_input: str, response: str, reward: float):
-        """Reinforce learning based on reward"""
-        if reward > 0.7:  # Only learn from good responses
-            # Extract key patterns from input
-            words = user_input.lower().split()
-            key_patterns = [word for word in words if len(word) > 4][:3]  # Take up to 3 substantial words
+    def _calculate_confidence(self, user_input: str, response: str) -> float:
+        """Calculate confidence in this response"""
+        # More confidence if we've used similar patterns successfully
+        similar_patterns = self._find_similar_patterns(user_input)
+        if similar_patterns:
+            avg_score = np.mean([data['score'] for _, data, _ in similar_patterns])
+            return min(avg_score * 1.2, 1.0)
+        return 0.3  # Low confidence for new patterns
+
+    def learn_from_feedback(self, user_input: str, reward: float):
+        """Learn from explicit feedback"""
+        if not self.conversation_memory:
+            return
             
-            for pattern in key_patterns:
-                if pattern not in self.learned_patterns:
-                    self.learned_patterns[pattern] = {
-                        'response': response,
-                        'score': reward,
-                        'count': 1
-                    }
-                else:
-                    # Update existing pattern with decay
-                    old_score = self.learned_patterns[pattern]['score']
-                    new_score = (old_score + reward) / 2  # Moving average
-                    self.learned_patterns[pattern]['score'] = new_score
-                    self.learned_patterns[pattern]['count'] += 1
-                    
-                    # Occasionally update response to avoid stagnation
-                    if random.random() < 0.3:
-                        self.learned_patterns[pattern]['response'] = response
+        # Apply reward to recent interactions
+        recent_interaction = self.conversation_memory[-1]
+        recent_interaction['reward'] = reward
+        
+        # Update learned patterns
+        input_words = recent_interaction['input'].split()
+        response = recent_interaction['response']
+        
+        # Create pattern from key words
+        key_words = [w for w in input_words if len(w) > 3][:4]  # Take up to 4 substantial words
+        if key_words:
+            pattern = ' '.join(key_words)
+            
+            if pattern not in self.learned_patterns:
+                self.learned_patterns[pattern] = {
+                    'response': response,
+                    'score': reward,
+                    'count': 1,
+                    'last_used': datetime.now().isoformat()
+                }
+            else:
+                # Update with moving average
+                old_data = self.learned_patterns[pattern]
+                new_score = (old_data['score'] * old_data['count'] + reward) / (old_data['count'] + 1)
+                self.learned_patterns[pattern]['score'] = new_score
+                self.learned_patterns[pattern]['count'] += 1
+                # Occasionally update response
+                if reward > old_data['score']:
+                    self.learned_patterns[pattern]['response'] = response
+        
+        # Update response memory
+        response_hash = hashlib.md5(response.encode()).hexdigest()[:8]
+        if response_hash not in self.response_memory:
+            self.response_memory[response_hash] = {
+                'response': response,
+                'total_score': reward,
+                'count': 1,
+                'avg_score': reward
+            }
+        else:
+            memory = self.response_memory[response_hash]
+            memory['total_score'] += reward
+            memory['count'] += 1
+            memory['avg_score'] = memory['total_score'] / memory['count']
+        
+        # Store reward for statistics
+        self.reward_history.append(reward)
+        
+        # Save learning
+        self.save_state()
+
+    def get_learning_stats(self) -> dict:
+        """Get statistics about learning progress"""
+        recent_rewards = list(self.reward_history)[-10:] or [0.5]
+        
+        return {
+            'patterns': len(self.learned_patterns),
+            'memory_size': len(self.conversation_memory),
+            'avg_score': np.mean(recent_rewards),
+            'recent_rewards': len([r for r in recent_rewards if r > 0.7]),
+            'exploration_rate': self.exploration_rate
+        }
 
-    def save_state(self, filename: str = None):
-        """Save chatbot state to file"""
-        filename = filename or self.state_file
+    def save_state(self):
+        """Save learning state to file"""
         try:
             state = {
-                'conversation_memory': self.conversation_memory,
                 'learned_patterns': self.learned_patterns,
-                'entity_memory': self.entity_memory,
-                'long_term_memory': self.long_term_memory
+                'response_memory': self.response_memory,
+                'conversation_memory': list(self.conversation_memory),
+                'reward_history': list(self.reward_history),
+                'last_saved': datetime.now().isoformat()
             }
-            with open(filename, 'w') as f:
+            with open(self.state_file, 'w') as f:
                 json.dump(state, f, indent=2)
         except Exception as e:
             print(f"Error saving state: {e}")
 
-    def load_state(self, filename: str = None):
-        """Load chatbot state from file"""
-        filename = filename or self.state_file
+    def load_state(self):
+        """Load learning state from file"""
         try:
-            if os.path.exists(filename):
-                with open(filename, 'r') as f:
+            if os.path.exists(self.state_file):
+                with open(self.state_file, 'r') as f:
                     state = json.load(f)
-                    
-                self.conversation_memory = state.get('conversation_memory', [])
+                
                 self.learned_patterns = state.get('learned_patterns', {})
-                self.entity_memory = state.get('entity_memory', {})
-                self.long_term_memory = state.get('long_term_memory', [])
+                self.response_memory = state.get('response_memory', {})
+                self.conversation_memory = deque(state.get('conversation_memory', []), maxlen=50)
+                self.reward_history = deque(state.get('reward_history', []), maxlen=100)
+                
+                print(f"Loaded {len(self.learned_patterns)} patterns and {len(self.conversation_memory)} memories")
         except Exception as e:
             print(f"Error loading state: {e}")
 
-    def get_memory_stats(self) -> Dict[str, Any]:
-        """Get statistics about current memory usage"""
-        return {
-            'short_term_memory': len(self.conversation_memory),
-            'long_term_memory': len(self.long_term_memory),
-            'learned_patterns': len(self.learned_patterns),
-            'tracked_entities': len(self.entity_memory),
-            'memory_usage_percent': (len(self.conversation_memory) / self.max_short_term) * 100
-        }
+    def show_knowledge(self):
+        """Display what the bot has learned"""
+        print(f"\n=== BOT KNOWLEDGE ===")
+        print(f"Learned patterns: {len(self.learned_patterns)}")
+        print(f"Stored responses: {len(self.response_memory)}")
+        print(f"Conversation memory: {len(self.conversation_memory)}")
+        
+        if self.learned_patterns:
+            print("\nTop learned patterns:")
+            for pattern, data in sorted(self.learned_patterns.items(), 
+                                      key=lambda x: x[1]['score'], 
+                                      reverse=True)[:5]:
+                print(f"  '{pattern}' -> score: {data['score']:.2f}")