coreml-complexity-analyzer 0.1.0__tar.gz

coreml_complexity_analyzer-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Devavarapu Yashwanth, Ireddi Rakshitha
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

coreml_complexity_analyzer-0.1.0/PKG-INFO

@@ -0,0 +1,200 @@
+Metadata-Version: 2.4
+Name: coreml-complexity-analyzer
+Version: 0.1.0
+Summary: FLOPS estimation, memory analysis, and per-layer profiling for Core ML models
+Author: Devavarapu Yashwanth, Ireddi Rakshitha
+License: BSD-3-Clause
+Project-URL: Homepage, https://github.com/yaswanth169/coreml-complexity-analyzer
+Project-URL: Repository, https://github.com/yaswanth169/coreml-complexity-analyzer
+Project-URL: Issues, https://github.com/yaswanth169/coreml-complexity-analyzer/issues
+Project-URL: Documentation, https://github.com/yaswanth169/coreml-complexity-analyzer#readme
+Keywords: coreml,flops,model-analysis,complexity,apple,mlmodel,machine-learning,model-profiling,neural-network
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: coremltools>=7.0
+Requires-Dist: numpy
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Dynamic: license-file
+
+# coreml-complexity-analyzer
+
+FLOPS estimation, memory analysis, and per-layer profiling for Core ML models.
+
+[![PyPI version](https://badge.fury.io/py/coreml-complexity-analyzer.svg)](https://pypi.org/project/coreml-complexity-analyzer/)
+[![License: BSD-3-Clause](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+
+## Why This Exists
+
+Before deploying Core ML models to Apple devices, developers need to understand:
+
+- **Compute cost**: How many FLOPS/MACs does the model require?
+- **Memory footprint**: How much memory for parameters and activations?
+- **Bottleneck layers**: Which layers dominate compute and memory?
+
+`coremltools` does not provide these analysis capabilities out of the box. This package fills that gap.
+
+## Installation
+
+```bash
+pip install coreml-complexity-analyzer
+```
+
+Requirements: `coremltools >= 7.0`, `numpy`
+
+## Quick Start
+
+```python
+import coremltools as ct
+from coreml_complexity_analyzer import generate_report
+
+model = ct.models.MLModel("my_model.mlpackage")
+report = generate_report(model, "ResNet50")
+
+print(f"Total GFLOPS: {report.total_gflops:.2f}")
+print(f"Parameters: {report.parameters_millions:.2f}M")
+print(f"Memory: {report.memory_breakdown.total_mb:.2f} MB")
+
+# Full markdown report
+print(report.to_markdown())
+```
+
+## API
+
+### FLOPSAnalyzer
+
+Compute floating-point operations for each layer in a model.
+
+```python
+from coreml_complexity_analyzer import FLOPSAnalyzer
+
+analyzer = FLOPSAnalyzer(model)
+total = analyzer.get_total_flops()
+breakdown = analyzer.get_layer_breakdown()
+by_type = analyzer.get_flops_by_op_type()
+```
+
+### MemoryEstimator
+
+Estimate memory requirements (parameters + activations + overhead).
+
+```python
+from coreml_complexity_analyzer import MemoryEstimator
+
+estimator = MemoryEstimator(model)
+breakdown = estimator.estimate()
+param_count = estimator.get_parameter_count()
+
+print(f"Total: {breakdown.total_mb:.2f} MB")
+print(f"Parameters: {breakdown.parameter_mb:.2f} MB")
+```
+
+### LayerProfiler
+
+Detailed per-layer analysis combining FLOPS, memory, and shape information.
+
+```python
+from coreml_complexity_analyzer import LayerProfiler
+
+profiler = LayerProfiler(model)
+profiles = profiler.profile()
+
+top_layers = profiler.get_top_layers(n=5, by="flops")
+for layer in top_layers:
+    print(f"{layer.name}: {layer.mflops:.2f} MFLOPS")
+```
+
+### generate_report
+
+Generate comprehensive reports combining all analyses.
+
+```python
+from coreml_complexity_analyzer import generate_report
+
+report = generate_report(model, "ModelName")
+
+# Output formats
+print(report.to_markdown())   # Markdown table
+print(report.to_text())       # Plain text
+data = report.to_dict()       # Dictionary
+```
+
+## Supported Operations
+
+| Category | Operations |
+|----------|-----------|
+| Convolutions | `conv`, `conv_transpose` |
+| Linear | `linear`, `matmul`, `einsum` |
+| Activations | `relu`, `sigmoid`, `tanh`, `gelu`, `silu`, `softplus` |
+| Normalization | `batch_norm`, `layer_norm`, `instance_norm` |
+| Pooling | `max_pool`, `avg_pool` |
+| Element-wise | `add`, `sub`, `mul`, `div` |
+| Reductions | `reduce_sum`, `reduce_mean`, `reduce_max`, `reduce_min` |
+| Other | `softmax` |
+
+## Example Output
+
+```
+============================================================
+Model Complexity Report: ResNet50
+============================================================
+SUMMARY
+----------------------------------------
+  Total FLOPS:            4,089,184,256
+  Total GFLOPS:                    4.09
+  Parameters:                25,557,032
+  Parameters (M):                 25.56
+
+MEMORY ANALYSIS
+----------------------------------------
+  Total Memory:              106.42 MB
+  Parameters:                 97.52 MB
+
+TOP OPERATIONS BY FLOPS
+----------------------------------------
+  conv                 3,891,200,000 ( 95.2%)
+  linear                 102,400,000 (  2.5%)
+  batch_norm              51,200,000 (  1.3%)
+============================================================
+```
+
+## Use Cases
+
+- **Model Optimization**: Identify bottleneck layers before applying compression
+- **Deployment Planning**: Estimate if a model fits device constraints
+- **Model Comparison**: Compare efficiency across architectures
+- **Research**: Analyze compute/memory trade-offs
+
+## Development
+
+```bash
+git clone https://github.com/yaswanth169/coreml-complexity-analyzer.git
+cd coreml-complexity-analyzer
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+BSD-3-Clause
+
+## Authors
+
+- Devavarapu Yashwanth
+- Ireddi Rakshitha

coreml_complexity_analyzer-0.1.0/README.md

@@ -0,0 +1,165 @@
+# coreml-complexity-analyzer
+
+FLOPS estimation, memory analysis, and per-layer profiling for Core ML models.
+
+[![PyPI version](https://badge.fury.io/py/coreml-complexity-analyzer.svg)](https://pypi.org/project/coreml-complexity-analyzer/)
+[![License: BSD-3-Clause](https://img.shields.io/badge/License-BSD_3--Clause-blue.svg)](https://opensource.org/licenses/BSD-3-Clause)
+
+## Why This Exists
+
+Before deploying Core ML models to Apple devices, developers need to understand:
+
+- **Compute cost**: How many FLOPS/MACs does the model require?
+- **Memory footprint**: How much memory for parameters and activations?
+- **Bottleneck layers**: Which layers dominate compute and memory?
+
+`coremltools` does not provide these analysis capabilities out of the box. This package fills that gap.
+
+## Installation
+
+```bash
+pip install coreml-complexity-analyzer
+```
+
+Requirements: `coremltools >= 7.0`, `numpy`
+
+## Quick Start
+
+```python
+import coremltools as ct
+from coreml_complexity_analyzer import generate_report
+
+model = ct.models.MLModel("my_model.mlpackage")
+report = generate_report(model, "ResNet50")
+
+print(f"Total GFLOPS: {report.total_gflops:.2f}")
+print(f"Parameters: {report.parameters_millions:.2f}M")
+print(f"Memory: {report.memory_breakdown.total_mb:.2f} MB")
+
+# Full markdown report
+print(report.to_markdown())
+```
+
+## API
+
+### FLOPSAnalyzer
+
+Compute floating-point operations for each layer in a model.
+
+```python
+from coreml_complexity_analyzer import FLOPSAnalyzer
+
+analyzer = FLOPSAnalyzer(model)
+total = analyzer.get_total_flops()
+breakdown = analyzer.get_layer_breakdown()
+by_type = analyzer.get_flops_by_op_type()
+```
+
+### MemoryEstimator
+
+Estimate memory requirements (parameters + activations + overhead).
+
+```python
+from coreml_complexity_analyzer import MemoryEstimator
+
+estimator = MemoryEstimator(model)
+breakdown = estimator.estimate()
+param_count = estimator.get_parameter_count()
+
+print(f"Total: {breakdown.total_mb:.2f} MB")
+print(f"Parameters: {breakdown.parameter_mb:.2f} MB")
+```
+
+### LayerProfiler
+
+Detailed per-layer analysis combining FLOPS, memory, and shape information.
+
+```python
+from coreml_complexity_analyzer import LayerProfiler
+
+profiler = LayerProfiler(model)
+profiles = profiler.profile()
+
+top_layers = profiler.get_top_layers(n=5, by="flops")
+for layer in top_layers:
+    print(f"{layer.name}: {layer.mflops:.2f} MFLOPS")
+```
+
+### generate_report
+
+Generate comprehensive reports combining all analyses.
+
+```python
+from coreml_complexity_analyzer import generate_report
+
+report = generate_report(model, "ModelName")
+
+# Output formats
+print(report.to_markdown())   # Markdown table
+print(report.to_text())       # Plain text
+data = report.to_dict()       # Dictionary
+```
+
+## Supported Operations
+
+| Category | Operations |
+|----------|-----------|
+| Convolutions | `conv`, `conv_transpose` |
+| Linear | `linear`, `matmul`, `einsum` |
+| Activations | `relu`, `sigmoid`, `tanh`, `gelu`, `silu`, `softplus` |
+| Normalization | `batch_norm`, `layer_norm`, `instance_norm` |
+| Pooling | `max_pool`, `avg_pool` |
+| Element-wise | `add`, `sub`, `mul`, `div` |
+| Reductions | `reduce_sum`, `reduce_mean`, `reduce_max`, `reduce_min` |
+| Other | `softmax` |
+
+## Example Output
+
+```
+============================================================
+Model Complexity Report: ResNet50
+============================================================
+SUMMARY
+----------------------------------------
+  Total FLOPS:            4,089,184,256
+  Total GFLOPS:                    4.09
+  Parameters:                25,557,032
+  Parameters (M):                 25.56
+
+MEMORY ANALYSIS
+----------------------------------------
+  Total Memory:              106.42 MB
+  Parameters:                 97.52 MB
+
+TOP OPERATIONS BY FLOPS
+----------------------------------------
+  conv                 3,891,200,000 ( 95.2%)
+  linear                 102,400,000 (  2.5%)
+  batch_norm              51,200,000 (  1.3%)
+============================================================
+```
+
+## Use Cases
+
+- **Model Optimization**: Identify bottleneck layers before applying compression
+- **Deployment Planning**: Estimate if a model fits device constraints
+- **Model Comparison**: Compare efficiency across architectures
+- **Research**: Analyze compute/memory trade-offs
+
+## Development
+
+```bash
+git clone https://github.com/yaswanth169/coreml-complexity-analyzer.git
+cd coreml-complexity-analyzer
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+BSD-3-Clause
+
+## Authors
+
+- Devavarapu Yashwanth
+- Ireddi Rakshitha

coreml_complexity_analyzer-0.1.0/coreml_complexity_analyzer/__init__.py

@@ -0,0 +1,29 @@
+# Copyright (c) 2025, Devavarapu Yashwanth, Ireddi Rakshitha. All rights reserved.
+#
+# Use of this source code is governed by a BSD-3-clause license that can be
+# found in the LICENSE file.
+
+"""
+Model Complexity Analyzer for Core ML Models.
+
+Provides FLOPS estimation, memory footprint analysis, and
+detailed per-layer profiling for Core ML models.
+"""
+
+__version__ = "0.1.0"
+
+from .flops_analyzer import FLOPSAnalyzer, LayerFLOPS
+from .memory_estimator import MemoryEstimator, MemoryBreakdown
+from .compute_cost_report import ComputeCostReport, generate_report
+from .layer_profiler import LayerProfiler, LayerProfile
+
+__all__ = [
+    "FLOPSAnalyzer",
+    "LayerFLOPS",
+    "MemoryEstimator",
+    "MemoryBreakdown",
+    "ComputeCostReport",
+    "generate_report",
+    "LayerProfiler",
+    "LayerProfile",
+]

coreml_complexity_analyzer-0.1.0/coreml_complexity_analyzer/compute_cost_report.py

@@ -0,0 +1,214 @@
+# Copyright (c) 2025, Devavarapu Yashwanth, Ireddi Rakshitha. All rights reserved.
+#
+# Use of this source code is governed by a BSD-3-clause license that can be
+# found in the LICENSE file.
+
+"""
+Compute Cost Report Generator for Core ML Models.
+
+Generates human-readable reports summarizing model complexity metrics
+including FLOPS, memory, and computational cost analysis.
+"""
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+
+from .flops_analyzer import FLOPSAnalyzer, LayerFLOPS
+from .memory_estimator import MemoryEstimator, MemoryBreakdown
+
+
+@dataclass
+class ComputeCostReport:
+    """Complete compute cost report for a Core ML model."""
+
+    model_name: str
+    total_flops: int
+    total_mac_ops: int
+    total_parameters: int
+    memory_breakdown: MemoryBreakdown
+    layer_breakdown: List[LayerFLOPS]
+    flops_by_op_type: Dict[str, int]
+    generated_at: str = field(default_factory=lambda: datetime.now().isoformat())
+
+    @property
+    def total_gflops(self) -> float:
+        """Total FLOPS in billions."""
+        return self.total_flops / 1e9
+
+    @property
+    def total_mflops(self) -> float:
+        """Total FLOPS in millions."""
+        return self.total_flops / 1e6
+
+    @property
+    def parameters_millions(self) -> float:
+        """Parameters in millions."""
+        return self.total_parameters / 1e6
+
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert report to dictionary."""
+        return {
+            "model_name": self.model_name,
+            "generated_at": self.generated_at,
+            "summary": {
+                "total_flops": self.total_flops,
+                "total_gflops": self.total_gflops,
+                "total_mac_ops": self.total_mac_ops,
+                "total_parameters": self.total_parameters,
+                "parameters_millions": self.parameters_millions,
+            },
+            "memory": self.memory_breakdown.to_dict(),
+            "flops_by_op_type": self.flops_by_op_type,
+            "top_layers": [
+                {
+                    "name": layer.name,
+                    "op_type": layer.op_type,
+                    "flops": layer.flops,
+                    "mflops": layer.mflops,
+                }
+                for layer in self.layer_breakdown[:10]
+            ],
+        }
+
+    def to_markdown(self) -> str:
+        """Generate a markdown formatted report."""
+        lines = [
+            f"# Model Complexity Report: {self.model_name}",
+            "",
+            f"*Generated at: {self.generated_at}*",
+            "",
+            "## Summary",
+            "",
+            "| Metric | Value |",
+            "|--------|-------|",
+            f"| Total FLOPS | {self.total_flops:,} |",
+            f"| Total GFLOPS | {self.total_gflops:.2f} |",
+            f"| Total MAC Ops | {self.total_mac_ops:,} |",
+            f"| Total Parameters | {self.total_parameters:,} |",
+            f"| Parameters (M) | {self.parameters_millions:.2f} |",
+            "",
+            "## Memory Analysis",
+            "",
+            "| Component | Size |",
+            "|-----------|------|",
+            f"| Total Memory | {self.memory_breakdown.total_mb:.2f} MB |",
+            f"| Parameter Memory | {self.memory_breakdown.parameter_mb:.2f} MB |",
+            f"| Activation Memory | {self.memory_breakdown.activation_mb:.2f} MB |",
+            f"| Overhead | {self.memory_breakdown.overhead_bytes / (1024*1024):.2f} MB |",
+            "",
+            "## FLOPS by Operation Type",
+            "",
+            "| Operation | FLOPS | Percentage |",
+            "|-----------|-------|------------|",
+        ]
+
+        for op_type, flops in list(self.flops_by_op_type.items())[:15]:
+            percentage = (
+                (flops / self.total_flops * 100) if self.total_flops > 0 else 0
+            )
+            lines.append(f"| {op_type} | {flops:,} | {percentage:.1f}% |")
+
+        lines.extend(
+            [
+                "",
+                "## Top 10 Layers by FLOPS",
+                "",
+                "| Layer | Type | FLOPS | MFLOPS |",
+                "|-------|------|-------|--------|",
+            ]
+        )
+
+        for layer in self.layer_breakdown[:10]:
+            lines.append(
+                f"| {layer.name[:40]} | {layer.op_type} | "
+                f"{layer.flops:,} | {layer.mflops:.2f} |"
+            )
+
+        return "\n".join(lines)
+
+    def to_text(self) -> str:
+        """Generate a plain text report."""
+        separator = "=" * 60
+        lines = [
+            separator,
+            f"Model Complexity Report: {self.model_name}",
+            separator,
+            f"Generated: {self.generated_at}",
+            "",
+            "SUMMARY",
+            "-" * 40,
+            f"  Total FLOPS:      {self.total_flops:>15,}",
+            f"  Total GFLOPS:     {self.total_gflops:>15.2f}",
+            f"  Total MAC Ops:    {self.total_mac_ops:>15,}",
+            f"  Parameters:       {self.total_parameters:>15,}",
+            f"  Parameters (M):   {self.parameters_millions:>15.2f}",
+            "",
+            "MEMORY ANALYSIS",
+            "-" * 40,
+            f"  Total Memory:     {self.memory_breakdown.total_mb:>12.2f} MB",
+            f"  Parameters:       {self.memory_breakdown.parameter_mb:>12.2f} MB",
+            f"  Activations:      {self.memory_breakdown.activation_mb:>12.2f} MB",
+            "",
+            "TOP OPERATIONS BY FLOPS",
+            "-" * 40,
+        ]
+
+        for op_type, flops in list(self.flops_by_op_type.items())[:10]:
+            percentage = (
+                (flops / self.total_flops * 100) if self.total_flops > 0 else 0
+            )
+            lines.append(f"  {op_type:<20} {flops:>12,} ({percentage:>5.1f}%)")
+
+        lines.extend(["", separator])
+
+        return "\n".join(lines)
+
+
+def generate_report(model, model_name: Optional[str] = None) -> ComputeCostReport:
+    """
+    Generate a comprehensive compute cost report for a Core ML model.
+
+    Parameters
+    ----------
+    model : MLModel or str
+        A loaded MLModel instance or path to a .mlmodel/.mlpackage file.
+    model_name : str, optional
+        Name to use in the report. Defaults to "Unnamed Model".
+
+    Returns
+    -------
+    ComputeCostReport
+        Complete report with FLOPS, memory, and layer breakdown.
+
+    Examples
+    --------
+    >>> import coremltools as ct
+    >>> from coreml_complexity_analyzer import generate_report
+    >>>
+    >>> model = ct.models.MLModel("my_model.mlpackage")
+    >>> report = generate_report(model, "MyModel")
+    >>> print(report.to_markdown())
+    >>>
+    >>> print(f"Total GFLOPS: {report.total_gflops:.2f}")
+    >>> print(f"Memory: {report.memory_breakdown.total_mb:.2f} MB")
+    """
+    if model_name is None:
+        model_name = "Unnamed Model"
+
+    flops_analyzer = FLOPSAnalyzer(model)
+    memory_estimator = MemoryEstimator(model)
+
+    layer_breakdown = flops_analyzer.analyze()
+    flops_by_op_type = flops_analyzer.get_flops_by_op_type()
+    memory_breakdown = memory_estimator.estimate()
+
+    return ComputeCostReport(
+        model_name=model_name,
+        total_flops=flops_analyzer.get_total_flops(),
+        total_mac_ops=flops_analyzer.get_total_mac_ops(),
+        total_parameters=memory_estimator.get_parameter_count(),
+        memory_breakdown=memory_breakdown,
+        layer_breakdown=layer_breakdown,
+        flops_by_op_type=flops_by_op_type,
+    )