morphml 1.0.0__py3-none-any.whl

morphml/optimizers/nsga2.py

@@ -0,0 +1,308 @@
+"""NSGA-II - Non-dominated Sorting Genetic Algorithm II.
+
+Multi-objective optimization using Pareto dominance and crowding distance.
+"""
+
+import random
+from typing import Callable, Dict, List, Optional
+
+from morphml.core.dsl.search_space import SearchSpace
+from morphml.core.graph import GraphMutator, ModelGraph
+from morphml.core.search import Individual, Population
+from morphml.exceptions import OptimizerError
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class NSGA2:
+    """
+    NSGA-II for multi-objective NAS.
+
+    Optimizes multiple objectives simultaneously using:
+    - Non-dominated sorting
+    - Crowding distance
+    - Pareto front preservation
+    """
+
+    def __init__(
+        self,
+        search_space: SearchSpace,
+        objectives: List[str],
+        population_size: int = 100,
+        num_generations: int = 100,
+        mutation_rate: float = 0.2,
+        crossover_rate: float = 0.8,
+        **kwargs,
+    ):
+        """Initialize NSGA-II."""
+        self.search_space = search_space
+        self.objectives = objectives
+        self.population_size = population_size
+        self.num_generations = num_generations
+        self.mutation_rate = mutation_rate
+        self.crossover_rate = crossover_rate
+
+        self.population = Population(max_size=population_size * 2, elitism=0)
+        self.mutator = GraphMutator()
+        self.pareto_front: List[Individual] = []
+        self.history: List[dict] = []
+
+        logger.info(f"Created NSGA2: objectives={objectives}, pop={population_size}")
+
+    def dominates(self, ind1: Individual, ind2: Individual) -> bool:
+        """Check if ind1 dominates ind2."""
+        better_in_any = False
+
+        for obj in self.objectives:
+            val1 = ind1.get_metric(obj, 0.0)
+            val2 = ind2.get_metric(obj, 0.0)
+
+            if val1 < val2:
+                return False  # Worse in this objective
+            if val1 > val2:
+                better_in_any = True
+
+        return better_in_any
+
+    def fast_non_dominated_sort(self, individuals: List[Individual]) -> List[List[Individual]]:
+        """Perform fast non-dominated sorting."""
+        fronts: List[List[Individual]] = [[]]
+        domination_count: Dict[str, int] = {}
+        dominated_solutions: Dict[str, List[Individual]] = {}
+
+        # Initialize
+        for ind in individuals:
+            ind_id = ind.id
+            domination_count[ind_id] = 0
+            dominated_solutions[ind_id] = []
+
+        # Find domination relationships
+        for i, ind1 in enumerate(individuals):
+            for ind2 in individuals[i + 1 :]:
+                if self.dominates(ind1, ind2):
+                    dominated_solutions[ind1.id].append(ind2)
+                    domination_count[ind2.id] += 1
+                elif self.dominates(ind2, ind1):
+                    dominated_solutions[ind2.id].append(ind1)
+                    domination_count[ind1.id] += 1
+
+            # If not dominated by anyone, belongs to first front
+            if domination_count[ind1.id] == 0:
+                fronts[0].append(ind1)
+
+        # Build subsequent fronts
+        current_front = 0
+        while fronts[current_front]:
+            next_front = []
+            for ind in fronts[current_front]:
+                for dominated in dominated_solutions[ind.id]:
+                    domination_count[dominated.id] -= 1
+                    if domination_count[dominated.id] == 0:
+                        next_front.append(dominated)
+
+            current_front += 1
+            if next_front:
+                fronts.append(next_front)
+            else:
+                break
+
+        return [f for f in fronts if f]  # Remove empty fronts
+
+    def calculate_crowding_distance(self, front: List[Individual]) -> Dict[str, float]:
+        """Calculate crowding distance for individuals in front."""
+        distances: Dict[str, float] = {ind.id: 0.0 for ind in front}
+
+        if len(front) <= 2:
+            for ind in front:
+                distances[ind.id] = float("inf")
+            return distances
+
+        # For each objective
+        for obj in self.objectives:
+            # Sort by objective value
+            sorted_front = sorted(front, key=lambda x: x.get_metric(obj, 0.0))
+
+            # Boundary points get infinite distance
+            distances[sorted_front[0].id] = float("inf")
+            distances[sorted_front[-1].id] = float("inf")
+
+            # Get objective range
+            obj_min = sorted_front[0].get_metric(obj, 0.0)
+            obj_max = sorted_front[-1].get_metric(obj, 0.0)
+            obj_range = obj_max - obj_min
+
+            if obj_range == 0:
+                continue
+
+            # Calculate crowding distance
+            for i in range(1, len(sorted_front) - 1):
+                prev_val = sorted_front[i - 1].get_metric(obj, 0.0)
+                next_val = sorted_front[i + 1].get_metric(obj, 0.0)
+                distances[sorted_front[i].id] += (next_val - prev_val) / obj_range
+
+        return distances
+
+    def environmental_selection(self, individuals: List[Individual]) -> List[Individual]:
+        """Select next generation using NSGA-II selection."""
+        # Non-dominated sorting
+        fronts = self.fast_non_dominated_sort(individuals)
+
+        # Select individuals
+        selected = []
+        for front in fronts:
+            if len(selected) + len(front) <= self.population_size:
+                selected.extend(front)
+            else:
+                # Calculate crowding distance for this front
+                distances = self.calculate_crowding_distance(front)
+
+                # Sort by crowding distance (descending)
+                front_sorted = sorted(front, key=lambda x: distances[x.id], reverse=True)
+
+                # Add individuals until population is full
+                remaining = self.population_size - len(selected)
+                selected.extend(front_sorted[:remaining])
+                break
+
+        return selected
+
+    def initialize_population(self) -> None:
+        """Initialize population."""
+        logger.info(f"Initializing population of size {self.population_size}")
+
+        for i in range(self.population_size):
+            try:
+                graph = self.search_space.sample()
+                individual = Individual(graph)
+                self.population.add(individual)
+            except Exception as e:
+                logger.warning(f"Failed to sample individual {i}: {e}")
+                continue
+
+    def evaluate_population(self, evaluator: Callable[[ModelGraph], Dict[str, float]]) -> None:
+        """Evaluate population on multiple objectives."""
+        unevaluated = self.population.get_unevaluated()
+
+        if not unevaluated:
+            return
+
+        logger.info(f"Evaluating {len(unevaluated)} individuals")
+
+        for ind in unevaluated:
+            try:
+                # Evaluator returns dict of objective values
+                metrics = evaluator(ind.graph)
+
+                # Set fitness as primary objective
+                if self.objectives:
+                    primary_fitness = metrics.get(self.objectives[0], 0.0)
+                    ind.set_fitness(primary_fitness, **metrics)
+                else:
+                    ind.set_fitness(sum(metrics.values()) / len(metrics), **metrics)
+
+            except Exception as e:
+                logger.error(f"Evaluation failed: {e}")
+                ind.set_fitness(0.0)
+
+    def generate_offspring(self, parents: List[Individual]) -> List[Individual]:
+        """Generate offspring through crossover and mutation."""
+        offspring = []
+
+        while len(offspring) < len(parents):
+            # Select parents
+            parent1, parent2 = random.sample(parents, 2)
+
+            # Crossover
+            if random.random() < self.crossover_rate:
+                child = parent1.clone(keep_fitness=False)
+                child.parent_ids = [parent1.id, parent2.id]
+            else:
+                child = random.choice([parent1, parent2]).clone(keep_fitness=False)
+
+            # Mutation
+            if random.random() < self.mutation_rate:
+                mutated_graph = self.mutator.mutate(child.graph)
+                child = Individual(mutated_graph, parent_ids=child.parent_ids)
+
+            offspring.append(child)
+
+        return offspring
+
+    def optimize(
+        self,
+        evaluator: Callable[[ModelGraph], Dict[str, float]],
+        callback: Optional[Callable[[int, List[Individual]], None]] = None,
+    ) -> List[Individual]:
+        """Run NSGA-II optimization."""
+        try:
+            # Initialize
+            self.initialize_population()
+            self.evaluate_population(evaluator)
+
+            # Evolution loop
+            for gen in range(self.num_generations):
+                logger.info(f"Generation {gen + 1}/{self.num_generations}")
+
+                # Generate offspring
+                parents = list(self.population.individuals)
+                offspring = self.generate_offspring(parents)
+
+                # Evaluate offspring
+                self.population.add_many(offspring)
+                self.evaluate_population(evaluator)
+
+                # Environmental selection
+                combined = list(self.population.individuals)
+                selected = self.environmental_selection(combined)
+
+                # Update population
+                self.population.clear()
+                self.population.add_many(selected)
+
+                # Update Pareto front
+                fronts = self.fast_non_dominated_sort(selected)
+                self.pareto_front = fronts[0] if fronts else []
+
+                # Record stats
+                stats = {
+                    "generation": gen + 1,
+                    "pareto_size": len(self.pareto_front),
+                    "population_size": len(selected),
+                }
+                self.history.append(stats)
+
+                logger.info(f"Gen {gen + 1}: Pareto front size = {len(self.pareto_front)}")
+
+                # Callback
+                if callback:
+                    callback(gen + 1, self.pareto_front)
+
+            logger.info(f"NSGA-II complete: Pareto front size = {len(self.pareto_front)}")
+            return self.pareto_front
+
+        except Exception as e:
+            logger.error(f"NSGA-II optimization failed: {e}")
+            raise OptimizerError(f"NSGA-II optimization failed: {e}") from e
+
+    def get_pareto_front(self) -> List[Individual]:
+        """Get current Pareto front."""
+        return self.pareto_front
+
+    def get_history(self) -> List[dict]:
+        """Get optimization history."""
+        return self.history
+
+    def reset(self) -> None:
+        """Reset optimizer."""
+        self.population.clear()
+        self.pareto_front.clear()
+        self.history.clear()
+        logger.info("NSGA-II reset")
+
+    def __repr__(self) -> str:
+        return (
+            f"NSGA2(objectives={self.objectives}, "
+            f"pop={self.population_size}, "
+            f"pareto_size={len(self.pareto_front)})"
+        )

morphml/optimizers/random_search.py

@@ -0,0 +1,172 @@
+"""Random Search optimizer - baseline for NAS.
+
+Simplest possible search strategy: randomly sample architectures
+and return the best one. Serves as a baseline for comparison.
+
+Example:
+    >>> from morphml.optimizers import RandomSearch
+    >>> from morphml.core.dsl import create_cnn_space
+    >>>
+    >>> space = create_cnn_space(num_classes=10)
+    >>> rs = RandomSearch(search_space=space, num_samples=100)
+    >>> best = rs.optimize(evaluator=my_evaluator)
+"""
+
+from typing import Callable, List, Optional
+
+from morphml.core.dsl.search_space import SearchSpace
+from morphml.core.graph import ModelGraph
+from morphml.core.search import Individual
+from morphml.exceptions import OptimizerError
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class RandomSearch:
+    """
+    Random Search optimizer - baseline for Neural Architecture Search.
+
+    Randomly samples N architectures from the search space, evaluates
+    them all, and returns the best one. Despite its simplicity, often
+    surprisingly effective and serves as an important baseline.
+
+    Attributes:
+        search_space: SearchSpace to sample from
+        num_samples: Number of architectures to evaluate
+        evaluated: List of evaluated individuals
+        best_individual: Best architecture found
+
+    Example:
+        >>> rs = RandomSearch(
+        ...     search_space=space,
+        ...     num_samples=100,
+        ...     allow_duplicates=False
+        ... )
+        >>> best = rs.optimize(evaluator=evaluate_func)
+    """
+
+    def __init__(
+        self,
+        search_space: SearchSpace,
+        num_samples: int = 100,
+        allow_duplicates: bool = False,
+        **kwargs,
+    ):
+        """
+        Initialize Random Search optimizer.
+
+        Args:
+            search_space: SearchSpace to sample architectures from
+            num_samples: Number of architectures to sample and evaluate
+            allow_duplicates: Whether to allow duplicate architectures
+            **kwargs: Additional configuration (for compatibility)
+        """
+        self.search_space = search_space
+        self.num_samples = num_samples
+        self.allow_duplicates = allow_duplicates
+
+        self.evaluated: List[Individual] = []
+        self.best_individual: Optional[Individual] = None
+
+        logger.info(f"Created RandomSearch: num_samples={num_samples}")
+
+    def optimize(self, evaluator: Callable[[ModelGraph], float]) -> Individual:
+        """
+        Run random search optimization.
+
+        Args:
+            evaluator: Function to evaluate fitness of architectures
+
+        Returns:
+            Best individual found
+
+        Raises:
+            OptimizerError: If optimization fails
+
+        Example:
+            >>> def evaluate(graph):
+            ...     return accuracy_score
+            >>> best = rs.optimize(evaluate)
+        """
+        try:
+            logger.info(f"Starting random search with {self.num_samples} samples")
+
+            seen_hashes = set()
+            sampled = 0
+
+            while sampled < self.num_samples:
+                try:
+                    # Sample architecture
+                    graph = self.search_space.sample()
+
+                    # Check for duplicates
+                    if not self.allow_duplicates:
+                        graph_hash = graph.hash()
+                        if graph_hash in seen_hashes:
+                            logger.debug("Skipping duplicate architecture")
+                            continue
+                        seen_hashes.add(graph_hash)
+
+                    # Create individual and evaluate
+                    individual = Individual(graph)
+                    fitness = evaluator(graph)
+                    individual.set_fitness(fitness)
+
+                    self.evaluated.append(individual)
+                    sampled += 1
+
+                    # Track best
+                    if self.best_individual is None or fitness > self.best_individual.fitness:
+                        self.best_individual = individual
+                        logger.info(f"New best: {fitness:.4f} (sample {sampled})")
+
+                    if sampled % 10 == 0:
+                        logger.debug(f"Evaluated {sampled}/{self.num_samples} architectures")
+
+                except Exception as e:
+                    logger.warning(f"Sample failed: {e}")
+                    continue
+
+            # Final results
+            logger.info(
+                f"Random search complete: " f"Best fitness = {self.best_individual.fitness:.4f}"
+            )
+
+            return self.best_individual
+
+        except Exception as e:
+            logger.error(f"Random search failed: {e}")
+            raise OptimizerError(f"Random search optimization failed: {e}") from e
+
+    def get_all_evaluated(self) -> List[Individual]:
+        """
+        Get all evaluated individuals.
+
+        Returns:
+            List of all evaluated individuals
+        """
+        return self.evaluated
+
+    def get_best_n(self, n: int = 10) -> List[Individual]:
+        """
+        Get top N individuals.
+
+        Args:
+            n: Number of individuals to return
+
+        Returns:
+            List of best individuals sorted by fitness
+        """
+        sorted_inds = sorted(self.evaluated, key=lambda x: x.fitness or 0, reverse=True)
+        return sorted_inds[:n]
+
+    def reset(self) -> None:
+        """Reset optimizer state."""
+        self.evaluated.clear()
+        self.best_individual = None
+        logger.info("Random search reset")
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"RandomSearch(num_samples={self.num_samples}, " f"evaluated={len(self.evaluated)})"

morphml/optimizers/simulated_annealing.py

@@ -0,0 +1,181 @@
+"""Simulated Annealing optimizer for NAS.
+
+Probabilistic hill climbing that accepts worse solutions with
+decreasing probability to escape local optima.
+"""
+
+import math
+import random
+from typing import Callable, List, Optional
+
+from morphml.core.dsl.search_space import SearchSpace
+from morphml.core.graph import GraphMutator, ModelGraph
+from morphml.core.search import Individual
+from morphml.exceptions import OptimizerError
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class SimulatedAnnealing:
+    """
+    Simulated Annealing optimizer.
+
+    Accepts worse solutions with probability based on temperature
+    schedule, enabling escape from local optima.
+    """
+
+    def __init__(
+        self,
+        search_space: SearchSpace,
+        max_iterations: int = 1000,
+        initial_temp: float = 100.0,
+        final_temp: float = 0.1,
+        cooling_rate: float = 0.95,
+        cooling_schedule: str = "exponential",
+        num_mutations: int = 3,
+        mutation_rate: float = 0.3,
+        **kwargs,
+    ):
+        """Initialize SA optimizer."""
+        self.search_space = search_space
+        self.max_iterations = max_iterations
+        self.initial_temp = initial_temp
+        self.final_temp = final_temp
+        self.cooling_rate = cooling_rate
+        self.cooling_schedule = cooling_schedule
+        self.num_mutations = num_mutations
+        self.mutation_rate = mutation_rate
+
+        self.mutator = GraphMutator()
+        self.current: Optional[Individual] = None
+        self.best: Optional[Individual] = None
+        self.history: List[dict] = []
+
+        logger.info(f"Created SimulatedAnnealing: T0={initial_temp}, Tf={final_temp}")
+
+    def get_temperature(self, iteration: int) -> float:
+        """Calculate temperature at iteration."""
+        progress = iteration / self.max_iterations
+
+        if self.cooling_schedule == "exponential":
+            return self.initial_temp * (self.cooling_rate**iteration)
+        elif self.cooling_schedule == "linear":
+            return self.initial_temp - (self.initial_temp - self.final_temp) * progress
+        elif self.cooling_schedule == "logarithmic":
+            return self.initial_temp / (1 + math.log(1 + iteration))
+        else:
+            return self.initial_temp * (self.cooling_rate**iteration)
+
+    def acceptance_probability(self, old_fitness: float, new_fitness: float, temp: float) -> float:
+        """Calculate acceptance probability."""
+        if new_fitness > old_fitness:
+            return 1.0
+
+        if temp <= 0:
+            return 0.0
+
+        delta = new_fitness - old_fitness
+        return math.exp(delta / temp)
+
+    def optimize(self, evaluator: Callable[[ModelGraph], float]) -> Individual:
+        """Run simulated annealing."""
+        try:
+            # Initialize
+            logger.info("Initializing simulated annealing")
+            init_graph = self.search_space.sample()
+            self.current = Individual(init_graph)
+            fitness = evaluator(self.current.graph)
+            self.current.set_fitness(fitness)
+            self.best = self.current
+
+            self.history.append(
+                {
+                    "iteration": 0,
+                    "fitness": fitness,
+                    "temperature": self.initial_temp,
+                    "accepted": True,
+                }
+            )
+
+            logger.info(f"Initial fitness: {fitness:.4f}")
+
+            for iteration in range(1, self.max_iterations + 1):
+                # Get temperature
+                temp = self.get_temperature(iteration)
+
+                # Generate neighbor
+                mutated_graph = self.mutator.mutate(
+                    self.current.graph,
+                    mutation_rate=self.mutation_rate,
+                    max_mutations=self.num_mutations,
+                )
+
+                neighbor = Individual(mutated_graph)
+                neighbor_fitness = evaluator(neighbor.graph)
+                neighbor.set_fitness(neighbor_fitness)
+
+                # Accept or reject
+                prob = self.acceptance_probability(self.current.fitness, neighbor_fitness, temp)
+
+                accepted = random.random() < prob
+
+                if accepted:
+                    self.current = neighbor
+
+                    # Update best
+                    if neighbor_fitness > self.best.fitness:
+                        self.best = neighbor
+                        logger.info(
+                            f"Iteration {iteration}: New best {neighbor_fitness:.4f} "
+                            f"(T={temp:.3f})"
+                        )
+
+                self.history.append(
+                    {
+                        "iteration": iteration,
+                        "fitness": neighbor_fitness,
+                        "temperature": temp,
+                        "accepted": accepted,
+                    }
+                )
+
+                if iteration % 100 == 0:
+                    logger.debug(
+                        f"Iteration {iteration}/{self.max_iterations}: "
+                        f"Current={self.current.fitness:.4f}, "
+                        f"Best={self.best.fitness:.4f}, "
+                        f"T={temp:.3f}"
+                    )
+
+            logger.info(f"SA complete: Best fitness = {self.best.fitness:.4f}")
+            return self.best
+
+        except Exception as e:
+            logger.error(f"Simulated annealing failed: {e}")
+            raise OptimizerError(f"SA optimization failed: {e}") from e
+
+    def get_history(self) -> List[dict]:
+        """Get optimization history."""
+        return self.history
+
+    def get_acceptance_rate(self) -> float:
+        """Calculate overall acceptance rate."""
+        if not self.history:
+            return 0.0
+        accepted = sum(1 for h in self.history if h["accepted"])
+        return accepted / len(self.history)
+
+    def reset(self) -> None:
+        """Reset optimizer."""
+        self.current = None
+        self.best = None
+        self.history.clear()
+        logger.info("SA reset")
+
+    def __repr__(self) -> str:
+        return (
+            f"SimulatedAnnealing(T0={self.initial_temp}, "
+            f"Tf={self.final_temp}, "
+            f"iterations={self.max_iterations})"
+        )

morphml/plugins/__init__.py

@@ -0,0 +1,35 @@
+"""Plugin system for MorphML.
+
+Provides extensibility through plugins for:
+- Custom optimizers
+- Custom evaluators
+- Custom mutation operators
+- Custom objectives
+- Custom visualizations
+
+Example:
+    >>> from morphml.plugins import PluginManager
+    >>> manager = PluginManager()
+    >>> manager.load_plugin('custom_optimizer')
+    >>> plugin = manager.get_plugin('custom_optimizer')
+"""
+
+from morphml.plugins.plugin_system import (
+    EvaluatorPlugin,
+    MutationPlugin,
+    ObjectivePlugin,
+    OptimizerPlugin,
+    Plugin,
+    PluginManager,
+    VisualizationPlugin,
+)
+
+__all__ = [
+    "Plugin",
+    "OptimizerPlugin",
+    "EvaluatorPlugin",
+    "MutationPlugin",
+    "ObjectivePlugin",
+    "VisualizationPlugin",
+    "PluginManager",
+]