morphml 1.0.0__py3-none-any.whl

morphml/core/dsl/layers.py

@@ -0,0 +1,368 @@
+"""Layer builders for the MorphML DSL.
+
+This module provides a Pythonic interface for defining neural network layers
+in search spaces using a builder pattern.
+
+Example:
+    >>> from morphml.core.dsl import Layer
+    >>>
+    >>> # Define a conv2d layer with multiple filter options
+    >>> conv = Layer.conv2d(filters=[32, 64, 128], kernel_size=[3, 5])
+    >>>
+    >>> # Define a dense layer
+    >>> dense = Layer.dense(units=[128, 256, 512])
+"""
+
+from typing import Any, Dict, List, Optional, Union
+
+from morphml.core.graph import GraphNode
+
+
+class LayerSpec:
+    """
+    Specification for a layer in the search space.
+
+    A LayerSpec defines a layer type and its parameter ranges.
+    During search, specific parameter values are sampled from these ranges.
+
+    Attributes:
+        operation: Layer operation type (conv2d, dense, etc.)
+        param_ranges: Dictionary of parameter names to possible values
+        metadata: Additional metadata
+
+    Example:
+        >>> spec = LayerSpec("conv2d", {
+        ...     "filters": [32, 64, 128],
+        ...     "kernel_size": [3, 5, 7]
+        ... })
+    """
+
+    def __init__(
+        self,
+        operation: str,
+        param_ranges: Optional[Dict[str, Any]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+    ):
+        """
+        Initialize layer specification.
+
+        Args:
+            operation: Layer operation type
+            param_ranges: Parameter ranges (param_name -> list of values or single value)
+            metadata: Additional metadata
+        """
+        self.operation = operation
+        self.param_ranges = param_ranges or {}
+        self.metadata = metadata or {}
+
+    def sample(self) -> GraphNode:
+        """
+        Sample a concrete layer from this specification.
+
+        Returns:
+            GraphNode with sampled parameters
+        """
+        import random
+
+        # Sample one value from each parameter range
+        params = {}
+        for param_name, values in self.param_ranges.items():
+            if isinstance(values, list) and values:
+                params[param_name] = random.choice(values)
+            else:
+                params[param_name] = values
+
+        return GraphNode.create(self.operation, params=params, metadata=self.metadata)
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize to dictionary."""
+        return {
+            "operation": self.operation,
+            "param_ranges": self.param_ranges,
+            "metadata": self.metadata,
+        }
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> "LayerSpec":
+        """Deserialize from dictionary."""
+        return cls(
+            operation=data["operation"],
+            param_ranges=data.get("param_ranges", {}),
+            metadata=data.get("metadata", {}),
+        )
+
+    def __repr__(self) -> str:
+        """String representation."""
+        return f"LayerSpec(operation={self.operation}, params={list(self.param_ranges.keys())})"
+
+
+class Layer:
+    """
+    Builder for defining layers in the search space.
+
+    Provides static methods for creating layer specifications with a
+    Pythonic API.
+
+    Example:
+        >>> # Convolutional layers
+        >>> Layer.conv2d(filters=[32, 64], kernel_size=3)
+        >>> Layer.conv2d(filters=64, kernel_size=[3, 5, 7])
+        >>>
+        >>> # Pooling layers
+        >>> Layer.maxpool(pool_size=2)
+        >>> Layer.avgpool(pool_size=[2, 3])
+        >>>
+        >>> # Dense layers
+        >>> Layer.dense(units=[128, 256, 512])
+        >>>
+        >>> # Activation layers
+        >>> Layer.relu()
+        >>> Layer.sigmoid()
+    """
+
+    @staticmethod
+    def conv2d(
+        filters: Union[int, List[int]],
+        kernel_size: Union[int, List[int]] = 3,
+        strides: Union[int, List[int]] = 1,
+        padding: str = "same",
+        activation: Optional[str] = None,
+        **kwargs: Any,
+    ) -> LayerSpec:
+        """
+        Define a 2D convolutional layer.
+
+        Args:
+            filters: Number of filters (can be list for search)
+            kernel_size: Kernel size (can be list for search)
+            strides: Stride size
+            padding: Padding mode ('same' or 'valid')
+            activation: Optional activation function
+            **kwargs: Additional parameters
+
+        Returns:
+            LayerSpec for conv2d layer
+
+        Example:
+            >>> Layer.conv2d(filters=[32, 64, 128], kernel_size=[3, 5])
+        """
+        param_ranges = {
+            "filters": filters if isinstance(filters, list) else [filters],
+            "kernel_size": kernel_size if isinstance(kernel_size, list) else [kernel_size],
+            "strides": strides if isinstance(strides, list) else [strides],
+            "padding": [padding],
+        }
+
+        if activation:
+            param_ranges["activation"] = [activation]
+
+        param_ranges.update(kwargs)
+
+        return LayerSpec("conv2d", param_ranges)
+
+    @staticmethod
+    def dense(
+        units: Union[int, List[int]],
+        activation: Optional[str] = None,
+        use_bias: bool = True,
+        **kwargs: Any,
+    ) -> LayerSpec:
+        """
+        Define a fully-connected (dense) layer.
+
+        Args:
+            units: Number of units (can be list for search)
+            activation: Optional activation function
+            use_bias: Whether to use bias
+            **kwargs: Additional parameters
+
+        Returns:
+            LayerSpec for dense layer
+
+        Example:
+            >>> Layer.dense(units=[128, 256, 512])
+        """
+        param_ranges = {
+            "units": units if isinstance(units, list) else [units],
+            "use_bias": [use_bias],
+        }
+
+        if activation:
+            param_ranges["activation"] = [activation]
+
+        param_ranges.update(kwargs)
+
+        return LayerSpec("dense", param_ranges)
+
+    @staticmethod
+    def maxpool(
+        pool_size: Union[int, List[int]] = 2,
+        strides: Optional[Union[int, List[int]]] = None,
+        padding: str = "valid",
+        **kwargs: Any,
+    ) -> LayerSpec:
+        """
+        Define a max pooling layer.
+
+        Args:
+            pool_size: Pool size (can be list for search)
+            strides: Stride size (defaults to pool_size)
+            padding: Padding mode
+            **kwargs: Additional parameters
+
+        Returns:
+            LayerSpec for maxpool layer
+        """
+        param_ranges = {
+            "pool_size": pool_size if isinstance(pool_size, list) else [pool_size],
+            "padding": [padding],
+        }
+
+        if strides is not None:
+            param_ranges["strides"] = strides if isinstance(strides, list) else [strides]
+
+        param_ranges.update(kwargs)
+
+        return LayerSpec("maxpool", param_ranges)
+
+    @staticmethod
+    def avgpool(
+        pool_size: Union[int, List[int]] = 2,
+        strides: Optional[Union[int, List[int]]] = None,
+        padding: str = "valid",
+        **kwargs: Any,
+    ) -> LayerSpec:
+        """Define an average pooling layer."""
+        param_ranges = {
+            "pool_size": pool_size if isinstance(pool_size, list) else [pool_size],
+            "padding": [padding],
+        }
+
+        if strides is not None:
+            param_ranges["strides"] = strides if isinstance(strides, list) else [strides]
+
+        param_ranges.update(kwargs)
+
+        return LayerSpec("avgpool", param_ranges)
+
+    @staticmethod
+    def dropout(rate: Union[float, List[float]] = 0.5, **kwargs: Any) -> LayerSpec:
+        """
+        Define a dropout layer.
+
+        Args:
+            rate: Dropout rate (can be list for search)
+            **kwargs: Additional parameters
+
+        Returns:
+            LayerSpec for dropout layer
+        """
+        param_ranges = {
+            "rate": rate if isinstance(rate, list) else [rate],
+        }
+        param_ranges.update(kwargs)
+
+        return LayerSpec("dropout", param_ranges)
+
+    @staticmethod
+    def batchnorm(**kwargs: Any) -> LayerSpec:
+        """Define a batch normalization layer."""
+        return LayerSpec("batchnorm", param_ranges=kwargs)
+
+    @staticmethod
+    def flatten(**kwargs: Any) -> LayerSpec:
+        """
+        Define a flatten layer.
+
+        Flattens the input tensor to 1D (excluding batch dimension).
+        Commonly used between convolutional and dense layers.
+
+        Args:
+            **kwargs: Additional parameters
+
+        Returns:
+            LayerSpec for flatten layer
+        """
+        return LayerSpec("flatten", param_ranges=kwargs)
+
+    @staticmethod
+    def relu(**kwargs: Any) -> LayerSpec:
+        """Define a ReLU activation layer."""
+        return LayerSpec("relu", param_ranges=kwargs)
+
+    @staticmethod
+    def sigmoid(**kwargs: Any) -> LayerSpec:
+        """Define a sigmoid activation layer."""
+        return LayerSpec("sigmoid", param_ranges=kwargs)
+
+    @staticmethod
+    def tanh(**kwargs: Any) -> LayerSpec:
+        """Define a tanh activation layer."""
+        return LayerSpec("tanh", param_ranges=kwargs)
+
+    @staticmethod
+    def softmax(**kwargs: Any) -> LayerSpec:
+        """Define a softmax activation layer."""
+        return LayerSpec("softmax", param_ranges=kwargs)
+
+    @staticmethod
+    def input(shape: tuple, **kwargs: Any) -> LayerSpec:
+        """
+        Define an input layer.
+
+        Args:
+            shape: Input shape (excluding batch dimension)
+            **kwargs: Additional parameters
+
+        Returns:
+            LayerSpec for input layer
+        """
+        param_ranges = {"shape": [shape]}
+        param_ranges.update(kwargs)
+
+        return LayerSpec("input", param_ranges)
+
+    @staticmethod
+    def output(units: int, activation: str = "softmax", **kwargs: Any) -> LayerSpec:
+        """
+        Define an output layer.
+
+        Args:
+            units: Number of output units (classes)
+            activation: Activation function
+            **kwargs: Additional parameters
+
+        Returns:
+            LayerSpec for output layer
+        """
+        param_ranges = {
+            "units": [units],
+            "activation": [activation],
+        }
+        param_ranges.update(kwargs)
+
+        return LayerSpec("dense", param_ranges, metadata={"is_output": True})
+
+    @staticmethod
+    def custom(
+        operation: str,
+        param_ranges: Optional[Dict[str, List[Any]]] = None,
+        **kwargs: Any,
+    ) -> LayerSpec:
+        """
+        Define a custom layer.
+
+        Args:
+            operation: Operation type
+            param_ranges: Parameter ranges
+            **kwargs: Additional parameter ranges
+
+        Returns:
+            LayerSpec for custom layer
+
+        Example:
+            >>> Layer.custom("my_op", {"param1": [1, 2, 3]})
+        """
+        ranges = param_ranges or {}
+        ranges.update(kwargs)
+        return LayerSpec(operation, ranges)

morphml/core/dsl/lexer.py

@@ -0,0 +1,336 @@
+"""Lexical analyzer for MorphML DSL.
+
+Converts source code into a stream of tokens for parsing.
+
+Author: Eshan Roy <eshanized@proton.me>
+Organization: TONMOY INFRASTRUCTURE & VISION
+"""
+
+from dataclasses import dataclass
+from typing import Any, List, Optional
+
+from morphml.core.dsl.syntax import KEYWORDS, OPERATORS, TokenType
+from morphml.exceptions import DSLError
+from morphml.logging_config import get_logger
+
+logger = get_logger(__name__)
+
+
+@dataclass
+class Token:
+    """Represents a single token in the source code."""
+
+    type: TokenType
+    value: Any
+    line: int
+    column: int
+
+    def __repr__(self) -> str:
+        """String representation for debugging."""
+        return f"Token({self.type.name}, {self.value!r}, {self.line}:{self.column})"
+
+
+class Lexer:
+    """
+    Tokenizes MorphML DSL source code.
+
+    Converts a string of source code into a stream of tokens that can be
+    parsed into an abstract syntax tree.
+
+    Example:
+        >>> source = 'Layer.conv2d(filters=[32, 64])'
+        >>> lexer = Lexer(source)
+        >>> tokens = lexer.tokenize()
+        >>> for token in tokens:
+        ...     print(token)
+    """
+
+    def __init__(self, source: str):
+        """
+        Initialize lexer with source code.
+
+        Args:
+            source: Source code string to tokenize
+        """
+        self.source = source
+        self.position = 0
+        self.line = 1
+        self.column = 1
+        self.tokens: List[Token] = []
+
+    def tokenize(self) -> List[Token]:
+        """
+        Main tokenization method.
+
+        Returns:
+            List of tokens representing the source code
+
+        Raises:
+            DSLError: If invalid characters or syntax is encountered
+        """
+        while self.position < len(self.source):
+            # Skip whitespace
+            if self._skip_whitespace():
+                continue
+
+            # Skip comments
+            if self._skip_comment():
+                continue
+
+            # Match tokens
+            if self._match_number():
+                continue
+            elif self._match_string():
+                continue
+            elif self._match_keyword_or_identifier():
+                continue
+            elif self._match_operator():
+                continue
+            else:
+                char = self._current_char()
+                self._error(f"Unexpected character: '{char}' (ASCII {ord(char)})")
+
+        # Add EOF token
+        self.tokens.append(Token(TokenType.EOF, None, self.line, self.column))
+        logger.debug(f"Tokenized {len(self.tokens)} tokens from {self.line} lines")
+        return self.tokens
+
+    def _current_char(self) -> Optional[str]:
+        """Get current character without advancing."""
+        if self.position >= len(self.source):
+            return None
+        return self.source[self.position]
+
+    def _peek_char(self, offset: int = 1) -> Optional[str]:
+        """Look ahead at character at offset from current position."""
+        pos = self.position + offset
+        if pos >= len(self.source):
+            return None
+        return self.source[pos]
+
+    def _advance(self) -> Optional[str]:
+        """Move to next character and return current one."""
+        if self.position >= len(self.source):
+            return None
+
+        char = self.source[self.position]
+        self.position += 1
+
+        # Track line and column for error messages
+        if char == "\n":
+            self.line += 1
+            self.column = 1
+        else:
+            self.column += 1
+
+        return char
+
+    def _skip_whitespace(self) -> bool:
+        """Skip whitespace characters (space, tab, newline)."""
+        char = self._current_char()
+        if char and char in " \t\n\r":
+            self._advance()
+            return True
+        return False
+
+    def _skip_comment(self) -> bool:
+        """Skip comments starting with #."""
+        if self._current_char() == "#":
+            # Skip until end of line
+            while self._current_char() and self._current_char() != "\n":
+                self._advance()
+            return True
+        return False
+
+    def _match_number(self) -> bool:
+        """
+        Match integer, float, or scientific notation.
+
+        Formats supported:
+        - Integer: 42, -123
+        - Float: 3.14, -0.5
+        - Scientific: 1.5e-3, 2E+10
+        """
+        start_pos = self.position
+        start_col = self.column
+
+        # Handle negative sign
+        if self._current_char() == "-":
+            # Check if next char is digit
+            if not (self._peek_char() and self._peek_char().isdigit()):
+                return False
+            self._advance()
+
+        # Must start with digit
+        if not (self._current_char() and self._current_char().isdigit()):
+            return False
+
+        # Match integer part
+        while self._current_char() and self._current_char().isdigit():
+            self._advance()
+
+        # Match decimal point and fractional part
+        if self._current_char() == ".":
+            # Peek ahead to ensure it's a decimal, not a method call
+            if self._peek_char() and self._peek_char().isdigit():
+                self._advance()  # consume '.'
+                while self._current_char() and self._current_char().isdigit():
+                    self._advance()
+
+        # Match scientific notation
+        if self._current_char() and self._current_char() in ("e", "E"):
+            self._advance()
+            # Optional sign
+            if self._current_char() and self._current_char() in ("+", "-"):
+                self._advance()
+            # Exponent digits
+            if not (self._current_char() and self._current_char().isdigit()):
+                self._error("Invalid scientific notation: expected digits after exponent")
+            while self._current_char() and self._current_char().isdigit():
+                self._advance()
+
+        # Extract value and convert
+        value_str = self.source[start_pos : self.position]
+        try:
+            if "." in value_str or "e" in value_str or "E" in value_str:
+                value = float(value_str)
+            else:
+                value = int(value_str)
+        except ValueError:
+            self._error(f"Invalid number format: {value_str}")
+
+        self.tokens.append(Token(TokenType.NUMBER, value, self.line, start_col))
+        return True
+
+    def _match_string(self) -> bool:
+        """
+        Match quoted strings with escape sequences.
+
+        Supports both single and double quotes.
+        Handles escape sequences: \\n, \\t, \\', \\", \\\\
+        """
+        start_col = self.column
+        quote_char = self._current_char()
+
+        if quote_char not in ('"', "'"):
+            return False
+
+        self._advance()  # consume opening quote
+        chars = []
+
+        while self._current_char() and self._current_char() != quote_char:
+            if self._current_char() == "\\":
+                # Handle escape sequences
+                self._advance()
+                escape_char = self._current_char()
+                if escape_char == "n":
+                    chars.append("\n")
+                elif escape_char == "t":
+                    chars.append("\t")
+                elif escape_char == "r":
+                    chars.append("\r")
+                elif escape_char == "\\":
+                    chars.append("\\")
+                elif escape_char == quote_char:
+                    chars.append(quote_char)
+                else:
+                    chars.append(escape_char)
+                self._advance()
+            else:
+                chars.append(self._current_char())
+                self._advance()
+
+        if self._current_char() != quote_char:
+            self._error(f"Unterminated string starting at line {self.line}, column {start_col}")
+
+        self._advance()  # consume closing quote
+
+        value = "".join(chars)
+        self.tokens.append(Token(TokenType.STRING, value, self.line, start_col))
+        return True
+
+    def _match_keyword_or_identifier(self) -> bool:
+        """
+        Match keywords or identifiers.
+
+        Identifiers: [a-zA-Z_][a-zA-Z0-9_]*
+        Keywords: SearchSpace, Layer, Evolution, etc.
+        """
+        start_col = self.column
+        char = self._current_char()
+
+        # Must start with letter or underscore
+        if not (char and (char.isalpha() or char == "_")):
+            return False
+
+        # Collect identifier characters
+        chars = []
+        while self._current_char() and (
+            self._current_char().isalnum() or self._current_char() == "_"
+        ):
+            chars.append(self._current_char())
+            self._advance()
+
+        identifier = "".join(chars)
+
+        # Check if it's a keyword
+        if identifier in KEYWORDS:
+            token_type = KEYWORDS[identifier]
+            # For boolean keywords, store the boolean value
+            if token_type == TokenType.BOOLEAN:
+                value = identifier in ("True", "true")
+            else:
+                value = identifier
+            self.tokens.append(Token(token_type, value, self.line, start_col))
+        else:
+            # Regular identifier
+            self.tokens.append(Token(TokenType.IDENTIFIER, identifier, self.line, start_col))
+
+        return True
+
+    def _match_operator(self) -> bool:
+        """Match operators and delimiters."""
+        start_col = self.column
+        char = self._current_char()
+
+        if char in OPERATORS:
+            token_type = OPERATORS[char]
+            self._advance()
+            self.tokens.append(Token(token_type, char, self.line, start_col))
+            return True
+
+        return False
+
+    def _error(self, message: str) -> None:
+        """
+        Raise DSLError with line and column information.
+
+        Args:
+            message: Error message
+
+        Raises:
+            DSLError: With formatted error message
+        """
+        raise DSLError(
+            f"{message}\n"
+            f"  at line {self.line}, column {self.column}\n"
+            f"  {self._get_error_context()}",
+            line=self.line,
+            column=self.column,
+        )
+
+    def _get_error_context(self) -> str:
+        """Get source code context around error for display."""
+        # Find start and end of current line
+        line_start = self.position
+        while line_start > 0 and self.source[line_start - 1] != "\n":
+            line_start -= 1
+
+        line_end = self.position
+        while line_end < len(self.source) and self.source[line_end] != "\n":
+            line_end += 1
+
+        line_content = self.source[line_start:line_end]
+        pointer = " " * (self.column - 1) + "^"
+
+        return f"{line_content}\n  {pointer}"