1000luca/FlexDM-decision-index

Code (GitHub) · Leaderboard · Submission (PR #246) · Trained version: FlexDM-LoRA · Blog

FlexDM · Gemma-4-31B

Stock Gemma-4-31B-it, no training, read better. FlexDM reads the unmodified google/gemma-4-31B-it checkpoint with two prompt changes, questions first and a second read of short inputs, and returns a probability for every option from a single prefill. It generates no text, and it has no trained weights, adapters or heads.

This repository holds FlexDM's Decision Index 0.3 public run. The code is at github.com/1000luca/FlexDM (tag v1.0).

Highlights

• 1st among inference techniques on its first board. On the Decision Index 0.4.1 board of 2026-10-21, FlexDM scored a Full score of 67.56, 8th of 223 models, in the #3 tied group: 1st of the 26 inference techniques, and tied 1st with AJev lm6q (LoRA, 67.57) among all entries that are not full fine-tunes.
• New domains 74.92 on that board: the highest of any entry that is not a full fine-tune, 4th overall.
• Still the highest entry on unmodified weights. On the board of 2026-11-06 (275 entries), FlexDM is 22nd. The only inference technique above it is REAX 1.3, an ensemble of fine-tuned models; every other entry above it trains weights.
• Reproduced exactly. The maintainers' rerun with our code agreed on 100.00% of 831 decisions (the bar for FP8 is 96%).
• Fast. Board latency on one RTX PRO 6000: median 109 ms, mean 301 ms, p95 1,106 ms.
• The base of FlexDM-LoRA. FlexDM-LoRA ver 2.1 adds a LoRA adapter to this exact reader and is 4th of 275 (Full 71.61).

The Decision Index leaderboard, Full score view, board data of 2026-10-21. FlexDM · Gemma-4-31B is the blue (inference technique) bar at 67.6, next to AJev lm6q (green, LoRA) in the #3 tied group.

Board result

Jev Decision Index 0.4.1 (PR #246). The Full score is 0.6 × private same-skills tests

• 0.4 × private new-domain tasks, both on the public scale, as the board shows them; the public score is shown but does not count. The board counts Full scores less than 0.9 apart as a tie.

	Board of 2026-10-21	Board of 2026-11-06
Full score	67.56, 8th of 223 models (#3 tied group)	67.56, 22nd of 275
Among inference techniques	1st of 26 (next: Aleria Judge 1.1.1, 66.67)	2nd of 28 (1st: REAX 1.3, an ensemble of fine-tuned models)
Among entries that are not full fine-tunes	tied 1st with AJev lm6q (LoRA, 67.57)
Private tests, same skills (60% of Full)	62.66	62.66
Private tasks, new domains (40% of Full)	74.92: highest of any entry that is not a full fine-tune, 4th overall	74.92, 14th of 275
Public 0.3 index (this dataset; shown, not counted)	63.63	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
Calibration, board measurement	ECE 0.044

Where the gain comes from

The same stock weights, read three ways, on a 2,000-row stratified sample of the public 0.3 suite (vLLM FP8, same GPU):

How it reads	Sample index
state first, then the question	55.39
questions first	60.98
questions first, and inputs up to 3,000 tokens read twice (FlexDM)	62.82

In a paired test on the same sample, reading twice added +1.79 to the sample index (90% interval +0.17 to +3.40).

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

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.

How it answers

<chat head>Questions that will be asked about the context:      1. questions first
- <question 1>
- <question 2>

Context:
<state>

Question: <question i>
Options:
(A) <option>
(B) <option>

Read the same input again before answering:                      2. second copy, for inputs of up to 3,000 tokens
<question list, state, question and options again>
<chat tail, thinking off>Answer: (                               3. read the option labels here

• 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

assets/ holds the banner and the leaderboard screenshot used on this page.

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 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 with the state first, 60.98 with the questions first, 62.82 with the questions first and 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.
• 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.

Citation

@misc{flexdm_2026,
  title  = {FlexDM: reading stock Gemma-4-31B-it for typed decisions},
  author = {1000luca},
  note   = {KAIST EE, FlexML Lab},
  year   = {2026},
  url    = {https://github.com/1000luca/FlexDM}
}

License

The results in this dataset and the FlexDM code are MIT. The base model is © Google, Apache-2.0 (Gemma 4 licence), and is not redistributed here.