README.md

metadata

pretty_name: Elixir preference optimization — DPO and KTO sets
license: apache-2.0
language:
  - en
tags:
  - elixir
  - code
  - code-generation
  - preference-optimization
  - dpo
  - kto
  - rlhf
  - otp
task_categories:
  - text-generation
size_categories:
  - n<1K
configs:
  - config_name: dpo-failv0
    data_files: data/dpo/dpo_failv0.jsonl
    default: true
  - config_name: kto-v0
    data_files: data/kto/kto_v0.jsonl
  - config_name: onpolicy-micro-dpo-v1
    data_files: data/onpolicy/qwen25c3b_micro_dpo_v1.jsonl
  - config_name: onpolicy-round02-dpo
    data_files: data/onpolicy/qwen25c3b_micro_round2_dpo.jsonl
  - config_name: onpolicy-round04-dpo
    data_files: data/onpolicy/qwen25c3b_micro_round4_dpo.jsonl
  - config_name: onpolicy-round13-dpo
    data_files: data/onpolicy/qwen25c3b_micro_round13_dpo.jsonl
  - config_name: onpolicy-round03-kto
    data_files: data/onpolicy/qwen25c3b_micro_round3_kto.jsonl
  - config_name: onpolicy-round06-kto
    data_files: data/onpolicy/qwen25c3b_micro_round6_kto.jsonl
  - config_name: onpolicy-round11-kto
    data_files: data/onpolicy/qwen25c3b_micro_round11_kto.jsonl

Elixir preference optimization — DPO and KTO sets

909 preference rows in 9 configs for Elixir code models: 654 DPO pairs, 76 balanced KTO examples, and 179 rows from the on-policy Qwen2.5-Coder-3B refinement rounds. Every chosen completion was executed and passed the project's isolated Elixir scorer (compile + ExUnit + static contract checks); every rejected completion was confirmed to fail the intended gate. The frozen evaluation packs are held out: measured prompt-level and module-level collisions are zero for every config.

Do not execute the rejected completions. They are deliberately broken, and some contain intentional defects (swallowed errors, wrong endianness, unsafe state handling). Treat every rejected field as hostile input.

What "preference" means here

These pairs are not style opinions. They encode executable correctness and static contracts for Elixir:

• preference_kind: correctness — the chosen module compiles and passes its tests; the rejected one fails to compile, fails a test, or drops a required contract.
• preference_kind: functional-style — both sides may behave correctly, but the rejected side uses process state, side effects or a non-idiomatic construct where the task explicitly asked for pure functional code. The rejection is a violated static gate, not a matter of taste.

The failure modes were mined from real model output, then re-targeted onto original tasks with new module names and specifications, so no benchmark task is copied into the data.

Configs

config	rows	format	what it is
dpo-failv0	654	DPO pairs	Mined from evaluation failures of gemma12b-elixir-cpt-q4 (40/128) and qwen35-9b-elixir-cpt-sft-q5 (46/128). 534 correctness pairs + 120 functional-style pairs.
kto-v0	76	KTO	Balanced 38 accepted / 38 rejected. Each original task contributes exactly one accepted and one rejected completion; 40 functional-style + 36 correctness rows.
onpolicy-micro-dpo-v1	36	DPO pairs	First on-policy DPO round for the Qwen2.5-Coder-3B depth-expanded checkpoint.
onpolicy-round02-dpo	25	DPO pairs	Round 2: up to three fresh, scorer-gated prompts per construction weakness; format-only pairs excluded.
onpolicy-round04-dpo	11	DPO pairs	Round 4.
onpolicy-round13-dpo	17	DPO pairs	Round 13.
onpolicy-round03-kto	34	KTO	Round 3 KTO: OTP and bit-syntax focus.
onpolicy-round06-kto	22	KTO	Round 6 KTO: functional-style focus (12 functional rows).
onpolicy-round11-kto	34	KTO	Round 11 KTO: four rows per family.

DPO family coverage (dpo-failv0): otp 134, functional 120, binaries 119, beam 66, stdlib 49, errors 47, abstractions 41, core 41, collections 37. The weakness taxonomy is distilled from the failing completions — the largest buckets are format-hygiene (114), enum-state (99), err-swallow (42), edge-empty (42), functional-style-process-state (40), functional-style-agent-state (40), bin-size-guard (33) and bin-endian (24); the complete per-weakness counts are in metadata/dataset_stats.json.

KTO family coverage: functional 40, otp 12, binaries 10, protocol 4, stdlib 4, errors 2, core 2, format 2.

The onpolicy-* configs are checkpoint-specific artifacts of one model's targeted rounds; each round's build manifest (base checkpoint, selection rules, counts, validation) is in metadata/manifests/. If you want a single general preference set, use dpo-failv0 (or kto-v0 for the balanced KTO formulation).

Row schemas

DPO (dpo-failv0 and the on-policy DPO configs) — ShareGPT prompt plus two string completions:

{
  "id": "dpo.binaries.s16be.bin-endian",
  "family": "binaries",
  "source": "elixir_dpo_failv0",
  "weakness": "bin-endian",
  "origin": "designed",
  "preference_kind": "correctness",
  "models": ["gemma12b-elixir-cpt-q4", "qwen35-9b-elixir-cpt-sft-q5"],
  "conversations": [
    {"from": "system", "value": "You are a friendly coding assistant ..."},
    {"from": "human", "value": "Write a module `S16BE` with: ..."}
  ],
  "chosen": "```elixir\ndefmodule S16BE do ... end\n```",
  "rejected": "```elixir\ndefmodule S16BE do ... end\n```"
}

KTO (kto-v0 and the on-policy KTO configs) — TRL conversational schema with a boolean label:

{
  "id": "kto.functional.map-pipeline.chosen",
  "family": "functional",
  "label": true,
  "preference_kind": "functional-style",
  "weakness": "functional-pipeline",
  "prompt": [
    {"role": "system", "content": "You are a friendly coding assistant ..."},
    {"role": "user", "content": "Write a module `KtoFnMapPipeline` with: ..."}
  ],
  "completion": [{"role": "assistant", "content": "```elixir ... ```"}]
}

In DPO files, models records which checkpoints' failures motivated the pair and origin distinguishes designed, handmade and functional-style rows. The on-policy files carry the same fields plus the round-specific annotations.

Loading

from datasets import load_dataset

dpo = load_dataset("jmarceno/elixir-preference", "dpo-failv0", split="train")
kto = load_dataset("jmarceno/elixir-preference", "kto-v0", split="train")
print(dpo[0]["chosen"][:200])
print(kto[0]["label"], kto[0]["prompt"])

Raw JSONL:

from huggingface_hub import hf_hub_download

path = hf_hub_download(
    "jmarceno/elixir-preference", "data/dpo/dpo_failv0.jsonl", repo_type="dataset"
)

Shaping the DPO file for TRL DPOTrainer:

from datasets import load_dataset

ROLE = {"system": "system", "human": "user", "gpt": "assistant"}

def to_dpo(row):
    return {
        "prompt": [
            {"role": ROLE[turn["from"]], "content": turn["value"]}
            for turn in row["conversations"]
        ],
        "chosen": [{"role": "assistant", "content": row["chosen"]}],
        "rejected": [{"role": "assistant", "content": row["rejected"]}],
    }

ds = load_dataset("jmarceno/elixir-preference", "dpo-failv0", split="train")
ds = ds.map(to_dpo, remove_columns=ds.column_names)

The KTO configs already match the TRL KTOTrainer columns (prompt, completion, label) and need no conversion.

Quality gates

• Every chosen completion was executed through the real scorer: compile, generated ExUnit tests, and static contract checks. A row only ships when the chosen side has zero test failures and a clean static result; compile warnings are counted and reported.
• Every rejected completion fails the declared gate for a reason recorded in weakness. For functional-style pairs, the rejected side is behaviourally correct and fails only the declared style gate — that is the teaching signal.
• Ids are unique per file, and prompts are unique per file.
• Zero exact prompt collisions and zero module-name collisions against both frozen evaluation packs.
• metadata/sha256sums.txt lets you confirm the bytes you downloaded are the bytes that passed those gates.

Intended use and limitations

• Intended: DPO or KTO preference tuning of Elixir code models that already produce working code, especially for OTP timeouts, error handling, edge cases, bit syntax and functional style.
• Not intended: as a standalone fine-tuning dataset (use an SFT set first), for instruction-following evaluation, for multi-turn agent data, or for any non-Elixir language.
• 909 rows is small by design. These sets target specific failure families observed in this project's models; they are not a general Elixir preference corpus and will not teach unrelated skills.
• Rejected completions are broken on purpose; never execute them in an unsandboxed process.
• Do not treat the size of a configuration as its importance: the on-policy rounds exist to document a training loop, not to be pooled blindly into a new run.

Provenance and licensing

Rows were authored for this project and mined from this project's own model evaluations on original tasks. No benchmark task and no upstream repository code is redistributed here. The CPT corpora (which do contain upstream Elixir/Erlang sources) are published separately.

Released under Apache-2.0. "Elixir" and "Erlang" are trademarks of their respective owners; this dataset is not affiliated with or endorsed by the Elixir or Erlang teams.

Repository layout

data/dpo/dpo_failv0.jsonl                        dpo-failv0
data/kto/kto_v0.jsonl                            kto-v0
data/onpolicy/qwen25c3b_micro_*_dpo.jsonl        onpolicy-*-dpo configs
data/onpolicy/qwen25c3b_micro_*_kto.jsonl        onpolicy-*-kto configs
metadata/dataset_stats.json                      per-file rows, hashes, families, pack overlap
metadata/sha256sums.txt                          data-file checksums
metadata/provenance.json                         source commit, exclusions, build note
metadata/manifests/*.json                        per-round build manifests

Citation

@dataset{jmarceno_elixir_preference_2026,
  author    = {jmarceno},
  title     = {Elixir preference optimization — DPO and KTO sets},
  year      = {2026},
  publisher = {Hugging Face},
  url       = {https://huggingface.co/datasets/jmarceno/elixir-preference},
  note      = {Apache-2.0}
}