morphml 1.0.0__py3-none-any.whl

morphml/constraints/handler.py

@@ -0,0 +1,205 @@
+"""Constraint handler for managing architecture constraints."""
+
+from typing import Dict, List
+
+from morphml.constraints.predicates import Constraint
+from morphml.core.graph import ModelGraph
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+class ConstraintHandler:
+    """
+    Manages and evaluates constraints on architectures.
+
+    Example:
+        >>> handler = ConstraintHandler()
+        >>> handler.add_constraint(MaxParametersConstraint(1000000))
+        >>> handler.add_constraint(DepthConstraint(min_depth=5, max_depth=20))
+        >>>
+        >>> if handler.check(graph):
+        ...     print("Valid!")
+        >>>
+        >>> penalty = handler.total_penalty(graph)
+    """
+
+    def __init__(self):
+        """Initialize constraint handler."""
+        self.constraints: List[Constraint] = []
+        logger.debug("Created ConstraintHandler")
+
+    def add_constraint(self, constraint: Constraint) -> None:
+        """
+        Add a constraint.
+
+        Args:
+            constraint: Constraint to add
+        """
+        self.constraints.append(constraint)
+        logger.debug(f"Added constraint: {constraint}")
+
+    def remove_constraint(self, name: str) -> None:
+        """
+        Remove a constraint by name.
+
+        Args:
+            name: Constraint name
+        """
+        self.constraints = [c for c in self.constraints if c.name != name]
+        logger.debug(f"Removed constraint: {name}")
+
+    def check(self, graph: ModelGraph) -> bool:
+        """
+        Check if graph satisfies all constraints.
+
+        Args:
+            graph: Graph to check
+
+        Returns:
+            True if all constraints satisfied
+        """
+        for constraint in self.constraints:
+            if not constraint.check(graph):
+                logger.debug(f"Constraint violated: {constraint.name}")
+                return False
+        return True
+
+    def get_violations(self, graph: ModelGraph) -> List[str]:
+        """
+        Get list of violated constraints.
+
+        Args:
+            graph: Graph to check
+
+        Returns:
+            List of violated constraint names
+        """
+        violations = []
+        for constraint in self.constraints:
+            if not constraint.check(graph):
+                violations.append(constraint.name)
+        return violations
+
+    def get_detailed_violations(self, graph: ModelGraph) -> List[Dict[str, any]]:
+        """
+        Get detailed information about violated constraints.
+
+        Args:
+            graph: Graph to check
+
+        Returns:
+            List of dictionaries with violation details including:
+            - name: Constraint name
+            - message: Descriptive error message
+            - penalty: Penalty value
+            - actual: Actual value measured
+            - expected: Expected value/range
+        """
+        violations = []
+        for constraint in self.constraints:
+            if not constraint.check(graph):
+                violation_info = {
+                    "name": constraint.name,
+                    "penalty": constraint.penalty(graph),
+                }
+
+                # Add constraint-specific details
+                if hasattr(constraint, "get_violation_message"):
+                    violation_info["message"] = constraint.get_violation_message(graph)
+                else:
+                    violation_info["message"] = f"Constraint '{constraint.name}' violated"
+
+                if hasattr(constraint, "get_actual_value"):
+                    violation_info["actual"] = constraint.get_actual_value(graph)
+
+                if hasattr(constraint, "get_expected_range"):
+                    violation_info["expected"] = constraint.get_expected_range()
+
+                violations.append(violation_info)
+
+        return violations
+
+    def format_violations(self, graph: ModelGraph) -> str:
+        """
+        Format violation details as a human-readable string.
+
+        Args:
+            graph: Graph to check
+
+        Returns:
+            Formatted string describing all violations
+        """
+        violations = self.get_detailed_violations(graph)
+
+        if not violations:
+            return "No constraint violations"
+
+        lines = [f"Found {len(violations)} constraint violation(s):"]
+        for i, v in enumerate(violations, 1):
+            lines.append(f"\n{i}. {v['name']}")
+            lines.append(f"   Message: {v['message']}")
+            if "actual" in v:
+                lines.append(f"   Actual: {v['actual']}")
+            if "expected" in v:
+                lines.append(f"   Expected: {v['expected']}")
+            lines.append(f"   Penalty: {v['penalty']:.4f}")
+
+        return "\n".join(lines)
+
+    def total_penalty(self, graph: ModelGraph) -> float:
+        """
+        Calculate total penalty for all constraints.
+
+        Args:
+            graph: Graph to evaluate
+
+        Returns:
+            Total penalty (0 = all constraints satisfied)
+        """
+        if not self.constraints:
+            return 0.0
+
+        total = sum(c.penalty(graph) for c in self.constraints)
+        return total / len(self.constraints)
+
+    def get_penalties(self, graph: ModelGraph) -> Dict[str, float]:
+        """
+        Get penalties for each constraint.
+
+        Args:
+            graph: Graph to evaluate
+
+        Returns:
+            Dictionary mapping constraint names to penalties
+        """
+        return {c.name: c.penalty(graph) for c in self.constraints}
+
+    def apply_penalty_to_fitness(
+        self, fitness: float, graph: ModelGraph, penalty_weight: float = 0.5
+    ) -> float:
+        """
+        Apply constraint penalties to fitness score.
+
+        Args:
+            fitness: Original fitness
+            graph: Architecture graph
+            penalty_weight: Weight for penalty term
+
+        Returns:
+            Penalized fitness
+        """
+        penalty = self.total_penalty(graph)
+        return fitness * (1 - penalty_weight * penalty)
+
+    def clear(self) -> None:
+        """Remove all constraints."""
+        self.constraints.clear()
+        logger.debug("Cleared all constraints")
+
+    def __len__(self) -> int:
+        """Return number of constraints."""
+        return len(self.constraints)
+
+    def __repr__(self) -> str:
+        return f"ConstraintHandler(constraints={len(self.constraints)})"

morphml/constraints/predicates.py

@@ -0,0 +1,285 @@
+"""Constraint predicates for architecture validation."""
+
+from typing import List, Optional, Set
+
+from morphml.core.graph import ModelGraph
+
+
+class Constraint:
+    """Base class for constraints."""
+
+    def __init__(self, name: str):
+        """Initialize constraint."""
+        self.name = name
+
+    def check(self, graph: ModelGraph) -> bool:
+        """Check if graph satisfies constraint."""
+        raise NotImplementedError
+
+    def penalty(self, graph: ModelGraph) -> float:
+        """Calculate penalty for constraint violation."""
+        return 0.0 if self.check(graph) else 1.0
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(name={self.name})"
+
+
+class MaxParametersConstraint(Constraint):
+    """Constraint on maximum parameters."""
+
+    def __init__(self, max_params: int, name: str = "max_parameters"):
+        """
+        Initialize max parameters constraint.
+
+        Args:
+            max_params: Maximum allowed parameters
+            name: Constraint name
+        """
+        super().__init__(name)
+        self.max_params = max_params
+
+    def check(self, graph: ModelGraph) -> bool:
+        """Check if within parameter limit."""
+        return graph.estimate_parameters() <= self.max_params
+
+    def penalty(self, graph: ModelGraph) -> float:
+        """Penalty based on excess parameters."""
+        params = graph.estimate_parameters()
+        if params <= self.max_params:
+            return 0.0
+        excess_ratio = (params - self.max_params) / self.max_params
+        return min(1.0, excess_ratio)
+
+    def get_actual_value(self, graph: ModelGraph) -> int:
+        """Get actual parameter count."""
+        return graph.estimate_parameters()
+
+    def get_expected_range(self) -> str:
+        """Get expected parameter range."""
+        return f"<= {self.max_params:,}"
+
+    def get_violation_message(self, graph: ModelGraph) -> str:
+        """Get detailed violation message."""
+        actual = self.get_actual_value(graph)
+        excess = actual - self.max_params
+        return f"Architecture has {actual:,} parameters, exceeding limit by {excess:,}"
+
+    def __repr__(self) -> str:
+        return f"MaxParametersConstraint(max={self.max_params:,})"
+
+
+class MinParametersConstraint(Constraint):
+    """Constraint on minimum parameters."""
+
+    def __init__(self, min_params: int, name: str = "min_parameters"):
+        """Initialize min parameters constraint."""
+        super().__init__(name)
+        self.min_params = min_params
+
+    def check(self, graph: ModelGraph) -> bool:
+        """Check if meets minimum parameters."""
+        return graph.estimate_parameters() >= self.min_params
+
+    def penalty(self, graph: ModelGraph) -> float:
+        """Penalty based on parameter deficit."""
+        params = graph.estimate_parameters()
+        if params >= self.min_params:
+            return 0.0
+        deficit_ratio = (self.min_params - params) / self.min_params
+        return min(1.0, deficit_ratio)
+
+    def get_actual_value(self, graph: ModelGraph) -> int:
+        """Get actual parameter count."""
+        return graph.estimate_parameters()
+
+    def get_expected_range(self) -> str:
+        """Get expected parameter range."""
+        return f">= {self.min_params:,}"
+
+    def get_violation_message(self, graph: ModelGraph) -> str:
+        """Get detailed violation message."""
+        actual = self.get_actual_value(graph)
+        deficit = self.min_params - actual
+        return f"Architecture has {actual:,} parameters, below minimum by {deficit:,}"
+
+
+class DepthConstraint(Constraint):
+    """Constraint on network depth."""
+
+    def __init__(self, min_depth: int = 1, max_depth: int = 100, name: str = "depth"):
+        """Initialize depth constraint."""
+        super().__init__(name)
+        self.min_depth = min_depth
+        self.max_depth = max_depth
+
+    def check(self, graph: ModelGraph) -> bool:
+        """Check if depth is within range."""
+        depth = graph.get_depth()
+        return self.min_depth <= depth <= self.max_depth
+
+    def penalty(self, graph: ModelGraph) -> float:
+        """Penalty based on depth violation."""
+        depth = graph.get_depth()
+
+        if depth < self.min_depth:
+            deficit = (self.min_depth - depth) / self.min_depth
+            return min(1.0, deficit)
+        elif depth > self.max_depth:
+            excess = (depth - self.max_depth) / self.max_depth
+            return min(1.0, excess)
+        else:
+            return 0.0
+
+
+class WidthConstraint(Constraint):
+    """Constraint on network width."""
+
+    def __init__(self, min_width: int = 1, max_width: int = 100, name: str = "width"):
+        """Initialize width constraint."""
+        super().__init__(name)
+        self.min_width = min_width
+        self.max_width = max_width
+
+    def check(self, graph: ModelGraph) -> bool:
+        """Check if width is within range."""
+        width = graph.get_max_width()
+        return self.min_width <= width <= self.max_width
+
+    def penalty(self, graph: ModelGraph) -> float:
+        """Penalty based on width violation."""
+        width = graph.get_max_width()
+
+        if width < self.min_width:
+            return (self.min_width - width) / self.min_width
+        elif width > self.max_width:
+            return (width - self.max_width) / self.max_width
+        else:
+            return 0.0
+
+
+class OperationConstraint(Constraint):
+    """Constraint on required/forbidden operations."""
+
+    def __init__(
+        self,
+        required_ops: Optional[Set[str]] = None,
+        forbidden_ops: Optional[Set[str]] = None,
+        name: str = "operations",
+    ):
+        """
+        Initialize operation constraint.
+
+        Args:
+            required_ops: Set of required operation types
+            forbidden_ops: Set of forbidden operation types
+            name: Constraint name
+        """
+        super().__init__(name)
+        self.required_ops = required_ops or set()
+        self.forbidden_ops = forbidden_ops or set()
+
+    def check(self, graph: ModelGraph) -> bool:
+        """Check if operations satisfy constraints."""
+        graph_ops = {node.operation for node in graph.nodes.values()}
+
+        # Check required operations
+        if self.required_ops and not self.required_ops.issubset(graph_ops):
+            return False
+
+        # Check forbidden operations
+        if self.forbidden_ops and self.forbidden_ops.intersection(graph_ops):
+            return False
+
+        return True
+
+    def penalty(self, graph: ModelGraph) -> float:
+        """Penalty based on operation violations."""
+        graph_ops = {node.operation for node in graph.nodes.values()}
+
+        penalty = 0.0
+
+        # Penalty for missing required ops
+        if self.required_ops:
+            missing = len(self.required_ops - graph_ops)
+            penalty += missing / max(1, len(self.required_ops))
+
+        # Penalty for forbidden ops
+        if self.forbidden_ops:
+            forbidden_count = len(self.forbidden_ops.intersection(graph_ops))
+            penalty += forbidden_count / max(1, len(self.forbidden_ops))
+
+        return min(1.0, penalty)
+
+
+class ConnectivityConstraint(Constraint):
+    """Constraint on graph connectivity."""
+
+    def __init__(
+        self,
+        min_edges: Optional[int] = None,
+        max_edges: Optional[int] = None,
+        name: str = "connectivity",
+    ):
+        """Initialize connectivity constraint."""
+        super().__init__(name)
+        self.min_edges = min_edges
+        self.max_edges = max_edges
+
+    def check(self, graph: ModelGraph) -> bool:
+        """Check if connectivity is within range."""
+        num_edges = len(graph.edges)
+
+        if self.min_edges is not None and num_edges < self.min_edges:
+            return False
+        if self.max_edges is not None and num_edges > self.max_edges:
+            return False
+
+        return True
+
+    def penalty(self, graph: ModelGraph) -> float:
+        """Penalty based on connectivity violation."""
+        num_edges = len(graph.edges)
+
+        if self.min_edges and num_edges < self.min_edges:
+            return (self.min_edges - num_edges) / self.min_edges
+        elif self.max_edges and num_edges > self.max_edges:
+            return (num_edges - self.max_edges) / self.max_edges
+        else:
+            return 0.0
+
+
+class CompositeConstraint(Constraint):
+    """Composite constraint combining multiple constraints."""
+
+    def __init__(self, constraints: List[Constraint], mode: str = "all", name: str = "composite"):
+        """
+        Initialize composite constraint.
+
+        Args:
+            constraints: List of constraints
+            mode: 'all' (AND) or 'any' (OR)
+            name: Constraint name
+        """
+        super().__init__(name)
+        self.constraints = constraints
+        self.mode = mode
+
+    def check(self, graph: ModelGraph) -> bool:
+        """Check if graph satisfies composite constraint."""
+        if self.mode == "all":
+            return all(c.check(graph) for c in self.constraints)
+        elif self.mode == "any":
+            return any(c.check(graph) for c in self.constraints)
+        else:
+            return False
+
+    def penalty(self, graph: ModelGraph) -> float:
+        """Calculate composite penalty."""
+        penalties = [c.penalty(graph) for c in self.constraints]
+
+        if self.mode == "all":
+            return sum(penalties) / len(penalties) if penalties else 0.0
+        elif self.mode == "any":
+            return min(penalties) if penalties else 0.0
+        else:
+            return 0.0

morphml/core/__init__.py

@@ -0,0 +1,3 @@
+"""Core modules for MorphML."""
+
+__all__ = []