morphml 1.0.0__py3-none-any.whl

morphml/meta_learning/architecture_similarity.py

@@ -0,0 +1,277 @@
+"""Architecture similarity metrics for transfer learning.
+
+Measures distance between neural architectures for warm-starting.
+
+Author: Eshan Roy <eshanized@proton.me>
+Organization: TONMOY INFRASTRUCTURE & VISION
+"""
+
+from collections import Counter
+from typing import TYPE_CHECKING, List
+
+import numpy as np
+
+from morphml.core.graph import ModelGraph
+from morphml.logging_config import get_logger
+
+if TYPE_CHECKING:
+    from morphml.meta_learning.experiment_database import TaskMetadata
+
+logger = get_logger(__name__)
+
+
+class ArchitectureSimilarity:
+    """
+    Compute similarity between neural architectures.
+
+    Provides multiple similarity metrics:
+    1. **Operation Distribution** - Fast, compares layer type distributions
+    2. **Graph Edit Distance** - Precise, expensive for large graphs
+    3. **Path Encoding** - Medium complexity, encodes computational paths
+
+    Example:
+        >>> sim = ArchitectureSimilarity()
+        >>> similarity = sim.compute(graph1, graph2, method='operation_distribution')
+        >>> print(f"Similarity: {similarity:.3f}")
+    """
+
+    @staticmethod
+    def compute(
+        graph1: ModelGraph, graph2: ModelGraph, method: str = "operation_distribution"
+    ) -> float:
+        """
+        Compute similarity between two architectures.
+
+        Args:
+            graph1: First architecture
+            graph2: Second architecture
+            method: Similarity method
+                - 'operation_distribution': Fast, based on layer types
+                - 'graph_structure': Medium, considers connections
+                - 'combined': Weighted combination
+
+        Returns:
+            Similarity score (0-1, 1=identical)
+        """
+        if method == "operation_distribution":
+            return ArchitectureSimilarity.operation_distribution_similarity(graph1, graph2)
+        elif method == "graph_structure":
+            return ArchitectureSimilarity.graph_structure_similarity(graph1, graph2)
+        elif method == "combined":
+            op_sim = ArchitectureSimilarity.operation_distribution_similarity(graph1, graph2)
+            struct_sim = ArchitectureSimilarity.graph_structure_similarity(graph1, graph2)
+            return 0.6 * op_sim + 0.4 * struct_sim
+        else:
+            raise ValueError(f"Unknown similarity method: {method}")
+
+    @staticmethod
+    def operation_distribution_similarity(graph1: ModelGraph, graph2: ModelGraph) -> float:
+        """
+        Compare operation type distributions (fast method).
+
+        Computes cosine similarity between operation count vectors.
+
+        Args:
+            graph1: First architecture
+            graph2: Second architecture
+
+        Returns:
+            Similarity score (0-1)
+        """
+        # Extract operations
+        ops1 = [layer.layer_type for layer in graph1.layers]
+        ops2 = [layer.layer_type for layer in graph2.layers]
+
+        if not ops1 or not ops2:
+            return 0.0
+
+        # Count operation types
+        count1 = Counter(ops1)
+        count2 = Counter(ops2)
+
+        # All operation types
+        all_ops = sorted(set(count1.keys()) | set(count2.keys()))
+
+        if not all_ops:
+            return 1.0
+
+        # Create normalized vectors
+        vec1 = np.array([count1.get(op, 0) for op in all_ops], dtype=float)
+        vec2 = np.array([count2.get(op, 0) for op in all_ops], dtype=float)
+
+        # Normalize
+        vec1 = vec1 / (vec1.sum() + 1e-8)
+        vec2 = vec2 / (vec2.sum() + 1e-8)
+
+        # Cosine similarity
+        similarity = np.dot(vec1, vec2) / (np.linalg.norm(vec1) * np.linalg.norm(vec2) + 1e-8)
+
+        return max(0.0, min(1.0, similarity))
+
+    @staticmethod
+    def graph_structure_similarity(graph1: ModelGraph, graph2: ModelGraph) -> float:
+        """
+        Compare graph structures (medium complexity).
+
+        Considers both nodes and edges.
+
+        Args:
+            graph1: First architecture
+            graph2: Second architecture
+
+        Returns:
+            Similarity score (0-1)
+        """
+        # Number of layers
+        n1 = len(graph1.layers)
+        n2 = len(graph2.layers)
+
+        if n1 == 0 and n2 == 0:
+            return 1.0
+
+        # Normalized layer count difference
+        size_similarity = 1.0 - abs(n1 - n2) / max(n1, n2, 1)
+
+        # Operation similarity
+        op_similarity = ArchitectureSimilarity.operation_distribution_similarity(graph1, graph2)
+
+        # Combine
+        similarity = 0.5 * size_similarity + 0.5 * op_similarity
+
+        return similarity
+
+    @staticmethod
+    def parameter_count_similarity(graph1: ModelGraph, graph2: ModelGraph) -> float:
+        """
+        Compare models by parameter count.
+
+        Args:
+            graph1: First architecture
+            graph2: Second architecture
+
+        Returns:
+            Similarity score (0-1)
+        """
+        params1 = graph1.count_parameters()
+        params2 = graph2.count_parameters()
+
+        if params1 == 0 and params2 == 0:
+            return 1.0
+
+        # Normalized difference
+        max_params = max(params1, params2, 1)
+        similarity = 1.0 - abs(params1 - params2) / max_params
+
+        return similarity
+
+    @staticmethod
+    def depth_similarity(graph1: ModelGraph, graph2: ModelGraph) -> float:
+        """
+        Compare network depth.
+
+        Args:
+            graph1: First architecture
+            graph2: Second architecture
+
+        Returns:
+            Similarity score (0-1)
+        """
+        depth1 = len(graph1.layers)
+        depth2 = len(graph2.layers)
+
+        if depth1 == 0 and depth2 == 0:
+            return 1.0
+
+        max_depth = max(depth1, depth2, 1)
+        similarity = 1.0 - abs(depth1 - depth2) / max_depth
+
+        return similarity
+
+    @staticmethod
+    def batch_similarity(
+        query_graph: ModelGraph,
+        candidate_graphs: List[ModelGraph],
+        method: str = "operation_distribution",
+    ) -> np.ndarray:
+        """
+        Compute similarity between one graph and multiple candidates.
+
+        Efficient batch computation.
+
+        Args:
+            query_graph: Query architecture
+            candidate_graphs: List of candidate architectures
+            method: Similarity method
+
+        Returns:
+            Array of similarity scores
+        """
+        similarities = []
+
+        for candidate in candidate_graphs:
+            sim = ArchitectureSimilarity.compute(query_graph, candidate, method=method)
+            similarities.append(sim)
+
+        return np.array(similarities)
+
+
+def compute_task_similarity(
+    task1: "TaskMetadata", task2: "TaskMetadata", method: str = "meta_features"
+) -> float:
+    """
+    Compute similarity between tasks.
+
+    Args:
+        task1: First task
+        task2: Second task
+        method: Similarity method
+            - 'meta_features': Based on dataset characteristics
+            - 'dataset_name': Simple name matching
+
+    Returns:
+        Similarity score (0-1)
+    """
+    if method == "dataset_name":
+        # Simple string similarity
+        if task1.dataset_name == task2.dataset_name:
+            return 1.0
+        elif task1.dataset_name in task2.dataset_name or task2.dataset_name in task1.dataset_name:
+            return 0.7
+        else:
+            return 0.0
+
+    elif method == "meta_features":
+        # Meta-feature based similarity
+        features1 = np.array(
+            [
+                task1.num_samples / 100000.0,
+                task1.num_classes / 100.0,
+                task1.input_size[0] / 3.0,  # Channels
+                task1.input_size[1] / 224.0,  # Height
+                task1.input_size[2] / 224.0,  # Width
+            ]
+        )
+
+        features2 = np.array(
+            [
+                task2.num_samples / 100000.0,
+                task2.num_classes / 100.0,
+                task2.input_size[0] / 3.0,
+                task2.input_size[1] / 224.0,
+                task2.input_size[2] / 224.0,
+            ]
+        )
+
+        # Cosine similarity
+        similarity = np.dot(features1, features2) / (
+            np.linalg.norm(features1) * np.linalg.norm(features2) + 1e-8
+        )
+
+        # Problem type bonus
+        if task1.problem_type == task2.problem_type:
+            similarity *= 1.2  # Boost for same problem type
+
+        return max(0.0, min(1.0, similarity))
+
+    else:
+        raise ValueError(f"Unknown method: {method}")

morphml/meta_learning/experiment_database.py

@@ -0,0 +1,240 @@
+"""Experiment database for meta-learning knowledge base.
+
+Stores and retrieves past experiments for transfer learning.
+
+Author: Eshan Roy <eshanized@proton.me>
+Organization: TONMOY INFRASTRUCTURE & VISION
+"""
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Tuple
+
+from morphml.core.graph import ModelGraph
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+try:
+    DB_AVAILABLE = True
+except ImportError:
+    DB_AVAILABLE = False
+
+
+@dataclass
+class TaskMetadata:
+    """
+    Metadata describing a machine learning task.
+
+    Used for task similarity computation and warm-starting.
+
+    Attributes:
+        task_id: Unique task identifier
+        dataset_name: Name of dataset (e.g., 'CIFAR-10')
+        num_samples: Number of training samples
+        num_classes: Number of output classes
+        input_size: Input tensor shape (C, H, W)
+        problem_type: Type of problem ('classification', 'detection', 'segmentation')
+        metadata: Additional task-specific metadata
+    """
+
+    task_id: str
+    dataset_name: str
+    num_samples: int
+    num_classes: int
+    input_size: Tuple[int, int, int]  # (C, H, W)
+    problem_type: str = "classification"
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert to dictionary."""
+        return {
+            "task_id": self.task_id,
+            "dataset_name": self.dataset_name,
+            "num_samples": self.num_samples,
+            "num_classes": self.num_classes,
+            "input_size": list(self.input_size),
+            "problem_type": self.problem_type,
+            "metadata": self.metadata,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "TaskMetadata":
+        """Create from dictionary."""
+        return cls(
+            task_id=data["task_id"],
+            dataset_name=data["dataset_name"],
+            num_samples=data["num_samples"],
+            num_classes=data["num_classes"],
+            input_size=tuple(data["input_size"]),
+            problem_type=data.get("problem_type", "classification"),
+            metadata=data.get("metadata", {}),
+        )
+
+
+class ExperimentDatabase:
+    """
+    Database interface for past experiments.
+
+    Provides access to experiment history for meta-learning:
+    - Query tasks by similarity
+    - Retrieve top architectures
+    - Get search trajectories
+    - Store new experiments
+
+    Args:
+        db_manager: DatabaseManager instance (if using SQL backend)
+        storage_path: Path to local storage (if using file backend)
+
+    Example:
+        >>> db = ExperimentDatabase(db_manager)
+        >>> tasks = db.get_all_tasks()
+        >>> archs = db.get_top_architectures('exp1', top_k=10)
+    """
+
+    def __init__(self, db_manager: Optional[Any] = None, storage_path: Optional[str] = None):
+        """Initialize experiment database."""
+        self.db_manager = db_manager
+        self.storage_path = storage_path
+
+        # In-memory cache
+        self._task_cache: Dict[str, TaskMetadata] = {}
+        self._arch_cache: Dict[str, List[ModelGraph]] = {}
+
+        logger.info("Initialized ExperimentDatabase")
+
+    def add_task(self, task: TaskMetadata) -> None:
+        """
+        Add task metadata to database.
+
+        Args:
+            task: Task metadata
+        """
+        self._task_cache[task.task_id] = task
+        logger.debug(f"Added task {task.task_id} to database")
+
+    def get_all_tasks(self) -> List[TaskMetadata]:
+        """
+        Get all past tasks.
+
+        Returns:
+            List of task metadata
+        """
+        if self.db_manager and DB_AVAILABLE:
+            # Query from SQL database
+            try:
+                experiments = self.db_manager.list_experiments()
+                tasks = [self._experiment_to_task_metadata(exp) for exp in experiments]
+                return tasks
+            except Exception as e:
+                logger.warning(f"Failed to query database: {e}")
+
+        # Return from cache
+        return list(self._task_cache.values())
+
+    def get_task(self, task_id: str) -> Optional[TaskMetadata]:
+        """
+        Get specific task metadata.
+
+        Args:
+            task_id: Task identifier
+
+        Returns:
+            Task metadata or None
+        """
+        return self._task_cache.get(task_id)
+
+    def get_top_architectures(self, task_id: str, top_k: int = 10) -> List[ModelGraph]:
+        """
+        Get top-k architectures for a task.
+
+        Args:
+            task_id: Task identifier
+            top_k: Number of architectures to return
+
+        Returns:
+            List of best architectures
+        """
+        # Check cache first
+        if task_id in self._arch_cache:
+            cached = self._arch_cache[task_id]
+            return cached[:top_k]
+
+        if self.db_manager and DB_AVAILABLE:
+            # Query from SQL database
+            try:
+                best = self.db_manager.get_best_architectures(task_id, top_k=top_k)
+                graphs = []
+
+                for arch in best:
+                    try:
+                        graph_dict = json.loads(arch.architecture_json)
+                        graph = ModelGraph.from_dict(graph_dict)
+                        graphs.append(graph)
+                    except Exception as e:
+                        logger.warning(f"Failed to deserialize architecture: {e}")
+
+                # Cache results
+                self._arch_cache[task_id] = graphs
+
+                return graphs
+            except Exception as e:
+                logger.warning(f"Failed to query architectures: {e}")
+
+        return []
+
+    def add_architecture(self, task_id: str, graph: ModelGraph, fitness: float) -> None:
+        """
+        Add architecture to database.
+
+        Args:
+            task_id: Task identifier
+            graph: Architecture graph
+            fitness: Performance score
+        """
+        if task_id not in self._arch_cache:
+            self._arch_cache[task_id] = []
+
+        self._arch_cache[task_id].append(graph)
+
+        # Sort by fitness (need to store fitness too)
+        # For now just append
+        logger.debug(f"Added architecture to task {task_id}")
+
+    def _experiment_to_task_metadata(self, experiment: Any) -> TaskMetadata:
+        """Convert database Experiment to TaskMetadata."""
+        try:
+            config = json.loads(experiment.config) if hasattr(experiment, "config") else {}
+            (json.loads(experiment.search_space) if hasattr(experiment, "search_space") else {})
+
+            # Extract metadata
+            return TaskMetadata(
+                task_id=str(experiment.id),
+                dataset_name=experiment.name,
+                num_samples=config.get("num_samples", 50000),
+                num_classes=config.get("num_classes", 10),
+                input_size=tuple(config.get("input_size", [3, 32, 32])),
+                problem_type=config.get("problem_type", "classification"),
+                metadata={
+                    "optimizer": experiment.optimizer,
+                    "status": experiment.status,
+                    "num_evaluations": experiment.num_evaluations,
+                },
+            )
+        except Exception as e:
+            logger.warning(f"Failed to convert experiment: {e}")
+            # Return default
+            return TaskMetadata(
+                task_id=str(experiment.id),
+                dataset_name=experiment.name,
+                num_samples=50000,
+                num_classes=10,
+                input_size=(3, 32, 32),
+            )
+
+    def get_statistics(self) -> Dict[str, Any]:
+        """Get database statistics."""
+        return {
+            "num_tasks": len(self._task_cache),
+            "num_cached_architectures": sum(len(archs) for archs in self._arch_cache.values()),
+        }

morphml/meta_learning/knowledge_base/__init__.py

@@ -0,0 +1,19 @@
+"""Knowledge base for experiment history and retrieval.
+
+Vector-based storage and similarity search for architectures.
+
+Author: Eshan Roy <eshanized@proton.me>
+Organization: TONMOY INFRASTRUCTURE & VISION
+"""
+
+from morphml.meta_learning.knowledge_base.embedder import ArchitectureEmbedder
+from morphml.meta_learning.knowledge_base.knowledge_base import KnowledgeBase
+from morphml.meta_learning.knowledge_base.meta_features import MetaFeatureExtractor
+from morphml.meta_learning.knowledge_base.vector_store import VectorStore
+
+__all__ = [
+    "ArchitectureEmbedder",
+    "VectorStore",
+    "KnowledgeBase",
+    "MetaFeatureExtractor",
+]