"""
Pattern 57: Meta-Learning

Purpose: Learn how to learn - optimize learning algorithms and strategies themselves.
"Learning to learn" by improving the learning process across multiple tasks.
"""

from typing import Dict, Any, List, Optional, Tuple
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
import random
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI


class MetaStrategy(Enum):
    """Meta-learning strategies."""
    MAML = "maml"  # Model-Agnostic Meta-Learning
    REPTILE = "reptile"  # Simplified MAML
    LEARNING_TO_COMPARE = "learning_to_compare"  # Siamese networks
    OPTIMIZATION_AS_MODEL = "optimization_as_model"  # Learn optimizer


@dataclass
class Task:
    """A learning task."""
    id: str
    name: str
    domain: str
    examples: List[Dict[str, Any]] = field(default_factory=list)
    difficulty: float = 0.5
    metadata: Dict[str, Any] = field(default_factory=dict)


@dataclass
class LearningExperience:
    """Experience from learning a task."""
    task_id: str
    strategy_used: str
    initial_performance: float
    final_performance: float
    learning_rate: float
    steps_taken: int
    insights: List[str] = field(default_factory=list)
    timestamp: datetime = field(default_factory=datetime.now)


@dataclass
class MetaKnowledge:
    """Meta-level knowledge about learning."""
    strategy: str
    effectiveness: float
    best_domains: List[str]
    optimal_learning_rate: float
    optimal_batch_size: int
    learned_from_tasks: int
    confidence: float


class MetaLearningAgent:
    """
    Meta-Learning Agent - Learn how to learn.
    
    Optimizes the learning process itself by learning from experience
    across multiple tasks. Discovers optimal learning strategies,
    hyperparameters, and approaches.
    """
    
    def __init__(self, 
                 name: str,
                 strategy: MetaStrategy = MetaStrategy.MAML):
        self.name = name
        self.strategy = strategy
        self.llm = ChatOpenAI(model="gpt-4", temperature=0.3)
        
        # Meta-knowledge base
        self.learning_experiences: List[LearningExperience] = []
        self.meta_knowledge: Dict[str, MetaKnowledge] = {}
        
        # Learned meta-parameters
        self.optimal_learning_rate: float = 0.01
        self.optimal_batch_size: int = 32
        self.adaptation_steps: int = 5
        
        # Performance tracking
        self.tasks_learned: int = 0
        self.meta_updates: int = 0
        
        # Statistics
        self.statistics: Dict[str, Any] = {
            "avg_initial_performance": 0.0,
            "avg_final_performance": 0.0,
            "avg_improvement": 0.0,
            "best_strategy": None
        }
    
    def meta_train(self, tasks: List[Task]):
        """Meta-train on multiple tasks to learn how to learn."""
        print(f"\n   {self.name}: Meta-training on {len(tasks)} tasks...")
        
        for task in tasks:
            # Learn the task
            experience = self._learn_task(task)
            self.learning_experiences.append(experience)
            self.tasks_learned += 1
            
            # Update meta-knowledge
            self._update_meta_knowledge(experience)
            self.meta_updates += 1
            
            if self.tasks_learned % 5 == 0:
                print(f"   Meta-trained on {self.tasks_learned} tasks...")
        
        # Extract meta-level insights
        self._extract_meta_insights()
        
        print(f"   Meta-training complete! Learned from {self.tasks_learned} tasks")
    
    def _learn_task(self, task: Task) -> LearningExperience:
        """Learn a single task and record the experience."""
        # Simulate initial performance
        initial_perf = random.uniform(0.3, 0.5)
        
        # Apply current meta-knowledge
        learning_rate = self.optimal_learning_rate
        batch_size = self.optimal_batch_size
        
        # Simulate learning with current strategy
        final_perf = initial_perf
        steps = 0
        
        for step in range(self.adaptation_steps):
            # Simulate improvement based on strategy effectiveness
            if self.strategy == MetaStrategy.MAML:
                improvement = 0.08 * (1.0 - final_perf)  # Fast adaptation
            elif self.strategy == MetaStrategy.REPTILE:
                improvement = 0.06 * (1.0 - final_perf)
            elif self.strategy == MetaStrategy.LEARNING_TO_COMPARE:
                improvement = 0.07 * (1.0 - final_perf)
            else:  # OPTIMIZATION_AS_MODEL
                improvement = 0.09 * (1.0 - final_perf)
            
            # Add some randomness
            improvement *= random.uniform(0.8, 1.2)
            final_perf = min(0.95, final_perf + improvement)
            steps += 1
            
            # Early stopping if good enough
            if final_perf > 0.85:
                break
        
        # Generate insights using LLM
        insights = self._generate_learning_insights(task, initial_perf, final_perf, steps)
        
        return LearningExperience(
            task_id=task.id,
            strategy_used=self.strategy.value,
            initial_performance=initial_perf,
            final_performance=final_perf,
            learning_rate=learning_rate,
            steps_taken=steps,
            insights=insights
        )
    
    def _generate_learning_insights(self, 
                                    task: Task,
                                    initial_perf: float,
                                    final_perf: float,
                                    steps: int) -> List[str]:
        """Generate insights about the learning process."""
        prompt = ChatPromptTemplate.from_messages([
            ("system", "You are a meta-learning expert analyzing learning experiences. "
                      "Provide 2-3 brief insights about what made this learning process effective or ineffective."),
            ("human", f"Task: {task.name} (domain: {task.domain})\n"
                     f"Strategy: {self.strategy.value}\n"
                     f"Initial Performance: {initial_perf:.2%}\n"
                     f"Final Performance: {final_perf:.2%}\n"
                     f"Steps: {steps}\n"
                     f"Improvement: {final_perf - initial_perf:.2%}\n\n"
                     f"Provide 2-3 brief insights (one per line):")
        ])
        
        chain = prompt | self.llm
        insights = []
        
        try:
            response = chain.invoke({})
            content = response.content if isinstance(response.content, str) else str(response.content)
            lines = content.strip().split('\n')
            insights = [line.strip('- ').strip() for line in lines if line.strip()][:3]
        except:
            insights = [
                f"Improved from {initial_perf:.2%} to {final_perf:.2%}",
                f"Required {steps} adaptation steps",
                f"Strategy {self.strategy.value} was effective"
            ]
        
        return insights
    
    def _update_meta_knowledge(self, experience: LearningExperience):
        """Update meta-knowledge based on learning experience."""
        strategy_key = experience.strategy_used
        
        if strategy_key not in self.meta_knowledge:
            self.meta_knowledge[strategy_key] = MetaKnowledge(
                strategy=strategy_key,
                effectiveness=0.0,
                best_domains=[],
                optimal_learning_rate=self.optimal_learning_rate,
                optimal_batch_size=self.optimal_batch_size,
                learned_from_tasks=0,
                confidence=0.0
            )
        
        meta = self.meta_knowledge[strategy_key]
        
        # Update effectiveness (moving average)
        improvement = experience.final_performance - experience.initial_performance
        meta.effectiveness = (
            0.9 * meta.effectiveness + 0.1 * improvement
        ) if meta.learned_from_tasks > 0 else improvement
        
        meta.learned_from_tasks += 1
        meta.confidence = min(1.0, meta.learned_from_tasks / 20.0)
        
        # Optimize learning rate based on experience
        if improvement > 0.3:
            # Good improvement, slightly increase LR
            self.optimal_learning_rate = min(0.1, self.optimal_learning_rate * 1.05)
        elif improvement  Dict[str, Any]:
        """Rapidly adapt to a new task using meta-learned knowledge."""
        if not self.meta_knowledge:
            print(f"   {self.name}: No meta-knowledge yet. Learning from scratch...")
            experience = self._learn_task(task)
            return {
                "task": task.name,
                "initial_performance": experience.initial_performance,
                "final_performance": experience.final_performance,
                "steps": experience.steps_taken,
                "used_meta_knowledge": False
            }
        
        print(f"\n   {self.name}: Adapting to new task '{task.name}' using meta-knowledge...")
        
        # Use meta-knowledge for faster adaptation
        best_meta = max(self.meta_knowledge.values(), key=lambda m: m.effectiveness)
        
        # Apply optimal hyperparameters
        old_lr = self.optimal_learning_rate
        old_steps = self.adaptation_steps
        
        self.optimal_learning_rate = best_meta.optimal_learning_rate
        self.adaptation_steps = max(2, self.adaptation_steps // 2)  # Faster adaptation
        
        # Learn with meta-knowledge
        experience = self._learn_task(task)
        
        # Restore
        self.optimal_learning_rate = old_lr
        self.adaptation_steps = old_steps
        
        print(f"   Adapted in {experience.steps_taken} steps "
              f"(improvement: {experience.final_performance - experience.initial_performance:.2%})")
        
        return {
            "task": task.name,
            "initial_performance": experience.initial_performance,
            "final_performance": experience.final_performance,
            "steps": experience.steps_taken,
            "used_meta_knowledge": True,
            "strategy": best_meta.strategy,
            "insights": experience.insights
        }
    
    def get_meta_insights(self) -> str:
        """Get human-readable meta-learning insights."""
        if not self.learning_experiences:
            return "No learning experiences yet."
        
        insights = []
        insights.append(f"Meta-learned from {self.tasks_learned} tasks using {self.strategy.value}")
        insights.append(f"Average improvement: {self.statistics['avg_improvement']:.2%}")
        insights.append(f"Optimal learning rate: {self.optimal_learning_rate:.4f}")
        insights.append(f"Optimal adaptation steps: {self.adaptation_steps}")
        
        if self.meta_knowledge:
            insights.append(f"\nMeta-knowledge acquired:")
            for strategy, meta in self.meta_knowledge.items():
                insights.append(f"  - {strategy}: effectiveness {meta.effectiveness:.2%} "
                              f"(confidence: {meta.confidence:.2%})")
        
        return "\n".join(insights)
    
    def get_statistics(self) -> Dict[str, Any]:
        """Get comprehensive statistics."""
        return {
            "name": self.name,
            "strategy": self.strategy.value,
            "tasks_learned": self.tasks_learned,
            "meta_updates": self.meta_updates,
            "optimal_learning_rate": self.optimal_learning_rate,
            "optimal_batch_size": self.optimal_batch_size,
            "adaptation_steps": self.adaptation_steps,
            **self.statistics
        }


class MetaLearningPattern:
    """
    Meta-Learning Pattern - Learn how to learn.
    
    Coordinates meta-learning agents to optimize learning strategies
    across multiple tasks.
    """
    
    def __init__(self):
        self.agents: Dict[str, MetaLearningAgent] = {}
        self.training_tasks: List[Task] = []
        self.test_tasks: List[Task] = []
    
    def register_agent(self, agent: MetaLearningAgent):
        """Register meta-learning agent."""
        self.agents[agent.name] = agent
        print(f"   Registered agent: {agent.name} ({agent.strategy.value})")
    
    def add_training_tasks(self, tasks: List[Task]):
        """Add tasks for meta-training."""
        self.training_tasks.extend(tasks)
        print(f"   Added {len(tasks)} training tasks (total: {len(self.training_tasks)})")
    
    def add_test_tasks(self, tasks: List[Task]):
        """Add tasks for testing adaptation."""
        self.test_tasks.extend(tasks)
        print(f"   Added {len(tasks)} test tasks")
    
    def meta_train_all(self):
        """Meta-train all agents."""
        print("\n   Meta-training all agents...")
        for agent in self.agents.values():
            agent.meta_train(self.training_tasks)
    
    def test_adaptation(self) -> Dict[str, List[Dict[str, Any]]]:
        """Test rapid adaptation on new tasks."""
        print("\n   Testing adaptation on new tasks...")
        
        results = {}
        for agent_name, agent in self.agents.items():
            agent_results = []
            for task in self.test_tasks:
                result = agent.adapt_to_new_task(task)
                agent_results.append(result)
            results[agent_name] = agent_results
        
        return results
    
    def run(self, 
            training_tasks: List[Task],
            test_tasks: List[Task]) -> Dict[str, Any]:
        """Run meta-learning pipeline."""
        print("=== Meta-Learning Pattern Demo ===\n")
        
        # Add tasks
        print("1. Adding tasks...")
        self.add_training_tasks(training_tasks)
        self.add_test_tasks(test_tasks)
        
        # Meta-train
        print("\n2. Meta-training...")
        self.meta_train_all()
        
        # Test adaptation
        print("\n3. Testing rapid adaptation...")
        adaptation_results = self.test_adaptation()
        
        # Get insights
        print("\n4. Extracting meta-insights...")
        insights = {name: agent.get_meta_insights() 
                   for name, agent in self.agents.items()}
        
        # Get statistics
        stats = {name: agent.get_statistics() 
                for name, agent in self.agents.items()}
        
        return {
            "pattern": "MetaLearning",
            "agents": len(self.agents),
            "training_tasks": len(training_tasks),
            "test_tasks": len(test_tasks),
            "adaptation_results": adaptation_results,
            "insights": insights,
            "statistics": stats
        }


# Example usage
if __name__ == "__main__":
    print("=== Meta-Learning Pattern Demo ===\n")
    
    # Create pattern
    pattern = MetaLearningPattern()
    
    # Create agents with different strategies
    print("1. Creating meta-learning agents...")
    maml_agent = MetaLearningAgent(
        name="MAML_Agent",
        strategy=MetaStrategy.MAML
    )
    pattern.register_agent(maml_agent)
    
    reptile_agent = MetaLearningAgent(
        name="Reptile_Agent",
        strategy=MetaStrategy.REPTILE
    )
    pattern.register_agent(reptile_agent)
    
    # Create training tasks (diverse domains)
    print("\n2. Creating training tasks...")
    training_tasks = [
        Task(id="train_1", name="Sentiment Classification", domain="text", 
             examples=[{"text": "good", "label": "pos"}]),
        Task(id="train_2", name="Spam Detection", domain="text",
             examples=[{"text": "buy now", "label": "spam"}]),
        Task(id="train_3", name="Image Classification", domain="vision",
             examples=[{"image": "cat.jpg", "label": "cat"}]),
        Task(id="train_4", name="Language Translation", domain="text",
             examples=[{"en": "hello", "fr": "bonjour"}]),
        Task(id="train_5", name="Recommendation", domain="recommendation",
             examples=[{"user": "1", "item": "A", "rating": 5}]),
        Task(id="train_6", name="Named Entity Recognition", domain="text",
             examples=[{"text": "John lives in NYC", "entities": ["John", "NYC"]}]),
        Task(id="train_7", name="Question Answering", domain="text",
             examples=[{"q": "What is AI?", "a": "Artificial Intelligence"}]),
        Task(id="train_8", name="Regression", domain="numeric",
             examples=[{"x": 1, "y": 2}]),
    ]
    
    # Create test tasks (new but similar domains)
    print("\n3. Creating test tasks...")
    test_tasks = [
        Task(id="test_1", name="Review Classification", domain="text",
             examples=[{"text": "amazing product", "label": "positive"}]),
        Task(id="test_2", name="Intent Detection", domain="text",
             examples=[{"text": "book a flight", "label": "booking"}]),
    ]
    
    # Run meta-learning
    print("\n4. Running meta-learning pipeline...")
    summary = pattern.run(training_tasks, test_tasks)
    
    print(f"\n5. Results:")
    print(f"   Agents: {summary['agents']}")
    print(f"   Training Tasks: {summary['training_tasks']}")
    print(f"   Test Tasks: {summary['test_tasks']}")
    
    print(f"\n6. Adaptation Results:")
    for agent_name, results in summary['adaptation_results'].items():
        print(f"\n   {agent_name}:")
        for result in results:
            print(f"     {result['task']}: {result['steps']} steps, "
                  f"improvement: {result['final_performance'] - result['initial_performance']:.2%}")
    
    print(f"\n7. Meta-Insights:")
    for agent_name, insight in summary['insights'].items():
        print(f"\n   {agent_name}:")
        for line in insight.split('\n'):
            print(f"   {line}")
    
    print(f"\n8. Statistics:")
    for agent_name, stats in summary['statistics'].items():
        print(f"\n   {agent_name}:")
        for key, value in stats.items():
            if key != "name":
                if isinstance(value, float):
                    print(f"     {key}: {value:.4f}")
                else:
                    print(f"     {key}: {value}")
    
    print("\n✓ Meta-learning enabled rapid adaptation to new tasks!")

    

Agentic Architecture Pattern: Meta Learning

Pattern 57: 57 Meta Learning – Line-by-Line Explanation

Overview

Pattern 57: Meta-Learning

Purpose: Learn how to learn – optimize learning algorithms and strategies themselves. “Learning to learn” by improving the learning process across multiple tasks.

Code Structure Analysis

File Information

• Pattern Number: 57
• Pattern Name: 57 Meta Learning
• File Path: patterns\learning_adaptation\57_meta_learning.py
• Total Lines: 504

Detailed Code Explanation

Module Docstring

"""
Pattern 57: Meta-Learning

Purpose: Learn how to learn - optimize learning algorithms and strategies themselves.
"Learning to learn" by improving the learning process across multiple tasks.
"""

Explanation: This module docstring describes the purpose and key features of the 57 Meta Learning pattern.

Imports Section

from typing import Dict, Any, List, Optional, Tuple
from dataclasses import dataclass, field
from datetime import datetime
from enum import Enum
import random
from langchain_core.prompts import ChatPromptTemplate
from langchain_openai import ChatOpenAI  # First 20 imports shown

Explanation: The module imports necessary dependencies: – from typing import Dict, Any, List, Optional, Tuple: Type hints for better code documentation – from dataclasses import dataclass, field: Data class decorators for clean data structures – from datetime import datetime: Date and time utilities – from enum import Enum: Enumeration support for fixed sets of values – from langchain_core.prompts import ChatPromptTemplate: LangChain framework integration – from langchain_openai import ChatOpenAI: LangChain framework integration

Enumerations

MetaStrategy (Line 17)

class MetaStrategy(Enum):
    MAML
    REPTILE
    LEARNING_TO_COMPARE
    OPTIMIZATION_AS_MODEL

Purpose: Meta-learning strategies.

Values: – MAML: Represents maml – REPTILE: Represents reptile – LEARNING_TO_COMPARE: Represents learning to compare – OPTIMIZATION_AS_MODEL: Represents optimization as model

Classes

MetaStrategy (Line 17)

Description: Meta-learning strategies.

Task (Line 26)

Description: A learning task.

LearningExperience (Line 37)

Description: Experience from learning a task.

MetaKnowledge (Line 50)

Description: Meta-level knowledge about learning.

MetaLearningAgent (Line 61)

Description: Meta-Learning Agent – Learn how to learn.

Optimizes the learning process itself by learning from experience across multiple tasks. Discovers optimal learning strategies, hyperparameters, and approaches.

Methods:

__init__ (Line 70)

def __init__(self, name, strategy):
    """No method docstring."""

Purpose: No method docstring.

Parameters: – self: Instance reference – name: Identifier or label – strategy: Parameter for strategy

meta_train (Line 98)

def meta_train(self, tasks):
    """Meta-train on multiple tasks to learn how to learn."""

Purpose: Meta-train on multiple tasks to learn how to learn.

Parameters: – self: Instance reference – tasks: Parameter for tasks

_learn_task (Line 120)

def _learn_task(self, task):
    """Learn a single task and record the experience."""

Purpose: Learn a single task and record the experience.

Parameters: – self: Instance reference – task: Parameter for task

_generate_learning_insights (Line 166)

def _generate_learning_insights(self, task, initial_perf, final_perf, steps):
    """Generate insights about the learning process."""

Purpose: Generate insights about the learning process.

Parameters: – self: Instance reference – task: Parameter for task – initial_perf: Parameter for initial_perf – final_perf: Parameter for final_perf – steps: Parameter for steps

_update_meta_knowledge (Line 201)

def _update_meta_knowledge(self, experience):
    """Update meta-knowledge based on learning experience."""

Purpose: Update meta-knowledge based on learning experience.

Parameters: – self: Instance reference – experience: Parameter for experience

_extract_meta_insights (Line 235)

def _extract_meta_insights(self):
    """Extract high-level meta-learning insights."""

Purpose: Extract high-level meta-learning insights.

Parameters: – self: Instance reference

adapt_to_new_task (Line 255)

def adapt_to_new_task(self, task):
    """Rapidly adapt to a new task using meta-learned knowledge."""

Purpose: Rapidly adapt to a new task using meta-learned knowledge.

Parameters: – self: Instance reference – task: Parameter for task

get_meta_insights (Line 300)

def get_meta_insights(self):
    """Get human-readable meta-learning insights."""

Purpose: Get human-readable meta-learning insights.

Parameters: – self: Instance reference

get_statistics (Line 319)

def get_statistics(self):
    """Get comprehensive statistics."""

Purpose: Get comprehensive statistics.

Parameters: – self: Instance reference

MetaLearningPattern (Line 333)

Description: Meta-Learning Pattern – Learn how to learn.

Coordinates meta-learning agents to optimize learning strategies across multiple tasks.

Methods:

__init__ (Line 341)

def __init__(self):
    """No method docstring."""

Purpose: No method docstring.

Parameters: – self: Instance reference

register_agent (Line 346)

def register_agent(self, agent):
    """Register meta-learning agent."""

Purpose: Register meta-learning agent.

Parameters: – self: Instance reference – agent: Parameter for agent

add_training_tasks (Line 351)

def add_training_tasks(self, tasks):
    """Add tasks for meta-training."""

Purpose: Add tasks for meta-training.

Parameters: – self: Instance reference – tasks: Parameter for tasks

add_test_tasks (Line 356)

def add_test_tasks(self, tasks):
    """Add tasks for testing adaptation."""

Purpose: Add tasks for testing adaptation.

Parameters: – self: Instance reference – tasks: Parameter for tasks

meta_train_all (Line 361)

def meta_train_all(self):
    """Meta-train all agents."""

Purpose: Meta-train all agents.

Parameters: – self: Instance reference

test_adaptation (Line 367)

def test_adaptation(self):
    """Test rapid adaptation on new tasks."""

Purpose: Test rapid adaptation on new tasks.

Parameters: – self: Instance reference

run (Line 381)

def run(self, training_tasks, test_tasks):
    """Run meta-learning pipeline."""

Purpose: Run meta-learning pipeline.

Parameters: – self: Instance reference – training_tasks: Parameter for training_tasks – test_tasks: Parameter for test_tasks

Design Patterns Used

• Strategy Pattern: Different execution strategies for various scenarios
• State Pattern: Managing different states in the workflow
• Chain of Responsibility: Sequential processing through workflow nodes
• Observer Pattern: Tracking and monitoring pattern execution
• Factory Pattern: Creating instances with proper configuration

Usage Example

# Initialize the pattern
pattern = MetaStrategy(name="example", model_name="gpt-4")

# Configure and execute
result = pattern.execute(data={"key": "value"})

# Check results
print(result)

Key Concepts

• LLM Integration: Uses LangChain/OpenAI for intelligent decision-making
• Workflow Orchestration: LangGraph manages execution flow through nodes
• State Management: TypedDict defines workflow state structure
• Error Handling: Comprehensive error handling and fallback mechanisms
• Extensibility: Designed for easy customization and extension

Extension Points

This pattern can be extended by: 1. Adding custom workflow nodes 2. Implementing additional validation logic 3. Integrating with external services 4. Customizing LLM prompts and responses 5. Adding monitoring and logging capabilities