1000luca/FlexDM-decision-index

FlexDM · Gemma-4-31B, Decision Index results

Stock google/gemma-4-31B-it @ 842da37 (no training, FP8 per-block quantization at load), read by 1000luca/FlexDM, tag v1.0 (commit d6ee1990a9abd7bf6030bd65416a26d60cb3e9cf), engine jevlab.vllm_reader:VllmReader, options layout=header read_twice=true twice_max_tokens=3000 temperature_choice=10.9757 temperature_choice_log_slope=-1.7016 temperature_noul=10.732 noul_bias=0.

Board result

Jev Decision Index 0.4.1, board of 2026-10-21 (PR #246):

	FlexDM
Full score	67.56, 8th of 223 models
Among entries that are not full fine-tunes (inference techniques, LoRA, LoRA + head)	tied 1st with AJev lm6q (LoRA, 67.57)
Among the 26 inference techniques	1st (next: Aleria Judge 1.1.1, 66.67)
Private tests, same skills (60% of Full)	62.98
Private tests, new domains (40% of Full)	58.52: highest of any entry that is not a full fine-tune, 4th overall
Public 0.3 index (this dataset; shown on the board, not counted since 0.4)	63.63
Maintainers' rerun with our code	100.00% decision agreement on 831 rows (FP8 bar: 96%)
Latency, board measurement (one RTX PRO 6000, one request at a time)	median 109 ms, mean 301 ms, p95 1,106 ms

FlexDM is the highest-ranked entry on the board that uses no trained weights. The board counts Full scores less than 0.9 apart as a tie.

This dataset: the public 0.3 run

Public index (0.3)	63.63 (raw 72.25)
Requests	140,178 of 140,178 scoreable ok, 0 unsupported, 0 errors; complete: true (all 140,620 rows were run; the scorer drops the 442 excluded rows)
Latency, this run	one RTX PRO 6000 Blackwell Max-Q (300 W), one process, one request at a time, over the scoreable rows: median 146 ms, mean 403 ms, p80 534 ms, p95 1,583 ms
Estimate before the run	2,000-row stratified public sample, reweighted to the suite's rows per benchmark, same GPU: median 145 ms, mean 412 ms, p80 621 ms
Agreement with a second process	2,000 rows of our 2,000-row stratified public sample, read earlier by a separate process with the same read policy: same top answer on 100.00% of 16,537 questions

How it answers

• One prompt layout (header) for every request, with no per-benchmark prompts or rules. Each row is one question in Gemma's chat template with thinking off: the list of the request's questions, then the state, then the question and its options, ending at Answer: (. Nothing is generated.
• vLLM reads one step (max_tokens=1) and returns the log-probabilities of the option labels (logprob_token_ids, after Gemma's final soft cap). All rows of a request go in one generate call, sharing their prefix through the prefix cache.
• A request of at most 3,000 tokens read once has its user turn written twice, joined by Read the same input again before answering:. Longer requests are read once.
• Per-type temperatures were fitted on our own off-suite calibration rows: choice T = 10.9757 - 1.7016 ln(n options), noul T = 10.732, no noul bias. Temperatures do not change the top answer.
• Limits: 131,071 tokens per row and 2-255 options per question. Longer rows are recorded as unsupported, and nothing is truncated. No public request reaches either limit.

Settings

vLLM 0.30.0 (offline LLM, in-process, prompt token ids), torch 2.13.0+cu130, transformers 5.16.1, tokenizers 0.23.1, Python 3.12. The engine passes these settings to vLLM:

• quantization fp8_per_block (online, at load), dtype bfloat16, KV cache bf16 (kv_cache_dtype auto)
• max_model_len 131072, gpu_memory_utilization 0.70
• attention backend TRITON_ATTN, prefix caching on (retention interval 32)
• max_num_batched_tokens 8192, max_num_seqs 256, seed 0
• logprobs_mode raw_logprobs, generation_config vllm, VLLM_USE_DEEP_GEMM=0

The complete list is in environment.json → model_source. The exact package versions are in requirements.txt of the engine repository.

How it was run

1. Kit apolinario/decision-index at f8552a13b643d39f61185f5951bb5fed16bedf51, unmodified runner (sha256 f4c9f36c…), on the frozen 0.3 suite (suite verify matches the pinned hashes).
2. One decision_index run process on one GPU, one request at a time, with --compact. The run started on 2026-10-18 19:39 UTC and finished on 2026-10-19 18:14 UTC after 1 start(s).
   • Our driver waits for a GPU with enough free memory and resumes after an interruption.
   • It refuses to resume if the options, the engine files or the kit commit changed. driver.json records them, and attempts/ keeps each start's environment.json and status.json.
3. Scored with decision_index score --edition 0.3. The 442 excluded rows were run too, so the latency in scores.json includes them. The latency above covers the scoreable rows only.

The engine files the run loaded, byte-identical to the files at the tag:

e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855  jevlab/__init__.py
9ee4dbf437531d6093fa52bbcab3e9143f62e451c1450714fe1cb8411351e03c  jevlab/reader.py
d69770c5e1e947b3b7aaedc1ed0d435fa441dc2ff08863d4bc3cf88ff22c71b8  jevlab/vllm_reader.py

To reproduce, follow the engine README: install from requirements.txt at the tag, then run python -m decision_index run --engine jevlab.vllm_reader:VllmReader --option layout=header --option read_twice=true --option twice_max_tokens=3000 --option temperature_choice=10.9757 --option temperature_choice_log_slope=-1.7016 --option temperature_noul=10.732 --option noul_bias=0 --compact --out runs/flexdm on one GPU with about 70 GB free.

Files

Everything is in runs/flexdm-l1-full/:

file	contents
results.jsonl.gz	one record per request: answers, probabilities, timings and run_id. Written with --compact, so it contains no suite text (payload) and no raw_output
scores.json	the kit's combined scores and completion flags (the file the submission points at)
index.json	per-benchmark raw, skill, coverage and chance; areas; index and raw index
benchmark-summary.json	native metric per benchmark, with answered, unsupported and error counts
environment.json	engine, options, model_source (all serving settings), library versions, GPU, runner sha256
status.json	final run status and counts
driver.json	options, engine file sha256 and kit commit, as checked on every start
attempts/	environment.json and status.json of each start

This dataset contains no suite rows. The suite's sources do not allow republishing them, so build the suite with the kit to re-score: gunzip -k results.jsonl.gz, then python -m decision_index score --edition 0.3 --results results.jsonl.

Known slow case

Requests of 33,000-54,000 tokens (some ToolRet and BRIGHT rows, most of them among the 442 excluded rows) take tens of seconds each. The slowest request in this run took 31.0 s. These requests are rare in the suite.

Disclosures

• No training. These are the stock base-model weights with FP8 quantization at load time, so the quantized reproduction bar (96%) applies. We publish no weight, adapter, head or scorer files.
• No Jev outputs (Jev API answers) were used anywhere.
• The layout was chosen with public-suite sample runs and an off-suite shadow index, so the public score is not blind to that choice.
  • We adopted the header layout (from wcole3/jev-brain) and the read-twice cut at 3,000 tokens after comparing them on a 2,000-row stratified sample of the public 0.3 suite: sample index 55.39 for the decider layout, 60.98 for header, 62.82 for header with read twice.
  • We also compared them on our shadow index, 10,381 requests from 16 public datasets outside the suite's sources.
  • Reversed-option re-reading, an option-position bias correction and layout mixing gave no gain and were not used.
• Temperatures were fitted on our own off-suite calibration rows.
  • The calibration split has 2,871 requests from the same 16 datasets, disjoint from the shadow evaluation rows, with no suite rows. We fitted on one half and checked on the other.
  • The fit also proposed a noul bias, which we set to 0 because its calibration questions came from one dataset. On our public sample the bias would have changed 13 answers and lowered the sample index by 0.31.
• Prompt sources. The header layout comes from wcole3/jev-brain (MIT). The chat layout and the long-array index annotation come from decider-ai 1.6.0, Mapika/decider (Apache-2.0). Reading twice follows shisa-ai/shisa-de-2.
• Hardware. Our RTX PRO 6000 Blackwell is the 300 W Max-Q edition, so our latency is more conservative than on the 600 W card.