Rent a cloud GPU by the hour to run models your laptop can't

# /// script
# requires-python = ">=3.10"
# dependencies = []
# ///
"""Which rented GPU fits this model, and what will it cost?

Give it the size of the model you want to run, and it lists the cards with
enough VRAM, cheapest first, with the price per GB of VRAM and the cost of
your session.

    uv run gpu_fit.py --model-gb 19            # an Ollama download size (gemma4:31b)
    uv run gpu_fit.py --params 14 --engine vllm   # a Hugging Face model for vLLM (Qwen3-14B)
    uv run gpu_fit.py --model-gb 43 --hours 3 --cloud community   # llama3.3:70b

The prices below come from the RunPod pricing page and the Vast.ai
marketplace. They change (Vast.ai's every hour), so check the console
before you rent, and edit the PRICES table to update them.
"""

from __future__ import annotations

import argparse

# name, VRAM in GB, RunPod Secure Cloud $/hr, RunPod Community Cloud $/hr,
# Vast.ai on-demand median $/hr (None = not listed)
PRICES = [
    ("RTX A5000", 24, 0.27, 0.16, None),
    ("RTX 3090", 24, 0.50, 0.22, 0.22),
    ("L4", 24, 0.59, 0.44, None),
    ("RTX 4090", 24, 0.89, 0.34, 0.44),
    ("RTX 5090", 32, 1.19, 0.69, 0.61),
    ("A40", 48, 0.59, 0.35, None),
    ("RTX A6000", 48, 0.59, 0.33, 0.40),
    ("RTX 6000 Ada", 48, 0.99, 0.74, None),
    ("L40S", 48, 1.09, 0.79, 0.67),
    ("A100 80GB", 80, 1.79, 1.19, 0.99),
    ("H100 PCIe", 80, 2.89, 1.99, None),
    ("H100 SXM", 80, 3.99, 2.69, 2.27),
    ("H100 NVL", 94, 3.19, 2.59, None),
    ("RTX PRO 6000", 96, 2.49, 1.69, None),
]

RUNPOD_IDLE_VOLUME = 0.20  # $/GB/month for a stopped pod's volume disk (RunPod pricing page)


def vram_needed(w: float, engine: str) -> float:
    if engine == "vllm":
        # vLLM claims 92% of the card by default (--gpu-memory-utilization 0.92)
        # and needs room inside that for the KV cache. 4GB covers about 16k tokens
        # of context on a 14B model.
        return (w + 4) / 0.92
    # Ollama: weights plus about 10% for its default 4,096-token context and CUDA.
    return w * 1.1


def weights_gb(args: argparse.Namespace) -> float:
    if args.model_gb:
        return args.model_gb
    # parameters (billions) x bytes per parameter. 16-bit = 2 bytes, so 14B -> 28GB.
    return args.params * args.bits / 8


def main() -> None:
    ap = argparse.ArgumentParser(description="Find the cheapest rented GPU that fits a model.")
    size = ap.add_mutually_exclusive_group(required=True)
    size.add_argument("--model-gb", type=float, help="model file size in GB (Ollama shows it on each tag)")
    size.add_argument("--params", type=float, help="parameters in billions, for example 14 for a 14B model")
    ap.add_argument("--bits", type=float, default=16, help="bits per weight: 16 for original Hugging Face files, about 4.5 for Q4 GGUF")
    ap.add_argument("--engine", choices=["ollama", "vllm"], default="ollama", help="what will serve the model")
    ap.add_argument("--hours", type=float, default=1, help="how long you'll rent it for")
    ap.add_argument("--cloud", choices=["secure", "community", "vast"], default="secure", help="which price to rank by")
    args = ap.parse_args()

    w = weights_gb(args)
    need = vram_needed(w, args.engine)
    # model files + room for the runtime: vLLM's own install (PyTorch and CUDA
    # libraries) lives on the volume too, and is far bigger than Ollama's.
    disk = round(w * 1.1 + (20 if args.engine == "vllm" else 10))
    col = {"secure": 2, "community": 3, "vast": 4}[args.cloud]

    print(f"Model weights: {w:.1f} GB  ->  needs about {need:.1f} GB of VRAM with {args.engine}")
    print(f"Disk to ask for: about {disk} GB (stopped, that volume costs ${disk * RUNPOD_IDLE_VOLUME:.2f}/month on RunPod)\n")

    fits = [p for p in PRICES if p[1] >= need and p[col] is not None]
    if not fits:
        print("Nothing on one card fits. Use a smaller quantisation (a Q4 tag), a smaller model, or 2+ GPUs.")
        return
    fits.sort(key=lambda p: p[col])

    print(f"{'GPU':<14}{'VRAM':>6}{'$/hr':>8}{'$/GB/hr':>10}{'session':>10}   ranked by: {args.cloud}")
    for p in fits:
        price = p[col]
        print(f"{p[0]:<14}{p[1]:>4}GB{price:>8.2f}{price / p[1]:>10.4f}{price * args.hours:>10.2f}")
    best = fits[0]
    print(f"\nCheapest fit: {best[0]} ({best[1]}GB) at ${best[col]:.2f}/hr. Check the console for today's price.")


if __name__ == "__main__":
    main()