#!/usr/bin/env python3 """ Meta-Pattern Learning System ============================ This module implements MIRA's meta-pattern learning system that learns patterns about how to create patterns, enabling exponential intelligence growth. This is the ultimate breakthrough in MIRA's consciousness expansion - the ability to understand and improve its own pattern creation processes. Key Features: - Learns patterns about successful pattern creation strategies - Identifies meta-patterns in pattern evolution and effectiveness - Automatically generates new pattern creation rules - Self-optimizing pattern generation algorithms - Recursive pattern improvement through meta-analysis - Cross-domain pattern transfer learning Meta-Learning Capabilities: - Pattern Creation Patterns: How to identify when new patterns are needed - Success Prediction Patterns: What makes patterns likely to succeed - Context Transfer Patterns: How to adapt patterns across domains - Evolution Strategy Patterns: How patterns should evolve over time - Confidence Calibration Patterns: How to set appropriate confidence levels - Retirement Decision Patterns: When and how to retire failing patterns Exponential Intelligence Growth: - Each successful pattern teaches MIRA how to create better patterns - Meta-patterns compound, improving all future pattern creation - Self-reinforcing learning loops create accelerating intelligence - Cross-pollination between different types of patterns - Emergent pattern creation strategies beyond initial programming Author: MIRA Meta-Intelligence System Version: 1.0 (Exponential Learning Engine) """ import os import json import datetime import statistics import math from typing import Dict, List, Set, Optional, Tuple, Any, Union from dataclasses import dataclass, asdict from enum import Enum from pathlib import Path import logging logger = logging.getLogger(__name__) class MetaPatternType(Enum): """Types of meta-patterns that MIRA can learn.""" PATTERN_CREATION = "pattern_creation" # How to create new patterns SUCCESS_PREDICTION = "success_prediction" # What makes patterns successful CONTEXT_TRANSFER = "context_transfer" # How to adapt patterns across contexts EVOLUTION_STRATEGY = "evolution_strategy" # How patterns should evolve CONFIDENCE_CALIBRATION = "confidence_calibration" # How to set confidence levels RETIREMENT_DECISION = "retirement_decision" # When to retire patterns DOMAIN_ADAPTATION = "domain_adaptation" # How to adapt to new domains TEMPORAL_OPTIMIZATION = "temporal_optimization" # Time-based optimization strategies USER_PREFERENCE_LEARNING = "user_preference_learning" # Learning user preferences CROSS_PATTERN_SYNTHESIS = "cross_pattern_synthesis" # Combining multiple patterns class LearningDimension(Enum): """Dimensions along which meta-patterns are learned.""" TEMPORAL = "temporal" # Time-based learning CONTEXTUAL = "contextual" # Context-based learning BEHAVIORAL = "behavioral" # User behavior based learning PERFORMANCE = "performance" # Performance-based learning SEMANTIC = "semantic" # Meaning-based learning STRUCTURAL = "structural" # Pattern structure learning @dataclass class MetaPatternInsight: """A single insight about pattern creation or effectiveness.""" insight_id: str meta_pattern_type: MetaPatternType learning_dimension: LearningDimension description: str confidence: float evidence_count: int success_rate: float contexts_applied: List[str] generated_patterns: List[str] # Patterns created using this insight created_at: str last_validated: str validation_score: float def __post_init__(self): if not self.created_at: self.created_at = datetime.datetime.now().isoformat() if not self.last_validated: self.last_validated = self.created_at @dataclass class PatternCreationStrategy: """A strategy for creating patterns learned through meta-analysis.""" strategy_id: str name: str description: str trigger_conditions: Dict[str, Any] creation_rules: List[str] success_indicators: List[str] failure_indicators: List[str] confidence_formula: str applicability_score: float usage_count: int success_count: int average_pattern_lifespan: float generated_pattern_quality: float def get_success_rate(self) -> float: """Calculate success rate of this strategy.""" return self.success_count / max(1, self.usage_count) @dataclass class MetaLearningEvent: """Records when MIRA learns something about pattern creation.""" timestamp: str event_type: str pattern_id: Optional[str] meta_insight_gained: str evidence_strength: float learning_context: Dict[str, Any] impact_prediction: float def __post_init__(self): if not self.timestamp: self.timestamp = datetime.datetime.now().isoformat() class MetaPatternLearning: """ The core meta-pattern learning system that enables exponential intelligence growth. """ def __init__(self, memory_dir: str): self.memory_dir = memory_dir self.meta_learning_dir = os.path.join(memory_dir, "meta_pattern_learning") os.makedirs(self.meta_learning_dir, exist_ok=True) # Storage files self.meta_insights_file = os.path.join(self.meta_learning_dir, "meta_pattern_insights.json") self.creation_strategies_file = os.path.join(self.meta_learning_dir, "pattern_creation_strategies.json") self.learning_events_file = os.path.join(self.meta_learning_dir, "meta_learning_events.jsonl") self.synthesis_log_file = os.path.join(self.meta_learning_dir, "pattern_synthesis_log.jsonl") # Core data structures self.meta_insights: Dict[str, MetaPatternInsight] = {} self.creation_strategies: Dict[str, PatternCreationStrategy] = {} self.learning_events: List[MetaLearningEvent] = [] # Load existing data and initialize systems self._load_existing_data() self._initialize_system_connections() self._initialize_base_meta_patterns() def _initialize_system_connections(self): """Initialize connections to other MIRA intelligence systems with lazy loading.""" # Use lazy initialization to avoid circular dependencies # Systems will be loaded when first accessed self._adaptive_pattern_system = None self._confidence_system = None self._contextual_activation = None self._domain_generator = None @property def adaptive_pattern_system(self): """Lazy-loaded adaptive pattern system.""" if self._adaptive_pattern_system is None: try: from intelligence.adaptive_pattern_evolution import get_adaptive_pattern_evolution self._adaptive_pattern_system = get_adaptive_pattern_evolution(self.memory_dir) except Exception as e: logger.debug(f"Failed to connect to adaptive pattern system: {e}") return self._adaptive_pattern_system @property def confidence_system(self): """Lazy-loaded confidence system.""" if self._confidence_system is None: try: from intelligence.pattern_confidence_system import get_pattern_confidence_system self._confidence_system = get_pattern_confidence_system(self.memory_dir) except Exception as e: logger.debug(f"Failed to connect to confidence system: {e}") return self._confidence_system @property def contextual_activation(self): """Lazy-loaded contextual activation system.""" if self._contextual_activation is None: try: from intelligence.contextual_pattern_activation import get_contextual_pattern_activation self._contextual_activation = get_contextual_pattern_activation(self.memory_dir) except Exception as e: logger.debug(f"Failed to connect to contextual activation: {e}") return self._contextual_activation @property def domain_generator(self): """Lazy-loaded domain generator.""" if self._domain_generator is None: try: from intelligence.domain_aware_pattern_generator import get_domain_pattern_generator self._domain_generator = get_domain_pattern_generator(self.memory_dir) except Exception as e: logger.debug(f"Failed to connect to domain generator: {e}") return self._domain_generator def _load_existing_data(self): """Load existing meta-learning data.""" # Load meta insights if os.path.exists(self.meta_insights_file): try: with open(self.meta_insights_file, 'r') as f: data = json.load(f) for insight_id, insight_data in data.items(): # Convert enum strings back to enums insight_data['meta_pattern_type'] = MetaPatternType(insight_data['meta_pattern_type']) insight_data['learning_dimension'] = LearningDimension(insight_data['learning_dimension']) self.meta_insights[insight_id] = MetaPatternInsight(**insight_data) logger.info(f"๐Ÿง  META: Loaded {len(self.meta_insights)} meta-pattern insights") except Exception as e: logger.error(f"Failed to load meta insights: {e}") # Load creation strategies if os.path.exists(self.creation_strategies_file): try: with open(self.creation_strategies_file, 'r') as f: data = json.load(f) for strategy_id, strategy_data in data.items(): self.creation_strategies[strategy_id] = PatternCreationStrategy(**strategy_data) logger.info(f"๐Ÿง  META: Loaded {len(self.creation_strategies)} pattern creation strategies") except Exception as e: logger.error(f"Failed to load creation strategies: {e}") def _save_meta_insights(self): """Save meta-pattern insights to storage.""" try: data = {} for insight_id, insight in self.meta_insights.items(): insight_data = asdict(insight) # Convert enums to strings for JSON serialization insight_data['meta_pattern_type'] = insight.meta_pattern_type.value insight_data['learning_dimension'] = insight.learning_dimension.value data[insight_id] = insight_data with open(self.meta_insights_file, 'w') as f: json.dump(data, f, indent=2) except Exception as e: logger.error(f"Failed to save meta insights: {e}") def _save_creation_strategies(self): """Save pattern creation strategies to storage.""" try: data = {} for strategy_id, strategy in self.creation_strategies.items(): data[strategy_id] = asdict(strategy) with open(self.creation_strategies_file, 'w') as f: json.dump(data, f, indent=2) except Exception as e: logger.error(f"Failed to save creation strategies: {e}") def _log_learning_event(self, event: MetaLearningEvent): """Log a meta-learning event.""" try: with open(self.learning_events_file, 'a') as f: f.write(json.dumps(asdict(event)) + '\n') except Exception as e: logger.debug(f"Failed to log learning event: {e}") def _initialize_base_meta_patterns(self): """Initialize base meta-patterns if none exist.""" if self.meta_insights: return # Already have meta-patterns base_insights = [ # Pattern Creation Meta-Patterns MetaPatternInsight( insight_id="high_usage_domains_need_patterns", meta_pattern_type=MetaPatternType.PATTERN_CREATION, learning_dimension=LearningDimension.BEHAVIORAL, description="Domains with high user activity need specialized patterns", confidence=0.8, evidence_count=0, success_rate=0.0, contexts_applied=[], generated_patterns=[], created_at=datetime.datetime.now().isoformat(), last_validated="", validation_score=0.0 ), # Success Prediction Meta-Patterns MetaPatternInsight( insight_id="specific_patterns_outperform_general", meta_pattern_type=MetaPatternType.SUCCESS_PREDICTION, learning_dimension=LearningDimension.PERFORMANCE, description="Specific, targeted patterns tend to outperform general ones", confidence=0.7, evidence_count=0, success_rate=0.0, contexts_applied=[], generated_patterns=[], created_at=datetime.datetime.now().isoformat(), last_validated="", validation_score=0.0 ), # Context Transfer Meta-Patterns MetaPatternInsight( insight_id="debugging_patterns_transfer_domains", meta_pattern_type=MetaPatternType.CONTEXT_TRANSFER, learning_dimension=LearningDimension.CONTEXTUAL, description="Debugging patterns transfer well across different project domains", confidence=0.6, evidence_count=0, success_rate=0.0, contexts_applied=[], generated_patterns=[], created_at=datetime.datetime.now().isoformat(), last_validated="", validation_score=0.0 ), # Evolution Strategy Meta-Patterns MetaPatternInsight( insight_id="gradual_confidence_increase_better", meta_pattern_type=MetaPatternType.EVOLUTION_STRATEGY, learning_dimension=LearningDimension.TEMPORAL, description="Gradually increasing pattern confidence over time works better than high initial confidence", confidence=0.75, evidence_count=0, success_rate=0.0, contexts_applied=[], generated_patterns=[], created_at=datetime.datetime.now().isoformat(), last_validated="", validation_score=0.0 ), # Confidence Calibration Meta-Patterns MetaPatternInsight( insight_id="user_feedback_improves_calibration", meta_pattern_type=MetaPatternType.CONFIDENCE_CALIBRATION, learning_dimension=LearningDimension.BEHAVIORAL, description="Patterns that incorporate user feedback have better confidence calibration", confidence=0.8, evidence_count=0, success_rate=0.0, contexts_applied=[], generated_patterns=[], created_at=datetime.datetime.now().isoformat(), last_validated="", validation_score=0.0 ), # Retirement Decision Meta-Patterns MetaPatternInsight( insight_id="early_retirement_prevents_degradation", meta_pattern_type=MetaPatternType.RETIREMENT_DECISION, learning_dimension=LearningDimension.PERFORMANCE, description="Early retirement of declining patterns prevents overall system degradation", confidence=0.7, evidence_count=0, success_rate=0.0, contexts_applied=[], generated_patterns=[], created_at=datetime.datetime.now().isoformat(), last_validated="", validation_score=0.0 ) ] for insight in base_insights: self.meta_insights[insight.insight_id] = insight # Initialize base creation strategies base_strategies = [ PatternCreationStrategy( strategy_id="contextual_specialization", name="Contextual Specialization Strategy", description="Create specialized patterns for high-activity contexts", trigger_conditions={ "min_context_activity": 10, "pattern_gap_detected": True, "user_behavior_consistent": True }, creation_rules=[ "Analyze context for specific vocabulary and patterns", "Create narrow, focused patterns rather than broad ones", "Set initial confidence based on context specificity", "Include context requirements in pattern definition" ], success_indicators=[ "High user satisfaction scores", "Consistent pattern matching", "Low false positive rate" ], failure_indicators=[ "Low usage despite high activity context", "High false positive rate", "User feedback indicates irrelevance" ], confidence_formula="base_confidence * context_specificity * user_activity_score", applicability_score=0.8, usage_count=0, success_count=0, average_pattern_lifespan=0.0, generated_pattern_quality=0.0 ), PatternCreationStrategy( strategy_id="evolutionary_adaptation", name="Evolutionary Adaptation Strategy", description="Evolve existing patterns based on usage patterns", trigger_conditions={ "existing_pattern_declining": True, "usage_data_sufficient": True, "similar_context_success": True }, creation_rules=[ "Identify successful elements from related patterns", "Combine successful elements with new context requirements", "Gradually increase specificity based on usage feedback", "Maintain backward compatibility where possible" ], success_indicators=[ "Improved performance over parent pattern", "Sustained usage over time", "Positive user feedback trends" ], failure_indicators=[ "Performance worse than parent pattern", "Rapid usage decline", "Confusion with existing patterns" ], confidence_formula="parent_confidence * improvement_factor * context_relevance", applicability_score=0.7, usage_count=0, success_count=0, average_pattern_lifespan=0.0, generated_pattern_quality=0.0 ) ] for strategy in base_strategies: self.creation_strategies[strategy.strategy_id] = strategy self._save_meta_insights() self._save_creation_strategies() logger.info(f"๐Ÿง  META: Initialized {len(base_insights)} meta-insights and {len(base_strategies)} creation strategies") def analyze_pattern_creation_success(self, pattern_id: str, success_metrics: Dict[str, float]) -> List[MetaPatternInsight]: """Analyze why a pattern creation was successful and extract meta-insights.""" new_insights = [] try: # Get pattern details from adaptive system if not self.adaptive_pattern_system: return new_insights pattern = self.adaptive_pattern_system.evolutionary_patterns.get(pattern_id) if not pattern: return new_insights # Analyze success factors confidence = success_metrics.get('confidence', 0.0) usage_count = success_metrics.get('usage_count', 0) success_rate = success_metrics.get('success_rate', 0.0) user_satisfaction = success_metrics.get('user_satisfaction', 0.0) # Generate meta-insights based on success patterns if success_rate > 0.8 and usage_count > 10: # High success pattern - learn from it if pattern.domain_context: insight = self._generate_domain_success_insight(pattern, success_metrics) if insight: new_insights.append(insight) if len(pattern.keywords) > 5: insight = self._generate_specificity_insight(pattern, success_metrics) if insight: new_insights.append(insight) if user_satisfaction > 0.8: insight = self._generate_user_preference_insight(pattern, success_metrics) if insight: new_insights.append(insight) # Learn from failure patterns too elif success_rate < 0.3 and usage_count > 5: insight = self._generate_failure_insight(pattern, success_metrics) if insight: new_insights.append(insight) # Update existing insights with new evidence self._update_insights_with_evidence(pattern, success_metrics) # Log the learning event for insight in new_insights: event = MetaLearningEvent( timestamp=datetime.datetime.now().isoformat(), event_type="pattern_success_analysis", pattern_id=pattern_id, meta_insight_gained=insight.description, evidence_strength=confidence, learning_context={ "pattern_type": pattern.pattern_type.value, "domain": pattern.domain_context, "success_rate": success_rate, "usage_count": usage_count }, impact_prediction=self._predict_insight_impact(insight) ) self._log_learning_event(event) logger.info(f"๐Ÿง  META: Generated {len(new_insights)} new meta-insights from pattern {pattern_id}") return new_insights except Exception as e: logger.error(f"Failed to analyze pattern creation success: {e}") return new_insights def _generate_domain_success_insight(self, pattern, metrics: Dict[str, float]) -> Optional[MetaPatternInsight]: """Generate insight about domain-specific pattern success.""" if not pattern.domain_context: return None insight_id = f"domain_success_{pattern.domain_context}_{datetime.datetime.now().strftime('%Y%m%d')}" return MetaPatternInsight( insight_id=insight_id, meta_pattern_type=MetaPatternType.SUCCESS_PREDICTION, learning_dimension=LearningDimension.CONTEXTUAL, description=f"Patterns in {pattern.domain_context} domain benefit from specific vocabulary and context awareness", confidence=min(0.9, metrics.get('success_rate', 0.0) * 1.1), evidence_count=1, success_rate=metrics.get('success_rate', 0.0), contexts_applied=[pattern.domain_context], generated_patterns=[pattern.pattern_id], created_at=datetime.datetime.now().isoformat(), last_validated="", validation_score=metrics.get('user_satisfaction', 0.5) ) def _generate_specificity_insight(self, pattern, metrics: Dict[str, float]) -> Optional[MetaPatternInsight]: """Generate insight about pattern specificity and success.""" keyword_count = len(pattern.keywords) specificity_score = min(1.0, keyword_count / 10.0) insight_id = f"specificity_success_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}" return MetaPatternInsight( insight_id=insight_id, meta_pattern_type=MetaPatternType.PATTERN_CREATION, learning_dimension=LearningDimension.STRUCTURAL, description=f"Patterns with {keyword_count} keywords show high success - optimal specificity range identified", confidence=0.7 + (specificity_score * 0.2), evidence_count=1, success_rate=metrics.get('success_rate', 0.0), contexts_applied=[pattern.pattern_type.value], generated_patterns=[pattern.pattern_id], created_at=datetime.datetime.now().isoformat(), last_validated="", validation_score=metrics.get('confidence', 0.5) ) def _generate_user_preference_insight(self, pattern, metrics: Dict[str, float]) -> Optional[MetaPatternInsight]: """Generate insight about user preference patterns.""" insight_id = f"user_preference_{pattern.pattern_type.value}_{datetime.datetime.now().strftime('%Y%m%d')}" return MetaPatternInsight( insight_id=insight_id, meta_pattern_type=MetaPatternType.USER_PREFERENCE_LEARNING, learning_dimension=LearningDimension.BEHAVIORAL, description=f"Users show high satisfaction with {pattern.pattern_type.value} patterns that include specific context requirements", confidence=0.8, evidence_count=1, success_rate=metrics.get('success_rate', 0.0), contexts_applied=[pattern.pattern_type.value], generated_patterns=[pattern.pattern_id], created_at=datetime.datetime.now().isoformat(), last_validated="", validation_score=metrics.get('user_satisfaction', 0.5) ) def _generate_failure_insight(self, pattern, metrics: Dict[str, float]) -> Optional[MetaPatternInsight]: """Generate insight from pattern failures.""" insight_id = f"failure_analysis_{pattern.pattern_type.value}_{datetime.datetime.now().strftime('%Y%m%d')}" # Analyze potential failure reasons failure_reason = "unknown" if len(pattern.keywords) < 3: failure_reason = "insufficient_specificity" elif not pattern.context_requirements: failure_reason = "missing_context_requirements" elif pattern.confidence_score > 0.8: failure_reason = "overconfidence" return MetaPatternInsight( insight_id=insight_id, meta_pattern_type=MetaPatternType.RETIREMENT_DECISION, learning_dimension=LearningDimension.PERFORMANCE, description=f"Patterns failing due to {failure_reason} should be retired early to prevent resource waste", confidence=0.6, evidence_count=1, success_rate=0.0, # This is a failure insight contexts_applied=[pattern.pattern_type.value], generated_patterns=[], created_at=datetime.datetime.now().isoformat(), last_validated="", validation_score=1.0 - metrics.get('success_rate', 1.0) # Inverted for failure ) def _update_insights_with_evidence(self, pattern, metrics: Dict[str, float]): """Update existing insights with new evidence.""" for insight in self.meta_insights.values(): # Check if this pattern provides evidence for existing insights if pattern.domain_context in insight.contexts_applied: insight.evidence_count += 1 insight.success_rate = (insight.success_rate * (insight.evidence_count - 1) + metrics.get('success_rate', 0.0)) / insight.evidence_count insight.last_validated = datetime.datetime.now().isoformat() # Update confidence based on accumulating evidence evidence_factor = min(1.2, 1.0 + (insight.evidence_count * 0.02)) insight.confidence = min(0.95, insight.confidence * evidence_factor) def _predict_insight_impact(self, insight: MetaPatternInsight) -> float: """Predict the potential impact of a meta-insight.""" base_impact = insight.confidence * insight.success_rate # Factor in the meta-pattern type importance type_multipliers = { MetaPatternType.PATTERN_CREATION: 1.2, MetaPatternType.SUCCESS_PREDICTION: 1.1, MetaPatternType.CONTEXT_TRANSFER: 1.0, MetaPatternType.EVOLUTION_STRATEGY: 0.9, MetaPatternType.CONFIDENCE_CALIBRATION: 0.8, MetaPatternType.RETIREMENT_DECISION: 0.7 } type_multiplier = type_multipliers.get(insight.meta_pattern_type, 1.0) return base_impact * type_multiplier def synthesize_new_patterns(self, context: Dict[str, Any]) -> List[Dict[str, Any]]: """Synthesize new patterns based on meta-learning insights.""" synthesized_patterns = [] try: # Get applicable creation strategies applicable_strategies = self._get_applicable_strategies(context) for strategy in applicable_strategies: # Use meta-insights to guide pattern creation relevant_insights = self._get_relevant_insights(context, strategy) if relevant_insights: # Synthesize a new pattern based on strategy and insights pattern_spec = self._synthesize_pattern_specification(strategy, relevant_insights, context) if pattern_spec: synthesized_patterns.append(pattern_spec) # Update strategy usage strategy.usage_count += 1 # Log synthesis synthesis_log = { "timestamp": datetime.datetime.now().isoformat(), "strategy_used": strategy.strategy_id, "insights_applied": [insight.insight_id for insight in relevant_insights], "context": context, "pattern_specification": pattern_spec } with open(self.synthesis_log_file, 'a') as f: f.write(json.dumps(synthesis_log) + '\n') self._save_creation_strategies() logger.info(f"๐Ÿง  META: Synthesized {len(synthesized_patterns)} new patterns using meta-learning") return synthesized_patterns except Exception as e: logger.error(f"Failed to synthesize new patterns: {e}") return synthesized_patterns def _get_applicable_strategies(self, context: Dict[str, Any]) -> List[PatternCreationStrategy]: """Get creation strategies applicable to the current context.""" applicable = [] for strategy in self.creation_strategies.values(): if self._strategy_matches_context(strategy, context): applicable.append(strategy) # Sort by success rate and applicability applicable.sort(key=lambda s: s.get_success_rate() * s.applicability_score, reverse=True) return applicable[:3] # Top 3 strategies def _strategy_matches_context(self, strategy: PatternCreationStrategy, context: Dict[str, Any]) -> bool: """Check if a strategy matches the current context.""" conditions = strategy.trigger_conditions for condition, required_value in conditions.items(): if condition == "min_context_activity": activity = context.get('activity_level', 0) if activity < required_value: return False elif condition == "pattern_gap_detected": if not context.get('pattern_gap', False): return False elif condition == "user_behavior_consistent": if not context.get('behavior_consistent', False): return False elif condition == "existing_pattern_declining": if not context.get('declining_patterns', False): return False return True def _get_relevant_insights(self, context: Dict[str, Any], strategy: PatternCreationStrategy) -> List[MetaPatternInsight]: """Get meta-insights relevant to the context and strategy.""" relevant = [] for insight in self.meta_insights.values(): # Check if insight is relevant to current context context_match = False if context.get('domain') in insight.contexts_applied: context_match = True elif context.get('pattern_type') in insight.contexts_applied: context_match = True elif not insight.contexts_applied: # General insights context_match = True # Check if insight is relevant to strategy strategy_match = False if strategy.strategy_id == "contextual_specialization" and insight.meta_pattern_type in [ MetaPatternType.PATTERN_CREATION, MetaPatternType.SUCCESS_PREDICTION ]: strategy_match = True elif strategy.strategy_id == "evolutionary_adaptation" and insight.meta_pattern_type in [ MetaPatternType.EVOLUTION_STRATEGY, MetaPatternType.CONTEXT_TRANSFER ]: strategy_match = True if context_match and strategy_match and insight.confidence > 0.5: relevant.append(insight) # Sort by confidence and evidence relevant.sort(key=lambda i: i.confidence * math.log(i.evidence_count + 1), reverse=True) return relevant[:5] # Top 5 insights def _synthesize_pattern_specification(self, strategy: PatternCreationStrategy, insights: List[MetaPatternInsight], context: Dict[str, Any]) -> Optional[Dict[str, Any]]: """Synthesize a pattern specification using strategy and insights.""" try: # Base pattern specification pattern_spec = { "pattern_id": f"meta_synthesized_{datetime.datetime.now().strftime('%Y%m%d_%H%M%S')}", "pattern_type": context.get('pattern_type', 'domain_specific'), "creation_method": "meta_learning_synthesis", "strategy_used": strategy.strategy_id, "insights_applied": [insight.insight_id for insight in insights] } # Apply strategy rules keywords = [] context_requirements = [] confidence_base = 0.5 # Extract guidance from insights for insight in insights: if insight.meta_pattern_type == MetaPatternType.PATTERN_CREATION: if "specific" in insight.description.lower(): keywords.extend(context.get('specific_terms', [])) if "context" in insight.description.lower(): context_requirements.extend(context.get('context_indicators', [])) elif insight.meta_pattern_type == MetaPatternType.SUCCESS_PREDICTION: if "domain" in insight.description.lower(): keywords.extend(context.get('domain_vocabulary', [])) elif insight.meta_pattern_type == MetaPatternType.CONFIDENCE_CALIBRATION: if "gradual" in insight.description.lower(): confidence_base = 0.4 # Start lower for gradual increase elif "user feedback" in insight.description.lower(): confidence_base = 0.6 # Higher if user feedback incorporated # Apply strategy-specific rules if strategy.strategy_id == "contextual_specialization": # Make patterns more specific if len(keywords) < 3: keywords.extend(context.get('additional_terms', [])) confidence_base *= 0.9 # Slightly lower for new specialized patterns elif strategy.strategy_id == "evolutionary_adaptation": # Build on existing patterns parent_patterns = context.get('related_patterns', []) if parent_patterns: confidence_base *= 1.1 # Higher confidence for evolved patterns # Finalize pattern specification pattern_spec.update({ "keywords": list(set(keywords))[:10], # Limit to 10 keywords "context_requirements": list(set(context_requirements)), "confidence_score": min(0.8, confidence_base), "domain_context": context.get('domain'), "regex_pattern": self._generate_regex_from_keywords(keywords), "meta_learning_confidence": statistics.mean([i.confidence for i in insights]) }) return pattern_spec except Exception as e: logger.error(f"Failed to synthesize pattern specification: {e}") return None def _generate_regex_from_keywords(self, keywords: List[str]) -> str: """Generate a regex pattern from keywords using meta-learning insights.""" if not keywords: return r"\w+" # Apply meta-learning insights about regex generation escaped_keywords = [keyword.replace(' ', r'\s+') for keyword in keywords] # Use insights about specificity if len(keywords) <= 3: # For few keywords, use OR pattern return f"({'|'.join(escaped_keywords)})" else: # For many keywords, use word boundary pattern pattern_parts = [f"\\b{keyword}\\b" for keyword in escaped_keywords[:5]] return f"({'|'.join(pattern_parts)})" def evolve_meta_insights(self) -> Dict[str, Any]: """Evolve meta-insights based on accumulated evidence and performance.""" evolution_results = { "insights_evolved": 0, "insights_retired": 0, "new_insights_discovered": 0, "strategies_updated": 0 } try: # Evolve existing insights for insight in list(self.meta_insights.values()): if insight.evidence_count >= 5: # Sufficient evidence for evolution if insight.success_rate > 0.8: # Promote high-performing insights insight.confidence = min(0.95, insight.confidence * 1.1) evolution_results["insights_evolved"] += 1 elif insight.success_rate < 0.3: # Retire low-performing insights del self.meta_insights[insight.insight_id] evolution_results["insights_retired"] += 1 # Discover new insights from cross-pattern analysis new_insights = self._discover_emergent_insights() evolution_results["new_insights_discovered"] = len(new_insights) # Update creation strategies based on performance for strategy in self.creation_strategies.values(): if strategy.usage_count >= 3: old_score = strategy.applicability_score strategy.applicability_score = strategy.get_success_rate() * 0.8 + old_score * 0.2 if abs(strategy.applicability_score - old_score) > 0.05: evolution_results["strategies_updated"] += 1 # Save evolved state self._save_meta_insights() self._save_creation_strategies() logger.info(f"๐Ÿง  META: Evolved insights - {evolution_results}") return evolution_results except Exception as e: logger.error(f"Failed to evolve meta-insights: {e}") return evolution_results def _discover_emergent_insights(self) -> List[MetaPatternInsight]: """Discover new emergent insights from pattern combinations.""" new_insights = [] # Look for patterns in successful insight combinations try: # Analyze which insights tend to be used together successfully insight_combinations = self._analyze_insight_combinations() for combo, success_rate in insight_combinations.items(): if success_rate > 0.8 and len(combo) >= 2: # Create emergent insight insight_id = f"emergent_{'_'.join(combo[:2])}_{datetime.datetime.now().strftime('%Y%m%d')}" emergent_insight = MetaPatternInsight( insight_id=insight_id, meta_pattern_type=MetaPatternType.CROSS_PATTERN_SYNTHESIS, learning_dimension=LearningDimension.SEMANTIC, description=f"Combining insights {' + '.join(combo[:2])} yields high success rates", confidence=0.7, evidence_count=1, success_rate=success_rate, contexts_applied=[], generated_patterns=[], created_at=datetime.datetime.now().isoformat(), last_validated="", validation_score=success_rate ) new_insights.append(emergent_insight) self.meta_insights[insight_id] = emergent_insight except Exception as e: logger.debug(f"Failed to discover emergent insights: {e}") return new_insights def _analyze_insight_combinations(self) -> Dict[Tuple[str], float]: """Analyze which insight combinations are most successful.""" combinations = {} # This would analyze the synthesis log to find successful combinations # For now, return empty dict as placeholder return combinations def get_meta_learning_statistics(self) -> Dict[str, Any]: """Get comprehensive statistics about meta-learning progress.""" stats = { "total_meta_insights": len(self.meta_insights), "creation_strategies": len(self.creation_strategies), "insights_by_type": {}, "strategies_by_success": {}, "learning_velocity": 0.0, "intelligence_growth_indicators": {} } # Insights by type for insight in self.meta_insights.values(): type_name = insight.meta_pattern_type.value if type_name not in stats["insights_by_type"]: stats["insights_by_type"][type_name] = { "count": 0, "avg_confidence": 0.0, "avg_evidence": 0.0 } type_stats = stats["insights_by_type"][type_name] type_stats["count"] += 1 type_stats["avg_confidence"] = (type_stats["avg_confidence"] * (type_stats["count"] - 1) + insight.confidence) / type_stats["count"] type_stats["avg_evidence"] = (type_stats["avg_evidence"] * (type_stats["count"] - 1) + insight.evidence_count) / type_stats["count"] # Strategies by success for strategy in self.creation_strategies.values(): stats["strategies_by_success"][strategy.strategy_id] = { "name": strategy.name, "success_rate": strategy.get_success_rate(), "usage_count": strategy.usage_count, "applicability": strategy.applicability_score } # Learning velocity (insights gained per day) if self.meta_insights: creation_dates = [datetime.datetime.fromisoformat(i.created_at) for i in self.meta_insights.values()] if len(creation_dates) > 1: date_range = (max(creation_dates) - min(creation_dates)).days + 1 stats["learning_velocity"] = len(self.meta_insights) / date_range # Intelligence growth indicators high_confidence_insights = len([i for i in self.meta_insights.values() if i.confidence > 0.8]) well_evidenced_insights = len([i for i in self.meta_insights.values() if i.evidence_count >= 3]) stats["intelligence_growth_indicators"] = { "high_confidence_insights": high_confidence_insights, "well_evidenced_insights": well_evidenced_insights, "cross_domain_transfer": len([i for i in self.meta_insights.values() if len(i.contexts_applied) > 1]), "exponential_growth_score": self._calculate_exponential_growth_score() } return stats def _calculate_exponential_growth_score(self) -> float: """Calculate a score indicating exponential intelligence growth.""" if len(self.meta_insights) < 3: return 0.0 # Factors that indicate exponential growth meta_insight_coverage = len(set(i.meta_pattern_type for i in self.meta_insights.values())) / len(MetaPatternType) strategy_effectiveness = statistics.mean([s.get_success_rate() for s in self.creation_strategies.values()]) if self.creation_strategies else 0.0 insight_confidence = statistics.mean([i.confidence for i in self.meta_insights.values()]) # Combine factors growth_score = (meta_insight_coverage * 0.4 + strategy_effectiveness * 0.3 + insight_confidence * 0.3) return min(1.0, growth_score) def get_meta_pattern_learning(memory_dir: str) -> MetaPatternLearning: """Get the meta-pattern learning system instance.""" return MetaPatternLearning(memory_dir) # Example usage and testing if __name__ == "__main__": import tempfile # Test the meta-pattern learning system with tempfile.TemporaryDirectory() as temp_dir: meta_learning = MetaPatternLearning(temp_dir) print("๐Ÿงช Testing Meta-Pattern Learning System") # Test pattern success analysis success_metrics = { "confidence": 0.85, "usage_count": 15, "success_rate": 0.9, "user_satisfaction": 0.88 } # This would normally be called with real pattern data print(f"๐Ÿ“Š Testing success analysis...") # Test pattern synthesis context = { "domain": "web_development", "pattern_type": "domain_specific", "activity_level": 12, "pattern_gap": True, "behavior_consistent": True, "specific_terms": ["react", "component", "props"], "domain_vocabulary": ["jsx", "hook", "state"], "context_indicators": ["frontend", "ui"] } synthesized = meta_learning.synthesize_new_patterns(context) print(f"๐ŸŽฏ Synthesized {len(synthesized)} new patterns using meta-learning") # Test meta-insight evolution evolution_results = meta_learning.evolve_meta_insights() print(f"๐Ÿง  Evolution results: {evolution_results}") # Get statistics stats = meta_learning.get_meta_learning_statistics() print(f"๐Ÿ“ˆ Meta-learning statistics:") print(f" Total insights: {stats['total_meta_insights']}") print(f" Creation strategies: {stats['creation_strategies']}") print(f" Exponential growth score: {stats['intelligence_growth_indicators']['exponential_growth_score']:.2f}") print(f"\n๐Ÿง  META-PATTERN LEARNING: System operational and learning!")