morphml 1.0.0__py3-none-any.whl

morphml/cli/quickstart.py

@@ -0,0 +1,312 @@
+"""Quick-start CLI helper for MorphML.
+
+Provides interactive setup and template generation for common NAS tasks.
+
+Run:
+    morphml quickstart
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import click
+
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+TEMPLATES = {
+    "cnn_classification": """\"\"\"CNN Image Classification NAS Example.
+
+Generated by: morphml quickstart
+\"\"\"
+
+from morphml.core.dsl import Layer, SearchSpace
+from morphml.constraints import ConstraintHandler, MaxParametersConstraint
+from morphml.evaluation import HeuristicEvaluator
+from morphml.optimizers import GeneticAlgorithm
+from morphml.utils import ArchitectureExporter
+
+# Define search space
+space = SearchSpace("{name}")
+space.add_layers(
+    Layer.input(shape=(3, 32, 32)),
+
+    # First conv block
+    Layer.conv2d(filters=[32, 64], kernel_size=[3, 5]),
+    Layer.batchnorm(),
+    Layer.relu(),
+    Layer.maxpool(pool_size=2),
+
+    # Second conv block
+    Layer.conv2d(filters=[64, 128], kernel_size=3),
+    Layer.batchnorm(),
+    Layer.relu(),
+    Layer.maxpool(pool_size=2),
+
+    # Classification head
+    Layer.flatten(),
+    Layer.dense(units=[128, 256, 512]),
+    Layer.relu(),
+    Layer.dropout(rate=[0.3, 0.5]),
+    Layer.dense(units={num_classes}),
+    Layer.softmax(),
+)
+
+# Set up constraints
+handler = ConstraintHandler()
+handler.add_constraint(MaxParametersConstraint(max_params={max_params}))
+
+# Create evaluator
+evaluator = HeuristicEvaluator()
+
+# Configure optimizer
+optimizer = GeneticAlgorithm(
+    search_space=space,
+    config={{
+        "population_size": {population_size},
+        "num_generations": {num_generations},
+        "mutation_rate": 0.2,
+        "crossover_rate": 0.8,
+    }}
+)
+
+# Run optimization
+print(f"Starting NAS: {{optimizer.config['num_generations']}} generations...")
+best = optimizer.optimize(evaluator)
+
+# Check constraints
+if not handler.check(best.graph):
+    print("\\nWarning: Best architecture violates constraints:")
+    print(handler.format_violations(best.graph))
+else:
+    print("\\n✓ Best architecture satisfies all constraints")
+
+# Show results
+print(f"\\nBest Architecture:")
+print(f"  Fitness: {{best.fitness:.4f}}")
+print(f"  Parameters: {{best.graph.estimate_parameters():,}}")
+print(f"  Depth: {{best.graph.depth()}}")
+
+# Export architecture
+exporter = ArchitectureExporter()
+pytorch_code = exporter.to_pytorch(best.graph, "{name}_model")
+
+output_file = "{name}_model.py"
+with open(output_file, 'w') as f:
+    f.write(pytorch_code)
+
+print(f"\\n✓ Exported to {{output_file}}")
+""",
+    "simple_nas": """\"\"\"Simple NAS Example.
+
+Generated by: morphml quickstart
+\"\"\"
+
+from morphml.core.dsl import Layer, SearchSpace
+from morphml.evaluation import HeuristicEvaluator
+from morphml.optimizers import GeneticAlgorithm
+
+# Define search space
+space = SearchSpace("{name}")
+space.add_layers(
+    Layer.input(shape=(3, 32, 32)),
+    Layer.conv2d(filters=[32, 64, 128], kernel_size=3),
+    Layer.relu(),
+    Layer.maxpool(pool_size=2),
+    Layer.flatten(),
+    Layer.dense(units=[128, 256]),
+    Layer.dense(units={num_classes}),
+)
+
+# Run quick search
+evaluator = HeuristicEvaluator()
+optimizer = GeneticAlgorithm(space, config={{
+    "population_size": 10,
+    "num_generations": 20,
+}})
+
+best = optimizer.optimize(evaluator)
+print(f"Best fitness: {{best.fitness:.4f}}")
+""",
+    "advanced_nas": """\"\"\"Advanced NAS with Adaptive Operators.
+
+Generated by: morphml quickstart
+\"\"\"
+
+from morphml.core.dsl import Layer, SearchSpace
+from morphml.constraints import ConstraintHandler, MaxParametersConstraint, DepthConstraint
+from morphml.evaluation import HeuristicEvaluator
+from morphml.optimizers import GeneticAlgorithm
+from morphml.optimizers.adaptive_operators import AdaptiveOperatorScheduler
+from morphml.visualization.crossover_viz import quick_crossover_viz
+from morphml.utils import ArchitectureExporter
+
+# Define search space
+space = SearchSpace("{name}")
+space.add_layers(
+    Layer.input(shape=(3, 32, 32)),
+    Layer.conv2d(filters=[32, 64, 128], kernel_size=[3, 5, 7]),
+    Layer.batchnorm(),
+    Layer.relu(),
+    Layer.maxpool(pool_size=2),
+    Layer.conv2d(filters=[64, 128, 256], kernel_size=[3, 5]),
+    Layer.batchnorm(),
+    Layer.relu(),
+    Layer.maxpool(pool_size=2),
+    Layer.flatten(),
+    Layer.dense(units=[128, 256, 512, 1024]),
+    Layer.relu(),
+    Layer.dropout(rate=[0.3, 0.5, 0.7]),
+    Layer.dense(units={num_classes}),
+)
+
+# Set up constraints
+handler = ConstraintHandler()
+handler.add_constraint(MaxParametersConstraint(max_params={max_params}))
+handler.add_constraint(DepthConstraint(min_depth=5, max_depth=20))
+
+# Create adaptive scheduler
+scheduler = AdaptiveOperatorScheduler(
+    initial_crossover=0.8,
+    initial_mutation=0.2
+)
+
+# Run optimization
+evaluator = HeuristicEvaluator()
+optimizer = GeneticAlgorithm(space, config={{
+    "population_size": {population_size},
+    "num_generations": {num_generations},
+}})
+
+print("Running advanced NAS with adaptive operators...")
+best = optimizer.optimize(evaluator)
+
+# Visualize if parents available
+if best.parent_ids and len(best.parent_ids) == 2:
+    try:
+        quick_crossover_viz(
+            optimizer.population.get(best.parent_ids[0]).graph,
+            optimizer.population.get(best.parent_ids[1]).graph,
+            "best_parents_crossover.png"
+        )
+        print("\\n✓ Saved crossover visualization")
+    except Exception as e:
+        print(f"\\nVisualization skipped: {{e}}")
+
+# Export
+exporter = ArchitectureExporter()
+code = exporter.to_pytorch(best.graph, "{name}_model")
+with open("{name}_model.py", 'w') as f:
+    f.write(code)
+
+print(f"\\n✓ Best architecture exported!")
+print(f"  Fitness: {{best.fitness:.4f}}")
+print(f"  Parameters: {{best.graph.estimate_parameters():,}}")
+""",
+}
+
+
+@click.command()
+@click.option(
+    "--template",
+    "-t",
+    type=click.Choice(["cnn_classification", "simple_nas", "advanced_nas"]),
+    default="cnn_classification",
+    help="Template type",
+)
+@click.option("--name", "-n", default="my_nas", help="Project name")
+@click.option("--output", "-o", default=None, help="Output file path")
+@click.option("--num-classes", default=10, help="Number of output classes")
+@click.option("--max-params", default=1000000, help="Maximum parameters constraint")
+@click.option("--population-size", default=20, help="Population size")
+@click.option("--num-generations", default=50, help="Number of generations")
+@click.option("--interactive", "-i", is_flag=True, help="Interactive mode")
+def quickstart(
+    template: str,
+    name: str,
+    output: Optional[str],
+    num_classes: int,
+    max_params: int,
+    population_size: int,
+    num_generations: int,
+    interactive: bool,
+):
+    """
+    Generate a quick-start NAS project from template.
+
+    Examples:
+        morphml quickstart
+        morphml quickstart -t simple_nas -n my_project
+        morphml quickstart -i  # Interactive mode
+    """
+    # Interactive mode
+    if interactive:
+        click.echo("🧬 MorphML Quick Start - Interactive Mode\n")
+
+        template = click.prompt(
+            "Select template",
+            type=click.Choice(["cnn_classification", "simple_nas", "advanced_nas"]),
+            default="cnn_classification",
+        )
+        name = click.prompt("Project name", default="my_nas")
+        num_classes = click.prompt("Number of classes", default=10, type=int)
+
+        if template in ["cnn_classification", "advanced_nas"]:
+            max_params = click.prompt("Max parameters", default=1000000, type=int)
+            population_size = click.prompt("Population size", default=20, type=int)
+            num_generations = click.prompt("Number of generations", default=50, type=int)
+
+    # Generate code from template
+    template_code = TEMPLATES[template]
+    code = template_code.format(
+        name=name,
+        num_classes=num_classes,
+        max_params=max_params,
+        population_size=population_size,
+        num_generations=num_generations,
+    )
+
+    # Determine output file
+    if output is None:
+        output = f"{name}.py"
+
+    output_path = Path(output)
+
+    # Check if file exists
+    if output_path.exists():
+        if not click.confirm(f"File {output} already exists. Overwrite?"):
+            click.echo("Aborted.")
+            return
+
+    # Write file
+    output_path.write_text(code)
+
+    # Success message
+    click.echo(f"\n✓ Created {output}")
+    click.echo(f"\nTemplate: {template}")
+    click.echo(f"Project: {name}")
+    click.echo(f"Classes: {num_classes}")
+
+    if template in ["cnn_classification", "advanced_nas"]:
+        click.echo(f"Max params: {max_params:,}")
+        click.echo(f"Population: {population_size}")
+        click.echo(f"Generations: {num_generations}")
+
+    click.echo("\nNext steps:")
+    click.echo(f"  1. Review and customize {output}")
+    click.echo(f"  2. Run: python {output}")
+    click.echo("  3. Check exported model file")
+
+    # Show template description
+    descriptions = {
+        "cnn_classification": "Full CNN classification with constraints and export",
+        "simple_nas": "Minimal NAS example for quick testing",
+        "advanced_nas": "Advanced NAS with adaptive operators and visualization",
+    }
+    click.echo(f"\nTemplate: {descriptions[template]}")
+
+
+if __name__ == "__main__":
+    quickstart()

morphml/config.py

@@ -0,0 +1,278 @@
+"""Configuration management for MorphML."""
+
+import os
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+from pydantic import BaseModel, Field
+
+from morphml.exceptions import ConfigurationError
+
+
+class OptimizerConfig(BaseModel):
+    """Configuration for optimizers."""
+
+    name: str = Field(description="Optimizer name (genetic, bayesian, darts, etc.)")
+    population_size: int = Field(default=50, ge=1, description="Population size")
+    num_generations: int = Field(default=100, ge=1, description="Number of generations")
+    mutation_rate: float = Field(default=0.1, ge=0.0, le=1.0, description="Mutation probability")
+    crossover_rate: float = Field(default=0.8, ge=0.0, le=1.0, description="Crossover probability")
+
+    class Config:
+        extra = "allow"  # Allow additional fields for optimizer-specific config
+
+
+class EvaluationConfig(BaseModel):
+    """Configuration for architecture evaluation."""
+
+    num_epochs: int = Field(default=50, ge=1, description="Training epochs")
+    batch_size: int = Field(default=128, ge=1, description="Batch size")
+    learning_rate: float = Field(default=0.001, gt=0.0, description="Learning rate")
+    device: str = Field(default="cuda", description="Device (cuda or cpu)")
+    num_workers: int = Field(default=4, ge=0, description="Data loader workers")
+
+
+class LoggingConfig(BaseModel):
+    """Configuration for logging."""
+
+    level: str = Field(default="INFO", description="Log level")
+    format: str = Field(
+        default="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        description="Log format",
+    )
+    file: Optional[str] = Field(default=None, description="Log file path")
+    console: bool = Field(default=True, description="Enable console logging")
+
+
+class ExperimentConfig(BaseModel):
+    """Main experiment configuration."""
+
+    name: str = Field(description="Experiment name")
+    seed: int = Field(default=42, description="Random seed for reproducibility")
+    output_dir: Path = Field(default=Path("./experiments"), description="Output directory")
+
+    optimizer: OptimizerConfig
+    evaluation: EvaluationConfig = Field(default_factory=EvaluationConfig)
+    logging: LoggingConfig = Field(default_factory=LoggingConfig)
+
+    class Config:
+        arbitrary_types_allowed = True
+
+
+class ConfigManager:
+    """
+    Manage MorphML configuration.
+
+    Supports loading from:
+    - YAML files
+    - Environment variables
+    - Python dictionaries
+
+    Usage:
+        config = ConfigManager.from_yaml("config.yaml")
+        config.get("optimizer.population_size")
+        config.set("optimizer.mutation_rate", 0.2)
+    """
+
+    def __init__(self, config_dict: Optional[Dict[str, Any]] = None):
+        """
+        Initialize configuration manager.
+
+        Args:
+            config_dict: Configuration dictionary
+        """
+        self._config = config_dict or {}
+        self._experiment_config: Optional[ExperimentConfig] = None
+
+    @classmethod
+    def from_yaml(cls, config_path: str) -> "ConfigManager":
+        """
+        Load configuration from YAML file.
+
+        Args:
+            config_path: Path to YAML file
+
+        Returns:
+            ConfigManager instance
+
+        Raises:
+            ConfigurationError: If file cannot be loaded
+        """
+        try:
+            with open(config_path, "r") as f:
+                config_dict = yaml.safe_load(f)
+            return cls(config_dict)
+        except Exception as e:
+            raise ConfigurationError(f"Failed to load config from {config_path}: {e}") from e
+
+    @classmethod
+    def from_dict(cls, config_dict: Dict[str, Any]) -> "ConfigManager":
+        """Create configuration from dictionary."""
+        return cls(config_dict)
+
+    def get(self, key: str, default: Any = None) -> Any:
+        """
+        Get configuration value by dot-separated key.
+
+        Args:
+            key: Dot-separated key (e.g., "optimizer.population_size")
+            default: Default value if key not found
+
+        Returns:
+            Configuration value
+
+        Example:
+            >>> config.get("optimizer.mutation_rate")
+            0.1
+        """
+        keys = key.split(".")
+        value: Any = self._config
+
+        for k in keys:
+            if isinstance(value, dict):
+                value = value.get(k)
+                if value is None:
+                    return default
+            else:
+                return default
+
+        return value
+
+    def set(self, key: str, value: Any) -> None:
+        """
+        Set configuration value by dot-separated key.
+
+        Args:
+            key: Dot-separated key
+            value: Value to set
+        """
+        keys = key.split(".")
+        config = self._config
+
+        for k in keys[:-1]:
+            if k not in config:
+                config[k] = {}
+            config = config[k]
+
+        config[keys[-1]] = value
+
+    def validate(self) -> ExperimentConfig:
+        """
+        Validate configuration using Pydantic model.
+
+        Returns:
+            Validated ExperimentConfig
+
+        Raises:
+            ConfigurationError: If validation fails
+        """
+        try:
+            self._experiment_config = ExperimentConfig(**self._config)
+            return self._experiment_config
+        except Exception as e:
+            raise ConfigurationError(f"Configuration validation failed: {e}") from e
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Export configuration as dictionary."""
+        return self._config.copy()
+
+    def save(self, output_path: str) -> None:
+        """
+        Save configuration to YAML file.
+
+        Args:
+            output_path: Output file path
+        """
+        with open(output_path, "w") as f:
+            yaml.dump(self._config, f, default_flow_style=False, sort_keys=False)
+
+    def merge(self, other_config: Dict[str, Any]) -> None:
+        """
+        Merge another configuration into this one.
+
+        Args:
+            other_config: Configuration dictionary to merge
+        """
+        self._deep_merge(self._config, other_config)
+
+    @staticmethod
+    def _deep_merge(base: Dict, update: Dict) -> None:
+        """Deep merge update dict into base dict."""
+        for key, value in update.items():
+            if key in base and isinstance(base[key], dict) and isinstance(value, dict):
+                ConfigManager._deep_merge(base[key], value)
+            else:
+                base[key] = value
+
+
+def load_config_from_env() -> Dict[str, Any]:
+    """
+    Load configuration from environment variables.
+
+    Environment variables should be prefixed with MORPHML_
+    Example: MORPHML_OPTIMIZER_POPULATION_SIZE=100
+
+    Returns:
+        Configuration dictionary
+    """
+    config: Dict[str, Any] = {}
+    prefix = "MORPHML_"
+
+    for key, value in os.environ.items():
+        if key.startswith(prefix):
+            # Remove prefix and convert to lowercase with dots
+            config_key = key[len(prefix) :].lower().replace("_", ".")
+
+            # Try to convert to int/float
+            try:
+                if "." in value:
+                    value = float(value)  # type: ignore
+                else:
+                    value = int(value)  # type: ignore
+            except ValueError:
+                pass
+
+            # Set in config
+            keys = config_key.split(".")
+            current = config
+            for k in keys[:-1]:
+                if k not in current:
+                    current[k] = {}
+                current = current[k]
+            current[keys[-1]] = value
+
+    return config
+
+
+# Default configuration template
+DEFAULT_CONFIG = {
+    "name": "morphml_experiment",
+    "seed": 42,
+    "output_dir": "./experiments",
+    "optimizer": {
+        "name": "genetic",
+        "population_size": 50,
+        "num_generations": 100,
+        "mutation_rate": 0.1,
+        "crossover_rate": 0.8,
+    },
+    "evaluation": {
+        "num_epochs": 50,
+        "batch_size": 128,
+        "learning_rate": 0.001,
+        "device": "cuda",
+        "num_workers": 4,
+    },
+    "logging": {"level": "INFO", "console": True, "file": None},
+}
+
+
+def get_config() -> ConfigManager:
+    """
+    Get default configuration manager.
+
+    Returns:
+        ConfigManager instance with default configuration
+    """
+    return ConfigManager.from_dict(DEFAULT_CONFIG)

morphml/constraints/__init__.py

@@ -0,0 +1,19 @@
+"""Constraint handling for architecture search."""
+
+from morphml.constraints.handler import ConstraintHandler
+from morphml.constraints.predicates import (
+    DepthConstraint,
+    MaxParametersConstraint,
+    MinParametersConstraint,
+    OperationConstraint,
+    WidthConstraint,
+)
+
+__all__ = [
+    "ConstraintHandler",
+    "MaxParametersConstraint",
+    "MinParametersConstraint",
+    "DepthConstraint",
+    "WidthConstraint",
+    "OperationConstraint",
+]