Machine Learning & AI Engineering

Trapezoidal area under the ROC curve from your (FPR, TPR) operating points — the threshold-independent ranking score.

Find the probability cutoff that minimizes expected cost given your false-positive and false-negative penalties.

Cluster cohesion vs separation for one point — the building block of the silhouette metric for choosing K.

Agreement between two clusterings (or clustering vs ground truth), corrected for chance — from pair counts.

Weighted gap between predicted confidence and actual accuracy across bins — the standard model-calibration metric.

Fraction of samples whose true label is among the model's top-K predictions — the ImageNet-style metric.

Percentage forecast error and its symmetric variant — the demand/sales forecasting accuracy metrics, with their pitfalls.

Scale-free forecast accuracy benchmarked against a naive forecast — the metric that works on any series, zeros included.

Information shared between two clusterings or label sets, normalized to 0–1 — a chance-aware clustering metric.

Hit rate, catalog coverage and an aggregate-diversity view for recommendation systems — beyond just accuracy.

SQuAD-style exact-match and token-overlap F1 between a predicted answer and the reference — the QA evaluation pair.

Speech-recognition and OCR accuracy — substitutions, deletions and insertions per reference word/character.

Compute accuracy, precision, recall, F1, specificity, MCC and more for classification metrics from TP/FP/FN/TN counts.

Compute accuracy, precision, recall, F1, specificity, MCC and more for spam filter from TP/FP/FN/TN counts.

Compute accuracy, precision, recall, F1, specificity, MCC and more for medical diagnostic test from TP/FP/FN/TN counts.

Compute accuracy, precision, recall, F1, specificity, MCC and more for fraud detection from TP/FP/FN/TN counts.

Compute accuracy, precision, recall, F1, specificity, MCC and more for customer churn prediction from TP/FP/FN/TN counts.

Compute accuracy, precision, recall, F1, specificity, MCC and more for sentiment analysis from TP/FP/FN/TN counts.

Compute accuracy, precision, recall, F1, specificity, MCC and more for image classification (binary) from TP/FP/FN/TN counts.

Compute accuracy, precision, recall, F1, specificity, MCC and more for manufacturing defect detection from TP/FP/FN/TN counts.

Weighted harmonic mean of precision and recall — tune β to favor recall (β>1) or precision (β<1) for your problem.

Inter-rater / model-vs-label agreement corrected for chance — the metric for labeling quality and annotation studies.

Aggregate per-class precision and recall into macro, micro and weighted F1 — and see why they disagree on imbalanced data.

Turn a test's sensitivity and specificity into predictive values at any prevalence — the base-rate calculator.

Average of sensitivity and specificity — the imbalance-proof accuracy, plus Youden's J for optimal threshold selection.

Paste predicted vs actual values and get MAE, MSE, RMSE, MAPE and R² — every regression error metric at once.

Binary cross-entropy for predicted probabilities vs true labels — the loss that punishes confident wrong answers.

Mean squared error of probability forecasts — the calibration metric for weather, risk and probabilistic models.

Top-K ranking quality for search, recommendations and RAG retrieval — relevance of the results you actually show.

Average of 1/rank of the first correct answer — the metric for QA, autocomplete and single-answer retrieval.

Normalized Discounted Cumulative Gain — the gold-standard ranking metric with graded relevance and position discounting.

Average precision across recall levels for binary relevance — the IR and object-detection ranking standard.

Angle-based similarity between two vectors — the core of semantic search, embeddings and recommendation.

Compute L1, L2, L∞ and general Lp distances between two vectors — and see how the metric changes the 'nearest' point.

Minimum insert/delete/substitute edits between two strings — plus normalized similarity for fuzzy matching and WER.

N-gram precision with brevity penalty for machine translation and generation — the classic MT metric, computed live.

ROUGE-N and ROUGE-L recall/precision/F1 for summarization — how much of the reference your summary covers.

Convert a language model's cross-entropy loss (nats or bits) to perplexity — the 'effective branching factor' of predictions.

Intersection-over-Union and Dice/F1 overlap for object detection and image segmentation — from areas or set counts.

Estimate GPU memory to run Llama 3 8B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run Llama 3 70B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run Llama 3.1 405B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run Llama 2 7B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run Mistral 7B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run Mixtral 8x7B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run Qwen2.5 7B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run Qwen2.5 72B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run Phi-3 Mini 3.8B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run Gemma 2 9B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run Gemma 2 27B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run DeepSeek-V3 671B (MoE) — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run StableLM 2 1.6B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Estimate GPU memory to run Command R 35B — weights, KV cache and overhead at FP16/INT8/INT4, with a fits-on-which-GPU verdict.

Compare full fine-tuning vs LoRA vs QLoRA memory for Llama 3 8B — weights, gradients, optimizer states and activations.

Compare full fine-tuning vs LoRA vs QLoRA memory for Llama 3 70B — weights, gradients, optimizer states and activations.

Compare full fine-tuning vs LoRA vs QLoRA memory for Mistral 7B — weights, gradients, optimizer states and activations.

Compare full fine-tuning vs LoRA vs QLoRA memory for Qwen2.5 7B — weights, gradients, optimizer states and activations.

Compare full fine-tuning vs LoRA vs QLoRA memory for Qwen2.5 72B — weights, gradients, optimizer states and activations.

Compare full fine-tuning vs LoRA vs QLoRA memory for Phi-3 Mini 3.8B — weights, gradients, optimizer states and activations.

Compare full fine-tuning vs LoRA vs QLoRA memory for Gemma 2 9B — weights, gradients, optimizer states and activations.

Compare full fine-tuning vs LoRA vs QLoRA memory for Gemma 2 27B — weights, gradients, optimizer states and activations.

Compare full fine-tuning vs LoRA vs QLoRA memory for Llama 2 7B — weights, gradients, optimizer states and activations.

Compare full fine-tuning vs LoRA vs QLoRA memory for Mixtral 8x7B — weights, gradients, optimizer states and activations.

Per-token and total key-value cache memory for Llama 3 8B across context length, batch size and cache precision.

Per-token and total key-value cache memory for Llama 3 70B across context length, batch size and cache precision.

Per-token and total key-value cache memory for Llama 3.1 405B across context length, batch size and cache precision.

Per-token and total key-value cache memory for Mistral 7B across context length, batch size and cache precision.

Per-token and total key-value cache memory for Qwen2.5 7B across context length, batch size and cache precision.

Per-token and total key-value cache memory for Qwen2.5 72B across context length, batch size and cache precision.

Per-token and total key-value cache memory for Gemma 2 9B across context length, batch size and cache precision.

Per-token and total key-value cache memory for Llama 2 7B across context length, batch size and cache precision.

Per-token and total key-value cache memory for DeepSeek-V3 671B (MoE) across context length, batch size and cache precision.

Per-token and total key-value cache memory for Command R 35B across context length, batch size and cache precision.

File size and RAM needed for any model in llama.cpp's most popular quant — Q4_K_M.

Size a Q5_K_M GGUF — the 'quality first' k-quant — for any parameter count, with RAM headroom.

Near-lossless 8-bit GGUF sizing — when you want FP16 quality at half the memory.

Extreme-compression sizing: what a 2-bit k-quant really costs in GB and what you give up.

VRAM footprint of GPTQ-quantized checkpoints (group size 128) for GPU serving.

Activation-aware 4-bit (AWQ) checkpoint sizing for vLLM/TensorRT-LLM deployments.

Size models stored in FP8 (E4M3) — the H100-era serving format — with per-tensor scale overhead.

Count parameters of a decoder-only transformer from layers, hidden size, FFN width, vocab and GQA heads.

Parameters of one multi-head / GQA / MQA attention block — Wq, Wk, Wv, Wo broken out.

Parameters and memory of a transformer FFN block — classic GELU vs gated SwiGLU, any width multiple.

Vocab × hidden embedding-table cost — tied vs untied, plus the memory bill at FP16/INT8.

Forward-pass compute per token (≈2P) plus attention's context-dependent term — and tokens/s on your GPU.

Total training compute C = 6·N·D, the Chinchilla-optimal token count, and your over/under-training ratio.

Turn a training budget (params × tokens) into GPU-hours, wall-clock days and rental dollars at your MFU.

Measure how efficiently your training run uses its GPUs — observed tokens/s vs theoretical peak.

Quadratic cost of self-attention: score and value FLOPs for a full sequence, vs the linear projection cost.

Total vs active parameters of a mixture-of-experts transformer — experts, top-k routing and shared blocks.

Output H×W of a 2-D convolution from input size, kernel, stride, padding and dilation — with the floor-division gotcha.

Weights and biases of a conv layer — standard, depthwise and depthwise-separable compared side by side.

Multiply-adds of a convolutional layer over a full feature map — see why early layers dominate compute.

Output length of 1-D convolutions over audio samples, sensor streams or token sequences — wav2vec-style stacks included.

Output D×H×W of 3-D convolutions for video clips and CT/MRI volumes — with voxel/frame budgeting.

Upsampling output size for deconvolutions in GANs, U-Nets and segmentation decoders — incl. output_padding.

Effective kernel size and stacked receptive field of dilated (atrous) convolutions — WaveNet/DeepLab style.

Exact padding to preserve (or precisely control) feature-map size for any kernel/stride/dilation — incl. asymmetric TF cases.

Max/avg pooling output sizes — with ceil_mode, the overlapping-pool case, and global pooling explained.

Bytes of any tensor from its shape and dtype — parse '64, 3, 224, 224' and compare FP32/BF16/INT8/INT4.

Shape check + exact FLOPs/memory of (M×K)·(K×N) — and whether the matmul is compute- or bandwidth-bound on your GPU.

Check whether two tensor shapes broadcast together and get the result shape — with the rule applied step by step.

Verify a reshape preserves the element count, solve the -1 wildcard, and learn when view() fails but reshape() works.

Parameters, FLOPs and activation memory of fully-connected layers — the MLP-head and projection workhorse.

Memory of the s×s attention-score matrix — the quadratic wall FlashAttention removes. See it before you hit it.

Check which models fit on a RTX 3060 12GB: max parameters per precision, cache headroom and estimated tokens/sec.

Check which models fit on a RTX 4060 Ti 16GB: max parameters per precision, cache headroom and estimated tokens/sec.

Check which models fit on a RTX 3090 24GB: max parameters per precision, cache headroom and estimated tokens/sec.

Check which models fit on a RTX 4090 24GB: max parameters per precision, cache headroom and estimated tokens/sec.

Check which models fit on a RTX 5090 32GB: max parameters per precision, cache headroom and estimated tokens/sec.

Check which models fit on a RTX A6000 48GB: max parameters per precision, cache headroom and estimated tokens/sec.

Check which models fit on a Tesla T4 16GB: max parameters per precision, cache headroom and estimated tokens/sec.

Check which models fit on a A100 80GB: max parameters per precision, cache headroom and estimated tokens/sec.

Check which models fit on a H100 80GB: max parameters per precision, cache headroom and estimated tokens/sec.

Check which models fit on a Apple M4 Max (128GB unified): max parameters per precision, cache headroom and estimated tokens/sec.

Forward-pass activations a transformer stores for backprop — per layer and total, with and without checkpointing.

Memory of AdamW, SGD, Adafactor, 8-bit Adam and Lion states for any model size — the hidden 2–3× weights tax.

Per-GPU memory at ZeRO stages 0–3 (FSDP full-shard) for any model and cluster size — see what each stage shards.

Steps to simulate a target global batch from your micro-batch and GPU count — with tokens-per-step and LR advice.

Scale a known-good LR to a new batch size — linear and square-root rules, with warmup-steps suggestion.

Learning rate at any step of a warmup-plus-cosine schedule — the default decay of modern LLM training.

Convert dataset size, batch and sequence length into optimizer steps and epochs — and check repeat-data limits.

Estimate LLM tokens from words, characters or pages — per-language ratios for English, code, Hindi, Chinese.

Trainable parameters and file size of LoRA adapters from rank, target modules and model architecture.

Stretch a model's context with RoPE scaling — linear vs NTK-aware factors, effective θ and quality expectations.

RAM/disk for N embeddings at any dimension — float32 vs PQ/binary compression, plus HNSW index overhead.

Expected speedup from draft-model speculation given acceptance rate, draft length and model cost ratio.

Break-even between per-token API pricing and renting GPUs — utilization is the whole story; see yours.

How long a checkpoint takes to pull at your bandwidth — with the real-world Hub throttle and resume math.

Size/speed/quality trade of distilling a teacher into a student — compression ratio, capacity gap and serving gains.

Memory and FLOPs after unstructured, 2:4 semi-structured, or structured pruning — with realistic speedup caveats.

Power cost of running GPUs — per hour, month, and per million tokens, at your local tariff.

How batch size trades per-user latency for aggregate tokens/sec — the roofline crossover made interactive.

Full inference-memory budget for ANY transformer from raw config.json fields — weights, KV cache, overhead.

Split a context window between system prompt, RAG chunks, history and output — and catch overflow before the API does.

FP32 vs FP16/BF16-mixed vs pure-BF16 vs FP8 training memory side by side — where the savings actually are.

Generic per-token and total KV-cache memory from architecture fields — the long-context budgeting workhorse.

Right-size LR warmup from total steps, batch size and model scale — with the heuristics labs actually use.

Normalize GPU offers into the metric that decides training budgets — billions of tokens trained per dollar.