Upload app.py

app.py

@@ -728,17 +728,51 @@ class UltimateMambaSwarm:
         self.model_loaded = False
         self.current_model_size = "auto"
         
-        # Enhanced domain detection with confidence scoring
-        self.domain_keywords = {
-            'medical': ['medical', 'health', 'doctor', 'patient', 'disease', 'treatment', 'symptom', 'diagnosis', 'medicine', 'hospital', 'clinical', 'therapy', 'pharmaceutical', 'healthcare', 'surgeon', 'nurse', 'clinic', 'prescription', 'dosage', 'vaccine'],
-            'legal': ['legal', 'law', 'court', 'judge', 'contract', 'attorney', 'lawyer', 'legislation', 'rights', 'lawsuit', 'statute', 'regulation', 'jurisdiction', 'litigation', 'defendant', 'plaintiff', 'evidence', 'testimony', 'verdict', 'appeal'],
-            'code': ['code', 'python', 'programming', 'function', 'algorithm', 'software', 'debug', 'script', 'developer', 'syntax', 'variable', 'loop', 'class', 'method', 'library', 'framework', 'api', 'database', 'web development', 'javascript', 'html', 'css', 'react', 'node', 'git', 'github', 'programming language', 'coding', 'development', 'computer science', 'data structure', 'array', 'list', 'dictionary', 'string', 'integer', 'boolean', 'import', 'def', 'if', 'else', 'for', 'while', 'try', 'except', 'return', 'print', 'input', 'output', 'file', 'json', 'xml', 'csv', 'pandas', 'numpy', 'matplotlib', 'sklearn', 'tensorflow', 'pytorch', 'machine learning', 'ai', 'artificial intelligence', 'neural network', 'deep learning', 'model training', 'regression', 'classification', 'clustering', 'supervised', 'unsupervised', 'reinforcement learning'],
-            'science': ['science', 'research', 'experiment', 'theory', 'physics', 'chemistry', 'biology', 'scientific', 'hypothesis', 'laboratory', 'analysis', 'data', 'observation', 'methodology', 'peer review', 'publication', 'journal', 'academic', 'study', 'quantum', 'molecular', 'genetic', 'evolution', 'ecosystem', 'climate', 'astronomy', 'geology', 'mathematics', 'statistics', 'engineering'],
-            'creative': ['story', 'creative', 'write', 'novel', 'poem', 'character', 'fiction', 'narrative', 'art', 'imagination', 'plot', 'dialogue', 'setting', 'theme', 'author', 'writing', 'literature', 'poetry', 'drama', 'screenplay', 'script', 'book', 'chapter', 'scene', 'metaphor', 'symbolism', 'style', 'voice', 'tone'],
-            'business': ['business', 'marketing', 'strategy', 'finance', 'management', 'economics', 'profit', 'company', 'entrepreneur', 'startup', 'investment', 'revenue', 'sales', 'customer', 'market', 'competition', 'brand', 'product', 'service', 'leadership', 'team', 'organization', 'budget', 'roi', 'kpi', 'analytics', 'growth', 'scale', 'innovation'],
-            'general': ['explain', 'what', 'how', 'why', 'describe', 'tell', 'help', 'question', 'information', 'knowledge', 'understand', 'learn', 'teach', 'example', 'definition', 'meaning', 'concept', 'idea', 'topic', 'subject']
+        # Dynamic adaptive domain detection system
+        self.base_domain_patterns = {
+            'medical': {
+                'core_terms': ['medical', 'health', 'doctor', 'patient', 'treatment', 'diagnosis'],
+                'semantic_patterns': ['symptoms of', 'treatment for', 'causes of', 'how to treat', 'medical condition'],
+                'context_indicators': ['healthcare', 'clinical', 'pharmaceutical', 'therapeutic']
+            },
+            'legal': {
+                'core_terms': ['legal', 'law', 'court', 'contract', 'attorney', 'rights'],
+                'semantic_patterns': ['according to law', 'legal rights', 'court case', 'legal advice', 'lawsuit'],
+                'context_indicators': ['jurisdiction', 'litigation', 'statute', 'regulation']
+            },
+            'code': {
+                'core_terms': ['code', 'python', 'programming', 'function', 'algorithm', 'software'],
+                'semantic_patterns': ['write a function', 'create a program', 'how to code', 'programming problem', 'implement algorithm'],
+                'context_indicators': ['syntax', 'debugging', 'development', 'coding', 'script']
+            },
+            'science': {
+                'core_terms': ['science', 'research', 'experiment', 'theory', 'study', 'analysis'],
+                'semantic_patterns': ['scientific method', 'research shows', 'experimental results', 'theory suggests'],
+                'context_indicators': ['hypothesis', 'methodology', 'peer review', 'laboratory']
+            },
+            'creative': {
+                'core_terms': ['story', 'creative', 'write', 'character', 'fiction', 'art'],
+                'semantic_patterns': ['write a story', 'create a character', 'creative writing', 'artistic expression'],
+                'context_indicators': ['imagination', 'narrative', 'literature', 'poetry']
+            },
+            'business': {
+                'core_terms': ['business', 'marketing', 'strategy', 'finance', 'management', 'company'],
+                'semantic_patterns': ['business plan', 'marketing strategy', 'financial analysis', 'company growth'],
+                'context_indicators': ['entrepreneur', 'investment', 'revenue', 'profit']
+            },
+            'general': {
+                'core_terms': ['explain', 'what', 'how', 'why', 'describe', 'help'],
+                'semantic_patterns': ['can you explain', 'what is', 'how does', 'why do', 'help me understand'],
+                'context_indicators': ['information', 'knowledge', 'understanding', 'learning']
+            }
         }
         
+        # Dynamic learning components
+        self.learned_patterns = {}  # Store patterns learned from user interactions
+        self.domain_context_history = []  # Track recent domain contexts for better detection
+        self.semantic_similarity_cache = {}  # Cache for performance
+        self.interaction_count = 0
+        
         # Initialize with default model
         self._initialize_system()
     
@@ -774,74 +808,223 @@ class UltimateMambaSwarm:
             logger.error(f"System initialization failed: {e}")
     
     def detect_domain_advanced(self, prompt: str) -> Tuple[str, float]:
-        """Advanced domain detection with confidence scoring and debugging"""
+        """Advanced adaptive domain detection with machine learning-like capabilities"""
         prompt_lower = prompt.lower()
+        self.interaction_count += 1
+        
+        print(f"🔍 Adaptive Domain Detection #{self.interaction_count}: '{prompt[:50]}...'")
+        
+        # Multi-layered detection approach
         domain_scores = {}
         
-        print(f"🔍 Domain Detection Debug: Analyzing prompt: '{prompt[:50]}...'")
+        # Layer 1: Semantic Pattern Analysis
+        semantic_scores = self._analyze_semantic_patterns(prompt_lower)
+        
+        # Layer 2: Context-Aware Detection
+        context_scores = self._analyze_context_patterns(prompt_lower)
+        
+        # Layer 3: Historical Context Influence
+        history_scores = self._analyze_historical_context(prompt_lower)
         
-        for domain, keywords in self.domain_keywords.items():
-            matches = []
-            for keyword in keywords:
-                if keyword in prompt_lower:
-                    matches.append(keyword)
+        # Layer 4: Learned Pattern Matching
+        learned_scores = self._analyze_learned_patterns(prompt_lower)
+        
+        # Combine all layers with weighted importance
+        for domain in self.base_domain_patterns.keys():
+            combined_score = (
+                semantic_scores.get(domain, 0) * 0.4 +
+                context_scores.get(domain, 0) * 0.3 +
+                history_scores.get(domain, 0) * 0.2 +
+                learned_scores.get(domain, 0) * 0.1
+            )
             
-            if matches:
-                # Enhanced scoring algorithm
-                base_score = len(matches) / len(keywords)
-                
-                # Bonus for multiple matches
-                if len(matches) > 1:
-                    base_score *= (1.0 + 0.1 * len(matches))  # Progressive bonus
-                
-                # Special bonuses for specific domains
-                if domain == 'code':
-                    # Strong bonus for programming-specific terms
-                    programming_terms = ['python', 'programming', 'code', 'function', 'script', 'algorithm', 'development', 'coding']
-                    programming_matches = sum(1 for term in programming_terms if term in matches)
-                    if programming_matches > 0:
-                        base_score *= 2.0  # Double score for programming
-                        
-                    # Extra bonus for code syntax patterns
-                    code_patterns = ['def ', 'class ', 'import ', 'for ', 'while ', 'if ', 'else:', 'try:', 'except:', 'return ', 'print(', 'input(']
-                    pattern_matches = sum(1 for pattern in code_patterns if pattern in prompt_lower)
-                    if pattern_matches > 0:
-                        base_score *= (1.5 + 0.2 * pattern_matches)
-                        
-                elif domain == 'medical':
-                    # Bonus for medical terminology
-                    medical_terms = ['medical', 'health', 'doctor', 'patient', 'treatment', 'diagnosis']
-                    medical_matches = sum(1 for term in medical_terms if term in matches)
-                    if medical_matches > 0:
-                        base_score *= 1.8
-                        
-                elif domain == 'science':
-                    # Bonus for scientific methodology terms
-                    science_terms = ['research', 'experiment', 'theory', 'hypothesis', 'analysis', 'study']
-                    science_matches = sum(1 for term in science_terms if term in matches)
-                    if science_matches > 0:
-                        base_score *= 1.6
-                
-                # Cap the score to reasonable levels
-                domain_scores[domain] = min(base_score, 2.0)
-                print(f"  📊 {domain}: {len(matches)} matches {matches[:3]}{'...' if len(matches) > 3 else ''} → Score: {domain_scores[domain]:.3f}")
+            if combined_score > 0:
+                domain_scores[domain] = combined_score
+                print(f"  📈 {domain}: semantic={semantic_scores.get(domain, 0):.3f}, context={context_scores.get(domain, 0):.3f}, history={history_scores.get(domain, 0):.3f}, learned={learned_scores.get(domain, 0):.3f} → Total={combined_score:.3f}")
         
-        # Determine best domain
+        # Determine best domain with dynamic thresholding
         if domain_scores:
             best_domain = max(domain_scores, key=domain_scores.get)
             confidence = min(domain_scores[best_domain], 1.0)
             
-            # Ensure minimum confidence threshold for specialized domains
-            if best_domain != 'general' and confidence < 0.3:
-                print(f"  ⚠️  Low confidence ({confidence:.3f}) for {best_domain}, falling back to general")
-                return 'general', 0.5
+            # Dynamic confidence adjustment based on interaction history
+            if len(self.domain_context_history) > 3:
+                recent_domains = [entry['domain'] for entry in self.domain_context_history[-3:]]
+                if best_domain in recent_domains:
+                    confidence *= 1.1  # Boost confidence for consistent domain usage
+                    print(f"  🔄 Confidence boosted due to recent domain consistency")
+            
+            # Adaptive threshold - becomes more lenient with more interactions
+            min_threshold = max(0.2, 0.4 - (self.interaction_count * 0.01))
+            
+            if confidence >= min_threshold:
+                # Store successful detection for learning
+                self._update_learned_patterns(prompt_lower, best_domain, confidence)
+                self._update_context_history(prompt, best_domain, confidence)
                 
-            print(f"  ✅ Selected Domain: {best_domain} (confidence: {confidence:.3f})")
-            return best_domain, confidence
+                print(f"  ✅ Selected Domain: {best_domain} (confidence: {confidence:.3f}, threshold: {min_threshold:.3f})")
+                return best_domain, confidence
+            else:
+                print(f"  ⚠️  Low confidence ({confidence:.3f} < {min_threshold:.3f}), using general")
+        else:
+            print(f"  🔄 No patterns matched, using general")
         
-        print(f"  🔄 No specific domain detected, using general")
+        # Fallback to general with context storage
+        self._update_context_history(prompt, 'general', 0.5)
         return 'general', 0.5
     
+    def _analyze_semantic_patterns(self, prompt_lower: str) -> Dict[str, float]:
+        """Analyze semantic patterns in the prompt"""
+        scores = {}
+        
+        for domain, patterns in self.base_domain_patterns.items():
+            score = 0
+            
+            # Check core terms with fuzzy matching
+            core_matches = sum(1 for term in patterns['core_terms'] if term in prompt_lower)
+            score += core_matches * 0.3
+            
+            # Check semantic patterns (phrase-level matching)
+            pattern_matches = sum(1 for pattern in patterns['semantic_patterns'] if pattern in prompt_lower)
+            score += pattern_matches * 0.5
+            
+            # Special domain-specific boosters
+            if domain == 'code':
+                # Look for code-specific patterns
+                code_indicators = ['def ', 'class ', 'import ', 'function(', '()', '{', '}', '[]', 'return ', 'print(', 'console.log']
+                code_pattern_score = sum(1 for indicator in code_indicators if indicator in prompt_lower)
+                score += code_pattern_score * 0.4
+                
+                # Programming language detection
+                languages = ['python', 'javascript', 'java', 'c++', 'html', 'css', 'sql', 'react', 'node']
+                lang_score = sum(1 for lang in languages if lang in prompt_lower)
+                score += lang_score * 0.3
+                
+            elif domain == 'medical':
+                # Medical question patterns
+                medical_questions = ['what causes', 'symptoms of', 'treatment for', 'how to cure', 'side effects']
+                med_pattern_score = sum(1 for pattern in medical_questions if pattern in prompt_lower)
+                score += med_pattern_score * 0.4
+                
+            elif domain == 'creative':
+                # Creative request patterns
+                creative_requests = ['write a', 'create a story', 'imagine', 'make up', 'fictional']
+                creative_score = sum(1 for pattern in creative_requests if pattern in prompt_lower)
+                score += creative_score * 0.4
+            
+            if score > 0:
+                scores[domain] = min(score, 2.0)  # Cap maximum score
+        
+        return scores
+    
+    def _analyze_context_patterns(self, prompt_lower: str) -> Dict[str, float]:
+        """Analyze contextual indicators in the prompt"""
+        scores = {}
+        
+        for domain, patterns in self.base_domain_patterns.items():
+            score = 0
+            
+            # Context indicators
+            context_matches = sum(1 for indicator in patterns['context_indicators'] if indicator in prompt_lower)
+            score += context_matches * 0.2
+            
+            # Question type analysis
+            if any(q in prompt_lower for q in ['how to', 'what is', 'explain']):
+                if domain in ['general', 'science']:
+                    score += 0.2
+            
+            if any(q in prompt_lower for q in ['create', 'make', 'build', 'develop']):
+                if domain in ['code', 'creative', 'business']:
+                    score += 0.3
+            
+            if score > 0:
+                scores[domain] = score
+        
+        return scores
+    
+    def _analyze_historical_context(self, prompt_lower: str) -> Dict[str, float]:
+        """Analyze based on recent interaction history"""
+        scores = {}
+        
+        if not self.domain_context_history:
+            return scores
+        
+        # Look at recent domain patterns
+        recent_history = self.domain_context_history[-5:]  # Last 5 interactions
+        domain_frequency = {}
+        
+        for entry in recent_history:
+            domain = entry['domain']
+            domain_frequency[domain] = domain_frequency.get(domain, 0) + 1
+        
+        # Boost scores for recently used domains
+        for domain, frequency in domain_frequency.items():
+            if domain != 'general':  # Don't boost general
+                boost = frequency * 0.1
+                scores[domain] = boost
+        
+        return scores
+    
+    def _analyze_learned_patterns(self, prompt_lower: str) -> Dict[str, float]:
+        """Analyze using patterns learned from previous interactions"""
+        scores = {}
+        
+        for domain, learned_data in self.learned_patterns.items():
+            score = 0
+            
+            # Check learned phrases
+            for phrase, weight in learned_data.get('phrases', {}).items():
+                if phrase in prompt_lower:
+                    score += weight * 0.2
+            
+            # Check learned word combinations
+            for combo, weight in learned_data.get('combinations', {}).items():
+                if all(word in prompt_lower for word in combo.split()):
+                    score += weight * 0.3
+            
+            if score > 0:
+                scores[domain] = min(score, 1.0)
+        
+        return scores
+    
+    def _update_learned_patterns(self, prompt_lower: str, domain: str, confidence: float):
+        """Update learned patterns based on successful detections"""
+        if domain not in self.learned_patterns:
+            self.learned_patterns[domain] = {'phrases': {}, 'combinations': {}}
+        
+        # Extract and store successful phrases (2-4 words)
+        words = prompt_lower.split()
+        for i in range(len(words) - 1):
+            for length in [2, 3, 4]:
+                if i + length <= len(words):
+                    phrase = ' '.join(words[i:i+length])
+                    if len(phrase) > 8:  # Only meaningful phrases
+                        current_weight = self.learned_patterns[domain]['phrases'].get(phrase, 0)
+                        self.learned_patterns[domain]['phrases'][phrase] = min(current_weight + confidence * 0.1, 1.0)
+        
+        # Limit stored patterns to prevent memory bloat
+        if len(self.learned_patterns[domain]['phrases']) > 100:
+            # Keep only top 50 patterns
+            sorted_phrases = sorted(
+                self.learned_patterns[domain]['phrases'].items(), 
+                key=lambda x: x[1], 
+                reverse=True
+            )
+            self.learned_patterns[domain]['phrases'] = dict(sorted_phrases[:50])
+    
+    def _update_context_history(self, prompt: str, domain: str, confidence: float):
+        """Update interaction history for context analysis"""
+        self.domain_context_history.append({
+            'prompt': prompt[:100],  # Store truncated prompt
+            'domain': domain,
+            'confidence': confidence,
+            'timestamp': time.time()
+        })
+        
+        # Keep only recent history (last 20 interactions)
+        if len(self.domain_context_history) > 20:
+            self.domain_context_history = self.domain_context_history[-20:]
+    
     def simulate_advanced_encoder_routing(self, domain: str, confidence: float, num_encoders: int, model_size: str) -> Dict:
         """Advanced encoder routing with model size consideration"""
         
@@ -1532,6 +1715,12 @@ Secondary: {', '.join(map(str, routing_info['selected_encoders'][8:16]))}{'...'
 - **Parameter Optimization**: Dynamic
 - **Fallback Protection**: Multi-layer
 
+**🧠 Adaptive Learning System:**
+- **Interactions Processed**: {self.interaction_count}
+- **Learned Patterns**: {sum(len(patterns.get('phrases', {})) for patterns in self.learned_patterns.values())}
+- **Context History**: {len(self.domain_context_history)} entries
+- **Learning Domains**: {', '.join(self.learned_patterns.keys()) if self.learned_patterns else 'Initializing'}
+
 **🐍 Mamba Status**: Ready for GPU activation (mamba_ssm commented out)
 """