morphml 1.0.0__py3-none-any.whl

morphml/integrations/sklearn_adapter.py

@@ -0,0 +1,206 @@
+"""Scikit-learn adapter for MorphML.
+
+Converts ModelGraph to scikit-learn Pipeline for classical ML.
+
+Example:
+    >>> from morphml.integrations import SklearnAdapter
+    >>> adapter = SklearnAdapter()
+    >>> pipeline = adapter.build_pipeline(graph)
+    >>> pipeline.fit(X_train, y_train)
+    >>> predictions = pipeline.predict(X_test)
+"""
+
+from typing import Any, Dict, Optional
+
+try:
+    from sklearn.decomposition import PCA
+    from sklearn.ensemble import GradientBoostingClassifier, RandomForestClassifier
+    from sklearn.linear_model import LogisticRegression
+    from sklearn.neighbors import KNeighborsClassifier
+    from sklearn.pipeline import Pipeline
+    from sklearn.preprocessing import StandardScaler
+    from sklearn.svm import SVC
+
+    SKLEARN_AVAILABLE = True
+except ImportError:
+    SKLEARN_AVAILABLE = False
+    Pipeline = None
+
+from morphml.core.graph import GraphNode, ModelGraph
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class SklearnAdapter:
+    """
+    Convert ModelGraph to scikit-learn Pipeline.
+
+    Supports classical ML algorithms and preprocessing steps.
+
+    Example:
+        >>> adapter = SklearnAdapter()
+        >>> pipeline = adapter.build_pipeline(graph)
+        >>> pipeline.fit(X_train, y_train)
+        >>> score = pipeline.score(X_test, y_test)
+    """
+
+    def __init__(self):
+        """Initialize Scikit-learn adapter."""
+        if not SKLEARN_AVAILABLE:
+            raise ImportError(
+                "Scikit-learn is required for SklearnAdapter. "
+                "Install with: pip install scikit-learn"
+            )
+        logger.info("Initialized SklearnAdapter")
+
+    def build_pipeline(
+        self, graph: ModelGraph, config: Optional[Dict[str, Any]] = None
+    ) -> Pipeline:
+        """
+        Build scikit-learn pipeline from graph.
+
+        Args:
+            graph: ModelGraph to convert
+            config: Optional configuration
+
+        Returns:
+            sklearn Pipeline instance
+
+        Example:
+            >>> pipeline = adapter.build_pipeline(graph)
+        """
+        steps = []
+
+        for node in graph.topological_sort():
+            step = self._create_step(node)
+            if step is not None:
+                steps.append(step)
+
+        if not steps:
+            # Default pipeline
+            steps = [("scaler", StandardScaler()), ("classifier", RandomForestClassifier())]
+
+        pipeline = Pipeline(steps)
+
+        logger.info(f"Created sklearn pipeline with {len(steps)} steps")
+
+        return pipeline
+
+    def _create_step(self, node: GraphNode) -> Optional[tuple]:
+        """
+        Create pipeline step from node.
+
+        Args:
+            node: GraphNode to convert
+
+        Returns:
+            Tuple of (name, estimator) or None
+        """
+        op = node.operation
+        params = node.params
+
+        if op == "input":
+            return None
+
+        elif op == "scaler":
+            return (f"scaler_{node.id}", StandardScaler())
+
+        elif op == "pca":
+            n_components = params.get("n_components", 50)
+            return (f"pca_{node.id}", PCA(n_components=n_components))
+
+        elif op == "random_forest":
+            return (
+                f"rf_{node.id}",
+                RandomForestClassifier(
+                    n_estimators=params.get("n_estimators", 100),
+                    max_depth=params.get("max_depth", None),
+                    min_samples_split=params.get("min_samples_split", 2),
+                    random_state=params.get("random_state", 42),
+                ),
+            )
+
+        elif op == "gradient_boosting":
+            return (
+                f"gb_{node.id}",
+                GradientBoostingClassifier(
+                    n_estimators=params.get("n_estimators", 100),
+                    learning_rate=params.get("learning_rate", 0.1),
+                    max_depth=params.get("max_depth", 3),
+                    random_state=params.get("random_state", 42),
+                ),
+            )
+
+        elif op == "logistic_regression":
+            return (
+                f"lr_{node.id}",
+                LogisticRegression(
+                    C=params.get("C", 1.0),
+                    max_iter=params.get("max_iter", 100),
+                    random_state=params.get("random_state", 42),
+                ),
+            )
+
+        elif op == "svm":
+            return (
+                f"svm_{node.id}",
+                SVC(
+                    C=params.get("C", 1.0),
+                    kernel=params.get("kernel", "rbf"),
+                    gamma=params.get("gamma", "scale"),
+                    random_state=params.get("random_state", 42),
+                ),
+            )
+
+        elif op == "knn":
+            return (
+                f"knn_{node.id}",
+                KNeighborsClassifier(
+                    n_neighbors=params.get("n_neighbors", 5),
+                    weights=params.get("weights", "uniform"),
+                ),
+            )
+
+        else:
+            logger.warning(f"Unknown operation for sklearn: {op}")
+            return None
+
+    def create_search_space_for_sklearn(self, graph: ModelGraph) -> Dict[str, Any]:
+        """
+        Create hyperparameter search space for sklearn pipeline.
+
+        Args:
+            graph: ModelGraph
+
+        Returns:
+            Dictionary of hyperparameter distributions
+
+        Example:
+            >>> search_space = adapter.create_search_space_for_sklearn(graph)
+            >>> # Use with GridSearchCV or RandomizedSearchCV
+        """
+        param_grid = {}
+
+        for node in graph.topological_sort():
+            op = node.operation
+
+            if op == "random_forest":
+                param_grid[f"rf_{node.id}__n_estimators"] = [50, 100, 200]
+                param_grid[f"rf_{node.id}__max_depth"] = [None, 10, 20, 30]
+
+            elif op == "gradient_boosting":
+                param_grid[f"gb_{node.id}__n_estimators"] = [50, 100, 200]
+                param_grid[f"gb_{node.id}__learning_rate"] = [0.01, 0.1, 0.2]
+
+            elif op == "logistic_regression":
+                param_grid[f"lr_{node.id}__C"] = [0.1, 1.0, 10.0]
+
+            elif op == "svm":
+                param_grid[f"svm_{node.id}__C"] = [0.1, 1.0, 10.0]
+                param_grid[f"svm_{node.id}__kernel"] = ["linear", "rbf"]
+
+            elif op == "pca":
+                param_grid[f"pca_{node.id}__n_components"] = [10, 20, 50, 100]
+
+        return param_grid

morphml/integrations/tensorflow_adapter.py

@@ -0,0 +1,230 @@
+"""TensorFlow/Keras adapter for MorphML.
+
+Converts ModelGraph to Keras Model using Functional API.
+
+Example:
+    >>> from morphml.integrations import TensorFlowAdapter
+    >>> adapter = TensorFlowAdapter()
+    >>> model = adapter.build_model(graph)
+    >>> model.compile(optimizer='adam', loss='categorical_crossentropy')
+    >>> model.fit(x_train, y_train, validation_data=(x_val, y_val))
+"""
+
+from typing import Any, Dict, Optional, Tuple
+
+try:
+    import tensorflow as tf
+    from tensorflow import keras
+    from tensorflow.keras import layers
+
+    TF_AVAILABLE = True
+except ImportError:
+    TF_AVAILABLE = False
+    tf = None
+    keras = None
+    layers = None
+
+from morphml.core.graph import GraphNode, ModelGraph
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class TensorFlowAdapter:
+    """
+    Convert ModelGraph to TensorFlow/Keras Model.
+
+    Uses Keras Functional API to build models from graph structure.
+
+    Example:
+        >>> adapter = TensorFlowAdapter()
+        >>> model = adapter.build_model(graph, input_shape=(32, 32, 3))
+        >>> model.summary()
+    """
+
+    def __init__(self):
+        """Initialize TensorFlow adapter."""
+        if not TF_AVAILABLE:
+            raise ImportError(
+                "TensorFlow is required for TensorFlowAdapter. "
+                "Install with: pip install tensorflow"
+            )
+        logger.info("Initialized TensorFlowAdapter")
+
+    def build_model(
+        self, graph: ModelGraph, input_shape: Optional[Tuple[int, ...]] = None
+    ) -> "keras.Model":
+        """
+        Build Keras model from graph.
+
+        Args:
+            graph: ModelGraph to convert
+            input_shape: Input shape (H, W, C) for Keras
+
+        Returns:
+            keras.Model instance
+
+        Example:
+            >>> model = adapter.build_model(graph, input_shape=(32, 32, 3))
+        """
+        if input_shape is None:
+            input_shape = (32, 32, 3)
+
+        # Create input
+        inputs = keras.Input(shape=input_shape)
+
+        # Build layers following graph topology
+        layer_outputs = {}
+
+        for node in graph.topological_sort():
+            if node.operation == "input":
+                layer_outputs[node.id] = inputs
+                continue
+
+            # Create layer
+            layer = self._create_layer(node)
+
+            # Get input
+            if not node.predecessors:
+                x = inputs
+            else:
+                # Get predecessor outputs
+                pred_outputs = [layer_outputs[p.id] for p in node.predecessors]
+
+                if len(pred_outputs) == 1:
+                    x = pred_outputs[0]
+                else:
+                    # Concatenate along channel dimension
+                    x = layers.Concatenate(axis=-1)(pred_outputs)
+
+            # Apply layer
+            if layer is not None:
+                layer_outputs[node.id] = layer(x)
+            else:
+                layer_outputs[node.id] = x
+
+        # Get output
+        output_nodes = [n for n in graph.nodes.values() if not n.successors]
+        if output_nodes:
+            outputs = layer_outputs[output_nodes[0].id]
+        else:
+            # Use last node
+            outputs = layer_outputs[list(layer_outputs.keys())[-1]]
+
+        # Create model
+        model = keras.Model(inputs=inputs, outputs=outputs)
+
+        logger.info(f"Created Keras model with {len(model.layers)} layers")
+
+        return model
+
+    def _create_layer(self, node: GraphNode):
+        """
+        Create Keras layer from node.
+
+        Args:
+            node: GraphNode to convert
+
+        Returns:
+            Keras layer or None
+        """
+        op = node.operation
+        params = node.params
+
+        if op == "input":
+            return None
+
+        elif op == "conv2d":
+            return layers.Conv2D(
+                filters=params.get("filters", 64),
+                kernel_size=params.get("kernel_size", 3),
+                strides=params.get("stride", 1),
+                padding=params.get("padding", "same"),
+                activation=None,
+            )
+
+        elif op == "maxpool":
+            return layers.MaxPooling2D(
+                pool_size=params.get("pool_size", 2), strides=params.get("stride", None)
+            )
+
+        elif op == "avgpool":
+            return layers.AveragePooling2D(
+                pool_size=params.get("pool_size", 2), strides=params.get("stride", None)
+            )
+
+        elif op == "dense":
+            return layers.Dense(units=params.get("units", 10), activation=None)
+
+        elif op == "relu":
+            return layers.ReLU()
+
+        elif op == "sigmoid":
+            return layers.Activation("sigmoid")
+
+        elif op == "tanh":
+            return layers.Activation("tanh")
+
+        elif op == "softmax":
+            return layers.Softmax()
+
+        elif op == "batchnorm":
+            return layers.BatchNormalization()
+
+        elif op == "dropout":
+            return layers.Dropout(rate=params.get("rate", 0.5))
+
+        elif op == "flatten":
+            return layers.Flatten()
+
+        else:
+            logger.warning(f"Unknown operation: {op}, using Lambda identity")
+            return layers.Lambda(lambda x: x)
+
+    def compile_model(
+        self, model: "keras.Model", config: Optional[Dict[str, Any]] = None
+    ) -> "keras.Model":
+        """
+        Compile Keras model with optimizer and loss.
+
+        Args:
+            model: Keras model
+            config: Compilation configuration
+
+        Returns:
+            Compiled model
+
+        Example:
+            >>> model = adapter.compile_model(model, {
+            ...     'optimizer': 'adam',
+            ...     'learning_rate': 1e-3,
+            ...     'loss': 'categorical_crossentropy'
+            ... })
+        """
+        if config is None:
+            config = {}
+
+        # Optimizer
+        optimizer_name = config.get("optimizer", "adam")
+        lr = config.get("learning_rate", 1e-3)
+
+        if optimizer_name == "adam":
+            optimizer = keras.optimizers.Adam(learning_rate=lr)
+        elif optimizer_name == "sgd":
+            optimizer = keras.optimizers.SGD(learning_rate=lr, momentum=config.get("momentum", 0.9))
+        elif optimizer_name == "rmsprop":
+            optimizer = keras.optimizers.RMSprop(learning_rate=lr)
+        else:
+            optimizer = optimizer_name
+
+        # Loss
+        loss = config.get("loss", "categorical_crossentropy")
+
+        # Metrics
+        metrics = config.get("metrics", ["accuracy"])
+
+        model.compile(optimizer=optimizer, loss=loss, metrics=metrics)
+
+        logger.info(f"Compiled model with {optimizer_name} optimizer")
+
+        return model

morphml/logging_config.py

@@ -0,0 +1,93 @@
+"""Logging configuration for MorphML."""
+
+import logging
+from pathlib import Path
+from typing import Optional
+
+from rich.console import Console
+from rich.logging import RichHandler
+
+
+def setup_logging(
+    level: str = "INFO",
+    log_file: Optional[str] = None,
+    console: bool = True,
+    format_string: Optional[str] = None,
+) -> logging.Logger:
+    """
+    Set up logging for MorphML.
+
+    Args:
+        level: Log level (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        log_file: Optional file path for logging
+        console: Enable console logging with Rich
+        format_string: Custom format string (if not using Rich)
+
+    Returns:
+        Configured logger instance
+
+    Example:
+        >>> logger = setup_logging(level="DEBUG", log_file="morphml.log")
+        >>> logger.info("Starting experiment")
+    """
+    # Get root logger for morphml
+    logger = logging.getLogger("morphml")
+    logger.setLevel(getattr(logging, level.upper()))
+
+    # Remove existing handlers
+    logger.handlers.clear()
+
+    # Console handler with Rich
+    if console:
+        console_handler = RichHandler(
+            rich_tracebacks=True,
+            tracebacks_show_locals=True,
+            console=Console(stderr=True),
+        )
+        console_handler.setLevel(getattr(logging, level.upper()))
+        logger.addHandler(console_handler)
+
+    # File handler
+    if log_file:
+        # Create log directory if it doesn't exist
+        log_path = Path(log_file)
+        log_path.parent.mkdir(parents=True, exist_ok=True)
+
+        file_handler = logging.FileHandler(log_file)
+        file_handler.setLevel(logging.DEBUG)  # Always DEBUG to file
+
+        # Use custom format for file
+        if format_string is None:
+            format_string = (
+                "%(asctime)s - %(name)s - %(levelname)s - " "%(filename)s:%(lineno)d - %(message)s"
+            )
+
+        formatter = logging.Formatter(format_string)
+        file_handler.setFormatter(formatter)
+        logger.addHandler(file_handler)
+
+    # Prevent propagation to root logger
+    logger.propagate = False
+
+    return logger
+
+
+def get_logger(name: str) -> logging.Logger:
+    """
+    Get a logger instance for a specific module.
+
+    Args:
+        name: Logger name (usually __name__)
+
+    Returns:
+        Logger instance
+
+    Example:
+        >>> logger = get_logger(__name__)
+        >>> logger.info("Module initialized")
+    """
+    return logging.getLogger(f"morphml.{name}")
+
+
+# Create default logger
+logger = logging.getLogger("morphml")

morphml/meta_learning/__init__.py

@@ -0,0 +1,66 @@
+"""Meta-learning and transfer learning for MorphML.
+
+Enables intelligent search through:
+- Warm-starting from past experiments
+- Performance prediction
+- Transfer learning across tasks
+- Knowledge base management
+- Strategy evolution
+
+Author: Eshan Roy <eshanized@proton.me>
+Organization: TONMOY INFRASTRUCTURE & VISION
+"""
+
+from morphml.meta_learning.architecture_similarity import ArchitectureSimilarity
+from morphml.meta_learning.experiment_database import ExperimentDatabase, TaskMetadata
+from morphml.meta_learning.knowledge_base import (
+    ArchitectureEmbedder,
+    KnowledgeBase,
+    MetaFeatureExtractor,
+    VectorStore,
+)
+from morphml.meta_learning.predictors import (
+    EnsemblePredictor,
+    LearningCurvePredictor,
+    ProxyMetricPredictor,
+)
+from morphml.meta_learning.strategy_evolution import (
+    AdaptiveOptimizer,
+    PortfolioOptimizer,
+    ThompsonSamplingSelector,
+    UCBSelector,
+)
+from morphml.meta_learning.transfer import (
+    ArchitectureTransfer,
+    FineTuningStrategy,
+    MultiTaskNAS,
+)
+from morphml.meta_learning.warm_start import WarmStarter
+
+__all__ = [
+    # Warm-starting
+    "WarmStarter",
+    "TaskMetadata",
+    "ExperimentDatabase",
+    "ArchitectureSimilarity",
+    # Performance prediction
+    "ProxyMetricPredictor",
+    "LearningCurvePredictor",
+    "EnsemblePredictor",
+    # Knowledge base
+    "KnowledgeBase",
+    "ArchitectureEmbedder",
+    "MetaFeatureExtractor",
+    "VectorStore",
+    # Strategy evolution
+    "UCBSelector",
+    "ThompsonSamplingSelector",
+    "AdaptiveOptimizer",
+    "PortfolioOptimizer",
+    # Transfer learning
+    "ArchitectureTransfer",
+    "FineTuningStrategy",
+    "MultiTaskNAS",
+]
+
+__version__ = "0.1.0"