blink-gpu 0.1.0__py3-none-any.whl

blink/__init__.py

@@ -0,0 +1,30 @@
+"""
+Blink — GPU Performance Predictor
+==================================
+Predict GPU execution time and memory usage for PyTorch models
+*before* running them on GPU hardware.
+
+Quick start
+-----------
+>>> from blink import BlinkPredictor
+>>> predictor = BlinkPredictor()
+>>> result = predictor.predict("resnet18", batch_size=32)
+>>> print(f"Exec time: {result['exec_time_ms']:.1f} ms")
+>>> print(f"Memory   : {result['memory_mb']:.1f} MB")
+
+Or with your own model:
+>>> import torch.nn as nn
+>>> model = nn.Sequential(nn.Linear(512, 256), nn.ReLU(), nn.Linear(256, 10))
+>>> result = BlinkPredictor().predict(model, batch_size=64)
+"""
+from __future__ import annotations
+
+from blink._predictor import BlinkPredictor
+from blink._analyzer  import BlinkAnalyzer
+from blink._version   import __version__
+
+__all__ = [
+    "BlinkPredictor",
+    "BlinkAnalyzer",
+    "__version__",
+]

blink/__main__.py

@@ -0,0 +1,117 @@
+"""
+blink.__main__
+==============
+CLI entry point for the blink-gpu package.
+
+Usage
+-----
+    # Quick prediction from the command line
+    blink predict resnet50 --batch-size 32
+
+    # Start the Streamlit dashboard
+    blink dashboard
+
+    # Start the FastAPI server
+    blink-server
+    blink-server --host 0.0.0.0 --port 8000 --workers 4
+
+    # Check installed version
+    blink --version
+"""
+from __future__ import annotations
+
+import argparse
+import sys
+
+
+def main() -> None:
+    """Entry point for the ``blink`` CLI command."""
+    parser = argparse.ArgumentParser(
+        prog="blink",
+        description="Blink — GPU performance predictor for PyTorch models",
+    )
+    parser.add_argument("--version", action="store_true", help="Show version and exit")
+
+    sub = parser.add_subparsers(dest="command")
+
+    # ── predict ───────────────────────────────────────────────────────────────
+    p_pred = sub.add_parser("predict", help="Predict GPU usage for a named model")
+    p_pred.add_argument("model", help='Model name, e.g. "resnet50"')
+    p_pred.add_argument("--batch-size", "-b", type=int, default=32)
+    p_pred.add_argument("--all-batches", action="store_true",
+                        help="Also show batch sizes 1,2,4,8,16,64")
+
+    # ── dashboard ─────────────────────────────────────────────────────────────
+    p_dash = sub.add_parser("dashboard", help="Launch the Streamlit dashboard")
+    p_dash.add_argument("--port", type=int, default=8501)
+
+    # ── server ────────────────────────────────────────────────────────────────
+    p_srv = sub.add_parser("server", help="Launch the FastAPI REST server")
+    p_srv.add_argument("--host", default="0.0.0.0")
+    p_srv.add_argument("--port", type=int, default=8000)
+    p_srv.add_argument("--workers", "-w", type=int, default=1)
+
+    args = parser.parse_args()
+
+    # ── --version ──────────────────────────────────────────────────────────────
+    if args.version or args.command is None:
+        from blink._version import __version__
+        print(f"blink-gpu {__version__}")
+        if args.command is None and not args.version:
+            parser.print_help()
+        return
+
+    # ── predict ───────────────────────────────────────────────────────────────
+    if args.command == "predict":
+        from blink._predictor import BlinkPredictor
+        p = BlinkPredictor()
+        batch_sizes = ([1, 2, 4, 8, 16, args.batch_size, 64]
+                       if args.all_batches else [args.batch_size])
+        batch_sizes = sorted(set(batch_sizes))
+
+        print(f"\n🔮 Blink prediction for '{args.model}'\n")
+        print(f"{'Batch':>6}  {'Exec (ms)':>10}  {'Memory (MB)':>12}  CI-Exec (80%)")
+        print("-" * 60)
+        for bs in batch_sizes:
+            try:
+                r = p.predict(args.model, batch_size=bs)
+                ci = f"[{r['exec_time_lower']:.1f} – {r['exec_time_upper']:.1f}]"
+                print(f"{bs:>6}  {r['exec_time_ms']:>10.2f}  {r['memory_mb']:>12.1f}  {ci}")
+            except Exception as e:
+                print(f"{bs:>6}  ERROR: {e}")
+        print()
+        return
+
+    # ── dashboard ─────────────────────────────────────────────────────────────
+    if args.command == "dashboard":
+        import subprocess
+        from pathlib import Path
+        dash = Path(__file__).parent.parent / "dashboard.py"
+        print(f"Launching Blink dashboard on http://localhost:{args.port} ...")
+        subprocess.run([
+            sys.executable, "-m", "streamlit", "run", str(dash),
+            f"--server.port={args.port}",
+        ], check=True)
+        return
+
+    # ── server ────────────────────────────────────────────────────────────────
+    if args.command == "server":
+        serve(host=args.host, port=args.port, workers=args.workers)
+        return
+
+
+def serve(host: str = "0.0.0.0", port: int = 8000, workers: int = 1) -> None:
+    """Entry point for the ``blink-server`` CLI command."""
+    import uvicorn
+    print(f"🚀 Starting Blink REST API on http://{host}:{port} | docs: /docs")
+    uvicorn.run(
+        "api.main:app",
+        host=host,
+        port=port,
+        workers=workers,
+        log_level="info",
+    )
+
+
+if __name__ == "__main__":
+    main()

blink/_analyzer.py

@@ -0,0 +1,98 @@
+"""
+blink._analyzer
+===============
+BlinkAnalyzer — public-facing facade over ModelAnalyser.
+Extracts architecture features from any PyTorch nn.Module.
+"""
+from __future__ import annotations
+
+import sys
+from pathlib import Path
+from typing import Union
+
+import torch.nn as nn
+
+_ROOT = Path(__file__).parent.parent
+if str(_ROOT) not in sys.path:
+    sys.path.insert(0, str(_ROOT))
+
+
+class BlinkAnalyzer:
+    """
+    Extract architecture features from a PyTorch model.
+
+    Used internally by BlinkPredictor, but also useful standalone
+    if you want to inspect what Blink sees about your model.
+
+    Examples
+    --------
+    >>> from blink import BlinkAnalyzer
+    >>> import torchvision.models as tv
+    >>> model = tv.resnet18(weights=None)
+    >>> feats = BlinkAnalyzer().analyze(model)
+    >>> feats["flops"]
+    1814073344
+    >>> feats["num_conv_layers"]
+    20
+    """
+
+    def __init__(self):
+        self._analyser = None
+
+    def _get(self):
+        if self._analyser is None:
+            from model_analyser import ModelAnalyzer
+            self._analyser = ModelAnalyzer()
+        return self._analyser
+
+    def analyze(
+        self,
+        model: "nn.Module",
+        input_shape: tuple = (3, 224, 224),
+    ) -> dict:
+        """
+        Extract architecture features from *model*.
+
+        Parameters
+        ----------
+        model : nn.Module
+            Any PyTorch model.
+        input_shape : tuple
+            (C, H, W) input shape. Default ``(3, 224, 224)``.
+
+        Returns
+        -------
+        dict
+            Architecture features used by Blink's prediction models, e.g.
+            ``flops``, ``num_conv_layers``, ``model_size_mb``, etc.
+        """
+        return self._get().extract_features(model, input_shape)
+
+    def summary(self, model: "nn.Module", input_shape: tuple = (3, 224, 224)) -> str:
+        """
+        Return a human-readable string summary of the model's key metrics.
+
+        Examples
+        --------
+        >>> print(BlinkAnalyzer().summary(model))
+        Model Architecture Summary
+        ==========================
+        Parameters  :  11,689,512
+        FLOPs       :   1,814 M
+        Conv layers :        20
+        Size (MB)   :   44.59
+        """
+        feats = self.analyze(model, input_shape)
+        flops_m = feats.get('flops', 0) / 1e6
+        lines = [
+            "Model Architecture Summary",
+            "==========================",
+            f"Parameters  : {feats.get('total_parameters', 0):>12,}",
+            f"FLOPs       : {flops_m:>10.1f} M",
+            f"Conv layers : {feats.get('num_conv_layers', 0):>10}",
+            f"FC layers   : {feats.get('num_fc_layers', 0):>10}",
+            f"BN layers   : {feats.get('num_bn_layers', 0):>10}",
+            f"Model depth : {feats.get('model_depth', 0):>10}",
+            f"Size (MB)   : {feats.get('model_size_mb', 0):>10.2f}",
+        ]
+        return "\n".join(lines)

blink/_predictor.py

@@ -0,0 +1,164 @@
+"""
+blink._predictor
+================
+BlinkPredictor — public-facing facade over gpu_predictor.GpuPredictor.
+"""
+from __future__ import annotations
+
+import os
+import sys
+from pathlib import Path
+from typing import Union, List, Optional
+
+import torch.nn as nn
+
+# Ensure the repo root is on sys.path so the original modules are importable,
+# regardless of how/where the package was installed.
+_ROOT = Path(__file__).parent.parent
+if str(_ROOT) not in sys.path:
+    sys.path.insert(0, str(_ROOT))
+
+_DEFAULT_MODELS_DIR = _ROOT / "models"
+
+
+class BlinkPredictor:
+    """
+    Predict GPU execution time and peak memory for a PyTorch model.
+
+    Parameters
+    ----------
+    models_dir : str or Path, optional
+        Path to the directory containing Blink's trained model files.
+        Defaults to ``<repo_root>/models``.
+
+    Examples
+    --------
+    >>> from blink import BlinkPredictor
+    >>> p = BlinkPredictor()
+
+    Predict with a pre-trained model name:
+    >>> result = p.predict("resnet50", batch_size=16)
+    >>> result["exec_time_ms"]
+    28.4
+
+    Predict with your own nn.Module:
+    >>> import torch.nn as nn
+    >>> model = nn.Sequential(nn.Linear(512, 256), nn.ReLU(), nn.Linear(256, 10))
+    >>> result = p.predict(model, batch_size=32)
+    """
+
+    # Supported named model aliases
+    NAMED_MODELS = {
+        "resnet18", "resnet50", "vgg16", "mobilenet_v2", "densenet121",
+    }
+
+    def __init__(self, models_dir: Optional[Union[str, Path]] = None):
+        self._models_dir = Path(models_dir) if models_dir else _DEFAULT_MODELS_DIR
+        self._predictor = None   # lazy-loaded
+
+    # ── Lazy init ─────────────────────────────────────────────────────────────
+
+    def _get_predictor(self):
+        if self._predictor is None:
+            from gpu_predictor import GPUPredictor
+            self._predictor = GPUPredictor(
+                model_path=str(self._models_dir / "random_forest_model.joblib"),
+                memory_model_path=str(self._models_dir / "memory_model.joblib"),
+            )
+        return self._predictor
+
+    # ── Public API ────────────────────────────────────────────────────────────
+
+    def predict(
+        self,
+        model: Union[str, "nn.Module"],
+        batch_size: int = 32,
+        input_shape: tuple = (3, 224, 224),
+    ) -> dict:
+        """
+        Predict execution time and peak memory for *model* at *batch_size*.
+
+        Parameters
+        ----------
+        model : str or nn.Module
+            Either a model name string (e.g. ``"resnet18"``), or an
+            instantiated ``torch.nn.Module``.
+        batch_size : int
+            Batch size to predict for.
+        input_shape : tuple
+            Input tensor shape (C, H, W). Default ``(3, 224, 224)``.
+
+        Returns
+        -------
+        dict with keys:
+            exec_time_ms       : float  — predicted execution time (ms)
+            exec_time_lower    : float  — 80 % CI lower bound (ms)
+            exec_time_upper    : float  — 80 % CI upper bound (ms)
+            memory_mb          : float  — predicted peak memory (MB)
+            memory_lower_mb    : float  — 80 % CI lower bound (MB)
+            memory_upper_mb    : float  — 80 % CI upper bound (MB)
+            source             : str    — which backend produced this prediction
+        """
+        predictor = self._get_predictor()
+
+        # Resolve named model
+        if isinstance(model, str):
+            model = _load_named_model(model)
+
+        # Extract features
+        from model_analyser import ModelAnalyzer
+        analyser = ModelAnalyzer()
+        features = analyser.extract_features(model, input_shape)
+        features["batch_size"] = batch_size
+
+        raw = predictor.predict([features])
+        if isinstance(raw, list):
+            raw = raw[0]
+
+        return {
+            "exec_time_ms":    raw.get("exec_time_ms", 0.0),
+            "exec_time_lower": raw.get("exec_time_lower", 0.0),
+            "exec_time_upper": raw.get("exec_time_upper", 0.0),
+            "memory_mb":       raw.get("memory_usage_mb", 0.0),
+            "memory_lower_mb": raw.get("memory_lower_mb", 0.0),
+            "memory_upper_mb": raw.get("memory_upper_mb", 0.0),
+            "source":          raw.get("source", "blink"),
+        }
+
+    def predict_batch(
+        self,
+        model: Union[str, "nn.Module"],
+        batch_sizes: List[int],
+        input_shape: tuple = (3, 224, 224),
+    ) -> List[dict]:
+        """
+        Predict for multiple batch sizes in one call.
+
+        Returns
+        -------
+        list[dict]
+            One result dict per entry in *batch_sizes*.
+        """
+        return [self.predict(model, bs, input_shape) for bs in batch_sizes]
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+def _load_named_model(name: str) -> "nn.Module":
+    """Load a torchvision pre-trained model by name."""
+    import torchvision.models as tv
+    name = name.lower().replace("-", "_")
+    loaders = {
+        "resnet18":     lambda: tv.resnet18(weights=None),
+        "resnet50":     lambda: tv.resnet50(weights=None),
+        "vgg16":        lambda: tv.vgg16(weights=None),
+        "mobilenet_v2": lambda: tv.mobilenet_v2(weights=None),
+        "densenet121":  lambda: tv.densenet121(weights=None),
+    }
+    if name not in loaders:
+        raise ValueError(
+            f"Unknown model '{name}'. "
+            f"Supported names: {sorted(loaders)}. "
+            "Or pass an nn.Module directly."
+        )
+    return loaders[name]()

blink/_version.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

blink/py.typed

@@ -0,0 +1 @@
+# Marker file for PEP 561 — tells type checkers this package has type info

blink_gpu-0.1.0.dist-info/METADATA

@@ -0,0 +1,315 @@
+Metadata-Version: 2.4
+Name: blink-gpu
+Version: 0.1.0
+Summary: Predict GPU execution time & memory for PyTorch models — without running them.
+Author-email: Aniket Mishra <aniket@blink-gpu.dev>
+License: MIT
+Project-URL: Homepage, https://github.com/Aniketxmishra/Blink_Main
+Project-URL: Documentation, https://github.com/Aniketxmishra/Blink_Main#readme
+Project-URL: Repository, https://github.com/Aniketxmishra/Blink_Main.git
+Project-URL: Bug Tracker, https://github.com/Aniketxmishra/Blink_Main/issues
+Keywords: gpu,performance,prediction,pytorch,neural-network,profiling,machine-learning,explainability
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: System :: Hardware
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=1.24
+Requires-Dist: pandas>=2.0
+Requires-Dist: scikit-learn>=1.3
+Requires-Dist: xgboost>=2.0
+Requires-Dist: joblib>=1.3
+Requires-Dist: thop>=0.1.1
+Provides-Extra: full
+Requires-Dist: optuna; extra == "full"
+Requires-Dist: lightgbm; extra == "full"
+Requires-Dist: pynvml; extra == "full"
+Requires-Dist: shap>=0.44; extra == "full"
+Requires-Dist: streamlit>=1.30; extra == "full"
+Requires-Dist: plotly>=5.18; extra == "full"
+Requires-Dist: matplotlib>=3.8; extra == "full"
+Requires-Dist: seaborn>=0.13; extra == "full"
+Provides-Extra: api
+Requires-Dist: fastapi>=0.110; extra == "api"
+Requires-Dist: uvicorn[standard]>=0.27; extra == "api"
+Requires-Dist: python-multipart; extra == "api"
+Requires-Dist: httpx; extra == "api"
+Provides-Extra: gnn
+Requires-Dist: torch-geometric; extra == "gnn"
+Provides-Extra: explain
+Requires-Dist: shap>=0.44; extra == "explain"
+Provides-Extra: dev
+Requires-Dist: pytest>=7.4; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pre-commit; extra == "dev"
+Provides-Extra: all
+Requires-Dist: blink-gpu[api,dev,explain,full,gnn]; extra == "all"
+
+# Blink 🔭
+> **GPU Performance Predictor for Deep Learning Models**
+
+Blink predicts **execution time** and **memory usage** of PyTorch neural networks on GPU without actually running them. It combines classical ML (XGBoost, Random Forest) with a Graph Neural Network (GNN) that encodes the computational graph of any model architecture.
+
+---
+
+## 📋 Table of Contents
+- [Overview](#overview)
+- [Architecture](#architecture)
+- [Project Structure](#project-structure)
+- [Installation](#installation)
+- [Usage](#usage)
+- [Data Pipeline](#data-pipeline)
+- [Model Performance](#model-performance)
+- [Dashboard](#dashboard)
+- [Paper Reproducibility](#paper-reproducibility)
+
+---
+
+## Overview
+
+Given a PyTorch model and a batch size, Blink answers:
+- *How long will a forward pass take on this GPU?*
+- *How much GPU memory will it consume?*
+
+This is useful for:
+- **Batch size optimization** before deployment
+- **Hardware cost estimation** for training runs
+- **NAS (Neural Architecture Search)** — filtering architectures by predicted cost
+
+---
+
+## Architecture
+
+```
+PyTorch Model
+      │
+      ▼
+┌─────────────────────┐
+│  Feature Extractor  │  ← layer counts, FLOPs, params, depth, width, skip connections
+│  + GNN Extractor    │  ← graph-based architecture encoding (ArchitectureGNN)
+└─────────┬───────────┘
+          │
+          ▼
+┌─────────────────────┐
+│  Prediction Models  │
+│  ─────────────────  │
+│  · XGBoost (tuned)  │  ← main predictor (best MAPE)
+│  · Random Forest    │  ← ensemble comparison
+│  · GNN Predictor    │  ← graph-native, generalizes across architectures
+│  · Linear / Ridge   │  ← baselines
+└─────────┬───────────┘
+          │
+          ▼
+   Predicted: execution_time_ms, memory_mb
+   + Uncertainty bounds (lower / upper)
+```
+
+---
+
+## Project Structure
+
+```
+Blink/
+├── dashboard.py             # 🖥️  Main Streamlit web app  (run this)
+├── prediction_api.py        # 🌐  Flask REST API
+│
+├── ── Core ML Modules ──
+│   ├── model_profiler.py    # GPU profiler (CUDA events)
+│   ├── feature_extractor.py # Static feature extraction from nn.Module
+│   ├── gnn_extractor.py     # GNN-based graph feature extraction
+│   ├── gnn_model.py         # ArchitectureGNN model definition (PyG)
+│   ├── prediction_model.py  # Train XGBoost / RF / Linear models
+│   ├── train_gnn.py         # Train the GNN predictor
+│   ├── train_memory_model.py# Train memory prediction model
+│   ├── gpu_predictor.py     # Inference class with caching & batch support
+│   ├── model_analyser.py    # Model complexity analysis utilities
+│   ├── advanced_features.py # Extended feature engineering
+│   ├── dynamic_predictor.py # Dynamic / online prediction
+│   ├── gpu_info.py          # GPU metadata (pynvml)
+│   ├── workload_scheduler.py# Batch workload scheduler
+│   └── performance_monitor.py
+│
+├── scripts/                 # 🔬  Experiment & data scripts
+│   ├── collect_data.py      # Profile CNN/Transformer/custom models → data/raw/
+│   ├── enhance_dataset.py   # Augment dataset (more batch sizes / models)
+│   ├── diverse_architectures.py  # Profile diverse arch families
+│   ├── ablation_study.py    # 5-condition ablation (Table II in paper)
+│   ├── generate_paper_figures.py # Reproduce all paper figures
+│   └── generate_paper_tables.py  # Reproduce paper tables
+│
+├── tests/                   # ✅  Test suite
+│   ├── test_diverse_models.py
+│   ├── test_predictors.py
+│   ├── test_profiler.py
+│   ├── test_gnn_scaling.py
+│   └── evaluate_gnn_vs_xgb.py
+│
+├── data/
+│   ├── raw/                 # Raw profiling CSVs (gitignored)
+│   ├── processed/           # Feature-engineered CSVs
+│   ├── enriched/            # Final training-ready dataset
+│   └── feedback_log.csv     # Online feedback loop log
+│
+├── models/                  # Serialized model artifacts (gitignored)
+│   ├── xgboost_(tuned)_model.joblib
+│   ├── random_forest_model.joblib
+│   ├── gnn_predictor.pth
+│   ├── memory_model.joblib
+│   └── ...
+│
+├── results/
+│   ├── figures/             # Paper figures (PNG)
+│   ├── ablation_study_table.csv
+│   ├── gnn_scaling_table.csv
+│   └── ...
+│
+├── templates/index.html     # HTML template for web interface
+├── legacy/                  # Archived / superseded scripts
+├── requirements.txt
+└── .gitignore
+```
+
+---
+
+## Installation
+
+```bash
+# 1. Clone the repo
+git clone <your-repo-url>
+cd Blink
+
+# 2. Create a virtual environment
+python -m venv venv
+venv\Scripts\activate        # Windows
+# source venv/bin/activate   # Linux/macOS
+
+# 3. Install dependencies
+pip install -r requirements.txt
+
+# 4. Install PyTorch Geometric (match your CUDA version)
+# See: https://pytorch-geometric.readthedocs.io/en/latest/install/installation.html
+pip install torch-geometric
+```
+
+**Requirements:** NVIDIA GPU with CUDA, Python ≥ 3.10
+
+---
+
+## Usage
+
+### 1. Launch the Dashboard
+```bash
+streamlit run dashboard.py
+```
+Features: live model prediction, batch size optimizer, model comparison, performance monitor.
+
+### 2. Collect Profiling Data
+```bash
+python scripts/collect_data.py --batch-sizes 1 4 16 32 64
+```
+
+### 3. Train Prediction Models
+```bash
+# Train XGBoost / RF / Linear baseline models
+python prediction_model.py
+
+# Train GNN predictor
+python train_gnn.py
+
+# Train memory model
+python train_memory_model.py
+```
+
+### 4. Run Ablation Study
+```bash
+python scripts/ablation_study.py
+```
+
+### 5. Predict via Python API
+```python
+from gpu_predictor import GPUPredictor
+import torchvision.models as models
+
+predictor = GPUPredictor()
+model = models.resnet50(pretrained=False)
+result = predictor.predict_for_custom_model(model, batch_size=16)
+print(result)
+# {'execution_time_ms': 12.4, 'memory_mb': 1820, 'confidence_lower': 11.1, ...}
+```
+
+---
+
+## Data Pipeline
+
+```
+collect_data.py
+    └─▶ data/raw/*.csv          (GPU profiling measurements)
+            │
+            ▼
+feature_extractor.py
+    └─▶ data/processed/*.csv    (static model features)
+            │
+            ▼
+enhance_dataset.py
+    └─▶ data/enriched/*.csv     (augmented, training-ready)
+            │
+            ▼
+prediction_model.py / train_gnn.py
+    └─▶ models/                 (trained predictors)
+```
+
+---
+
+## Model Performance
+
+Results on held-out test set (20% split):
+
+| Model | Exec Time MAPE | Memory MAPE | Notes |
+|---|---|---|---|
+| XGBoost (tuned) | ~8% | ~6% | Best overall |
+| Random Forest | ~11% | ~9% | Robust baseline |
+| GNN Predictor | ~10% | ~8% | Best on unseen architectures |
+| Linear Regression | ~22% | ~19% | Baseline |
+
+*(Full ablation study results: `results/ablation_study_table.csv`)*
+
+---
+
+## Dashboard
+
+The Streamlit dashboard (`dashboard.py`) provides:
+
+| Tab | Description |
+|---|---|
+| 🎯 Prediction | Predict execution time & memory for standard or custom models |
+| ⚡ Batch Optimizer | Find optimal batch size within a memory budget |
+| 📊 Model Comparison | Compare predictions across multiple architectures |
+| 📈 Performance Monitor | Live GPU utilization and prediction history |
+
+---
+
+## Paper Reproducibility
+
+To reproduce all paper figures and tables:
+```bash
+python scripts/generate_paper_figures.py
+python scripts/generate_paper_tables.py
+python scripts/ablation_study.py
+```
+Outputs saved to `results/figures/`.
+
+---
+
+## License
+
+MIT License — see [LICENSE](LICENSE) for details.

blink_gpu-0.1.0.dist-info/RECORD

@@ -0,0 +1,11 @@
+blink/__init__.py,sha256=UDhgI4dDpgE1Q3YVLm74C52xHua6Hefk9BGfjwRi1mY,905
+blink/__main__.py,sha256=mXMtOZ4oRM3RYFJC09QjPZar2THUA17o0iw9vELk8pw,5209
+blink/_analyzer.py,sha256=3i0CDjSdvAM2GFPVilbQi2WXPN7bUpdqudHKt7SxAUQ,3009
+blink/_predictor.py,sha256=wcvqUS_oFwsu0jpTT7_llP6DPbU12-Wq-0NFuaxjLLg,6053
+blink/_version.py,sha256=QTYqXqSTHFRkM9TEgpDFcHvwLbvqHDqvqfQ9EiXkcAM,23
+blink/py.typed,sha256=lXMgLeTOnHBTwAn-DccqgnOKJtar2iZt2pXnesWpLfg,78
+blink_gpu-0.1.0.dist-info/METADATA,sha256=8iiaw8VyMirwvwUhv6G7CnwbLWCBePpCcieQJQKl4eU,10656
+blink_gpu-0.1.0.dist-info/WHEEL,sha256=YCfwYGOYMi5Jhw2fU4yNgwErybb2IX5PEwBKV4ZbdBo,91
+blink_gpu-0.1.0.dist-info/entry_points.txt,sha256=UdF6SJDELNZ97RJGcoxSRmoNYXnSe_KbIwaGkkiC0Gw,82
+blink_gpu-0.1.0.dist-info/top_level.txt,sha256=sU9Oyo7qzPcr4N7WRlLbNaNIJxCBOcWERCHfjqincMQ,6
+blink_gpu-0.1.0.dist-info/RECORD,,

blink_gpu-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

blink_gpu-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+blink = blink.__main__:main
+blink-server = blink.__main__:serve

blink_gpu-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+blink