humanfia-lab/inference-kernels

Inference Kernels

21 FlashInfer Trace operator definitions, with self-contained PyTorch references, open-source baseline solutions, and workloads captured from actual inference: 19 through SGLang, and the 2 gated delta definitions from the MLSys 2026 FlashInfer contest. Model dimensions are constants. Runtime batch sizes, sequence lengths, page sizes, and image grids remain variable.

Every published tensor input references a complete safetensors snapshot. Python scalar arguments use scalar descriptors. There are no random-input descriptors or synthetic activation generators. captures.jsonl joins each workload UUID to its model revision, request, engine operation, input adaptations, actual outputs, and validation results.

1,104 real workloads cover all 21 definitions: 133 Qwen Image, 384 Qwen Flash-Next, 226 DeepSeek, 207 LTX, and 154 Qwen3-Next from the MLSys 2026 contest. The 950 SGLang captures pass complete-output replay; the contest publishes no engine outputs, so its workloads are checked by running the reference. The complete dataset is published at humanfia-lab/inference-kernels, including definitions, workloads, capture records, baseline solutions, and tensors. The 5,493 tensor paths contain 5,111 unique snapshots of inputs, complete engine outputs, and auxiliary capture tensors. Fetch them with Git LFS before running workloads.

The dataset was regenerated from full pinned checkpoints through SGLang on NVIDIA B300 GPUs. The interface and implementation audit records all 21 call boundaries, the feasible interface simplifications, current implementation updates, validation evidence and remaining integration work. This audit does not change task tolerances, dev UUIDs or input tensor values.

Kernels

BF16, FP16, FP32, and FP64 mean 16-bit Brain Floating Point, IEEE half precision, 32-bit floating point, and 64-bit floating point. FP8 and FP4 are 8-bit and 4-bit quantized formats. Q, K, and V denote queries, keys, and values.

Family	Model	Fixed dimensions	Definitions	Workloads
Dense matrix multiplication	Qwen Image 2.1 Turbo	(N,K): (4096,4096), (12288,4096), (4096,12288); M >= 4096	3	93
Grouped expert matrix multiplication	DeepSeek V4.1 Flash	384 experts; (N,K): (4608,5120), (5120,2304); FP8 × FP4	2	104
Mixed-format latent attention	DeepSeek V4.1 Flash	64 heads × 512 dimensions; 128 FP8 window slots and 512 FP4 compressed slots	1	42
Sparse multi-head latent attention (MLA), prefill	DeepSeek V4.1 Flash	64 query heads × 512 dimensions; 1 shared key/value head; BF16; separate 128-slot and 640-slot definitions	2	30
Gated delta recurrence	Qwen3-Next (MLSys 2026 contest)	4 query/key heads, 8 value heads (TP=4 shard), dimension 128; k-last state; prefill and decode	2	154
Noncausal dense attention	LTX-2.5	Video: 32 heads × 128; audio: 32 heads × 64; no mask	2	162
Qwen sparse attention	Qwen 3.8 Flash-Next	24 query heads, 2 key/value heads, dimension 256; 512 four-token blocks	1	192
Prefix-cached block-causal attention	Qwen Image 2.1 Turbo	32 heads × 128; empty-prefix and cached-prefix cases	2	40
Sparse index scoring and selection	Qwen 3.8 Flash-Next	4 query heads × 128; Top-512 complete four-token blocks	1	192
Expert router	DeepSeek V4.1 Flash	Hidden dimension 5120, 384 experts, Top-6 selection	1	50
Three-dimensional neighborhood attention	LTX-2.5 diffusion decoder	Dimension 64; (heads, window): (32,3×7×7), (16,3×7×7), (8,3×5×5), (4,11×11×11)	4	45

Shape distribution histograms for all 21 kernels show how the 1,104 workloads are distributed across exact runtime shapes. Each bar counts captured workloads with the same complete combination of variable dimensions; fixed model dimensions are listed above the plot. These counts describe this dataset, not AgentX traffic frequencies. Regenerate the figures with python scripts/plot_shape_distributions.py (requires Matplotlib; no GPU or tensor files needed).

Definitions describe complete logical operators. Captures preserve all model heads and experts; distributed shards must be gathered before publication. Backend padding, layout changes, and page remapping are recorded explicitly. Cache snapshots retain every referenced page, including its unused tail; unreachable allocator pages are omitted. Tensor strides are normalized to contiguous storage without changing values.

The gated delta definitions are the MLSys 2026 contest's: Q/K/V with the gate inputs A_log, a, dt_bias and b, and the k-last state layout [sequence, value head, value dimension, key dimension]. Prefill takes variable-length sequences through cu_seqlens. These are unchanged Qwen3-Next TP=4 contest contracts, not a layout conversion of the removed Qwen Flash-Next captures. Their references do not perform Q/K L2 normalization. Decode accepts per-batch states rather than the mutable SGLang state pool and slot indices. The actual SGLang FlashInfer prefill leaf already accepts gathered per-batch states, but uses normalized Q/K, precomputed gates, preallocated outputs and optional checkpoints. See the per-definition audit.

Quantized byte carriers use int8 because the trace schema lacks unsigned-byte and exponent-only scale types. The byte patterns remain unchanged. Grouped matrix multiplication uses logical scale layouts with one scale per 32 K elements. Mixed attention preserves the engine's physical pages: each page stores all payload rows followed by all scale rows. Both cache formats share the softmax denominator, including the zero-value attention sink.

Engine inputs

Text: Qwen Flash-Next and DeepSeek

The engine receives sequences of token IDs. Their lengths and shared prefixes come from selected requests in the public AgentX trace: 98,827 requests across 393 sessions. The selected records are in agentx_shapes.json, pinned to trace revision 23f152f6f0f9399a85901b89a6458def0ef16729.

Text content. The original prompts are not public. We use one short, authored coding conversation about fixing a Python cache and writing tests. The served model's tokenizer converts it to tokens. The trace describes prompts in anonymous 64-token blocks; each session/block ID selects a repeatable 64-token span from the replacement text. Joining those spans produces the recorded input length.

If two requests start with the same blocks, they receive the same initial tokens. For example, three shared blocks give them a shared 192-token prefix. Because the replacement text is short, different block IDs can also select identical spans. The input therefore repeats a small amount of coding text; it does not reproduce the original vocabulary, topics, or token frequencies. Lengths follow the trace's block counts, not a retokenization of the unavailable original prompts.

Lengths. Cases cover short requests, long contexts, reused prefixes, full-prefix reuse, and long responses:

Model	Input tokens	Generated output tokens
Qwen Flash-Next	Selected short-to-long requests, up to 249,088	Recorded lengths, including a 7,948-token response
DeepSeek, serial requests	128 / 2,944 / 142,016 / 549,504 / 989,824	Respectively 107 / 1,813 / 90 / 6,765 / 1,204
DeepSeek, three concurrent requests	35,008 / 35,392 / 35,456	Respectively 120 / 108 / 126

The engine uses temperature 0 and is instructed to generate the recorded output length, ignoring an early end-of-sequence signal. Thus output length is controlled by the replay. All eight DeepSeek requests completed on four GPUs, producing 10,333 tokens in total without the earlier extra 128-token cap.

Cache reuse. A cache hit lets the engine reuse work for an identical beginning of a request. Before each serial case, we clear the cache. For a case with a shared prefix, we first submit its recorded predecessor, generate one token to populate the cache, and then send the target request. For a cold case, we send the target directly. This exercises reuse through actual requests rather than assigning a cache-hit percentage.

For example, the 549,504-token DeepSeek request reused 541,952 tokens, leaving 7,552 prompt tokens to process. The actual hit can differ from the trace's shared-prefix length because of engine cache boundaries and the replacement text. This procedure does not replay the entire conversation or its cache-eviction history.

Concurrency. Qwen includes groups of 3, 9, and 23 requests that overlapped in the source trace; DeepSeek includes a group of 3. Each group starts with a cleared cache and is submitted together. The engine schedules the requests itself. Original arrival times are not reproduced.

Frequency distribution. Requests are chosen to cover different situations, without frequency weights. For example, the full trace's median input is 142,016 tokens, its 90th percentile is 549,504, and its maximum is 989,824; DeepSeek includes those lengths as coverage points. Their inclusion does not mean these requests are replayed in their original proportions. The input/output length histogram, overall cache-hit rate, role proportions, and token frequencies do not match AgentX traffic.

Images: Qwen Image

The engine receives four authored prompts, independent of AgentX:

Request	Input content	Requested output size
Text to image	A red ceramic teapot on a wooden table	1024 × 1024
Landscape	A lakeside village at sunrise	1536 × 1024
Image editing	The generated teapot image, with an instruction to make it blue	1024 × 1024
Transparent background	An orange cat on a transparent background	1024 × 1024

Each prompt is submitted with 1, 2, and 4 requested outputs. Multiple outputs share the prompt and use independent seeds starting at 42. All requests use the checkpoint's original eight-step Turbo schedule and guidance scale 1. These four prompts cover generation modes and image sizes; they are not sampled from a production prompt distribution.

Video and audio: LTX

The engine receives three authored requests, also independent of AgentX:

Request	Input content	Requested width × height × frames
Text to video	A camera moving toward a steaming teapot	768 × 448 × 49
Image to video	The Qwen-generated teapot image, with a camera-motion instruction	512 × 320 × 49
Longer video	A boat crossing a lake at sunrise	512 × 320 × 121

Each is submitted with 1, 2, and 4 requested outputs, at 24 frames per second. Multiple outputs share the prompt and use independent seeds starting at 42. All requests use the original eight-step schedule, guidance scale 1, and the full decoder; generated videos include audio. These cases cover two resolutions, two durations, and text/image conditioning. They do not represent production frequencies of video sizes or content. All nine requests are included; audio and video transformer attention use the math SDPA policy described below.

Baseline solutions

solutions/ contains native FlashInfer Trace Solution JSON files, with embedded source code, entry points, and pinned dependencies. Each solution accepts the definition's complete inputs and returns its complete outputs. GPU layout conversions, padding, sparse gathers, and output reordering are included in the solution call.

Historical B200 measurements below describe the original 768-workload dataset. Current B300 validation and comparisons are reported separately in the audit. Version currency alone does not establish a fastest implementation, and a standalone pass does not prove direct engine integration.

Kernels	Open-source implementation
Dense and grouped matrix multiplication	DeepGEMM; native PyTorch linear is selected on three measured large-M B300 shapes
Sparse MLA prefill and mixed-format MLA decode	FlashMLA
Dense and block-causal attention	FlashAttention-4 4.0.0b35; tiny audio self-attention uses native SDPA
Sparse grouped-query attention	Current SGLang/FlashInfer TRT-LLM paged attention, plus the FA4 sparse-gather alternative
Gated delta recurrence	Maintained FlashInfer prefill/decode APIs; the contest recurrence, normalization boundary and state output contract remain explicit
Sparse index scoring and selection	Maintained SGLang TileLang scoring, exact-threshold Top-512, stable Triton compaction, and a score-free short-context path
Expert router	SGLang FP32-output projection and fused modality-aware Top-6 gate, with a combined Triton output ordering kernel
Three-dimensional neighborhood attention	NATTEN 0.21.7 Blackwell fused neighborhood attention

Historical B200 comparisons covered 45 dense GEMM shapes across 147 backend/shape pairs, nine grouped GEMM shapes with five implementations/configurations each, and all 19 sparse-index workloads. Dense dispatch selects the fastest tested backend per captured shape; DeepGEMM won all nine grouped comparisons. The index adapter was 1.21–2.58× faster than full stable sorting while returning exactly the same IDs. These measurements describe the tested B200 configurations.

The current audio-attention solution uses BF16 FA4 directly, with native SDPA for self-attention tiles of at most 64 tokens. Both alternatives pass all 108 current audio workloads under the existing required_matched_ratio=0.9999 policy. The former FP16 input/output conversions are removed; no tolerance was relaxed. Historical all-element B200 validation used different input tensors and the former FP16 computation.

Install the dependencies listed in each solution's spec before running it. The historical B200 baseline environment used PyTorch 2.11.0, CUDA 13.2, Triton 3.6.0, CUTLASS DSL 4.7.1, Quack 0.6.5, TileLang 0.1.15, and TVM FFI 0.1.12. NATTEN and FlashMLA were built from their pinned sources for Blackwell. FlashMLA's CUDA 13.2 build required its upstream FLASH_MLA_SKIP_REG_SPILL_CHECK=1 option; timings include that build.

python scripts/benchmark_solutions.py \
  --gpu GPU-UUID --lock-directory /path/to/kernel-locks \
  --report results/baselines/local.jsonl

The runner uses the native Trace builder, validates every output element against the unchanged definition reference, then measures GPU time with CUDA events over CUDA Graph replays. Compilation and input loading occur before timing. --solution NAME selects a solution and --validation-only skips timing. --compare-to capture explicitly compares against saved engine outputs instead; two approximate implementations can differ beyond tolerance even when both pass against the independent reference.

SGLang baselines

Each SGLang-captured definition also has solutions/<family>/sglang_<definition>.json: the capture-commit SGLang implementation behind an explicit dataset-to-engine adapter. These provide a serving implementation comparison, not a declaration that the dataset already has every native interface. The module docstring cites the engine call path. Run these solutions inside the capture image lmsysorg/sglang@sha256:ddae0e399d3d94f7827f16183301cf8dac4cf0eae0ef25590b7dac5881d713d8. Each module also exposes prepare(*inputs), which does the host-side setup the engine does once (layouts, block masks, workspaces) and returns a zero-argument launch; run(*inputs) does both.

The SGLang solutions adapt the dataset's independent operator interfaces to the pinned engine implementations. Those adapters include padding, layouts, per-rank calls, metadata and output ordering where needed; their module docstrings describe the boundary. A passing standalone workload does not establish that a candidate can replace an engine call without integration work.

The audit runner can validate the complete packaged call, check byte-level input immutability, and compare eager and prepared-launch CUDA Graph timing under the task's exact tolerance. scripts/benchmark_solutions.py also reads tasks/ for acceptance instead of applying a generic FP32 fallback.

Task acceptance configs

tasks/<definition>.json is how KDA (Kernel Design Agents) judges a candidate kernel on that definition. The definition's reference is the truth. SGLang tasks time their engine baseline with only launch timed; imported GDN tasks time the complete maintained FlashInfer baseline call. The fields are:

• tolerance: atol and rtol apply per element. A non-null required_matched_ratio is the fraction of elements that must pass; the LTX dense attention uses 0.9999 because fused attention kernels round the probabilities to BF16 and miss the every-element bound on 1–3 of up to 10⁹ elements.
• dev: UUIDs selecting at most ten existing workloads for quick iteration. These UUIDs resolve in the listed workload files; they are not additional workloads. Final judgments use every workload, not just this subset.
• tolerance.comparison: absent means abs_error <= atol + rtol * abs(reference). The GDN configs explicitly use absolute_or_relative, matching the pinned FlashInfer-Bench evaluator: abs_error <= atol or abs_error / (abs(reference) + 1e-8) <= rtol. Nonfinite values fail.
• group_axis and timing (warmup, iters, trials).

A task config selects the definition, workload files, timed baseline and acceptance policy. captures.jsonl is a separate provenance record: it explains where input tensors came from, which capture adaptations were applied, and which replay checks were recorded. The standalone kernel judge reads the definition, workloads and task config; it does not require capture receipts to compute outputs or judge a candidate. All 21 definitions have an explicit task config. The 19 SGLang configs retain their existing tolerances, dev UUIDs and timing. The two imported GDN tasks use the contest evaluation policy: FlashInfer-Bench defaults atol=rtol=0.01, every element required, and its absolute-or-relative error test. Their configs pin the policy sources. The GDN dev subsets are selected from existing runtime shapes; the full evaluation still uses all 154 GDN workloads. See GDN prefill numerical analysis for the earlier strict FP32 diagnostic.

Curation

This revision curates inference operator tasks for KDA (Kernel Design Agents). Per-shape definitions, workload files and solution names stay separate; model dimensions remain constant axes. Captured interface adaptations are retained explicitly.

• Removed dense_gemm_bf16_nt_n64_k4096 and dense_gemm_bf16_nt_n4096_k64. These are the image output and input projections: memory-bound 8–45 µs GEMMs that run once per forward.
• Removed grouped_gemm_fp8_fp4_e384_n2304_k5120_g32. It was cut from the columns of the concatenated gate/up GEMM; no engine runs a separate gate or up GEMM.
• Replaced the gated delta definitions. gated_delta_rule_prefill_h48_dk128_dv128 pre-repeated 16 Q/K heads to 48; the old decode kept 16 raw Q/K heads and included normalization and gating. Both captures extracted states from the engine pool and transposed them to [B, H, K, V]. They are replaced by the MLSys 2026 FlashInfer contest definitions gdn_{decode,prefill}_qk4_v8_d128_k_last, with their workloads and independent references preserved. The audit subsequently replaces the legacy vendored wrappers with maintained FlashInfer API calls. Each input tensor is stored in its own content-addressed file. Each receipt records the source workload, plus a check that the reference returns finite outputs of the declared shapes.
• The three remaining dense GEMMs keep only their M >= 4096 rows. The M <= 32 rows were 11–27 µs launches.
• The LTX dense attention definitions drop the dense [B, H, Nq, Nk] visibility mask. It was all True on every captured call (up to 839 MB). On one GPU the engine passes no mask, or an all-visible prompt mask. Replay against the captured engine outputs still passes.
• Receipts and tensors. The receipts of removed workloads are dropped, along with every tensor that nothing references.
• Scripts.
  • check_workload_inputs.py evaluates constraints that read inputs, such as cu_seqlens[-1].
  • The replay in capture_inputs.py skips imported workloads, which have no engine output.
  • plot_shape_distributions.py accepts axes without a description.

Reproduce

The capture engine image is lmsysorg/sglang:nightly-dev-cu13-20261014-684fea8a, verified as lmsysorg/sglang@sha256:ddae0e399d3d94f7827f16183301cf8dac4cf0eae0ef25590b7dac5881d713d8. It contains PyTorch 2.14.1+cu130 and SGLang build 684fea8af3b11a5b51ec9966c02959a32ad3421c. The native dataset checker was run with FlashInfer-Bench commit 15618a67e8d7b7f49ca61b5ba3b9f26a876d0bee. The Modal runner defaults to its cached image in the current workspace; --image accepts another prepared Modal image ID. Install the Modal client locally and authenticate it before using the runner. Model downloads use a CPU worker and the task's persistent volume.

For LTX, pass --audio-sdpa-backend math --video-sdpa-backend math. These options select standard PyTorch math SDPA for every transformer audio/video attention call, retaining BF16 inputs/outputs and FP32 intermediates. This avoids the default BF16 backend's observed tolerance failures and includes all nine LTX requests without changing references or tolerances.

# Use a GPU lock directory appropriate for your environment.
python scripts/run_modal_capture.py --name image-model --kind image \
  --prepare-model --lock-directory /path/to/kernel-locks
python scripts/run_modal_capture.py --name image --kind image \
  --lock-directory /path/to/kernel-locks

python scripts/run_modal_capture.py --name qwen-model --kind qwen-next \
  --prepare-model --lock-directory /path/to/kernel-locks
python scripts/run_modal_capture.py --name qwen-agentx --kind qwen-next \
  --lock-directory /path/to/kernel-locks
python scripts/run_modal_capture.py --name qwen-overlap --kind qwen-next \
  --case overlap_p50 --case overlap_p95 --case overlap_p100 \
  --lock-directory /path/to/kernel-locks

python scripts/run_modal_capture.py --name deepseek-model --kind deepseek41 \
  --prepare-model --lock-directory /path/to/kernel-locks
python scripts/run_modal_capture.py --name deepseek-agentx --kind deepseek41 \
  --case short_request --case cold_main --case full_context_p50 \
  --case full_context_p90 --case full_context_max --case overlap_p50 \
  --lock-directory /path/to/kernel-locks

python scripts/run_modal_capture.py --name ltx-model --kind ltx25 \
  --prepare-model --lock-directory /path/to/kernel-locks
python scripts/run_modal_capture.py --name ltx --kind ltx25 \
  --audio-sdpa-backend math --video-sdpa-backend math \
  --reference-image /task/data/captures/image/results/square.png \
  --lock-directory /path/to/kernel-locks

The runner takes exclusive GPU locks, uploads the capture hooks and definitions, starts the serving engine, sends requests, validates captured outputs, releases the GPUs, and retrieves dumped tensors. Runs are stored under results/capture/<name>/dataset/. --retrieve-only resumes file retrieval using the saved inventory. --case selects a request; --max-output-tokens explicitly caps output for instrumentation checks. For image/video capture, --num-outputs 2 or --num-outputs 4 requests native multi-output generation; use a distinct --name for each run. --reference-image can reuse the original single-image capture for both editing and video conditioning. Every returned image/video is saved and its count checked.

With the pinned engine image and an existing checkpoint, DeepSeek can also run directly on four local GPUs. Acquire their device locks before running the following command. Container caches must be writable; set SGLANG_CACHE_DIR to a writable task directory when the container filesystem is read-only.

CUDA_VISIBLE_DEVICES=0,1,2,3 python scripts/capture_llm.py \
  --kind deepseek41 --model-path /path/to/DeepSeek-V4.1-Flash \
  --output-root results/capture/deepseek-host/dataset \
  --case short_request --case cold_main --case full_context_p50 \
  --case full_context_p90 --case full_context_max --case overlap_p50

To reproduce each validated LTX batch, use --audio-sdpa-backend math --video-sdpa-backend math, and run all three request types with --num-outputs 1, 2, and 4 under distinct run names. Keep the same reference image for image editing and image-conditioned video.

The capture kept every passing workload from the nine canonical runs (the curation then removed some): images 101 + 78 + 78; Qwen 193 serial + 448 concurrent; DeepSeek 278 of 279; LTX 69 + 69 + 69. The optional Modal retrieval filters (--batch-sizes and --context-endpoints) were not used for this publication. DeepSeek retains 52 workloads per grouped matrix definition, 50 router calls, 42 mixed-attention calls, and 30 sparse-prefill calls. Each grouped definition covers actual row counts 6/12/18/768/2688/11904/14592/17664/20736/24192/24576. Decode captures include early, middle, and final steps and actual concurrent batches 1/2/3.

All 768 original request/operator/step locations remain represented. New UUIDs and tensor hashes identify the regenerated values. Images, Qwen, and LTX retain every original exact runtime shape. DeepSeek mixed attention keeps the actual reachable physical pages selected by the new full-model execution: 14 calls differ in their N4/N8 page counts, leaving 12 original exact storage shapes absent. These content-dependent cache footprints are not padded to imitate earlier allocations.

Pinned checkpoints are Qwen Image 2.1 Turbo, NVIDIA Qwen 3.8 Flash-Next NVFP4, and DeepSeek V4.1 Flash. Qwen uses the full NVIDIA quantized export with its original architecture, not a smaller model. Its large embedding table is offloaded to CPU.

All regenerated DeepSeek samples use exactly four B300 GPUs with tensor parallelism 4, expert parallelism 4, and data parallelism 1. Tensor and expert parallelism use the same four GPUs. The local run retains the full architecture and shared CPU Engram tables. Prefill chunks contain at most 4,096 tokens; CUDA Graph and overlap scheduling are disabled for capture. The capture hook gathers all expert shards and query heads into complete logical operators. It also corrects the pinned engine's FP4-expert scale recipe to use the dispatcher's actual activation-group metadata; quantized tensor bytes are unchanged. Mixed-attention runs explicitly select the V4.1 cache layout, because the pinned engine otherwise defaults to the older layout. These settings are recorded with each request.

LTX uses the licensed public original-weight distribution and a pinned convolutional VAE distribution. prepare_ltx.py verifies file hashes, retains license notices, extracts the embedded Gemma tokenizer, and invokes the official Diffusers converter at commit efe46a5b177af67c64b3666da8ddddac7ee12163. All components load strictly, including all text/transformer layers and vision/audio embeddings. The original optional decoder keyframe tag is retained; these requests use the ordinary decoder path without an auxiliary keyframe stream.

Import and validate

Only completely validated captures can be imported:

python scripts/capture_inputs.py --import-capture results/capture/image/dataset --output-root .
python scripts/check_workload_inputs.py
python scripts/capture_inputs.py --replay-root . --device cuda

Input checking requires PyTorch, safetensors, and FlashInfer-Bench. It verifies native schemas, every tensor's shape/dtype/content hash, complete input mappings, and provenance coverage. Missing model captures are listed separately. Output replay runs the embedded reference at each complete captured shape and compares all output elements with the saved serving output. No output sampling is used.

BF16 comparisons use rtol=0.016, atol=0.005; FP32 uses rtol=1e-4, atol=2e-5; integer outputs must match exactly. Gated delta prefill state has a separate finite-precision comparison because the engine's chunk algorithm rounds intermediate matrix operands to BF16 despite storing state in FP32: relative root-mean-square error ≤1%, maximum absolute error relative to the largest state value ≤1.5%, and per-head relative root-mean-square error ≤2%. Every measured error and criterion is saved with its workload. Qwen block IDs and DeepSeek expert IDs are serialized in increasing ID order without changing selected membership; router weights follow their IDs. Original engine IDs/weights are also saved. Comparisons preserve exact selected-set equality; this ordering does not relax selection accuracy.

One complete router workload is excluded from the 279 DeepSeek raw captures: at two rows of a 4,096-row call, FP32 ranking ties produce different expert selections. The original FP32 reference and exact selected-set requirement remain unchanged. This call was also absent from the original dataset. No rows are removed from published tensors. All nine LTX requests pass and are included.

Tensor files are published directly as blob/workloads/<definition>/<hash>.safetensors through Git LFS. Every workload and capture record references tensors under its definition directory. Shared snapshots have identical LFS objects across directories: 5,493 paths contain 5,111 unique snapshots totaling 146.34 GB (146.44 GB when materialized at every path).

git clone https://huggingface.co/datasets/humanfia-lab/inference-kernels
cd inference-kernels
git lfs install --local
git lfs pull
python scripts/check_workload_inputs.py

Checkpoint tensors retain their upstream license terms; required license text and notices are in licenses/. The NVIDIA export's model card links the NVIDIA Open Model License and Qwen Community License.

results/ holds local run logs, generated images, and validation reports. record.md stays outside this repository and is never committed. The new capture runs do not support serving-performance claims because tracing and comparison add substantial overhead; baseline measurements above are historical.