haoline 0.3.0__py3-none-any.whl

haoline/examples/__init__.py

@@ -0,0 +1,15 @@
+# Copyright (c) 2025 HaoLine Contributors
+# SPDX-License-Identifier: MIT
+
+"""
+HaoLine Example Scripts
+
+This package contains example scripts demonstrating common use cases:
+
+- basic_inspection.py: Analyze a single model and export JSON
+- compare_models.py: Compare multiple model variants (FP32/FP16/INT8)
+- hardware_estimation.py: Estimate performance on different GPUs
+
+Run from the tools/python directory:
+    python -m util.haoline.examples.basic_inspection model.onnx
+"""

haoline/examples/basic_inspection.py

@@ -0,0 +1,74 @@
+#!/usr/bin/env python
+# Copyright (c) 2025 HaoLine Contributors
+# SPDX-License-Identifier: MIT
+
+"""
+Example: Basic Model Inspection
+
+This script demonstrates how to use HaoLine to inspect a model
+and generate reports programmatically (without CLI).
+
+Usage:
+    python basic_inspection.py model.onnx
+"""
+
+import sys
+from pathlib import Path
+
+from haoline import ModelInspector
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python basic_inspection.py <model.onnx>")
+        sys.exit(1)
+
+    model_path = Path(sys.argv[1])
+    if not model_path.exists():
+        print(f"Error: Model not found: {model_path}")
+        sys.exit(1)
+
+    # Create inspector and analyze model
+    inspector = ModelInspector()
+    report = inspector.inspect(model_path)
+
+    # Print summary
+    print(f"\n{'=' * 60}")
+    print(f"Model: {model_path.name}")
+    print(f"{'=' * 60}")
+
+    # Basic stats
+    if report.graph_summary:
+        print("\nGraph Structure:")
+        print(f"  Nodes: {report.graph_summary.num_nodes}")
+        print(f"  Inputs: {report.graph_summary.num_inputs}")
+        print(f"  Outputs: {report.graph_summary.num_outputs}")
+
+    # Parameters
+    if report.param_counts:
+        total_params = report.param_counts.total
+        print(f"\nParameters: {total_params:,}")
+        if total_params > 1_000_000:
+            print(f"  ({total_params / 1_000_000:.1f}M)")
+
+    # FLOPs
+    if report.flop_counts:
+        total_flops = report.flop_counts.total
+        print(f"\nFLOPs: {total_flops:,}")
+        if total_flops > 1_000_000_000:
+            print(f"  ({total_flops / 1_000_000_000:.1f}G)")
+
+    # Memory
+    if report.memory_estimates:
+        print("\nMemory:")
+        print(f"  Model size: {report.memory_estimates.model_size_mb:.1f} MB")
+        print(f"  Peak activation: {report.memory_estimates.peak_activation_mb:.1f} MB")
+
+    # Export to JSON
+    json_path = model_path.with_suffix(".json")
+    json_path.write_text(report.to_json(), encoding="utf-8")
+    print(f"\nJSON report saved to: {json_path}")
+
+
+if __name__ == "__main__":
+    main()

haoline/examples/compare_models.py

@@ -0,0 +1,117 @@
+#!/usr/bin/env python
+# Copyright (c) 2025 HaoLine Contributors
+# SPDX-License-Identifier: MIT
+
+"""
+Example: Compare Multiple Models
+
+This script demonstrates how to compare multiple model variants
+(e.g., FP32 vs FP16 vs INT8) programmatically.
+
+Usage:
+    python compare_models.py model_fp32.onnx model_fp16.onnx model_int8.onnx
+"""
+
+import sys
+from pathlib import Path
+
+from haoline import ModelInspector
+
+
+def format_size(bytes_val: int) -> str:
+    """Format bytes as human-readable string."""
+    if bytes_val >= 1_000_000_000:
+        return f"{bytes_val / 1_000_000_000:.1f} GB"
+    elif bytes_val >= 1_000_000:
+        return f"{bytes_val / 1_000_000:.1f} MB"
+    elif bytes_val >= 1_000:
+        return f"{bytes_val / 1_000:.1f} KB"
+    return f"{bytes_val} B"
+
+
+def main():
+    if len(sys.argv) < 3:
+        print("Usage: python compare_models.py <model1.onnx> <model2.onnx> [model3.onnx ...]")
+        sys.exit(1)
+
+    model_paths = [Path(p) for p in sys.argv[1:]]
+
+    # Validate all models exist
+    for path in model_paths:
+        if not path.exists():
+            print(f"Error: Model not found: {path}")
+            sys.exit(1)
+
+    # Inspect all models
+    inspector = ModelInspector()
+    reports = []
+
+    print("Analyzing models...")
+    for path in model_paths:
+        print(f"  - {path.name}")
+        report = inspector.inspect(path)
+        reports.append((path.name, report))
+
+    # Print comparison table
+    print(f"\n{'=' * 80}")
+    print("MODEL COMPARISON")
+    print(f"{'=' * 80}")
+
+    # Header
+    print(f"\n{'Metric':<25}", end="")
+    for name, _ in reports:
+        print(f"{name:<20}", end="")
+    print()
+    print("-" * (25 + 20 * len(reports)))
+
+    # File size
+    print(f"{'File Size':<25}", end="")
+    for path, _report in zip(model_paths, reports, strict=True):
+        size = path.stat().st_size
+        print(f"{format_size(size):<20}", end="")
+    print()
+
+    # Parameters
+    print(f"{'Parameters':<25}", end="")
+    for _, report in reports:
+        params = report[1].param_counts.total if report[1].param_counts else 0
+        print(f"{params:,}".ljust(20), end="")
+    print()
+
+    # FLOPs
+    print(f"{'FLOPs':<25}", end="")
+    for _, report in reports:
+        flops = report[1].flop_counts.total if report[1].flop_counts else 0
+        print(f"{flops:,}".ljust(20), end="")
+    print()
+
+    # Memory
+    print(f"{'Peak Activation (MB)':<25}", end="")
+    for _, report in reports:
+        mem = report[1].memory_estimates.peak_activation_mb if report[1].memory_estimates else 0
+        print(f"{mem:.1f}".ljust(20), end="")
+    print()
+
+    # Compute deltas vs first model (baseline)
+    baseline_name, baseline_report = reports[0]
+    baseline_size = model_paths[0].stat().st_size
+
+    print(f"\n{'=' * 80}")
+    print(f"DELTAS vs {baseline_name} (baseline)")
+    print(f"{'=' * 80}")
+
+    for _i, (path, (name, report)) in enumerate(zip(model_paths[1:], reports[1:], strict=True)):
+        size = path.stat().st_size
+        size_delta = (size - baseline_size) / baseline_size * 100
+
+        params = report.param_counts.total if report.param_counts else 0
+        baseline_params = baseline_report.param_counts.total if baseline_report.param_counts else 0
+        params_delta = (params - baseline_params) / baseline_params * 100 if baseline_params else 0
+
+        print(f"\n{name}:")
+        print(f"  Size: {size_delta:+.1f}%")
+        print(f"  Parameters: {params_delta:+.1f}%")
+
+
+if __name__ == "__main__":
+    main()

haoline/examples/hardware_estimation.py

@@ -0,0 +1,78 @@
+#!/usr/bin/env python
+# Copyright (c) 2025 HaoLine Contributors
+# SPDX-License-Identifier: MIT
+
+"""
+Example: Hardware Performance Estimation
+
+This script demonstrates how to estimate model performance
+on different hardware targets.
+
+Usage:
+    python hardware_estimation.py model.onnx
+"""
+
+import sys
+from pathlib import Path
+
+from haoline import (
+    HardwareEstimator,
+    ModelInspector,
+    get_profile,
+    list_available_profiles,
+)
+
+
+def main():
+    if len(sys.argv) < 2:
+        print("Usage: python hardware_estimation.py <model.onnx>")
+        print("\nAvailable hardware profiles:")
+        for name in list_available_profiles()[:10]:
+            print(f"  - {name}")
+        print("  ... and more")
+        sys.exit(1)
+
+    model_path = Path(sys.argv[1])
+    if not model_path.exists():
+        print(f"Error: Model not found: {model_path}")
+        sys.exit(1)
+
+    # Inspect model
+    inspector = ModelInspector()
+    report = inspector.inspect(model_path)
+
+    print(f"\n{'=' * 60}")
+    print(f"Hardware Performance Estimates: {model_path.name}")
+    print(f"{'=' * 60}")
+
+    # Test on a few hardware profiles
+    test_profiles = ["rtx4090", "rtx3080", "a100_40gb", "t4", "jetson_orin"]
+
+    estimator = HardwareEstimator()
+
+    for profile_name in test_profiles:
+        profile = get_profile(profile_name)
+        if profile is None:
+            continue
+
+        estimates = estimator.estimate(
+            flops=report.flop_counts.total if report.flop_counts else 0,
+            params=report.param_counts.total if report.param_counts else 0,
+            activation_bytes=(
+                report.memory_estimates.peak_activation_bytes if report.memory_estimates else 0
+            ),
+            hardware=profile,
+            precision="fp16",
+            batch_size=1,
+        )
+
+        print(f"\n{profile.name}:")
+        print(f"  VRAM Required: {estimates.vram_required_gb:.1f} GB")
+        print(f"  Fits in VRAM: {'Yes' if estimates.fits_in_vram else 'No'}")
+        print(f"  Estimated Latency: {estimates.latency_ms:.2f} ms")
+        print(f"  Estimated Throughput: {estimates.throughput_fps:.0f} fps")
+        print(f"  Bottleneck: {estimates.bottleneck}")
+
+
+if __name__ == "__main__":
+    main()