samuki-hf/ocaml-test-rollouts

OCaml test-suite rollouts (multilingual LiveCodeBench)

Model-generated test suites for OCaml competitive-programming problems. Each rollout is a language model's response to a problem statement when asked to produce tests for a program solving it, rather than the program itself.

Companion to the OCaml code rollouts in samuki-hf/temperature-sweep-data (rollouts/domain=mlcb/language=ocaml/...), generated over the same problems with the same models, sampling configuration and sample depth, so the two can be joined on question_id.

Contents

436 stdin/stdout problems from multilingual LiveCodeBench (release_v6, contests from 2024-01-01, stdin testtypes only), 100 rollouts per problem per cell, temperature 0.6.

role	what the model was asked for
tests_io	a suite of 4 to 10 stdin/stdout test cases, as one JSON object
tests_ocaml	an OCaml program that emits test inputs and judges the outputs
tests_io_nocopy	as tests_io, with an added instruction not to reuse the statement's examples (pilot only)

Cells: qwen3-8b and qwen3-14b, each in a reasoning (think) and non-reasoning (nothink) arm.

test_rollouts/domain=mlcb/language=ocaml/role=<role>/model=<tag>/temp=0.6/data.parquet
pilot_rollouts/...      smaller 30-problem x 20-sample run, all roles including tests_io_nocopy

Prompts

Every prompt keeps the problem statement byte-identical to the one used for the code rollouts and varies only the instruction block that follows it.

tests_io asks for between 4 and 10 test cases as a single JSON object in a fenced block:

{"tests": [{"input": "3\n1 2 3\n", "output": "6\n"}]}

with the requirement that every input be valid under the problem's stated input format.

tests_ocaml asks for an OCaml program, standard library only, run twice and selecting its mode from Sys.argv.(1):

• inputs prints the number of test cases and then the inputs, separated by ###
• judge reads back the inputs together with the outputs a program under test produced, and prints PASS or FAIL per case

Columns

Matches the code-side rollouts schema, plus role, parse_ok and n_tests.

column	meaning
question_id, instance_id	problem identifiers; instance_id is <question_id>@ocaml
model, thinking_mode, temp, language, role	cell identifiers
sample	0..99 within a problem
raw_text, reasoning_text, answer_text	the completion, split at </think>
extracted_code	the normalised suite JSON, or the OCaml source
parse_ok	the artifact validated: JSON parsed with well-formed tests, or a code block was emitted
n_tests	suite size for the tests_io roles; null for tests_ocaml, which is only decidable by running it
finish_reason, thinking_closed, answer_present	generation status
n_reasoning_tokens, n_answer_tokens, n_total_tokens, sum_logprob	token accounting
sampling_params	JSON string of the decode settings

Invalid rows are kept, not dropped. Filter on parse_ok for usable artifacts. Validity is 92 to 97% for tests_io and 95 to 99% for tests_ocaml.

Generation

vLLM 0.21.0, torch 2.11.0, transformers 4.57.6, seed 42, max_tokens 24576, Qwen3 sampling cards (reasoning: top_p 0.95, top_k 20; non-reasoning: top_p 0.80, top_k 20). Prompts and code extraction come from genlm-eval's livecodebench_multilingual domain, matching the code-side rollouts.

Notes

• Reasoning-arm cells are roughly 100x larger than non-reasoning cells; that is reasoning_text.
• Suite sizes cluster at the top of the requested range: models generally return 10 test cases when asked for "between 4 and 10".
• The tests_ocaml cells under test_rollouts/ use a revised instruction block relative to the pilot_rollouts/ ones: it specifies how judge-mode blocks are separated, notes that inputs may span several lines, and states that the verdict is read from the printed PASS/FAIL lines rather than the process exit status. Do not pool the two.
• Roughly half of the tests_ocaml programs do not compile under ocamlc. Nothing here is filtered on compilability.

Loading

from datasets import load_dataset
ds = load_dataset("samuki-hf/ocaml-test-rollouts", "tests_ocaml", split="train")

A single cell in place:

import pyarrow.parquet as pq
from huggingface_hub import hf_hub_download
p = hf_hub_download("samuki-hf/ocaml-test-rollouts",
      "test_rollouts/domain=mlcb/language=ocaml/role=tests_io/model=qwen3-14b-think/temp=0.6/data.parquet",
      repo_type="dataset")
tbl = pq.ParquetFile(p).read()   # ParquetFile, not read_table: the hive-style key=value
                                 # path makes read_table scan sibling cells