haoline 0.3.0__py3-none-any.whl

haoline/visualize_yolo.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""Visualize a YOLO model."""
+
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(__file__).replace("\\", "/").rsplit("/", 4)[0])
+
+from util.haoline.analyzer import ONNXGraphLoader
+from util.haoline.edge_analysis import EdgeAnalyzer
+from util.haoline.hierarchical_graph import HierarchicalGraphBuilder
+from util.haoline.html_export import HTMLExporter
+from util.haoline.patterns import PatternAnalyzer
+
+model_path = Path(
+    r"C:\Users\marcu\Roomer\room_detection_training\local_training_output\yolo-v8l-200epoch\weights\best.onnx"
+)
+
+print(f"Loading {model_path.name}...")
+loader = ONNXGraphLoader()
+_, graph_info = loader.load(model_path)
+
+print("Detecting patterns...")
+pattern_analyzer = PatternAnalyzer()
+blocks = pattern_analyzer.group_into_blocks(graph_info)
+
+print("Analyzing edges...")
+edge_analyzer = EdgeAnalyzer()
+edge_result = edge_analyzer.analyze(graph_info)
+
+print("Building hierarchy...")
+builder = HierarchicalGraphBuilder()
+hier_graph = builder.build(graph_info, blocks, model_path.stem)
+
+print("Exporting HTML...")
+exporter = HTMLExporter()
+output_path = exporter.export(
+    hier_graph,
+    edge_result,
+    output_path=model_path.with_suffix(".html"),
+    title=model_path.stem,
+)
+
+print(f"Done! Open {output_path}")

haoline/web.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python
+# Copyright (c) 2025 HaoLine Contributors
+# SPDX-License-Identifier: MIT
+
+"""
+HaoLine Web UI launcher.
+
+Launches the Streamlit web interface for model analysis.
+
+Usage:
+    haoline-web           # Launch the web UI
+    haoline-web --port 8080  # Custom port
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import subprocess
+import sys
+from pathlib import Path
+
+
+def get_streamlit_app_path() -> Path:
+    """Get the path to the bundled streamlit app."""
+    # The app is bundled within the package
+    return Path(__file__).parent / "streamlit_app.py"
+
+
+def get_config_dir() -> Path:
+    """Get the path to the bundled .streamlit config directory."""
+    return Path(__file__).parent / ".streamlit"
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Launch the HaoLine Streamlit web interface."""
+    parser = argparse.ArgumentParser(
+        prog="haoline-web",
+        description="Launch the HaoLine web interface for model analysis.",
+    )
+    parser.add_argument(
+        "--port",
+        type=int,
+        default=8501,
+        help="Port to run the web server on (default: 8501)",
+    )
+    parser.add_argument(
+        "--host",
+        type=str,
+        default="localhost",
+        help="Host to bind to (default: localhost)",
+    )
+    parser.add_argument(
+        "--no-browser",
+        action="store_true",
+        help="Don't open browser automatically",
+    )
+
+    args = parser.parse_args(argv)
+
+    # Check if streamlit is installed
+    try:
+        import streamlit  # noqa: F401
+    except ImportError:
+        print("Error: Streamlit is not installed.")
+        print("Install it with: pip install haoline[web]")
+        return 1
+
+    app_path = get_streamlit_app_path()
+
+    if not app_path.exists():
+        print(f"Error: Streamlit app not found at {app_path}")
+        print("This may indicate a broken installation. Try reinstalling:")
+        print("  pip install --force-reinstall haoline[web]")
+        return 1
+
+    # Build streamlit command
+    cmd = [
+        sys.executable,
+        "-m",
+        "streamlit",
+        "run",
+        str(app_path),
+        "--server.port",
+        str(args.port),
+        "--server.address",
+        args.host,
+    ]
+
+    if args.no_browser:
+        cmd.extend(["--server.headless", "true"])
+
+    print(f"Starting HaoLine Web UI at http://{args.host}:{args.port}")
+    print("Press Ctrl+C to stop.\n")
+
+    # Set up environment with config directory for dark theme
+    env = os.environ.copy()
+    config_dir = get_config_dir()
+    if config_dir.exists():
+        env["STREAMLIT_CONFIG_DIR"] = str(config_dir)
+
+    try:
+        return subprocess.call(cmd, env=env)
+    except KeyboardInterrupt:
+        print("\nShutting down...")
+        return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

haoline-0.3.0.dist-info/METADATA

@@ -0,0 +1,471 @@
+Metadata-Version: 2.4
+Name: haoline
+Version: 0.3.0
+Summary: HaoLine (皓线) - Universal Model Inspector. See what's really inside your models.
+Project-URL: Homepage, https://github.com/mdayku/HaoLine
+Project-URL: Documentation, https://github.com/mdayku/HaoLine#readme
+Project-URL: Repository, https://github.com/mdayku/HaoLine
+Project-URL: Issues, https://github.com/mdayku/HaoLine/issues
+Project-URL: Changelog, https://github.com/mdayku/HaoLine/blob/main/CHANGELOG.md
+Author-email: Marcus Day <marcusday3586@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: deep-learning,flops,machine-learning,memory,model-analysis,model-inspector,neural-network,onnx,parameters,profiling,pytorch,tensorflow,tensorrt
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: Web Environment
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+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: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Requires-Dist: matplotlib>=3.5.0
+Requires-Dist: numpy>=1.20.0
+Requires-Dist: onnx>=1.14.0
+Requires-Dist: pydantic>=2.0.0
+Provides-Extra: coreml
+Requires-Dist: coremltools>=7.0; extra == 'coreml'
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.0.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Provides-Extra: formats
+Requires-Dist: safetensors>=0.4.0; extra == 'formats'
+Requires-Dist: tflite-runtime>=2.14.0; extra == 'formats'
+Provides-Extra: full
+Requires-Dist: anthropic>=0.20.0; extra == 'full'
+Requires-Dist: google-generativeai>=0.3.0; extra == 'full'
+Requires-Dist: matplotlib>=3.5.0; extra == 'full'
+Requires-Dist: nvidia-ml-py>=12.0.0; extra == 'full'
+Requires-Dist: onnxruntime>=1.16.0; extra == 'full'
+Requires-Dist: openai>=1.0.0; extra == 'full'
+Requires-Dist: playwright>=1.40.0; extra == 'full'
+Requires-Dist: python-dotenv>=1.0.0; extra == 'full'
+Requires-Dist: safetensors>=0.4.0; extra == 'full'
+Requires-Dist: streamlit>=1.28.0; extra == 'full'
+Requires-Dist: tflite-runtime>=2.14.0; extra == 'full'
+Provides-Extra: gpu
+Requires-Dist: nvidia-ml-py>=12.0.0; extra == 'gpu'
+Provides-Extra: llm
+Requires-Dist: anthropic>=0.20.0; extra == 'llm'
+Requires-Dist: google-generativeai>=0.3.0; extra == 'llm'
+Requires-Dist: openai>=1.0.0; extra == 'llm'
+Requires-Dist: python-dotenv>=1.0.0; extra == 'llm'
+Provides-Extra: openvino
+Requires-Dist: openvino>=2024.0.0; extra == 'openvino'
+Provides-Extra: pdf
+Requires-Dist: playwright>=1.40.0; extra == 'pdf'
+Provides-Extra: runtime
+Requires-Dist: onnxruntime>=1.16.0; extra == 'runtime'
+Provides-Extra: safetensors
+Requires-Dist: safetensors>=0.4.0; extra == 'safetensors'
+Provides-Extra: tflite
+Requires-Dist: tflite-runtime>=2.14.0; extra == 'tflite'
+Provides-Extra: viz
+Requires-Dist: matplotlib>=3.5.0; extra == 'viz'
+Provides-Extra: web
+Requires-Dist: streamlit>=1.28.0; extra == 'web'
+Description-Content-Type: text/markdown
+
+# HaoLine (皓线)
+
+**Universal Model Inspector — See what's really inside your neural networks.**
+
+[![PyPI version](https://badge.fury.io/py/haoline.svg)](https://badge.fury.io/py/haoline)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+
+HaoLine analyzes neural network architectures and generates comprehensive reports with metrics, visualizations, and AI-powered summaries. Works with ONNX, PyTorch, and TensorFlow models.
+
+---
+
+## Complete Beginner Guide
+
+**Don't have a model yet?** No problem. Follow these steps to analyze your first model in under 5 minutes.
+
+### Step 1: Install HaoLine
+
+```bash
+pip install haoline[llm]
+```
+
+This installs HaoLine with chart generation and AI summary support.
+
+### Step 2: Get a Model to Analyze
+
+**Option A: Download a pre-trained model from Hugging Face**
+
+```bash
+# Install huggingface_hub if you don't have it
+pip install huggingface_hub
+
+# Download a small image classification model (MobileNet, ~14MB)
+python -c "from huggingface_hub import hf_hub_download; hf_hub_download('onnx/models', 'validated/vision/classification/mobilenet/model/mobilenetv2-7.onnx', local_dir='.')"
+```
+
+**Option B: Use your own model**
+
+If you have a `.onnx`, `.pt`, `.pth`, or TensorFlow SavedModel, you can analyze it directly.
+
+**Option C: Convert a PyTorch model**
+
+```bash
+# HaoLine can convert PyTorch models on the fly
+haoline --from-pytorch your_model.pt --input-shape 1,3,224,224 --out-html report.html
+```
+
+### Step 3: Set Up AI Summaries (Optional but Recommended)
+
+To get AI-generated executive summaries, set your OpenAI API key:
+
+```bash
+# Linux/macOS
+export OPENAI_API_KEY="sk-..."
+
+# Windows PowerShell
+$env:OPENAI_API_KEY = "sk-..."
+
+# Or create a .env file in your working directory
+echo "OPENAI_API_KEY=sk-..." > .env
+```
+
+Get your API key at: https://platform.openai.com/api-keys
+
+### Step 4: Generate Your Full Report
+
+```bash
+haoline mobilenetv2-7.onnx \
+  --out-html report.html \
+  --include-graph \
+  --llm-summary \
+  --hardware auto
+```
+
+This generates `report.html` containing:
+- Model architecture overview
+- Parameter counts and FLOPs analysis  
+- Memory requirements
+- Interactive neural network graph (zoomable, searchable)
+- AI-generated executive summary
+- Hardware performance estimates for your GPU
+
+**Open `report.html` in your browser to explore your model!**
+
+---
+
+## Web Interface
+
+**Try it now:** [huggingface.co/spaces/mdayku/haoline](https://huggingface.co/spaces/mdayku/haoline) — no installation required!
+
+Or run locally with a single command:
+
+```bash
+pip install haoline[web]
+haoline-web
+```
+
+This opens an interactive dashboard at `http://localhost:8501` with:
+
+- Drag-and-drop model upload (ONNX, PyTorch)
+- Hardware selection with 50+ GPU profiles (searchable)
+- **NEW:** Batch size and GPU count controls
+- **NEW:** System Requirements (Steam-style min/rec/optimal)
+- **NEW:** Deployment Cost Calculator (monthly cloud cost estimates)
+- **NEW:** Cloud instance selector (T4, A10G, A100, H100, Jetson)
+- Full interactive D3.js neural network graph
+- Model comparison mode (side-by-side analysis)
+- **NEW:** Per-layer timing breakdown (when benchmarked)
+- **NEW:** Memory usage overview chart
+- **NEW:** Run Benchmark button (actual ONNX Runtime measurements)
+- **NEW:** Privacy controls (redact layer names, summary-only mode)
+- AI-powered summaries (bring your own API key)
+- Export to PDF, HTML, JSON, Markdown, **Universal IR**, **DOT graph**
+
+> **Want to deploy your own?** See [DEPLOYMENT.md](DEPLOYMENT.md) for HuggingFace Spaces, Docker, and self-hosted options.
+
+---
+
+## Installation Options
+
+| Command | What You Get |
+|---------|--------------|
+| `pip install haoline` | Core analysis + charts |
+| `pip install haoline[llm]` | + AI-powered summaries |
+| `pip install haoline[full]` | + PDF export, GPU metrics, runtime profiling |
+
+---
+
+## Common Commands
+
+```bash
+# Basic analysis (prints to console)
+haoline model.onnx
+
+# Generate HTML report with charts
+haoline model.onnx --out-html report.html --with-plots
+
+# Full analysis with interactive graph and AI summary
+haoline model.onnx --out-html report.html --include-graph --llm-summary
+
+# Specify hardware for performance estimates
+haoline model.onnx --hardware rtx4090 --out-html report.html
+
+# Auto-detect your GPU
+haoline model.onnx --hardware auto --out-html report.html
+
+# List all available hardware profiles
+haoline --list-hardware
+
+# Convert and analyze a PyTorch model
+haoline --from-pytorch model.pt --input-shape 1,3,224,224 --out-html report.html
+
+# Convert and analyze a TensorFlow SavedModel
+haoline --from-tensorflow ./saved_model_dir --out-html report.html
+
+# Generate JSON for programmatic use
+haoline model.onnx --out-json report.json
+```
+
+---
+
+## Compare Model Variants
+
+Compare different quantizations or architectures side-by-side:
+
+```bash
+haoline-compare \
+  --models resnet_fp32.onnx resnet_fp16.onnx resnet_int8.onnx \
+  --eval-metrics eval_fp32.json eval_fp16.json eval_int8.json \
+  --baseline-precision fp32 \
+  --out-html comparison.html \
+  --with-charts
+```
+
+Or use the web UI's comparison mode for an interactive experience.
+
+---
+
+## CLI Reference
+
+### Output Options
+
+| Flag | Description |
+|------|-------------|
+| `--out-json PATH` | Write JSON report |
+| `--out-md PATH` | Write Markdown model card |
+| `--out-html PATH` | Write HTML report (single shareable file) |
+| `--out-pdf PATH` | Write PDF report (requires playwright) |
+| `--html-graph PATH` | Write standalone interactive graph HTML |
+| `--layer-csv PATH` | Write per-layer metrics CSV |
+
+### Report Options
+
+| Flag | Description |
+|------|-------------|
+| `--include-graph` | Embed interactive D3.js graph in HTML report |
+| `--include-layer-table` | Include sortable per-layer table in HTML |
+| `--with-plots` | Generate matplotlib visualization charts |
+| `--assets-dir PATH` | Directory for chart PNG files |
+
+### Hardware Options
+
+| Flag | Description |
+|------|-------------|
+| `--hardware PROFILE` | GPU profile (`auto`, `rtx4090`, `a100`, `h100`, etc.) |
+| `--list-hardware` | Show all 50+ available GPU profiles |
+| `--precision {fp32,fp16,bf16,int8}` | Precision for estimates |
+| `--batch-size N` | Batch size for estimates |
+| `--gpu-count N` | Multi-GPU scaling (2, 4, 8) |
+| `--cloud INSTANCE` | Cloud instance (e.g., `aws-p4d-24xlarge`) |
+| `--list-cloud` | Show available cloud instances |
+| `--system-requirements` | Generate Steam-style min/recommended specs |
+| `--sweep-batch-sizes` | Find optimal batch size |
+| `--sweep-resolutions` | Analyze resolution scaling |
+
+### LLM Options
+
+| Flag | Description |
+|------|-------------|
+| `--llm-summary` | Generate AI-powered executive summary |
+| `--llm-model MODEL` | Model to use (default: `gpt-4o-mini`) |
+
+### Conversion Options
+
+| Flag | Description |
+|------|-------------|
+| `--from-pytorch PATH` | Convert PyTorch model to ONNX |
+| `--from-tensorflow PATH` | Convert TensorFlow SavedModel |
+| `--from-keras PATH` | Convert Keras .h5/.keras model |
+| `--from-jax PATH` | Convert JAX/Flax model |
+| `--input-shape SHAPE` | Input shape for conversion (e.g., `1,3,224,224`) |
+| `--keep-onnx PATH` | Save converted ONNX to path |
+
+### Privacy Options
+
+| Flag | Description |
+|------|-------------|
+| `--redact-names` | Anonymize layer names for IP protection |
+| `--summary-only` | Show only aggregate statistics |
+| `--offline` | Disable all network requests |
+
+### Universal IR Export
+
+| Flag | Description |
+|------|-------------|
+| `--export-ir PATH` | Export format-agnostic graph as JSON |
+| `--export-graph PATH` | Export graph as DOT or PNG (Graphviz) |
+| `--list-conversions` | Show all supported format conversions |
+
+### Other Options
+
+| Flag | Description |
+|------|-------------|
+| `--quiet` | Suppress console output |
+| `--progress` | Show progress for large models |
+| `--log-level {debug,info,warning,error}` | Logging verbosity |
+
+---
+
+## Python API
+
+```python
+from haoline import ModelInspector
+
+inspector = ModelInspector()
+report = inspector.inspect("model.onnx")
+
+# Access metrics
+print(f"Parameters: {report.param_counts.total:,}")
+print(f"FLOPs: {report.flop_counts.total:,}")
+print(f"Peak Memory: {report.memory_estimates.peak_activation_bytes / 1e9:.2f} GB")
+
+# Export reports
+report.to_json("report.json")
+report.to_markdown("model_card.md")
+report.to_html("report.html")
+```
+
+---
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **Parameter Counts** | Per-node, per-block, and total parameter analysis |
+| **FLOP Estimates** | Identify compute hotspots in your model |
+| **Memory Analysis** | Peak activation memory and VRAM requirements |
+| **Risk Signals** | Detect problematic architecture patterns |
+| **Hardware Estimates** | GPU utilization predictions for 30+ NVIDIA profiles |
+| **Runtime Profiling** | Actual inference benchmarks with ONNX Runtime |
+| **Visualizations** | Operator histograms, parameter/FLOPs distribution charts |
+| **Interactive Graph** | Zoomable D3.js neural network visualization |
+| **AI Summaries** | GPT-powered executive summaries of your architecture |
+| **Multiple Formats** | Export to HTML, Markdown, PDF, JSON, or CSV |
+| **Universal IR** | Format-agnostic intermediate representation for cross-format analysis |
+
+---
+
+## Universal IR (Internal Representation)
+
+HaoLine uses a Universal IR to represent models in a format-agnostic way, enabling:
+
+- **Cross-format comparison**: Compare PyTorch vs ONNX vs TensorFlow architectures
+- **Structural analysis**: Check if two models are architecturally identical
+- **Graph visualization**: Export to Graphviz DOT or PNG
+
+```bash
+# Export model as Universal IR (JSON)
+haoline model.onnx --export-ir model_ir.json
+
+# Export graph visualization
+haoline model.onnx --export-graph graph.dot
+haoline model.onnx --export-graph graph.png --graph-max-nodes 200
+
+# List available format conversions
+haoline --list-conversions
+```
+
+The Universal IR includes:
+- **UniversalGraph**: Container for nodes, tensors, and metadata
+- **UniversalNode**: Format-agnostic operation representation
+- **UniversalTensor**: Weight, input, output, and activation metadata
+
+---
+
+## Supported Model Formats
+
+| Format | Support | Notes |
+|--------|---------|-------|
+| ONNX (.onnx) | ✅ Full | Native support |
+| PyTorch (.pt, .pth) | ✅ Full | Auto-converts to ONNX |
+| TensorFlow SavedModel | ✅ Full | Requires tf2onnx |
+| Keras (.h5, .keras) | ✅ Full | Requires tf2onnx |
+| GGUF (.gguf) | ✅ Read | llama.cpp LLMs (`pip install haoline`) |
+| SafeTensors (.safetensors) | ✅ Read | HuggingFace weights (`pip install haoline[formats]`) |
+| TFLite (.tflite) | ✅ Read | Mobile/edge (`pip install haoline[formats]`) |
+| CoreML (.mlmodel, .mlpackage) | ✅ Read | Apple devices (`pip install haoline[coreml]`) |
+| OpenVINO (.xml) | ✅ Read | Intel inference (`pip install haoline[openvino]`) |
+| TensorRT Engine | 🔜 Coming | NVIDIA optimized engines |
+
+---
+
+## LLM Providers
+
+HaoLine supports multiple AI providers for generating summaries:
+
+| Provider | Environment Variable | Get API Key |
+|----------|---------------------|-------------|
+| OpenAI | `OPENAI_API_KEY` | [platform.openai.com](https://platform.openai.com/api-keys) |
+| Anthropic | `ANTHROPIC_API_KEY` | [console.anthropic.com](https://console.anthropic.com/) |
+| Google Gemini | `GOOGLE_API_KEY` | [aistudio.google.com](https://aistudio.google.com/app/apikey) |
+| xAI Grok | `XAI_API_KEY` | [console.x.ai](https://console.x.ai/) |
+
+---
+
+## Where to Find Models
+
+| Source | URL | Notes |
+|--------|-----|-------|
+| Hugging Face ONNX | [huggingface.co/onnx](https://huggingface.co/onnx) | Pre-converted ONNX models |
+| ONNX Model Zoo | [github.com/onnx/models](https://github.com/onnx/models) | Official ONNX examples |
+| Hugging Face Hub | [huggingface.co/models](https://huggingface.co/models) | PyTorch/TF models (convert with HaoLine) |
+| TorchVision | `torchvision.models` | Classic vision models |
+| Timm | [github.com/huggingface/pytorch-image-models](https://github.com/huggingface/pytorch-image-models) | State-of-the-art vision models |
+
+---
+
+## Security Notice
+
+⚠️ **Loading untrusted models is inherently risky.**
+
+Like PyTorch's `torch.load()`, HaoLine uses `pickle` when loading certain model formats. These can execute arbitrary code if the model file is malicious.
+
+**Best practices:**
+- Only analyze models from trusted sources
+- Run in a sandboxed environment (Docker, VM) when analyzing unknown models
+- Review model provenance before loading
+
+---
+
+## License
+
+MIT License - See [LICENSE](LICENSE) for details.
+
+---
+
+## Etymology
+
+**HaoLine** (皓线) combines:
+- 皓 (hào) = "bright, luminous" in Chinese
+- Line = the paths through your neural network
+
+*"Illuminating the architecture of your models."*

haoline-0.3.0.dist-info/RECORD

@@ -0,0 +1,70 @@
+haoline/__init__.py,sha256=X5MQk2oUDc9UJcHCyomAC-6yEvFH7pG5ZnNXDMbGMB4,6645
+haoline/analyzer.py,sha256=YTttwpqjA9yELhj-ziVqhipUEx5d5xDbqu7654y5Hwk,37024
+haoline/cli.py,sha256=xqLna6YY2L-eAtQVqn4xm9apCikxGsWjVTFCXYjVm60,100749
+haoline/compare.py,sha256=2epr4ZSK0PlQYWzSbvHmiqBSgjkFBfIxQGSiEe1jXQg,29122
+haoline/compare_visualizations.py,sha256=vLiSMr29noV81WS5K_wDHe4axahW5w-yROFNHqtecfI,53006
+haoline/edge_analysis.py,sha256=Y3o5v85G3AZyCQyuVmrtPHCK63tiKHPDs8OVmbZi-0A,18010
+haoline/format_adapters.py,sha256=BjLlDI3QqjS0q3niVhm7jocpzDtqW5FpiGBJ7883d78,33757
+haoline/hardware.py,sha256=XS8NykPId15tI_1yilS3Iqyd_bERx-UEbvvqaUFnZIM,77521
+haoline/hierarchical_graph.py,sha256=PjH687ApgQyXLT21FapvZoLsjOwTFBMXTiJxknOyESY,15851
+haoline/html_export.py,sha256=NAltKGDcRHVaNtV3ydp_FWo5WwTEKkUGnrVYBhIegME,60766
+haoline/layer_summary.py,sha256=enumGcgmkNM8qyH4hY2kjZivZ7rAZ8Qh6yWvLDiAEtU,26416
+haoline/llm_summarizer.py,sha256=BK9reMlh2GNAzabKEoPhfBeXsPCfUgn5885JzQMgFGA,18056
+haoline/op_icons.py,sha256=w41dXtoTjqNLKbGWMpP1D4d9r4tYU_C7HllChq0ufhQ,19578
+haoline/operational_profiling.py,sha256=7FfggwT8Uy3LyOmOTuXDxUFjIAKQmKYKVL0LYQCiQU4,54921
+haoline/patterns.py,sha256=QHav0dL5O4kCZ4agBQhGXPJ2PYqAAUsduONBhz3JzbY,45659
+haoline/pdf_generator.py,sha256=Kcnk3VTu-C-Lwi_LsZ3OM6Sne5w_ze-14KQWm-uXowQ,9470
+haoline/privacy.py,sha256=qtWAZCUpB5l3-2mOWEnViY5gwxcK6DGnDosKpQqF5Lg,8458
+haoline/pydantic_models.py,sha256=t6hKMTbw1wOceHEobVR6rME3-yRamzCmUtxOVhsR1WU,9396
+haoline/report.py,sha256=29AsHoKoiemlZpIbXjue2Mwa4sZeSTonwqabwyWnyqM,76212
+haoline/report_sections.py,sha256=hIu51QGGTvIU7ZEYTL-pzCTr0zE8TPuldnIcPXVZWOg,17494
+haoline/risks.py,sha256=4eL-xwJlF13ndUj9R-lYoojijFf5J7UdGhPWOrmScpw,19873
+haoline/schema.py,sha256=9aVEXkbOVqZGMZ5OsOCV0akhKViwYBpsM_lNLhJoklk,20353
+haoline/streamlit_app.py,sha256=_QyfA3ORh2x36EZq_C7jGMM_5qYECGAsLeIdvH7gBn4,80602
+haoline/universal_ir.py,sha256=WBKxfonhL7-QgHAE0Ki6G-7UmyUC2rj6YlZN0ixejtU,30717
+haoline/visualizations.py,sha256=83V0XwY1cKNWL_PJxtmitjWjKzh34x1devSA2QiadE0,35776
+haoline/visualize_yolo.py,sha256=l0k1wKy0dgeoGiYoM2efunkzd79qJeMVFRVXxYoviTg,1316
+haoline/web.py,sha256=sYYU0ObvRfC0X7XDsnTltLNIByTZB5l3JiF3by1sMe0,2921
+haoline/.streamlit/config.toml,sha256=OoeP2GLvcQg6-ouZYF5RKDXxxDCibzgAJY-vgehMfoQ,175
+haoline/eval/__init__.py,sha256=Id1mi4PDhZeuwgwhw0ObaUk1oxL8UFZlK5GnXhjXm7M,3271
+haoline/eval/adapters.py,sha256=DHazME6YerCruZp4bTbmx-Dyog5PYpS4cX220BG2OQU,28138
+haoline/eval/cli.py,sha256=ihf1UzLt2JR0rYmTcac1J5zaBtG7b-cpTCy3qkNyW2M,12466
+haoline/eval/comparison.py,sha256=cgkpgiNY8wVeWsdy-XWjlenoGZmxXuwCGWXCcV6L-lY,17679
+haoline/eval/deployment.py,sha256=G2_4SeNEiGrr5zxfwZi20SUQWqP1ZER5ty3Tkh2VvHg,21458
+haoline/eval/schemas.py,sha256=ZxMGDIOjzv7uFECmqXc6dF6_srWXj8aFyb-h43eUPog,26736
+haoline/examples/__init__.py,sha256=6N49SoBePYOid8XAgBxBDsA9-GkJhG_pPK1x36Y_1j8,492
+haoline/examples/basic_inspection.py,sha256=9jr5QhIYCrllZDWmzmi3FW0jG_fM3mciy1PVuI-E_jQ,2149
+haoline/examples/compare_models.py,sha256=ATxne-kFmPBYTR3eSs2IrsBx1EoCVBPAfHuMKhgB-5Q,3603
+haoline/examples/hardware_estimation.py,sha256=UQ0jIJyQAV0Hq74BPLgiJvfmeC1hjmNGEtH1e6vvkVw,2308
+haoline/formats/__init__.py,sha256=fSR7jQnmF0NS7Y6P_Pj5pxpifdMU1t8_Vut8oEJ8goM,2948
+haoline/formats/coreml.py,sha256=fCU_iFzpuXJ7uju-T-l-BRUfgVEMWQsslVqM7syFMIc,7961
+haoline/formats/gguf.py,sha256=EL1SqxJiXaY3pwwlE28R16W8GfWZnqDjbCfi4id3BSU,15343
+haoline/formats/openvino.py,sha256=mApzb4Aj3a_jX2VvSLlfMvcK7z7vwFphtiJXp4iPWpg,7878
+haoline/formats/safetensors.py,sha256=nO5MUhXTwPyeluAa1W4jDLoCaqC2KSi7DxBqdbIjtYY,7764
+haoline/formats/tflite.py,sha256=DxdmnDLO09-khbt85zYr2XD0buENVSX9HlfQ_9aMerE,10614
+haoline/tests/__init__.py,sha256=HSbYxxTpeXSudDMh-xkVThIr2JyyHqP4BKXevFsqKLw,110
+haoline/tests/conftest.py,sha256=IPqruuvPOe_dzQSwSDLi1yinHTGnGK4afNdcX6P_DlI,3838
+haoline/tests/test_analyzer.py,sha256=3qV_dxMRFZ0EiAgN-0KnKEejfVdvnaUHybFDuDbREkY,28847
+haoline/tests/test_compare_visualizations.py,sha256=iT3n-EY0NlC7lxy7SVYa9luB4v9weE6uPJ8LHTuuvLo,11120
+haoline/tests/test_edge_analysis.py,sha256=bMTSm3nV5vEmBF4r8a7gfdEJFbOMTwXwJP25lNptuk0,7918
+haoline/tests/test_eval.py,sha256=JzdnEd_z5drAB4LpeOFZI5tBXgKUsBtYvh22U7qXOLA,20393
+haoline/tests/test_format_adapters.py,sha256=biT0Rcwevf3V8harsohGQYKhN063Jpv_ccjkTpy1zFg,17082
+haoline/tests/test_hardware.py,sha256=KcjT_Vul5o7MPYO-ftqlYNdUXcPwNnPcLh0lBj5lj3A,8151
+haoline/tests/test_hardware_recommender.py,sha256=_uJ3VBuDA6VaWL8Yqzjqb7BP2ngJjHPg1Fs-NOqynok,3101
+haoline/tests/test_hierarchical_graph.py,sha256=z3L2F9UyBybuq096ZoyDCTq3Sayql5MBkbhQJL90kWc,10038
+haoline/tests/test_html_export.py,sha256=MdUz_6bVqrd8sseDLrDd8SVnq6ZxNnOhFUzhFy6RaOY,5713
+haoline/tests/test_layer_summary.py,sha256=L3nQUYav-5n1xqUwjIdesWTwrPzu44SGYMgx4ZBA9Y8,14817
+haoline/tests/test_llm_patterns.py,sha256=tqGtjTIj59Nj7HO9S3GPNDKTmBtLvnxkK84ZkAkDQbQ,18619
+haoline/tests/test_llm_summarizer.py,sha256=QT7tEIKQpSpe_SZ2UANOLKnIRjYvDQRgxUc5Kk6qsXA,10904
+haoline/tests/test_patterns.py,sha256=i6I1z_NTApRIlkiIl15chXNUoF-w8zJ3yCQwMM1SGJE,26286
+haoline/tests/test_pytorch.py,sha256=BW_SjFfpKpSXsSqk-TDS77Kq_XcpTTwjPSFmQN5-W9s,10981
+haoline/tests/test_report.py,sha256=DW7pyixAQRYZKZXnh1ehGDAN772N9-GrjSp_AK40Rdw,13093
+haoline/tests/test_risks.py,sha256=w3YfHQHDG3jn2pw39tAkcY8qXOFnKwrv6zLpUc3_Ow4,14603
+haoline/tests/test_schema.py,sha256=91BSUhPOKOb7z89BOMvjeuIAWTFFGP-bzSc2r2jHiCs,14448
+haoline/tests/test_tensorflow.py,sha256=K9pVd63k835zyG3gH2a6VXzHGNgrvDo1qRt3wHT3KOA,12062
+haoline/tests/test_visualizations.py,sha256=k4RXG_T_VW8kL-KF7_dhossEDu5CxvShAjSmI7nMD8I,10570
+haoline-0.3.0.dist-info/METADATA,sha256=lJ5h_N1r6iBK5ERftg10PXhaUZgWDrRWUG22XWCFekU,16347
+haoline-0.3.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+haoline-0.3.0.dist-info/entry_points.txt,sha256=L4shBI6eAO14k2VbV2Zx2Sw7mfT3_bw-xRPMCINXKdk,166
+haoline-0.3.0.dist-info/licenses/LICENSE,sha256=_ktRHwuyG2LBwOGwXYIv6IZ6Av2FyrptFefD9RXGNM0,1090
+haoline-0.3.0.dist-info/RECORD,,