tinymlc 0.1.0__py3-none-any.whl

TinyMLC/ANG/args.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+# TinyMLC - Tiny Machine Learning Compiler
+#
+# Copyright (c) 2026 Jia Liu & TinyMLC Contributors
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file is part of TinyMLC.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#!/usr/bin/env python3
+"""Command-line argument utilities for ANG and TinyMLC CLI"""
+
+import argparse
+from typing import List
+
+from TinyMLC.ANG.estimator import Estimator
+from TinyMLC.ANG.estimator_software import SoftwareEstimator
+from TinyMLC.ANG.estimator_qemu import QemuEstimator
+from TinyMLC.ANG.estimator_hal import HardwareHALEstimator
+from utils.dump import fatal_error
+
+def parse_shape(shape_str: str) -> List[int]:
+    """Parse shape string like '1,28,28,1' to list of integers"""
+    return [int(x.strip()) for x in shape_str.split(",")]
+
+
+def create_estimator(args: argparse.Namespace) -> Estimator:
+    """
+    Create an estimator based on command-line arguments.
+    """
+    estimator_type = getattr(args, "estimator", "software")
+
+    # Read from args
+    max_macs = getattr(args, "max_macs", 100000)
+    max_ram_kb = getattr(args, "max_ram", 30)
+    max_flash_kb = getattr(args, "max_flash", 64)
+
+    if estimator_type == "software":
+        return SoftwareEstimator(
+            {
+                "max_macs": max_macs,
+                "max_params": 50000,  # TODO: Independently configurable.
+                "max_ram": max_ram_kb * 1024,
+                "clock_speed": getattr(args, "clock_speed", 100000000),
+            }
+        )
+
+    elif estimator_type == "qemu":
+        return QemuEstimator(
+            {
+                "max_macs": max_macs,
+                "max_params": 50000,
+                "max_ram": max_ram_kb * 1024,
+                "qemu_binary": "qemu-system-" + getattr(args, "target", "arm"),
+                "cpu": getattr(args, "qemu_cpu", "cortex-m4"),
+                "icount_shift": getattr(args, "icount_shift", 0),
+                "clock_speed": getattr(args, "clock_speed", 100000000),
+            }
+        )
+
+    elif estimator_type == "hardware":
+        return HardwareHALEstimator(
+            {
+                "max_macs": max_macs,
+                "max_params": 50000,
+                "max_ram": max_ram_kb * 1024,
+                "script_path": getattr(args, "estimator_script", None),
+                "function_name": getattr(
+                    args, "estimator_function", "estimate"
+                ),
+                "clock_speed": getattr(args, "clock_speed", 100000000),
+            }
+        )
+
+    else:
+        fatal_error(f"Unknown estimator type: {estimator_type}")

TinyMLC/ANG/estimator.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# TinyMLC - Tiny Machine Learning Compiler
+#
+# Copyright (c) 2026 Jia Liu & TinyMLC Contributors
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file is part of TinyMLC.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Abstract base class for all estimators.
+
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+
+from TinyMLC.ANG.utils import hash_structure
+
+class Estimator(ABC):
+    """
+    Abstract base class for network performance estimation.
+
+    All estimators (Software, QEMU, Hardware HAL) inherit from this class
+    and implement the estimate() method.
+
+    The estimate() method takes a model_info structure and returns
+    a Score dictionary with performance metrics.
+    """
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the estimator with optional configuration.
+
+        Args:
+            config: Configuration dictionary for the estimator.
+        """
+        self.config = config or {}
+        self._cache: Dict[str, Dict[str, Any]] = {}
+
+    @abstractmethod
+    def estimate(self, model_info: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Estimate the performance of a given model.
+
+        The returned dictionary must contain at least:
+            - 'score': float, higher is better
+            - 'macs': int
+            - 'params': int
+            - 'peak_ram': int (bytes)
+            - 'flash': int (bytes)
+            - 'latency_ms': float
+
+        Additional fields can be added as needed.
+
+        Args:
+            model_info: ModelInfo dictionary.
+
+        Returns:
+            Dictionary with performance metrics.
+        """
+        pass
+
+    @abstractmethod
+    def get_info(self) -> Dict[str, str]:
+        """
+        Get information about this estimator.
+
+        Returns:
+            Dictionary with estimator name, version, and description.
+        """
+        pass
+
+    def estimate_cached(self, model_info: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Estimate with caching to avoid redundant evaluations.
+
+        Args:
+            model_info: ModelInfo dictionary.
+
+        Returns:
+            Dictionary with performance metrics.
+        """
+        # Compute a hash of the model structure
+        key = hash_structure(model_info)
+
+        if key in self._cache:
+            return self._cache[key]
+
+        result = self.estimate(model_info)
+        self._cache[key] = result
+        return result
+
+    def clear_cache(self) -> None:
+        """Clear the evaluation cache."""
+        self._cache.clear()

TinyMLC/ANG/estimator_hal.py

@@ -0,0 +1,184 @@
+# -*- coding: utf-8 -*-
+# TinyMLC - Tiny Machine Learning Compiler
+#
+# Copyright (c) 2026 Jia Liu & TinyMLC Contributors
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file is part of TinyMLC.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# Hardware HAL estimator - user-provided script for real hardware.
+
+import importlib.util
+import sys
+from pathlib import Path
+from typing import Dict, Any, Optional
+
+from TinyMLC.ANG.estimator import Estimator
+from TinyMLC.ANG.utils import (calculate_macs, calculate_params,
+                               calculate_peak_ram)
+
+
+class HardwareHALEstimator(Estimator):
+    """
+    Hardware HAL estimator (closed-loop).
+
+    This estimator calls a user-provided Python script that interfaces
+    with real hardware. The script must implement the estimate() function.
+
+    This is a "closed-loop" estimator because it provides feedback
+    from actual hardware execution.
+
+    Vendors can implement their own hardware testing scripts following
+    the same interface.
+    """
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the hardware HAL estimator.
+
+        Args:
+            config: Must contain 'script_path' pointing to the user script.
+        """
+        super().__init__(config)
+
+        self.default_config = {
+            "script_path": None,  # Path to user script
+            "function_name": "estimate",  # Function name in user script
+            "timeout": 60,  # Timeout in seconds
+            "max_macs": 100000,
+            "max_params": 50000,
+            "max_ram": 32768,
+        }
+        self.config = {**self.default_config, **(config or {})}
+        self._estimator_func = None
+
+        if self.config.get("script_path"):
+            self._load_estimator()
+
+    def _load_estimator(self) -> None:
+        """
+        Load the user-provided estimator function.
+        """
+        script_path = self.config.get("script_path")
+        if not script_path:
+            raise ValueError(
+                "HardwareHALEstimator requires 'script_path' in config"
+            )
+
+        path = Path(script_path)
+        if not path.exists():
+            raise FileNotFoundError(
+                f"Estimator script not found: {script_path}"
+            )
+
+        # Dynamic import of the user script
+        spec = importlib.util.spec_from_file_location("user_estimator", path)
+        if spec is None:
+            raise ImportError(f"Cannot load script: {script_path}")
+
+        module = importlib.util.module_from_spec(spec)
+        sys.modules["user_estimator"] = module
+        if spec.loader is None:
+            raise ImportError(f"Cannot find loader for: {script_path}")
+        spec.loader.exec_module(module)
+
+        func_name = self.config.get("function_name", "estimate")
+        if not hasattr(module, func_name):
+            raise AttributeError(
+                f"Function '{func_name}' not found in {script_path}"
+            )
+
+        self._estimator_func = getattr(module, func_name)
+
+    def estimate(self, model_info: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Estimate performance using the user-provided hardware script.
+
+        Args:
+            model_info: ModelInfo dictionary.
+
+        Returns:
+            Dictionary with performance metrics.
+        """
+        # Get software metrics as fallback
+        macs = calculate_macs(model_info)
+        params = calculate_params(model_info)
+        peak_ram = calculate_peak_ram(model_info)
+
+        if self._estimator_func is None:
+            self._load_estimator()
+
+        try:
+            # Call the user's estimate function
+            result = self._estimator_func(model_info)
+
+            # Validate the result has all required fields
+            required_keys = ["score", "macs", "params", "peak_ram", "flash"]
+            for key in required_keys:
+                if key not in result:
+                    raise ValueError(
+                        f"Estimator result missing required key: {key}"
+                    )
+
+            # If latency_ms is not provided, estimate it
+            if "latency_ms" not in result:
+                clock = self.config.get("clock_speed", 100000000)
+                result["latency_ms"] = (macs / clock) * 1000.0
+
+            return result
+
+        except Exception as e:
+            # Fallback to software estimation on error
+            max_macs = self.config["max_macs"]
+            max_params = self.config["max_params"]
+            max_ram = self.config["max_ram"]
+
+            macs_score = (
+                1.0 - min(macs / max_macs, 1.0) if max_macs > 0 else 0.0
+            )
+            params_score = (
+                1.0 - min(params / max_params, 1.0) if max_params > 0 else 0.0
+            )
+            ram_score = (
+                1.0 - min(peak_ram / max_ram, 1.0) if max_ram > 0 else 0.0
+            )
+
+            score = (
+                0.4 * macs_score + 0.3 * params_score + 0.3 * ram_score
+            ) * 100.0
+
+            return {
+                "score": score,
+                "macs": macs,
+                "params": params,
+                "peak_ram": peak_ram,
+                "flash": params + 1024,
+                "latency_ms": (macs / 100000000) * 1000.0,
+                "details": {
+                    "estimator": "hardware_hal",
+                    "fallback": True,
+                    "error": str(e),
+                },
+            }
+
+    def get_info(self) -> Dict[str, str]:
+        """Get estimator information."""
+        return {
+            "name": "HardwareHALEstimator",
+            "version": "1.0",
+            "type": "closed_loop",
+            "description": "Hardware HAL estimator with user script",
+            "script_path": str(self.config.get("script_path", "")),
+            "function_name": self.config.get("function_name", "estimate"),
+        }

TinyMLC/ANG/estimator_qemu.py

@@ -0,0 +1,257 @@
+# -*- coding: utf-8 -*-
+# TinyMLC - Tiny Machine Learning Compiler
+#
+# Copyright (c) 2026 Jia Liu & TinyMLC Contributors
+# SPDX-License-Identifier: Apache-2.0
+#
+# This file is part of TinyMLC.
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at:
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# QEMU-based estimator using icount mode for deterministic instruction counts.
+
+import subprocess
+import tempfile
+import re
+from typing import Dict, Any, Optional
+
+from TinyMLC.ANG.estimator import Estimator
+from TinyMLC.ANG.utils import (calculate_macs, calculate_params,
+                               calculate_peak_ram)
+
+
+class QemuEstimator(Estimator):
+    """
+    QEMU-based estimator (closed-loop).
+
+    This estimator compiles the model to an ELF file and runs it under
+    QEMU with icount mode enabled. The instruction count is used as
+    a stable, deterministic performance metric.
+
+    This is a "closed-loop" estimator because it provides feedback
+    from actual execution (even if simulated).
+    """
+
+    def __init__(self, config: Optional[Dict[str, Any]] = None):
+        """
+        Initialize the QEMU estimator.
+
+        Args:
+            config: Configuration with QEMU and compilation settings.
+        """
+        super().__init__(config)
+
+        self.default_config = {
+            "qemu_binary": "qemu-system-arm",  # QEMU binary to use
+            "cpu": "cortex-m4",  # CPU model
+            "icount_shift": 0,  # icount shift (0 = 1 instr/tick)
+            "clock_speed": 100000000,  # Clock speed in Hz
+            "timeout": 30,  # Timeout in seconds
+            "max_macs": 100000,  # For score calculation
+            "max_params": 50000,
+            "max_ram": 32768,
+            "gcc_binary": "arm-none-eabi-gcc",  # Cross-compiler
+            "linker_script": "mcu.ld",  # Linker script path
+        }
+        self.config = {**self.default_config, **(config or {})}
+        self._compile_cache = {}
+
+    def estimate(self, model_info: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Estimate performance by running the model under QEMU.
+
+        Args:
+            model_info: ModelInfo dictionary.
+
+        Returns:
+            Dictionary with performance metrics.
+        """
+        # Get software metrics first
+        macs = calculate_macs(model_info)
+        params = calculate_params(model_info)
+        peak_ram = calculate_peak_ram(model_info)
+
+        # Compile and run under QEMU
+        try:
+            elf_path = self._compile_model(model_info)
+            instr_count = self._run_qemu_icount(elf_path)
+        except Exception as e:
+            # On failure, fall back to software estimates
+            instr_count = macs  # Approximate instruction count
+
+        # Estimate latency from instruction count
+        latency_ms = (instr_count / self.config["clock_speed"]) * 1000.0
+
+        # Flash usage from ELF size
+        flash = (
+            self._get_elf_flash_size(elf_path)
+            if elf_path
+            else params + 1024
+        )
+
+        # Calculate score (same as software estimator)
+        max_macs = self.config["max_macs"]
+        max_params = self.config["max_params"]
+        max_ram = self.config["max_ram"]
+
+        macs_score = 1.0 - min(macs / max_macs, 1.0) if max_macs > 0 else 0.0
+        params_score = (
+            1.0 - min(params / max_params, 1.0) if max_params > 0 else 0.0
+        )
+        ram_score = 1.0 - min(peak_ram / max_ram, 1.0) if max_ram > 0 else 0.0
+
+        score = (
+            0.4 * macs_score + 0.3 * params_score + 0.3 * ram_score
+        ) * 100.0
+
+        return {
+            "score": score,
+            "macs": macs,
+            "params": params,
+            "peak_ram": peak_ram,
+            "flash": flash,
+            "latency_ms": latency_ms,
+            "instr_count": instr_count,  # QEMU-specific
+            "details": {
+                "estimator": "qemu",
+                "qemu_cpu": self.config["cpu"],
+                "icount_shift": self.config["icount_shift"],
+                "elf_path": elf_path,
+            },
+        }
+
+    def get_info(self) -> Dict[str, str]:
+        """Get estimator information."""
+        return {
+            "name": "QemuEstimator",
+            "version": "1.0",
+            "type": "closed_loop",
+            "description": "QEMU icount-based estimator",
+            "qemu_binary": self.config["qemu_binary"],
+            "cpu": self.config["cpu"],
+        }
+
+    def _compile_model(self, model_info: Dict[str, Any]) -> str:
+        """
+        Compile the model to an ELF file.
+
+        Args:
+            model_info: ModelInfo dictionary.
+
+        Returns:
+            Path to the compiled ELF file.
+        """
+        # This would call the TinyMLC code generator
+        # For now, we return a placeholder
+        # In production, this would:
+        #   1. Call generate_c_code(model_info)
+        #   2. Compile with the cross-compiler
+        #   3. Return the ELF path
+
+        # Placeholder implementation
+        with tempfile.NamedTemporaryFile(suffix=".elf", delete=False) as f:
+            elf_path = f.name
+
+        # TODO: Actually compile the model
+        # This requires integration with TinyMLC code generation
+
+        return elf_path
+
+    def _run_qemu_icount(self, elf_path: str) -> int:
+        """
+        Run the ELF under QEMU with icount mode.
+
+        Args:
+            elf_path: Path to the ELF file.
+
+        Returns:
+            Instruction count.
+        """
+        cmd = [
+            self.config["qemu_binary"],
+            "-cpu",
+            self.config["cpu"],
+            "-nographic",
+            "-icount",
+            f"shift={self.config['icount_shift']}",
+            "-semihosting",
+            "-semihosting-config",
+            "enable=on,target=native",
+            "-kernel",
+            elf_path,
+        ]
+
+        try:
+            result = subprocess.run(
+                cmd,
+                capture_output=True,
+                text=True,
+                timeout=self.config["timeout"],
+            )
+            # Parse instruction count from output
+            return self._parse_icount(result.stdout + result.stderr)
+        except subprocess.TimeoutExpired:
+            return 0
+
+    def _parse_icount(self, output: str) -> int:
+        """
+        Parse instruction count from QEMU output.
+
+        Args:
+            output: QEMU stdout/stderr.
+
+        Returns:
+            Instruction count.
+        """
+        # Try different patterns
+        patterns = [
+            r"INSTR_COUNT:\s*(\d+)",
+            r"icount:\s*(\d+)",
+            r"instructions\s*:\s*(\d+)",
+        ]
+        for pattern in patterns:
+            match = re.search(pattern, output, re.IGNORECASE)
+            if match:
+                return int(match.group(1))
+
+        return 0
+
+    def _get_elf_flash_size(self, elf_path: str) -> int:
+        """
+        Get flash size from ELF using size command.
+
+        Args:
+            elf_path: Path to the ELF file.
+
+        Returns:
+            Flash size in bytes.
+        """
+        try:
+            # Use GNU size to get text + data
+            size_cmd = self.config.get("size_binary", "arm-none-eabi-size")
+            result = subprocess.run(
+                [size_cmd, elf_path],
+                capture_output=True,
+                text=True,
+            )
+            if result.returncode == 0:
+                lines = result.stdout.strip().split("\n")
+                if len(lines) >= 2:
+                    parts = lines[1].split()
+                    if len(parts) >= 3:
+                        # text, data, bss
+                        text = int(parts[0])
+                        data = int(parts[1])
+                        return text + data
+        except Exception:
+            pass
+        return 0