Initial commit;

.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

README.md

@@ -1,15 +1,347 @@
 ---
-title: Wattgpu
-emoji: 💻
+title: WattGPU
+emoji: ⚡
 colorFrom: green
-colorTo: purple
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.26.0
-python_version: '3.12'
+sdk_version: 5.49.1
 app_file: app.py
 pinned: false
 license: apache-2.0
-short_description: Estimate energy, emissions, and latency for LLMs on GPUs
+short_description: Predict LLM inference power and latency on any GPU
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# WattGPU demo
+
+Predict the **mean GPU power draw** and **inter-token latency** of serving an LLM,
+without profiling it and without access to the hardware.
+
+A research demo by [Leaner AI](https://leaner-ai.com), built on the models from
+[*WattGPU: Predicting Inference Power and Latency on Unseen GPUs and
+LLMs*](https://arxiv.org/abs/2607.02391) (1st Workshop on Sustainability and
+Resource-Efficiency of AI @ IJCAI 2026).
+
+Search any model on the Hugging Face Hub and pick any GPU:
+
+- the LLM's architecture is read from its `config.json` on the Hub and adapted
+  to WattGPU's feature schema by `llm_info_from_config`, with the parameter
+  count taken from the Hub's safetensors index;
+- the GPU's specifications come from a [dbgpu](https://github.com/painebenjamin/dbgpu)-derived
+  database, restricted to NVIDIA — every profiled run used NVIDIA hardware under
+  vLLM, and the hardware features the models lean on do not carry across to
+  other vendors' matrix engines. The dropdown lists only the measured GPUs;
+  typing searches the rest of the database.
+
+## Operational scenario
+
+The dataset contains exactly two server request rates plus an offline setting,
+so these are three **measured operating points**, not ranges. Converted at a
+typical one message per minute per active user (0.017 requests/s each):
+
+| Setting | Request rate | ≈ concurrent users | Paper scenario |
+|---|---|---|---|
+| Low load — a single concurrent user | 0.017 /s | ~1 | `server_low` |
+| Medium load — about 20 concurrent users | 0.330 /s | ~20 | `server_high` |
+| Offline / batch | work always queued | — | `offline` |
+
+A fully saturated server keeps its GPU continuously busy just as a batch job
+does, so the **offline / batch power figure is a reasonable estimate for a
+saturated server** too, and its throughput is the ceiling the pair can sustain.
+Per-user responsiveness does not carry over.
+
+Where load tips into saturation is a property of the whole deployment — model
+size against memory bandwidth, prompt and response lengths, how the server
+batches concurrent requests, how bursty arrivals are — so the demo cannot locate
+it. `scenario` enters the model as one of three categories, with no
+interpolation to an arbitrary request rate.
+
+### What the latency target means, and where throughput comes from
+
+Under **low and medium load** the dataset times individual requests, so the model
+predicts a genuine **inter-token latency**: the gap one user sees between tokens.
+System throughput cannot be recovered from it without knowing how many requests
+run at once, so it is not reported.
+
+**Offline** the dataset times only the batch as a whole, so the target is
+wall-clock time per token across every request in flight. **Throughput is
+reported as the exact inverse of that estimate** — no assumption about batching
+needed. For Llama-3.1-8B on an H200 that is 29,245 tok/s aggregate, against a
+per-user 5.08 ms between tokens under load: the two are ~150× apart because
+roughly that many requests are being served at once. Because the offline figure
+is measured across the whole batch rather than per request, it cannot be used to
+derive the inter-token latency an individual user would see on a server, and the
+UI says so.
+
+Energy per token is `mean power ÷ throughput`, and so is reported offline only.
+
+## The certainty tier
+
+Every prediction is labelled by how far it sits from the 42 LLMs and 8 GPUs that
+were actually profiled:
+
+| Tier | Meaning | Validation protocol |
+|---|---|---|
+| 🟢 High | Both LLM and GPU in the training data | 5-fold grouped CV |
+| 🟡 Moderate | LLM not in training data, GPU is | leave-one-LLM-out |
+| 🟠 Lower | GPU not in training data, LLM is | leave-one-GPU-out |
+| 🟠 Lower | Neither in the training data, under server load | double holdout (both removed) |
+| 🔴 Low | Neither in the training data, offline / batch | double holdout (both removed) |
+
+The first three protocols are the paper's. The **double holdout** is an
+extension added here: for each of the 262 measured pairs, the model is retrained
+with that GPU *and* that LLM removed entirely, then asked to predict the pair.
+It is what lets the lowest tier carry a measured error rather than an
+unvalidated guess.
+
+Each prediction shows the median absolute percentage error (MdAPE) measured
+under exactly the protocol that matches its tier, split by offline and server
+operation:
+
+| | Power (offline / server) | ITL (offline / server) |
+|---|---|---|
+| 🟢 | 1.4% / 5.7% | 12.7% / 4.9% |
+| 🟡 | 1.9% / 6.8% | 15.6% / 5.6% |
+| 🟠 | 3.9% / 13.0% | 24.9% / 8.5% |
+| 🔴 | 3.9% / 15.1% | 36.2% / 8.6% |
+
+Dropping the LLM as well as the GPU costs surprisingly little: the hardware axis
+dominates the difficulty, so once a GPU is held out, also holding out the model
+adds a few points rather than breaking the estimate. Offline latency is the
+exception, where it goes from 24.9% to 36.2%.
+
+That is why the hardest case appears in two bands. Under server load the double
+holdout tracks leave-one-GPU-out closely enough to share the orange band;
+offline it does not, and drops to red. The band is presentational — the error
+quoted is always the one measured for the actual coverage, so a both-unseen pair
+shown in orange still reports the double-holdout figure (15.1%, not 13.0%).
+
+Requests outside the models' scope are refused rather than tiered:
+mixture-of-experts and quantised models, embedding and reranking models, and
+pairs whose weights do not fit in GPU memory.
+
+## Accuracy reported in the paper
+
+Tables 2 and 3 of the paper, reproduced by `scripts/train_models.py`. τ is
+Kendall's tau over the induced ranking of GPUs and of LLMs — how reliably the
+model puts hardware, and models, in the right order.
+
+**Mean power draw (Table 2)**
+
+| Model | Scenario | Strategy | MdAPE | Pearson r | GPU τ | LLM τ |
+|---|---|---|---|---|---|---|
+| XGBoost | Offline | CV | **1.6%** | 0.992 | 0.96 | 0.44 |
+| XGBoost | Offline | LOGO | **3.4%** | 0.988 | 0.95 | 0.40 |
+| XGBoost | Offline | LOLO | **2.0%** | 0.979 | 0.97 | 0.33 |
+| XGBoost | Server | CV | **5.5%** | 0.981 | 0.86 | 0.68 |
+| XGBoost | Server | LOGO | **13.5%** | 0.965 | 0.76 | 0.72 |
+| XGBoost | Server | LOLO | **6.7%** | 0.955 | 0.85 | 0.54 |
+| TDP baseline | Offline | — | 4.4% | 0.916 | 0.96 | — |
+| TDP baseline | Server | — | 190.1% | 0.590 | 0.60 | — |
+| Least-squares TDP | Offline | — | 7.2% | 0.916 | 0.96 | — |
+| Least-squares TDP | Server | — | 26.0% | 0.779 | 0.60 | — |
+
+Assuming a GPU draws its TDP is roughly adequate offline, where a saturated GPU
+does sit near its power limit, and badly wrong under server load (190% error).
+
+**Inter-token latency (Table 3)**
+
+| Model | Scenario | Strategy | MdAPE | Pearson r | GPU τ | LLM τ |
+|---|---|---|---|---|---|---|
+| XGBoost | Offline | CV | **12.8%** | 0.813 | 0.86 | 0.81 |
+| XGBoost | Offline | LOGO | **24.9%** | 0.727 | 0.72 | 0.83 |
+| XGBoost | Offline | LOLO | **15.6%** | 0.808 | 0.97 | 0.66 |
+| XGBoost | Server | CV | **4.9%** | 0.991 | 0.94 | 0.89 |
+| XGBoost | Server | LOGO | **8.5%** | 0.972 | 0.78 | 0.88 |
+| XGBoost | Server | LOLO | **5.6%** | 0.990 | 0.97 | 0.88 |
+| Roofline baseline | Offline | — | 80.2% | 0.545 | 0.82 | 0.61 |
+| Roofline baseline | Server | — | 29.6% | 0.991 | 0.88 | 0.91 |
+
+Latency is harder offline, where throughput depends on how vLLM batches
+requests. The roofline baseline tracks the ordering well but is off by 80% in
+magnitude offline, because it ignores batching entirely.
+
+CV rows correspond to the green tier, LOLO to yellow, LOGO to orange.
+
+## Running it
+
+```bash
+uv venv --python 3.12
+source .venv/bin/activate
+uv pip install -r requirements.txt
+python app.py
+```
+
+The repository ships the trained models and the GPU database, so this is all
+that is needed. To rebuild them from the paper's data in `../data`:
+
+```bash
+python scripts/build_gpu_db.py    # GPU specifications, from dbgpu
+python scripts/train_models.py    # fit the models and measure tier accuracy
+```
+
+No Hugging Face token is needed. Licence-gated models work anyway, in two ways:
+the 42 measured LLMs ship with their architectures, and a handful of popular
+gated models are cached separately by reading a **public, unquantised mirror**
+of the same weights:
+
+```bash
+python scripts/cache_gated_models.py    # writes data/gated_llms.json
+```
+
+Only the integers WattGPU needs are stored — layer count, hidden size, head
+counts, parameter count — all of which are published in the model cards and
+papers, so nothing gated is redistributed. Each entry records the mirror it came
+from, so any value can be traced. Being in this cache says only that the
+architecture is known offline; those models still land in the certainty tier
+their coverage earns, which for all of them is 🟡.
+
+### Tokens
+
+A token is only needed for a gated model that is not bundled, or when the Hub
+rate-limits the deployment's IP. Two ways to supply one:
+
+- **Per visitor.** A masked field, *Use your own Hugging Face token*, sits with
+  the accordions below the estimate. The token is used for that request and
+  discarded: never stored, logged, rendered, or put into a shared link, and
+  Gradio analytics are disabled so nothing leaves the deployment. The gated and
+  rate-limit error messages point at this field.
+- **Per deployment.** `HF_TOKEN` or `HUGGING_FACE_HUB_TOKEN` in the environment,
+  which every visitor then shares. A visitor's own token takes precedence.
+
+Use read-only tokens in both cases.
+
+## Layout
+
+| Path | What it is |
+|---|---|
+| `app.py` | Gradio UI and result rendering |
+| `wattgpu_demo/hf_models.py` | Hub search, and the `config.json` → features adapter |
+| `wattgpu_demo/gpu_db.py` | GPU specification look-ups |
+| `wattgpu_demo/features.py` | feature engineering, shared by training and inference |
+| `wattgpu_demo/predictor.py` | prediction and certainty tiers |
+| `scripts/build_gpu_db.py` | builds `data/gpu_database.csv` from dbgpu |
+| `scripts/train_models.py` | fits the models, writes `data/models/` |
+| `scripts/cache_gated_models.py` | caches gated architectures from public mirrors |
+| `wattgpu_demo/demand_log.py` | records refused queries as a coverage roadmap |
+| `assets/leaner-ai-logo.svg` | Leaner AI wordmark, inlined in the header |
+| `tests/test_demo.py` | tests, including all four tiers |
+
+## Tests
+
+```bash
+pytest                     # everything
+pytest -m "not network"    # skip the tests that reach the Hub
+```
+
+## What is out of scope
+
+Every measurement behind WattGPU used a **dense** model with **FP16** weights,
+on a single GPU under vLLM with 512-token prompts. Two model families are
+therefore refused outright rather than estimated:
+
+- **Mixture-of-experts**, detected from `num_local_experts`, `num_experts`,
+  `n_routed_experts`, `moe_intermediate_size` and friends, or from a `*MoE*`
+  architecture name.
+- **Quantised weights**, detected from `quantization_config` (GPTQ, AWQ,
+  bitsandbytes, compressed-tensors, FP8…), from a non-16-bit `torch_dtype` /
+  `dtype`, or, as a fallback, from markers such as `gptq`, `awq`, `-4bit` or
+  `fp8` in the repository name.
+
+Detection is reliable but not infallible — a repository can quantise without
+declaring it — so every estimate for a model that was not measured carries a
+note saying the architecture was read from `config.json` and what that implies.
+
+A pair whose **weights do not fit in GPU memory** is refused too, rather than
+estimated. The budget follows the paper's own feature engineering: vLLM claims
+90% of the card by default, and the FP16 weights come out of that, so a model
+fits when `0.9 × memory_size_gb − 2 × total_b_params > 0`. No pair in the
+dataset is refused by this rule — all 262 measured combinations pass — which is
+what pins the threshold; anything stricter would start contradicting runs that
+actually completed. Pairs that fit with under 2 GB to spare still get an
+estimate, plus a warning that the KV cache has little room and the figure will
+be optimistic.
+
+Quantised, multi-GPU and long-context deployments are all outside what the
+models were fitted on.
+
+## Energy and emissions
+
+Every energy figure is at the **facility level**. The models predict the GPU
+board's draw; that is grossed up to the whole host (the GPU taken as 70% of it,
+the rest being CPU, memory, storage, NICs and fans) and multiplied by a
+data-centre PUE of 1.2:
+
+```
+facility watts = GPU watts ÷ 0.7 × 1.2
+```
+
+Both factors are typical values rather than measurements. The same scaling is
+applied in every scenario, so the offline and server numbers describe one system
+boundary and can be compared.
+
+**Offline / batch reports per million tokens.** The GPU is saturated, so every
+joule is attributable to a token and energy per token is a stable property of
+the model and the hardware. Llama-3.1-8B on an H200 comes to 9.1 Wh per million
+tokens.
+
+**Server load reports per hour.** There the GPU spends much of its time waiting
+for the next request, so energy per token would mostly reflect how busy the
+server happens to be rather than anything about the model or the card. What an
+operator can act on is the draw of keeping the deployment up: 109 W on the card
+is about 187 W at the wall, or 187 Wh per hour. This split follows the paper's
+own reasoning.
+
+Emissions are the energy figure times one visible multiplier, the grid's carbon
+intensity, defaulting to **240 gCO₂e/kWh** (roughly the EU average). Real
+intensity varies by an order of magnitude between regions and by the hour within
+one, so the field links to
+[Electricity Maps](https://app.electricitymaps.com/map/live/fifteen_minutes).
+Clearing the box restores the default and writes it back, so the field never
+disagrees with the result.
+
+All of this lives in a collapsed **Assumptions** panel below the estimate rather
+than on every result.
+
+Cost is deliberately not included: prices depend on provider and region and go
+stale, whereas the energy figure needs no maintenance.
+
+## Sharing a result
+
+Every estimate carries a prominent **Share** button next to the certainty tier.
+It copies an absolute link to that exact estimate — `?model=…&gpu=…&scenario=…`,
+plus `carbon=` when the intensity is not the default — and confirms with a brief
+"Link copied". On devices that have a native share sheet it opens that instead.
+
+The button stores a *relative* href, resolved against the current page in the
+browser, so it works at any deployed URL without the server knowing what that
+URL is. Opening the link fills the form in and runs the estimate; values are
+validated against the catalogues on load, so a hand-edited link cannot put the
+form into a state the app would not otherwise reach.
+
+## Demand log
+
+Refusals that represent real unmet coverage — mixture-of-experts, quantised,
+non-generative, and pairs that do not fit — are appended to
+`data/demand_log.jsonl` as `{at, model, gpu, scenario, reason}`. Typos and
+unreachable repositories are not logged, since they say nothing about demand.
+Nothing identifying the requester is stored, and the footer discloses it.
+
+```bash
+python -c "from wattgpu_demo.demand_log import summarise; print(*summarise(), sep='\n')"
+```
+
+Set `WATTGPU_DEMAND_LOG` to choose the path, or `WATTGPU_DEMAND_LOG_DISABLED=1`
+to turn it off. On Hugging Face Spaces the container filesystem is ephemeral, so
+point `WATTGPU_DEMAND_LOG` at persistent storage or a mounted dataset repo if
+the log needs to survive restarts.
+
+## Links
+
+- [Leaner AI](https://leaner-ai.com)
+- [The paper](https://arxiv.org/abs/2607.02391)
+- [Watt Counts](https://arxiv.org/abs/2604.09048) — the measurement dataset
+- [Source](https://github.com/maufadel/wattgpu)
+
+## Licence
+
+Apache 2.0, as the parent repository.

app.py

@@ -0,0 +1,1105 @@
+"""WattGPU — predict LLM inference power and latency on a GPU you don't have.
+
+A Gradio front end over the models from "WattGPU: Predicting Inference Power
+and Latency on Unseen GPUs and LLMs" (SuRE @ IJCAI 2026). Pick any Hugging
+Face model and any GPU; the app reads the model's `config.json` from the Hub
+and the GPU's specifications from a dbgpu-derived database, and returns mean
+power draw and inter-token latency together with a certainty tier.
+
+Run locally:  python app.py
+"""
+
+from __future__ import annotations
+
+import html
+import os
+import re
+import traceback
+import urllib.parse
+
+import gradio as gr
+
+from wattgpu_demo import demand_log
+from wattgpu_demo.emissions import (
+    DEFAULT_CARBON_INTENSITY_G_PER_KWH,
+    DEFAULT_CARBON_INTENSITY_LABEL,
+    DEFAULT_PUE,
+    ELECTRICITY_MAPS_URL,
+    GPU_SHARE_OF_HOST_POWER,
+    MAX_CARBON_INTENSITY,
+    MIN_CARBON_INTENSITY,
+    clean_carbon_intensity,
+    format_co2,
+    format_energy,
+)
+from wattgpu_demo.errors import (
+    GPUNotFoundError,
+    InsufficientMemoryError,
+    ModelConfigError,
+    ModelNotFoundError,
+    UnsupportedModelError,
+    WattGPUError,
+)
+from wattgpu_demo.features import SCENARIO_LABELS, SCENARIOS
+from wattgpu_demo.hf_models import has_hf_token, search_models
+from wattgpu_demo.predictor import Prediction, WattGPUPredictor
+
+PAPER_TITLE = "WattGPU: Predicting Inference Power and Latency on Unseen GPUs and LLMs"
+PAPER_VENUE = "1st Workshop on Sustainability and Resource-Efficiency of AI @ IJCAI 2026"
+PAPER_URL = "https://arxiv.org/abs/2607.02391"
+LEANER_AI_URL = "https://leaner-ai.com"
+CODE_URL = "https://github.com/maufadel/wattgpu"
+# The measurement dataset the models were fitted on.
+WATT_COUNTS_URL = "https://arxiv.org/abs/2604.09048"
+CONTACT_URL = "https://leaner-ai.com/#report-form"
+
+ASSETS_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "assets")
+
+# Four confidence tiers, plus a visually distinct marker for refusals — being
+# out of scope is not a low confidence level, it is a different kind of answer.
+TIER_GLYPHS = {"green": "●", "yellow": "●", "orange": "●", "red": "●", "error": "■"}
+
+# Injected into the page head. The share button is rendered inside a Gradio HTML
+# component, which is replaced on every estimate, so the handler has to live
+# outside it rather than in a <script> beside the button.
+HEAD = """
+<script>
+window.wgShare = async function (button) {
+  const url = new URL(button.getAttribute("data-href"), window.location.href).href;
+  const label = button.querySelector(".wg-share-label");
+  const original = label.textContent;
+
+  const flash = (text) => {
+    label.textContent = text;
+    button.classList.add("wg-shared");
+    setTimeout(() => {
+      label.textContent = original;
+      button.classList.remove("wg-shared");
+    }, 2000);
+  };
+
+  // Native share sheet where there is one (phones, some desktops).
+  if (navigator.share) {
+    try {
+      await navigator.share({ title: "WattGPU estimate", url: url });
+      return;
+    } catch (err) {
+      if (err && err.name === "AbortError") return;  // user dismissed it
+    }
+  }
+
+  try {
+    await navigator.clipboard.writeText(url);
+    flash("Link copied");
+    return;
+  } catch (err) {
+    // clipboard needs a secure context; fall back to a scratch textarea
+  }
+
+  const scratch = document.createElement("textarea");
+  scratch.value = url;
+  scratch.setAttribute("readonly", "");
+  scratch.style.position = "fixed";
+  scratch.style.opacity = "0";
+  document.body.appendChild(scratch);
+  scratch.select();
+  let copied = false;
+  try {
+    copied = document.execCommand("copy");
+  } catch (err) {
+    copied = false;
+  }
+  scratch.remove();
+  flash(copied ? "Link copied" : "Press Ctrl+C to copy");
+};
+</script>
+"""
+
+CSS = """
+/* --- Leaner AI palette -------------------------------------------------
+   Brand sky #38bdf8 (hover #0284c7), ink #0f172a, muted #64748b, and the
+   brand gradient sky -> green -> violet used on leaner-ai.com. Tier accents
+   stay semantic but are drawn from the same family, with a dark variant each
+   because Gradio toggles dark mode with a `.dark` class. */
+.gradio-container {
+  --wg-brand: #0284c7;
+  --wg-brand-soft: #38bdf8;
+  --wg-ink: #0f172a;
+  --wg-muted: #64748b;
+  --wg-gradient: linear-gradient(90deg, #38bdf8 0%, #22c55e 50%, #a78bfa 100%);
+}
+.dark .gradio-container, .gradio-container.dark {
+  --wg-brand: #38bdf8;
+  --wg-brand-soft: #7dd3fc;
+  --wg-ink: #f8fafc;
+  --wg-muted: #94a3b8;
+}
+
+.wg-green  { --wg-accent: #15803d; }
+.wg-yellow { --wg-accent: #a16207; }
+.wg-orange { --wg-accent: #c2410c; }
+.wg-red    { --wg-accent: #be123c; }
+.wg-error  { --wg-accent: #475569; }
+.dark .wg-green  { --wg-accent: #22c55e; }
+.dark .wg-yellow { --wg-accent: #eab308; }
+.dark .wg-orange { --wg-accent: #fb923c; }
+.dark .wg-red    { --wg-accent: #fb7185; }
+.dark .wg-error  { --wg-accent: #94a3b8; }
+
+/* --- Header ----------------------------------------------------------- */
+.wg-header { display: flex; align-items: center; justify-content: space-between;
+             flex-wrap: wrap; gap: 14px; padding: 4px 0 10px; }
+.wg-header .wg-brandmark { display: flex; align-items: center; gap: 12px; }
+.wg-header .wg-brandmark svg { height: 26px; width: auto; display: block; }
+.wg-header .wg-eyebrow { font-size: 12px; letter-spacing: .08em; text-transform: uppercase;
+                         color: var(--wg-muted); border-left: 1px solid var(--border-color-primary);
+                         padding-left: 12px; }
+.wg-links { display: flex; gap: 8px; flex-wrap: wrap; }
+.wg-links a { display: inline-flex; align-items: center; gap: 6px; text-decoration: none;
+              font-size: 13px; font-weight: 600; padding: 6px 12px; border-radius: 999px;
+              border: 1px solid var(--border-color-primary); color: var(--wg-brand);
+              background: var(--background-fill-secondary); transition: .15s; }
+.wg-links a:hover { border-color: var(--wg-brand); color: var(--wg-brand);
+                    background: color-mix(in srgb, var(--wg-brand) 12%, transparent); }
+.wg-title-bar { height: 3px; border-radius: 3px; background: var(--wg-gradient);
+                margin: 0 0 18px; }
+
+/* --- Result --------------------------------------------------------- */
+.wg-chip { display: inline-flex; align-items: center; gap: 7px; margin-bottom: 12px;
+           padding: 5px 13px; border-radius: 999px; font-size: 13px; font-weight: 700;
+           color: var(--wg-accent); border: 1px solid var(--wg-accent);
+           background: color-mix(in srgb, var(--wg-accent) 12%, transparent); }
+
+.wg-details { margin-top: 14px; }
+.wg-details > summary { cursor: pointer; font-size: 13px; font-weight: 600;
+                        color: var(--wg-muted); padding: 6px 0; list-style-position: outside; }
+.wg-details > summary:hover { color: var(--wg-brand); }
+.wg-details[open] > summary { margin-bottom: 10px; }
+
+.wg-banner { border-radius: 10px; padding: 14px 16px; margin-bottom: 14px;
+             border-left: 6px solid var(--wg-accent); font-size: 15px;
+             background: color-mix(in srgb, var(--wg-accent) 10%, var(--background-fill-secondary));
+             color: var(--body-text-color); }
+.wg-banner .wg-title { font-weight: 700; margin-bottom: 4px; color: var(--wg-accent); }
+.wg-banner .wg-body { font-size: 14px; line-height: 1.55; color: var(--body-text-color); }
+.wg-cards { display: flex; gap: 12px; flex-wrap: wrap; margin-bottom: 14px; }
+.wg-card { flex: 1 1 190px; border: 1px solid var(--border-color-primary);
+           border-top: 3px solid var(--wg-brand-soft); border-radius: 10px; padding: 13px 16px;
+           background: var(--background-fill-secondary); color: var(--body-text-color); }
+.wg-card .wg-label { font-size: 12px; text-transform: uppercase; letter-spacing: .05em;
+                     color: var(--wg-muted); margin-bottom: 6px; }
+.wg-card .wg-value { font-size: 26px; font-weight: 700; line-height: 1.15; color: var(--wg-ink); }
+.wg-card .wg-sub { font-size: 12px; color: var(--wg-muted);
+                   margin-top: 6px; line-height: 1.4; }
+.wg-note { border-radius: 8px; padding: 10px 14px; margin-bottom: 8px; font-size: 13.5px;
+           background: var(--background-fill-secondary); color: var(--body-text-color);
+           border-left: 4px solid var(--wg-brand-soft); line-height: 1.55; }
+.wg-specs { display: flex; gap: 26px; flex-wrap: wrap; font-size: 13.5px;
+            margin-top: 4px; color: var(--body-text-color); }
+.wg-specs table { border-collapse: collapse; }
+.wg-specs td { padding: 3px 14px 3px 0; vertical-align: top; }
+.wg-specs td:first-child { color: var(--wg-muted); white-space: nowrap; }
+.wg-specs h4 { margin: 0 0 6px; font-size: 12px; text-transform: uppercase;
+               letter-spacing: .05em; color: var(--wg-muted); }
+.wg-banner code, .wg-note code { background: var(--background-fill-primary);
+                                 padding: 1px 5px; border-radius: 4px; font-size: .92em; }
+
+.wg-result-head { display: flex; align-items: center; justify-content: space-between;
+                  gap: 12px; flex-wrap: wrap; margin-bottom: 12px; }
+.wg-result-head .wg-chip { margin-bottom: 0; }
+/* Scoped through .gradio-container so Gradio's own button reset, which sets
+   background, colour, padding and weight on every button, does not win. */
+/* Matches the primary button: white on sky-500 in both themes. */
+.gradio-container button.wg-share {
+  display: inline-flex; align-items: center; gap: 7px; cursor: pointer;
+  font-family: inherit; font-size: 13px; font-weight: 600; line-height: 1.2;
+  padding: 8px 16px; border-radius: 999px; border: 1px solid #0ea5e9;
+  color: #fff; background: #0ea5e9; box-shadow: none; transition: .15s;
+}
+.gradio-container button.wg-share:hover { filter: brightness(1.08); }
+.gradio-container button.wg-share:active { transform: translateY(1px); }
+.gradio-container button.wg-share.wg-shared,
+.dark .gradio-container button.wg-share.wg-shared {
+  background: #15803d; border-color: #15803d; color: #fff;
+}
+
+.wg-note-quiet { border-left-color: var(--border-color-primary);
+                 color: var(--wg-muted); font-size: 13px; }
+
+.wg-scenario-head { display: flex; align-items: baseline; gap: 14px; flex-wrap: wrap;
+                    margin: 6px 0 -4px; }
+.wg-scenario-title { font-size: 14px; font-weight: 600; color: var(--body-text-color); }
+
+.wg-loadhelp { margin: 0; }
+.wg-loadhelp > summary { cursor: pointer; display: flex; align-items: center; gap: 8px;
+                         font-size: 13px; font-weight: 600; color: var(--wg-muted);
+                         padding: 4px 0; list-style: none; }
+.wg-loadhelp > summary::-webkit-details-marker { display: none; }
+.wg-loadhelp > summary:hover { color: var(--wg-brand); }
+.wg-q { display: inline-flex; align-items: center; justify-content: center;
+        width: 17px; height: 17px; border-radius: 50%; font-size: 11px; font-weight: 700;
+        border: 1px solid currentColor; flex: none; }
+.wg-loadhelp-body { font-size: 13px; color: var(--body-text-color); line-height: 1.65;
+                    border-left: 3px solid var(--wg-brand-soft); padding: 2px 0 2px 14px;
+                    margin: 6px 0 4px; }
+.wg-loadhelp-body p { margin: 0 0 9px; }
+.wg-loadhelp-body ul { margin: 0 0 9px; padding-left: 20px; }
+.wg-loadhelp-body li { margin-bottom: 3px; }
+.wg-loadhelp-body pre { margin: 0 0 9px; padding: 8px 11px; border-radius: 6px;
+                        background: var(--background-fill-secondary); font-size: 12.5px;
+                        white-space: pre-wrap; }
+.wg-loadhelp-body code { background: var(--background-fill-secondary);
+                         padding: 1px 5px; border-radius: 4px; font-size: .92em; }
+
+/* --- Footer ----------------------------------------------------------- */
+.wg-footer { margin-top: 22px; padding-top: 14px; font-size: 13px; color: var(--wg-muted);
+             border-top: 1px solid var(--border-color-primary); line-height: 1.6; }
+.wg-footer a { color: var(--wg-brand); text-decoration: none; font-weight: 600; }
+.wg-footer a:hover { text-decoration: underline; }
+.wg-footer p { margin: 0 0 9px; }
+.wg-footer .wg-legal { font-size: 11.5px; line-height: 1.55; opacity: .85; }
+"""
+
+# ---------------------------------------------------------------------------
+# Rendering
+# ---------------------------------------------------------------------------
+
+def _banner(tier: str, title: str, body: str) -> str:
+    """Tier banner. Colours come from the CSS classes so both themes work."""
+    return (
+        f'<div class="wg-banner wg-{tier}">'
+        f'<div class="wg-title">{TIER_GLYPHS[tier]} {html.escape(title)}</div>'
+        f'<div class="wg-body">{body}</div></div>'
+    )
+
+
+def _chip(tier: str, label: str) -> str:
+    """Compact certainty marker shown above the numbers."""
+    return (f'<div class="wg-chip wg-{tier}">{TIER_GLYPHS[tier]} '
+            f'{html.escape(label)}</div>')
+
+
+SHARE_ICON = (
+    '<svg viewBox="0 0 24 24" width="15" height="15" fill="none" stroke="currentColor" '
+    'stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">'
+    '<circle cx="18" cy="5" r="3"></circle><circle cx="6" cy="12" r="3"></circle>'
+    '<circle cx="18" cy="19" r="3"></circle>'
+    '<line x1="8.6" y1="10.5" x2="15.4" y2="6.5"></line>'
+    '<line x1="8.6" y1="13.5" x2="15.4" y2="17.5"></line></svg>'
+)
+
+
+def _result_head(certainty, query: str) -> str:
+    """The tier chip and the share button, on one line above the numbers."""
+    return (
+        '<div class="wg-result-head">'
+        + _chip(certainty.tier, certainty.label)
+        + f'<button type="button" class="wg-share" data-href="?{html.escape(query)}" '
+          'onclick="wgShare(this)" title="Copy a link to this estimate">'
+          f'{SHARE_ICON}<span class="wg-share-label">Share</span></button>'
+        + "</div>"
+    )
+
+
+def _card(label: str, value: str, sub: str = "") -> str:
+    sub_html = f'<div class="wg-sub">{sub}</div>' if sub else ""
+    return (f'<div class="wg-card"><div class="wg-label">{html.escape(label)}</div>'
+            f'<div class="wg-value">{value}</div>{sub_html}</div>')
+
+
+def _spec_table(heading: str, rows: list[tuple[str, str]]) -> str:
+    body = "".join(
+        f"<tr><td>{html.escape(k)}</td><td>{html.escape(str(v))}</td></tr>" for k, v in rows
+    )
+    return f"<div><h4>{html.escape(heading)}</h4><table>{body}</table></div>"
+
+
+# Only links to our own site are turned into anchors, so a model id or GPU name
+# echoed back from user input can never become a link.
+_ALLOWED_LINK_PREFIXES = ("https://leaner-ai.com", "https://arxiv.org/abs/",
+                          "mailto:mfa@leaner-ai.com")
+
+_LINK_RE = re.compile(r"\[([^\]]+)\]\(((?:https|mailto):[^\s)]+)\)")
+
+
+def _markdown_bold(text: str) -> str:
+    """Escape user-facing text, then honour `**bold**`, `code` and links."""
+    out = html.escape(text)
+
+    def link(match: re.Match[str]) -> str:
+        label, url = match.group(1), match.group(2)
+        if not url.startswith(_ALLOWED_LINK_PREFIXES):
+            return label
+        return f'<a href="{url}" target="_blank" rel="noopener">{label}</a>'
+
+    out = _LINK_RE.sub(link, out)
+    while out.count("**") >= 2:
+        out = out.replace("**", "<strong>", 1).replace("**", "</strong>", 1)
+    while out.count("`") >= 2:
+        out = out.replace("`", "<code>", 1).replace("`", "</code>", 1)
+    return out.replace("\n\n", "<br><br>")
+
+
+def _format_seconds(seconds: float) -> str:
+    if seconds >= 1:
+        return f"{seconds:.2f} s"
+    if seconds >= 1e-3:
+        return f"{seconds * 1e3:.2f} ms"
+    return f"{seconds * 1e6:.0f} µs"
+
+
+def render_error(error: WattGPUError) -> str:
+    body = _markdown_bold(error.hint) if error.hint else ""
+    return _banner("error", "Cannot make this estimate", 
+                   f"{_markdown_bold(error.message)}<br><br>{body}" if body
+                   else _markdown_bold(error.message))
+
+
+def render_prediction(prediction: Prediction) -> str:
+    """Render one prediction: a tier chip, the numbers, caveats, details."""
+    certainty = prediction.certainty
+    offline = prediction.scenario == "offline"
+
+    # The tier is a compact chip. What each tier means lives in the accordion
+    # below the form, so it is not repeated on every result.
+    parts: list[str] = []  # the head is prepended once the permalink is known
+
+    power_sub = f"{prediction.power_fraction_of_tdp * 100:.0f}% of {prediction.gpu.thermal_design_power_w:.0f} W TDP"
+    if prediction.power_mdape is not None:
+        power_sub += f" · ±{prediction.power_mdape:.1f}% typical error"
+    cards = [_card("GPU mean power draw", f"{prediction.power_w:,.0f} W", power_sub)]
+
+    if prediction.itl_s is not None:
+        error_suffix = (f" · ±{prediction.itl_mdape:.1f}% typical error"
+                        if prediction.itl_mdape is not None else "")
+        if prediction.latency_is_per_user:
+            cards.append(_card(
+                "Inter-token latency", _format_seconds(prediction.itl_s),
+                "the time the user experiences between tokens" + error_suffix))
+        else:
+            # Offline the model predicts wall-clock time per token over the whole
+            # batch, so throughput is exactly its inverse.
+            cards.append(_card(
+                "Throughput", f"{prediction.tokens_per_second:,.0f} tok/s",
+                "aggregate across the batch" + error_suffix))
+
+        intensity = f"at {prediction.carbon_intensity_g_per_kwh:g} gCO₂e/kWh"
+
+        energy_wh = prediction.energy_per_million_tokens_wh
+        if energy_wh is not None:
+            cards.append(_card(
+                "Energy per 1M tokens", format_energy(energy_wh),
+                "whole server, including data-centre overhead"))
+            cards.append(_card(
+                "CO₂e per 1M tokens",
+                format_co2(prediction.co2_per_million_tokens_g or 0.0), intensity))
+
+        hourly_wh = prediction.energy_per_hour_wh
+        if hourly_wh is not None:
+            cards.append(_card(
+                "Host energy per hour", format_energy(hourly_wh),
+                "whole server, including data-centre overhead"))
+            cards.append(_card(
+                "CO₂e per hour",
+                format_co2(prediction.co2_per_hour_g or 0.0), intensity))
+    else:
+        label = "Inter-token latency" if prediction.latency_is_per_user else "Throughput"
+        cards.append(_card(label, "—", "unavailable, see below"))
+
+    parts.append(f'<div class="wg-cards">{"".join(cards)}</div>')
+
+    if prediction.itl_s is not None and not prediction.latency_is_per_user:
+        parts.append(
+            '<div class="wg-note">Throughput is the inverse of the inter-token latency '
+            'estimated for this scenario. That latency is measured across the whole batch '
+            'rather than per request, so it cannot be used to derive the inter-token '
+            'latency an individual user would see on a server.</div>'
+        )
+    if prediction.itl_unavailable_reason:
+        parts.append(f'<div class="wg-note">{html.escape(prediction.itl_unavailable_reason)}</div>')
+    for warning in prediction.warnings:
+        parts.append(f'<div class="wg-note">⚠ {_markdown_bold(warning)}</div>')
+    for note in prediction.notes:
+        parts.append(f'<div class="wg-note wg-note-quiet">{_markdown_bold(note)}</div>')
+
+    # A relative href resolves against the current page, so this is a working
+    # permalink with no JavaScript and no need to know the deployed URL.
+    # A relative href resolves against the current page, so the share button
+    # works at any deployed URL without the server knowing what that URL is.
+    link_params = {
+        "model": prediction.llm.model_id,
+        "gpu": prediction.gpu.gpu_db_name,
+        "scenario": prediction.scenario,
+    }
+    # Only carried when it differs from the default, so ordinary links stay short.
+    if prediction.carbon_intensity_g_per_kwh != DEFAULT_CARBON_INTENSITY_G_PER_KWH:
+        link_params["carbon"] = f"{prediction.carbon_intensity_g_per_kwh:g}"
+    parts.insert(0, _result_head(certainty, urllib.parse.urlencode(link_params)))
+
+    # Inputs used, collapsed: available for checking, out of the way by default.
+    llm_heading = ("Model, from the profiled dataset"
+                   if prediction.llm.params_source == "profiled dataset"
+                   else "Model, from its config.json on the Hub")
+    parts.append(
+        '<details class="wg-details"><summary>Inputs used for this prediction</summary>'
+        '<div class="wg-specs">'
+        + _spec_table(llm_heading, prediction.llm.spec_rows())
+        + _spec_table("GPU, from the specification database", prediction.gpu.spec_rows())
+        + "</div></details>"
+    )
+    return "".join(parts)
+
+
+def _leaner_ai_logo() -> str:
+    """Inline the Leaner AI wordmark.
+
+    Inlined rather than served as a file so the SVG picks up the page's own
+    sizing rules and needs no static-file route.
+    """
+    path = os.path.join(ASSETS_DIR, "leaner-ai-logo.svg")
+    try:
+        with open(path, encoding="utf-8") as fh:
+            svg = fh.read()
+    except OSError:
+        return '<strong style="font-size:18px">Leaner AI</strong>'
+    # Drop the fixed width/height so the CSS controls the size.
+    return re.sub(r'\s(width|height)="\d+"', "", svg, count=2)
+
+
+def _header() -> str:
+    links = [
+        (LEANER_AI_URL, "Leaner AI", "↗"),
+        (PAPER_URL, "Read the paper", "↗"),
+        (CODE_URL, "Code", "↗"),
+    ]
+    anchors = "".join(
+        f'<a href="{url}" target="_blank" rel="noopener">{html.escape(text)}'
+        f'<span aria-hidden="true">{glyph}</span></a>'
+        for url, text, glyph in links
+    )
+    return (
+        '<div class="wg-header">'
+        f'<div class="wg-brandmark"><a href="{LEANER_AI_URL}" target="_blank" '
+        f'rel="noopener" aria-label="Leaner AI">{_leaner_ai_logo()}</a>'
+        '<span class="wg-eyebrow">Research demo</span></div>'
+        f'<div class="wg-links">{anchors}</div></div>'
+        '<div class="wg-title-bar"></div>'
+    )
+
+
+def _footer() -> str:
+    """Attribution, then the disclaimer and terms of use."""
+    return (
+        '<div class="wg-footer">'
+        f'<p>A research demo by <a href="{LEANER_AI_URL}" target="_blank" rel="noopener">Leaner AI</a>. '
+        f'Method and results: <a href="{PAPER_URL}" target="_blank" rel="noopener">{html.escape(PAPER_TITLE)}</a>, '
+        f'{html.escape(PAPER_VENUE)}. '
+        f'Source: <a href="{CODE_URL}" target="_blank" rel="noopener">github.com/maufadel/wattgpu</a>.</p>'
+
+        '<p><strong>Need this for a real deployment?</strong> Leaner AI does this '
+        'as a service — measured benchmarking and deployment advice for your own '
+        'models, hardware and workload. '
+        f'<a href="{CONTACT_URL}" target="_blank" rel="noopener">Get in touch</a>.</p>'
+
+        '<p class="wg-legal"><strong>Disclaimer and terms of use.</strong> '
+        'This is a research demonstrator provided for informational and '
+        'illustrative purposes only, and is intended as a rough guide rather than '
+        'a basis for decisions. All figures are statistical estimates derived from '
+        'public specifications, not measurements of your deployment, and they carry '
+        'the errors reported above. They are not a benchmark, a certification, an '
+        'energy or emissions disclosure, a capacity plan, or professional advice of '
+        'any kind.</p>'
+
+        '<p class="wg-legal">The demo and its output are provided <strong>"as is" '
+        'and "as available", without warranties or conditions of any kind</strong>, '
+        'whether express, implied or statutory, including without limitation any '
+        'warranty of accuracy, completeness, reliability, fitness for a particular '
+        'purpose, non-infringement, or uninterrupted or error-free operation.</p>'
+
+        '<p class="wg-legal">To the fullest extent permitted by applicable law, '
+        'Leaner AI and the authors accept no liability and assume no responsibility '
+        'for any use of this demo or its output, or for any loss or damage of any '
+        'kind — including direct, indirect, incidental, special, consequential, '
+        'exemplary or punitive damages, and any loss of profit, revenue, data, '
+        'business or goodwill — arising out of or in connection with such use, '
+        'whether in contract, tort (including negligence), strict liability or '
+        'otherwise, and whether or not advised of the possibility of such damage. '
+        'Nothing here excludes or limits liability that cannot be excluded or '
+        'limited by law.</p>'
+
+        '<p class="wg-legal"><strong>You are solely responsible for how you use '
+        'this demo and any data it produces</strong>, including any decision taken '
+        'in reliance on it and any consequences of that decision. You should '
+        'independently verify any figure before relying on it. By using this demo '
+        'you accept these terms; if you do not accept them, do not use it.</p>'
+
+        '<p class="wg-legal">When an estimate cannot be produced, the model name, '
+        'GPU name, scenario and reason are recorded so we can see which coverage '
+        'gaps matter most. Nothing about who asked is stored.</p>'
+
+        f'<p class="wg-legal">Provider identification and further legal notices: '
+        f'<a href="{LEANER_AI_URL}" target="_blank" rel="noopener">leaner-ai.com</a>.</p>'
+        '</div>'
+    )
+
+
+# ---------------------------------------------------------------------------
+# App
+# ---------------------------------------------------------------------------
+
+# Leaner AI's brand sky, as Gradio's primary hue (Tailwind `sky`).
+BRAND_SKY = gr.themes.Color(
+    c50="#f0f9ff", c100="#e0f2fe", c200="#bae6fd", c300="#7dd3fc", c400="#38bdf8",
+    c500="#0ea5e9", c600="#0284c7", c700="#0369a1", c800="#075985", c900="#0c4a6e",
+    c950="#082f49",
+)
+
+THEME = gr.themes.Soft(
+    primary_hue=BRAND_SKY,
+    secondary_hue=BRAND_SKY,
+    neutral_hue="slate",
+    font=[gr.themes.GoogleFont("Inter"), "system-ui", "-apple-system", "sans-serif"],
+)
+
+predictor = WattGPUPredictor()
+
+SCENARIO_CHOICES = [(SCENARIO_LABELS[s], s) for s in SCENARIOS]
+
+# A profiled, widely recognised model, so the first prediction lands on green.
+DEFAULT_MODEL = next(
+    (m for m in ("meta-llama/Llama-3.1-8B-Instruct", "Qwen/Qwen2.5-7B-Instruct")
+     if m in predictor.profiled_models),
+    predictor.profiled_models[0],
+)
+
+
+def _refusal_reason(error: WattGPUError) -> str | None:
+    """Short category for the demand log, or None if not worth recording.
+
+    Typos and unreachable repositories say nothing about demand, so only
+    refusals that represent real unmet coverage are logged.
+    """
+    if isinstance(error, UnsupportedModelError):
+        message = error.message
+        if "mixture-of-experts" in message:
+            return "moe"
+        if "quantised" in message:
+            return "quantised"
+        return "not-generative"
+    if isinstance(error, InsufficientMemoryError):
+        return "does-not-fit"
+    if isinstance(error, (ModelNotFoundError, ModelConfigError, GPUNotFoundError)):
+        return None
+    return None
+
+
+def predict(model_id: str, gpu_name: str, scenario: str,
+            carbon_intensity: float | None = None,
+            hf_token: str | None = None) -> str:
+    """Gradio callback. Every failure becomes a rendered message, never a crash.
+
+    `hf_token` is a per-request credential: it is handed to the Hub lookup and
+    never stored, logged, rendered, or put into a shareable link.
+    """
+    try:
+        return render_prediction(
+            predictor.predict(model_id, gpu_name, scenario, carbon_intensity, hf_token))
+    except WattGPUError as error:
+        reason = _refusal_reason(error)
+        if reason:
+            demand_log.record_refusal(model_id, gpu_name, scenario, reason)
+        return render_error(error)
+    except Exception:  # noqa: BLE001 - the UI must never show a raw traceback
+        traceback.print_exc()
+        return _banner(
+            "error", "Something went wrong",
+            "An unexpected error occurred while making this prediction. The details "
+            "were written to the server log. Please try a different model or GPU.",
+        )
+
+
+INTRO = f"""
+# WattGPU
+
+Estimate the **power draw** and **inter-token latency** of serving an LLM, before
+you rent the GPU. Search any Hugging Face model, search the NVIDIA GPU database,
+and pick your operational scenario.
+
+Every estimate is labelled by how far it sits from the
+{len(predictor.profiled_models)} LLMs and {len(predictor.profiled_gpus)} GPUs that were
+actually measured. [Read the paper]({PAPER_URL}).
+"""
+
+LEGEND = """
+| | Tier | Meaning | Validation protocol |
+|---|---|---|---|
+| 🟢 | **High** | Both the LLM and the GPU are in the training data. | 5-fold grouped CV |
+| 🟡 | **Moderate** | LLM not in training data, GPU is. | Leave-one-LLM-out (LOLO) |
+| 🟠 | **Lower** | GPU not in training data, LLM is. | Leave-one-GPU-out (LOGO) |
+| 🟠 | **Lower** | Neither is in the training data, under server load. | Double holdout (both removed) |
+| 🔴 | **Low** | Neither is in the training data, offline / batch. | Double holdout (both removed) |
+
+Generalising to hardware that was never measured is consistently harder than
+generalising to an unmeasured model architecture, which is why an unknown GPU
+ranks below an unknown LLM.
+
+The first three protocols are the paper's. The **double holdout** is an
+extension added for this demo: for every measured pair, the model is retrained
+with that GPU **and** that LLM removed entirely, then asked to predict the pair.
+It is what lets the hardest case carry a measured error instead of an
+unvalidated guess.
+
+That measurement is also why the hardest case appears in two different bands.
+Under server load, dropping the LLM as well as the GPU barely hurts — 15.1%
+against 13.1% for power, 8.6% against 8.5% for latency — so it sits in the same
+band as an unknown GPU alone. Offline it does hurt: latency goes from 24.9% to
+36.2%, which is a genuinely weaker estimate and gets its own band. Whichever
+band is shown, the error quoted is always the one measured for the actual
+situation.
+
+Some requests are refused outright rather than given a tier — mixture-of-experts
+and quantised models, embedding and reranking models, and pairs whose weights do
+not fit in GPU memory. Those are outside what the models were fitted on, so an
+estimate would be misleading rather than merely uncertain.
+"""
+
+TYPICAL_ERROR = """
+The **typical error** shown beside each number is the *median absolute
+percentage error* (MdAPE) of the model, measured during training and looked up
+when you ask — it is not computed from your particular query.
+
+### How it is measured
+
+Every row of the dataset is predicted by a model that never saw it
+(*out-of-fold* prediction), then:
+
+```
+MdAPE = median( |actual − predicted| ÷ actual ) × 100
+```
+
+The median rather than the mean, following the paper: it is not distorted by the
+few pairs the model gets badly wrong — but that is also why it describes a
+typical case rather than a worst case.
+
+### Why it changes with the tier
+
+The data is split in whatever way reproduces the situation the tier describes,
+so the error you are shown was measured under exactly that kind of
+generalisation:
+
+| Tier | How the data was split | What it simulates |
+|---|---|---|
+| 🟢 High | 5-fold, grouped on the (LLM, GPU) pair | both already measured |
+| 🟡 Moderate | leave-one-LLM-out | an architecture never measured |
+| 🟠 Lower | leave-one-GPU-out | hardware never measured |
+| 🟠 / 🔴 | that GPU **and** that LLM both removed | neither ever measured |
+
+The band shown and the protocol behind it are not always the same. A pair where
+neither side was measured is backed by the double holdout in every scenario, but
+under server load that protocol performs closely enough to leave-one-GPU-out to
+share its band. The number beside the estimate always comes from the protocol,
+never from the band.
+
+Grouping on the pair for the green tier keeps the repeated runs of one
+configuration from landing on both sides of the split, which would otherwise
+flatter the result.
+
+The figures are also split between offline and server operation, because the two
+regimes differ a lot — especially for latency, where offline behaviour depends on
+batching that the features only partly capture.
+
+### What it does not tell you
+
+- It is a **median across a whole tier**, so half the held-out cases in that tier
+  were worse. It is not a bound, and not a confidence interval for your pair.
+- There is **no per-prediction uncertainty**: two queries in the same tier and
+  regime always show the same figure.
+- It measures the model against the paper's setup — vLLM, FP16, one GPU,
+  512-token prompts. It says nothing about how well that setup matches yours.
+"""
+
+SCENARIO_HEADING = """
+<div class="wg-scenario-head">
+  <span class="wg-scenario-title">Operational scenario</span>
+  <details class="wg-loadhelp">
+    <summary><span class="wg-q">?</span> What do these mean?</summary>
+    <div class="wg-loadhelp-body">
+
+<p>These are three <strong>measured operating points</strong>, not ranges. Every
+server run behind WattGPU used one of exactly two request rates, and the offline
+runs kept the GPU permanently busy:</p>
+
+<ul>
+<li><strong>Low load</strong> — 0.017 requests/s. The GPU is idle most of the time.</li>
+<li><strong>Medium load</strong> — 0.33 requests/s. The GPU still keeps up comfortably.</li>
+<li><strong>Offline / batch</strong> — a batch job with work always queued. The GPU
+never goes idle.</li>
+</ul>
+
+<p><strong>Concurrent users</strong> are the people <em>using</em> the system at the
+same time — everyone with the chat open, reading a reply or typing the next
+message. That is not the same as concurrent <em>requests</em>: a user spends most of
+their session thinking and reading, and only occasionally sends something for the
+model to answer.</p>
+
+<p>To convert:</p>
+
+<pre>concurrent users × messages per user per second = requests per second</pre>
+
+<p>At about one message per minute each, a user generates
+<code>1 ÷ 60 = 0.017</code> requests per second. So the two measured rates work out
+at roughly <strong>1</strong> and <strong>20</strong> concurrent users — ten people
+chatting sit between the two.</p>
+
+<p><strong>Using offline / batch for a busy server.</strong> A server that is fully
+saturated keeps its GPU continuously busy, just as a batch job does, so the
+<em>mean power draw</em> estimated for offline / batch is a reasonable figure for a
+saturated server too. The <em>throughput</em> carries over as the ceiling the pair
+can sustain. What does not carry over is per-user responsiveness: in a saturated
+batch each individual request waits far longer between tokens than the aggregate
+rate suggests.</p>
+
+<p><strong>Why it is not easy to determine when a server saturates.</strong> The point where
+load tips into saturation is a property of the whole deployment, not of the
+hardware alone. It moves with model size against memory bandwidth, prompt and
+response lengths, how the server batches concurrent requests, and how bursty the
+arrivals are. A small model on an H200 stays responsive with far more users than a
+30B model on an L4. WattGPU takes the scenario as one of three measured categories,
+so it cannot interpolate to an arbitrary request rate or locate that tipping point —
+treat low, medium and offline as three reference points rather than a continuum.</p>
+
+    </div>
+  </details>
+</div>
+"""
+
+ENERGY_ASSUMPTIONS = f"""
+### What the energy figures cover
+
+The models predict the **GPU board's** power draw. The figures shown are scaled
+up from there to roughly what the wall socket sees:
+
+```
+facility watts = GPU watts ÷ {GPU_SHARE_OF_HOST_POWER} × {DEFAULT_PUE}
+```
+
+The GPU is taken as **{GPU_SHARE_OF_HOST_POWER:.0%} of the host server's draw** — the rest is CPU,
+memory, storage, NICs and fans — and a **PUE of {DEFAULT_PUE}** is applied on top for
+cooling and power distribution. Both are typical values rather than
+measurements, so your own hardware and site will differ. The same scaling
+applies in every scenario, so the per-token and per-hour numbers describe the
+same system boundary.
+
+### Why per token offline, but per hour under server load
+
+Offline the GPU is saturated: it is generating essentially all of the time, so
+every joule is attributable to a token and **energy per token** is a stable
+property of the model and the hardware.
+
+Under server load it is not. The GPU spends much of its time waiting for the
+next request, so energy per token would mostly reflect how busy the server
+happens to be rather than anything about the model or the card. What an operator
+can act on there is the draw of keeping the deployment up, so the figures are
+reported **per hour** instead.
+
+### Grid carbon intensity
+"""
+
+HF_TOKEN_HELP = f"""
+The demo reads model architectures from the Hugging Face Hub anonymously, which
+is enough almost all of the time. A token helps in two cases:
+
+- **Licence-gated models.** Most of the well-known gated models are already
+  bundled, but for one that is not, a token from an account that has accepted
+  the licence will read it.
+- **Rate limiting.** The Hub limits anonymous requests per IP address, and every
+  visitor to this demo shares one. Your own token gives you your own allowance.
+
+Create a **read-only** token at
+[huggingface.co/settings/tokens](https://huggingface.co/settings/tokens). It is
+used for your request and then discarded — never stored, never logged, and never
+included in a shared link. Even so, prefer a fine-grained read-only token over
+one with write access.
+
+Measured and bundled models need no token at all: they are answered without
+contacting the Hub.
+"""
+
+CITATION = rf"""
+If this demo or the models behind it are useful in your work, please cite the
+paper:
+
+> Fadel Argerich, M., Fürst, J., and Patiño-Martínez, M. (2026).
+> *{PAPER_TITLE}*.
+> {PAPER_VENUE}. CEUR Workshop Proceedings, ISSN 1613-0073.
+> [arxiv.org/abs/2607.02391]({PAPER_URL})
+
+```bibtex
+@inproceedings{{fadelargerich2026wattgpu,
+  title     = {{{{WattGPU}}: Predicting Inference Power and Latency on
+               Unseen GPUs and LLMs}},
+  author    = {{Fadel Argerich, Mauricio and F{{\"u}}rst, Jonathan and
+               Pati{{\~n}}o-Mart{{\'i}}nez, Marta}},
+  booktitle = {{Proceedings of the 1st Workshop on Sustainability and
+               Resource-Efficiency of Artificial Intelligence (SuRE) @ IJCAI}},
+  series    = {{CEUR Workshop Proceedings}},
+  publisher = {{CEUR-WS.org}},
+  issn      = {{1613-0073}},
+  year      = {{2026}},
+  eprint    = {{2607.02391}},
+  archivePrefix = {{arXiv}},
+  url       = {{{PAPER_URL}}}
+}}
+```
+
+The code, the trained models and the measurement subset are available under
+Apache 2.0 at [github.com/maufadel/wattgpu]({CODE_URL}).
+"""
+
+# Tables 2 and 3 of the paper, reproduced by `scripts/train_models.py`.
+# MdAPE is the median absolute percentage error; τ is Kendall's tau over the
+# induced ranking of GPUs and of LLMs.
+PAPER_RESULTS = f"""
+These are the numbers reported in
+[{PAPER_TITLE}]({PAPER_URL}), reproduced by `scripts/train_models.py` in this
+repository. **MdAPE** is the median absolute percentage error. **Pearson r**
+measures how well predictions track the true values, and **GPU τ** / **LLM τ**
+are Kendall rank correlations — how reliably the model puts GPUs, and LLMs, in
+the right order. Ranking matters as much as absolute error when the question is
+"which of these should I deploy on?".
+
+### Mean power draw (Table 2)
+
+| Model | Scenario | Strategy | MdAPE | Pearson r | GPU τ | LLM τ |
+|---|---|---|---|---|---|---|
+| XGBoost | Offline | CV | **1.6%** | 0.992 | 0.96 | 0.44 |
+| XGBoost | Offline | LOGO | **3.4%** | 0.988 | 0.95 | 0.40 |
+| XGBoost | Offline | LOLO | **2.0%** | 0.979 | 0.97 | 0.33 |
+| XGBoost | Server | CV | **5.5%** | 0.981 | 0.86 | 0.68 |
+| XGBoost | Server | LOGO | **13.5%** | 0.965 | 0.76 | 0.72 |
+| XGBoost | Server | LOLO | **6.7%** | 0.955 | 0.85 | 0.54 |
+| TDP baseline | Offline | — | 4.4% | 0.916 | 0.96 | — |
+| TDP baseline | Server | — | 190.1% | 0.590 | 0.60 | — |
+| Least-squares TDP | Offline | — | 7.2% | 0.916 | 0.96 | — |
+| Least-squares TDP | Server | — | 26.0% | 0.779 | 0.60 | — |
+
+Assuming a GPU simply draws its TDP is roughly adequate offline, where a
+saturated GPU really does sit near its power limit, and badly wrong under server
+load (190% error) where utilisation is far below peak. That is where the learned
+model earns its place.
+
+### Inter-token latency (Table 3)
+
+| Model | Scenario | Strategy | MdAPE | Pearson r | GPU τ | LLM τ |
+|---|---|---|---|---|---|---|
+| XGBoost | Offline | CV | **12.8%** | 0.813 | 0.86 | 0.81 |
+| XGBoost | Offline | LOGO | **24.9%** | 0.727 | 0.72 | 0.83 |
+| XGBoost | Offline | LOLO | **15.6%** | 0.808 | 0.97 | 0.66 |
+| XGBoost | Server | CV | **4.9%** | 0.991 | 0.94 | 0.89 |
+| XGBoost | Server | LOGO | **8.5%** | 0.972 | 0.78 | 0.88 |
+| XGBoost | Server | LOLO | **5.6%** | 0.990 | 0.97 | 0.88 |
+| Roofline baseline | Offline | — | 80.2% | 0.545 | 0.82 | 0.61 |
+| Roofline baseline | Server | — | 29.6% | 0.991 | 0.88 | 0.91 |
+
+Latency is harder offline than under server load: offline throughput depends on
+how vLLM batches requests, which the features capture only partly. The roofline
+baseline — the time to stream the model's FP16 weights from memory once per
+token — tracks the *ordering* well (τ up to 0.91) but is off by 80% in
+magnitude offline, because it ignores batching entirely.
+
+### How to read this
+
+- **CV** rows are the green tier, **LOLO** the yellow, **LOGO** the orange.
+- Generalising to an unseen **GPU** (LOGO) is consistently harder than to an
+  unseen **LLM** (LOLO). That is why an unprofiled GPU is ranked below an
+  unprofiled LLM in the certainty tiers.
+- All errors are for the paper's setup: vLLM, FP16 weights, a single GPU,
+  512-token prompts. They are not warranties for other configurations.
+"""
+
+def search_hub(key_up: gr.KeyUpData, hf_token: str | None = None) -> gr.Dropdown:
+    """Live search of the Hugging Face Hub as the user types.
+
+    Profiled models are surfaced first, since those give the most reliable
+    estimates, then whatever the Hub returns for the query.
+    """
+    query = (key_up.input_value or "").strip()
+    if len(query) < 2:
+        return gr.Dropdown(choices=predictor.known_models)
+
+    lowered = query.lower()
+    known = [m for m in predictor.known_models if lowered in m.lower()]
+    hub = [m for m in search_models(query, token=hf_token) if m not in known]
+    return gr.Dropdown(choices=known + hub)
+
+
+def on_submit(model_id: str, gpu_name: str, scenario: str,
+              carbon_intensity: float | None,
+              hf_token: str | None = None) -> tuple[str, float]:
+    """Run an estimate and echo back the intensity actually used.
+
+    Clearing the intensity leaves it empty, so the value that was applied is
+    written back into it -- the box never disagrees with the number in the
+    result. The token is passed straight through and never echoed back.
+    """
+    intensity = clean_carbon_intensity(carbon_intensity)
+    return predict(model_id, gpu_name, scenario, intensity, hf_token), intensity
+
+
+def search_gpus(key_up: gr.KeyUpData) -> gr.Dropdown:
+    """Search the whole GPU catalogue as the user types.
+
+    The list starts as just the measured GPUs, which are the ones that give a
+    high-confidence estimate; the other 500-odd are a search away.
+    """
+    query = (key_up.input_value or "").strip()
+    if len(query) < 2:
+        return gr.Dropdown(choices=predictor.profiled_gpus)
+
+    lowered = query.lower()
+    measured = [g for g in predictor.profiled_gpus if lowered in g.lower()]
+    rest = [g for g in predictor.gpu_db.search(query) if g not in measured]
+    return gr.Dropdown(choices=measured + rest)
+
+
+def restore_from_link(request: gr.Request):
+    """Populate the form from a shared permalink, and run it.
+
+    Values are validated against the catalogues before use, so a hand-edited
+    link cannot put the form into a state the app would not otherwise reach.
+    """
+    params = dict(request.query_params or {})
+    model = (params.get("model") or "").strip()
+    gpu = (params.get("gpu") or "").strip()
+    scenario = (params.get("scenario") or "").strip()
+
+    unchanged = (gr.skip(), gr.skip(), gr.skip(), gr.skip(), gr.skip())
+    if not (model and gpu):
+        return unchanged
+    if scenario not in SCENARIOS:
+        scenario = "server_low"
+    try:
+        gpu = predictor.gpu_db.get(gpu).gpu_db_name
+    except WattGPUError:
+        return unchanged  # do not open the page on an error
+
+    carbon = clean_carbon_intensity(params.get("carbon"))
+    return (
+        gr.Dropdown(choices=sorted({*predictor.known_models, model}), value=model),
+        gr.Dropdown(choices=sorted({*predictor.profiled_gpus, gpu}), value=gpu),
+        scenario,
+        carbon,
+        predict(model, gpu, scenario, carbon),
+    )
+
+
+# `analytics_enabled=False`: the form carries a per-request Hugging Face token,
+# so no usage telemetry leaves the deployment.
+with gr.Blocks(title="WattGPU — Leaner AI", theme=THEME, css=CSS, head=HEAD,
+               analytics_enabled=False) as demo:
+    gr.HTML(_header())
+    gr.Markdown(INTRO)
+
+    with gr.Row():
+        with gr.Column(scale=3):
+            model_input = gr.Dropdown(
+                label="Model",
+                info="Search any model on the Hugging Face Hub.",
+                choices=predictor.known_models,
+                value=DEFAULT_MODEL,
+                allow_custom_value=True,
+                filterable=True,
+            )
+        with gr.Column(scale=3):
+            gpu_input = gr.Dropdown(
+                label="GPU",
+                info=("Measured GPUs are shown in the list. "
+                      "Type to search the rest of the NVIDIA database."),
+                choices=predictor.profiled_gpus,
+                value=predictor.profiled_gpus[0],
+                allow_custom_value=True,
+                filterable=True,
+            )
+
+    gr.HTML(SCENARIO_HEADING)
+    scenario_input = gr.Radio(
+        label="Operational scenario",
+        show_label=False,          # the heading above carries the label and its help
+        choices=SCENARIO_CHOICES,
+        value="server_low",
+    )
+
+
+    submit = gr.Button("Estimate power and latency", variant="primary", size="lg")
+    output = gr.HTML(label="Estimate")
+
+    with gr.Accordion("Assumptions behind the energy and emissions figures", open=False):
+        gr.Markdown(ENERGY_ASSUMPTIONS)
+        carbon_input = gr.Number(
+            label="Grid carbon intensity (gCO₂e/kWh)",
+            info=(f"Default is the {DEFAULT_CARBON_INTENSITY_LABEL}. Your own grid "
+                  "might be different — check it for your region and hour on "
+                  f"[Electricity Maps]({ELECTRICITY_MAPS_URL}). Leave it empty to "
+                  "go back to the default."),
+            value=DEFAULT_CARBON_INTENSITY_G_PER_KWH,
+            minimum=MIN_CARBON_INTENSITY,
+            maximum=MAX_CARBON_INTENSITY,
+            step=10,
+            precision=0,
+        )
+
+    with gr.Accordion("Use your own Hugging Face token", open=False):
+        gr.Markdown(HF_TOKEN_HELP)
+        token_input = gr.Textbox(
+            label="Hugging Face access token",
+            placeholder="hf_…",
+            type="password",
+            lines=1,
+            autofocus=False,
+        )
+
+    with gr.Accordion("How to read the certainty tier", open=False):
+        gr.Markdown(LEGEND)
+
+    with gr.Accordion("How the typical error is calculated", open=False):
+        gr.Markdown(TYPICAL_ERROR)
+
+    with gr.Accordion("Model accuracy, as reported in the paper", open=False):
+        gr.Markdown(PAPER_RESULTS)
+
+    with gr.Accordion("Cite this work", open=False):
+        gr.Markdown(CITATION)
+
+    with gr.Accordion("What was measured", open=False):
+        gr.Markdown(
+            f"**GPUs ({len(predictor.profiled_gpus)}):** "
+            + ", ".join(f"`{g}`" for g in predictor.profiled_gpus)
+            + f"\n\n**LLMs ({len(predictor.profiled_models)}):** "
+            + ", ".join(f"`{m}`" for m in predictor.profiled_models)
+            + "\n\nAll from the subset of "
+            f"[Watt Counts]({WATT_COUNTS_URL}) used in the paper: vLLM, FP16 "
+            "weights, one GPU, 512-token prompts. Quantised, multi-GPU or "
+            "long-context deployments will differ.\n\n"
+            + ("Licence-gated models are readable: an `HF_TOKEN` is configured."
+               if has_hf_token() else
+               "Licence-gated models that were not measured (some Llama and Gemma "
+               "variants) need an `HF_TOKEN` environment variable from an account "
+               "that has accepted their licences.")
+        )
+
+    gr.HTML(_footer())
+
+    demo.load(restore_from_link,
+              outputs=[model_input, gpu_input, scenario_input, carbon_input, output])
+    model_input.key_up(search_hub, inputs=token_input, outputs=model_input,
+                       show_progress="hidden", queue=False)
+    gpu_input.key_up(search_gpus, outputs=gpu_input,
+                     show_progress="hidden", queue=False)
+    submit.click(on_submit,
+                 inputs=[model_input, gpu_input, scenario_input, carbon_input,
+                         token_input],
+                 outputs=[output, carbon_input])
+
+
+if __name__ == "__main__":
+    demo.launch(server_name=os.environ.get("GRADIO_SERVER_NAME", "127.0.0.1"))

data/demand_log.jsonl

@@ -0,0 +1 @@
+{"at": "2026-09-03T13:21:01+00:00", "model": "microsoft/phi-4", "gpu": "Tesla T4", "scenario": "offline", "reason": "does-not-fit"}

data/gated_llms.json

@@ -0,0 +1,72 @@
+{
+  "google/gemma-3-1b-it": {
+    "architectures": [
+      "Gemma3ForCausalLM"
+    ],
+    "hidden_size": 1152,
+    "max_position_embeddings": 32768,
+    "model_type": "gemma3_text",
+    "num_attention_heads": 4,
+    "num_key_value_heads": 1,
+    "num_layers": 26,
+    "source_mirror": "unsloth/gemma-3-1b-it",
+    "torch_dtype": "bfloat16",
+    "total_b_params": 0.999886
+  },
+  "google/gemma-3-270m": {
+    "architectures": [
+      "Gemma3ForCausalLM"
+    ],
+    "hidden_size": 640,
+    "max_position_embeddings": 32768,
+    "model_type": "gemma3_text",
+    "num_attention_heads": 4,
+    "num_key_value_heads": 1,
+    "num_layers": 18,
+    "source_mirror": "unsloth/gemma-3-270m",
+    "torch_dtype": "bfloat16",
+    "total_b_params": 0.268098
+  },
+  "meta-llama/Llama-3.2-1B": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 2048,
+    "max_position_embeddings": 131072,
+    "model_type": "llama",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 16,
+    "source_mirror": "unsloth/Llama-3.2-1B",
+    "torch_dtype": "bfloat16",
+    "total_b_params": 1.235814
+  },
+  "meta-llama/Llama-3.2-1B-Instruct": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 2048,
+    "max_position_embeddings": 131072,
+    "model_type": "llama",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 16,
+    "source_mirror": "unsloth/Llama-3.2-1B-Instruct",
+    "torch_dtype": "bfloat16",
+    "total_b_params": 1.235814
+  },
+  "meta-llama/Meta-Llama-3-8B-Instruct": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 8192,
+    "model_type": "llama",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 32,
+    "source_mirror": "NousResearch/Meta-Llama-3-8B-Instruct",
+    "torch_dtype": "bfloat16",
+    "total_b_params": 8.030261
+  }
+}

data/gpu_database.csv

@@ -0,0 +1,355 @@
+manufacturer,gpu_db_name,gpu_name,generation,architecture,base_clock_mhz,boost_clock_mhz,process_size_nm,transistor_count_m,release_date,memory_clock_mhz,memory_size_gb,memory_bus_bits,memory_bandwidth_gb_s,memory_type,shading_units,streaming_multiprocessors,tensor_cores,l2_cache_mb,thermal_design_power_w,half_float_performance_gflop_s,single_float_performance_gflop_s,tpu_url,release_year,tensor_tflops_16b,tensor_tflops_source,boost_percentage
+NVIDIA,A10 PCIe,GA102,Server Ampere(Axx),Ampere,885.0,1695.0,8.0,28300.0,2021-04-12,1563.0,24.0,384.0,600.2,GDDR6,9216,72,288,6.0,150.0,31240.0,31240.0,https://www.techpowerup.com/gpu-specs/a10-pcie.c3793,2021,125.0,reported,1.9152542372881356
+NVIDIA,A100 PCIe 40 GB,GA100,Server Ampere(Axx),Ampere,765.0,1410.0,7.0,54200.0,2020-06-22,1215.0,40.0,5120.0,1560.0,HBM2e,6912,108,432,40.0,250.0,77970.0,19490.0,https://www.techpowerup.com/gpu-specs/a100-pcie-40-gb.c3623,2020,312.0,reported,1.8431372549019607
+NVIDIA,A100 PCIe 80 GB,GA100,Server Ampere(Axx),Ampere,1065.0,1410.0,7.0,54200.0,2021-06-28,1512.0,80.0,5120.0,1940.0,HBM2e,6912,108,432,80.0,300.0,77970.0,19490.0,https://www.techpowerup.com/gpu-specs/a100-pcie-80-gb.c3821,2021,312.0,reported,1.323943661971831
+NVIDIA,A100 SXM4 40 GB,GA100,Server Ampere(Axx),Ampere,1095.0,1410.0,7.0,54200.0,2020-05-14,1215.0,40.0,5120.0,1560.0,HBM2e,6912,108,432,40.0,400.0,77970.0,19490.0,https://www.techpowerup.com/gpu-specs/a100-sxm4-40-gb.c3506,2020,312.0,reported,1.2876712328767124
+NVIDIA,A100 SXM4 80 GB,GA100,Server Ampere(Axx),Ampere,1275.0,1410.0,7.0,54200.0,2020-11-16,1593.0,80.0,5120.0,2040.0,HBM2e,6912,108,432,40.0,400.0,77970.0,19490.0,https://www.techpowerup.com/gpu-specs/a100-sxm4-80-gb.c3746,2020,312.0,reported,1.1058823529411765
+NVIDIA,A100X,GA100,Server Ampere(Axx),Ampere,795.0,1440.0,7.0,54200.0,2021-06-28,1593.0,80.0,5120.0,2040.0,HBM2e,6912,108,432,80.0,300.0,79630.0,19910.0,https://www.techpowerup.com/gpu-specs/a100x.c3958,2021,318.5,estimated,1.8113207547169812
+NVIDIA,A10G,GA102,Server Ampere(Axx),Ampere,1320.0,1710.0,8.0,28300.0,2021-04-12,1563.0,24.0,384.0,600.2,GDDR6,9216,72,288,6.0,150.0,31520.0,31520.0,https://www.techpowerup.com/gpu-specs/a10g.c3798,2021,70.0,reported,1.2954545454545454
+NVIDIA,A10M,GA102,Server Ampere(Axx),Ampere,975.0,1635.0,8.0,28300.0,2022-02-01,1563.0,20.0,320.0,500.2,GDDR6,7168,56,224,6.0,150.0,23440.0,23440.0,https://www.techpowerup.com/gpu-specs/a10m.c4200,2022,93.8,estimated,1.676923076923077
+NVIDIA,A16 PCIe,GA107,Server Ampere(Axx),Ampere,1312.0,1755.0,8.0,8700.0,2021-04-12,1563.0,16.0,128.0,200.1,GDDR6,1280,10,40,2.0,250.0,4493.0,4493.0,https://www.techpowerup.com/gpu-specs/a16-pcie.c3794,2021,71.0,reported,1.3376524390243902
+NVIDIA,A2,GA107,Workstation Ampere(Ax000),Ampere,1440.0,1770.0,8.0,8700.0,2021-11-10,1563.0,16.0,128.0,200.1,GDDR6,1280,10,40,2.0,60.0,4531.0,4531.0,https://www.techpowerup.com/gpu-specs/a2.c3848,2021,18.1,estimated,1.2291666666666667
+NVIDIA,A2 PCIe,GA107,Server Ampere(Axx),Ampere,1440.0,1770.0,8.0,8700.0,2021-11-10,1563.0,16.0,128.0,200.1,GDDR6,1280,10,40,2.0,60.0,4531.0,4531.0,https://www.techpowerup.com/gpu-specs/a2-pcie.c4112,2021,36.0,reported,1.2291666666666667
+NVIDIA,A30 PCIe,GA100,Server Ampere(Axx),Ampere,930.0,1440.0,7.0,54200.0,2021-04-12,1215.0,24.0,3072.0,933.1,HBM2e,3584,56,224,24.0,165.0,10320.0,10320.0,https://www.techpowerup.com/gpu-specs/a30-pcie.c3792,2021,165.0,reported,1.5483870967741935
+NVIDIA,A30X,GA100,Server Ampere(Axx),Ampere,1035.0,1440.0,7.0,54200.0,2021-04-12,1593.0,24.0,3072.0,1220.0,HBM2e,3584,56,224,24.0,230.0,10320.0,10320.0,https://www.techpowerup.com/gpu-specs/a30x.c3968,2021,165.2,estimated,1.391304347826087
+NVIDIA,A40 PCIe,GA102,Server Ampere(Axx),Ampere,1305.0,1740.0,8.0,28300.0,2020-10-05,1812.0,48.0,384.0,695.8,GDDR6,10752,84,336,6.0,300.0,37420.0,37420.0,https://www.techpowerup.com/gpu-specs/a40-pcie.c3700,2020,150.0,reported,1.3333333333333333
+NVIDIA,A800 PCIe 40 GB,GA100,Server Ampere(Axx),Ampere,765.0,1410.0,7.0,54200.0,2022-11-08,1215.0,40.0,5120.0,1560.0,HBM2e,6912,108,432,40.0,250.0,77970.0,19490.0,https://www.techpowerup.com/gpu-specs/a800-pcie-40-gb.c3964,2022,311.9,estimated,1.8431372549019607
+NVIDIA,A800 PCIe 80 GB,GA100,Server Ampere(Axx),Ampere,1065.0,1410.0,7.0,54200.0,2022-11-08,1512.0,80.0,5120.0,1940.0,HBM2e,6912,108,432,80.0,250.0,77970.0,19490.0,https://www.techpowerup.com/gpu-specs/a800-pcie-80-gb.c3965,2022,311.9,estimated,1.323943661971831
+NVIDIA,A800 SXM4 80 GB,GA100,Server Ampere(Axx),Ampere,1155.0,1410.0,7.0,54200.0,2022-08-11,1593.0,80.0,5120.0,2040.0,HBM2e,6912,108,432,40.0,400.0,77970.0,19490.0,https://www.techpowerup.com/gpu-specs/a800-sxm4-80-gb.c3966,2022,311.9,estimated,1.2207792207792207
+NVIDIA,B200,GB100,Server Blackwell(Bxx),Blackwell,700.0,1965.0,5.0,104000.0,2024-01-01,2000.0,90.0,4096.0,4099.999999999999,HBM3e,18944,148,592,50.0,1000.0,1191200.0,74450.0,https://www.techpowerup.com/gpu-specs/b200.c4210,2024,297.8,estimated,2.807142857142857
+NVIDIA,B300,GB110,Server Blackwell(Bxx),Blackwell Ultra,1665.0,2032.0,5.0,104000.0,2025-09-11,2000.0,144.0,4096.0,4099.999999999999,HBM3e,18944,148,592,50.0,1400.0,1231800.0,76990.0,https://www.techpowerup.com/gpu-specs/b300.c4375,2025,,unknown,1.2204204204204203
+NVIDIA,CMP 100HX-210,GV100,Mining GPUs,Volta,555.0,1147.0,12.0,21100.0,2020-01-01,810.0,16.0,4096.0,829.4,HBM2,5120,80,640,6.0,250.0,23490.0,11750.0,https://www.techpowerup.com/gpu-specs/cmp-100hx-210.c4202,2020,94.0,estimated,2.066666666666667
+NVIDIA,CMP 170HX 10 GB,GA100,Mining GPUs,Ampere,1140.0,1410.0,7.0,54200.0,2021-09-01,1215.0,10.0,5120.0,1560.0,HBM2e,4480,70,280,10.0,250.0,50530.0,12630.0,https://www.techpowerup.com/gpu-specs/cmp-170hx-10-gb.c3957,2021,202.1,estimated,1.236842105263158
+NVIDIA,CMP 170HX 8 GB,GA100,Mining GPUs,Ampere,1140.0,1410.0,7.0,54200.0,2021-09-01,1458.0,8.0,4096.0,1490.0,HBM2e,4480,70,280,8.0,250.0,50530.0,12630.0,https://www.techpowerup.com/gpu-specs/cmp-170hx-8-gb.c3830,2021,202.1,estimated,1.236842105263158
+NVIDIA,CMP 30HX,TU116,Mining GPUs,Turing,1530.0,1785.0,12.0,6600.0,2021-02-25,1750.0,6.0,192.0,336.0,GDDR6,1408,22,0,1.5,125.0,10050.0,5027.0,https://www.techpowerup.com/gpu-specs/cmp-30hx.c3780,2021,,unknown,1.1666666666666667
+NVIDIA,CMP 40HX,TU106,Mining GPUs,Turing,1470.0,1650.0,12.0,10800.0,2021-02-25,1750.0,8.0,256.0,448.0,GDDR6,2304,36,288,4.0,185.0,15210.0,7603.0,https://www.techpowerup.com/gpu-specs/cmp-40hx.c3781,2021,60.8,estimated,1.1224489795918366
+NVIDIA,CMP 50HX,TU102,Mining GPUs,Turing,1350.0,1545.0,12.0,18600.0,2021-06-24,1750.0,10.0,320.0,560.0,GDDR6,3584,56,448,5.0,250.0,22150.0,11070.0,https://www.techpowerup.com/gpu-specs/cmp-50hx.c3782,2021,88.6,estimated,1.1444444444444444
+NVIDIA,CMP 90HX,GA102,Mining GPUs,Ampere,1500.0,1710.0,8.0,28300.0,2021-07-28,1188.0,10.0,320.0,760.3,GDDR6X,6400,50,200,5.0,320.0,21890.0,21890.0,https://www.techpowerup.com/gpu-specs/cmp-90hx.c3783,2021,87.6,estimated,1.14
+NVIDIA,DRIVE A100 PROD,GA100,DRIVE(Axx),Ampere,1260.0,1260.0,7.0,54200.0,2020-05-14,1215.0,32.0,6144.0,1870.0,HBM2e,6912,108,432,32.0,400.0,69670.0,17420.000000000004,https://www.techpowerup.com/gpu-specs/drive-a100-prod.c3967,2020,278.7,estimated,1.0
+NVIDIA,GB10,GB20B,Server Blackwell(Bxx),Blackwell 2.0,1665.0,2418.0,5.0,,2025-10-15,1067.0,128.0,256.0,273.2,LPDDR5X,6144,48,384,50.0,140.0,29710.0,29710.0,https://www.techpowerup.com/gpu-specs/gb10.c4342,2025,237.7,estimated,1.4522522522522523
+NVIDIA,GRID A100A,GA100,GRID(Ax),Ampere,1095.0,1410.0,7.0,54200.0,2020-05-14,1215.0,32.0,6144.0,1870.0,HBM2e,6912,108,432,32.0,400.0,77970.0,19490.0,https://www.techpowerup.com/gpu-specs/grid-a100a.c3579,2020,311.9,estimated,1.2876712328767124
+NVIDIA,GRID A100B,GA100,GRID(Ax),Ampere,900.0,1005.0,7.0,54200.0,2020-05-14,1215.0,48.0,6144.0,1870.0,HBM2e,6912,108,432,48.0,400.0,55570.0,13890.0,https://www.techpowerup.com/gpu-specs/grid-a100b.c3578,2020,222.3,estimated,1.1166666666666667
+NVIDIA,GRID M10-8Q,GM107,GRID(Mx),Maxwell,1033.0,1306.0,28.0,1870.0,2016-05-18,1300.0,8.0,128.0,83.2,GDDR5,640,5,0,2.0,225.0,,1672.0,https://www.techpowerup.com/gpu-specs/grid-m10-8q.c3086,2016,,unknown,1.2642787996127782
+NVIDIA,GRID M40,GM107,GRID(Mx),Maxwell,1033.0,1033.0,28.0,1870.0,2016-05-18,1300.0,8.0,128.0,83.2,GDDR5,384,3,0,2.0,50.0,,793.3,https://www.techpowerup.com/gpu-specs/grid-m40.c2518,2016,,unknown,1.0
+NVIDIA,GRID M6-8Q,GM204,GRID(Mx),Maxwell 2.0,722.0,722.0,28.0,5200.0,2015-08-30,1253.0,8.0,256.0,160.4,GDDR5,1536,12,0,2.0,100.0,,2218.0,https://www.techpowerup.com/gpu-specs/grid-m6-8q.c3052,2015,,unknown,1.0
+NVIDIA,GRID M60-8Q,GM204,GRID(Mx),Maxwell 2.0,557.0,1178.0,28.0,5200.0,2015-08-30,1253.0,8.0,256.0,160.4,GDDR5,2048,16,0,2.0,225.0,,4825.0,https://www.techpowerup.com/gpu-specs/grid-m60-8q.c3089,2015,,unknown,2.1149012567324954
+NVIDIA,GeForce GTX 1060 6 GB,GP106,GeForce 10,Pascal,1506.0,1709.0,16.0,4400.0,2016-07-19,2002.0,6.0,192.0,192.2,GDDR5,1280,10,0,1.5,120.0,68.36,4375.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1060-6-gb.c2862,2016,,unknown,1.1347941567065074
+NVIDIA,GeForce GTX 1060 6 GB 9Gbps,GP106,GeForce 10,Pascal,1506.0,1709.0,16.0,4400.0,2017-04-20,2257.0,6.0,192.0,216.7,GDDR5,1280,10,0,1.5,120.0,68.36,4375.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1060-6-gb-9gbps.c2952,2017,,unknown,1.1347941567065074
+NVIDIA,GeForce GTX 1060 6 GB GDDR5X,GP104,GeForce 10,Pascal,1506.0,1709.0,16.0,7200.0,2018-10-18,1001.0,6.0,192.0,192.2,GDDR5X,1280,10,0,1.5,120.0,68.36,4375.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1060-6-gb-gddr5x.c3328,2018,,unknown,1.1347941567065074
+NVIDIA,GeForce GTX 1060 6 GB GP104,GP104,GeForce 10,Pascal,1506.0,1708.0,16.0,7200.0,2018-03-08,2002.0,6.0,192.0,192.2,GDDR5,1280,10,0,1.5,120.0,68.32,4372.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1060-6-gb-gp104.c3250,2018,,unknown,1.1341301460823374
+NVIDIA,GeForce GTX 1060 6 GB Rev. 2,GP106,GeForce 10,Pascal,1506.0,1709.0,16.0,4400.0,2018-01-05,2002.0,6.0,192.0,192.2,GDDR5,1280,10,0,1.5,120.0,68.36,4375.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1060-6-gb-rev-2.c3063,2018,,unknown,1.1347941567065074
+NVIDIA,GeForce GTX 1060 Max-Q,GP106,GeForce 10 Mobile,Pascal,1063.0,1480.0,16.0,4400.0,2017-06-27,2002.0,6.0,192.0,192.2,GDDR5,1280,10,0,1.5,80.0,59.2,3789.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1060-max-q.c2976,2017,,unknown,1.3922859830667922
+NVIDIA,GeForce GTX 1060 Mobile,GP106,GeForce 10 Mobile,Pascal,1405.0,1671.0,16.0,4400.0,2016-08-15,2002.0,6.0,192.0,192.2,GDDR5,1280,10,0,1.5,80.0,66.84,4277.999999999999,https://www.techpowerup.com/gpu-specs/geforce-gtx-1060-mobile.c3016,2016,,unknown,1.1893238434163702
+NVIDIA,GeForce GTX 1070,GP104,GeForce 10,Pascal,1506.0,1683.0,16.0,7200.0,2016-06-10,2002.0,8.0,256.0,256.3,GDDR5,1920,15,0,2.0,150.0,101.0,6463.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1070.c2840,2016,,unknown,1.1175298804780875
+NVIDIA,GeForce GTX 1070 GDDR5X,GP104,GeForce 10,Pascal,1506.0,1683.0,16.0,7200.0,2018-12-04,1001.0,8.0,256.0,256.3,GDDR5X,1920,15,0,2.0,150.0,101.0,6463.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1070-gddr5x.c3343,2018,,unknown,1.1175298804780875
+NVIDIA,GeForce GTX 1070 Max-Q,GP104B,GeForce 10 Mobile,Pascal,1215.0,1379.0,16.0,7200.0,2017-06-27,2002.0,8.0,256.0,256.3,GDDR5,2048,16,0,2.0,115.0,88.26,5648.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1070-max-q.c2974,2017,,unknown,1.1349794238683129
+NVIDIA,GeForce GTX 1070 Mobile,GP104B,GeForce 10 Mobile,Pascal,1443.0,1645.0,16.0,7200.0,2016-08-15,2002.0,8.0,256.0,256.3,GDDR5,2048,16,0,2.0,120.0,105.3,6738.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1070-mobile.c2869,2016,,unknown,1.13998613998614
+NVIDIA,GeForce GTX 1070 Ti,GP104,GeForce 10,Pascal,1607.0,1683.0,16.0,7200.0,2017-11-02,2002.0,8.0,256.0,256.3,GDDR5,2432,19,0,2.0,180.0,127.9,8186.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1070-ti.c3010,2017,,unknown,1.047293092719353
+NVIDIA,GeForce GTX 1080,GP104,GeForce 10,Pascal,1607.0,1733.0,16.0,7200.0,2016-05-27,1251.0,8.0,256.0,320.3,GDDR5X,2560,20,0,2.0,180.0,138.6,8873.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1080.c2839,2016,,unknown,1.0784069695084006
+NVIDIA,GeForce GTX 1080 11Gbps,GP104,GeForce 10,Pascal,1607.0,1733.0,16.0,7200.0,2017-04-20,1376.0,8.0,256.0,352.3,GDDR5X,2560,20,0,2.0,180.0,138.6,8873.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1080-11gbps.c2951,2017,,unknown,1.0784069695084006
+NVIDIA,GeForce GTX 1080 Max-Q,GP104B,GeForce 10 Mobile,Pascal,1277.0,1366.0,16.0,7200.0,2017-06-27,1251.0,8.0,256.0,320.3,GDDR5X,2560,20,0,2.0,150.0,109.3,6994.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1080-max-q.c2975,2017,,unknown,1.0696945967110416
+NVIDIA,GeForce GTX 1080 Mobile,GP104B,GeForce 10 Mobile,Pascal,1557.0,1734.0,16.0,7200.0,2016-08-15,1251.0,8.0,256.0,320.3,GDDR5X,2560,20,0,2.0,150.0,138.7,8878.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1080-mobile.c2870,2016,,unknown,1.1136801541425818
+NVIDIA,GeForce GTX 1080 Ti,GP102,GeForce 10,Pascal,1481.0,1582.0,16.0,11800.0,2017-03-10,1376.0,11.0,352.0,484.4,GDDR5X,3584,28,0,2.75,250.0,177.2,11340.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1080-ti.c2877,2017,,unknown,1.0681971640783254
+NVIDIA,GeForce GTX 1660,TU116,GeForce 16,Turing,1530.0,1785.0,12.0,6600.0,2019-03-14,2001.0,6.0,192.0,192.1,GDDR5,1408,22,0,1.5,120.0,10050.0,5027.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1660.c3365,2019,,unknown,1.1666666666666667
+NVIDIA,GeForce GTX 1660 SUPER,TU116,GeForce 16,Turing,1530.0,1785.0,12.0,6600.0,2019-10-29,1750.0,6.0,192.0,336.0,GDDR6,1408,22,0,1.5,125.0,10050.0,5027.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1660-super.c3458,2019,,unknown,1.1666666666666667
+NVIDIA,GeForce GTX 1660 Ti,TU116,GeForce 16,Turing,1500.0,1770.0,12.0,6600.0,2019-02-22,1500.0,6.0,192.0,288.0,GDDR6,1536,24,0,1.5,120.0,10870.0,5437.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-1660-ti.c3364,2019,,unknown,1.18
+NVIDIA,GeForce GTX 780 6 GB,GK110B,GeForce 700,Kepler,863.0,902.0,28.0,7080.0,2013-09-10,1502.0,6.0,384.0,288.4,GDDR5,2304,0,0,1.5,250.0,,4155.999999999999,https://www.techpowerup.com/gpu-specs/geforce-gtx-780-6-gb.c2707,2013,,unknown,1.045191193511008
+NVIDIA,GeForce GTX 880M,GK104,GeForce 800M,Kepler,954.0,993.0,28.0,3540.0,2014-03-12,1250.0,8.0,256.0,160.0,GDDR5,1536,0,0,0.5,122.0,,3050.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-880m.c2534,2014,,unknown,1.0408805031446542
+NVIDIA,GeForce GTX 980 Ti,GM200,GeForce 900,Maxwell 2.0,1000.0,1076.0,28.0,8000.0,2015-06-02,1753.0,6.0,384.0,336.6,GDDR5,2816,22,0,3.0,250.0,,6060.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-980-ti.c2724,2015,,unknown,1.076
+NVIDIA,GeForce GTX 980MX,GM204,GeForce 900M,Maxwell 2.0,1050.0,1178.0,28.0,5200.0,2016-06-01,1500.0,8.0,256.0,192.0,GDDR5,1664,13,0,2.0,148.0,,3920.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-980mx.c2808,2016,,unknown,1.121904761904762
+NVIDIA,GeForce GTX TITAN,GK110,GeForce 700,Kepler,836.0,876.0,28.0,7080.0,2013-02-19,1502.0,6.0,384.0,288.4,GDDR5,2688,0,0,1.5,250.0,,4709.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-titan.c1996,2013,,unknown,1.0478468899521531
+NVIDIA,GeForce GTX TITAN BLACK,GK110B,GeForce 700,Kepler,889.0,980.0,28.0,7080.0,2014-02-18,1750.0,6.0,384.0,336.0,GDDR5,2880,0,0,1.5,250.0,,5645.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-titan-black.c2549,2014,,unknown,1.1023622047244095
+NVIDIA,GeForce GTX TITAN X,GM200,GeForce 900,Maxwell 2.0,1000.0,1089.0,28.0,8000.0,2015-03-17,1753.0,12.0,384.0,336.6,GDDR5,3072,24,0,3.0,250.0,,6691.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-titan-x.c2632,2015,,unknown,1.089
+NVIDIA,GeForce GTX TITAN Z,GK110B,GeForce 700,Kepler,705.0,876.0,28.0,7080.0,2014-05-28,1750.0,6.0,384.0,336.0,GDDR5,2880,0,0,1.5,375.0,,5046.0,https://www.techpowerup.com/gpu-specs/geforce-gtx-titan-z.c2575,2014,,unknown,1.2425531914893617
+NVIDIA,GeForce RTX 2060,TU106,GeForce 20,Turing,1365.0,1680.0,12.0,10800.0,2019-01-07,1750.0,6.0,192.0,336.0,GDDR6,1920,30,240,3.0,160.0,12900.0,6451.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2060.c3310,2019,51.6,estimated,1.2307692307692308
+NVIDIA,GeForce RTX 2060 12 GB,TU106,GeForce 20,Turing,1470.0,1650.0,12.0,10800.0,2021-12-07,1750.0,12.0,192.0,336.0,GDDR6,2176,34,272,3.0,184.0,14360.0,7181.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2060-12-gb.c3836,2021,57.4,estimated,1.1224489795918366
+NVIDIA,GeForce RTX 2060 Max-Q,TU106,GeForce 20 Mobile,Turing,975.0,1185.0,12.0,10800.0,2020-01-29,1375.0,6.0,192.0,264.0,GDDR6,1920,30,240,3.0,65.0,9101.0,4550.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2060-max-q.c3533,2020,36.4,estimated,1.2153846153846153
+NVIDIA,GeForce RTX 2060 Max-Q Refresh,TU106B,GeForce 20 Mobile,Turing,960.0,1200.0,12.0,10800.0,2019-01-29,1353.0,6.0,192.0,259.8,GDDR6,1920,30,240,3.0,115.0,9216.0,4608.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2060-max-q-refresh.c3628,2019,36.9,estimated,1.25
+NVIDIA,GeForce RTX 2060 Mobile,TU106,GeForce 20 Mobile,Turing,960.0,1200.0,12.0,10800.0,2019-01-29,1750.0,6.0,192.0,336.0,GDDR6,1920,30,240,3.0,115.0,9216.0,4608.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2060-mobile.c3348,2019,36.9,estimated,1.25
+NVIDIA,GeForce RTX 2060 Mobile Refresh,TU106B,GeForce 20 Mobile,Turing,1005.0,1560.0,12.0,10800.0,2019-01-29,1375.0,6.0,192.0,264.0,GDDR6,1920,30,240,3.0,65.0,11980.0,5990.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2060-mobile-refresh.c3567,2019,47.9,estimated,1.5522388059701493
+NVIDIA,GeForce RTX 2060 SUPER,TU106,GeForce 20,Turing,1470.0,1650.0,12.0,10800.0,2019-07-09,1750.0,8.0,256.0,448.0,GDDR6,2176,34,272,4.0,175.0,14360.0,7181.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2060-super.c3441,2019,57.4,estimated,1.1224489795918366
+NVIDIA,GeForce RTX 2060 SUPER Mobile,TU106,GeForce 20 Mobile,Turing,1470.0,1530.0,12.0,10800.0,2019-07-09,1750.0,8.0,256.0,448.0,GDDR6,2176,34,272,4.0,175.0,13320.0,6659.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2060-super-mobile.c4150,2019,53.3,estimated,1.0408163265306123
+NVIDIA,GeForce RTX 2060 TU104,TU104,GeForce 20,Turing,1365.0,1680.0,12.0,13600.0,2020-01-10,1750.0,6.0,192.0,336.0,GDDR6,1920,30,240,3.0,160.0,12900.0,6451.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2060-tu104.c3495,2020,51.6,estimated,1.2307692307692308
+NVIDIA,GeForce RTX 2070,TU106,GeForce 20,Turing,1410.0,1620.0,12.0,10800.0,2018-10-17,1750.0,8.0,256.0,448.0,GDDR6,2304,36,288,4.0,175.0,14930.0,7465.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2070.c3252,2018,59.7,estimated,1.148936170212766
+NVIDIA,GeForce RTX 2070 Max-Q,TU106,GeForce 20 Mobile,Turing,885.0,1185.0,12.0,10800.0,2019-01-29,1500.0,8.0,256.0,384.0,GDDR6,2304,36,288,4.0,90.0,10920.0,5460.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2070-max-q.c3392,2019,43.7,estimated,1.3389830508474576
+NVIDIA,GeForce RTX 2070 Max-Q Refresh,TU106B,GeForce 20 Mobile,Turing,900.0,1125.0,12.0,10800.0,2020-03-04,1375.0,8.0,256.0,352.0,GDDR6,2304,36,288,4.0,115.0,10370.0,5184.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2070-max-q-refresh.c3574,2020,41.5,estimated,1.25
+NVIDIA,GeForce RTX 2070 Mobile,TU106,GeForce 20 Mobile,Turing,1215.0,1440.0,12.0,10800.0,2019-01-29,1750.0,8.0,256.0,448.0,GDDR6,2304,36,288,4.0,115.0,13270.0,6636.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2070-mobile.c3349,2019,53.1,estimated,1.1851851851851851
+NVIDIA,GeForce RTX 2070 Mobile Refresh,TU106B,GeForce 20 Mobile,Turing,1260.0,1455.0,12.0,10800.0,2020-03-04,1375.0,8.0,256.0,352.0,GDDR6,2304,36,288,4.0,115.0,13410.0,6705.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2070-mobile-refresh.c3573,2020,53.6,estimated,1.1547619047619047
+NVIDIA,GeForce RTX 2070 SUPER,TU104,GeForce 20,Turing,1605.0,1770.0,12.0,13600.0,2019-07-09,1750.0,8.0,256.0,448.0,GDDR6,2560,40,320,4.0,215.0,18120.0,9062.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2070-super.c3440,2019,72.5,estimated,1.102803738317757
+NVIDIA,GeForce RTX 2070 SUPER Max-Q,TU104,GeForce 20 Mobile,Turing,930.0,1155.0,12.0,13600.0,2020-04-02,1375.0,8.0,256.0,352.0,GDDR6,2560,40,320,4.0,80.0,11830.0,5914.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2070-super-max-q.c3563,2020,47.3,estimated,1.2419354838709677
+NVIDIA,GeForce RTX 2070 SUPER Mobile,TU104,GeForce 20 Mobile,Turing,1140.0,1380.0,12.0,13600.0,2020-04-02,1750.0,8.0,256.0,448.0,GDDR6,2560,40,320,4.0,115.0,14130.0,7066.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2070-super-mobile.c3514,2020,56.5,estimated,1.2105263157894737
+NVIDIA,GeForce RTX 2080,TU104,GeForce 20,Turing,1515.0,1710.0,12.0,13600.0,2018-09-20,1750.0,8.0,256.0,448.0,GDDR6,2944,46,368,4.0,215.0,20140.0,10070.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2080.c3224,2018,80.5,estimated,1.1287128712871286
+NVIDIA,GeForce RTX 2080 Max-Q,TU104,GeForce 20 Mobile,Turing,735.0,1095.0,12.0,13600.0,2019-01-29,1500.0,8.0,256.0,384.0,GDDR6,2944,46,368,4.0,80.0,12890.0,6447.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2080-max-q.c3363,2019,51.6,estimated,1.489795918367347
+NVIDIA,GeForce RTX 2080 Mobile,TU104,GeForce 20 Mobile,Turing,1380.0,1590.0,12.0,13600.0,2019-01-29,1750.0,8.0,256.0,448.0,GDDR6,2944,46,368,4.0,150.0,18720.0,9362.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2080-mobile.c3312,2019,74.9,estimated,1.1521739130434783
+NVIDIA,GeForce RTX 2080 SUPER,TU104,GeForce 20,Turing,1650.0,1815.0,12.0,13600.0,2019-07-23,1937.0,8.0,256.0,495.9,GDDR6,3072,48,384,4.0,250.0,22300.0,11150.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2080-super.c3439,2019,89.2,estimated,1.1
+NVIDIA,GeForce RTX 2080 SUPER Max-Q,TU104,GeForce 20 Mobile,Turing,735.0,975.0,12.0,13600.0,2020-04-02,1375.0,8.0,256.0,352.0,GDDR6,3072,48,384,4.0,80.0,11980.0,5990.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2080-super-max-q.c3566,2020,47.9,estimated,1.3265306122448979
+NVIDIA,GeForce RTX 2080 SUPER Mobile,TU104,GeForce 20 Mobile,Turing,1365.0,1560.0,12.0,13600.0,2020-04-02,1750.0,8.0,256.0,448.0,GDDR6,3072,48,384,4.0,150.0,19170.0,9585.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2080-super-mobile.c3513,2020,76.7,estimated,1.1428571428571428
+NVIDIA,GeForce RTX 2080 Ti,TU102,GeForce 20,Turing,1350.0,1545.0,12.0,18600.0,2018-09-20,1750.0,11.0,352.0,616.0,GDDR6,4352,68,544,5.5,250.0,26900.0,13450.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-2080-ti.c3305,2018,107.6,estimated,1.1444444444444444
+NVIDIA,GeForce RTX 3050 6 GB,GA107,GeForce 30,Ampere,1042.0,1470.0,8.0,8700.0,2024-02-02,1750.0,6.0,96.0,168.0,GDDR6,2304,18,72,2.0,70.0,6774.0,6774.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3050-6-gb.c4188,2024,27.1,estimated,1.4107485604606527
+NVIDIA,GeForce RTX 3050 8 GB,GA106,GeForce 30,Ampere,1552.0,1777.0,8.0,12000.0,2022-01-04,1750.0,8.0,128.0,224.0,GDDR6,2560,20,80,2.0,130.0,9098.0,9098.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3050-8-gb.c3858,2022,36.4,estimated,1.1449742268041236
+NVIDIA,GeForce RTX 3050 8 GB GA107,GA107,GeForce 30,Ampere,1552.0,1777.0,8.0,8700.0,2022-12-16,1750.0,8.0,128.0,224.0,GDDR6,2560,20,80,2.0,115.0,9098.0,9098.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3050-8-gb-ga107.c3880,2022,36.4,estimated,1.1449742268041236
+NVIDIA,GeForce RTX 3050 Max-Q Refresh 6 GB,GA107,GeForce 30 Mobile,Ampere,622.0,990.0,8.0,8700.0,2022-07-06,1375.0,6.0,96.0,132.0,GDDR6,2560,20,80,2.0,35.0,5069.0,5069.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3050-max-q-refresh-6-gb.c3970,2022,20.3,estimated,1.5916398713826367
+NVIDIA,GeForce RTX 3050 Mobile Refresh 6 GB,GA107,GeForce 30 Mobile,Ampere,1237.0,1492.0,8.0,8700.0,2022-07-06,1750.0,6.0,96.0,168.0,GDDR6,2560,20,80,2.0,75.0,7639.0,7639.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3050-mobile-refresh-6-gb.c3971,2022,30.6,estimated,1.206143896523848
+NVIDIA,GeForce RTX 3050 OEM,GA106,GeForce 30,Ampere,1515.0,1755.0,8.0,12000.0,2022-01-04,1750.0,8.0,128.0,224.0,GDDR6,2304,18,72,2.0,130.0,8087.0,8087.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3050-oem.c3915,2022,32.3,estimated,1.1584158415841583
+NVIDIA,GeForce RTX 3060 12 GB,GA106,GeForce 30,Ampere,1320.0,1777.0,8.0,12000.0,2021-01-12,1875.0,12.0,192.0,360.0,GDDR6,3584,28,112,3.0,170.0,12740.0,12740.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3060-12-gb.c3682,2021,51.0,estimated,1.3462121212121212
+NVIDIA,GeForce RTX 3060 12 GB GA104,GA104,GeForce 30,Ampere,1320.0,1777.0,8.0,17400.0,2021-09-01,1875.0,12.0,192.0,360.0,GDDR6,3584,28,112,3.0,170.0,12740.0,12740.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3060-12-gb-ga104.c3832,2021,51.0,estimated,1.3462121212121212
+NVIDIA,GeForce RTX 3060 3840SP,GA106,GeForce 30,Ampere,1627.0,1852.0,8.0,12000.0,2021-01-01,1750.0,6.0,192.0,336.0,GDDR6,3840,30,120,3.0,185.0,14220.0,14220.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3060-3840sp.c4080,2021,56.9,estimated,1.1382913337430853
+NVIDIA,GeForce RTX 3060 8 GB,GA106,GeForce 30,Ampere,1320.0,1777.0,8.0,12000.0,2022-10-12,1875.0,8.0,128.0,240.0,GDDR6,3584,28,112,3.0,170.0,12740.0,12740.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3060-8-gb.c3937,2022,51.0,estimated,1.3462121212121212
+NVIDIA,GeForce RTX 3060 8 GB GA104,GA104,GeForce 30,Ampere,1320.0,1777.0,8.0,17400.0,2022-10-01,1875.0,8.0,128.0,240.0,GDDR6,3584,28,112,3.0,195.0,12740.0,12740.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3060-8-gb-ga104.c4132,2022,51.0,estimated,1.3462121212121212
+NVIDIA,GeForce RTX 3060 Max-Q,GA106,GeForce 30 Mobile,Ampere,817.0,1282.0,8.0,12000.0,2021-01-12,1500.0,6.0,192.0,288.0,GDDR6,3840,30,120,3.0,60.0,9846.0,9846.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3060-max-q.c3752,2021,39.4,estimated,1.569155446756426
+NVIDIA,GeForce RTX 3060 Mobile,GA106,GeForce 30 Mobile,Ampere,900.0,1425.0,8.0,12000.0,2021-01-12,1750.0,6.0,192.0,336.0,GDDR6,3840,30,120,3.0,80.0,10940.0,10940.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3060-mobile.c3757,2021,43.8,estimated,1.5833333333333333
+NVIDIA,GeForce RTX 3060 Ti,GA104,GeForce 30,Ampere,1410.0,1665.0,8.0,17400.0,2020-12-01,1750.0,8.0,256.0,448.0,GDDR6,4864,38,152,4.0,200.0,16200.0,16200.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3060-ti.c3681,2020,64.8,estimated,1.1808510638297873
+NVIDIA,GeForce RTX 3060 Ti GA103,GA103,GeForce 30,Ampere,1410.0,1665.0,8.0,22000.0,2022-02-23,1750.0,8.0,256.0,448.0,GDDR6,4864,38,152,4.0,200.0,16200.0,16200.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3060-ti-ga103.c3872,2022,64.8,estimated,1.1808510638297873
+NVIDIA,GeForce RTX 3060 Ti GDDR6X,GA104,GeForce 30,Ampere,1410.0,1665.0,8.0,17400.0,2022-10-19,1188.0,8.0,256.0,608.3,GDDR6X,4864,38,152,4.0,225.0,16200.0,16200.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3060-ti-gddr6x.c3935,2022,64.8,estimated,1.1808510638297873
+NVIDIA,GeForce RTX 3070,GA104,GeForce 30,Ampere,1500.0,1725.0,8.0,17400.0,2020-09-01,1750.0,8.0,256.0,448.0,GDDR6,5888,46,184,4.0,220.0,20310.0,20310.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3070.c3674,2020,81.3,estimated,1.15
+NVIDIA,GeForce RTX 3070 Max-Q,GA104,GeForce 30 Mobile,Ampere,780.0,1290.0,8.0,17400.0,2021-01-12,1500.0,8.0,256.0,384.0,GDDR6,5120,40,160,4.0,80.0,13210.0,13210.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3070-max-q.c3685,2021,52.8,estimated,1.6538461538461537
+NVIDIA,GeForce RTX 3070 Mobile,GA104,GeForce 30 Mobile,Ampere,1110.0,1560.0,8.0,17400.0,2021-01-12,1750.0,8.0,256.0,448.0,GDDR6,5120,40,160,4.0,115.0,15970.0,15970.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3070-mobile.c3712,2021,63.9,estimated,1.4054054054054055
+NVIDIA,GeForce RTX 3070 Ti,GA104,GeForce 30,Ampere,1575.0,1770.0,8.0,17400.0,2021-05-31,1188.0,8.0,256.0,608.3,GDDR6X,6144,48,192,4.0,290.0,21750.0,21750.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3070-ti.c3675,2021,87.0,estimated,1.1238095238095238
+NVIDIA,GeForce RTX 3070 Ti 8 GB GA102,GA102,GeForce 30,Ampere,1575.0,1770.0,8.0,28300.0,2022-10-21,1188.0,8.0,256.0,608.3,GDDR6X,6144,48,192,4.0,290.0,21750.0,21750.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3070-ti-8-gb-ga102.c3936,2022,87.0,estimated,1.1238095238095238
+NVIDIA,GeForce RTX 3070 Ti Max-Q,GA104,GeForce 30 Mobile,Ampere,510.0,1035.0,8.0,17400.0,2022-01-04,1500.0,8.0,256.0,384.0,GDDR6,5888,46,184,4.0,80.0,12190.0,12190.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3070-ti-max-q.c3923,2022,48.8,estimated,2.0294117647058822
+NVIDIA,GeForce RTX 3070 Ti Mobile,GA104,GeForce 30 Mobile,Ampere,915.0,1410.0,8.0,17400.0,2022-01-04,1750.0,8.0,256.0,448.0,GDDR6,5888,46,184,4.0,115.0,16600.000000000004,16600.000000000004,https://www.techpowerup.com/gpu-specs/geforce-rtx-3070-ti-mobile.c3852,2022,66.4,estimated,1.540983606557377
+NVIDIA,GeForce RTX 3070 TiM,GA104,GeForce 30,Ampere,915.0,1410.0,8.0,17400.0,2022-11-01,1750.0,8.0,256.0,448.0,GDDR6,5888,46,184,4.0,220.0,16600.000000000004,16600.000000000004,https://www.techpowerup.com/gpu-specs/geforce-rtx-3070-tim.c3951,2022,66.4,estimated,1.540983606557377
+NVIDIA,GeForce RTX 3080,GA102,GeForce 30,Ampere,1440.0,1710.0,8.0,28300.0,2020-09-01,1188.0,10.0,320.0,760.3,GDDR6X,8704,68,272,5.0,320.0,29770.0,29770.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3080.c3621,2020,119.1,estimated,1.1875
+NVIDIA,GeForce RTX 3080 12 GB,GA102,GeForce 30,Ampere,1260.0,1710.0,8.0,28300.0,2022-01-11,1188.0,12.0,384.0,912.4,GDDR6X,8960,70,280,6.0,350.0,30640.0,30640.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3080-12-gb.c3834,2022,122.6,estimated,1.3571428571428572
+NVIDIA,GeForce RTX 3080 Max-Q,GA104,GeForce 30 Mobile,Ampere,780.0,1245.0,8.0,17400.0,2021-01-12,1500.0,8.0,256.0,384.0,GDDR6,6144,48,192,4.0,80.0,15300.0,15300.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3080-max-q.c3753,2021,61.2,estimated,1.5961538461538463
+NVIDIA,GeForce RTX 3080 Mobile,GA104,GeForce 30 Mobile,Ampere,1110.0,1545.0,8.0,17400.0,2021-01-12,1750.0,8.0,256.0,448.0,GDDR6,6144,48,192,4.0,115.0,18980.0,18980.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3080-mobile.c3684,2021,75.9,estimated,1.3918918918918919
+NVIDIA,GeForce RTX 3080 Ti,GA102,GeForce 30,Ampere,1365.0,1665.0,8.0,28300.0,2021-05-31,1188.0,12.0,384.0,912.4,GDDR6X,10240,80,320,6.0,350.0,34100.0,34100.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3080-ti.c3735,2021,136.4,estimated,1.2197802197802199
+NVIDIA,GeForce RTX 3080 Ti 20 GB,GA102,GeForce 30,Ampere,1335.0,1665.0,8.0,28300.0,2022-01-01,1188.0,20.0,320.0,760.3,GDDR6X,10240,80,320,6.0,350.0,34100.0,34100.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3080-ti-20-gb.c3831,2022,136.4,estimated,1.247191011235955
+NVIDIA,GeForce RTX 3080 Ti Max-Q,GA103,GeForce 30 Mobile,Ampere,585.0,1125.0,8.0,22000.0,2022-01-25,1500.0,16.0,256.0,384.0,GDDR6,7424,58,232,4.0,80.0,16700.0,16700.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3080-ti-max-q.c3841,2022,66.8,estimated,1.9230769230769231
+NVIDIA,GeForce RTX 3080 Ti Mobile,GA103,GeForce 30 Mobile,Ampere,810.0,1260.0,8.0,22000.0,2022-01-25,2000.0,16.0,256.0,512.0,GDDR6,7424,58,232,4.0,115.0,18710.0,18710.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3080-ti-mobile.c3840,2022,74.8,estimated,1.5555555555555556
+NVIDIA,GeForce RTX 3090,GA102,GeForce 30,Ampere,1395.0,1695.0,8.0,28300.0,2020-09-01,1219.0,24.0,384.0,936.2,GDDR6X,10496,82,328,6.0,350.0,35580.0,35580.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3090.c3622,2020,142.3,estimated,1.2150537634408602
+NVIDIA,GeForce RTX 3090 Ti,GA102,GeForce 30,Ampere,1560.0,1860.0,8.0,28300.0,2022-01-27,1313.0,24.0,384.0,1010.0,GDDR6X,10752,84,336,6.0,450.0,40000.0,40000.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-3090-ti.c3829,2022,160.0,estimated,1.1923076923076923
+NVIDIA,GeForce RTX 4050 Max-Q,AD107,GeForce 40 Mobile,Ada Lovelace,1140.0,1605.0,5.0,18900.0,2023-01-03,2000.0,6.0,96.0,192.0,GDDR6,2560,20,80,12.0,35.0,8218.0,8218.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4050-max-q.c3987,2023,32.9,estimated,1.4078947368421053
+NVIDIA,GeForce RTX 4050 Mobile,AD107,GeForce 40 Mobile,Ada Lovelace,1455.0,1755.0,5.0,18900.0,2023-01-03,2000.0,6.0,96.0,192.0,GDDR6,2560,20,80,12.0,50.0,8986.0,8986.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4050-mobile.c3953,2023,35.9,estimated,1.2061855670103092
+NVIDIA,GeForce RTX 4060,AD107,GeForce 40,Ada Lovelace,1830.0,2460.0,5.0,18900.0,2023-05-18,2125.0,8.0,128.0,272.0,GDDR6,3072,24,96,24.0,115.0,15110.0,15110.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4060.c4107,2023,60.5,estimated,1.3442622950819672
+NVIDIA,GeForce RTX 4060 AD106,AD106,GeForce 40,Ada Lovelace,1830.0,2460.0,5.0,22900.0,2024-04-01,2125.0,8.0,128.0,272.0,GDDR6,3072,24,96,24.0,115.0,15110.0,15110.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4060-ad106.c3891,2024,60.5,estimated,1.3442622950819672
+NVIDIA,GeForce RTX 4060 Max-Q,AD107,GeForce 40 Mobile,Ada Lovelace,1140.0,1470.0,5.0,18900.0,2023-01-03,2000.0,8.0,128.0,256.0,GDDR6,3072,24,96,32.0,35.0,9032.0,9032.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4060-max-q.c3986,2023,36.1,estimated,1.2894736842105263
+NVIDIA,GeForce RTX 4060 Mobile,AD107,GeForce 40 Mobile,Ada Lovelace,1545.0,1890.0,5.0,18900.0,2023-01-03,2000.0,8.0,128.0,256.0,GDDR6,3072,24,96,32.0,115.0,11610.0,11610.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4060-mobile.c3946,2023,46.4,estimated,1.2233009708737863
+NVIDIA,GeForce RTX 4060 Ti 16 GB,AD106,GeForce 40,Ada Lovelace,2310.0,2535.0,5.0,22900.0,2023-05-18,2250.0,16.0,128.0,288.0,GDDR6,4352,34,136,32.0,165.0,22060.0,22060.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4060-ti-16-gb.c4155,2023,88.3,estimated,1.0974025974025974
+NVIDIA,GeForce RTX 4060 Ti 8 GB,AD106,GeForce 40,Ada Lovelace,2310.0,2535.0,5.0,22900.0,2023-05-18,2250.0,8.0,128.0,288.0,GDDR6,4352,34,136,32.0,160.0,22060.0,22060.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4060-ti-8-gb.c3890,2023,88.3,estimated,1.0974025974025974
+NVIDIA,GeForce RTX 4060 Ti AD104,AD104,GeForce 40,Ada Lovelace,2310.0,2535.0,5.0,35800.0,2024-04-01,2250.0,8.0,128.0,288.0,GDDR6,4352,34,136,32.0,160.0,22060.0,22060.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4060-ti-ad104.c4204,2024,88.3,estimated,1.0974025974025974
+NVIDIA,GeForce RTX 4070,AD104,GeForce 40,Ada Lovelace,1920.0,2475.0,5.0,35800.0,2023-04-12,1313.0,12.0,192.0,504.2,GDDR6X,5888,46,184,36.0,200.0,29150.0,29150.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4070.c3924,2023,116.6,estimated,1.2890625
+NVIDIA,GeForce RTX 4070 AD103,AD103,GeForce 40,Ada Lovelace,1920.0,2475.0,5.0,45900.0,2024-03-01,1313.0,12.0,192.0,504.2,GDDR6X,5888,46,184,36.0,200.0,29150.0,29150.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4070-ad103.c4205,2024,116.6,estimated,1.2890625
+NVIDIA,GeForce RTX 4070 GDDR6,AD104,GeForce 40,Ada Lovelace,1920.0,2475.0,5.0,35800.0,2024-08-20,2500.0,12.0,192.0,480.0,GDDR6,5888,46,184,36.0,200.0,29150.0,29150.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4070-gddr6.c4228,2024,116.6,estimated,1.2890625
+NVIDIA,GeForce RTX 4070 Max-Q,AD106,GeForce 40 Mobile,Ada Lovelace,735.0,1230.0,5.0,22900.0,2023-01-03,2000.0,8.0,128.0,256.0,GDDR6,4608,36,144,32.0,35.0,11340.0,11340.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4070-max-q.c3954,2023,45.3,estimated,1.6734693877551021
+NVIDIA,GeForce RTX 4070 Mobile,AD106,GeForce 40 Mobile,Ada Lovelace,1395.0,1695.0,5.0,22900.0,2023-01-03,2000.0,8.0,128.0,256.0,GDDR6,4608,36,144,32.0,115.0,15620.0,15620.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4070-mobile.c3944,2023,62.5,estimated,1.2150537634408602
+NVIDIA,GeForce RTX 4070 SUPER,AD104,GeForce 40,Ada Lovelace,1980.0,2475.0,5.0,35800.0,2024-01-08,1313.0,12.0,192.0,504.2,GDDR6X,7168,56,224,48.0,220.0,35480.0,35480.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4070-super.c4186,2024,141.9,estimated,1.25
+NVIDIA,GeForce RTX 4070 Ti,AD104,GeForce 40,Ada Lovelace,2310.0,2610.0,5.0,35800.0,2023-01-03,1313.0,12.0,192.0,504.2,GDDR6X,7680,60,240,48.0,285.0,40090.0,40090.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4070-ti.c3950,2023,160.4,estimated,1.12987012987013
+NVIDIA,GeForce RTX 4070 Ti SUPER,AD103,GeForce 40,Ada Lovelace,2340.0,2610.0,5.0,45900.0,2024-01-08,1313.0,16.0,256.0,672.3,GDDR6X,8448,66,264,48.0,285.0,44100.0,44100.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4070-ti-super.c4187,2024,176.4,estimated,1.1153846153846154
+NVIDIA,GeForce RTX 4070 Ti SUPER AD102,AD102,GeForce 40,Ada Lovelace,2340.0,2610.0,5.0,76300.0,2024-06-10,1313.0,16.0,256.0,672.3,GDDR6X,8448,66,264,48.0,285.0,44100.0,44100.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4070-ti-super-ad102.c4215,2024,176.4,estimated,1.1153846153846154
+NVIDIA,GeForce RTX 4080,AD103,GeForce 40,Ada Lovelace,2205.0,2505.0,5.0,45900.0,2022-09-20,1400.0,16.0,256.0,716.8,GDDR6X,9728,76,304,64.0,320.0,48740.0,48740.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4080.c3888,2022,194.9,estimated,1.1360544217687074
+NVIDIA,GeForce RTX 4080 Max-Q,AD104,GeForce 40 Mobile,Ada Lovelace,795.0,1350.0,5.0,35800.0,2023-01-03,2250.0,12.0,192.0,432.0,GDDR6,7424,58,232,48.0,60.0,20040.0,20040.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4080-max-q.c3948,2023,80.2,estimated,1.6981132075471699
+NVIDIA,GeForce RTX 4080 Mobile,AD104,GeForce 40 Mobile,Ada Lovelace,1290.0,1665.0,5.0,35800.0,2023-01-03,2250.0,12.0,192.0,432.0,GDDR6,7424,58,232,48.0,110.0,24720.0,24720.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4080-mobile.c3947,2023,98.9,estimated,1.2906976744186047
+NVIDIA,GeForce RTX 4080 SUPER,AD103,GeForce 40,Ada Lovelace,2295.0,2550.0,5.0,45900.0,2024-01-08,1438.0,16.0,256.0,736.3,GDDR6X,10240,80,320,64.0,320.0,52220.0,52220.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4080-super.c4182,2024,208.9,estimated,1.1111111111111112
+NVIDIA,GeForce RTX 4090,AD102,GeForce 40,Ada Lovelace,2235.0,2520.0,5.0,76300.0,2022-09-20,1313.0,24.0,384.0,1010.0,GDDR6X,16384,128,512,72.0,450.0,82580.0,82580.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4090.c3889,2022,330.3,estimated,1.1275167785234899
+NVIDIA,GeForce RTX 4090 D,AD102,GeForce 40,Ada Lovelace,2280.0,2520.0,5.0,76300.0,2023-12-28,1313.0,24.0,384.0,1010.0,GDDR6X,14592,114,456,72.0,425.0,73540.0,73540.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4090-d.c4189,2023,294.2,estimated,1.105263157894737
+NVIDIA,GeForce RTX 4090 Max-Q,AD103,GeForce 40 Mobile,Ada Lovelace,930.0,1455.0,5.0,45900.0,2023-01-03,2250.0,16.0,256.0,576.0,GDDR6,9728,76,304,64.0,80.0,28310.0,28310.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-4090-max-q.c3988,2023,113.2,estimated,1.564516129032258
+NVIDIA,GeForce RTX 4090 Mobile,AD103,GeForce 40 Mobile,Ada Lovelace,1335.0,1695.0,5.0,45900.0,2023-01-03,2250.0,16.0,256.0,576.0,GDDR6,9728,76,304,64.0,120.0,32979.99999999999,32979.99999999999,https://www.techpowerup.com/gpu-specs/geforce-rtx-4090-mobile.c3949,2023,131.9,estimated,1.2696629213483146
+NVIDIA,GeForce RTX 5050,GB207,GeForce 50,Blackwell 2.0,2317.0,2572.0,5.0,16900.0,2025-07-01,2500.0,8.0,128.0,320.0,GDDR6,2560,20,80,24.0,130.0,13170.0,13170.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5050.c4220,2025,52.7,estimated,1.110056107034959
+NVIDIA,GeForce RTX 5050 Mobile,GB207,GeForce 50 Mobile,Blackwell 2.0,1020.0,1500.0,5.0,16900.0,2025-06-24,1500.0,8.0,128.0,384.0,GDDR7,2560,20,80,32.0,50.0,7680.0,7680.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5050-mobile.c4239,2025,30.7,estimated,1.4705882352941178
+NVIDIA,GeForce RTX 5060,GB206,GeForce 50,Blackwell 2.0,2280.0,2497.0,5.0,21900.0,2025-05-19,1750.0,8.0,128.0,448.0,GDDR7,3840,30,120,32.0,145.0,19180.0,19180.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5060.c4219,2025,76.7,estimated,1.0951754385964911
+NVIDIA,GeForce RTX 5060 Mobile,GB206,GeForce 50 Mobile,Blackwell 2.0,952.0,1455.0,5.0,21900.0,2025-05-20,1500.0,8.0,128.0,384.0,GDDR7,3328,26,104,32.0,45.0,9684.0,9684.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5060-mobile.c4230,2025,38.7,estimated,1.528361344537815
+NVIDIA,GeForce RTX 5060 Ti 16 GB,GB206,GeForce 50,Blackwell 2.0,2407.0,2572.0,5.0,21900.0,2025-04-16,1750.0,16.0,128.0,448.0,GDDR7,4608,36,144,32.0,180.0,23700.0,23700.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5060-ti-16-gb.c4292,2025,94.8,estimated,1.0685500623182385
+NVIDIA,GeForce RTX 5060 Ti 8 GB,GB206,GeForce 50,Blackwell 2.0,2407.0,2572.0,5.0,21900.0,2025-04-16,1750.0,8.0,128.0,448.0,GDDR7,4608,36,144,32.0,180.0,23700.0,23700.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5060-ti-8-gb.c4246,2025,94.8,estimated,1.0685500623182385
+NVIDIA,GeForce RTX 5070,GB205,GeForce 50,Blackwell 2.0,2325.0,2512.0,5.0,31100.0,2025-03-04,1750.0,12.0,192.0,672.0,GDDR7,6144,48,192,48.0,250.0,30870.0,30870.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5070.c4218,2025,123.5,estimated,1.0804301075268816
+NVIDIA,GeForce RTX 5070 Mobile,GB206,GeForce 50 Mobile,Blackwell 2.0,907.0,1425.0,5.0,21900.0,2025-04-01,1500.0,8.0,128.0,384.0,GDDR7,4608,36,144,32.0,50.0,13130.0,13130.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5070-mobile.c4237,2025,52.5,estimated,1.5711135611907387
+NVIDIA,GeForce RTX 5070 Ti,GB203,GeForce 50,Blackwell 2.0,2295.0,2452.0,5.0,45600.0,2025-02-20,1750.0,16.0,256.0,896.0,GDDR7,8960,70,280,48.0,300.0,43940.0,43940.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5070-ti.c4243,2025,175.8,estimated,1.068409586056645
+NVIDIA,GeForce RTX 5070 Ti Mobile,GB205,GeForce 50 Mobile,Blackwell 2.0,847.0,1447.0,5.0,31100.0,2025-03-01,1750.0,12.0,192.0,672.0,GDDR7,5888,46,184,48.0,60.0,17040.0,17040.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5070-ti-mobile.c4238,2025,68.2,estimated,1.7083825265643446
+NVIDIA,GeForce RTX 5080,GB203,GeForce 50,Blackwell 2.0,2295.0,2617.0,5.0,45600.0,2025-01-30,1875.0,16.0,256.0,960.0,GDDR7,10752,84,336,64.0,360.0,56280.0,56280.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5080.c4217,2025,225.1,estimated,1.1403050108932462
+NVIDIA,GeForce RTX 5080 Mobile,GB203,GeForce 50 Mobile,Blackwell 2.0,975.0,1500.0,5.0,45600.0,2025-04-02,1750.0,16.0,256.0,896.0,GDDR7,7680,60,240,64.0,80.0,23040.0,23040.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5080-mobile.c4236,2025,92.2,estimated,1.5384615384615385
+NVIDIA,GeForce RTX 5090,GB202,GeForce 50,Blackwell 2.0,2017.0,2407.0,5.0,92200.0,2025-01-30,1750.0,32.0,512.0,1790.0,GDDR7,21760,170,680,96.0,575.0,104800.0,104800.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5090.c4216,2025,419.0,estimated,1.193356470004958
+NVIDIA,GeForce RTX 5090 D,GB202,GeForce 50,Blackwell 2.0,2017.0,2407.0,5.0,92200.0,2025-01-30,1750.0,32.0,512.0,1790.0,GDDR7,21760,170,680,96.0,575.0,104800.0,104800.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5090-d.c4253,2025,419.0,estimated,1.193356470004958
+NVIDIA,GeForce RTX 5090 D V2,GB202,GeForce 50,Blackwell 2.0,2017.0,2407.0,5.0,92200.0,2025-08-15,1750.0,24.0,384.0,1340.0,GDDR7,21760,170,680,96.0,575.0,104800.0,104800.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5090-d-v2.c4310,2025,419.0,estimated,1.193356470004958
+NVIDIA,GeForce RTX 5090 Mobile,GB203,GeForce 50 Mobile,Blackwell 2.0,990.0,1515.0,5.0,45600.0,2025-03-27,1750.0,24.0,256.0,896.0,GDDR7,10496,82,328,64.0,95.0,31800.0,31800.0,https://www.techpowerup.com/gpu-specs/geforce-rtx-5090-mobile.c4235,2025,127.2,estimated,1.5303030303030303
+NVIDIA,H100 CNX,GH100,Server Hopper(Hxx),Hopper,690.0,1845.0,5.0,80000.0,2023-03-21,1593.0,80.0,5120.0,2040.0,HBM2e,14592,114,456,50.0,350.0,215400.0,53840.0,https://www.techpowerup.com/gpu-specs/h100-cnx.c4131,2023,861.5,estimated,2.6739130434782608
+NVIDIA,H100 NVL 94 GB,GH100,Server Hopper(Hxx),Hopper,1080.0,1785.0,5.0,80000.0,2023-03-21,1310.0,94.0,6016.0,3940.0,HBM3,16896,132,528,50.0,400.0,241300.0,60320.0,https://www.techpowerup.com/gpu-specs/h100-nvl-94-gb.c4327,2023,835.0,reported,1.6527777777777777
+NVIDIA,H100 PCIe 80 GB,GH100,Server Hopper(Hxx),Hopper,1095.0,1755.0,5.0,80000.0,2022-10-01,1593.0,80.0,5120.0,2040.0,HBM2e,14592,114,456,50.0,350.0,204900.0,51220.0,https://www.techpowerup.com/gpu-specs/h100-pcie-80-gb.c3899,2022,756.0,reported,1.6027397260273972
+NVIDIA,H100 PCIe 96 GB,GH100,Server Hopper(Hxx),Hopper,1665.0,1837.0,5.0,80000.0,2023-03-21,1313.0,96.0,5120.0,3360.0,HBM3,16896,132,528,50.0,700.0,248300.0,62080.0,https://www.techpowerup.com/gpu-specs/h100-pcie-96-gb.c4164,2023,993.2,estimated,1.1033033033033033
+NVIDIA,H100 SXM5 64 GB,GH100,Server Hopper(Hxx),Hopper,1665.0,1980.0,5.0,80000.0,2023-03-21,1313.0,64.0,3072.0,2020.0,HBM3,16896,132,528,30.0,700.0,267600.00000000006,66910.0,https://www.techpowerup.com/gpu-specs/h100-sxm5-64-gb.c4165,2023,1070.5,estimated,1.1891891891891893
+NVIDIA,H100 SXM5 80 GB,GH100,Server Hopper(Hxx),Hopper,1590.0,1980.0,5.0,80000.0,2022-10-01,1313.0,80.0,5120.0,3360.0,HBM3,16896,132,528,50.0,700.0,267600.00000000006,66910.0,https://www.techpowerup.com/gpu-specs/h100-sxm5-80-gb.c3900,2022,989.0,reported,1.2452830188679245
+NVIDIA,H100 SXM5 94 GB,GH100,Server Hopper(Hxx),Hopper,1350.0,1980.0,5.0,80000.0,2023-03-21,1313.0,94.0,5120.0,3360.0,HBM3,16896,132,528,50.0,700.0,267600.00000000006,66910.0,https://www.techpowerup.com/gpu-specs/h100-sxm5-94-gb.c4294,2023,1070.5,estimated,1.4666666666666666
+NVIDIA,H100 SXM5 96 GB,GH100,Server Hopper(Hxx),Hopper,1350.0,1980.0,5.0,80000.0,2023-03-21,1313.0,96.0,5120.0,3360.0,HBM3,16896,132,528,50.0,700.0,267600.00000000006,66910.0,https://www.techpowerup.com/gpu-specs/h100-sxm5-96-gb.c3974,2023,989.0,reported,1.4666666666666666
+NVIDIA,H200 NVL,GH100,Server Hopper(Hxx),Hopper,1365.0,1785.0,5.0,80000.0,2024-11-18,1593.0,141.0,6144.0,4890.0,HBM3e,16896,132,528,50.0,600.0,241300.0,60320.0,https://www.techpowerup.com/gpu-specs/h200-nvl.c4254,2024,835.0,reported,1.3076923076923077
+NVIDIA,H200 SXM 141 GB,GH100,Server Hopper(Hxx),Hopper,1500.0,1980.0,5.0,80000.0,2024-11-18,1593.0,141.0,6144.0,4890.0,HBM3e,16896,132,528,50.0,700.0,267600.00000000006,66910.0,https://www.techpowerup.com/gpu-specs/h200-sxm-141-gb.c4255,2024,989.0,reported,1.32
+NVIDIA,H800 PCIe 80 GB,GH100,Server Hopper(Hxx),Hopper,1095.0,1755.0,5.0,80000.0,2023-03-21,1593.0,80.0,5120.0,2040.0,HBM2e,14592,114,456,50.0,350.0,204900.0,51220.0,https://www.techpowerup.com/gpu-specs/h800-pcie-80-gb.c4181,2023,819.5,estimated,1.6027397260273972
+NVIDIA,H800 SXM5,GH100,Server Hopper(Hxx),Hopper,1095.0,1755.0,5.0,80000.0,2023-03-21,1313.0,80.0,5120.0,3360.0,HBM3,16896,132,528,50.0,700.0,237200.0,59300.0,https://www.techpowerup.com/gpu-specs/h800-sxm5.c3975,2023,948.9,estimated,1.6027397260273972
+NVIDIA,Jetson AGX Orin 32 GB,GA10B,Tegra(Ampere),Ampere,930.0,930.0,8.0,,2023-02-01,800.0,32.0,256.0,204.8,LPDDR5,1792,14,56,6.0,40.0,6666.0,3333.0,https://www.techpowerup.com/gpu-specs/jetson-agx-orin-32-gb.c4084,2023,13.3,estimated,1.0
+NVIDIA,Jetson AGX Orin 64 GB,GA10B,Tegra(Ampere),Ampere,1300.0,1300.0,8.0,,2023-03-01,800.0,64.0,256.0,204.8,LPDDR5,2048,16,64,6.0,60.0,10650.0,5325.0,https://www.techpowerup.com/gpu-specs/jetson-agx-orin-64-gb.c4085,2023,21.3,estimated,1.0
+NVIDIA,Jetson AGX Xavier 16 GB,GV10B,Tegra(Volta),Volta,854.0,1377.0,12.0,9000.0,2018-10-01,2133.0,16.0,256.0,136.5,LPDDR4X,512,8,64,0.5,30.0,2820.0,1410.0,https://www.techpowerup.com/gpu-specs/jetson-agx-xavier-16-gb.c3232,2018,11.3,estimated,1.6124121779859484
+NVIDIA,Jetson AGX Xavier 32 GB,GV10B,Tegra(Volta),Volta,854.0,1377.0,12.0,9000.0,2018-10-01,2133.0,32.0,256.0,136.5,LPDDR4X,512,8,64,0.5,30.0,2820.0,1410.0,https://www.techpowerup.com/gpu-specs/jetson-agx-xavier-32-gb.c4088,2018,11.3,estimated,1.6124121779859484
+NVIDIA,Jetson Orin NX 16 GB,GA10B,Tegra(Ampere),Ampere,918.0,918.0,8.0,,2023-02-01,800.0,16.0,128.0,102.4,LPDDR5,1024,8,32,4.0,25.0,3760.0,1880.0,https://www.techpowerup.com/gpu-specs/jetson-orin-nx-16-gb.c4086,2023,7.5,estimated,1.0
+NVIDIA,Jetson Orin NX 8 GB,GA10B,Tegra(Ampere),Ampere,765.0,765.0,8.0,,2023-03-01,800.0,8.0,128.0,102.4,LPDDR5,1024,8,32,4.0,20.0,3133.0,1567.0,https://www.techpowerup.com/gpu-specs/jetson-orin-nx-8-gb.c4081,2023,6.3,estimated,1.0
+NVIDIA,Jetson Orin Nano 8 GB,GA10B,Tegra(Ampere),Ampere,625.0,625.0,8.0,,2023-03-01,533.0,8.0,128.0,68.22,LPDDR5,1024,8,32,2.0,15.0,2560.0,1280.0,https://www.techpowerup.com/gpu-specs/jetson-orin-nano-8-gb.c4082,2023,5.1,estimated,1.0
+NVIDIA,Jetson Orin Nano Super,GA10B,Tegra(Ampere),Ampere,1020.0,1020.0,8.0,,2024-12-17,800.0,8.0,128.0,102.4,LPDDR5,1024,8,32,2.0,25.0,4178.0,2089.0,https://www.techpowerup.com/gpu-specs/jetson-orin-nano-super.c4377,2024,8.4,estimated,1.0
+NVIDIA,Jetson T4000,GB10B,Server Blackwell(Bxx),Blackwell,1665.0,2525.0,3.0,,2025-08-27,1067.0,64.0,256.0,273.2,LPDDR5X,1536,12,64,50.0,40.0,31030.0,7757.0,https://www.techpowerup.com/gpu-specs/jetson-t4000.c4369,2025,41.4,estimated,1.5165165165165164
+NVIDIA,Jetson T5000,GB10B,Server Blackwell(Bxx),Blackwell,1665.0,2525.0,3.0,,2025-08-27,1067.0,128.0,256.0,273.2,LPDDR5X,2560,20,96,50.0,40.0,51710.0,12930.0,https://www.techpowerup.com/gpu-specs/jetson-t5000.c4370,2025,62.1,estimated,1.5165165165165164
+NVIDIA,Jetson TX2,GP10B,Tegra(Pascal),Pascal,1300.0,1300.0,16.0,,2016-01-01,1866.0,8.0,128.0,59.71,LPDDR4,256,2,0,0.5,15.0,1331.2,665.6,https://www.techpowerup.com/gpu-specs/jetson-tx2.c3231,2016,,unknown,1.0
+NVIDIA,Jetson Xavier NX 16 GB,GV10B,Tegra(Volta),Volta,854.0,1100.0,12.0,9000.0,2020-05-14,1866.0,16.0,128.0,59.71,LPDDR4X,384,6,48,0.25,20.0,1690.0,844.8,https://www.techpowerup.com/gpu-specs/jetson-xavier-nx-16-gb.c4087,2020,6.8,estimated,1.288056206088993
+NVIDIA,Jetson Xavier NX 8 GB,GV10B,Tegra(Volta),Volta,854.0,1100.0,12.0,9000.0,2020-05-14,1866.0,8.0,128.0,59.71,LPDDR4X,384,6,48,0.25,15.0,1690.0,844.8,https://www.techpowerup.com/gpu-specs/jetson-xavier-nx-8-gb.c3642,2020,6.8,estimated,1.288056206088993
+NVIDIA,L20,AD102,Server Ada(Lxx),Ada Lovelace,1440.0,2520.0,5.0,76300.0,2023-11-16,2250.0,48.0,384.0,864.0,GDDR6,11776,92,368,96.0,275.0,59350.0,59350.0,https://www.techpowerup.com/gpu-specs/l20.c4206,2023,237.4,estimated,1.75
+NVIDIA,L4,AD104,Server Ada(Lxx),Ada Lovelace,795.0,2040.0,5.0,35800.0,2023-03-21,1563.0,24.0,192.0,300.1,GDDR6,7424,60,240,48.0,72.0,30290.0,30290.0,https://www.techpowerup.com/gpu-specs/l4.c4091,2023,121.0,reported,2.5660377358490565
+NVIDIA,L40,AD102,Server Ada(Lxx),Ada Lovelace,735.0,2490.0,5.0,76300.0,2022-10-13,2250.0,48.0,384.0,864.0,GDDR6,18176,142,568,96.0,300.0,90520.0,90520.0,https://www.techpowerup.com/gpu-specs/l40.c3959,2022,181.0,reported,3.3877551020408165
+NVIDIA,L40 CNX,AD102,Server Ada(Lxx),Ada Lovelace,1005.0,2475.0,5.0,76300.0,2022-10-13,2250.0,24.0,384.0,864.0,GDDR6,18176,142,568,48.0,300.0,89970.0,89970.0,https://www.techpowerup.com/gpu-specs/l40-cnx.c3961,2022,359.9,estimated,2.462686567164179
+NVIDIA,L40G,AD102,Server Ada(Lxx),Ada Lovelace,1005.0,2475.0,5.0,76300.0,2022-10-13,2250.0,24.0,384.0,864.0,GDDR6,18176,142,568,48.0,300.0,89970.0,89970.0,https://www.techpowerup.com/gpu-specs/l40g.c3960,2022,359.9,estimated,2.462686567164179
+NVIDIA,L40S,AD102,Server Ada(Lxx),Ada Lovelace,1110.0,2520.0,5.0,76300.0,2022-10-13,2250.0,48.0,384.0,864.0,GDDR6,18176,142,568,48.0,300.0,91610.0,91610.0,https://www.techpowerup.com/gpu-specs/l40s.c4173,2022,362.0,reported,2.27027027027027
+NVIDIA,P102-101,GP102,Mining GPUs,Pascal,1557.0,1670.0,16.0,11800.0,2018-01-01,2002.0,10.0,320.0,320.3,GDDR5,3200,25,0,2.5,250.0,167.0,10690.0,https://www.techpowerup.com/gpu-specs/p102-101.c3284,2018,,unknown,1.0725754656390494
+NVIDIA,P106-100,GP106,Mining GPUs,Pascal,1506.0,1709.0,16.0,4400.0,2017-06-19,2002.0,6.0,192.0,192.2,GDDR5,1280,10,0,1.5,120.0,68.36,4375.0,https://www.techpowerup.com/gpu-specs/p106-100.c2980,2017,,unknown,1.1347941567065074
+NVIDIA,PG506-207,GA100,Server Ampere(Axx),Ampere,930.0,1440.0,7.0,54200.0,2021-04-12,1215.0,24.0,3072.0,933.1,HBM2,3584,56,224,24.0,165.0,10320.0,10320.0,https://www.techpowerup.com/gpu-specs/pg506-207.c3962,2021,165.2,estimated,1.5483870967741935
+NVIDIA,PG506-217,GA100,Server Ampere(Axx),Ampere,930.0,1440.0,7.0,54200.0,2021-04-12,1215.0,24.0,3072.0,933.1,HBM2,3584,56,224,24.0,165.0,10320.0,10320.0,https://www.techpowerup.com/gpu-specs/pg506-217.c3963,2021,165.2,estimated,1.5483870967741935
+NVIDIA,PG506-232,GA100,Server Ampere(Axx),Ampere,930.0,1440.0,7.0,54200.0,2021-04-12,1215.0,24.0,3072.0,933.1,HBM2,3584,56,224,24.0,165.0,10320.0,10320.0,https://www.techpowerup.com/gpu-specs/pg506-232.c3799,2021,165.2,estimated,1.5483870967741935
+NVIDIA,PG506-242,GA100,Server Ampere(Axx),Ampere,930.0,1440.0,7.0,54200.0,2021-04-12,1215.0,24.0,3072.0,933.1,HBM2,3584,56,224,24.0,165.0,10320.0,10320.0,https://www.techpowerup.com/gpu-specs/pg506-242.c3823,2021,165.2,estimated,1.5483870967741935
+NVIDIA,Quadro 6000,GF100,Quadro Fermi(x000),Fermi,574.0,574.0,40.0,3100.0,2010-12-10,747.0,6.0,384.0,143.4,GDDR5,448,14,0,0.75,204.0,,1027.7,https://www.techpowerup.com/gpu-specs/quadro-6000.c896,2010,,unknown,1.0
+NVIDIA,Quadro 6000 SDI,GF100,Quadro Fermi(x000),Fermi,574.0,574.0,40.0,3100.0,2011-07-25,747.0,6.0,384.0,143.4,GDDR5,448,14,0,0.75,231.0,,1027.7,https://www.techpowerup.com/gpu-specs/quadro-6000-sdi.c2141,2011,,unknown,1.0
+NVIDIA,Quadro 7000,GF110,Quadro Fermi(x000),Fermi 2.0,651.0,651.0,40.0,3000.0,2012-05-02,851.0,6.0,384.0,163.4,GDDR5,512,14,0,0.75,204.0,,1332.2,https://www.techpowerup.com/gpu-specs/quadro-7000.c1840,2012,,unknown,1.0
+NVIDIA,Quadro GP100,GP100,Quadro Pascal(Px000),Pascal,1304.0,1443.0,16.0,15300.0,2016-10-01,715.0,16.0,4096.0,732.2,HBM2,3584,56,0,4.0,235.0,20690.0,10340.0,https://www.techpowerup.com/gpu-specs/quadro-gp100.c2994,2016,,unknown,1.10659509202454
+NVIDIA,Quadro GV100,GV100,Quadro Volta(Vx000),Volta,1132.0,1627.0,12.0,21100.0,2018-03-27,848.0,32.0,4096.0,868.4,HBM2,5120,80,640,6.0,250.0,33320.0,16660.0,https://www.techpowerup.com/gpu-specs/quadro-gv100.c3066,2018,133.3,estimated,1.437279151943463
+NVIDIA,Quadro K5100M,GK104,Quadro Kepler-M(Kx100M),Kepler,771.0,771.0,28.0,3540.0,2013-07-23,900.0,8.0,256.0,115.2,GDDR5,1536,0,0,0.5,100.0,,2369.0,https://www.techpowerup.com/gpu-specs/quadro-k5100m.c2425,2013,,unknown,1.0
+NVIDIA,Quadro K5200,GK110B,Quadro Kepler(Kx200),Kepler,667.0,771.0,28.0,7080.0,2014-07-22,1502.0,8.0,256.0,192.3,GDDR5,2304,0,0,0.0,150.0,,3553.0,https://www.techpowerup.com/gpu-specs/quadro-k5200.c2603,2014,,unknown,1.1559220389805098
+NVIDIA,Quadro K6000,GK110B,Quadro Kepler(Kx000),Kepler,797.0,902.0,28.0,7080.0,2013-07-23,1502.0,12.0,384.0,288.4,GDDR5,2880,0,0,1.5,225.0,,5196.0,https://www.techpowerup.com/gpu-specs/quadro-k6000.c2426,2013,,unknown,1.1317440401505645
+NVIDIA,Quadro K6000 SDI,GK110,Quadro Kepler(Kx000),Kepler,902.0,902.0,28.0,7080.0,2013-07-23,1502.0,12.0,384.0,288.4,GDDR5,2880,0,0,1.5,239.0,,5196.0,https://www.techpowerup.com/gpu-specs/quadro-k6000-sdi.c2436,2013,,unknown,1.0
+NVIDIA,Quadro M4000,GM204,Quadro Maxwell(Mx000),Maxwell 2.0,773.0,773.0,28.0,5200.0,2015-06-29,1502.0,8.0,256.0,192.3,GDDR5,1664,13,0,2.0,120.0,,2573.0,https://www.techpowerup.com/gpu-specs/quadro-m4000.c2757,2015,,unknown,1.0
+NVIDIA,Quadro M5000,GM204,Quadro Maxwell(Mx000),Maxwell 2.0,861.0,1038.0,28.0,5200.0,2015-06-29,1653.0,8.0,256.0,211.6,GDDR5,2048,16,0,2.0,150.0,,4252.0,https://www.techpowerup.com/gpu-specs/quadro-m5000.c2756,2015,,unknown,1.2055749128919862
+NVIDIA,Quadro M5000M,GM204,Quadro Maxwell-M(Mx000M),Maxwell 2.0,962.0,1051.0,28.0,5200.0,2015-08-18,1253.0,8.0,256.0,160.4,GDDR5,1536,12,0,2.0,100.0,,3229.0,https://www.techpowerup.com/gpu-specs/quadro-m5000m.c2823,2015,,unknown,1.0925155925155925
+NVIDIA,Quadro M5500 Mobile,GM204,Quadro Maxwell-M(Mx000M),Maxwell 2.0,1140.0,1165.0,28.0,5200.0,2016-04-08,1753.0,8.0,256.0,224.4,GDDR5,2048,16,0,2.0,150.0,,4772.0,https://www.techpowerup.com/gpu-specs/quadro-m5500-mobile.c2838,2016,,unknown,1.0219298245614035
+NVIDIA,Quadro M6000,GM200,Quadro Maxwell(Mx000),Maxwell 2.0,988.0,1114.0,28.0,8000.0,2015-03-21,1653.0,12.0,384.0,317.4,GDDR5,3072,24,0,3.0,250.0,,6844.0,https://www.techpowerup.com/gpu-specs/quadro-m6000.c2638,2015,,unknown,1.1275303643724697
+NVIDIA,Quadro M6000 24 GB,GM200,Quadro Maxwell(Mx000),Maxwell 2.0,988.0,1114.0,28.0,8000.0,2016-03-05,1653.0,24.0,384.0,317.4,GDDR5,3072,24,0,3.0,250.0,,6844.0,https://www.techpowerup.com/gpu-specs/quadro-m6000-24-gb.c2824,2016,,unknown,1.1275303643724697
+NVIDIA,Quadro P3000 Mobile,GP104,Quadro Pascal-M(Px000),Pascal,1088.0,1215.0,16.0,7200.0,2017-01-11,1752.0,6.0,192.0,168.2,GDDR5,1280,10,0,1.5,75.0,48.6,3110.0,https://www.techpowerup.com/gpu-specs/quadro-p3000-mobile.c2923,2017,,unknown,1.1167279411764706
+NVIDIA,Quadro P3200 Max-Q,GP104,Quadro Pascal-M(Px200),Pascal,1139.0,1404.0,16.0,7200.0,2018-02-21,1753.0,6.0,192.0,168.3,GDDR5,1792,14,0,1.5,75.0,78.62,5032.0,https://www.techpowerup.com/gpu-specs/quadro-p3200-max-q.c3315,2018,,unknown,1.2326602282704127
+NVIDIA,Quadro P3200 Mobile,GP104,Quadro Pascal-M(Px200),Pascal,1328.0,1543.0,16.0,7200.0,2018-02-21,1752.0,6.0,192.0,168.2,GDDR5,1792,14,0,1.5,75.0,86.41,5530.0,https://www.techpowerup.com/gpu-specs/quadro-p3200-mobile.c3147,2018,,unknown,1.1618975903614457
+NVIDIA,Quadro P4000,GP104,Quadro Pascal(Px000),Pascal,1202.0,1480.0,16.0,7200.0,2017-02-06,1901.0,8.0,256.0,243.3,GDDR5,1792,14,0,2.0,105.0,82.88,5304.0,https://www.techpowerup.com/gpu-specs/quadro-p4000.c2930,2017,,unknown,1.2312811980033278
+NVIDIA,Quadro P4000 Max-Q,GP104,Quadro Pascal-M(Px000),Pascal,1114.0,1228.0,16.0,7200.0,2017-01-11,1502.0,8.0,256.0,192.3,GDDR5,1792,14,0,2.0,100.0,68.77,4401.0,https://www.techpowerup.com/gpu-specs/quadro-p4000-max-q.c3015,2017,,unknown,1.1023339317773788
+NVIDIA,Quadro P4000 Mobile,GP104,Quadro Pascal-M(Px000),Pascal,1202.0,1228.0,16.0,7200.0,2017-01-11,1500.0,8.0,256.0,192.0,GDDR5,1792,14,0,2.0,100.0,68.77,4401.0,https://www.techpowerup.com/gpu-specs/quadro-p4000-mobile.c2924,2017,,unknown,1.021630615640599
+NVIDIA,Quadro P4200 Max-Q,GP104,Quadro Pascal-M(Px200),Pascal,1215.0,1480.0,16.0,7200.0,2018-02-21,1753.0,8.0,256.0,224.4,GDDR5,2304,18,0,2.0,100.0,106.6,6820.0,https://www.techpowerup.com/gpu-specs/quadro-p4200-max-q.c4004,2018,,unknown,1.2181069958847737
+NVIDIA,Quadro P4200 Mobile,GP104,Quadro Pascal-M(Px200),Pascal,1418.0,1594.0,16.0,7200.0,2018-02-21,1753.0,8.0,256.0,224.4,GDDR5,2304,18,0,2.0,100.0,114.8,7345.0,https://www.techpowerup.com/gpu-specs/quadro-p4200-mobile.c3199,2018,,unknown,1.1241184767277856
+NVIDIA,Quadro P5000,GP104,Quadro Pascal(Px000),Pascal,1607.0,1733.0,16.0,7200.0,2016-10-01,1127.0,16.0,256.0,288.5,GDDR5X,2560,20,0,2.0,180.0,138.6,8873.0,https://www.techpowerup.com/gpu-specs/quadro-p5000.c2864,2016,,unknown,1.0784069695084006
+NVIDIA,Quadro P5000 Mobile,GP104,Quadro Pascal-M(Px000),Pascal,1164.0,1506.0,16.0,7200.0,2017-01-11,1500.0,16.0,256.0,192.0,GDDR5,2048,16,0,2.0,100.0,96.38,6169.0,https://www.techpowerup.com/gpu-specs/quadro-p5000-mobile.c2925,2017,,unknown,1.2938144329896908
+NVIDIA,Quadro P5000 X2 Mobile,GP104,Quadro Pascal-M(Px000),Pascal,1164.0,1506.0,16.0,7200.0,2017-01-11,1500.0,16.0,256.0,192.0,GDDR5,2048,16,0,2.0,200.0,96.38,6169.0,https://www.techpowerup.com/gpu-specs/quadro-p5000-x2-mobile.c4122,2017,,unknown,1.2938144329896908
+NVIDIA,Quadro P5200 Max-Q,GP104,Quadro Pascal-M(Px200),Pascal,1316.0,1569.0,16.0,7200.0,2018-02-21,1804.0,16.0,256.0,230.9,GDDR5,2560,20,0,2.0,100.0,125.5,8032.999999999999,https://www.techpowerup.com/gpu-specs/quadro-p5200-max-q.c3347,2018,,unknown,1.1922492401215805
+NVIDIA,Quadro P5200 Mobile,GP104,Quadro Pascal-M(Px200),Pascal,1582.0,1759.0,16.0,7200.0,2018-02-21,1804.0,16.0,256.0,230.9,GDDR5,2560,20,0,2.0,100.0,140.7,9006.0,https://www.techpowerup.com/gpu-specs/quadro-p5200-mobile.c3020,2018,,unknown,1.1118836915297092
+NVIDIA,Quadro P6000,GP102,Quadro Pascal(Px000),Pascal,1506.0,1645.0,16.0,11800.0,2016-10-01,1127.0,24.0,384.0,432.8,GDDR5X,3840,30,0,3.0,250.0,197.4,12630.0,https://www.techpowerup.com/gpu-specs/quadro-p6000.c2865,2016,,unknown,1.092297476759628
+NVIDIA,Quadro Plex 7000,GF110,Quadro Plex,Fermi 2.0,574.0,574.0,40.0,3000.0,2011-07-25,750.0,6.0,384.0,144.0,GDDR5,512,16,0,0.75,600.0,,1175.6,https://www.techpowerup.com/gpu-specs/quadro-plex-7000.c902,2011,,unknown,1.0
+NVIDIA,Quadro RTX 3000 Max-Q,TU106,Quadro Turing-M(Tx000),Turing,600.0,1215.0,12.0,10800.0,2019-05-27,1500.0,6.0,192.0,288.0,GDDR6,1920,30,240,3.0,60.0,9331.0,4666.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-3000-max-q.c3429,2019,37.3,estimated,2.025
+NVIDIA,Quadro RTX 3000 Mobile,TU106,Quadro Turing-M(Tx000),Turing,945.0,1380.0,12.0,10800.0,2019-05-27,1750.0,6.0,192.0,336.0,GDDR6,1920,30,240,3.0,80.0,10600.0,5299.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-3000-mobile.c3428,2019,42.4,estimated,1.4603174603174602
+NVIDIA,Quadro RTX 3000 Mobile Refresh,TU106,Quadro Turing-M(Tx000),Turing,945.0,1380.0,12.0,10800.0,2019-05-27,1750.0,6.0,192.0,336.0,GDDR6,1920,30,240,4.0,80.0,10600.0,5299.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-3000-mobile-refresh.c3697,2019,42.4,estimated,1.4603174603174602
+NVIDIA,Quadro RTX 3000 X2 Mobile,TU106,Quadro Turing-M(Tx000),Turing,945.0,1380.0,12.0,10800.0,2019-05-27,1750.0,6.0,192.0,336.0,GDDR6,1920,30,240,4.0,160.0,10600.0,5299.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-3000-x2-mobile.c4120,2019,42.4,estimated,1.4603174603174602
+NVIDIA,Quadro RTX 4000,TU104,Quadro Turing(Tx000),Turing,1005.0,1545.0,12.0,13600.0,2018-11-13,1625.0,8.0,256.0,416.0,GDDR6,2304,36,288,4.0,160.0,14240.0,7119.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-4000.c3336,2018,57.0,estimated,1.537313432835821
+NVIDIA,Quadro RTX 4000 Max-Q,TU104,Quadro Turing-M(Tx000),Turing,780.0,1380.0,12.0,13600.0,2019-05-27,1500.0,8.0,256.0,384.0,GDDR6,2560,40,320,4.0,80.0,14130.0,7066.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-4000-max-q.c3427,2019,56.5,estimated,1.7692307692307692
+NVIDIA,Quadro RTX 4000 Mobile,TU104,Quadro Turing-M(Tx000),Turing,1110.0,1560.0,12.0,13600.0,2019-05-27,1750.0,8.0,256.0,448.0,GDDR6,2560,40,320,4.0,110.0,15970.0,7987.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-4000-mobile.c3430,2019,63.9,estimated,1.4054054054054055
+NVIDIA,Quadro RTX 5000,TU104,Quadro Turing(Tx000),Turing,1620.0,1815.0,12.0,13600.0,2018-08-13,1750.0,16.0,256.0,448.0,GDDR6,3072,48,384,4.0,230.0,22300.0,11150.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-5000.c3308,2018,89.2,estimated,1.1203703703703705
+NVIDIA,Quadro RTX 5000 Max-Q,TU104,Quadro Turing-M(Tx000),Turing,600.0,1350.0,12.0,13600.0,2019-05-27,1500.0,16.0,256.0,384.0,GDDR6,3072,48,384,4.0,80.0,16590.0,8294.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-5000-max-q.c3432,2019,66.4,estimated,2.25
+NVIDIA,Quadro RTX 5000 Mobile,TU104,Quadro Turing-M(Tx000),Turing,1035.0,1530.0,12.0,13600.0,2019-05-27,1750.0,16.0,256.0,448.0,GDDR6,3072,48,384,4.0,110.0,18800.0,9400.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-5000-mobile.c3431,2019,75.2,estimated,1.4782608695652173
+NVIDIA,Quadro RTX 5000 Mobile Refresh,TU104B,Quadro Turing-M(Tx000),Turing,1035.0,1530.0,12.0,13600.0,2020-06-08,1750.0,16.0,256.0,448.0,GDDR6,3072,48,384,4.0,110.0,18800.0,9400.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-5000-mobile-refresh.c3625,2020,75.2,estimated,1.4782608695652173
+NVIDIA,Quadro RTX 5000 X2 Mobile,TU104,Quadro Turing-M(Tx000),Turing,1035.0,1530.0,12.0,13600.0,2020-06-08,1750.0,16.0,256.0,448.0,GDDR6,3072,48,384,4.0,110.0,18800.0,9400.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-5000-x2-mobile.c4121,2020,75.2,estimated,1.4782608695652173
+NVIDIA,Quadro RTX 6000,TU102,Quadro Turing(Tx000),Turing,1440.0,1770.0,12.0,18600.0,2018-08-13,1750.0,24.0,384.0,672.0,GDDR6,4608,72,576,6.0,260.0,32619.999999999996,16309.999999999998,https://www.techpowerup.com/gpu-specs/quadro-rtx-6000.c3307,2018,130.5,estimated,1.2291666666666667
+NVIDIA,Quadro RTX 6000 Passive,TU102,Quadro Turing(Tx000),Turing,1275.0,1620.0,12.0,18600.0,2018-08-13,1625.0,24.0,384.0,624.0,GDDR6,4608,72,576,6.0,260.0,29860.0,14930.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-6000-passive.c3469,2018,119.4,estimated,1.2705882352941176
+NVIDIA,Quadro RTX 8000,TU102,Quadro Turing(Tx000),Turing,1395.0,1770.0,12.0,18600.0,2018-08-13,1750.0,48.0,384.0,672.0,GDDR6,4608,72,576,6.0,260.0,32619.999999999996,16309.999999999998,https://www.techpowerup.com/gpu-specs/quadro-rtx-8000.c3306,2018,130.5,estimated,1.2688172043010753
+NVIDIA,Quadro RTX 8000 Passive,TU102,Quadro Turing(Tx000),Turing,1230.0,1620.0,12.0,18600.0,2018-08-13,1625.0,48.0,384.0,624.0,GDDR6,4608,72,576,6.0,260.0,29860.0,14930.0,https://www.techpowerup.com/gpu-specs/quadro-rtx-8000-passive.c3470,2018,119.4,estimated,1.3170731707317074
+NVIDIA,RTX 1000 Mobile Ada Generation,AD107,Ada-MW(x000A),Ada Lovelace,1485.0,2025.0,5.0,18900.0,2024-02-26,2000.0,6.0,96.0,192.0,GDDR6,2560,20,80,12.0,35.0,10370.0,10370.0,https://www.techpowerup.com/gpu-specs/rtx-1000-mobile-ada-generation.c4208,2024,41.5,estimated,1.3636363636363635
+NVIDIA,RTX 2000 Ada Generation,AD107,Workstation Ada(x000A),Ada Lovelace,1620.0,2130.0,5.0,18900.0,2024-02-12,2000.0,16.0,128.0,256.0,GDDR6,2816,22,88,12.0,70.0,12000.0,12000.0,https://www.techpowerup.com/gpu-specs/rtx-2000-ada-generation.c4199,2024,48.0,estimated,1.3148148148148149
+NVIDIA,RTX 2000 Embedded Ada Generation,AD107,Ada-MW(x000A),Ada Lovelace,1530.0,2010.0,5.0,18900.0,2023-03-21,2000.0,8.0,128.0,256.0,GDDR6,3072,24,96,12.0,50.0,12350.0,12350.0,https://www.techpowerup.com/gpu-specs/rtx-2000-embedded-ada-generation.c4177,2023,49.4,estimated,1.3137254901960784
+NVIDIA,RTX 2000 Max-Q Ada Generation,AD107,Ada-MW(x000A),Ada Lovelace,930.0,1455.0,5.0,18900.0,2023-03-21,2000.0,8.0,128.0,256.0,GDDR6,3072,24,96,12.0,35.0,8940.0,8940.0,https://www.techpowerup.com/gpu-specs/rtx-2000-max-q-ada-generation.c4094,2023,35.8,estimated,1.564516129032258
+NVIDIA,RTX 2000 Mobile Ada Generation,AD107,Ada-MW(x000A),Ada Lovelace,1635.0,2115.0,5.0,18900.0,2023-03-21,2000.0,8.0,128.0,256.0,GDDR6,3072,24,96,12.0,50.0,12990.0,12990.0,https://www.techpowerup.com/gpu-specs/rtx-2000-mobile-ada-generation.c4093,2023,52.0,estimated,1.2935779816513762
+NVIDIA,RTX 3000 Mobile Ada Generation,AD106,Ada-MW(x000A),Ada Lovelace,1395.0,1695.0,5.0,22900.0,2023-03-21,2000.0,8.0,128.0,256.0,GDDR6,4608,36,144,32.0,115.0,15620.0,15620.0,https://www.techpowerup.com/gpu-specs/rtx-3000-mobile-ada-generation.c4095,2023,62.5,estimated,1.2150537634408602
+NVIDIA,RTX 3500 Embedded Ada Generation,AD104,Ada-MW(x000A),Ada Lovelace,1725.0,2250.0,5.0,35800.0,2023-03-21,2250.0,12.0,192.0,432.0,GDDR6,5120,40,160,48.0,100.0,23040.0,23040.0,https://www.techpowerup.com/gpu-specs/rtx-3500-embedded-ada-generation.c4201,2023,92.2,estimated,1.3043478260869565
+NVIDIA,RTX 3500 Mobile Ada Generation,AD104,Ada-MW(x000A),Ada Lovelace,1110.0,1545.0,5.0,35800.0,2023-03-21,2250.0,12.0,192.0,432.0,GDDR6,5120,40,160,48.0,100.0,15820.0,15820.0,https://www.techpowerup.com/gpu-specs/rtx-3500-mobile-ada-generation.c4098,2023,63.3,estimated,1.3918918918918919
+NVIDIA,RTX 4000 Ada Generation,AD104,Workstation Ada(x000A),Ada Lovelace,1500.0,2175.0,5.0,35800.0,2023-08-09,2250.0,20.0,160.0,360.0,GDDR6,6144,48,192,48.0,130.0,26730.0,26730.0,https://www.techpowerup.com/gpu-specs/rtx-4000-ada-generation.c4171,2023,106.9,estimated,1.45
+NVIDIA,RTX 4000 Mobile Ada Generation,AD104,Ada-MW(x000A),Ada Lovelace,1290.0,1665.0,5.0,35800.0,2023-03-21,2250.0,12.0,192.0,432.0,GDDR6,7424,58,232,48.0,110.0,24720.0,24720.0,https://www.techpowerup.com/gpu-specs/rtx-4000-mobile-ada-generation.c4096,2023,98.9,estimated,1.2906976744186047
+NVIDIA,RTX 4000 SFF Ada Generation,AD104,Workstation Ada(x000A),Ada Lovelace,720.0,1560.0,5.0,35800.0,2023-03-21,1750.0,20.0,160.0,280.0,GDDR6,6144,48,192,48.0,70.0,19170.0,19170.0,https://www.techpowerup.com/gpu-specs/rtx-4000-sff-ada-generation.c4139,2023,76.7,estimated,2.1666666666666665
+NVIDIA,RTX 4500 Ada Generation,AD103,Workstation Ada(x000A),Ada Lovelace,2070.0,2580.0,5.0,45900.0,2023-08-09,2250.0,24.0,192.0,432.0,GDDR6,7680,60,240,48.0,210.0,39630.0,39630.0,https://www.techpowerup.com/gpu-specs/rtx-4500-ada-generation.c4172,2023,158.5,estimated,1.2463768115942029
+NVIDIA,RTX 5000 Ada Generation,AD102,Workstation Ada(x000A),Ada Lovelace,1155.0,2550.0,5.0,76300.0,2023-08-09,2250.0,32.0,256.0,576.0,GDDR6,12800,100,400,72.0,250.0,65280.0,65280.0,https://www.techpowerup.com/gpu-specs/rtx-5000-ada-generation.c4152,2023,262.0,reported,2.207792207792208
+NVIDIA,RTX 5000 Embedded Ada Generation,AD103,Ada-MW(x000A),Ada Lovelace,930.0,1680.0,5.0,45900.0,2023-03-21,2250.0,16.0,256.0,576.0,GDDR6,9728,76,304,64.0,120.0,32689.999999999996,32689.999999999996,https://www.techpowerup.com/gpu-specs/rtx-5000-embedded-ada-generation.c4176,2023,130.7,estimated,1.8064516129032258
+NVIDIA,RTX 5000 Embedded Ada Generation X2,AD103,Ada-MW(x000A),Ada Lovelace,930.0,1680.0,5.0,45900.0,2023-03-21,2250.0,16.0,256.0,576.0,GDDR6,9728,76,304,64.0,150.0,32689.999999999996,32689.999999999996,https://www.techpowerup.com/gpu-specs/rtx-5000-embedded-ada-generation-x2.c4256,2023,130.7,estimated,1.8064516129032258
+NVIDIA,RTX 5000 Max-Q Ada Generation,AD103,Ada-MW(x000A),Ada Lovelace,930.0,1680.0,5.0,45900.0,2023-03-21,2250.0,16.0,256.0,576.0,GDDR6,9728,76,304,64.0,120.0,32689.999999999996,32689.999999999996,https://www.techpowerup.com/gpu-specs/rtx-5000-max-q-ada-generation.c4154,2023,130.7,estimated,1.8064516129032258
+NVIDIA,RTX 5000 Mobile Ada Generation,AD103,Ada-MW(x000A),Ada Lovelace,1425.0,2115.0,5.0,45900.0,2023-03-21,2250.0,16.0,256.0,576.0,GDDR6,9728,76,304,64.0,120.0,41150.0,41150.0,https://www.techpowerup.com/gpu-specs/rtx-5000-mobile-ada-generation.c4097,2023,164.6,estimated,1.4842105263157894
+NVIDIA,RTX 5880 Ada Generation,AD102,Workstation Ada(x000A),Ada Lovelace,975.0,2460.0,5.0,76300.0,2024-01-05,2250.0,48.0,384.0,864.0,GDDR6,14080,110,440,72.0,285.0,69269.99999999999,69269.99999999999,https://www.techpowerup.com/gpu-specs/rtx-5880-ada-generation.c4191,2024,277.1,estimated,2.523076923076923
+NVIDIA,RTX 6000 Ada Generation,AD102,Workstation Ada(x000A),Ada Lovelace,915.0,2505.0,5.0,76300.0,2022-12-03,2500.0,48.0,384.0,960.0,GDDR6,18176,142,568,96.0,300.0,91060.0,91060.0,https://www.techpowerup.com/gpu-specs/rtx-6000-ada-generation.c3933,2022,364.0,reported,2.737704918032787
+NVIDIA,RTX 6000D,GB202,Blackwell PRO W(x000),Blackwell 2.0,1590.0,2430.0,5.0,92200.0,2025-03-18,1750.0,84.0,448.0,1570.0,GDDR7,19968,156,624,128.0,600.0,97040.0,97040.0,https://www.techpowerup.com/gpu-specs/rtx-6000d.c4363,2025,388.2,estimated,1.528301886792453
+NVIDIA,RTX A1000,GA107,Workstation Ampere(Ax000),Ampere,727.0,1462.0,8.0,8700.0,2024-04-16,1500.0,8.0,128.0,192.0,GDDR6,2304,18,72,2.0,50.0,6737.0,6737.0,https://www.techpowerup.com/gpu-specs/rtx-a1000.c4211,2024,26.9,estimated,2.0110041265474554
+NVIDIA,RTX A1000 Mobile 6 GB,GA107,Ampere-MW(Ax000),Ampere,652.0,1140.0,8.0,8700.0,2022-03-30,1375.0,6.0,96.0,132.0,GDDR6,2560,20,80,2.0,60.0,5837.0,5837.0,https://www.techpowerup.com/gpu-specs/rtx-a1000-mobile-6-gb.c4137,2022,23.3,estimated,1.7484662576687116
+NVIDIA,RTX A2000,GA106,Workstation Ampere(Ax000),Ampere,562.0,1200.0,8.0,12000.0,2021-08-10,1500.0,6.0,192.0,288.0,GDDR6,3328,26,104,3.0,70.0,7987.0,7987.0,https://www.techpowerup.com/gpu-specs/rtx-a2000.c3820,2021,31.9,estimated,2.1352313167259784
+NVIDIA,RTX A2000 12 GB,GA106,Workstation Ampere(Ax000),Ampere,562.0,1200.0,8.0,12000.0,2021-11-23,1500.0,12.0,192.0,288.0,GDDR6,3328,26,104,3.0,70.0,7987.0,7987.0,https://www.techpowerup.com/gpu-specs/rtx-a2000-12-gb.c3853,2021,31.9,estimated,2.1352313167259784
+NVIDIA,RTX A2000 Max-Q 8 GB,GA107,Ampere-MW(Ax000),Ampere,607.0,1177.0,8.0,8700.0,2021-04-12,1375.0,8.0,128.0,176.0,GDDR6,2560,20,80,2.0,95.0,6026.0,6026.0,https://www.techpowerup.com/gpu-specs/rtx-a2000-max-q-8-gb.c4288,2021,24.1,estimated,1.9390444810543657
+NVIDIA,RTX A2000 Mobile 8 GB,GA107,Ampere-MW(Ax000),Ampere,1117.0,1612.0,8.0,8700.0,2021-04-12,1750.0,8.0,128.0,224.0,GDDR6,2560,20,80,2.0,95.0,8253.0,8253.0,https://www.techpowerup.com/gpu-specs/rtx-a2000-mobile-8-gb.c4287,2021,33.0,estimated,1.4431512981199641
+NVIDIA,RTX A3000 Mobile,GA104,Ampere-MW(Ax000),Ampere,600.0,1230.0,8.0,17400.0,2021-04-12,1375.0,6.0,192.0,264.0,GDDR6,4096,32,128,4.0,70.0,10080.0,10080.0,https://www.techpowerup.com/gpu-specs/rtx-a3000-mobile.c3806,2021,40.3,estimated,2.05
+NVIDIA,RTX A3000 Mobile 12 GB,GA104,Ampere-MW(Ax000),Ampere,855.0,1440.0,8.0,17400.0,2022-03-22,1750.0,12.0,192.0,336.0,GDDR6,4096,32,128,4.0,115.0,11800.0,11800.0,https://www.techpowerup.com/gpu-specs/rtx-a3000-mobile-12-gb.c3903,2022,47.2,estimated,1.6842105263157894
+NVIDIA,RTX A4000,GA104,Workstation Ampere(Ax000),Ampere,735.0,1560.0,8.0,17400.0,2021-04-12,1750.0,16.0,256.0,448.0,GDDR6,6144,48,192,4.0,140.0,19170.0,19170.0,https://www.techpowerup.com/gpu-specs/rtx-a4000.c3756,2021,76.7,estimated,2.122448979591837
+NVIDIA,RTX A4000 Max-Q,GA104,Ampere-MW(Ax000),Ampere,780.0,1395.0,8.0,17400.0,2021-04-12,1375.0,8.0,256.0,352.0,GDDR6,5120,40,160,4.0,80.0,14280.0,14280.0,https://www.techpowerup.com/gpu-specs/rtx-a4000-max-q.c4008,2021,57.1,estimated,1.7884615384615385
+NVIDIA,RTX A4000 Mobile,GA104,Ampere-MW(Ax000),Ampere,1140.0,1680.0,8.0,17400.0,2021-04-12,1500.0,8.0,256.0,384.0,GDDR6,5120,40,160,4.0,115.0,17200.0,17200.0,https://www.techpowerup.com/gpu-specs/rtx-a4000-mobile.c3804,2021,68.8,estimated,1.4736842105263157
+NVIDIA,RTX A4000H,GA104,Workstation Ampere(Ax000),Ampere,735.0,1560.0,8.0,17400.0,2021-04-12,1750.0,16.0,256.0,448.0,GDDR6,6144,48,192,4.0,140.0,19170.0,19170.0,https://www.techpowerup.com/gpu-specs/rtx-a4000h.c3969,2021,76.7,estimated,2.122448979591837
+NVIDIA,RTX A4500,GA102,Workstation Ampere(Ax000),Ampere,1050.0,1650.0,8.0,28300.0,2021-11-23,2000.0,20.0,320.0,640.0,GDDR6,7168,56,224,6.0,200.0,23650.0,23650.0,https://www.techpowerup.com/gpu-specs/rtx-a4500.c3849,2021,94.6,estimated,1.5714285714285714
+NVIDIA,RTX A4500 Embedded,GA104,Ampere-MW(Ax000),Ampere,510.0,1215.0,8.0,17400.0,2022-03-30,1500.0,16.0,256.0,384.0,GDDR6,5888,46,184,4.0,80.0,14310.0,14310.0,https://www.techpowerup.com/gpu-specs/rtx-a4500-embedded.c3893,2022,57.2,estimated,2.3823529411764706
+NVIDIA,RTX A4500 Max-Q,GA104,Ampere-MW(Ax000),Ampere,510.0,1215.0,8.0,17400.0,2022-03-22,1750.0,16.0,256.0,448.0,GDDR6,5888,46,184,4.0,80.0,14310.0,14310.0,https://www.techpowerup.com/gpu-specs/rtx-a4500-max-q.c4009,2022,57.2,estimated,2.3823529411764706
+NVIDIA,RTX A4500 Mobile,GA104,Ampere-MW(Ax000),Ampere,930.0,1500.0,8.0,17400.0,2022-03-22,2000.0,16.0,256.0,512.0,GDDR6,5888,46,184,4.0,140.0,17660.0,17660.0,https://www.techpowerup.com/gpu-specs/rtx-a4500-mobile.c3851,2022,70.7,estimated,1.6129032258064515
+NVIDIA,RTX A5000,GA102,Workstation Ampere(Ax000),Ampere,1170.0,1695.0,8.0,28300.0,2021-04-12,2000.0,24.0,384.0,768.0,GDDR6,8192,64,256,6.0,230.0,27770.0,27770.0,https://www.techpowerup.com/gpu-specs/rtx-a5000.c3748,2021,111.0,reported,1.4487179487179487
+NVIDIA,RTX A5000 Max-Q,GA104,Ampere-MW(Ax000),Ampere,720.0,1350.0,8.0,17400.0,2021-04-12,1500.0,16.0,256.0,384.0,GDDR6,6144,48,192,4.0,80.0,16590.0,16590.0,https://www.techpowerup.com/gpu-specs/rtx-a5000-max-q.c4010,2021,66.4,estimated,1.875
+NVIDIA,RTX A5000 Mobile,GA104,Ampere-MW(Ax000),Ampere,900.0,1575.0,8.0,17400.0,2021-04-12,1750.0,16.0,256.0,448.0,GDDR6,6144,48,192,4.0,150.0,19350.0,19350.0,https://www.techpowerup.com/gpu-specs/rtx-a5000-mobile.c3805,2021,77.4,estimated,1.75
+NVIDIA,RTX A5000-12Q,GA102,Workstation Ampere(Ax000),Ampere,1170.0,1695.0,8.0,28300.0,2021-04-12,2000.0,12.0,384.0,768.0,GDDR6,8192,64,256,6.0,230.0,27770.0,27770.0,https://www.techpowerup.com/gpu-specs/rtx-a5000-12q.c3991,2021,111.1,estimated,1.4487179487179487
+NVIDIA,RTX A5000-8Q,GA102,Workstation Ampere(Ax000),Ampere,1170.0,1695.0,8.0,28300.0,2021-04-12,2000.0,8.0,384.0,768.0,GDDR6,8192,64,256,6.0,230.0,27770.0,27770.0,https://www.techpowerup.com/gpu-specs/rtx-a5000-8q.c3990,2021,111.1,estimated,1.4487179487179487
+NVIDIA,RTX A5500,GA102,Workstation Ampere(Ax000),Ampere,1080.0,1665.0,8.0,28300.0,2022-03-22,2000.0,24.0,384.0,768.0,GDDR6,10240,80,320,6.0,230.0,34100.0,34100.0,https://www.techpowerup.com/gpu-specs/rtx-a5500.c3901,2022,136.4,estimated,1.5416666666666667
+NVIDIA,RTX A5500 Max-Q,GA103,Ampere-MW(Ax000),Ampere,585.0,1260.0,8.0,22000.0,2022-03-22,1750.0,16.0,256.0,448.0,GDDR6,7424,58,232,4.0,80.0,18710.0,18710.0,https://www.techpowerup.com/gpu-specs/rtx-a5500-max-q.c4011,2022,74.8,estimated,2.1538461538461537
+NVIDIA,RTX A5500 Mobile,GA103,Ampere-MW(Ax000),Ampere,975.0,1500.0,8.0,22000.0,2022-03-22,2000.0,16.0,256.0,512.0,GDDR6,7424,58,232,4.0,165.0,22270.0,22270.0,https://www.techpowerup.com/gpu-specs/rtx-a5500-mobile.c3902,2022,89.1,estimated,1.5384615384615385
+NVIDIA,RTX A6000,GA102,Workstation Ampere(Ax000),Ampere,1410.0,1800.0,8.0,28300.0,2020-10-05,2000.0,48.0,384.0,768.0,GDDR6,10752,84,336,6.0,300.0,38710.0,38710.0,https://www.techpowerup.com/gpu-specs/rtx-a6000.c3686,2020,155.0,reported,1.2765957446808511
+NVIDIA,RTX PRO 2000 Blackwell,GB206,Blackwell PRO W(x000),Blackwell 2.0,982.0,1957.0,5.0,21900.0,2025-08-11,1125.0,16.0,128.0,288.0,GDDR7,4352,34,136,32.0,70.0,17030.000000000004,17030.000000000004,https://www.techpowerup.com/gpu-specs/rtx-pro-2000-blackwell.c4330,2025,68.1,estimated,1.9928716904276986
+NVIDIA,RTX PRO 4000 Blackwell,GB203,Blackwell PRO W(x000),Blackwell 2.0,1230.0,2055.0,5.0,45600.0,2025-03-18,1750.0,24.0,192.0,672.0,GDDR7,8960,70,280,48.0,140.0,36830.0,36830.0,https://www.techpowerup.com/gpu-specs/rtx-pro-4000-blackwell.c4279,2025,147.3,estimated,1.670731707317073
+NVIDIA,RTX PRO 4000 Blackwell SFF,GB203,Blackwell PRO W(x000),Blackwell 2.0,577.0,1432.0,5.0,45600.0,2025-08-11,1125.0,24.0,192.0,432.0,GDDR7,8960,70,280,48.0,70.0,25660.0,25660.0,https://www.techpowerup.com/gpu-specs/rtx-pro-4000-blackwell-sff.c4329,2025,102.6,estimated,2.481802426343154
+NVIDIA,RTX PRO 4500 Blackwell,GB203,Blackwell PRO W(x000),Blackwell 2.0,1635.0,2407.0,5.0,45600.0,2025-03-18,1750.0,32.0,256.0,896.0,GDDR7,10496,82,328,64.0,200.0,50530.0,50530.0,https://www.techpowerup.com/gpu-specs/rtx-pro-4500-blackwell.c4278,2025,202.1,estimated,1.47217125382263
+NVIDIA,RTX PRO 5000 72 GB Blackwell,GB202,Blackwell PRO W(x000),Blackwell 2.0,1740.0,2377.0,5.0,92200.0,2025-10-21,1750.0,72.0,384.0,1340.0,GDDR7,14080,110,440,96.0,300.0,66940.0,66940.0,https://www.techpowerup.com/gpu-specs/rtx-pro-5000-72-gb-blackwell.c4357,2025,267.7,estimated,1.3660919540229886
+NVIDIA,RTX PRO 5000 Blackwell,GB202,Blackwell PRO W(x000),Blackwell 2.0,1740.0,2377.0,5.0,92200.0,2025-03-18,1750.0,48.0,384.0,1340.0,GDDR7,14080,110,440,96.0,300.0,66940.0,66940.0,https://www.techpowerup.com/gpu-specs/rtx-pro-5000-blackwell.c4276,2025,267.7,estimated,1.3660919540229886
+NVIDIA,RTX PRO 6000 Blackwell,GB202,Blackwell PRO W(x000),Blackwell 2.0,1590.0,2617.0,5.0,92200.0,2025-03-18,1750.0,96.0,512.0,1790.0,GDDR7,24064,188,752,128.0,600.0,126000.0,126000.0,https://www.techpowerup.com/gpu-specs/rtx-pro-6000-blackwell.c4272,2025,503.8,estimated,1.6459119496855346
+NVIDIA,RTX PRO 6000 Blackwell Max-Q,GB202,Blackwell PRO W(x000),Blackwell 2.0,1035.0,2280.0,5.0,92200.0,2025-03-18,1750.0,96.0,512.0,1790.0,GDDR7,24064,188,752,128.0,300.0,109700.0,109700.0,https://www.techpowerup.com/gpu-specs/rtx-pro-6000-blackwell-max-q.c4273,2025,438.9,estimated,2.2028985507246377
+NVIDIA,RTX PRO 6000 Blackwell Server,GB202,Server Blackwell(Bxx),Blackwell 2.0,1590.0,2617.0,5.0,92200.0,2025-03-18,1750.0,96.0,512.0,1790.0,GDDR7,24064,188,752,128.0,600.0,126000.0,126000.0,https://www.techpowerup.com/gpu-specs/rtx-pro-6000-blackwell-server.c4274,2025,503.8,estimated,1.6459119496855346
+NVIDIA,RTX PRO 6000D Blackwell Max-Q,GB202,Blackwell PRO W(x000),Blackwell 2.0,1590.0,2288.0,5.0,92200.0,2025-03-18,1750.0,96.0,512.0,1790.0,GDDR7,24064,188,752,128.0,300.0,110100.0,110100.0,https://www.techpowerup.com/gpu-specs/rtx-pro-6000d-blackwell-max-q.c4364,2025,440.5,estimated,1.4389937106918238
+NVIDIA,Switch 2 GPU,GA10B,Console GPU(Nintendo),Ampere,561.0,1400.0,8.0,,2025-06-05,800.0,12.0,128.0,102.4,LPDDR5X,1536,12,48,4.0,40.0,8602.0,4301.0,https://www.techpowerup.com/gpu-specs/switch-2-gpu.c4313,2025,17.2,estimated,2.4955436720142603
+NVIDIA,T1000 8 GB,TU117,Quadro Turing(Tx000),Turing,1065.0,1395.0,12.0,4700.0,2021-05-06,1250.0,8.0,128.0,160.0,GDDR6,896,14,0,1.0,50.0,5000.0,2500.0,https://www.techpowerup.com/gpu-specs/t1000-8-gb.c3842,2021,,unknown,1.3098591549295775
+NVIDIA,TITAN RTX,TU102,GeForce 20,Turing,1350.0,1770.0,12.0,18600.0,2018-12-18,1750.0,24.0,384.0,672.0,GDDR6,4608,72,576,6.0,280.0,32619.999999999996,16309.999999999998,https://www.techpowerup.com/gpu-specs/titan-rtx.c3311,2018,130.5,estimated,1.3111111111111111
+NVIDIA,TITAN V,GV100,GeForce 10,Volta,1200.0,1455.0,12.0,21100.0,2017-12-07,848.0,12.0,3072.0,651.3,HBM2,5120,80,640,4.5,250.0,29800.0,14900.0,https://www.techpowerup.com/gpu-specs/titan-v.c3051,2017,119.2,estimated,1.2125
+NVIDIA,TITAN V CEO Edition,GV100,GeForce 10,Volta,1200.0,1455.0,12.0,21100.0,2018-06-21,848.0,32.0,4096.0,868.4,HBM2,5120,80,640,6.0,250.0,29800.0,14900.0,https://www.techpowerup.com/gpu-specs/titan-v-ceo-edition.c3277,2018,119.2,estimated,1.2125
+NVIDIA,TITAN X Pascal,GP102,GeForce 10,Pascal,1417.0,1531.0,16.0,11800.0,2016-08-02,1251.0,12.0,384.0,480.4,GDDR5X,3584,28,0,3.0,250.0,171.5,10970.0,https://www.techpowerup.com/gpu-specs/titan-x-pascal.c2863,2016,,unknown,1.0804516584333097
+NVIDIA,TITAN Xp,GP102,GeForce 10,Pascal,1405.0,1582.0,16.0,11800.0,2017-04-06,1426.0,12.0,384.0,547.6,GDDR5X,3840,30,0,3.0,250.0,189.8,12150.0,https://www.techpowerup.com/gpu-specs/titan-xp.c2948,2017,,unknown,1.1259786476868328
+NVIDIA,Tesla C2070,GF100,Tesla Fermi(x20xx),Fermi,574.0,574.0,40.0,3100.0,2011-07-25,747.0,6.0,384.0,143.4,GDDR5,448,14,0,0.75,238.0,,1027.7,https://www.techpowerup.com/gpu-specs/tesla-c2070.c924,2011,,unknown,1.0
+NVIDIA,Tesla C2075,GF110,Tesla Fermi(x20xx),Fermi 2.0,574.0,574.0,40.0,3000.0,2011-07-25,783.0,6.0,384.0,150.3,GDDR5,448,14,0,0.75,247.0,,1027.7,https://www.techpowerup.com/gpu-specs/tesla-c2075.c563,2011,,unknown,1.0
+NVIDIA,Tesla C2090,GF110,Tesla Fermi(x20xx),Fermi 2.0,651.0,651.0,40.0,3000.0,2011-07-25,924.0,6.0,384.0,177.4,GDDR5,512,16,0,0.75,250.0,,1332.2,https://www.techpowerup.com/gpu-specs/tesla-c2090.c2317,2011,,unknown,1.0
+NVIDIA,Tesla K20X,GK110,Tesla Kepler(Kxx),Kepler,732.0,732.0,28.0,7080.0,2012-11-12,1300.0,6.0,384.0,249.6,GDDR5,2688,0,0,1.5,235.0,,3935.0,https://www.techpowerup.com/gpu-specs/tesla-k20x.c2315,2012,,unknown,1.0
+NVIDIA,Tesla K20Xm,GK110,Tesla Kepler(Kxx),Kepler,732.0,732.0,28.0,7080.0,2012-11-12,1300.0,6.0,384.0,249.6,GDDR5,2688,0,0,1.5,235.0,,3935.0,https://www.techpowerup.com/gpu-specs/tesla-k20xm.c1884,2012,,unknown,1.0
+NVIDIA,Tesla K40c,GK180,Tesla Kepler(Kxx),Kepler,745.0,876.0,28.0,7080.0,2013-10-08,1502.0,12.0,384.0,288.4,GDDR5,2880,0,0,1.5,245.0,,5046.0,https://www.techpowerup.com/gpu-specs/tesla-k40c.c2505,2013,,unknown,1.1758389261744966
+NVIDIA,Tesla K40d,GK110B,Tesla Kepler(Kxx),Kepler,745.0,876.0,28.0,7080.0,2013-11-22,1502.0,12.0,384.0,288.4,GDDR5,2880,0,0,1.5,245.0,,5046.0,https://www.techpowerup.com/gpu-specs/tesla-k40d.c3402,2013,,unknown,1.1758389261744966
+NVIDIA,Tesla K40m,GK110B,Tesla Kepler(Kxx),Kepler,745.0,876.0,28.0,7080.0,2013-11-22,1502.0,12.0,384.0,288.4,GDDR5,2880,0,0,1.5,245.0,,5046.0,https://www.techpowerup.com/gpu-specs/tesla-k40m.c2529,2013,,unknown,1.1758389261744966
+NVIDIA,Tesla K40s,GK110B,Tesla Kepler(Kxx),Kepler,706.0,706.0,28.0,7080.0,2013-11-22,1502.0,12.0,384.0,288.4,GDDR5,2880,0,0,1.5,245.0,,4067.0,https://www.techpowerup.com/gpu-specs/tesla-k40s.c2528,2013,,unknown,1.0
+NVIDIA,Tesla K40st,GK110B,Tesla Kepler(Kxx),Kepler,575.0,575.0,28.0,7080.0,2013-11-22,1502.0,12.0,384.0,288.4,GDDR5,2880,0,0,1.5,245.0,,3312.0,https://www.techpowerup.com/gpu-specs/tesla-k40st.c2530,2013,,unknown,1.0
+NVIDIA,Tesla K40t,GK110B,Tesla Kepler(Kxx),Kepler,745.0,876.0,28.0,7080.0,2013-11-22,1502.0,12.0,384.0,288.4,GDDR5,2880,0,0,1.5,245.0,,5046.0,https://www.techpowerup.com/gpu-specs/tesla-k40t.c3403,2013,,unknown,1.1758389261744966
+NVIDIA,Tesla K8,GK104,Tesla Kepler(Kxx),Kepler,693.0,811.0,28.0,3540.0,2014-09-16,1250.0,8.0,256.0,160.0,GDDR5,1536,0,0,0.5,100.0,,2491.0,https://www.techpowerup.com/gpu-specs/tesla-k8.c2619,2014,,unknown,1.1702741702741704
+NVIDIA,Tesla K80,GK210,Tesla Kepler(Kxx),Kepler 2.0,562.0,824.0,28.0,7100.0,2014-11-17,1253.0,12.0,384.0,240.6,GDDR5,2496,0,0,1.5,300.0,,4113.000000000001,https://www.techpowerup.com/gpu-specs/tesla-k80.c2616,2014,,unknown,1.4661921708185053
+NVIDIA,Tesla M10,GM107,Tesla Maxwell(Mxx),Maxwell,1033.0,1306.0,28.0,1870.0,2016-05-18,1300.0,8.0,128.0,83.2,GDDR5,640,5,0,2.0,225.0,,1672.0,https://www.techpowerup.com/gpu-specs/tesla-m10.c3035,2016,,unknown,1.2642787996127782
+NVIDIA,Tesla M2070,GF100,Tesla Fermi(x20xx),Fermi,574.0,574.0,40.0,3100.0,2011-07-25,783.0,6.0,384.0,150.3,GDDR5,448,14,0,0.75,225.0,,1030.4,https://www.techpowerup.com/gpu-specs/tesla-m2070.c1535,2011,,unknown,1.0
+NVIDIA,Tesla M2070-Q,GF100,Tesla Fermi(x20xx),Fermi,574.0,574.0,40.0,3100.0,2011-07-25,783.0,6.0,384.0,150.3,GDDR5,448,14,0,0.75,225.0,,1027.7,https://www.techpowerup.com/gpu-specs/tesla-m2070-q.c1536,2011,,unknown,1.0
+NVIDIA,Tesla M2075,GF110,Tesla Fermi(x20xx),Fermi 2.0,574.0,574.0,40.0,3000.0,2011-07-25,783.0,6.0,384.0,150.3,GDDR5,448,14,0,0.75,225.0,,1027.7,https://www.techpowerup.com/gpu-specs/tesla-m2075.c2025,2011,,unknown,1.0
+NVIDIA,Tesla M2090,GF110,Tesla Fermi(x20xx),Fermi 2.0,651.0,651.0,40.0,3000.0,2011-07-25,924.0,6.0,384.0,177.4,GDDR5,512,16,0,0.75,250.0,,1332.2,https://www.techpowerup.com/gpu-specs/tesla-m2090.c1537,2011,,unknown,1.0
+NVIDIA,Tesla M40,GM200,Tesla Maxwell(Mxx),Maxwell 2.0,948.0,1112.0,28.0,8000.0,2015-11-10,1502.0,12.0,384.0,288.4,GDDR5,3072,24,0,3.0,250.0,,6832.0,https://www.techpowerup.com/gpu-specs/tesla-m40.c2771,2015,,unknown,1.1729957805907174
+NVIDIA,Tesla M40 24 GB,GM200,Tesla Maxwell(Mxx),Maxwell 2.0,948.0,1112.0,28.0,8000.0,2015-11-10,1502.0,24.0,384.0,288.4,GDDR5,3072,24,0,3.0,250.0,,6832.0,https://www.techpowerup.com/gpu-specs/tesla-m40-24-gb.c3838,2015,,unknown,1.1729957805907174
+NVIDIA,Tesla M6 Mobile,GM204,Tesla Maxwell(Mxx),Maxwell 2.0,930.0,1180.0,28.0,5200.0,2015-08-30,1253.0,8.0,256.0,160.4,GDDR5,1536,12,0,2.0,100.0,,3625.0,https://www.techpowerup.com/gpu-specs/tesla-m6-mobile.c2818,2015,,unknown,1.2688172043010753
+NVIDIA,Tesla M6 X2 Mobile,GM204,Tesla Maxwell(Mxx),Maxwell 2.0,930.0,1180.0,28.0,5200.0,2015-08-30,1253.0,8.0,256.0,160.4,GDDR5,1536,12,0,2.0,100.0,,3625.0,https://www.techpowerup.com/gpu-specs/tesla-m6-x2-mobile.c4123,2015,,unknown,1.2688172043010753
+NVIDIA,Tesla M60,GM204,Tesla Maxwell(Mxx),Maxwell 2.0,557.0,1178.0,28.0,5200.0,2015-08-30,1253.0,8.0,256.0,160.4,GDDR5,2048,16,0,2.0,300.0,,4825.0,https://www.techpowerup.com/gpu-specs/tesla-m60.c2760,2015,,unknown,2.1149012567324954
+NVIDIA,Tesla P10,GP102,Tesla Pascal(Pxx),Pascal,1025.0,1493.0,16.0,11800.0,2016-09-13,1808.0,24.0,384.0,694.3,GDDR5X,3840,30,0,3.0,150.0,179.2,11470.0,https://www.techpowerup.com/gpu-specs/tesla-p10.c3750,2016,,unknown,1.4565853658536585
+NVIDIA,Tesla P100 DGXS,GP100,Tesla Pascal(Pxx),Pascal,1328.0,1480.0,16.0,15300.0,2016-04-05,715.0,16.0,4096.0,732.2,HBM2,3584,56,0,4.0,300.0,21220.0,10610.0,https://www.techpowerup.com/gpu-specs/tesla-p100-dgxs.c3285,2016,,unknown,1.1144578313253013
+NVIDIA,Tesla P100 PCIe 12 GB,GP100,Tesla Pascal(Pxx),Pascal,1190.0,1329.0,16.0,15300.0,2016-06-20,715.0,12.0,3072.0,549.1,HBM2,3584,56,0,3.0,250.0,19050.0,9526.0,https://www.techpowerup.com/gpu-specs/tesla-p100-pcie-12-gb.c2915,2016,,unknown,1.1168067226890757
+NVIDIA,Tesla P100 PCIe 16 GB,GP100,Tesla Pascal(Pxx),Pascal,1190.0,1329.0,16.0,15300.0,2016-06-20,715.0,16.0,4096.0,732.2,HBM2,3584,56,0,4.0,250.0,19050.0,9526.0,https://www.techpowerup.com/gpu-specs/tesla-p100-pcie-16-gb.c2888,2016,,unknown,1.1168067226890757
+NVIDIA,Tesla P100 SXM2,GP100,Tesla Pascal(Pxx),Pascal,1328.0,1480.0,16.0,15300.0,2016-04-05,715.0,16.0,4096.0,732.2,HBM2,3584,56,0,4.0,300.0,21220.0,10610.0,https://www.techpowerup.com/gpu-specs/tesla-p100-sxm2.c3183,2016,,unknown,1.1144578313253013
+NVIDIA,Tesla P4,GP104,Tesla Pascal(Pxx),Pascal,886.0,1114.0,16.0,7200.0,2016-09-13,1502.0,8.0,256.0,192.3,GDDR5,2560,20,0,2.0,75.0,89.12,5704.0,https://www.techpowerup.com/gpu-specs/tesla-p4.c2879,2016,,unknown,1.257336343115124
+NVIDIA,Tesla P40,GP102,Tesla Pascal(Pxx),Pascal,1303.0,1531.0,16.0,11800.0,2016-09-13,1808.0,24.0,384.0,347.1,GDDR5,3840,30,0,3.0,250.0,183.7,11760.0,https://www.techpowerup.com/gpu-specs/tesla-p40.c2878,2016,,unknown,1.1749808135072908
+NVIDIA,Tesla P6 Mobile,GP104,Tesla Pascal(Pxx),Pascal,1012.0,1506.0,16.0,7200.0,2017-03-24,1502.0,16.0,256.0,192.3,GDDR5,2048,16,0,2.0,90.0,96.38,6169.0,https://www.techpowerup.com/gpu-specs/tesla-p6-mobile.c3036,2017,,unknown,1.4881422924901186
+NVIDIA,Tesla PG500-216,GV100,Tesla Volta(Vxx),Volta,1260.0,1380.0,12.0,21100.0,2019-11-26,1106.0,32.0,4096.0,1130.0,HBM2,5120,80,640,6.0,250.0,28260.0,14130.0,https://www.techpowerup.com/gpu-specs/tesla-pg500-216.c3791,2019,113.0,estimated,1.0952380952380953
+NVIDIA,Tesla PG503-216,GV100,Tesla Volta(Vxx),Volta,1312.0,1530.0,12.0,21100.0,2019-11-26,1106.0,32.0,4096.0,1130.0,HBM2,4608,80,640,6.0,250.0,28200.0,14100.0,https://www.techpowerup.com/gpu-specs/tesla-pg503-216.c3790,2019,125.3,estimated,1.166158536585366
+NVIDIA,Tesla T10 16 GB,TU102,Tesla Turing(Txx),Turing,1065.0,1395.0,12.0,18600.0,2020-01-01,1575.0,16.0,256.0,403.2,GDDR6,3584,56,448,6.0,150.0,20000.0,9999.0,https://www.techpowerup.com/gpu-specs/tesla-t10-16-gb.c4036,2020,80.0,estimated,1.3098591549295775
+NVIDIA,Tesla T4,TU104,Tesla Turing(Txx),Turing,585.0,1590.0,12.0,13600.0,2018-09-13,1250.0,16.0,256.0,320.0,GDDR6,2560,40,320,4.0,70.0,65129.99999999999,8141.0,https://www.techpowerup.com/gpu-specs/tesla-t4.c3316,2018,65.0,reported,2.717948717948718
+NVIDIA,Tesla T4G,TU104,Tesla Turing(Txx),Turing,585.0,1590.0,12.0,13600.0,2018-09-13,1250.0,16.0,256.0,320.0,GDDR6,2560,40,320,4.0,70.0,65129.99999999999,8141.0,https://www.techpowerup.com/gpu-specs/tesla-t4g.c4134,2018,65.1,estimated,2.717948717948718
+NVIDIA,Tesla V100 DGXS 16 GB,GV100,Tesla Volta(Vxx),Volta,1354.0,1582.0,12.0,21100.0,2018-03-27,876.0,16.0,4096.0,897.0,HBM2,5120,80,640,6.0,250.0,32400.0,16200.0,https://www.techpowerup.com/gpu-specs/tesla-v100-dgxs-16-gb.c3763,2018,129.6,estimated,1.1683899556868538
+NVIDIA,Tesla V100 DGXS 32 GB,GV100,Tesla Volta(Vxx),Volta,1297.0,1530.0,12.0,21100.0,2018-03-27,876.0,32.0,4096.0,897.0,HBM2,5120,80,640,6.0,250.0,31330.0,15670.0,https://www.techpowerup.com/gpu-specs/tesla-v100-dgxs-32-gb.c3186,2018,125.3,estimated,1.1796453353893601
+NVIDIA,Tesla V100 FHHL,GV100,Tesla Volta(Vxx),Volta,937.0,1290.0,12.0,21100.0,2018-03-27,808.0,16.0,4096.0,827.4,HBM2,5120,80,640,6.0,250.0,26420.0,13210.0,https://www.techpowerup.com/gpu-specs/tesla-v100-fhhl.c3248,2018,105.7,estimated,1.376734258271078
+NVIDIA,Tesla V100 PCIe 16 GB,GV100,Tesla Volta(Vxx),Volta,1245.0,1380.0,12.0,21100.0,2017-06-21,876.0,16.0,4096.0,897.0,HBM2,5120,80,640,6.0,300.0,28260.0,14130.0,https://www.techpowerup.com/gpu-specs/tesla-v100-pcie-16-gb.c2957,2017,112.0,reported,1.108433734939759
+NVIDIA,Tesla V100 PCIe 32 GB,GV100,Tesla Volta(Vxx),Volta,1230.0,1380.0,12.0,21100.0,2018-03-27,876.0,32.0,4096.0,897.0,HBM2,5120,80,640,6.0,250.0,28260.0,14130.0,https://www.techpowerup.com/gpu-specs/tesla-v100-pcie-32-gb.c3184,2018,113.0,estimated,1.1219512195121952
+NVIDIA,Tesla V100 SXM2 16 GB,GV100,Tesla Volta(Vxx),Volta,1245.0,1597.0,12.0,21100.0,2019-11-26,1106.0,16.0,4096.0,1130.0,HBM2,5120,80,640,6.0,250.0,32710.0,16350.000000000002,https://www.techpowerup.com/gpu-specs/tesla-v100-sxm2-16-gb.c3471,2019,125.0,reported,1.282730923694779
+NVIDIA,Tesla V100 SXM2 32 GB,GV100,Tesla Volta(Vxx),Volta,1290.0,1530.0,12.0,21100.0,2018-03-27,877.0,32.0,4096.0,898.0,HBM2,5120,80,640,6.0,250.0,31330.0,15670.0,https://www.techpowerup.com/gpu-specs/tesla-v100-sxm2-32-gb.c3185,2018,125.0,reported,1.186046511627907
+NVIDIA,Tesla V100 SXM3 32 GB,GV100,Tesla Volta(Vxx),Volta,1380.0,1597.0,12.0,21100.0,2018-03-27,958.0,32.0,4096.0,981.0,HBM2,5120,80,640,6.0,250.0,32710.0,16350.000000000002,https://www.techpowerup.com/gpu-specs/tesla-v100-sxm3-32-gb.c3472,2018,130.8,estimated,1.1572463768115941
+NVIDIA,Tesla V100S PCIe 32 GB,GV100,Tesla Volta(Vxx),Volta,1245.0,1597.0,12.0,21100.0,2019-11-26,1107.0,32.0,4096.0,1130.0,HBM2,5120,80,640,6.0,250.0,32710.0,16350.000000000002,https://www.techpowerup.com/gpu-specs/tesla-v100s-pcie-32-gb.c3467,2019,130.0,reported,1.282730923694779
+NVIDIA,Tesla X2070,GF100,Tesla Fermi(x20xx),Fermi,651.0,651.0,40.0,3100.0,2011-07-25,924.0,6.0,384.0,177.4,GDDR5,448,14,0,0.75,225.0,,1165.7,https://www.techpowerup.com/gpu-specs/tesla-x2070.c2024,2011,,unknown,1.0
+NVIDIA,Tesla X2090,GF110,Tesla Fermi(x20xx),Fermi 2.0,651.0,651.0,40.0,3000.0,2011-07-25,924.0,6.0,384.0,177.4,GDDR5,512,16,0,0.75,225.0,,1332.2,https://www.techpowerup.com/gpu-specs/tesla-x2090.c1887,2011,,unknown,1.0

data/models/itl.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c31f2a56d528318e0462ae82b0419beb77ff20a6411009ff1bbb4186813c0792
+size 238314

data/models/meta.json

@@ -0,0 +1,139 @@
+{
+  "seen_models": [
+    "01-ai/Yi-1.5-6B-Chat",
+    "01-ai/Yi-1.5-9B-Chat",
+    "EleutherAI/gpt-j-6b",
+    "EleutherAI/gpt-neox-20b",
+    "HuggingFaceTB/SmolLM2-1.7B-Instruct",
+    "Qwen/Qwen2.5-0.5B-Instruct",
+    "Qwen/Qwen2.5-1.5B-Instruct",
+    "Qwen/Qwen2.5-3B-Instruct",
+    "Qwen/Qwen2.5-7B-Instruct",
+    "Qwen/Qwen3-14B",
+    "allenai/OLMo-2-1124-13B-Instruct",
+    "allenai/OLMo-2-1124-7B-Instruct",
+    "berkeley-nest/Starling-LM-7B-alpha",
+    "deepseek-ai/deepseek-llm-7b-chat",
+    "google/gemma-2-2b-it",
+    "google/gemma-3-12b-it",
+    "google/gemma-3-27b-it",
+    "ibm-granite/granite-3.0-2b-instruct",
+    "ibm-granite/granite-3.0-8b-instruct",
+    "internlm/internlm2-7b",
+    "internlm/internlm2_5-20b-chat",
+    "meta-llama/Llama-2-13b-chat-hf",
+    "meta-llama/Llama-3.1-8B-Instruct",
+    "meta-llama/Llama-3.2-3B-Instruct",
+    "microsoft/Phi-3-medium-4k-instruct",
+    "microsoft/Phi-3-mini-4k-instruct",
+    "microsoft/phi-2",
+    "microsoft/phi-4",
+    "mistralai/Mistral-7B-Instruct-v0.3",
+    "mistralai/Mistral-Small-24B-Instruct-2501",
+    "mistralai/Mistral-Small-Instruct-2409",
+    "mlabonne/AlphaMonarch-7B",
+    "mlabonne/NeuralBeagle14-7B",
+    "nvidia/AceMath-1.5B-Instruct",
+    "nvidia/AceMath-7B-Instruct",
+    "nvidia/Llama-3.1-Minitron-4B-Width-Base",
+    "nvidia/Mistral-NeMo-Minitron-8B-Instruct",
+    "nvidia/Nemotron-Mini-4B-Instruct",
+    "openai-community/gpt2",
+    "tiiuae/Falcon3-3B-Instruct",
+    "upstage/SOLAR-10.7B-Instruct-v1.0",
+    "upstage/solar-pro-preview-instruct"
+  ],
+  "seen_gpus": [
+    "A100 SXM4 40 GB",
+    "A30 PCIe",
+    "H100 NVL 94 GB",
+    "H200 NVL",
+    "L4",
+    "L40S",
+    "Tesla T4",
+    "Tesla V100 SXM2 32 GB"
+  ],
+  "power_features": [
+    "scenario",
+    "log_total_b_params",
+    "model_type",
+    "num_key_value_heads",
+    "num_layers",
+    "memory_bandwidth_gb_s",
+    "boost_percentage",
+    "transistor_count_m",
+    "base_clock_mhz",
+    "release_year",
+    "bandwidth_latency"
+  ],
+  "itl_features": [
+    "scenario",
+    "model_type",
+    "total_b_params",
+    "hidden_size",
+    "num_attention_heads",
+    "num_key_value_heads",
+    "num_layers",
+    "memory_bandwidth_gb_s",
+    "memory_size_gb",
+    "memory_type",
+    "tflops_16b",
+    "release_year",
+    "bandwidth_latency",
+    "compute_latency_s"
+  ],
+  "tier_accuracy_mdape": {
+    "power": {
+      "green": {
+        "offline": 1.4,
+        "server": 5.7
+      },
+      "yellow": {
+        "offline": 1.9,
+        "server": 6.8
+      },
+      "orange": {
+        "offline": 3.9,
+        "server": 13.0
+      },
+      "red": {
+        "offline": 3.9,
+        "server": 15.1
+      }
+    },
+    "itl": {
+      "green": {
+        "offline": 12.7,
+        "server": 4.9
+      },
+      "yellow": {
+        "offline": 15.6,
+        "server": 5.6
+      },
+      "orange": {
+        "offline": 24.9,
+        "server": 8.5
+      },
+      "red": {
+        "offline": 36.2,
+        "server": 8.6
+      }
+    }
+  },
+  "log_transformed_targets": [
+    "itl"
+  ],
+  "n_training_runs": {
+    "power": 4213,
+    "itl": 4163
+  },
+  "gpu_tdp": {
+    "A30 PCIe": 165.0,
+    "H200 NVL": 700.0,
+    "A100 SXM4 40 GB": 400.0,
+    "L40S": 350.0,
+    "Tesla V100 SXM2 32 GB": 300.0,
+    "L4": 72.0,
+    "Tesla T4": 70.0
+  }
+}

data/models/power.joblib

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:551b7e9b99ffc3f45294d968f5b09147f52259fa62098948c7650a633bfc3b14
+size 771329

data/models/profiled_llms.json

@@ -0,0 +1,548 @@
+{
+  "01-ai/Yi-1.5-6B-Chat": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 4096,
+    "model_type": "llama",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 4,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 6.0
+  },
+  "01-ai/Yi-1.5-9B-Chat": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 4096,
+    "model_type": "llama",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 4,
+    "num_layers": 48,
+    "torch_dtype": null,
+    "total_b_params": 9.0
+  },
+  "EleutherAI/gpt-j-6b": {
+    "architectures": [
+      "GPTJForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": null,
+    "model_type": "gptj",
+    "num_attention_heads": 16,
+    "num_key_value_heads": 16,
+    "num_layers": 28,
+    "torch_dtype": null,
+    "total_b_params": 6.05
+  },
+  "EleutherAI/gpt-neox-20b": {
+    "architectures": [
+      "GPTNeoXForCausalLM"
+    ],
+    "hidden_size": 6144,
+    "max_position_embeddings": 2048,
+    "model_type": "gpt_neox",
+    "num_attention_heads": 64,
+    "num_key_value_heads": 64,
+    "num_layers": 44,
+    "torch_dtype": null,
+    "total_b_params": 20.0
+  },
+  "HuggingFaceTB/SmolLM2-1.7B-Instruct": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 2048,
+    "max_position_embeddings": 8192,
+    "model_type": "llama",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 32,
+    "num_layers": 24,
+    "torch_dtype": null,
+    "total_b_params": 1.7
+  },
+  "Qwen/Qwen2.5-0.5B-Instruct": {
+    "architectures": [
+      "Qwen2ForCausalLM"
+    ],
+    "hidden_size": 896,
+    "max_position_embeddings": 32768,
+    "model_type": "qwen2",
+    "num_attention_heads": 14,
+    "num_key_value_heads": 2,
+    "num_layers": 24,
+    "torch_dtype": null,
+    "total_b_params": 0.49
+  },
+  "Qwen/Qwen2.5-1.5B-Instruct": {
+    "architectures": [
+      "Qwen2ForCausalLM"
+    ],
+    "hidden_size": 1536,
+    "max_position_embeddings": 32768,
+    "model_type": "qwen2",
+    "num_attention_heads": 12,
+    "num_key_value_heads": 2,
+    "num_layers": 28,
+    "torch_dtype": null,
+    "total_b_params": 1.54
+  },
+  "Qwen/Qwen2.5-3B-Instruct": {
+    "architectures": [
+      "Qwen2ForCausalLM"
+    ],
+    "hidden_size": 2048,
+    "max_position_embeddings": 32768,
+    "model_type": "qwen2",
+    "num_attention_heads": 16,
+    "num_key_value_heads": 2,
+    "num_layers": 36,
+    "torch_dtype": null,
+    "total_b_params": 3.09
+  },
+  "Qwen/Qwen2.5-7B-Instruct": {
+    "architectures": [
+      "Qwen2ForCausalLM"
+    ],
+    "hidden_size": 3584,
+    "max_position_embeddings": 32768,
+    "model_type": "qwen2",
+    "num_attention_heads": 28,
+    "num_key_value_heads": 4,
+    "num_layers": 28,
+    "torch_dtype": null,
+    "total_b_params": 7.62
+  },
+  "Qwen/Qwen3-14B": {
+    "architectures": [
+      "Qwen3ForCausalLM"
+    ],
+    "hidden_size": 5120,
+    "max_position_embeddings": 40960,
+    "model_type": "qwen3",
+    "num_attention_heads": 40,
+    "num_key_value_heads": 8,
+    "num_layers": 40,
+    "torch_dtype": null,
+    "total_b_params": 14.0
+  },
+  "allenai/OLMo-2-1124-13B-Instruct": {
+    "architectures": [
+      "Olmo2ForCausalLM"
+    ],
+    "hidden_size": 5120,
+    "max_position_embeddings": 4096,
+    "model_type": "olmo2",
+    "num_attention_heads": 40,
+    "num_key_value_heads": 40,
+    "num_layers": 40,
+    "torch_dtype": null,
+    "total_b_params": 14.0
+  },
+  "allenai/OLMo-2-1124-7B-Instruct": {
+    "architectures": [
+      "Olmo2ForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 4096,
+    "model_type": "olmo2",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 32,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 7.0
+  },
+  "berkeley-nest/Starling-LM-7B-alpha": {
+    "architectures": [
+      "MistralForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 8192,
+    "model_type": "mistral",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 7.0
+  },
+  "deepseek-ai/deepseek-llm-7b-chat": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 4096,
+    "model_type": "llama",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 32,
+    "num_layers": 30,
+    "torch_dtype": null,
+    "total_b_params": 7.0
+  },
+  "google/gemma-2-2b-it": {
+    "architectures": [
+      "Gemma2ForCausalLM"
+    ],
+    "hidden_size": 2304,
+    "max_position_embeddings": 8192,
+    "model_type": "gemma2",
+    "num_attention_heads": 8,
+    "num_key_value_heads": 4,
+    "num_layers": 26,
+    "torch_dtype": null,
+    "total_b_params": 2.61
+  },
+  "google/gemma-3-12b-it": {
+    "architectures": [
+      "Gemma3ForConditionalGeneration"
+    ],
+    "hidden_size": 3840,
+    "max_position_embeddings": null,
+    "model_type": "gemma3",
+    "num_attention_heads": 16,
+    "num_key_value_heads": 8,
+    "num_layers": 48,
+    "torch_dtype": null,
+    "total_b_params": 12.0
+  },
+  "google/gemma-3-27b-it": {
+    "architectures": [
+      "Gemma3ForConditionalGeneration"
+    ],
+    "hidden_size": 5376,
+    "max_position_embeddings": null,
+    "model_type": "gemma3",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 16,
+    "num_layers": 62,
+    "torch_dtype": null,
+    "total_b_params": 27.0
+  },
+  "ibm-granite/granite-3.0-2b-instruct": {
+    "architectures": [
+      "GraniteForCausalLM"
+    ],
+    "hidden_size": 2048,
+    "max_position_embeddings": 4096,
+    "model_type": "granite",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 40,
+    "torch_dtype": null,
+    "total_b_params": 2.0
+  },
+  "ibm-granite/granite-3.0-8b-instruct": {
+    "architectures": [
+      "GraniteForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 4096,
+    "model_type": "granite",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 40,
+    "torch_dtype": null,
+    "total_b_params": 8.0
+  },
+  "internlm/internlm2-7b": {
+    "architectures": [
+      "InternLM2ForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 32768,
+    "model_type": "internlm2",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 7.0
+  },
+  "internlm/internlm2_5-20b-chat": {
+    "architectures": [
+      "InternLM2ForCausalLM"
+    ],
+    "hidden_size": 6144,
+    "max_position_embeddings": 32768,
+    "model_type": "internlm2",
+    "num_attention_heads": 48,
+    "num_key_value_heads": 8,
+    "num_layers": 48,
+    "torch_dtype": null,
+    "total_b_params": 20.0
+  },
+  "meta-llama/Llama-2-13b-chat-hf": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 5120,
+    "max_position_embeddings": 4096,
+    "model_type": "llama",
+    "num_attention_heads": 40,
+    "num_key_value_heads": 40,
+    "num_layers": 40,
+    "torch_dtype": null,
+    "total_b_params": 13.0
+  },
+  "meta-llama/Llama-3.1-8B-Instruct": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 131072,
+    "model_type": "llama",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 8.03
+  },
+  "meta-llama/Llama-3.2-3B-Instruct": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 3072,
+    "max_position_embeddings": 131072,
+    "model_type": "llama",
+    "num_attention_heads": 24,
+    "num_key_value_heads": 8,
+    "num_layers": 28,
+    "torch_dtype": null,
+    "total_b_params": 3.21
+  },
+  "microsoft/Phi-3-medium-4k-instruct": {
+    "architectures": [
+      "Phi3ForCausalLM"
+    ],
+    "hidden_size": 5120,
+    "max_position_embeddings": 4096,
+    "model_type": "phi3",
+    "num_attention_heads": 40,
+    "num_key_value_heads": 10,
+    "num_layers": 40,
+    "torch_dtype": null,
+    "total_b_params": 14.0
+  },
+  "microsoft/Phi-3-mini-4k-instruct": {
+    "architectures": [
+      "Phi3ForCausalLM"
+    ],
+    "hidden_size": 3072,
+    "max_position_embeddings": 4096,
+    "model_type": "phi3",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 32,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 3.8
+  },
+  "microsoft/phi-2": {
+    "architectures": [
+      "PhiForCausalLM"
+    ],
+    "hidden_size": 2560,
+    "max_position_embeddings": 2048,
+    "model_type": "phi",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 32,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 2.7
+  },
+  "microsoft/phi-4": {
+    "architectures": [
+      "Phi3ForCausalLM"
+    ],
+    "hidden_size": 5120,
+    "max_position_embeddings": 16384,
+    "model_type": "phi3",
+    "num_attention_heads": 40,
+    "num_key_value_heads": 10,
+    "num_layers": 40,
+    "torch_dtype": null,
+    "total_b_params": 14.7
+  },
+  "mistralai/Mistral-7B-Instruct-v0.3": {
+    "architectures": [
+      "MistralForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 32768,
+    "model_type": "mistral",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 7.25
+  },
+  "mistralai/Mistral-Small-24B-Instruct-2501": {
+    "architectures": [
+      "MistralForCausalLM"
+    ],
+    "hidden_size": 5120,
+    "max_position_embeddings": 32768,
+    "model_type": "mistral",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 40,
+    "torch_dtype": null,
+    "total_b_params": 24.0
+  },
+  "mistralai/Mistral-Small-Instruct-2409": {
+    "architectures": [
+      "MistralForCausalLM"
+    ],
+    "hidden_size": 6144,
+    "max_position_embeddings": 32768,
+    "model_type": "mistral",
+    "num_attention_heads": 48,
+    "num_key_value_heads": 8,
+    "num_layers": 56,
+    "torch_dtype": null,
+    "total_b_params": 24.0
+  },
+  "mlabonne/AlphaMonarch-7B": {
+    "architectures": [
+      "MistralForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 32768,
+    "model_type": "mistral",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 7.0
+  },
+  "mlabonne/NeuralBeagle14-7B": {
+    "architectures": [
+      "MistralForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 32768,
+    "model_type": "mistral",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 7.0
+  },
+  "nvidia/AceMath-1.5B-Instruct": {
+    "architectures": [
+      "Qwen2ForCausalLM"
+    ],
+    "hidden_size": 1536,
+    "max_position_embeddings": 4096,
+    "model_type": "qwen2",
+    "num_attention_heads": 12,
+    "num_key_value_heads": 2,
+    "num_layers": 28,
+    "torch_dtype": null,
+    "total_b_params": 1.5
+  },
+  "nvidia/AceMath-7B-Instruct": {
+    "architectures": [
+      "Qwen2ForCausalLM"
+    ],
+    "hidden_size": 3584,
+    "max_position_embeddings": 4096,
+    "model_type": "qwen2",
+    "num_attention_heads": 28,
+    "num_key_value_heads": 4,
+    "num_layers": 28,
+    "torch_dtype": null,
+    "total_b_params": 7.0
+  },
+  "nvidia/Llama-3.1-Minitron-4B-Width-Base": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 3072,
+    "max_position_embeddings": 131072,
+    "model_type": "llama",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 5.0
+  },
+  "nvidia/Mistral-NeMo-Minitron-8B-Instruct": {
+    "architectures": [
+      "MistralForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 8192,
+    "model_type": "mistral",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 40,
+    "torch_dtype": null,
+    "total_b_params": 8.0
+  },
+  "nvidia/Nemotron-Mini-4B-Instruct": {
+    "architectures": [
+      "NemotronForCausalLM"
+    ],
+    "hidden_size": 3072,
+    "max_position_embeddings": 4096,
+    "model_type": "nemotron",
+    "num_attention_heads": 24,
+    "num_key_value_heads": 8,
+    "num_layers": 32,
+    "torch_dtype": null,
+    "total_b_params": 4.0
+  },
+  "openai-community/gpt2": {
+    "architectures": [
+      "GPT2LMHeadModel"
+    ],
+    "hidden_size": 768,
+    "max_position_embeddings": null,
+    "model_type": "gpt2",
+    "num_attention_heads": 12,
+    "num_key_value_heads": 12,
+    "num_layers": 12,
+    "torch_dtype": null,
+    "total_b_params": 0.124
+  },
+  "tiiuae/Falcon3-3B-Instruct": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 3072,
+    "max_position_embeddings": 32768,
+    "model_type": "llama",
+    "num_attention_heads": 12,
+    "num_key_value_heads": 4,
+    "num_layers": 22,
+    "torch_dtype": null,
+    "total_b_params": 3.0
+  },
+  "upstage/SOLAR-10.7B-Instruct-v1.0": {
+    "architectures": [
+      "LlamaForCausalLM"
+    ],
+    "hidden_size": 4096,
+    "max_position_embeddings": 4096,
+    "model_type": "llama",
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "num_layers": 48,
+    "torch_dtype": null,
+    "total_b_params": 10.7
+  },
+  "upstage/solar-pro-preview-instruct": {
+    "architectures": [
+      "SolarForCausalLM"
+    ],
+    "hidden_size": 5120,
+    "max_position_embeddings": 4096,
+    "model_type": "solar",
+    "num_attention_heads": 40,
+    "num_key_value_heads": 10,
+    "num_layers": 64,
+    "torch_dtype": null,
+    "total_b_params": 22.1
+  }
+}

pytest.ini

@@ -0,0 +1,4 @@
+[pytest]
+testpaths = tests
+markers =
+    network: reaches the Hugging Face Hub

requirements.txt

@@ -0,0 +1,12 @@
+# Runtime
+gradio==5.49.1
+numpy==2.2.6
+pandas==2.3.1
+scikit-learn==1.7.1
+scipy==1.16.2
+xgboost==3.0.4
+joblib==1.5.2
+
+# Build-time only: scripts/build_gpu_db.py regenerates data/gpu_database.csv.
+# The app itself reads the generated CSV and never imports dbgpu.
+dbgpu==2025.12

scripts/build_gpu_db.py

@@ -0,0 +1,221 @@
+"""Build the demo's GPU database from dbgpu (TechPowerUp specs).
+
+The WattGPU models need a handful of GPU specifications per prediction:
+memory bandwidth, memory size, memory type, clocks, transistor count,
+release year, TDP, and peak dense FP16 tensor throughput.
+
+Everything except the tensor throughput comes straight out of `dbgpu`, which
+is the same source the paper's `data/gpu_features.csv` was generated from.
+TechPowerUp does not publish tensor-core throughput, so this script fills
+`tensor_tflops_16b` from, in order of preference:
+
+  1. the curated values already in the paper's `data/gpu_features.csv`,
+  2. a curated table of manufacturer-reported figures for common
+     accelerators (`CURATED_TENSOR_TFLOPS`),
+  3. an architecture-based estimate,
+     tensor_cores * boost_clock * FLOPs-per-tensor-core-per-cycle,
+     which reproduces the manufacturer figures for the GPUs in (1)-(2) to
+     within ~15%.
+
+Rows for which no throughput can be established at all are still kept: the
+power model does not use it, and the ITL model reports the gap to the user.
+
+Usage:  python scripts/build_gpu_db.py [--out data/gpu_database.csv]
+"""
+
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+
+import pandas as pd
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+PAPER_DATA = os.path.join(os.path.dirname(REPO_ROOT), "data")
+PAPER_GPU_FEATURES = os.path.join(PAPER_DATA, "gpu_features.csv")
+PAPER_MEASUREMENTS = os.path.join(PAPER_DATA, "watt_counts_subset.csv")
+
+# Columns the demo keeps from dbgpu. A superset of what the two models use, so
+# the UI can show a spec sheet alongside the prediction.
+KEPT_COLUMNS = [
+    "manufacturer",
+    "name",
+    "gpu_name",
+    "generation",
+    "architecture",
+    "base_clock_mhz",
+    "boost_clock_mhz",
+    "process_size_nm",
+    "transistor_count_m",
+    "release_date",
+    "memory_clock_mhz",
+    "memory_size_gb",
+    "memory_bus_bits",
+    "memory_bandwidth_gb_s",
+    "memory_type",
+    "shading_units",
+    "streaming_multiprocessors",
+    "tensor_cores",
+    "l2_cache_mb",
+    "thermal_design_power_w",
+    "half_float_performance_gflop_s",
+    "single_float_performance_gflop_s",
+    "tpu_url",
+]
+
+# Manufacturer-reported peak dense FP16 tensor throughput (TFLOP/s, no
+# sparsity). Sources: NVIDIA datasheets and AMD Instinct product briefs.
+CURATED_TENSOR_TFLOPS = {
+    # NVIDIA data centre
+    "Tesla V100 PCIe 16 GB": 112,
+    "Tesla V100 SXM2 16 GB": 125,
+    "Tesla V100 SXM2 32 GB": 125,
+    "Tesla V100S PCIe 32 GB": 130,
+    "Tesla T4": 65,
+    "A2 PCIe": 36,
+    "A10 PCIe": 125,
+    "A10G": 70,
+    "A16 PCIe": 71,
+    "A30 PCIe": 165,
+    "A40 PCIe": 150,
+    "A100 PCIe 40 GB": 312,
+    "A100 PCIe 80 GB": 312,
+    "A100 SXM4 40 GB": 312,
+    "A100 SXM4 80 GB": 312,
+    "L4": 121,
+    "L40": 181,
+    "L40S": 362,
+    "H100 PCIe 80 GB": 756,
+    "H100 SXM5 80 GB": 989,
+    "H100 SXM5 96 GB": 989,
+    "H100 NVL 94 GB": 835,
+    "H200 SXM 141 GB": 989,
+    "H200 NVL": 835,
+    "B200 SXM 180 GB": 2250,
+    "RTX 6000 Ada Generation": 364,
+    "RTX 5000 Ada Generation": 262,
+    "RTX A6000": 155,
+    "RTX A5000": 111,
+}
+
+# Only NVIDIA parts are kept. Every measurement behind WattGPU ran on NVIDIA
+# hardware under vLLM with CUDA, and the two strongest hardware features the
+# models use -- memory bandwidth and FP16 tensor throughput -- mean different
+# things on other vendors' matrix engines. Estimating for AMD or Intel would be
+# extrapolating across an architectural boundary the training data never crosses.
+KEPT_MANUFACTURERS = ("NVIDIA",)
+
+# Dense FP16 tensor FLOPs per tensor core per clock cycle, by architecture.
+# Consumer parts use the FP16-with-FP16-accumulate rate, matching how the
+# paper's `gpu_features.csv` reports RTX cards.
+FLOPS_PER_TENSOR_CORE_PER_CYCLE = {
+    "Volta": 128,
+    "Turing": 128,
+    "Ampere": 256,
+    "Ada Lovelace": 256,
+    "Hopper": 1024,
+    "Blackwell": 256,
+    "Blackwell 2.0": 256,
+}
+
+# GA100 (A100/A30) doubles the per-core rate of consumer Ampere.
+DATACENTRE_AMPERE_CHIPS = {"GA100"}
+
+
+def _estimate_tensor_tflops(row: pd.Series) -> float | None:
+    """Architecture-based estimate of dense FP16 tensor throughput."""
+    cores = row.get("tensor_cores")
+    clock = row.get("boost_clock_mhz")
+    arch = row.get("architecture")
+
+    if not cores or pd.isna(cores) or float(cores) <= 0:
+        return None
+    if not clock or pd.isna(clock):
+        return None
+
+    per_cycle = FLOPS_PER_TENSOR_CORE_PER_CYCLE.get(arch)
+    if per_cycle is None:
+        return None
+    if arch == "Ampere" and str(row.get("gpu_name")) in DATACENTRE_AMPERE_CHIPS:
+        per_cycle = 512
+
+    return round(float(cores) * float(clock) * 1e6 * per_cycle / 1e12, 1)
+
+
+def _paper_tensor_tflops() -> dict[str, float]:
+    """Tensor throughput for the GPUs the models were actually trained on.
+
+    Restricted to the profiled GPUs so the rest of the database stays on a
+    single convention (dense FP16 with FP16 accumulate). The paper's file also
+    lists consumer cards, but with the FP32-accumulate rate, which would be
+    inconsistent with the estimate used for every other consumer part.
+    """
+    if not (os.path.exists(PAPER_GPU_FEATURES) and os.path.exists(PAPER_MEASUREMENTS)):
+        print("note: paper data not found, skipping profiled-GPU overrides")
+        return {}
+
+    profiled = set(pd.read_csv(PAPER_MEASUREMENTS, usecols=["gpu_type"])["gpu_type"])
+    paper = pd.read_csv(PAPER_GPU_FEATURES, sep=";")
+    paper = paper[paper["gpu_type"].isin(profiled)]
+    paper = paper.dropna(subset=["gpu_db_name", "tensor_tflops"])
+    return dict(zip(paper["gpu_db_name"], paper["tensor_tflops"].astype(float)))
+
+
+def build(min_memory_gb: float = 6.0) -> pd.DataFrame:
+    from dbgpu import GPUDatabase
+
+    df = GPUDatabase.default().dataframe
+    print(f"dbgpu: {len(df)} GPU specifications")
+
+    df = df[[c for c in KEPT_COLUMNS if c in df.columns]].copy()
+
+    # Only GPUs that could plausibly serve an LLM: enough memory to hold
+    # weights, and a known memory bandwidth (the single strongest feature in
+    # both models).
+    df = df[df["manufacturer"].isin(KEPT_MANUFACTURERS)]
+    print(f"after restricting to {', '.join(KEPT_MANUFACTURERS)}: {len(df)}")
+
+    df = df[df["memory_bandwidth_gb_s"].notna()]
+    df = df[df["memory_size_gb"].fillna(0) >= min_memory_gb]
+    df = df[df["thermal_design_power_w"].notna()]
+    print(f"after filtering to LLM-capable parts: {len(df)}")
+
+    df["release_date"] = pd.to_datetime(df["release_date"], errors="coerce")
+    df["release_year"] = df["release_date"].dt.year
+
+    # `gpu_db_name` is the join key used by the paper's data files.
+    df = df.rename(columns={"name": "gpu_db_name"})
+
+    # Profiled GPUs take precedence: their values are the ones the models were
+    # trained against.
+    overrides = {**CURATED_TENSOR_TFLOPS, **_paper_tensor_tflops()}
+    df["tensor_tflops_16b"] = df["gpu_db_name"].map(overrides)
+    estimated = df.apply(_estimate_tensor_tflops, axis=1)
+    df["tensor_tflops_source"] = "unknown"
+    df.loc[estimated.notna(), "tensor_tflops_source"] = "estimated"
+    df.loc[df["tensor_tflops_16b"].notna(), "tensor_tflops_source"] = "reported"
+    df["tensor_tflops_16b"] = df["tensor_tflops_16b"].fillna(estimated)
+
+    df["boost_percentage"] = df["boost_clock_mhz"] / df["base_clock_mhz"]
+
+    df = df.sort_values(["manufacturer", "gpu_db_name"]).reset_index(drop=True)
+    print(df["tensor_tflops_source"].value_counts().to_string())
+    return df
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--out", default=os.path.join(REPO_ROOT, "data", "gpu_database.csv"))
+    parser.add_argument("--min-memory-gb", type=float, default=6.0)
+    args = parser.parse_args()
+
+    df = build(min_memory_gb=args.min_memory_gb)
+    os.makedirs(os.path.dirname(args.out), exist_ok=True)
+    df.to_csv(args.out, index=False)
+    print(f"wrote {len(df)} GPUs to {args.out}")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/cache_gated_models.py

@@ -0,0 +1,102 @@
+"""Cache the architecture of licence-gated models the demo cannot read.
+
+Some of the best-known LLMs -- Llama and Gemma -- are licence-gated on the
+Hugging Face Hub, so an anonymous demo cannot read their `config.json` and has
+to refuse them. Serving them with a maintainer's own token would work, but it
+would mean using one person's licence acceptance on behalf of every visitor.
+
+Instead this script reads the architecture from a public, unquantised mirror of
+the same weights and caches the handful of integers WattGPU actually needs.
+Those numbers -- layer count, hidden size, head counts, parameter count -- are
+published in the model cards and papers, so caching them redistributes nothing.
+
+Each entry records the mirror it came from, so any value can be traced and
+re-checked. Run this again to refresh:
+
+    python scripts/cache_gated_models.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, REPO_ROOT)
+
+from wattgpu_demo.hf_models import (  # noqa: E402
+    HF_ENDPOINT,
+    _get_json,
+    detect_quantisation,
+    llm_info_from_config,
+)
+
+# Gated model -> a public repository holding the same architecture at full
+# precision. Mirrors are checked for quantisation before anything is cached.
+MIRRORS = {
+    "meta-llama/Llama-3.2-1B": "unsloth/Llama-3.2-1B",
+    "meta-llama/Llama-3.2-1B-Instruct": "unsloth/Llama-3.2-1B-Instruct",
+    "meta-llama/Meta-Llama-3-8B-Instruct": "NousResearch/Meta-Llama-3-8B-Instruct",
+    "google/gemma-3-1b-it": "unsloth/gemma-3-1b-it",
+    "google/gemma-3-270m": "unsloth/gemma-3-270m",
+}
+
+DEFAULT_OUT = os.path.join(REPO_ROOT, "data", "gated_llms.json")
+
+
+def fetch_entry(canonical: str, mirror: str) -> dict:
+    config = _get_json(f"{HF_ENDPOINT}/{mirror}/raw/main/config.json", mirror)
+
+    quantisation = detect_quantisation(mirror, config)
+    if quantisation:
+        raise ValueError(
+            f"{mirror} is quantised ({quantisation}); it cannot stand in for {canonical}")
+
+    info = _get_json(f"{HF_ENDPOINT}/api/models/{mirror}", mirror)
+    total = ((info or {}).get("safetensors") or {}).get("total")
+    if not isinstance(total, (int, float)) or total <= 0:
+        raise ValueError(f"{mirror} publishes no safetensors index")
+
+    # Reuse the same adapter the live path uses, so a cached model and a
+    # fetched one go through identical validation.
+    llm = llm_info_from_config(canonical, config, float(total) / 1e9, "published config")
+    return {
+        "model_type": llm.model_type,
+        "num_layers": llm.num_layers,
+        "hidden_size": llm.hidden_size,
+        "num_attention_heads": llm.num_attention_heads,
+        "num_key_value_heads": llm.num_key_value_heads,
+        "total_b_params": round(llm.total_b_params, 6),
+        "architectures": llm.architectures,
+        "max_position_embeddings": llm.max_position_embeddings,
+        "torch_dtype": llm.torch_dtype,
+        "source_mirror": mirror,
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--out", default=DEFAULT_OUT)
+    args = parser.parse_args()
+
+    entries: dict[str, dict] = {}
+    for canonical, mirror in MIRRORS.items():
+        try:
+            entries[canonical] = fetch_entry(canonical, mirror)
+            e = entries[canonical]
+            print(f"  {canonical}: {e['total_b_params']:.3f} B, "
+                  f"{e['num_layers']} layers, via {mirror}")
+        except Exception as exc:  # noqa: BLE001 - report and keep going
+            print(f"  SKIPPED {canonical}: {exc}")
+
+    os.makedirs(os.path.dirname(args.out), exist_ok=True)
+    with open(args.out, "w") as fh:
+        json.dump(entries, fh, indent=2, sort_keys=True)
+    print(f"\nwrote {len(entries)} gated-model architectures to {args.out}")
+    return 0 if entries else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

scripts/train_models.py

@@ -0,0 +1,306 @@
+"""Fit the WattGPU power and ITL models and save them for the demo.
+
+Two things are produced:
+
+1. `power.joblib` / `itl.joblib` — the pipelines from the paper, refitted on
+   the full Watt Counts subset.
+2. `meta.json` — the sets of profiled LLMs and GPUs (which decide the demo's
+   certainty tier), plus the accuracy each tier can be expected to deliver.
+
+The tier accuracies come from the paper's own validation protocols, so the
+number shown next to a prediction is measured under exactly the conditions
+that prediction is made in:
+
+  green  (seen LLM, seen GPU)   -> 5-fold grouped CV
+  yellow (unseen LLM, seen GPU) -> leave-one-LLM-out
+  orange (seen LLM, unseen GPU) -> leave-one-GPU-out
+
+Usage:  python scripts/train_models.py
+"""
+
+from __future__ import annotations
+
+import argparse
+import ast
+import json
+import os
+import sys
+
+import joblib
+import numpy as np
+import pandas as pd
+from sklearn.compose import ColumnTransformer
+from sklearn.impute import SimpleImputer
+from sklearn.model_selection import GroupKFold, LeaveOneGroupOut
+from sklearn.pipeline import Pipeline
+from sklearn.preprocessing import OrdinalEncoder, StandardScaler
+from xgboost import XGBRegressor
+
+REPO_ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, REPO_ROOT)
+
+from wattgpu_demo.features import (  # noqa: E402
+    ID_COLUMNS,
+    ITL_FEATURES,
+    ITL_TARGET,
+    POWER_FEATURES,
+    POWER_TARGET,
+    build_training_frame,
+    clean_frame,
+)
+
+PAPER_DATA_DIR = os.path.join(os.path.dirname(REPO_ROOT), "data")
+
+# Hyperparameters as reported in the paper.
+POWER_REGRESSOR = dict(max_depth=6, reg_lambda=150, n_estimators=200)
+ITL_REGRESSOR = dict(max_depth=5, reg_lambda=100, n_estimators=100)
+
+
+def build_pipeline(X: pd.DataFrame, regressor) -> Pipeline:
+    """Preprocessing + regressor, identical to the notebook's `_build_pipeline`."""
+    numeric = X.select_dtypes(include=[np.number]).columns.tolist()
+    categorical = X.select_dtypes(include=["object", "category"]).columns.tolist()
+
+    preprocessor = ColumnTransformer([
+        ("num", Pipeline([
+            ("imputer", SimpleImputer(strategy="mean")),
+            ("scaler", StandardScaler()),
+        ]), numeric),
+        ("cat", Pipeline([
+            ("imputer", SimpleImputer(strategy="most_frequent")),
+            # Unseen categories (a new `model_type` or `memory_type`) encode to
+            # -1 rather than raising, which is what lets the demo predict for
+            # architectures that were never profiled.
+            ("encoder", OrdinalEncoder(handle_unknown="use_encoded_value", unknown_value=-1)),
+        ]), categorical),
+    ])
+    return Pipeline([("preprocessor", preprocessor), ("regressor", regressor)])
+
+
+def mdape(y_true: np.ndarray, y_pred: np.ndarray) -> float:
+    """Median absolute percentage error, the paper's headline metric."""
+    return float(np.median(np.abs((y_true - y_pred) / y_true)) * 100)
+
+
+def cross_validate(df: pd.DataFrame, group_col: str | None, target_col: str,
+                   regressor_kwargs: dict, log_transform_y: bool) -> np.ndarray:
+    """Out-of-fold predictions under CV, LOGO or LOLO."""
+    X = df.drop(columns=[c for c in [target_col, *ID_COLUMNS] if c in df.columns])
+    y = df[target_col]
+    predictions = np.full(len(df), np.nan)
+
+    if group_col is not None:
+        splits = LeaveOneGroupOut().split(X, y, df[group_col])
+    else:
+        # Group on the configuration so replicates of one (LLM, GPU) pair never
+        # straddle the train/test boundary.
+        config_id = df[ID_COLUMNS].astype(str).agg("|".join, axis=1)
+        splits = GroupKFold(n_splits=5).split(X, y, groups=config_id)
+
+    for train_idx, test_idx in splits:
+        pipeline = build_pipeline(X, XGBRegressor(**regressor_kwargs))
+        y_train = np.log(y.iloc[train_idx]) if log_transform_y else y.iloc[train_idx]
+        pipeline.fit(X.iloc[train_idx], y_train)
+        y_pred = pipeline.predict(X.iloc[test_idx])
+        predictions[test_idx] = np.exp(y_pred) if log_transform_y else y_pred
+
+    return predictions
+
+
+def double_holdout_predictions(df: pd.DataFrame, target_col: str,
+                               regressor_kwargs: dict, log_transform_y: bool) -> np.ndarray:
+    """Predictions for pairs whose LLM *and* GPU are both held out.
+
+    The paper validates generalisation one axis at a time (LOGO and LOLO). This
+    is the natural extension: for every measured (LLM, GPU) pair, train on the
+    data with that GPU and that LLM both removed entirely, then predict the
+    pair. It is the only honest way to attach an error to an estimate where
+    neither side was measured -- without it, such an estimate would carry no
+    validated accuracy at all.
+    """
+    X = df.drop(columns=[c for c in [target_col, *ID_COLUMNS] if c in df.columns])
+    y = df[target_col]
+    predictions = np.full(len(df), np.nan)
+
+    models = df["model"].to_numpy()
+    gpus = df["gpu_db_name"].to_numpy()
+    pairs = df[["model", "gpu_db_name"]].drop_duplicates().itertuples(index=False)
+
+    for n, (model, gpu) in enumerate(pairs, start=1):
+        test = (models == model) & (gpus == gpu)
+        train = (models != model) & (gpus != gpu)
+        if not train.any() or not test.any():
+            continue
+
+        pipeline = build_pipeline(X, XGBRegressor(**regressor_kwargs))
+        y_train = np.log(y[train]) if log_transform_y else y[train]
+        pipeline.fit(X[train], y_train)
+        y_pred = pipeline.predict(X[test])
+        predictions[test] = np.exp(y_pred) if log_transform_y else y_pred
+        if n % 40 == 0:
+            print(f"      double holdout: {n} pairs")
+
+    return predictions
+
+
+def tier_accuracy(df: pd.DataFrame, target_col: str, regressor_kwargs: dict,
+                  log_transform_y: bool, to_watts: bool) -> dict[str, dict[str, float]]:
+    """MdAPE per certainty tier and scenario, each under its own protocol.
+
+    Reported separately for offline and server operation because, as in the
+    paper's Tables 2 and 3, the two regimes differ substantially -- especially
+    for ITL, where offline throughput depends on batching effects that the
+    features capture only partly.
+    """
+    scale = df["thermal_design_power_w"].to_numpy() if to_watts else 1.0
+    y_true = df[target_col].to_numpy() * scale
+    # The paper reports the two server load levels together.
+    regime = np.where(df["scenario"].to_numpy() == "offline", "offline", "server")
+
+    results: dict[str, dict[str, float]] = {}
+    tiers = (("green", None), ("yellow", "model"), ("orange", "gpu_db_name"), ("red", "both"))
+    for tier, group_col in tiers:
+        if group_col == "both":
+            y_pred = double_holdout_predictions(
+                df, target_col, regressor_kwargs, log_transform_y) * scale
+        else:
+            y_pred = cross_validate(
+                df, group_col, target_col, regressor_kwargs, log_transform_y) * scale
+        valid = ~np.isnan(y_pred)
+        results[tier] = {
+            scenario: round(mdape(y_true[valid & (regime == scenario)],
+                                  y_pred[valid & (regime == scenario)]), 1)
+            for scenario in ("offline", "server")
+        }
+        print(f"    {tier:<7} MdAPE  offline {results[tier]['offline']:5.1f}%   "
+              f"server {results[tier]['server']:5.1f}%")
+    return results
+
+
+def fit_final(df: pd.DataFrame, target_col: str, regressor_kwargs: dict,
+              log_transform_y: bool) -> Pipeline:
+    """Refit on every row, which is what the demo serves predictions from."""
+    X = df.drop(columns=[c for c in [target_col, *ID_COLUMNS] if c in df.columns])
+    y = np.log(df[target_col]) if log_transform_y else df[target_col]
+    pipeline = build_pipeline(X, XGBRegressor(**regressor_kwargs))
+    pipeline.fit(X, y)
+    return pipeline
+
+
+def _parse_architectures(value) -> list[str]:
+    """`model_features.csv` stores the architecture list as a Python literal."""
+    if value is None or (isinstance(value, float) and pd.isna(value)):
+        return []
+    if isinstance(value, list):
+        return [str(v) for v in value]
+    try:
+        parsed = ast.literal_eval(str(value))
+    except (ValueError, SyntaxError):
+        return [str(value)]
+    return [str(v) for v in parsed] if isinstance(parsed, (list, tuple)) else [str(parsed)]
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--data-dir", default=PAPER_DATA_DIR)
+    parser.add_argument("--out-dir", default=os.path.join(REPO_ROOT, "data", "models"))
+    parser.add_argument("--skip-validation", action="store_true",
+                        help="fit only; keep the tier accuracies from a previous run")
+    args = parser.parse_args()
+
+    os.makedirs(args.out_dir, exist_ok=True)
+
+    print(f"loading measurements from {args.data_dir}")
+    df_all = build_training_frame(args.data_dir)
+    print(f"  {len(df_all)} runs, {df_all.model.nunique()} LLMs, {df_all.gpu_db_name.nunique()} GPUs")
+
+    meta: dict = {}
+    accuracies: dict = {}
+
+    # --- power draw ---------------------------------------------------------
+    df_power = clean_frame(df_all, [*ID_COLUMNS, POWER_TARGET, *POWER_FEATURES])
+    tdp = df_all.set_index("gpu_db_name")["thermal_design_power_w"].drop_duplicates()
+    df_power["thermal_design_power_w"] = df_power["gpu_db_name"].map(tdp)
+    print(f"\npower model: {len(df_power)} rows, {len(POWER_FEATURES)} features")
+    if not args.skip_validation:
+        accuracies["power"] = tier_accuracy(
+            df_power.drop(columns=["thermal_design_power_w"]).assign(
+                thermal_design_power_w=df_power["thermal_design_power_w"]),
+            POWER_TARGET, POWER_REGRESSOR, log_transform_y=False, to_watts=True)
+
+    power_pipeline = fit_final(
+        df_power.drop(columns=["thermal_design_power_w"]),
+        POWER_TARGET, POWER_REGRESSOR, log_transform_y=False)
+    joblib.dump(power_pipeline, os.path.join(args.out_dir, "power.joblib"))
+
+    # --- inter-token latency ------------------------------------------------
+    df_itl = clean_frame(df_all, [*ID_COLUMNS, ITL_TARGET, *ITL_FEATURES])
+    print(f"\nITL model: {len(df_itl)} rows, {len(ITL_FEATURES)} features")
+    if not args.skip_validation:
+        accuracies["itl"] = tier_accuracy(
+            df_itl, ITL_TARGET, ITL_REGRESSOR, log_transform_y=True, to_watts=False)
+
+    itl_pipeline = fit_final(df_itl, ITL_TARGET, ITL_REGRESSOR, log_transform_y=True)
+    joblib.dump(itl_pipeline, os.path.join(args.out_dir, "itl.joblib"))
+
+    # --- metadata -----------------------------------------------------------
+    meta_path = os.path.join(args.out_dir, "meta.json")
+    if args.skip_validation and os.path.exists(meta_path):
+        with open(meta_path) as fh:
+            accuracies = json.load(fh).get("tier_accuracy_mdape", accuracies)
+
+    # A model or GPU counts as "seen" only if it survived into a training frame.
+    seen_models = sorted(set(df_power["model"]) | set(df_itl["model"]))
+    seen_gpus = sorted(set(df_power["gpu_db_name"]) | set(df_itl["gpu_db_name"]))
+
+    meta = {
+        "seen_models": seen_models,
+        "seen_gpus": seen_gpus,
+        "power_features": POWER_FEATURES,
+        "itl_features": ITL_FEATURES,
+        "tier_accuracy_mdape": accuracies,
+        # The ITL model is fitted on log(itl); predictions must be exponentiated.
+        "log_transformed_targets": ["itl"],
+        "n_training_runs": {"power": len(df_power), "itl": len(df_itl)},
+        "gpu_tdp": {k: float(v) for k, v in tdp.items()},
+    }
+    with open(meta_path, "w") as fh:
+        json.dump(meta, fh, indent=2)
+
+    # Cache the architecture of every profiled LLM. These features are already
+    # in the paper's data, so a profiled model needs no Hub round-trip -- which
+    # also makes licence-gated models (Llama, Gemma) work without a token.
+    cache = {}
+    for model_id, group in df_all.groupby("model"):
+        if model_id not in seen_models:
+            continue
+        row = group.iloc[0]
+        cache[model_id] = {
+            "model_type": str(row["model_type"]),
+            "num_layers": int(row["num_layers"]),
+            "hidden_size": int(row["hidden_size"]),
+            "num_attention_heads": int(row["num_attention_heads"]),
+            "num_key_value_heads": int(row["num_key_value_heads"]),
+            "total_b_params": float(row["total_b_params"]),
+            "architectures": _parse_architectures(row.get("architectures")),
+            "max_position_embeddings": (
+                None if pd.isna(row.get("max_position_embeddings"))
+                else int(row["max_position_embeddings"])
+            ),
+            "torch_dtype": (
+                None if pd.isna(row.get("torch_dtype")) or row.get("torch_dtype") == "N/A"
+                else str(row["torch_dtype"])
+            ),
+        }
+    cache_path = os.path.join(args.out_dir, "profiled_llms.json")
+    with open(cache_path, "w") as fh:
+        json.dump(cache, fh, indent=2, sort_keys=True)
+    print(f"  cached architecture for {len(cache)} profiled LLMs")
+
+    print(f"\nsaved models and metadata to {args.out_dir}")
+    print(f"  {len(seen_models)} profiled LLMs, {len(seen_gpus)} profiled GPUs")
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

tests/test_demo.py

@@ -0,0 +1,1176 @@
+"""Tests for the WattGPU demo.
+
+Covers the four combinations the certainty tier distinguishes -- known and
+unknown LLMs against known and unknown GPUs -- plus the error paths.
+
+Tests marked `network` reach the Hugging Face Hub; run
+`pytest -m "not network"` to skip them.
+"""
+
+from __future__ import annotations
+
+import html
+import json
+import os
+import re
+import sys
+import urllib.parse
+
+import pytest
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+import app as demo_app  # noqa: E402
+from wattgpu_demo import demand_log, emissions  # noqa: E402
+from wattgpu_demo.errors import (  # noqa: E402
+    GPUNotFoundError,
+    InsufficientMemoryError,
+    ModelConfigError,
+    ModelNotFoundError,
+    NetworkError,
+    UnsupportedModelError,
+    WattGPUError,
+)
+from wattgpu_demo.features import ITL_FEATURES, POWER_FEATURES  # noqa: E402
+from wattgpu_demo.gpu_db import GPUDatabase  # noqa: E402
+from wattgpu_demo.hf_models import (  # noqa: E402
+    fetch_llm_info,
+    llm_info_from_config,
+    search_models,
+)
+from wattgpu_demo.predictor import WattGPUPredictor  # noqa: E402
+
+network = pytest.mark.network
+
+# A profiled LLM and a profiled GPU, from the paper's measurements.
+KNOWN_LLM = "meta-llama/Llama-3.1-8B-Instruct"
+KNOWN_GPU = "H200 NVL"
+# Released after the study, and never profiled.
+UNKNOWN_LLM = "Qwen/Qwen3-8B"
+UNKNOWN_GPU = "A100 SXM4 80 GB"
+
+
+@pytest.fixture(scope="session")
+def predictor() -> WattGPUPredictor:
+    return WattGPUPredictor()
+
+
+@pytest.fixture(scope="session")
+def gpu_db() -> GPUDatabase:
+    return GPUDatabase()
+
+
+# ---------------------------------------------------------------------------
+# Fixture assumptions
+# ---------------------------------------------------------------------------
+
+def test_fixtures_are_what_the_tests_assume(predictor):
+    assert KNOWN_LLM in predictor.profiled_models
+    assert KNOWN_GPU in predictor.profiled_gpus
+    assert UNKNOWN_LLM not in predictor.profiled_models
+    assert UNKNOWN_GPU not in predictor.profiled_gpus
+    assert UNKNOWN_GPU in predictor.gpu_db.names
+
+
+# ---------------------------------------------------------------------------
+# The four certainty tiers
+# ---------------------------------------------------------------------------
+
+def test_known_llm_known_gpu_is_green(predictor):
+    result = predictor.predict(KNOWN_LLM, KNOWN_GPU, "server_low")
+
+    assert result.certainty.tier == "green"
+    assert "High confidence" in result.certainty.label
+    # A profiled model is read from the local cache, not the Hub.
+    assert result.llm.params_source == "profiled dataset"
+    assert 0 < result.power_w <= result.gpu.thermal_design_power_w * 1.2
+    assert result.itl_s is not None and result.itl_s > 0
+    assert result.power_mdape is not None and result.itl_mdape is not None
+
+
+@network
+def test_unknown_llm_known_gpu_is_yellow(predictor):
+    result = predictor.predict(UNKNOWN_LLM, KNOWN_GPU, "server_low")
+
+    assert result.certainty.tier == "yellow"
+    assert result.llm.params_source == "safetensors index"
+    assert 7 < result.llm.total_b_params < 9
+    assert 0 < result.power_w <= result.gpu.thermal_design_power_w * 1.2
+    assert result.itl_s is not None and result.itl_s > 0
+
+
+def test_known_llm_unknown_gpu_is_orange(predictor):
+    result = predictor.predict(KNOWN_LLM, UNKNOWN_GPU, "offline")
+
+    assert result.certainty.tier == "orange"
+    assert result.gpu.gpu_db_name == UNKNOWN_GPU
+    assert 0 < result.power_w <= result.gpu.thermal_design_power_w * 1.2
+    assert result.itl_s is not None and result.itl_s > 0
+
+
+@network
+@pytest.mark.parametrize("scenario,expected_band,expected_label", [
+    ("server_low", "orange", "Lower confidence"),
+    ("server_high", "orange", "Lower confidence"),
+    ("offline", "red", "Low confidence"),
+])
+def test_unknown_llm_unknown_gpu_band_depends_on_scenario(
+        predictor, scenario, expected_band, expected_label):
+    """Extrapolating on both axes costs little under server load, a lot offline."""
+    result = predictor.predict(UNKNOWN_LLM, UNKNOWN_GPU, scenario)
+
+    assert result.certainty.tier == expected_band
+    assert expected_label in result.certainty.label
+    assert "neither in training data" in result.certainty.label
+    assert 0 < result.power_w <= result.gpu.thermal_design_power_w * 1.2
+    assert result.itl_s is not None and result.itl_s > 0
+    # The error must be measured, not left blank.
+    assert result.power_mdape is not None and result.itl_mdape is not None
+    note = " ".join(result.notes)
+    assert "both axes at once" in note and "mailto" in note
+
+
+@network
+def test_error_always_comes_from_the_double_holdout(predictor):
+    """A friendlier band must not borrow a friendlier number.
+
+    Under server load a both-unseen pair is shown in the orange band, but the
+    error reported has to stay the one measured by the double holdout.
+    """
+    both_unseen = predictor.predict(UNKNOWN_LLM, UNKNOWN_GPU, "server_low")
+    gpu_unseen = predictor.predict(KNOWN_LLM, UNKNOWN_GPU, "server_low")
+
+    assert both_unseen.certainty.tier == gpu_unseen.certainty.tier == "orange"
+    assert both_unseen.certainty.accuracy_key == "red"
+    assert gpu_unseen.certainty.accuracy_key == "orange"
+
+    accuracy = predictor.meta["tier_accuracy_mdape"]
+    assert both_unseen.power_mdape == accuracy["power"]["red"]["server"]
+    assert gpu_unseen.power_mdape == accuracy["power"]["orange"]["server"]
+    assert both_unseen.power_mdape > gpu_unseen.power_mdape
+
+
+def test_the_band_rule_is_justified_by_the_measurements(predictor):
+    """Pins the reason both-unseen shares the orange band under server load.
+
+    If retraining ever made the double holdout materially worse than
+    leave-one-GPU-out on the server side, the shared band would stop being
+    defensible and this test would catch it.
+    """
+    accuracy = predictor.meta["tier_accuracy_mdape"]
+    for target in ("power", "itl"):
+        orange = accuracy[target]["orange"]["server"]
+        red = accuracy[target]["red"]["server"]
+        assert red - orange <= 3.0, (
+            f"{target}: double holdout is {red}% vs {orange}% under server load, "
+            "too far apart to share the orange band")
+
+    # Offline latency is the case that does degrade, hence its own band.
+    assert (accuracy["itl"]["red"]["offline"]
+            - accuracy["itl"]["orange"]["offline"]) > 5.0
+
+
+def test_tier_accuracy_is_ordered_by_difficulty(predictor):
+    """Generalising to new hardware is harder than to new architectures."""
+    for target in ("power", "itl"):
+        for regime in ("offline", "server"):
+            accuracy = predictor.meta["tier_accuracy_mdape"][target]
+            assert accuracy["green"][regime] <= accuracy["yellow"][regime]
+            assert accuracy["yellow"][regime] <= accuracy["orange"][regime]
+            # Extrapolating on both axes is never easier than on one.
+            assert accuracy["orange"][regime] <= accuracy["red"][regime]
+
+
+def test_scenarios_are_labelled_by_concurrent_users(predictor):
+    """The UI asks for concurrent users, which is estimable before deployment."""
+    from wattgpu_demo.features import SCENARIO_LABELS, SCENARIOS
+
+    assert SCENARIOS == ["server_low", "server_high", "offline"]
+    assert set(SCENARIO_LABELS) == set(SCENARIOS)
+    assert "concurrent user" in SCENARIO_LABELS["server_low"]
+    assert "concurrent users" in SCENARIO_LABELS["server_high"]
+    assert "batch" in SCENARIO_LABELS["offline"]
+    # No label should still be phrased as a request rate.
+    assert not any("requests/s" in label for label in SCENARIO_LABELS.values())
+
+    # Every scenario must still be predictable end to end.
+    for scenario in SCENARIOS:
+        assert predictor.predict(KNOWN_LLM, KNOWN_GPU, scenario).power_w > 0
+
+
+def test_scenario_labels_match_the_measured_request_rates():
+    """The user-facing user counts must follow from the rates actually run.
+
+    Only two arrival rates appear in the dataset, so these settings are three
+    measured points rather than ranges. At ~1 message per minute per active
+    user they correspond to about 1 and about 20 concurrent users.
+    """
+    from wattgpu_demo.features import SCENARIO_LABELS, SCENARIO_RATES_QPS
+
+    assert SCENARIO_RATES_QPS["server_low"] == pytest.approx(0.017, abs=1e-3)
+    assert SCENARIO_RATES_QPS["server_high"] == pytest.approx(0.330, abs=1e-3)
+    assert SCENARIO_RATES_QPS["offline"] is None
+
+    per_user_rate = 1 / 60  # one message per minute
+    assert round(SCENARIO_RATES_QPS["server_low"] / per_user_rate) == 1
+    assert round(SCENARIO_RATES_QPS["server_high"] / per_user_rate) == 20
+
+    assert "single" in SCENARIO_LABELS["server_low"]
+    assert "20" in SCENARIO_LABELS["server_high"]
+
+
+def test_only_saturated_load_reports_batch_amortised_latency(predictor):
+    """The two latency definitions must never be presented as the same thing."""
+    for scenario in ("server_low", "server_high"):
+        result = predictor.predict(KNOWN_LLM, KNOWN_GPU, scenario)
+        assert result.latency_is_per_user
+        assert result.energy_per_token_j is None
+
+    saturated = predictor.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    assert not saturated.latency_is_per_user
+    assert saturated.energy_per_token_j is not None
+
+    # The whole-batch figure is orders of magnitude smaller than a user's wait,
+    # which is exactly why it must not be labelled a latency.
+    per_user = predictor.predict(KNOWN_LLM, KNOWN_GPU, "server_low")
+    assert saturated.itl_s < per_user.itl_s / 10
+
+
+def test_offline_reports_throughput_and_explains_where_it_comes_from():
+    output = demo_app.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    assert "Throughput" in output and "tok/s" in output
+    assert "Inter-token latency" not in output
+    # It must say how the number was derived, and why the batch-wide latency it
+    # came from cannot stand in for a server's per-user latency.
+    assert "inverse of the inter-token latency" in output
+    assert "whole batch" in output
+
+
+def test_per_user_result_calls_it_inter_token_latency():
+    output = demo_app.predict(KNOWN_LLM, KNOWN_GPU, "server_low")
+    assert "Inter-token latency" in output
+    assert "Throughput" not in output
+
+
+# ---------------------------------------------------------------------------
+# Error handling
+# ---------------------------------------------------------------------------
+
+@network
+def test_nonexistent_model_is_reported_clearly():
+    with pytest.raises(ModelNotFoundError) as excinfo:
+        fetch_llm_info("definitely-not-a-real-owner/definitely-not-a-real-model")
+    assert "not-a-real-model" in excinfo.value.display()
+
+
+@pytest.mark.parametrize("bad_id", ["", "   ", "justaname", "a/b/c"])
+def test_malformed_model_ids_are_rejected_without_a_request(bad_id):
+    with pytest.raises(ModelNotFoundError):
+        fetch_llm_info(bad_id)
+
+
+@network
+def test_repository_without_usable_config_is_reported():
+    """A GGUF-only repository has a config.json that lacks the needed fields."""
+    with pytest.raises((ModelConfigError, ModelNotFoundError)):
+        fetch_llm_info("TheBloke/Llama-2-7B-GGUF")
+
+
+def test_unknown_gpu_suggests_close_matches(gpu_db):
+    with pytest.raises(GPUNotFoundError) as excinfo:
+        gpu_db.get("A100 SXM 80")
+    assert "A100 SXM4 80 GB" in excinfo.value.display()
+
+
+def test_database_is_nvidia_only(gpu_db):
+    """Every profiled run used NVIDIA hardware under vLLM, so other vendors'
+    matrix engines are outside what the features describe."""
+    assert set(gpu_db.frame["manufacturer"]) == {"NVIDIA"}
+    for absent in ("Radeon Instinct MI300X", "Data Center GPU Max 1550"):
+        with pytest.raises(GPUNotFoundError):
+            gpu_db.get(absent)
+
+
+def test_empty_gpu_is_rejected(gpu_db):
+    with pytest.raises(GPUNotFoundError):
+        gpu_db.get("")
+
+
+def test_unknown_scenario_is_rejected(predictor):
+    with pytest.raises(WattGPUError):
+        predictor.predict(KNOWN_LLM, KNOWN_GPU, "not-a-scenario")
+
+
+@network
+@pytest.mark.parametrize("model_id,described_as", [
+    ("Qwen/Qwen3-Embedding-0.6B", "an embedding model"),   # declares ForCausalLM
+    ("Qwen/Qwen3-Reranker-4B", "a reranker"),              # declares ForCausalLM
+    ("sentence-transformers/all-MiniLM-L6-v2", "an embedding model"),
+    ("BAAI/bge-reranker-v2-m3", "a classifier"),
+])
+def test_embedding_and_reranking_models_are_refused(predictor, model_id, described_as):
+    """These run one forward pass rather than generating token by token, so
+    inter-token latency does not apply. Two of them declare `ForCausalLM`, so
+    the Hub's task tag is what distinguishes them."""
+    with pytest.raises(UnsupportedModelError) as excinfo:
+        predictor.predict(model_id, KNOWN_GPU, "offline")
+    assert described_as in excinfo.value.display()
+
+
+def test_non_generative_architecture_is_refused_without_the_network():
+    with pytest.raises(UnsupportedModelError):
+        llm_info_from_config("acme/encoder",
+                             {**LLAMA_8B_CONFIG, "architectures": ["BertModel"]})
+    with pytest.raises(UnsupportedModelError):
+        llm_info_from_config("acme/reranker",
+                             {**LLAMA_8B_CONFIG,
+                              "architectures": ["XLMRobertaForSequenceClassification"]})
+
+
+def test_model_too_large_for_the_gpu_is_refused(predictor):
+    """A model whose weights cannot fit gets no estimate at all."""
+    with pytest.raises(InsufficientMemoryError) as excinfo:
+        predictor.predict("microsoft/phi-4", "Tesla T4", "offline")
+
+    message = excinfo.value.display()
+    assert "Does not fit" in message
+    assert "29.4 GB" in message      # 14.7 B parameters at FP16
+    assert "14.4 GB" in message      # 90% of the T4's 16 GB
+    assert "at least 33 GB" in message
+
+
+def test_borderline_model_is_refused_rather_than_estimated(predictor):
+    """8.03 B at FP16 is 16.06 GB, which does not fit a 16 GB card once vLLM
+    has taken its 10%. The old code estimated anyway and rounded the warning to
+    a self-contradictory "16 GB, more than the 16 GB"."""
+    with pytest.raises(InsufficientMemoryError):
+        predictor.predict(KNOWN_LLM, "Tesla T4", "offline")
+
+
+@network
+def test_memory_check_runs_before_the_coverage_check(predictor):
+    """Not fitting is a physical fact, and the more useful thing to report."""
+    with pytest.raises(InsufficientMemoryError):
+        # Neither side measured, and also far too large: memory wins over the
+        # "we have no data for either" refusal.
+        predictor.predict(UNKNOWN_LLM, "GeForce RTX 3060 12 GB", "offline")
+
+
+def test_no_measured_pair_is_ever_refused_for_memory(predictor):
+    """Every pair in the dataset actually ran, so none may be called too large.
+
+    This is what pins the 90% budget: a stricter threshold would start
+    contradicting the measurements the models were fitted on.
+    """
+    from wattgpu_demo.features import build_training_frame
+    from wattgpu_demo.predictor import BYTES_PER_PARAM, VLLM_MEMORY_UTILISATION
+
+    paper_data = os.path.join(
+        os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))),
+        "data")
+    if not os.path.exists(paper_data):
+        pytest.skip("the paper's data directory is not available")
+
+    df = build_training_frame(paper_data)
+    pairs = df[["model", "gpu_db_name", "total_b_params", "memory_size_gb"]].drop_duplicates()
+    spare = (pairs.memory_size_gb * VLLM_MEMORY_UTILISATION
+             - pairs.total_b_params * BYTES_PER_PARAM)
+
+    too_large = pairs[spare <= 0]
+    assert too_large.empty, f"would refuse measured pairs:\n{too_large}"
+
+
+def test_tight_fit_warns_without_refusing(predictor):
+    """SOLAR-10.7B on an A30 was measured, but leaves ~0.2 GB for the KV cache."""
+    result = predictor.predict("upstage/SOLAR-10.7B-Instruct-v1.0", "A30 PCIe", "offline")
+    assert result.power_w > 0
+    assert any("KV cache" in w for w in result.warnings)
+
+
+# ---------------------------------------------------------------------------
+# config.json -> WattGPU features
+# ---------------------------------------------------------------------------
+
+LLAMA_8B_CONFIG = {
+    "model_type": "llama",
+    "architectures": ["LlamaForCausalLM"],
+    "num_hidden_layers": 32,
+    "hidden_size": 4096,
+    "num_attention_heads": 32,
+    "num_key_value_heads": 8,
+    "intermediate_size": 14336,
+    "vocab_size": 128256,
+    "max_position_embeddings": 131072,
+    "torch_dtype": "bfloat16",
+}
+
+
+def test_converter_maps_a_config_without_touching_the_network():
+    llm = llm_info_from_config("acme/llama-like", LLAMA_8B_CONFIG)
+
+    assert llm.model_type == "llama"
+    assert (llm.num_layers, llm.hidden_size) == (32, 4096)
+    assert (llm.num_attention_heads, llm.num_key_value_heads) == (32, 8)
+    # Estimated from the transformer's shape, so within a few percent of 8.03 B.
+    assert llm.total_b_params == pytest.approx(8.0, abs=0.4)
+    assert llm.params_source == "estimated from config"
+
+
+def test_converter_uses_a_known_parameter_count_when_given_one():
+    llm = llm_info_from_config("acme/llama-like", LLAMA_8B_CONFIG, 8.03, "safetensors index")
+    assert llm.total_b_params == 8.03
+    assert llm.params_source == "safetensors index"
+
+
+@pytest.mark.parametrize("aliases", [
+    {"n_layer": 12, "n_embd": 768, "n_head": 12},        # GPT-2 naming
+    {"num_layers": 12, "d_model": 768, "num_heads": 12},  # T5-ish naming
+])
+def test_converter_understands_alternative_field_names(aliases):
+    config = {"model_type": "x", "vocab_size": 50257, **aliases}
+    llm = llm_info_from_config("acme/aliased", config)
+    assert llm.num_layers == 12 and llm.hidden_size == 768
+    # No GQA declared, so every head keeps its own K/V.
+    assert llm.num_key_value_heads == llm.num_attention_heads
+
+
+def test_converter_unwraps_a_multimodal_text_config():
+    config = {
+        "model_type": "gemma3",
+        "architectures": ["Gemma3ForConditionalGeneration"],
+        "vision_config": {"hidden_size": 1152},
+        "text_config": {"num_hidden_layers": 48, "hidden_size": 3840,
+                        "num_attention_heads": 16, "num_key_value_heads": 8,
+                        "intermediate_size": 15360, "vocab_size": 262208},
+    }
+    llm = llm_info_from_config("acme/multimodal", config)
+    assert llm.num_layers == 48 and llm.hidden_size == 3840
+    assert any("multimodal" in w for w in llm.warnings)
+
+
+def test_converter_rejects_a_config_missing_required_fields():
+    with pytest.raises(ModelConfigError):
+        llm_info_from_config("acme/incomplete", {"model_type": "mystery"})
+
+
+# --- unsupported model families -----------------------------------------
+
+@pytest.mark.parametrize("moe_config", [
+    {"num_local_experts": 8},                       # Mixtral
+    {"num_experts": 64, "num_experts_per_tok": 8},  # Qwen3-MoE, OLMoE
+    {"n_routed_experts": 160},                      # DeepSeek
+    {"moe_intermediate_size": 1408},
+    {"architectures": ["Qwen3MoeForCausalLM"]},
+])
+def test_converter_refuses_mixture_of_experts(moe_config):
+    with pytest.raises(UnsupportedModelError) as excinfo:
+        llm_info_from_config("acme/moe", {**LLAMA_8B_CONFIG, **moe_config})
+    message = excinfo.value.display()
+    assert "Not supported yet" in message and "mixture-of-experts" in message
+    assert "get in touch" in message.lower()
+
+
+@pytest.mark.parametrize("quantised_config", [
+    {"quantization_config": {"quant_method": "gptq", "bits": 4}},
+    {"quantization_config": {"quant_method": "awq"}},
+    {"quantization_config": {"quant_method": "compressed-tensors"}},
+    {"torch_dtype": "int8"},
+    {"dtype": "float8_e4m3fn"},
+])
+def test_converter_refuses_quantised_models(quantised_config):
+    with pytest.raises(UnsupportedModelError) as excinfo:
+        llm_info_from_config("acme/quant", {**LLAMA_8B_CONFIG, **quantised_config})
+    assert "quantised" in excinfo.value.display()
+
+
+@pytest.mark.parametrize("model_id", [
+    "TheBloke/Llama-2-7B-AWQ",
+    "TheBloke/Llama-2-7B-GPTQ",
+    "unsloth/Llama-3.1-8B-bnb-4bit",
+    "RedHatAI/Llama-3.1-8B-Instruct-FP8",
+])
+def test_converter_refuses_quantised_repository_names(model_id):
+    """Caught even when the config does not declare the quantisation."""
+    with pytest.raises(UnsupportedModelError):
+        llm_info_from_config(model_id, LLAMA_8B_CONFIG)
+
+
+@pytest.mark.parametrize("model_id", [
+    "meta-llama/Llama-3.1-8B-Instruct",
+    "Qwen/Qwen3-8B",
+    "mistralai/Mistral-7B-Instruct-v0.3",
+    "microsoft/phi-4",
+    "allenai/OLMo-2-1124-7B-Instruct",
+])
+def test_ordinary_model_names_are_not_mistaken_for_quantised(model_id):
+    """The name-based fallback must not fire on plain model names."""
+    assert llm_info_from_config(model_id, LLAMA_8B_CONFIG).total_b_params > 0
+
+
+@network
+@pytest.mark.parametrize("model_id", [
+    "mistralai/Mixtral-8x7B-Instruct-v0.1",   # MoE
+    "Qwen/Qwen3-30B-A3B",                     # MoE
+    "openai/gpt-oss-20b",                     # MoE
+    "TheBloke/Llama-2-7B-AWQ",                # quantised
+    "RedHatAI/Meta-Llama-3.1-8B-Instruct-FP8",  # quantised
+])
+def test_real_unsupported_models_are_refused(model_id):
+    with pytest.raises(UnsupportedModelError):
+        fetch_llm_info(model_id)
+
+
+def test_unmeasured_model_carries_a_detection_caveat(predictor):
+    """Detection is good but not infallible, and the UI must say so."""
+    result = predictor.predict(UNKNOWN_LLM, KNOWN_GPU, "server_low")
+    assert result.notes, "an unmeasured model should carry a note"
+    note = " ".join(result.notes)
+    assert "config.json" in note
+    assert "mixture-of-experts" in note and "quantised" in note
+
+
+def test_measured_model_carries_no_detection_caveat(predictor):
+    assert predictor.predict(KNOWN_LLM, KNOWN_GPU, "server_low").notes == []
+
+
+@network
+def test_hub_search_finds_models():
+    results = search_models("qwen3")
+    assert results and all("/" in r for r in results)
+    assert any("Qwen" in r for r in results)
+
+
+@pytest.mark.parametrize("query", ["", " ", "q"])
+def test_hub_search_ignores_queries_that_are_too_short(query):
+    assert search_models(query) == []
+
+
+# ---------------------------------------------------------------------------
+# GPU database
+# ---------------------------------------------------------------------------
+
+def test_every_profiled_gpu_is_in_the_database(predictor, gpu_db):
+    missing = [g for g in predictor.profiled_gpus if g not in gpu_db.names]
+    assert missing == []
+
+
+def test_profiled_gpus_have_reported_throughput(predictor, gpu_db):
+    for name in predictor.profiled_gpus:
+        gpu = gpu_db.get(name)
+        assert gpu.tflops_source == "reported", name
+        assert gpu.tflops_16b and gpu.tflops_16b > 0
+
+
+def test_gpu_dropdown_lists_only_measured_gpus():
+    """Unmeasured GPUs are reachable by search, not by scrolling the list."""
+    assert demo_app.gpu_input.choices == [(g, g) for g in demo_app.predictor.profiled_gpus]
+
+
+@pytest.mark.parametrize("query,expected", [
+    ("a100", "A100 SXM4 80 GB"),
+    ("h100", "H100 SXM5 80 GB"),
+    ("4090", "GeForce RTX 4090"),
+])
+def test_gpu_search_reaches_the_full_catalogue(gpu_db, query, expected):
+    assert expected in gpu_db.search(query)
+
+
+def test_gpu_search_ranks_prefix_matches_first(gpu_db):
+    results = gpu_db.search("a100")
+    assert results[0].lower().startswith("a100")
+
+
+@pytest.mark.parametrize("query", ["", " ", "h"])
+def test_gpu_search_ignores_queries_that_are_too_short(gpu_db, query):
+    assert gpu_db.search(query) == []
+
+
+def test_gpu_search_surfaces_measured_gpus_first():
+    class KeyUp:
+        input_value = "h200"
+
+    choices = demo_app.search_gpus(KeyUp()).constructor_args["choices"]
+    assert choices[0] == "H200 NVL"  # the measured one, ahead of other H200 boards
+
+
+def test_gpu_lookup_is_case_insensitive(gpu_db):
+    assert gpu_db.get("h200 nvl").gpu_db_name == "H200 NVL"
+
+
+def test_database_covers_a_broad_range_of_nvidia_hardware(gpu_db):
+    assert len(gpu_db.names) > 200
+    for expected in ("H100 SXM5 80 GB", "A100 SXM4 80 GB", "GeForce RTX 4090",
+                     "RTX A6000", "L40"):
+        assert expected in gpu_db.names
+
+
+# ---------------------------------------------------------------------------
+# Feature-space consistency between training and inference
+# ---------------------------------------------------------------------------
+
+def test_inference_row_has_exactly_the_trained_features(predictor):
+    llm = predictor._resolve_llm(KNOWN_LLM)
+    gpu = predictor.gpu_db.get(KNOWN_GPU)
+    row = predictor._feature_row(llm, gpu, "offline")
+
+    for feature_set in (POWER_FEATURES, ITL_FEATURES):
+        assert set(feature_set) <= set(row.columns)
+        assert not row[feature_set].isna().any().any()
+
+    assert predictor.meta["power_features"] == POWER_FEATURES
+    assert predictor.meta["itl_features"] == ITL_FEATURES
+
+
+def test_derived_features_match_their_definitions(predictor):
+    llm = predictor._resolve_llm(KNOWN_LLM)
+    gpu = predictor.gpu_db.get(KNOWN_GPU)
+    row = predictor._feature_row(llm, gpu, "offline").iloc[0]
+
+    assert row["bandwidth_latency"] == pytest.approx(
+        llm.total_b_params * 2 / gpu.memory_bandwidth_gb_s)
+    assert row["compute_latency_s"] == pytest.approx(
+        2 * llm.total_b_params * 1e9 / (gpu.tflops_16b * 1e12))
+    assert row["boost_percentage"] == pytest.approx(
+        gpu.boost_clock_mhz / gpu.base_clock_mhz)
+
+
+# ---------------------------------------------------------------------------
+# Physical sanity
+# ---------------------------------------------------------------------------
+
+def test_faster_gpu_gives_lower_latency(predictor):
+    # A model small enough to fit both cards, so the comparison is about speed.
+    small = "Qwen/Qwen2.5-1.5B-Instruct"
+    fast = predictor.predict(small, "H200 NVL", "server_low")
+    slow = predictor.predict(small, "Tesla T4", "server_low")
+    assert fast.itl_s < slow.itl_s
+
+
+def test_larger_model_is_slower_on_the_same_gpu(predictor):
+    small = predictor.predict("Qwen/Qwen2.5-1.5B-Instruct", KNOWN_GPU, "server_low")
+    large = predictor.predict("Qwen/Qwen2.5-7B-Instruct", KNOWN_GPU, "server_low")
+    assert small.itl_s < large.itl_s
+
+
+def test_offline_reports_energy_per_token_and_server_does_not(predictor):
+    offline = predictor.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    server = predictor.predict(KNOWN_LLM, KNOWN_GPU, "server_high")
+
+    assert offline.energy_per_token_j is not None and offline.energy_per_token_j > 0
+    assert offline.energy_per_token_j == pytest.approx(offline.power_w * offline.itl_s)
+    assert server.energy_per_token_j is None
+
+
+def test_offline_draws_more_power_than_a_lightly_loaded_server(predictor):
+    """A saturated GPU should draw more than an idle-ish one."""
+    offline = predictor.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    server = predictor.predict(KNOWN_LLM, KNOWN_GPU, "server_low")
+    assert offline.power_w > server.power_w
+
+
+# ---------------------------------------------------------------------------
+# The Gradio callback itself
+# ---------------------------------------------------------------------------
+
+@pytest.mark.parametrize("model_id,gpu_name,expected", [
+    (KNOWN_LLM, KNOWN_GPU, "High confidence"),
+    (KNOWN_LLM, UNKNOWN_GPU, "GPU not in training data"),
+    ("not-a-real/model-at-all", KNOWN_GPU, "Cannot make this estimate"),
+    (KNOWN_LLM, "No Such GPU 9000", "not in the GPU database"),
+])
+def test_callback_always_renders_html(model_id, gpu_name, expected):
+    output = demo_app.predict(model_id, gpu_name, "offline")
+    assert output.startswith("<div")
+    assert expected in output
+
+
+@network
+def test_callback_renders_the_lowest_tier_rather_than_refusing():
+    output = demo_app.predict(UNKNOWN_LLM, UNKNOWN_GPU, "offline")
+    assert "wg-red" in output
+    assert "Low confidence" in output
+    assert "Cannot make this estimate" not in output
+
+
+def test_refusals_are_styled_apart_from_the_confidence_tiers():
+    """Being out of scope is not a low confidence level."""
+    output = demo_app.predict("not-a-real/model-at-all", KNOWN_GPU, "offline")
+    assert "wg-error" in output
+    assert "wg-red" not in output
+
+
+# ---------------------------------------------------------------------------
+# Energy and emissions per million tokens
+# ---------------------------------------------------------------------------
+
+def test_energy_per_million_tokens_follows_from_the_prediction(predictor):
+    result = predictor.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+
+    # Board joules per token, grossed up to the facility, then to Wh per 1M.
+    facility_j = result.energy_per_token_j / 0.7 * 1.2
+    assert result.energy_per_million_tokens_wh == pytest.approx(facility_j * 1e6 / 3600)
+    # And equivalently, power divided by throughput at the same boundary.
+    assert result.energy_per_million_tokens_wh == pytest.approx(
+        result.power_w / result.tokens_per_second / 0.7 * 1.2 * 1e6 / 3600)
+
+
+def test_both_scenarios_use_the_same_system_boundary(predictor):
+    """Offline per-token and server per-hour must be comparable, so both
+    gross the board power up by the same host and PUE factors."""
+    offline = predictor.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    server = predictor.predict(KNOWN_LLM, KNOWN_GPU, "server_low")
+
+    board_only_wh = offline.energy_per_token_j * 1e6 / 3600
+    assert offline.energy_per_million_tokens_wh / board_only_wh == pytest.approx(1.2 / 0.7)
+    assert server.energy_per_hour_wh / server.power_w == pytest.approx(1.2 / 0.7)
+
+
+def test_emissions_scale_with_the_grid(predictor):
+    clean = predictor.predict(KNOWN_LLM, KNOWN_GPU, "offline", carbon_intensity=30)
+    dirty = predictor.predict(KNOWN_LLM, KNOWN_GPU, "offline", carbon_intensity=600)
+
+    # Energy is a property of the hardware, not the grid.
+    assert clean.energy_per_million_tokens_wh == dirty.energy_per_million_tokens_wh
+    assert dirty.co2_per_million_tokens_g == pytest.approx(
+        clean.co2_per_million_tokens_g * 20)
+    assert clean.co2_per_million_tokens_g == pytest.approx(
+        clean.energy_per_million_tokens_wh / 1000 * 30)
+
+
+def test_default_grid_is_the_eu_average(predictor):
+    result = predictor.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    assert result.carbon_intensity_g_per_kwh == 240.0
+
+
+@pytest.mark.parametrize("bad", [None, "", "abc", -1, 99999])
+def test_unusable_carbon_intensity_falls_back_to_the_default(predictor, bad):
+    result = predictor.predict(KNOWN_LLM, KNOWN_GPU, "offline", carbon_intensity=bad)
+    assert result.carbon_intensity_g_per_kwh == 240.0
+
+
+@pytest.mark.parametrize("scenario", ["server_low", "server_high"])
+def test_per_token_energy_is_offline_only(predictor, scenario):
+    """Per-token energy derives from batch-wide timing, which server runs do
+    not measure; there the useful figure is per hour instead."""
+    result = predictor.predict(KNOWN_LLM, KNOWN_GPU, scenario)
+    assert result.energy_per_million_tokens_wh is None
+    assert result.co2_per_million_tokens_g is None
+    assert result.energy_per_hour_wh is not None
+
+
+def test_hourly_energy_is_server_only(predictor):
+    result = predictor.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    assert result.energy_per_hour_wh is None
+    assert result.co2_per_hour_g is None
+    assert result.energy_per_million_tokens_wh is not None
+
+
+@pytest.mark.parametrize("scenario", ["server_low", "server_high"])
+def test_hourly_energy_grosses_up_to_the_whole_facility(predictor, scenario):
+    """GPU board -> whole host (GPU is 70% of it) -> facility (PUE 1.2)."""
+    result = predictor.predict(KNOWN_LLM, KNOWN_GPU, scenario)
+
+    assert result.energy_per_hour_wh == pytest.approx(result.power_w / 0.7 * 1.2)
+    # Always more than the board alone, by that fixed factor.
+    assert result.energy_per_hour_wh > result.power_w
+    assert result.energy_per_hour_wh / result.power_w == pytest.approx(1.2 / 0.7)
+
+    assert result.co2_per_hour_g == pytest.approx(
+        result.energy_per_hour_wh / 1000 * result.carbon_intensity_g_per_kwh)
+
+
+def test_hourly_result_shows_the_figures():
+    output = demo_app.predict(KNOWN_LLM, KNOWN_GPU, "server_low")
+    assert "Host energy per hour" in output and "CO₂e per hour" in output
+    assert "Energy per 1M tokens" not in output
+    assert "whole server" in output
+
+
+# ---------------------------------------------------------------------------
+# Per-request Hugging Face token
+# ---------------------------------------------------------------------------
+
+def test_token_is_passed_to_the_hub_and_not_kept(predictor, monkeypatch):
+    """A visitor's token must reach the Hub call and go no further."""
+    seen = {}
+
+    def capture(model_id, token=None):
+        seen["token"] = token
+        return predictor._resolve_llm(KNOWN_LLM)
+
+    monkeypatch.setattr("wattgpu_demo.predictor.fetch_llm_info", capture)
+    result = predictor.predict("some/unmeasured", KNOWN_GPU, "server_low",
+                               hf_token="hf_secret_value")
+
+    assert seen["token"] == "hf_secret_value"
+    # It must not survive anywhere on the prediction.
+    assert "hf_secret_value" not in repr(result)
+
+
+def test_token_never_reaches_the_rendered_output():
+    output = demo_app.predict(KNOWN_LLM, KNOWN_GPU, "offline", 240, "hf_secret_value")
+    assert "hf_secret_value" not in output
+    # Nor the share link.
+    assert "token" not in _share_link(output)
+
+
+def test_token_is_not_echoed_back_by_the_submit_handler():
+    html_out, echoed = demo_app.on_submit(KNOWN_LLM, KNOWN_GPU, "offline", 240,
+                                          "hf_secret_value")
+    assert "hf_secret_value" not in html_out
+    assert echoed == 240  # only the intensity is written back
+
+
+def test_token_is_never_written_to_the_demand_log(demand_log_path):
+    demo_app.predict("microsoft/phi-4", "Tesla T4", "offline", 240, "hf_secret_value")
+    contents = demand_log_path.read_text()
+    assert "hf_secret_value" not in contents
+    assert set(_entries(demand_log_path)[0]) == {"at", "model", "gpu", "scenario", "reason"}
+
+
+def test_token_field_is_masked_and_empty_by_default():
+    assert demo_app.token_input.type == "password"
+    assert not demo_app.token_input.value
+
+
+def test_supplied_token_wins_over_the_deployment_token(monkeypatch):
+    from wattgpu_demo.hf_models import _auth_headers, has_hf_token
+
+    monkeypatch.setenv("HF_TOKEN", "hf_deployment")
+    assert _auth_headers("hf_visitor")["Authorization"] == "Bearer hf_visitor"
+    assert _auth_headers()["Authorization"] == "Bearer hf_deployment"
+    assert _auth_headers("   ")["Authorization"] == "Bearer hf_deployment"
+
+    monkeypatch.delenv("HF_TOKEN")
+    assert _auth_headers() == {}
+    assert _auth_headers("hf_visitor") == {"Authorization": "Bearer hf_visitor"}
+    # has_hf_token describes the deployment, not a per-request token.
+    assert has_hf_token() is False
+
+
+def test_gated_and_rate_limit_messages_point_at_the_token_field(monkeypatch):
+    import urllib.error
+
+    import wattgpu_demo.hf_models as hf
+
+    monkeypatch.delenv("HF_TOKEN", raising=False)
+    monkeypatch.delenv("HUGGING_FACE_HUB_TOKEN", raising=False)
+
+    for code, expected in ((401, "paste a read-only access token"),
+                           (429, "pasting a read-only access token")):
+        def fail(request, *a, _code=code, **kw):
+            raise urllib.error.HTTPError(request.full_url, _code, "nope", {}, None)
+
+        monkeypatch.setattr(hf.urllib.request, "urlopen", fail)
+        with pytest.raises(WattGPUError) as excinfo:
+            hf.fetch_llm_info("gated/model")
+        message = excinfo.value.display()
+        assert expected in message
+        assert "Use your own Hugging Face token" in message
+
+
+def test_analytics_are_disabled_because_the_form_carries_a_secret():
+    assert demo_app.demo.analytics_enabled is False
+
+
+def test_clearing_the_intensity_restores_the_default():
+    """An empty box must not silently disagree with the number in the result."""
+    html, echoed = demo_app.on_submit(KNOWN_LLM, KNOWN_GPU, "offline", None)
+    assert echoed == emissions.DEFAULT_CARBON_INTENSITY_G_PER_KWH
+    assert "240 gCO₂e/kWh" in html
+
+
+def test_submitting_a_valid_intensity_echoes_it_back():
+    html, echoed = demo_app.on_submit(KNOWN_LLM, KNOWN_GPU, "offline", 35)
+    assert echoed == 35
+    assert "35 gCO₂e/kWh" in html
+
+
+def test_intensity_help_offers_electricity_maps_without_overstating():
+    info = demo_app.carbon_input.info
+    assert emissions.ELECTRICITY_MAPS_URL in info
+    assert "might be different" in info
+    assert "probably very different" not in info
+
+
+def test_efficient_gpu_uses_less_energy_per_token(predictor):
+    small = "Qwen/Qwen2.5-1.5B-Instruct"
+    modern = predictor.predict(small, "H200 NVL", "offline")
+    older = predictor.predict(small, "Tesla T4", "offline")
+    assert modern.energy_per_million_tokens_wh < older.energy_per_million_tokens_wh
+
+
+def test_power_card_names_the_gpu_explicitly():
+    """The power figure is the board's, unlike the energy figures around it."""
+    output = demo_app.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    assert "GPU mean power draw" in output
+
+
+def test_share_button_matches_the_primary_button_in_both_themes():
+    """White on sky-500, with no theme-specific override to darken it."""
+    assert "color: #fff; background: #0ea5e9;" in demo_app.CSS
+    assert "#06202e" not in demo_app.CSS  # the old dark-mode text colour
+
+
+def test_watt_counts_dataset_is_cited():
+    assert demo_app.WATT_COUNTS_URL == "https://arxiv.org/abs/2604.09048"
+
+
+def test_offline_result_shows_energy_and_emissions():
+    output = demo_app.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    assert "Energy per 1M tokens" in output
+    assert "CO₂e per 1M tokens" in output
+    assert "240 gCO₂e/kWh" in output
+    assert "whole server" in output
+
+
+def test_the_boundary_is_explained_once_in_assumptions_not_on_every_result():
+    """The result stays uncluttered; the reasoning lives in the panel."""
+    for scenario in ("offline", "server_low"):
+        output = demo_app.predict(KNOWN_LLM, KNOWN_GPU, scenario)
+        assert "PUE" not in output
+        assert "70%" not in output
+
+    assert "PUE" in demo_app.ENERGY_ASSUMPTIONS
+    assert "70%" in demo_app.ENERGY_ASSUMPTIONS
+    # And why the two scenarios report different quantities.
+    assert "per hour" in demo_app.ENERGY_ASSUMPTIONS
+    assert "saturated" in demo_app.ENERGY_ASSUMPTIONS
+
+
+def test_electricity_maps_is_offered_as_the_source():
+    """Users cannot be expected to know their grid's intensity."""
+    assert "app.electricitymaps.com" in emissions.ELECTRICITY_MAPS_URL
+
+
+# ---------------------------------------------------------------------------
+# Licence-gated models
+# ---------------------------------------------------------------------------
+
+GATED_MODELS = [
+    "meta-llama/Llama-3.2-1B-Instruct",
+    "meta-llama/Meta-Llama-3-8B-Instruct",
+    "google/gemma-3-1b-it",
+    "google/gemma-3-270m",
+]
+
+
+@pytest.mark.parametrize("model_id", GATED_MODELS)
+def test_gated_models_resolve_without_a_token(predictor, model_id, monkeypatch):
+    """Llama and Gemma work with no HF_TOKEN and no Hub call at all."""
+    monkeypatch.delenv("HF_TOKEN", raising=False)
+    monkeypatch.delenv("HUGGING_FACE_HUB_TOKEN", raising=False)
+    # Any Hub lookup would be a bug: these must come from the local cache.
+    monkeypatch.setattr("wattgpu_demo.predictor.fetch_llm_info",
+                        lambda _: pytest.fail("hit the Hub for a cached gated model"))
+
+    result = predictor.predict(model_id, KNOWN_GPU, "server_low")
+    assert result.llm.params_source == "published config"
+    assert result.llm.total_b_params > 0
+    assert result.power_w > 0
+
+
+@pytest.mark.parametrize("model_id", GATED_MODELS)
+def test_gated_models_are_not_treated_as_measured(predictor, model_id):
+    """Knowing the architecture is not the same as having measured the model."""
+    assert model_id not in predictor.profiled_models
+    assert model_id in predictor.known_models
+    result = predictor.predict(model_id, KNOWN_GPU, "server_low")
+    assert result.certainty.tier == "yellow"
+    # And the estimate still carries the config-derived caveat.
+    assert any("config.json" in n for n in result.notes)
+
+
+def test_rate_limiting_is_explained_and_does_not_break_cached_models(predictor, monkeypatch):
+    """The Hub rate-limits anonymous traffic per IP, which a busy public Space
+    shares across all its visitors. Cached models must keep working."""
+    import urllib.error
+
+    import wattgpu_demo.hf_models as hf
+
+    def rate_limited(request, *args, **kwargs):
+        raise urllib.error.HTTPError(request.full_url, 429, "Too Many Requests", {}, None)
+
+    monkeypatch.setattr(hf.urllib.request, "urlopen", rate_limited)
+
+    with pytest.raises(NetworkError) as excinfo:
+        predictor.predict("some/unmeasured-model", KNOWN_GPU, "server_low")
+    assert "rate-limiting" in excinfo.value.display()
+
+    # Measured and gated-cached models need no Hub call, so they still answer.
+    assert predictor.predict(KNOWN_LLM, KNOWN_GPU, "server_low").power_w > 0
+    assert predictor.predict("google/gemma-3-1b-it", KNOWN_GPU, "server_low").power_w > 0
+
+
+def test_gated_cache_records_its_source(predictor):
+    """Every cached value must be traceable to the mirror it came from."""
+    for entry in predictor._gated_llms.values():
+        assert entry["source_mirror"].count("/") == 1
+        assert 0 < entry["total_b_params"] < 1000
+        assert entry["num_layers"] > 0 and entry["hidden_size"] > 0
+
+
+def test_known_models_are_offered_before_typing():
+    assert demo_app.model_input.choices == [
+        (m, m) for m in demo_app.predictor.known_models]
+
+
+# ---------------------------------------------------------------------------
+# Permalinks
+# ---------------------------------------------------------------------------
+
+class _FakeRequest:
+    def __init__(self, params):
+        self.query_params = params
+
+
+def _share_link(output: str) -> str:
+    """The permalink the share button carries.
+
+    Read the way a browser would: `&` is written `&amp;` inside an attribute,
+    and the DOM decodes it before any script sees it.
+    """
+    raw = re.search(r'class="wg-share" data-href="([^"]+)"', output).group(1)
+    return html.unescape(raw)
+
+
+def _value(component):
+    """The value a Gradio update carries, or the raw value if it is not one."""
+    args = getattr(component, "constructor_args", None)
+    return args.get("value") if isinstance(args, dict) else component
+
+
+def _is_untouched(component) -> bool:
+    """True for `gr.skip()`, which leaves a component exactly as it was."""
+    return component == {"__type__": "update"}
+
+
+def test_result_carries_a_relative_permalink():
+    output = demo_app.predict(KNOWN_LLM, KNOWN_GPU, "server_high")
+    href = _share_link(output)
+
+    assert href.startswith("?")  # relative, so it works at any deployed URL
+    params = dict(urllib.parse.parse_qsl(href[1:]))
+    assert params == {"model": KNOWN_LLM, "gpu": KNOWN_GPU, "scenario": "server_high"}
+
+
+def test_permalink_round_trips_into_the_form():
+    output = demo_app.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    href = _share_link(output)
+    params = dict(urllib.parse.parse_qsl(href[1:]))
+
+    model, gpu, scenario, carbon, result = demo_app.restore_from_link(_FakeRequest(params))
+    assert _value(model) == KNOWN_LLM
+    assert _value(gpu) == KNOWN_GPU
+    assert _value(scenario) == "offline"
+    assert _value(carbon) == emissions.DEFAULT_CARBON_INTENSITY_G_PER_KWH
+    assert "wg-chip" in result
+
+
+def test_permalink_ignores_an_unknown_gpu_rather_than_opening_on_an_error():
+    updates = demo_app.restore_from_link(
+        _FakeRequest({"model": KNOWN_LLM, "gpu": "No Such GPU", "scenario": "offline"}))
+    assert all(_is_untouched(component) for component in updates)
+
+
+def test_permalink_falls_back_on_invalid_values():
+    *_, scenario, carbon, result = demo_app.restore_from_link(
+        _FakeRequest({"model": KNOWN_LLM, "gpu": KNOWN_GPU,
+                      "scenario": "'; drop", "carbon": "not-a-number"}))
+    assert _value(scenario) == "server_low"
+    assert _value(carbon) == emissions.DEFAULT_CARBON_INTENSITY_G_PER_KWH
+    assert "wg-chip" in result
+
+
+def test_permalink_carries_a_non_default_carbon_intensity():
+    output = demo_app.predict(KNOWN_LLM, KNOWN_GPU, "offline", 35)
+    href = _share_link(output)
+    params = dict(urllib.parse.parse_qsl(href[1:]))
+    assert params["carbon"] == "35"
+
+    *_, carbon, result = demo_app.restore_from_link(_FakeRequest(params))
+    assert _value(carbon) == 35
+    assert "35 gCO₂e/kWh" in result
+
+
+def test_permalink_omits_the_default_carbon_intensity():
+    """Ordinary links stay short."""
+    output = demo_app.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    href = _share_link(output)
+    assert "carbon" not in href
+
+
+def test_page_without_parameters_is_left_alone():
+    assert all(_is_untouched(c) for c in demo_app.restore_from_link(_FakeRequest({})))
+
+
+# ---------------------------------------------------------------------------
+# Demand log
+# ---------------------------------------------------------------------------
+
+@pytest.fixture
+def demand_log_path(tmp_path, monkeypatch):
+    path = tmp_path / "demand.jsonl"
+    monkeypatch.setenv("WATTGPU_DEMAND_LOG", str(path))
+    monkeypatch.delenv("WATTGPU_DEMAND_LOG_DISABLED", raising=False)
+    return path
+
+
+def _entries(path):
+    return [json.loads(line) for line in path.read_text().splitlines()]
+
+
+@pytest.mark.parametrize("model_id,gpu_name,expected_reason", [
+    ("microsoft/phi-4", "Tesla T4", "does-not-fit"),
+])
+def test_refusals_are_logged_as_demand(demand_log_path, model_id, gpu_name, expected_reason):
+    demo_app.predict(model_id, gpu_name, "offline")
+
+    entries = _entries(demand_log_path)
+    assert len(entries) == 1
+    assert entries[0]["model"] == model_id
+    assert entries[0]["gpu"] == gpu_name
+    assert entries[0]["reason"] == expected_reason
+    assert entries[0]["scenario"] == "offline"
+    # Nothing about who asked.
+    assert set(entries[0]) == {"at", "model", "gpu", "scenario", "reason"}
+
+
+def test_typos_are_not_logged_as_demand(demand_log_path):
+    """A misspelled name is not evidence anybody wants that pair covered."""
+    demo_app.predict("nonexistent/typo-xyz", KNOWN_GPU, "offline")
+    demo_app.predict(KNOWN_LLM, "No Such GPU 9000", "offline")
+    assert not demand_log_path.exists()
+
+
+def test_successful_estimates_are_not_logged(demand_log_path):
+    demo_app.predict(KNOWN_LLM, KNOWN_GPU, "offline")
+    assert not demand_log_path.exists()
+
+
+def test_demand_log_can_be_disabled(demand_log_path, monkeypatch):
+    monkeypatch.setenv("WATTGPU_DEMAND_LOG_DISABLED", "1")
+    demo_app.predict("microsoft/phi-4", "Tesla T4", "offline")
+    assert not demand_log_path.exists()
+
+
+def test_demand_log_survives_an_unwritable_path(monkeypatch):
+    """Logging must never take down a response."""
+    monkeypatch.setenv("WATTGPU_DEMAND_LOG", "/proc/nope/cannot-write.jsonl")
+    output = demo_app.predict("microsoft/phi-4", "Tesla T4", "offline")
+    assert "Does not fit" in output
+
+
+def test_demand_summary_ranks_by_frequency(demand_log_path):
+    for _ in range(3):
+        demand_log.record_refusal("a/moe", "H200 NVL", "offline", "moe")
+    demand_log.record_refusal("b/quant", "L4", "server_low", "quantised")
+
+    assert demand_log.summarise(str(demand_log_path))[0] == (
+        "moe: a/moe @ H200 NVL", 3)
+
+
+def test_callback_escapes_html_in_user_input():
+    output = demo_app.predict("<script>alert(1)</script>/x", "L40S", "offline")
+    assert "<script>" not in output
+    assert "&lt;script&gt;" in output

wattgpu_demo/demand_log.py

@@ -0,0 +1,80 @@
+"""Record which (model, GPU) pairs the demo cannot answer.
+
+Every refusal is a request someone wanted and did not get, so the log doubles
+as a demand-ranked coverage roadmap: it says which models and which GPUs are
+worth measuring or supporting next.
+
+Only the query itself is written -- the model id, the GPU name, the scenario
+and why it was refused. No identifiers, no addresses, nothing about who asked.
+The UI discloses that this happens.
+
+On Hugging Face Spaces the container filesystem is ephemeral, so the log is
+lost on restart unless `WATTGPU_DEMAND_LOG` points at persistent storage.
+"""
+
+from __future__ import annotations
+
+import collections
+import json
+import os
+import threading
+from datetime import datetime, timezone
+
+DEFAULT_LOG_PATH = os.path.join(
+    os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+    "data", "demand_log.jsonl",
+)
+
+# Appends are short, but several viewers can hit the app at once.
+_LOCK = threading.Lock()
+
+# Truncated so a pathological input cannot bloat the log.
+MAX_FIELD_CHARS = 200
+
+
+def log_path() -> str:
+    return os.environ.get("WATTGPU_DEMAND_LOG", DEFAULT_LOG_PATH)
+
+
+def is_enabled() -> bool:
+    """Logging is on unless explicitly disabled."""
+    return os.environ.get("WATTGPU_DEMAND_LOG_DISABLED", "").lower() not in ("1", "true", "yes")
+
+
+def record_refusal(model_id: str, gpu_name: str, scenario: str, reason: str) -> None:
+    """Append one refused query. Never raises: logging must not break a response."""
+    if not is_enabled():
+        return
+
+    entry = {
+        "at": datetime.now(timezone.utc).isoformat(timespec="seconds"),
+        "model": str(model_id or "")[:MAX_FIELD_CHARS],
+        "gpu": str(gpu_name or "")[:MAX_FIELD_CHARS],
+        "scenario": str(scenario or "")[:MAX_FIELD_CHARS],
+        "reason": reason,
+    }
+    try:
+        path = log_path()
+        directory = os.path.dirname(path)
+        if directory:
+            os.makedirs(directory, exist_ok=True)
+        with _LOCK, open(path, "a", encoding="utf-8") as fh:
+            fh.write(json.dumps(entry) + "\n")
+    except OSError:
+        pass  # a read-only or full filesystem must not take the demo down
+
+
+def summarise(path: str | None = None, limit: int = 20) -> list[tuple[str, int]]:
+    """Most-requested refused queries, for deciding what to cover next."""
+    counts: collections.Counter[str] = collections.Counter()
+    try:
+        with open(path or log_path(), encoding="utf-8") as fh:
+            for line in fh:
+                try:
+                    entry = json.loads(line)
+                except json.JSONDecodeError:
+                    continue
+                counts[f"{entry.get('reason')}: {entry.get('model')} @ {entry.get('gpu')}"] += 1
+    except OSError:
+        return []
+    return counts.most_common(limit)

wattgpu_demo/emissions.py

@@ -0,0 +1,110 @@
+"""Turn predicted energy into per-million-token figures and CO2e.
+
+Energy per million tokens is the honest core here: it comes straight from the
+predicted power and latency, needs no assumption about who is running the GPU
+or where, and does not go stale. Emissions are a single visible multiplier on
+top of it -- the grid's carbon intensity, which the user can change.
+
+Every figure here is at the **facility level**: the predicted GPU board power is
+grossed up to the whole host, then multiplied by the data centre's PUE, so what
+is reported is roughly what the wall socket sees rather than what the card
+draws. The same scaling is applied in both scenarios, so the offline per-token
+and the server per-hour numbers describe the same system boundary.
+"""
+
+from __future__ import annotations
+
+JOULES_PER_WH = 3600.0
+TOKENS_PER_MILLION = 1_000_000
+
+# EU-27 average grid carbon intensity, approximately, in gCO2e per kWh. It is a
+# yearly average across a whole continent, so it is a reference point rather
+# than a figure for any particular deployment: real intensity swings by a factor
+# of ten between regions, and by the hour within one.
+DEFAULT_CARBON_INTENSITY_G_PER_KWH = 240.0
+DEFAULT_CARBON_INTENSITY_LABEL = "EU average"
+
+# Live and historical intensity by region.
+ELECTRICITY_MAPS_URL = "https://app.electricitymaps.com/map/live/fifteen_minutes"
+
+# Guards against nonsense typed into the input. The low end is below the
+# cleanest grids (Iceland, Norway), the high end above the dirtiest.
+MIN_CARBON_INTENSITY = 0.0
+MAX_CARBON_INTENSITY = 2000.0
+
+# Scaling the GPU board's draw up to what the wall socket sees.
+#
+# The GPU dominates an inference server but is not all of it: CPU, memory,
+# storage, NICs and fans draw the rest. Taking the GPU as ~70% of the host's
+# total is a common rule of thumb for a single-accelerator inference node.
+GPU_SHARE_OF_HOST_POWER = 0.7
+
+# Power usage effectiveness: facility draw divided by IT draw, covering cooling
+# and power distribution. 1.2 is typical of a modern hyperscale data centre;
+# older or smaller sites are worse.
+DEFAULT_PUE = 1.2
+
+
+def facility_power_w(gpu_power_w: float,
+                     gpu_share: float = GPU_SHARE_OF_HOST_POWER,
+                     pue: float = DEFAULT_PUE) -> float:
+    """Wall-socket power for one GPU's share of a server.
+
+    Grosses the predicted board power up to the whole host, then applies the
+    data centre's overhead on top.
+    """
+    return gpu_power_w / gpu_share * pue
+
+
+def energy_per_hour_wh(gpu_power_w: float) -> float:
+    """Facility-level watt-hours for one hour of serving. Numerically the
+    facility power, since one hour at W watts is W watt-hours."""
+    return facility_power_w(gpu_power_w)
+
+
+def co2_per_hour_g(energy_wh: float, carbon_intensity_g_per_kwh: float) -> float:
+    """Grams of CO2e for one hour at a given grid intensity."""
+    return (energy_wh / 1000.0) * carbon_intensity_g_per_kwh
+
+
+def energy_per_million_tokens_wh(gpu_energy_per_token_j: float) -> float:
+    """Facility watt-hours to generate a million tokens.
+
+    Takes the GPU board's energy per token, grosses it up to the whole server
+    and applies the data-centre overhead, so it is comparable with the hourly
+    figure reported under server load.
+    """
+    facility_j = facility_power_w(gpu_energy_per_token_j)
+    return facility_j * TOKENS_PER_MILLION / JOULES_PER_WH
+
+
+def co2_per_million_tokens_g(energy_wh: float, carbon_intensity_g_per_kwh: float) -> float:
+    """Grams of CO2e for a million tokens at a given grid intensity."""
+    return (energy_wh / 1000.0) * carbon_intensity_g_per_kwh
+
+
+def clean_carbon_intensity(value: float | int | str | None) -> float:
+    """Coerce user input to a usable intensity, falling back to the default."""
+    try:
+        intensity = float(value)  # type: ignore[arg-type]
+    except (TypeError, ValueError):
+        return DEFAULT_CARBON_INTENSITY_G_PER_KWH
+    if not MIN_CARBON_INTENSITY <= intensity <= MAX_CARBON_INTENSITY:
+        return DEFAULT_CARBON_INTENSITY_G_PER_KWH
+    return intensity
+
+
+def format_energy(watt_hours: float) -> str:
+    if watt_hours >= 1000:
+        return f"{watt_hours / 1000:,.3g} kWh"
+    if watt_hours >= 1:
+        return f"{watt_hours:.3g} Wh"
+    return f"{watt_hours * 1000:.3g} mWh"
+
+
+def format_co2(grams: float) -> str:
+    if grams >= 1000:
+        return f"{grams / 1000:,.3g} kg"
+    if grams >= 1:
+        return f"{grams:.3g} g"
+    return f"{grams * 1000:.3g} mg"

wattgpu_demo/errors.py

@@ -0,0 +1,44 @@
+"""User-facing errors.
+
+Every failure path in the demo raises a `WattGPUError` carrying a message
+that is safe and useful to show directly in the UI: what went wrong, and
+what the user can do about it.
+"""
+
+from __future__ import annotations
+
+
+class WattGPUError(Exception):
+    """An error with a message meant to be displayed to the user."""
+
+    def __init__(self, message: str, hint: str | None = None) -> None:
+        super().__init__(message)
+        self.message = message
+        self.hint = hint
+
+    def display(self) -> str:
+        return f"{self.message}\n\n{self.hint}" if self.hint else self.message
+
+
+class ModelNotFoundError(WattGPUError):
+    """The Hugging Face repository does not exist, or is gated/private."""
+
+
+class ModelConfigError(WattGPUError):
+    """The repository exists but does not look like a supported LLM."""
+
+
+class GPUNotFoundError(WattGPUError):
+    """The GPU is not in the specification database."""
+
+
+class NetworkError(WattGPUError):
+    """The Hugging Face Hub could not be reached."""
+
+
+class UnsupportedModelError(WattGPUError):
+    """The model is of a kind WattGPU does not cover: MoE or quantised."""
+
+
+class InsufficientMemoryError(WattGPUError):
+    """The model's weights do not fit in the GPU's usable memory."""

wattgpu_demo/features.py

@@ -0,0 +1,185 @@
+"""Feature engineering shared by training and inference.
+
+The transformations here mirror `WattGPU.ipynb` exactly. Keeping one
+implementation is what guarantees that a row built at inference time from a
+`config.json` and a dbgpu specification lands in the same feature space as the
+rows the models were fitted on.
+"""
+
+from __future__ import annotations
+
+import os
+
+import numpy as np
+import pandas as pd
+
+# Operational scenarios, derived in the paper from the Poisson arrival rate.
+# These are three *measured operating points*, not ranges. Every server run in
+# the dataset used one of exactly two Poisson arrival rates, and the offline
+# runs kept the GPU permanently saturated:
+#
+#   server_low   0.017 requests/s
+#   server_high  0.330 requests/s
+#   offline      saturated, requests always queued
+#
+# Converted at a typical one message per minute per active user
+# (0.0167 requests/s each), those rates are about 1 and about 20 concurrent
+# users. The model takes the scenario as a category, so it can only answer at
+# these three points -- there is no interpolation to an arbitrary request rate.
+SCENARIOS = ["server_low", "server_high", "offline"]
+SCENARIO_RATES_QPS = {"server_low": 0.017, "server_high": 0.330, "offline": None}
+SCENARIO_LABELS = {
+    "server_low": "Low load — a single concurrent user",
+    "server_high": "Medium load — about 20 concurrent users",
+    "offline": "Offline / batch",
+}
+
+# Offline runs record only whole-batch timing, so the latency target means
+# something different there: wall-clock time per token across every request in
+# flight, rather than the gap one user sees between tokens. Its inverse is
+# therefore the batch's aggregate throughput, which is how the UI reports it.
+# Under server load the target is a genuine per-user latency, and system
+# throughput cannot be recovered from it without a model of batching.
+SCENARIOS_WITH_PER_USER_LATENCY = ("server_low", "server_high")
+
+# Identifier columns kept for grouping but never used as features.
+ID_COLUMNS = ["gpu_db_name", "model"]
+
+# §4.1 feature set for mean power draw (target: normalized_power_draw).
+POWER_FEATURES = [
+    "scenario",
+    "log_total_b_params",
+    "model_type",
+    "num_key_value_heads",
+    "num_layers",
+    "memory_bandwidth_gb_s",
+    "boost_percentage",
+    "transistor_count_m",
+    "base_clock_mhz",
+    "release_year",
+    "bandwidth_latency",
+]
+
+# §4.2 feature set for inter-token latency (target: itl).
+ITL_FEATURES = [
+    "scenario",
+    "model_type",
+    "total_b_params",
+    "hidden_size",
+    "num_attention_heads",
+    "num_key_value_heads",
+    "num_layers",
+    "memory_bandwidth_gb_s",
+    "memory_size_gb",
+    "memory_type",
+    "tflops_16b",
+    "release_year",
+    "bandwidth_latency",
+    "compute_latency_s",
+]
+
+POWER_TARGET = "normalized_power_draw"
+ITL_TARGET = "itl"
+
+
+# ---------------------------------------------------------------------------
+# Derived features (single source of truth for training and inference)
+# ---------------------------------------------------------------------------
+
+def add_derived_features(df: pd.DataFrame) -> pd.DataFrame:
+    """Add the engineered GPU, LLM and pair features used by both models."""
+    df = df.copy()
+
+    df["boost_percentage"] = df["boost_clock_mhz"] / df["base_clock_mhz"]
+    df["log_total_b_params"] = np.log(df["total_b_params"])
+
+    # Bandwidth latency: time to read all FP16 weights from GPU memory once.
+    df["bandwidth_latency"] = (df["total_b_params"] * 2) / df["memory_bandwidth_gb_s"]
+
+    # Compute latency: lower bound on the time to compute one token at peak FLOPS.
+    df["compute_latency_s"] = (2 * df["total_b_params"] * 1e9) / (df["tflops_16b"] * 1e12)
+
+    return df
+
+
+# ---------------------------------------------------------------------------
+# Training frame (replicates the notebook's preprocessing)
+# ---------------------------------------------------------------------------
+
+def _convert_column_to_list(df: pd.DataFrame, column: str) -> None:
+    df[column] = df[column].apply(eval)
+
+
+def _compute_itl_per_request(row: pd.Series) -> float:
+    """Mean ITL for a server-scenario row, averaged over its requests.
+
+    ITL is undefined for requests generating fewer than two tokens, so those
+    are dropped.
+    """
+    e2e = np.array(row["e2e_request_latency_seconds_events"])
+    ttft = np.array(row["time_to_first_token_seconds_events"])
+    tokens = np.array(row["request_generation_tokens"])
+
+    valid = tokens >= 2
+    if not valid.any():
+        return np.nan
+    return ((e2e[valid] - ttft[valid]) / (tokens[valid] - 1)).mean()
+
+
+def build_training_frame(data_dir: str) -> pd.DataFrame:
+    """Load the Watt Counts subset and produce the modelling frame.
+
+    Follows `WattGPU.ipynb`: expand the per-request event lists, merge LLM and
+    GPU metadata, derive the operational scenario, restrict to dense models,
+    and engineer the features.
+    """
+    df = pd.read_csv(os.path.join(data_dir, "watt_counts_subset.csv"), index_col=0)
+
+    for column in (
+        "time_to_first_token_seconds_events",
+        "e2e_request_latency_seconds_events",
+        "request_generation_tokens",
+    ):
+        _convert_column_to_list(df, column)
+
+    # LLM metadata from Hugging Face; drop columns that are mostly empty.
+    df_models = pd.read_csv(os.path.join(data_dir, "model_features.csv"), sep=";", index_col=0)
+    df_models = df_models[df_models.columns[df_models.isna().sum() / len(df_models) < 0.1]]
+    df = df.merge(df_models, left_on="model", right_index=True, how="left")
+
+    # GPU metadata from manufacturer specifications.
+    df_gpus = pd.read_csv(os.path.join(data_dir, "gpu_features.csv"), index_col=0, sep=";")
+    df = df.merge(df_gpus, left_on="gpu_type", right_index=True, how="left")
+
+    # Scenario comes from the Poisson arrival rate; rows without one are offline.
+    df.loc[df.lambda_qps < 0.2, "scenario"] = "server_low"
+    df.loc[df.lambda_qps > 0.2, "scenario"] = "server_high"
+    df.loc[df.lambda_qps.isna(), "scenario"] = "offline"
+
+    df = df[df.generation_tokens_total != 0]
+
+    # Peak dense FP16 tensor throughput, which TechPowerUp does not publish.
+    df["tflops_16b"] = df["tensor_tflops"]
+
+    # MoE models are excluded: their inference pattern needs separate modelling.
+    df = df[df.total_b_params == df.active_b_params].copy()
+
+    df["normalized_power_draw"] = df["gpu_0_power_draw_watts_mean"] / df["thermal_design_power_w"]
+    df = add_derived_features(df)
+
+    # ITL: wall time per token offline, mean per-request decode latency on server.
+    offline = df.scenario == "offline"
+    df.loc[offline, "itl"] = (
+        df.loc[offline, "measurement_duration"] / df.loc[offline, "generation_tokens_total"]
+    )
+    df.loc[~offline, "itl"] = df.loc[~offline].apply(_compute_itl_per_request, axis=1)
+
+    return df
+
+
+def clean_frame(df: pd.DataFrame, columns: list[str]) -> pd.DataFrame:
+    """Select `columns`, drop uninformative ones, and drop rows with NaNs."""
+    out = df.loc[:, columns]
+    out = out.dropna(axis=1, how="all")
+    out = out.loc[:, out.nunique(dropna=True) > 1]
+    return out.dropna(axis=0, how="any")

wattgpu_demo/gpu_db.py

@@ -0,0 +1,148 @@
+"""Look-ups over the GPU specification database built by `scripts/build_gpu_db.py`."""
+
+from __future__ import annotations
+
+import difflib
+import os
+from dataclasses import dataclass, field
+from typing import Any
+
+import pandas as pd
+
+from .errors import GPUNotFoundError
+
+DEFAULT_DB_PATH = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+                               "data", "gpu_database.csv")
+
+
+@dataclass
+class GPUInfo:
+    """One GPU's specifications, as WattGPU consumes them."""
+
+    gpu_db_name: str
+    manufacturer: str
+    architecture: str | None
+    memory_size_gb: float
+    memory_bandwidth_gb_s: float
+    memory_type: str | None
+    base_clock_mhz: float | None
+    boost_clock_mhz: float | None
+    transistor_count_m: float | None
+    thermal_design_power_w: float
+    release_year: int | None
+    tflops_16b: float | None
+    tflops_source: str
+    tpu_url: str | None = None
+    warnings: list[str] = field(default_factory=list)
+
+    def spec_rows(self) -> list[tuple[str, str]]:
+        tflops = (f"{self.tflops_16b:.0f} ({self.tflops_source})"
+                  if self.tflops_16b is not None else "unknown")
+        return [
+            ("GPU", self.gpu_db_name),
+            ("Manufacturer", self.manufacturer),
+            ("Architecture", self.architecture or "—"),
+            ("Released", str(self.release_year or "—")),
+            ("Memory", f"{self.memory_size_gb:.0f} GB {self.memory_type or ''}".strip()),
+            ("Memory bandwidth", f"{self.memory_bandwidth_gb_s:,.0f} GB/s"),
+            ("Clocks", f"{self.base_clock_mhz or '—'} / {self.boost_clock_mhz or '—'} MHz"),
+            ("TDP", f"{self.thermal_design_power_w:.0f} W"),
+            ("FP16 tensor", f"{tflops} TFLOP/s"),
+        ]
+
+
+def _to_float(value: Any) -> float | None:
+    return None if value is None or pd.isna(value) else float(value)
+
+
+class GPUDatabase:
+    """The demo's GPU specifications, keyed by TechPowerUp product name."""
+
+    def __init__(self, path: str = DEFAULT_DB_PATH) -> None:
+        if not os.path.exists(path):
+            raise GPUNotFoundError(
+                "The GPU specification database is missing.",
+                f"Expected it at `{path}`. Run `python scripts/build_gpu_db.py` to create it.",
+            )
+        self.frame = pd.read_csv(path)
+        self._by_name = {name.lower(): name for name in self.frame["gpu_db_name"]}
+
+    @property
+    def names(self) -> list[str]:
+        return self.frame["gpu_db_name"].tolist()
+
+    def search(self, query: str, limit: int = 25) -> list[str]:
+        """Substring search over the catalogue, best matches first.
+
+        Names that start with the query rank above names that merely contain
+        it, so typing "a100" surfaces the A100 variants before the boards that
+        happen to mention it.
+        """
+        query = (query or "").strip().lower()
+        if len(query) < 2:
+            return []
+
+        starts, contains = [], []
+        for name in self.names:
+            lowered = name.lower()
+            if lowered.startswith(query):
+                starts.append(name)
+            elif query in lowered:
+                contains.append(name)
+        return (starts + contains)[:limit]
+
+    def get(self, name: str) -> GPUInfo:
+        """Resolve a GPU by name, case-insensitively.
+
+        Raises `GPUNotFoundError` with close-match suggestions when the name
+        is not in the database.
+        """
+        name = (name or "").strip()
+        if not name:
+            raise GPUNotFoundError(
+                "No GPU selected.",
+                "Pick one from the list, or type a product name such as `A100 SXM4 80 GB`.",
+            )
+
+        resolved = self._by_name.get(name.lower())
+        if resolved is None:
+            suggestions = difflib.get_close_matches(name, self.names, n=5, cutoff=0.5)
+            hint = (f"Did you mean: {', '.join(f'`{s}`' for s in suggestions)}?"
+                    if suggestions else
+                    "Use the TechPowerUp product name, for example `A100 SXM4 80 GB`. "
+                    "The list only covers accelerators with at least 6 GB of memory.")
+            raise GPUNotFoundError(f"**{name}** is not in the GPU database.", hint)
+
+        row = self.frame[self.frame["gpu_db_name"] == resolved].iloc[0]
+        warnings: list[str] = []
+
+        tflops = _to_float(row.get("tensor_tflops_16b"))
+        source = str(row.get("tensor_tflops_source") or "unknown")
+        if tflops is None:
+            warnings.append(
+                f"No FP16 tensor throughput known for {resolved}. Power is still "
+                "estimated; latency is not."
+            )
+        elif source == "estimated":
+            warnings.append(
+                f"FP16 throughput for {resolved} is estimated from its tensor-core "
+                "count and clock, not taken from a datasheet."
+            )
+
+        return GPUInfo(
+            gpu_db_name=resolved,
+            manufacturer=str(row.get("manufacturer") or "—"),
+            architecture=None if pd.isna(row.get("architecture")) else str(row["architecture"]),
+            memory_size_gb=float(row["memory_size_gb"]),
+            memory_bandwidth_gb_s=float(row["memory_bandwidth_gb_s"]),
+            memory_type=None if pd.isna(row.get("memory_type")) else str(row["memory_type"]),
+            base_clock_mhz=_to_float(row.get("base_clock_mhz")),
+            boost_clock_mhz=_to_float(row.get("boost_clock_mhz")),
+            transistor_count_m=_to_float(row.get("transistor_count_m")),
+            thermal_design_power_w=float(row["thermal_design_power_w"]),
+            release_year=None if pd.isna(row.get("release_year")) else int(row["release_year"]),
+            tflops_16b=tflops,
+            tflops_source=source,
+            tpu_url=None if pd.isna(row.get("tpu_url")) else str(row["tpu_url"]),
+            warnings=warnings,
+        )

wattgpu_demo/hf_models.py

@@ -0,0 +1,526 @@
+"""Fetch the LLM metadata WattGPU needs from the Hugging Face Hub.
+
+The models consume six architecture fields (`model_type`, `num_layers`,
+`hidden_size`, `num_attention_heads`, `num_key_value_heads`,
+`total_b_params`). Five come from `config.json`; the parameter count comes
+from the Hub's safetensors index, with a config-derived estimate as fallback
+for repositories that do not publish one.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any
+
+from .errors import (
+    ModelConfigError,
+    ModelNotFoundError,
+    NetworkError,
+    UnsupportedModelError,
+    WattGPUError,
+)
+
+# Direct contact for coverage requests and collaboration.
+CONTACT_EMAIL = "mfa@leaner-ai.com"
+CONTACT_URL = f"mailto:{CONTACT_EMAIL}"
+
+HF_ENDPOINT = "https://huggingface.co"
+USER_AGENT = "wattgpu-demo/1.0"
+TIMEOUT_S = 20
+
+# `config.json` keys that mean the same thing across architecture families.
+FIELD_ALIASES: dict[str, tuple[str, ...]] = {
+    "num_layers": ("num_hidden_layers", "n_layer", "num_layers", "n_layers"),
+    "hidden_size": ("hidden_size", "n_embd", "d_model", "hidden_dim"),
+    "num_attention_heads": ("num_attention_heads", "n_head", "n_heads", "num_heads"),
+    "num_key_value_heads": ("num_key_value_heads", "num_kv_heads", "n_head_kv"),
+    "intermediate_size": ("intermediate_size", "n_inner", "ffn_dim", "d_ff"),
+    "vocab_size": ("vocab_size",),
+}
+
+# Config keys that indicate a mixture-of-experts model. MoE inference activates
+# only a subset of the weights per token, so its power and latency behave
+# differently from the dense models WattGPU was trained on.
+MOE_KEYS = (
+    "num_experts",
+    "num_local_experts",
+    "n_routed_experts",
+    "moe_num_experts",
+    "num_experts_per_tok",
+    "moe_intermediate_size",
+    "n_shared_experts",
+    "moe_layer_freq",
+    "shared_expert_intermediate_size",
+)
+
+# Quantised weights change both the memory traffic and the arithmetic a GPU
+# does per token. Every profiled run used FP16, so quantised models are out of
+# scope. `quantization_config` is written by transformers for GPTQ, AWQ,
+# bitsandbytes, compressed-tensors, FP8 and friends, and is the reliable signal.
+QUANTIZATION_CONFIG_KEYS = ("quantization_config", "quantization")
+
+# Dtypes that are not a 16-bit float.
+QUANTISED_DTYPES = ("int8", "int4", "uint8", "uint4", "fp8", "float8", "fp4", "nf4")
+
+# Fallback for repositories that quantise without recording it in the config.
+# Matched against the repository id, lower-cased, so keep these specific enough
+# not to fire on ordinary model names.
+QUANTISATION_ID_MARKERS = (
+    "gptq", "awq", "gguf", "-4bit", "-8bit", "int4", "int8", "fp8", "fp4",
+    "nf4", "-bnb", "w4a16", "w8a8", "mxfp4", "autoround", "quantized",
+    "quantised", "-qat",
+)
+
+# WattGPU was profiled on decoder-only generative models served by vLLM.
+DECODER_ARCHITECTURE_SUFFIXES = ("ForCausalLM", "LMHeadModel", "ForConditionalGeneration")
+
+# Architectures that are definitely not autoregressive generation: encoders used
+# for embeddings, and classification heads used for reranking. These do not
+# generate tokens at all, so inter-token latency is meaningless for them.
+NON_GENERATIVE_ARCHITECTURE_SUFFIXES = (
+    "ForSequenceClassification",
+    "ForMaskedLM",
+    "ForTokenClassification",
+    "ForQuestionAnswering",
+    "ForMultipleChoice",
+    "EmbeddingModel",
+)
+
+# Hub task tags that mean the repository is not served as a generative LLM.
+# This is the load-bearing check: an embedding or reranker model built on a
+# causal LM (Qwen3-Embedding, Qwen3-Reranker) still declares `Qwen3ForCausalLM`
+# in its config, so the architecture alone cannot tell them apart.
+NON_GENERATIVE_PIPELINE_TAGS = {
+    "feature-extraction": "an embedding model",
+    "sentence-similarity": "an embedding model",
+    "text-ranking": "a reranker",
+    "text-classification": "a classifier",
+    "token-classification": "a token classifier",
+    "fill-mask": "a masked language model",
+    "question-answering": "an extractive question-answering model",
+    "zero-shot-classification": "a classifier",
+}
+
+
+@dataclass
+class LLMInfo:
+    """Everything the demo knows about one Hugging Face model."""
+
+    model_id: str
+    model_type: str
+    num_layers: int
+    hidden_size: int
+    num_attention_heads: int
+    num_key_value_heads: int
+    total_b_params: float
+    params_source: str
+    architectures: list[str] = field(default_factory=list)
+    max_position_embeddings: int | None = None
+    torch_dtype: str | None = None
+    is_moe: bool = False
+    warnings: list[str] = field(default_factory=list)
+
+    def spec_rows(self) -> list[tuple[str, str]]:
+        """Human-readable spec sheet for the UI."""
+        return [
+            ("Model", self.model_id),
+            ("Architecture", ", ".join(self.architectures) or "—"),
+            ("Model type", self.model_type),
+            ("Parameters (B)", f"{self.total_b_params:.3g}"
+                               + (" (estimated)" if "estimated" in self.params_source else "")),
+            ("Layers", str(self.num_layers)),
+            ("Hidden size", str(self.hidden_size)),
+            ("Attention heads", str(self.num_attention_heads)),
+            ("KV heads", str(self.num_key_value_heads)),
+            ("Max context", str(self.max_position_embeddings or "—")),
+            ("Weight dtype", self.torch_dtype or "—"),
+        ]
+
+
+def _auth_headers(token: str | None = None) -> dict[str, str]:
+    """Bearer token for the Hub, if one is available.
+
+    A token passed in by the caller wins over the deployment's own
+    `HF_TOKEN` / `HUGGING_FACE_HUB_TOKEN`, so a visitor can supply their own for
+    a single request. Caller-supplied tokens are used and discarded -- never
+    stored, logged, or written into a shareable link.
+    """
+    supplied = (token or "").strip()
+    if supplied:
+        return {"Authorization": f"Bearer {supplied}"}
+    configured = os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+    return {"Authorization": f"Bearer {configured.strip()}"} if configured else {}
+
+
+def has_hf_token() -> bool:
+    """Whether the deployment itself has a token, ignoring per-request ones."""
+    return bool(os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN"))
+
+
+def _get_json(url: str, what: str, token: str | None = None) -> Any:
+    headers = {"User-Agent": USER_AGENT, **_auth_headers(token)}
+    request = urllib.request.Request(url, headers=headers)
+    try:
+        with urllib.request.urlopen(request, timeout=TIMEOUT_S) as response:
+            return json.loads(response.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        if exc.code in (401, 403):
+            # The Hub answers 401 both for gated repositories and for ones that
+            # do not exist, so it is not possible to tell the two apart here.
+            hint = (
+                "Either the repository does not exist, or it is private or "
+                "licence-gated. Check the spelling first."
+            )
+            if _auth_headers(token):
+                hint += (
+                    " The token in use does not grant access to it — accept the "
+                    "model's licence on huggingface.co with that account."
+                )
+            else:
+                hint += (
+                    " For a gated model such as Llama or Gemma, accept its licence "
+                    "on huggingface.co and paste a read-only access token into "
+                    "**Use your own Hugging Face token** below."
+                )
+            raise ModelNotFoundError(f"Cannot read **{what}** from the Hugging Face Hub.", hint) from exc
+        if exc.code == 404:
+            raise ModelNotFoundError(
+                f"**{what}** has no `config.json`.",
+                "The repository exists but does not look like a transformers "
+                "model. GGUF-only and adapter repositories are not supported; "
+                "use the original model repository instead.",
+            ) from exc
+        if exc.code == 429:
+            # The Hub rate-limits anonymous requests per IP. A busy public
+            # deployment shares one IP across all its visitors, so this is
+            # reached in practice, not just under abuse.
+            hint = "The Hugging Face Hub is rate-limiting requests. Please try again shortly."
+            if not _auth_headers(token):
+                hint += (
+                    " The limit is per IP address and shared by everyone using this "
+                    "demo, so pasting a read-only access token into **Use your own "
+                    "Hugging Face token** below will lift it for you. Measured and "
+                    "cached models are unaffected — they need no Hub lookup at all."
+                )
+            raise NetworkError(f"Too many requests to the Hub while reading **{what}**.",
+                               hint) from exc
+        raise NetworkError(
+            f"Hugging Face returned HTTP {exc.code} for **{what}**.",
+            "This is usually temporary. Please try again in a moment.",
+        ) from exc
+    except urllib.error.URLError as exc:
+        raise NetworkError(
+            "Could not reach the Hugging Face Hub.",
+            f"The network request failed ({exc.reason}). Check connectivity and retry.",
+        ) from exc
+    except json.JSONDecodeError as exc:
+        raise ModelConfigError(
+            f"The configuration file for **{what}** is not valid JSON.",
+            "This repository does not look like a standard transformers model.",
+        ) from exc
+
+
+def _pick(config: dict, logical_name: str) -> Any:
+    for key in FIELD_ALIASES[logical_name]:
+        value = config.get(key)
+        if value is not None:
+            return value
+    return None
+
+
+def _unwrap_text_config(config: dict) -> tuple[dict, list[str]]:
+    """Multimodal repos nest the language model under `text_config`."""
+    text_config = config.get("text_config")
+    if isinstance(text_config, dict) and _pick(text_config, "num_layers") is not None:
+        merged = {**config, **text_config}
+        return merged, [
+            "This is a multimodal repository; predictions use its text decoder "
+            "(`text_config`) and ignore the vision tower."
+        ]
+    return config, []
+
+
+def _estimate_b_params(config: dict) -> float | None:
+    """Estimate parameter count from the transformer's shape.
+
+    Embeddings + per-layer attention and MLP weights. Accurate to a few percent
+    for standard decoder-only models, and only used when the Hub publishes no
+    safetensors index.
+    """
+    layers = _pick(config, "num_layers")
+    hidden = _pick(config, "hidden_size")
+    heads = _pick(config, "num_attention_heads")
+    vocab = _pick(config, "vocab_size")
+    intermediate = _pick(config, "intermediate_size")
+    if not all(isinstance(v, int) and v > 0 for v in (layers, hidden, heads, vocab)):
+        return None
+    if not isinstance(intermediate, int) or intermediate <= 0:
+        intermediate = 4 * hidden
+
+    kv_heads = _pick(config, "num_key_value_heads") or heads
+    head_dim = config.get("head_dim") or hidden // heads
+
+    attention = hidden * (heads * head_dim) + 2 * hidden * (kv_heads * head_dim) + (heads * head_dim) * hidden
+    mlp = 3 * hidden * intermediate  # gated MLP; ~1.5x the cost of a plain one
+    embeddings = vocab * hidden * (1 if config.get("tie_word_embeddings") else 2)
+
+    return (layers * (attention + mlp) + embeddings) / 1e9
+
+
+def detect_moe(config: dict) -> str | None:
+    """Return the config key that marks this as MoE, or None."""
+    for key in MOE_KEYS:
+        if config.get(key):
+            return key
+    for architecture in config.get("architectures") or []:
+        if "moe" in str(architecture).lower():
+            return "architectures"
+    return None
+
+
+def detect_quantisation(model_id: str, config: dict) -> str | None:
+    """Return a short description of the quantisation found, or None."""
+    for key in QUANTIZATION_CONFIG_KEYS:
+        value = config.get(key)
+        if isinstance(value, dict) and value:
+            method = value.get("quant_method") or value.get("method") or "unknown method"
+            return str(method)
+        if isinstance(value, str) and value:
+            return value
+
+    # Both spellings are checked independently: recent transformers renamed
+    # `torch_dtype` to `dtype`, and a config may carry both.
+    for key in ("torch_dtype", "dtype"):
+        dtype = str(config.get(key) or "").lower()
+        if any(marker in dtype for marker in QUANTISED_DTYPES):
+            return dtype
+
+    lowered = model_id.lower()
+    for marker in QUANTISATION_ID_MARKERS:
+        if marker in lowered:
+            return f"the repository name contains `{marker.strip('-')}`"
+    return None
+
+
+def _reject_if_unsupported(model_id: str, config: dict) -> None:
+    """Refuse model families WattGPU was never trained on.
+
+    Every profiled run served a dense model with FP16 weights. Mixture-of-experts
+    routing and quantised weights both change the memory traffic and arithmetic
+    per token enough that an estimate would be misleading rather than merely
+    uncertain, so these are refused rather than flagged.
+    """
+    moe_key = detect_moe(config)
+    if moe_key:
+        raise UnsupportedModelError(
+            f"Not supported yet: **{model_id}** is a mixture-of-experts model.",
+            "WattGPU was trained on dense models only. MoE models activate a "
+            "fraction of their weights per token, so their power and latency "
+            "follow different rules.\n\n"
+            "Support for mixture-of-experts models is in progress — "
+            f"[get in touch]({CONTACT_URL}) to hear when it lands, or to tell us "
+            "which models you need covered.",
+        )
+
+    quantisation = detect_quantisation(model_id, config)
+    if quantisation:
+        raise UnsupportedModelError(
+            f"Not supported yet: **{model_id}** looks quantised ({quantisation}).",
+            "Every measurement behind WattGPU used FP16 weights. Quantisation "
+            "changes both memory traffic and arithmetic per token, so an estimate "
+            "would not carry over.\n\n"
+            "Support for quantised weights is in progress — "
+            f"[get in touch]({CONTACT_URL}) to hear when it lands, or to tell us "
+            "which formats you need covered.",
+        )
+
+
+def llm_info_from_config(model_id: str, config: dict,
+                         total_b_params: float | None = None,
+                         params_source: str = "") -> LLMInfo:
+    """Convert a raw `config.json` into the features WattGPU consumes.
+
+    This is the adapter between the Hugging Face world -- where every
+    architecture family names its fields differently -- and the fixed schema
+    the trained models expect. It is pure: give it a parsed config and it
+    returns an `LLMInfo`, no network involved. `fetch_llm_info` is the thin
+    transport layer on top of it.
+
+    Pass `total_b_params` when the parameter count is known from elsewhere
+    (the Hub's safetensors index); otherwise it is estimated from the config.
+    """
+    if not isinstance(config, dict):
+        raise ModelConfigError(
+            f"**{model_id}** has an unexpected `config.json`.",
+            "Only standard transformers models are supported.",
+        )
+
+    config, warnings = _unwrap_text_config(config)
+
+    num_layers = _pick(config, "num_layers")
+    hidden_size = _pick(config, "hidden_size")
+    num_heads = _pick(config, "num_attention_heads")
+    missing = [
+        name
+        for name, value in (
+            ("number of layers", num_layers),
+            ("hidden size", hidden_size),
+            ("attention heads", num_heads),
+        )
+        if not isinstance(value, int) or value <= 0
+    ]
+    if missing:
+        raise ModelConfigError(
+            f"**{model_id}** does not expose the fields WattGPU needs "
+            f"({', '.join(missing)}).",
+            "This is usually an embedding model, an adapter, a quantised "
+            "re-upload, or a non-transformer architecture. Try the original "
+            "decoder-only base repository instead.",
+        )
+
+    kv_heads = _pick(config, "num_key_value_heads")
+    if not isinstance(kv_heads, int) or kv_heads <= 0:
+        kv_heads = num_heads  # no GQA/MQA: every head has its own K/V
+
+    if total_b_params is None:
+        estimate = _estimate_b_params(config)
+        if estimate is None:
+            raise ModelConfigError(
+                f"Could not determine the parameter count for **{model_id}**.",
+                "The repository publishes neither a safetensors index nor enough "
+                "of `config.json` to estimate it.",
+            )
+        total_b_params = estimate
+        params_source = params_source or "estimated from config"
+
+    architectures = list(config.get("architectures") or [])
+    if architectures and not any(
+        a.endswith(DECODER_ARCHITECTURE_SUFFIXES) for a in architectures
+    ):
+        # A bare `*Model` is an encoder without a language-modelling head.
+        definitely_not_generative = any(
+            a.endswith(NON_GENERATIVE_ARCHITECTURE_SUFFIXES) or a.endswith("Model")
+            for a in architectures
+        )
+        if definitely_not_generative:
+            raise UnsupportedModelError(
+                f"Not supported: **{model_id}** is not a generative model "
+                f"(`{', '.join(architectures)}`).",
+                "WattGPU estimates the cost of generating tokens one at a time. "
+                "Embedding, reranking and classification models run a single "
+                "forward pass instead, so inter-token latency does not apply and "
+                "their power profile is different.",
+            )
+        warnings.append(
+            f"`{', '.join(architectures)}` is not a recognised decoder-only "
+            "architecture. WattGPU was profiled on autoregressive LLMs, so treat "
+            "this estimate as indicative only."
+        )
+
+    _reject_if_unsupported(model_id, config)
+    is_moe = False
+
+    return LLMInfo(
+        model_id=model_id,
+        model_type=str(config.get("model_type") or "unknown"),
+        num_layers=int(num_layers),
+        hidden_size=int(hidden_size),
+        num_attention_heads=int(num_heads),
+        num_key_value_heads=int(kv_heads),
+        total_b_params=float(total_b_params),
+        params_source=params_source,
+        architectures=architectures,
+        max_position_embeddings=config.get("max_position_embeddings"),
+        torch_dtype=config.get("torch_dtype") or config.get("dtype"),
+        is_moe=is_moe,
+        warnings=warnings,
+    )
+
+
+def fetch_llm_info(model_id: str, token: str | None = None) -> LLMInfo:
+    """Look up a model on the Hugging Face Hub and extract WattGPU's features.
+
+    `token` is an optional per-request Hugging Face token, used for this call
+    and then dropped. Raises a `WattGPUError` subclass with a displayable
+    message on any failure.
+    """
+    model_id = (model_id or "").strip().strip("/")
+    if not model_id:
+        raise ModelNotFoundError(
+            "No model identifier given.",
+            "Enter a Hugging Face model id, for example `Qwen/Qwen3-4B`.",
+        )
+    if model_id.startswith(("http://", "https://")):
+        model_id = model_id.split("huggingface.co/", 1)[-1].split("/tree/", 1)[0]
+    if model_id.count("/") != 1:
+        raise ModelNotFoundError(
+            f"**{model_id}** is not a valid model identifier.",
+            "Use the `owner/name` form, for example `mistralai/Mistral-7B-Instruct-v0.3`.",
+        )
+
+    config = _get_json(f"{HF_ENDPOINT}/{model_id}/raw/main/config.json", model_id, token)
+
+    # Parameter count: prefer the Hub's safetensors index over an estimate.
+    total_b_params: float | None = None
+    params_source = ""
+    extra_warnings: list[str] = []
+    try:
+        info = _get_json(f"{HF_ENDPOINT}/api/models/{model_id}", model_id, token)
+
+        # The Hub's declared task is the only reliable way to spot an embedding
+        # or reranking model that is built on a causal-LM backbone.
+        pipeline_tag = (info or {}).get("pipeline_tag")
+        described_as = NON_GENERATIVE_PIPELINE_TAGS.get(pipeline_tag)
+        if described_as:
+            raise UnsupportedModelError(
+                f"Not supported: **{model_id}** is {described_as}, not a "
+                "text-generation model.",
+                "WattGPU estimates the cost of generating tokens one at a time. "
+                "Embedding, reranking and classification models run a single "
+                "forward pass instead, so inter-token latency does not apply and "
+                "their power profile is different.\n\n"
+                f"The Hub lists this repository under `{pipeline_tag}`.",
+            )
+
+        total = ((info or {}).get("safetensors") or {}).get("total")
+        if isinstance(total, (int, float)) and total > 0:
+            total_b_params = float(total) / 1e9
+            params_source = "safetensors index"
+    except NetworkError:
+        extra_warnings.append(
+            "Could not read the safetensors index; the parameter count is estimated."
+        )
+
+    llm = llm_info_from_config(model_id, config, total_b_params, params_source)
+    llm.warnings = [*extra_warnings, *llm.warnings]
+    return llm
+
+
+def search_models(query: str, limit: int = 20, token: str | None = None) -> list[str]:
+    """Search the Hub for text-generation models matching `query`.
+
+    Used to drive the live search box. Returns an empty list rather than
+    raising: a failed autocomplete should never interrupt typing.
+    """
+    query = (query or "").strip()
+    if len(query) < 2:
+        return []
+
+    url = (
+        f"{HF_ENDPOINT}/api/models"
+        f"?search={urllib.parse.quote(query)}"
+        "&filter=text-generation&sort=downloads&direction=-1"
+        f"&limit={int(limit)}"
+    )
+    try:
+        results = _get_json(url, query, token)
+    except WattGPUError:
+        return []
+    if not isinstance(results, list):
+        return []
+    return [m["id"] for m in results if isinstance(m, dict) and m.get("id")]

wattgpu_demo/predictor.py

@@ -0,0 +1,450 @@
+"""Serve WattGPU predictions, with a certainty tier attached to each one.
+
+The tier says how far the query sits from the models' training data, which is
+the single most important caveat on any prediction here:
+
+  green  — the LLM and the GPU were both profiled
+  yellow — an unprofiled LLM on a profiled GPU
+  orange — a profiled LLM on an unprofiled GPU
+  red    — neither was profiled; not supported
+
+The red case is refused rather than guessed at. The paper validates
+generalisation along one axis at a time (leave-one-LLM-out and
+leave-one-GPU-out), so there is no measured basis for extrapolating along both
+at once.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import os
+from dataclasses import dataclass, field
+
+import joblib
+import numpy as np
+import pandas as pd
+
+from .emissions import (
+    DEFAULT_CARBON_INTENSITY_G_PER_KWH,
+    clean_carbon_intensity,
+    co2_per_hour_g,
+    co2_per_million_tokens_g,
+    energy_per_hour_wh,
+    energy_per_million_tokens_wh,
+)
+from .errors import InsufficientMemoryError, WattGPUError
+from .features import (
+    ITL_FEATURES,
+    POWER_FEATURES,
+    SCENARIOS,
+    SCENARIOS_WITH_PER_USER_LATENCY,
+    add_derived_features,
+)
+from .gpu_db import GPUDatabase, GPUInfo
+from .hf_models import CONTACT_URL, LLMInfo, fetch_llm_info
+
+DEFAULT_MODEL_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+                                 "data", "models")
+
+# Bytes per parameter at FP16, the precision every profiled run used.
+BYTES_PER_PARAM = 2
+
+# vLLM's default `--gpu-memory-utilization`. The rest of the card is left to the
+# CUDA context and fragmentation, so it is not available for weights or KV cache.
+# The paper's own feature engineering uses the same 0.9 factor.
+VLLM_MEMORY_UTILISATION = 0.9
+
+
+@dataclass(frozen=True)
+class Certainty:
+    """A certainty tier. What each one means is explained once in the UI, so
+    only the short label travels with a prediction.
+
+    `tier` is the band shown to the user. `accuracy_key` is the validation
+    protocol whose measured error backs the estimate. The two usually match,
+    but not always: an estimate can sit in a better band than its coverage
+    alone suggests when the measurements say the extra extrapolation costs
+    almost nothing. The error reported always follows `accuracy_key`, so the
+    number stays the one that was actually measured for the situation.
+    """
+
+    tier: str
+    label: str
+    accuracy_key: str
+
+
+CERTAINTY_TIERS = {
+    "green": Certainty("green", "High confidence", "green"),
+    "yellow": Certainty("yellow", "Moderate confidence — LLM not in training data",
+                        "yellow"),
+    "orange": Certainty("orange", "Lower confidence — GPU not in training data",
+                        "orange"),
+    # Neither side measured. Under server load the double holdout lands within a
+    # couple of points of leave-one-GPU-out (power 15.1% vs 13.0%, latency 8.6%
+    # vs 8.5%), so it earns the same band. Offline it does not: latency degrades
+    # from 24.9% to 36.2%, which is a genuinely weaker estimate.
+    "neither_server": Certainty("orange", "Lower confidence — neither in training data",
+                                "red"),
+    "neither_offline": Certainty("red", "Low confidence — neither in training data",
+                                 "red"),
+}
+
+
+@dataclass
+class Prediction:
+    """A power and latency prediction with its provenance and caveats."""
+
+    llm: LLMInfo
+    gpu: GPUInfo
+    scenario: str
+    certainty: Certainty
+    power_w: float
+    power_fraction_of_tdp: float
+    power_mdape: float | None
+    itl_s: float | None
+    itl_mdape: float | None
+    itl_unavailable_reason: str | None = None
+    carbon_intensity_g_per_kwh: float = DEFAULT_CARBON_INTENSITY_G_PER_KWH
+    warnings: list[str] = field(default_factory=list)
+    notes: list[str] = field(default_factory=list)
+
+    @property
+    def tokens_per_second(self) -> float | None:
+        """Aggregate generation throughput, defined only for offline batches.
+
+        Offline the model's target is wall-clock time per generated token over
+        the whole batch, so its inverse is the batch's token throughput exactly
+        -- no assumption about batching required.
+
+        Under server load the target is one user's inter-token latency, and its
+        inverse would be that user's token rate rather than the system's. There
+        is no way to recover system throughput from it without knowing how many
+        requests the server runs at once, which is what WattGPU+ adds.
+        """
+        if self.latency_is_per_user or not self.itl_s:
+            return None
+        return 1.0 / self.itl_s
+
+    @property
+    def latency_is_per_user(self) -> bool:
+        """Whether `itl_s` is the gap one user sees between tokens.
+
+        True under light and moderate load, where the dataset timed individual
+        requests. False under saturation, where it timed only the batch as a
+        whole, so `itl_s` is wall-clock time per token amortised over every
+        request in flight -- a system capacity figure, not a user-facing one.
+        """
+        return self.scenario in SCENARIOS_WITH_PER_USER_LATENCY
+
+    @property
+    def energy_per_token_j(self) -> float | None:
+        """Energy per generated token, defined only under saturation.
+
+        There `itl_s` is wall time per token across the whole batch, so power
+        times that time is the energy the GPU spent per token. Under light or
+        moderate load `itl_s` is one user's latency while other requests share
+        the GPU, and the product would not be energy attributable to a token.
+        """
+        if self.latency_is_per_user or not self.itl_s:
+            return None
+        return self.power_w * self.itl_s
+
+    @property
+    def energy_per_million_tokens_wh(self) -> float | None:
+        """Watt-hours per million generated tokens.
+
+        Provider- and region-independent, and derived only from the two
+        quantities the models predict, so it needs no further assumptions.
+        """
+        energy = self.energy_per_token_j
+        return None if energy is None else energy_per_million_tokens_wh(energy)
+
+    @property
+    def co2_per_million_tokens_g(self) -> float | None:
+        """Grams of CO2e per million tokens at the chosen grid intensity."""
+        energy = self.energy_per_million_tokens_wh
+        if energy is None:
+            return None
+        return co2_per_million_tokens_g(energy, self.carbon_intensity_g_per_kwh)
+
+    @property
+    def energy_per_hour_wh(self) -> float | None:
+        """Wall-socket watt-hours for an hour of serving.
+
+        Reported under server load, where the useful question is what the
+        deployment costs to keep running rather than what a token costs: the
+        GPU is idle much of the time, so per-token figures would be dominated
+        by how busy it happens to be. Unlike the per-token figure this is a
+        facility-level number -- it grosses the board power up to the whole
+        host and applies the data centre's overhead.
+        """
+        if not self.latency_is_per_user:
+            return None
+        return energy_per_hour_wh(self.power_w)
+
+    @property
+    def co2_per_hour_g(self) -> float | None:
+        """Grams of CO2e for an hour of serving at the chosen grid intensity."""
+        energy = self.energy_per_hour_wh
+        if energy is None:
+            return None
+        return co2_per_hour_g(energy, self.carbon_intensity_g_per_kwh)
+
+
+class WattGPUPredictor:
+    """Loads the trained pipelines and answers prediction queries."""
+
+    def __init__(self, model_dir: str = DEFAULT_MODEL_DIR, gpu_db: GPUDatabase | None = None) -> None:
+        meta_path = os.path.join(model_dir, "meta.json")
+        if not os.path.exists(meta_path):
+            raise WattGPUError(
+                "The trained WattGPU models are missing.",
+                f"Expected them in `{model_dir}`. Run `python scripts/train_models.py` first.",
+            )
+        with open(meta_path) as fh:
+            self.meta = json.load(fh)
+
+        # Architectures of the profiled LLMs, taken from the paper's data. Using
+        # these instead of the Hub keeps green-tier predictions network-free and
+        # makes licence-gated models work without a token.
+        cache_path = os.path.join(model_dir, "profiled_llms.json")
+        self._profiled_llms: dict[str, dict] = {}
+        if os.path.exists(cache_path):
+            with open(cache_path) as fh:
+                self._profiled_llms = json.load(fh)
+
+        # Architectures of licence-gated models, read from public mirrors by
+        # `scripts/cache_gated_models.py`. Lets the demo answer for Llama and
+        # Gemma without a maintainer's token standing in for every visitor.
+        self._gated_llms: dict[str, dict] = {}
+        gated_path = os.path.join(
+            os.path.dirname(os.path.dirname(os.path.abspath(__file__))),
+            "data", "gated_llms.json")
+        if os.path.exists(gated_path):
+            with open(gated_path) as fh:
+                self._gated_llms = json.load(fh)
+
+        self.power_model = joblib.load(os.path.join(model_dir, "power.joblib"))
+        self.itl_model = joblib.load(os.path.join(model_dir, "itl.joblib"))
+        self.gpu_db = gpu_db or GPUDatabase()
+
+        self.seen_models = {m.lower() for m in self.meta["seen_models"]}
+        self.seen_gpus = set(self.meta["seen_gpus"])
+        self._accuracy = self.meta.get("tier_accuracy_mdape", {})
+        self._itl_is_log = "itl" in self.meta.get("log_transformed_targets", [])
+
+    # -- catalogue ---------------------------------------------------------
+
+    @property
+    def profiled_models(self) -> list[str]:
+        """Models the training data actually covers."""
+        return sorted(self.meta["seen_models"])
+
+    @property
+    def known_models(self) -> list[str]:
+        """Models resolvable without a Hub call: measured, plus gated mirrors.
+
+        These are what the dropdown offers before the user types. Being here
+        says only that the architecture is known offline, not that the model
+        was measured -- the certainty tier still follows coverage.
+        """
+        return sorted({*self.meta["seen_models"], *self._gated_llms})
+
+    @property
+    def profiled_gpus(self) -> list[str]:
+        return sorted(self.meta["seen_gpus"])
+
+    @property
+    def all_gpus(self) -> list[str]:
+        """Profiled GPUs first, then every other GPU in the database."""
+        profiled = self.profiled_gpus
+        rest = sorted(set(self.gpu_db.names) - set(profiled))
+        return profiled + rest
+
+    # -- certainty ---------------------------------------------------------
+
+    def classify(self, llm: LLMInfo, gpu: GPUInfo, scenario: str) -> Certainty:
+        """Pick the certainty tier for a query.
+
+        The scenario matters only for the hardest case: extrapolating on both
+        axes at once costs little under server load but a lot offline, so the
+        band follows the measurements rather than the coverage alone.
+        """
+        seen_llm = llm.model_id.lower() in self.seen_models
+        seen_gpu = gpu.gpu_db_name in self.seen_gpus
+
+        if seen_llm and seen_gpu:
+            return CERTAINTY_TIERS["green"]
+        if seen_gpu:
+            return CERTAINTY_TIERS["yellow"]
+        if seen_llm:
+            return CERTAINTY_TIERS["orange"]
+        # Neither measured, validated by the double holdout in train_models.py.
+        return CERTAINTY_TIERS[
+            "neither_offline" if scenario == "offline" else "neither_server"]
+
+    def _mdape(self, target: str, accuracy_key: str, scenario: str) -> float | None:
+        """The measured error for this situation, whatever band it is shown in."""
+        regime = "offline" if scenario == "offline" else "server"
+        return self._accuracy.get(target, {}).get(accuracy_key, {}).get(regime)
+
+    # -- prediction --------------------------------------------------------
+
+    def _feature_row(self, llm: LLMInfo, gpu: GPUInfo, scenario: str) -> pd.DataFrame:
+        row = pd.DataFrame([{
+            "scenario": scenario,
+            "model_type": llm.model_type,
+            "total_b_params": llm.total_b_params,
+            "hidden_size": llm.hidden_size,
+            "num_attention_heads": llm.num_attention_heads,
+            "num_key_value_heads": llm.num_key_value_heads,
+            "num_layers": llm.num_layers,
+            "memory_bandwidth_gb_s": gpu.memory_bandwidth_gb_s,
+            "memory_size_gb": gpu.memory_size_gb,
+            "memory_type": gpu.memory_type,
+            "base_clock_mhz": gpu.base_clock_mhz,
+            "boost_clock_mhz": gpu.boost_clock_mhz,
+            "transistor_count_m": gpu.transistor_count_m,
+            "release_year": gpu.release_year,
+            "tflops_16b": gpu.tflops_16b,
+        }])
+        return add_derived_features(row)
+
+    @staticmethod
+    def _lookup(cache: dict[str, dict], key: str) -> dict | None:
+        return cache.get(key) or next(
+            (v for k, v in cache.items() if k.lower() == key.lower()), None)
+
+    def _resolve_llm(self, model_id: str, token: str | None = None) -> LLMInfo:
+        """Resolve an LLM from the local caches, falling back to the Hub.
+
+        Measured models come from the profiled cache, licence-gated ones from
+        the mirrored cache, and everything else from a live Hub lookup. Only
+        the profiled cache implies the model is in the training data; the
+        gated cache is an architecture lookup and nothing more, so those models
+        still land in the tier their coverage earns.
+        """
+        key = (model_id or "").strip().strip("/")
+
+        profiled = self._lookup(self._profiled_llms, key)
+        if profiled is not None:
+            return LLMInfo(model_id=key, params_source="profiled dataset", **profiled)
+
+        gated = self._lookup(self._gated_llms, key)
+        if gated is not None:
+            entry = {k: v for k, v in gated.items() if k != "source_mirror"}
+            return LLMInfo(model_id=key, params_source="published config", **entry)
+
+        return fetch_llm_info(key, token)
+
+    @staticmethod
+    def _check_fits_in_memory(llm: LLMInfo, gpu: GPUInfo) -> float:
+        """Refuse pairs whose FP16 weights cannot fit, and return spare memory.
+
+        Returns the GB left for the KV cache and activations once the weights
+        are loaded, following the paper's own budget: vLLM claims 90% of the
+        card, and the weights come out of that.
+        """
+        weights_gb = llm.total_b_params * BYTES_PER_PARAM
+        usable_gb = gpu.memory_size_gb * VLLM_MEMORY_UTILISATION
+        spare_gb = usable_gb - weights_gb
+        if spare_gb > 0:
+            return spare_gb
+
+        # Smallest card that could hold the weights inside vLLM's 90% budget.
+        needed_gb = math.ceil(weights_gb / VLLM_MEMORY_UTILISATION)
+        raise InsufficientMemoryError(
+            f"Does not fit: **{llm.model_id}** needs more memory than "
+            f"**{gpu.gpu_db_name}** has.",
+            f"Its {llm.total_b_params:.1f} B parameters take about "
+            f"{weights_gb:.1f} GB at FP16, but only about {usable_gb:.1f} GB of the "
+            f"card's {gpu.memory_size_gb:.0f} GB is usable for a model — vLLM leaves "
+            "roughly 10% to the CUDA context — and the KV cache still has to come "
+            "out of what is left.\n\n"
+            "Running this would need quantisation or several GPUs, neither of which "
+            "WattGPU covers, so no estimate is given. Try a smaller model, or a GPU "
+            f"with at least {needed_gb} GB.",
+        )
+
+    def predict(self, model_id: str, gpu_name: str, scenario: str,
+                carbon_intensity: float | str | None = None,
+                hf_token: str | None = None) -> Prediction:
+        """Predict mean power draw and inter-token latency for one deployment.
+
+        Raises a `WattGPUError` subclass, with a message meant for display, if
+        the LLM or GPU cannot be resolved or the combination is unsupported.
+        """
+        if scenario not in SCENARIOS:
+            raise WattGPUError(
+                f"Unknown scenario **{scenario}**.",
+                f"Choose one of: {', '.join(SCENARIOS)}.",
+            )
+
+        llm = self._resolve_llm(model_id, hf_token)
+        gpu = self.gpu_db.get(gpu_name)
+        spare_memory_gb = self._check_fits_in_memory(llm, gpu)
+        certainty = self.classify(llm, gpu, scenario)
+
+        features = self._feature_row(llm, gpu, scenario)
+        warnings = [*llm.warnings, *gpu.warnings]
+        notes: list[str] = []
+
+        # For a model we never measured, everything WattGPU knows about it came
+        # from parsing `config.json`. Mixture-of-experts and quantised models are
+        # rejected on that basis, and the detection is good but not infallible --
+        # a repository can quantise without recording it. Say so, once.
+        if certainty.accuracy_key == "red":
+            notes.append(
+                "Neither side is in the training data, so this extrapolates on both "
+                "axes at once. The error shown is measured for exactly that case, by "
+                "retraining with this GPU and this model both removed. "
+                f"[Ask us]({CONTACT_URL}) if you need a measured figure for this pair."
+            )
+
+        if llm.params_source != "profiled dataset":
+            notes.append(
+                "Architecture read from `config.json` on the Hub. WattGPU covers "
+                "dense FP16 models only — mixture-of-experts and quantised models "
+                "are detected and refused, but one that declares neither in its "
+                "config could slip through."
+            )
+
+        # Power draw is predicted as a fraction of TDP, then denormalised.
+        fraction = float(self.power_model.predict(features[POWER_FEATURES])[0])
+        power_w = fraction * gpu.thermal_design_power_w
+
+        itl_s: float | None = None
+        itl_reason: str | None = None
+        if gpu.tflops_16b is None:
+            itl_reason = (
+                f"Latency needs the FP16 tensor throughput of {gpu.gpu_db_name}, "
+                "which is unknown."
+            )
+        else:
+            raw = float(self.itl_model.predict(features[ITL_FEATURES])[0])
+            itl_s = float(np.exp(raw)) if self._itl_is_log else raw
+
+        if spare_memory_gb < 2.0:
+            warnings.append(
+                f"The weights fit, but leave only about {spare_memory_gb:.1f} GB for the "
+                "KV cache, so the server would handle very few requests at once. Under "
+                "offline / batch that means far less batching than the measurements had, "
+                "and the estimate will be optimistic."
+            )
+
+        return Prediction(
+            llm=llm,
+            gpu=gpu,
+            scenario=scenario,
+            certainty=certainty,
+            power_w=power_w,
+            power_fraction_of_tdp=fraction,
+            power_mdape=self._mdape("power", certainty.accuracy_key, scenario),
+            itl_s=itl_s,
+            itl_mdape=self._mdape("itl", certainty.accuracy_key, scenario),
+            itl_unavailable_reason=itl_reason,
+            carbon_intensity_g_per_kwh=clean_carbon_intensity(carbon_intensity),
+            warnings=warnings,
+            notes=notes,
+        )