Hugging Face's logo

Datasets:
Jerrybro
/
qwen38-flash-next-int2-rtx5090-research

Languages:
English
Size:
n<1K
Tags:
qwen3.8-flash-next
autoround
sglang
rtx-5090
blackwell
int2
License:
Dataset card Files
xet
 Community
Dataset Viewer
Duplicate
The dataset viewer is not available for this split.
Cannot load the dataset split (in streaming mode) to extract the first rows.
Error code:   StreamingRowsError
Exception:    ValueError
Message:      Expected object or value
Traceback:    Traceback (most recent call last):
                File "/src/services/worker/src/worker/utils.py", line 147, in get_rows_or_raise
                  return get_rows(
                      dataset=dataset,
                  ...<4 lines>...
                      column_names=column_names,
                  )
                File "/src/libs/libcommon/src/libcommon/utils.py", line 272, in decorator
                  return func(*args, **kwargs)
                File "/src/services/worker/src/worker/utils.py", line 127, in get_rows
                  rows_plus_one = list(itertools.islice(safe_iter(ds, dataset=dataset), rows_max_number + 1))
                File "/src/services/worker/src/worker/utils.py", line 483, in safe_iter
                  yield from ds.decode(False) if ds.features else ds
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 2840, in __iter__
                  for key, example in ex_iterable:
                                      ^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 2373, in __iter__
                  for key, pa_table in self._iter_arrow():
                                       ~~~~~~~~~~~~~~~~^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 2398, in _iter_arrow
                  for key, pa_table in self.ex_iterable._iter_arrow():
                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 536, in _iter_arrow
                  for key, pa_table in iterator:
                                       ^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 419, in _iter_arrow
                  for key, pa_table in self.generate_tables_fn(**gen_kwags):
                                       ~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 281, in _generate_tables
                  examples = [ujson_loads(line) for line in batch.splitlines()]
                              ~~~~~~~~~~~^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/utils/json.py", line 20, in ujson_loads
                  return pd.io.json.ujson_loads(*args, **kwargs)
                         ~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^
              ValueError: Expected object or value

Need help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.

Qwen3.8-Flash-Next Mixed INT2 AutoRound on a Single RTX 5090

This benchmark and reproducibility artifact documents SGLang inference for the mixed-INT2 AutoRound Qwen3.8-Flash-Next checkpoint on one NVIDIA RTX 5090 Blackwell GPU. It covers a validated 256K / 262,144-token long context, MoE autotuning, tiered KV cache, CPU offload, and the device-local evidence showing why another Blackwell GPU's tuning configuration should not be copied blindly.

Single-GPU runtime and evidence map

Headline inference benchmark

Measurement Result
Maximum validated context 262,144 tokens
247,296-token needle retrieval 5/5
247,296-token prefill / decode 1,127.77 / 36.42 tok/s
257,519-token pressure prefill / decode 1,489.46 / 41.90 tok/s
Short decode, three-run median 60.78 tok/s end-to-end
Short decode range 59.58–62.14 tok/s
Synthetic regression smoke gate 8/8
Cross-device MoE seed rejected, −29.43% throughput

The 8/8 result is a deterministic integration gate, not a broad model-quality score.

Hardware under test

Component Hardware / current host snapshot
CPU AMD Ryzen 9 9950X3D · 16 cores / 32 logical processors
GPU NVIDIA GeForce RTX 5090 · 32,607 MiB reported by nvidia-smi (~31.8 GiB; marketed as 32 GB)
System memory 64 GB installed class · 61.3 GiB visible to the operating system
Host OS Microsoft Windows 11 Enterprise · version 10.0.26200 · build 26200
NVIDIA driver 616.64, observed on the current host on 2026-09-20
GPU compute capability 12.0, captured by the Qwen runtime device snapshot

This table records the hardware and current host state; the currently observed driver must not be assumed to be the driver used for every historical measurement. For the benchmark software snapshot and pinned revisions, treat environment/runtime.json and the files under results/ as authoritative.

Search terms: Qwen3.8 Flash Next / Qwen3.8-Flash-Next, mixed INT2 AutoRound, SGLang 256K long-context inference, RTX 5090 Blackwell, single-GPU local LLM, MoE autotuning, tiered KV cache, CPU offload, and bounded RAG, tool-calling, and agent regression evaluation.

What this dataset gives you

  • Sanitized performance, retrieval, quality-gate, and autotune summaries.
  • A path-neutral 256K SGLang launch template.
  • Endpoint-level decode and deterministic regression runners with no third-party Python dependencies.
  • Pinned runtime and checkpoint revisions.
  • A documented negative result: a same-generation GPU configuration removed warnings yet made the matched workload slower.

It does not contain model weights, runtime patches, credentials, chat history, private prompts, client data, or machine logs.

Download this research package 

hf download Jerrybro/qwen38-flash-next-rtx5090-research \
  --repo-type dataset \
  --local-dir qwen38-flash-next-rtx5090-research

Download the checkpoint from its publisher; this dataset never redistributes it:

hf download HaberstrohSystems/Qwen3.8-Flash-Next-int2-mixed-AutoRound-24GB-SGLang \
  --revision 1199caf239e61da9230b5ba7ba88d29304c9a309 \
  --local-dir Qwen3.8-Flash-Next-int2-mixed-AutoRound-24GB-SGLang

Upstream checkpoint: HaberstrohSystems/Qwen3.8-Flash-Next-int2-mixed-AutoRound-24GB-SGLang.

Package map

Path Purpose
results/benchmark-summary.json Long-context, needle, pressure, and short-decode measurements
results/autotune-summary.json Accepted device-local tune and rejected cross-device seed
results/quality-summary.json Scope and outcome of the eight-case regression gate
environment/runtime.json Device and pinned software revisions
config/serve-256k-reference.sh Path-neutral launch template
scripts/benchmark_decode.py Repeated endpoint-level decode measurement
scripts/run_quality_suite.py Deterministic JSONL regression runner
data/cos_domain_v1.jsonl Eight synthetic, non-client regression cases

Reproduce the measured launch profile

1. Match the software snapshot

The captured environment was Python 3.12.14, PyTorch 2.13.0+cu130, CUDA runtime 13.0, Triton 3.7.1, Transformers 5.12.1, and SGLang commit 73a2552. The runtime also used patch revision 1f73e9c8b6a572582292bd4717b3fa6616bf2cf2.

The INT4 ring-KV and lazy-backing switches in the reference template are not guaranteed to exist in stock SGLang. If that patch revision is unavailable, you can inspect the method and configuration here, but you cannot claim a bit-for-bit reproduction of the published run.

2. Launch the server 

cd qwen38-flash-next-rtx5090-research
export MODEL_PATH=/path/to/Qwen3.8-Flash-Next-int2-mixed-AutoRound-24GB-SGLang
export SERVED_MODEL_NAME=qwen38-flash-next-int2
export PORT=19080

# Optional: only use configurations generated and measured on the target GPU.
export MOE_CONFIG_DIR=/path/to/rtx5090-device-local-moe-configs

bash config/serve-256k-reference.sh

The template binds to loopback, allows one running request, uses 19 GB CPU weight offload, 1,024-token chunked prefill, a 32,768-token prefill ceiling, breakable decode CUDA Graphs, and int8ring_int4 tiered KV with lazy backing.

3. Measure short decode

Set OPENAI_BASE_URL to the OpenAI-compatible /v1 endpoint exposed by your runtime, then run:

python scripts/benchmark_decode.py \
  --endpoint "$OPENAI_BASE_URL" \
  --model qwen38-flash-next-int2 \
  --max-tokens 256 \
  --warmup 1 \
  --repeats 3 \
  --output reproduced/decode.json

4. Run the bounded quality gate 

python scripts/run_quality_suite.py \
  --endpoint "$OPENAI_BASE_URL" \
  --model qwen38-flash-next-int2 \
  --suite data/cos_domain_v1.jsonl \
  --output reproduced/quality.json

The runner returns a non-zero exit code if any case fails. Do not reinterpret this small, synthetic suite as a leaderboard result.

RTX 5090 optimization method

The reference profile combines four practical constraints:

  1. Fit the mixed-INT2 MoE weights with 19 GB CPU offload while keeping the serving path single-request and deterministic.
  2. Bound prefill pressure with 1,024-token chunks and a 32,768-token maximum prefill batch.
  3. Reduce long-context KV cost with int8ring_int4, lazy backing for 262,144 tokens, and an 8,192-token hot tier.
  4. Tune MoE kernels on the target device. The accepted RTX 5090 run observed 290 unique expert shapes across expert counts 57–480 and generated coverage for 1–512. It completed the 8/8 gate with zero default-config warnings and zero runtime errors.

Negative cross-GPU result

A seed derived from an RTX PRO 4000 Blackwell configuration was tested against the same eight-case gate. Both arms remained 8/8, but effective completion throughput fell from 17.87 to 12.61 tok/s, a 29.43% regression. The seed was rejected and removed.

This is the central portability finding: the launch policy is a reference; the MoE tune is device-local evidence, not a portable configuration artifact. Re-run measurement after any GPU, driver, Triton, SGLang, checkpoint, or batch-shape change.

Recommended settings

Setting Published value Why
Context / total tokens 262,144 Validated upper runtime setting
Running requests 1 Keeps the single-user memory envelope predictable
CPU weight offload 19 GB Fits the mixed-INT2 checkpoint on 32 GB VRAM
Chunked prefill 1,024 tokens Controls transient prefill pressure
Maximum prefill batch 32,768 tokens Bounds large-input scheduling
KV cache int8ring_int4 Reduces long-context KV footprint
Lazy KV tokens 262,144 Backs the full configured context
Lazy KV hot tier 8,192 tokens Keeps a recent working set resident
Decode CUDA Graph breakable Matches the measured runtime profile

Treat these as a tested RTX 5090 starting point, not a universal optimum.

Measurement boundaries

  • Needle retrieval, pressure, and decode rates are descriptive measurements from one host and one software snapshot.
  • The short-decode number is end-to-end completion tokens divided by wall time, with one warmup and three measured runs.
  • The 8-case suite tests formatting, retrieval, coding, simple reasoning, language handling, and unknown-data behavior. It is not a general intelligence, safety, or contamination-resistant benchmark.
  • Thermal state and background GPU activity were not controlled as laboratory variables.
  • No claim is made for other GPUs, drivers, checkpoint revisions, concurrency levels, or unpatched SGLang.

Companion research

For the separate PQ2/Q4-KV/Fable comparison on the same GPU class, see Jerrybro/bonsai2-27b-pq2-vs-fable-rtx5090.

Licensing and attribution

  • Dataset documentation, aggregate results, and original visual: CC BY 4.0.
  • Original scripts and launch template: Apache License 2.0.
  • The checkpoint, SGLang, PyTorch, Triton, Transformers, CUDA, and any runtime patches remain under their upstream licenses. Nothing here relicenses them.

Citation

Use CITATION.cff, and cite the upstream checkpoint and runtime when reporting reproduced results.

Author

Jerry Sheen · Hugging Face: Jerrybro
Downloads last month
176
Total file size:
40.1 kB