Datasets:

laion
/

laion-voice-profiles-dpo-cfg

+---
+license: cc-by-4.0
+pretty_name: LAION Voice Profiles — contrastive DPO pairs (CFG + phase 2)
+annotations_creators: [machine-generated]
+language_creators: [machine-generated]
+language: [en, de]
+task_categories: [text-to-speech]
+tags: [tts, dpo, preference, rlhf, voice-cloning, speech-emotion, moss, audio-codec, classifier-free-guidance]
+size_categories: [100K<n<1M]
+configs:
+  - config_name: cfg
+    data_files: [{split: train, path: cfg/shard-*.parquet}]
+  - config_name: p2
+    data_files: [{split: train, path: p2/shard-*.parquet}]
+---
+# LAION Voice Profiles — contrastive DPO pairs (CFG + phase 2)
+**Authors: Christoph Schuhmann and LAION.**
+**842,935 preference pairs in four families**, built from the same 500 synthetic voice profiles as
+[`laion/laion-voice-profiles-sft`](https://huggingface.co/datasets/laion/laion-voice-profiles-sft)
+and [`laion/laion-voice-profiles-dpo`](https://huggingface.co/datasets/laion/laion-voice-profiles-dpo).
+These are the two pair families that the sister DPO set does **not** contain: they were built later,
+for two measured defects of the models trained on it, and they are the complete remainder of the
+project's preference material that is publishable under CC-BY-4.0.
+| config | family | pairs | contrast | words in the prompt? |
+|---|---|--:|---|---|
+| `cfg` | `cfg_high` | 237,209 | same voice, matched length, the **top 1 %** of that voice's own range on one measured dimension against the **bottom 1 %**; the instruction asks for the dimension **high**, the high clip is chosen | no — replaced by `...` |
+| `cfg` | `cfg_low` | 237,209 | the **same 237,209 pairs with the roles flipped**: the instruction asks for the dimension **low**, the low clip is chosen | no |
+| `p2` | `p2_emox` | 309,128 | same voice, matched length, **intense on emotion A against intense on emotion B**; the instruction names A | no |
+| `p2` | `p2_len` | 59,389 | the **same clip at its true length against itself cut to 50–75 % or run on to 125–150 %**, with the emotion named | yes — the full timed script |
+Both sides of every pair ship as MOSS-Audio-Tokenizer-v2 codes (`codes` = chosen, `rej_codes` =
+rejected), together with the reference clip the chosen take was generated against (`ref_codes`).
+There is no audio in this repository; the waveforms of every source clip are in
+[`laion/laion-voice-profiles-annotated`](https://huggingface.co/datasets/laion/laion-voice-profiles-annotated)
+and the join is exact — see *The join*.
+---
+## Read this first
+1. **"CFG" is the project's name for the construction, not a guidance scale.** Nothing here was
+   generated with classifier-free guidance and there is no numeric guidance weight anywhere in the
+   data. The name comes from the *shape* of the pair: two clips of one voice that differ only in how
+   strongly one dimension is expressed, put under one prompt that states the level, and emitted in
+   both directions — the same conditional/unconditional contrast that guidance exploits at
+   inference, moved into the preference data. `cfg_high` / `cfg_low` mean "the instruction asked for
+   the dimension high / low", nothing else.
+2. **`uid` is a pair id, not a corpus utterance id.** `cfg<pair_id><h|l>` and
+   `p2<pair_id><e|c|x>`. The source clips are named in `cfg/pairs_index.parquet` and
+   `p2/pairs_index.parquet` (and, for `cfg`, also in the row's own `caption_tpl`), and *those* ids
+   are byte-identical to `uid` in `laion/laion-voice-profiles-annotated`.
+3. **Every row is `src = 0`, i.e. one of the 500 published synthetic voice profiles.** No real
+   recording, no podcast, no broadcast material contributes a clip, a transcript or a word
+   timeline to this set. Checked on every row and every source-clip reference, as an allowlist.
+4. **The words are deliberately absent from three of the four families.** A DPO pair shares one
+   prompt; when chosen and rejected are different recordings with different words, the words would
+   make the preference decidable from the transcript. `cfg_free_text = true` tells the prompt
+   renderer to print `...` for every speech chunk while keeping every pause, duration, burst and
+   direction tag. The `text` column is still shipped — it is the chosen clip's text, for lookup —
+   but it must not go into the prompt of those rows.
+5. **These rows are the training-corpus format, not the sister set's 86-column format.** They
+   are the exact files the two DPO runs below read, shipped unchanged (31 columns, `zstd`, 128
+   shards by `uid` hash). The per-clip annotation stack (40 emotion heads, 57 VoiceNet dimensions,
+   captions, speaker embedding) is not repeated here; it is one join away.
+---
+## Files
+| path | count | size | what |
+|---|--:|--:|---|
+| `cfg/shard-000.parquet` … `shard-127.parquet` | 128 | 3,668,193,909 B | `cfg_high` + `cfg_low`, 474,418 rows, 31 columns |
+| `p2/shard-000.parquet` … `shard-127.parquet` | 128 | 2,822,830,198 B | `p2_emox` + `p2_len`, 368,517 rows, same 31 columns |
+| `cfg/pairs_index.parquet` | 1 | 8,533,671 B | 237,209 base pairs: `pair_id`, `hi_uid`, `lo_uid`, measured values, percentiles, frames |
+| `p2/pairs_index.parquet` | 1 | 9,697,805 B | 368,517 rows: `pair_id`, `ch_uid`, `rj_uid`, percentiles, frames, `mode`, `cut_frames` |
+| `code/build_cfg.py`, `code/build_pairs2.py` | 2 | — | the two builders, verbatim, with their design notes in the docstrings |
+| `code/mix_cfg.py`, `code/mix_pairs2.py` | 2 | — | how the families were concatenated onto the earlier corpora for training |
+| `verify.json` | 1 | — | the verification run reproduced at the end of this card |
+Rows are bucketed by `blake2b(uid) % 128`, so every shard is a uniform random sample of its
+config and the two families of a config are interleaved. Shard `b` of `cfg/` and shard `b` of
+`p2/` are unrelated.
+```python
+from datasets import load_dataset
+cfg = load_dataset("laion/laion-voice-profiles-dpo-cfg", "cfg", split="train")
+p2  = load_dataset("laion/laion-voice-profiles-dpo-cfg", "p2",  split="train")
+```
+---
+## What the pairs are, and why
+Everything the project's models had been trained on *described* an emotion; nothing ever made two
+clips compete on **how strongly** one dimension is expressed. Asked for the 0.90–0.98 percentile of
+a named emotion, the round-3 model landed at 0.34. The two builds here are the two attempts to put
+intensity itself into the preference signal. Quoted numbers below are from the project protocol
+(§16, §I.13 of the technical report) and were re-derived from the shipped files where possible.
+### `cfg` — direction contrast on one measured dimension, both ways
+For one voice and one dimension, the clip pool is that voice's own training clips (1,199,355
+clips over 500 voices in the pool: `src = 0`, not held out, with codes), ranked by the value the
+annotation model **measured** on the finished audio — never by what the generating prompt asked
+for and never by the clip's intended condition.
+* **dimensions**: all **40** emotion heads and **15** VoiceNet ordinal ladders that describe *how*
+  something is spoken — `AROU BRGT CLRT DFLU FULL RANG RESP ROUG STNC TEMP TENS VALN VOLT VULN
+  WARM`. Identity, recording-quality and content heads (`AGEV GEND RCQL BKGN ESTH EXPL`) are
+  excluded: they are not things a performer can be asked to do.
+* **the two clips**: top 1 % against bottom 1 % of *that voice's* distribution (floor of 24 clips
+  per tail when 1 % is smaller). For emotion heads a separation of at least 0.25 corpus IQR is
+  required; realised median corrected percentile of the high clip is **0.998**, of the low clip
+  **0.000**, and the smallest high-minus-low gap in the set is 0.73. For VoiceNet ladders the two
+  clips sit in different ladder buckets (high side mostly buckets 4–6, low side 0–1).
+* **same voice** (`voice_key`), so speaker identity cannot decide the preference; **frames within
+  10 %** (`|f_hi − f_lo| ≤ 0.10 · min`, true on 237,209 / 237,209), so length cannot decide it;
+  **no words**, so the transcript cannot decide it. Language is **not** matched — 54.6 % of pairs
+  are same-language; the row's `lang` is the chosen clip's.
+* **nine base pairs per (voice, dimension) cell**, 237,209 base pairs in all (173,116 on emotion
+  heads, 64,093 on VoiceNet ladders), 408–495 per voice.
+* **both roles.** Every base pair is emitted twice. `cfg_high` (`uid` ends in `h`): instruction
+  asks for the dimension high, `codes` is the high clip, `rej_codes` the low one. `cfg_low` (`l`):
+  instruction asks for it low, roles swap. Each clip is therefore chosen in one row and rejected in
+  another; a policy that simply prefers louder or denser audio scores 50 % on this set, and the only
+  way to win is to condition on the instruction. The two families are balanced to the row.
+**How the level is stated.** For an emotion head the row carries the corpus's own caption form,
+`A voice <band phrase> expressing <emotion>, <prose>; reads as <emotion>`, and `emo_strength` is set
+so the prompt renderer picks the matching band:
+| role | `emo_strength` | band | band phrases | prose tail |
+|---|---|---|---|---|
+| high | 0.95 or 0.99, alternating by `uid` hash | `intense` / `extreme` | *intensely, powerfully, viscerally* / *to the extreme, utterly, overwhelmingly* | the corpus's expressed-side prose for that emotion |
+| low | the low clip's own percentile, capped at 0.60 (0.00 on 162,160 of 173,116 rows) | `faint` | *mildly, slightly, faintly, a little* | one of three generic "barely there" tails |
+The high role alternates between `intense` and `extreme` on purpose: both words are true of a clip
+at percentile 0.998, and a two-point contrast cannot calibrate *between* them. For a VoiceNet
+ladder there is no emotion to name; `caption_general` is `A voice; <clause> is <ladder tag>` and
+`cfg_neutral` carries the direction the renderer puts into the script — `"<tag>, and hold it there;
+otherwise exactly as this voice normally speaks"` — with `emo_strength = null` (128,186 rows).
+### `p2` — the two phase-2 families
+Built after the `cfg` run, for two defects it measured. The base pool and the matching rules are
+the same as above; the selection constants are `HI_PCT = 0.90`, `LO_PCT = 0.50`, `FRAME_TOL =
+0.10`, 8 emotion-contrastive and 6 length pairs per cell, seed 4711.
+**`p2_emox` — intense against intense, for selectivity.** Per-emotion adapters trained on
+intense-versus-mild contrasts raised their own emotion by +0.047 when asked for it — and by +0.033
+when not. "A ratio of 1.4 : 1 is not control, it is tinting" (the builder's docstring). Every
+earlier contrast pits an intense clip against a mild one, so a model can win by being generically
+expressive. Here the chosen clip sits at percentile ≥ 0.90 on the head being asked for *and* has
+that head as its own top emotion; the partner is ≤ 0.50 on that head and ≥ 0.90 on *its* own top
+head. Both sides really are intense, on different emotions, same voice, frames within 10 % (true
+on 309,128 / 309,128), words removed. Each base pair is emitted twice, the mirror naming the
+partner's own top emotion with the roles swapped (154,564 base pairs, 19,884 (voice, emotion)
+cells, all 40 heads). Realised: chosen-side percentile median 0.986 (min 0.900), rejected-side
+median 0.215, median gap 0.76.
+One honest detail about the mirror: the ≤ 0.50 bound was enforced on the *original* direction
+only. In the mirror row the rejected clip is the original's chosen clip, whose percentile on the
+partner's emotion was never constrained. Across all 309,128 rows the rejected side is ≤ 0.50 on the
+named head on 247,324 (80.0 %), above 0.50 on 61,804, and ≥ 0.90 on 14,281 (4.6 %) — those last
+are pairs where one clip is intense on both emotions — and on 3,372 rows (1.1 %) the rejected side
+is actually *higher* on the named head than the chosen one (worst gap −0.095). `p2/pairs_index.parquet` carries `ch_pct`
+and `rj_pct` per row, so you can filter on the gap you want.
+**`p2_len` — the right length, conditioned on the emotion.** The sister set's `truncation` and
+`continuation` families know nothing about emotion and teach "the right length is better" in the
+abstract. Here the speaker, the text and the emotion stay fixed and only the length moves: chosen
+is a clip whose top emotion is at percentile ≥ 0.90, rejected is the **same clip** cut to 50–75 %
+of its frames (`mode = cut`, 29,564 rows; realised keep fraction 0.49–0.75, median 0.62) or run on
+to 125–150 % by appending the opening frames of another clip of the same voice (`mode = ext`,
+29,825 rows; realised 1.23–1.50, median 1.37; the donor is `rj_uid`, same language on 54 %).
+Because the words are shared, the prompt carries the full timed script — the timing tags are
+exactly what the rejected side violates. Clips shorter than 40 frames (3.2 s) were not used.
+### What they trained, and what happened
+| adapter | corpus | pairs seen | reward | WER | emotion pct | quality | burst | burst hit rate |
+|---|---|--:|--:|--:|--:|--:|--:|--:|
+| SFT-3 base, no adapter | — | — | 0.4584 | 0.0987 | 0.3494 | 0.9127 | 0.3564 | 0.666 |
+| previous best DPO (sister families only) | 1,853,486 pairs | step 3216 | 0.4687 | 0.1094 | 0.3401 | 0.9211 | 0.3929 | 0.709 |
+| [`laion/moss-va-sft3-dpo-lora`](https://huggingface.co/laion/moss-va-sft3-dpo-lora) | sister families + **`cfg`** (2,327,904; 20.4 % `cfg`) | step 4912 | 0.4708 | **0.0950** | 0.3373 | **0.9235** | **0.4271** | **0.772** |
+| [`laion/moss-va-sft3-dpo-lora-p2`](https://huggingface.co/laion/moss-va-sft3-dpo-lora-p2) | the above + **`p2`** (2,696,421; 13.7 % `p2`) | step 5022 | **0.4757** | 0.0977 | **0.3541** | 0.9208 | 0.4180 | 0.762 |
+Both runs: LoRA rank 64 on
+[`laion/moss-tts-local-transformer-4.55b-voice-acting-v2-sft3`](https://huggingface.co/laion/moss-tts-local-transformer-4.55b-voice-acting-v2-sft3),
+β 30, lr 1e-6, 256 pairs per step, 8 nodes, stopped by a 6-hour wall clock at roughly half an
+epoch; 80-prompt standard evaluation, 320 clips per row.
+Read plainly: the `cfg` families made the best *general* checkpoint the project had measured —
+word error rate better than the supervised base, the highest quality and burst realisation — and
+did **not** move the thing they were built for; emotion percentile fell. Preference accuracy on the
+`cfg` rows went 0.56 → 0.98, so the model learned to *recognise* the level without gaining the
+ability to *reach* it — the high side of a pair is only as intense as the corpus gets. The `p2`
+families then produced the first preference-tuned model above the supervised baseline on emotion
+percentile (0.3541 against 0.3494, requested band 0.90–0.98), with emotion-contrastive preference
+accuracy 0.951 post-warmup, while `p2_len` saturated at accuracy 1.000 in the second half of the
+run — that family is solved and could be dropped from a future mix. The remaining half epoch of
+each run was never trained.
+---
+## The prompt
+The rows carry the *ingredients* of the prompt, not the rendered string, because the renderer is
+stochastic (direction placement, timed/untimed script, burst dropout, reference-versus-name slot,
+all drawn per step). The training code rendered every row into the base model's `<user_inst>`
+template with `prompt_lib2.render_prompt` (format hash `073aeb09dc923376`); the renderer itself
+is part of the training stack and is not shipped here. What it does with the columns of this set:
+* `caption_general` → the `GENERAL:` line (the level statement for emotion rows);
+* `text` + `words_json` + `burst_*` + `dur_s` → the timed `SCRIPT:` — segment durations, pauses,
+  detected bursts with their lengths, and the delivery direction drawn from `emo_strength`'s band
+  (or `cfg_neutral` for VoiceNet rows);
+* `cfg_free_text = true` → every speech chunk of that script becomes `...`;
+* `frames` → the `- Tokens:` budget; `lang` → `- Language:`; `ref_codes` → the `<|audio|>`
+  reference slot, or `Speaker: <speaker_name>` in name mode.
+Two rows of this set, rendered by that code (reference-audio mode):
+`cfg_high`, emotion head *Intoxication*, uid `cfgd0ac06bc0eea0a5f4dcch`:
+```
+<user_inst>
+- Reference(s):
+<|audio|>
+- Instruction:
+GENERAL: A voice utterly expressing intoxication, a woozy, slurring voice, intoxicated and untethered, in an altered haze, impossible to hide; reads as intoxication altered states of consciousness
+SCRIPT:
+(not holding it together at all, breath shallow and fast, the fear plain in the voice, unguarded; completely intoxicated) [4.3 seconds duration] ... [0.5 seconds pause] (keep it overwhelmingly intoxicated) [2.7 seconds duration] ...
+- Tokens:
+94
+- Quality:
+None
+- Sound Event:
+None
+- Ambient Sound:
+None
+- Language:
+English
+- Text:
+(not holding it together at all, breath shallow and fast, the fear plain in the voice, unguarded; completely intoxicated) [4.3 seconds duration] ... [0.5 seconds pause] (keep it overwhelmingly intoxicated) [2.7 seconds duration] ...
+</user_inst>
+```
+`cfg_low`, VoiceNet ladder *WARM* (timbre), uid `cfga19aa3876e64686f91c1l` — no `GENERAL:` line,
+the level sits in the script as `cfg_neutral`:
+```
+- Instruction:
+SCRIPT:
+[5.5 seconds pause] (slightly cool, and hold it there; otherwise exactly as this voice normally speaks) [1.4 seconds duration] ... [0.8 seconds pause] [3.2 seconds duration] ... [0.3 seconds pause]
+- Tokens:
+140
+```
+A `p2_len` row renders the same way with the words present in the script. The `[n seconds
+duration]` and `[n seconds pause]` tags come from `words_json`; the `(burst, n seconds)` tags from
+`burst_starts` / `burst_ends` / `burst_labels`; the parenthesised directions are drawn from the
+band and are not stored in the row.
+---
+## Columns — the 31 columns of `cfg/shard-*` and `p2/shard-*`
+| column | type | meaning |
+|---|---|---|
+| `uid` | `string` | pair-row id. `cfg` + 20-hex `pair_id` + `h`/`l` (role), or `p2` + 9-digit `pair_id` + `e`/`c`/`x` (`emox` / `cut` / `ext`). Unique across the whole set. |
+| `family` | `string` | `cfg_high`, `cfg_low`, `p2_emox`, `p2_len` |
+| `src` | `int8` | source group of the training corpus; **0 on every row** = synthetic voice profile |
+| `voice_key` | `string` | voice-profile id, one of the 500 (`anime_000`, `emolia_c0123`, `mediathek_…`, `refvoice_…`, `k<n>_age<n>_bg<n>`); both clips of the pair share it |
+| `lang` | `string` | `en` / `de` — of the **chosen** clip; the rejected clip of a `cfg` / `p2_emox` pair may be in the other language |
+| `text` | `string` | the chosen clip's generation text, verbatim (may contain the generator's own parenthesised burst directions). **Not** in the prompt when `cfg_free_text` is true. |
+| `text_bursts` | `string` | `text` with the *detected* vocal bursts inserted inline as `(label)`; equals `text` when nothing was detected (73 % of `cfg` rows, 75 % of `p2`) |
+| `caption_general` | `string` | the level statement. Emotion rows: `A voice <band> expressing <emotion>, <prose>; reads as <emotion>`. VoiceNet rows: `A voice; <clause> is <tag>`. |
+| `caption_script` | `string` | always empty in this set |
+| `caption_tpl_text` | `string` | always empty in this set |
+| `caption_tpl` | `string` | provenance key. `cfg`: `cfg\|<emo\|vn>\|<dimension>\|<hi_uid>\|<lo_uid>`. `p2`: `p2\|<emox\|len>\|<emox\|cut\|ext>\|<dimension>` |
+| `speaker_name` | `string` | the voice's assigned given name (the same mapping as `names.csv` in the sister set) |
+| `spoken_dur_s` | `float32` | end of the last aligned word of the chosen clip, seconds |
+| `dur_s` | `float32` | duration of the chosen clip, seconds (generator's pre-encode measurement; `frames == round(dur_s · 12.5)`) |
+| `words_json` | `string` | JSON list `[{"w","s","e"}, …]` — MMS_FA forced alignment of the chosen clip's text, seconds |
+| `burst_starts` / `burst_ends` | `list<float32>` | detected vocal-burst spans in the chosen clip, seconds |
+| `burst_labels` | `list<string>` | their class labels (`Contented Sigh`, `Breathy Giggle`, …) |
+| `in_extreme` | `bool` | legacy flag of the older corpus; **always false** here (`emo_strength` carries the band instead) |
+| `frames` | `int32` | MOSS frames of the chosen clip |
+| `codes` | `binary` | **chosen** MOSS codes, little-endian `uint16`, `frames × 12` values |
+| `rej_frames` | `int32` | MOSS frames of the rejected side |
+| `rej_codes` | `binary` | **rejected** MOSS codes, same layout. `cfg` / `p2_emox`: the other clip; `cut`: a frame-aligned prefix of `codes`; `ext`: `codes` followed by `cut_frames` frames of the donor |
+| `ref_frames` | `int32` | MOSS frames of the reference clip |
+| `ref_codes` | `binary` | the reference clip the chosen take was paired with in the training corpus — another take of the same voice; its uid is not carried in these rows |
+| `has_ref` | `bool` | always true here |
+| `is_val` | `bool` | `blake2b(uid) % 1000 == 0` — the training runs' held-out rows (490 in `cfg`, 373 in `p2`); shipped, not excluded |
+| `cfg_free_text` | `bool` | render the script without words. True on every `cfg` row and every `p2_emox` row, false on `p2_len` |
+| `cfg_neutral` | `string` | VoiceNet rows only: the direction stating the ladder tag (`"very tense, and hold it there; otherwise exactly as this voice normally speaks"`); empty elsewhere |
+| `emo_strength` | `float32`, nullable | the emotion band the prompt states, as a percentile: 0.95 / 0.99 for the high or named side, ≤ 0.06 for `cfg_low` emotion rows, **null** on VoiceNet rows |
+### `cfg/pairs_index.parquet` — 237,209 rows, one per base pair
+| column | type | meaning |
+|---|---|---|
+| `pair_id` | `string` | 20 hex characters; the row uids are `cfg{pair_id}h` and `cfg{pair_id}l` |
+| `voice_key` | `string` | the voice |
+| `dim` | `string` | emotion head name or VoiceNet code |
+| `kind` | `string` | `emo` (173,116) or `vn` (64,093) |
+| `hi_uid` / `lo_uid` | `string` | the high and the low clip — **uids of `laion/laion-voice-profiles-annotated`** |
+| `hi_val` / `lo_val` | `float32` | the measured value of `dim` on each clip (emotion intensity, or VoiceNet regression) |
+| `hi_frames` / `lo_frames` | `int32` | their MOSS frames |
+| `hi_pct` / `lo_pct` | `float32` | `emo`: tie-aware corpus ECDF percentile of the value; `vn`: the ladder bucket (0–6) as a float |
+### `p2/pairs_index.parquet` — 368,517 rows, one per shipped row
+| column | type | meaning |
+|---|---|---|
+| `pair_id` | `string` | 9 digits; the row uid is `p2{pair_id}{mode[0]}` |
+| `family` | `string` | `emox` or `len` (the row's `family` is `p2_` + this) |
+| `voice_key`, `dim` | `string` | the voice; the emotion head the instruction names |
+| `ch_uid` | `string` | the chosen clip — uid in `laion/laion-voice-profiles-annotated` |
+| `rj_uid` | `string` | `emox`: the rejected clip; `cut`: equal to `ch_uid`; `ext`: the donor whose opening frames are appended |
+| `ch_pct` / `rj_pct` | `float32` | percentile of `dim` on the chosen / rejected clip (`len`: both the chosen clip's own top-head percentile) |
+| `ch_frames` / `rj_frames` | `int32` | `emox`: frames of the two clips; `cut`: `rj_frames` is the kept prefix length; `ext`: `rj_frames` is the number of donor frames appended |
+| `mode` | `string` | `emox` / `cut` / `ext` |
+| `cut_frames` | `int32` | `cut`: frames kept; `ext`: frames appended; `emox`: 0 |
+---
+## The join
+`hi_uid`, `lo_uid`, `ch_uid`, `rj_uid` **are** the `uid` column of
+[`laion/laion-voice-profiles-annotated`](https://huggingface.co/datasets/laion/laion-voice-profiles-annotated)
+(`index/origin=original/`, and the tar member stem under `data/origin=original/`), of the form
+`<voice>__<block>__<cell>__<lang>.cNNN` — e.g. `anime_000__E__Affection__D__de.c037`. Verified
+byte-for-byte on the released index (see below). From there you have the MP3, the 205-column
+annotation, the speaker embedding, and — via the same uid — the rows of
+`laion/laion-voice-profiles-sft` and `-dpo`.
+```python
+import numpy as np, pyarrow.parquet as pq, pyarrow.dataset as ds
+def codes(b, frames, n_vq=12):
+    return np.frombuffer(b, dtype="<u2").reshape(frames, n_vq)
+row = pq.read_table("cfg/shard-000.parquet").slice(0, 1).to_pylist()[0]
+chosen, rejected = codes(row["codes"], row["frames"]), codes(row["rej_codes"], row["rej_frames"])
+# which clips are these?  (cfg: also readable from caption_tpl.split("|")[3:5])
+idx = pq.read_table("cfg/pairs_index.parquet").to_pandas().set_index("pair_id")
+p   = idx.loc[row["uid"][3:-1]]
+chosen_uid, rejected_uid = (p.hi_uid, p.lo_uid) if row["uid"].endswith("h") else (p.lo_uid, p.hi_uid)
+# the same for p2
+row = pq.read_table("p2/shard-000.parquet").slice(0, 1).to_pylist()[0]
+p   = pq.read_table("p2/pairs_index.parquet").to_pandas().set_index("pair_id").loc[row["uid"][2:-1]]
+chosen_uid, rejected_uid, mode = p.ch_uid, p.rj_uid, p.mode     # rj_uid == ch_uid when mode == "cut"
+# audio + full annotation, from the annotated corpus (local snapshot)
+ann = ds.dataset("laion-voice-profiles-annotated/index", partitioning="hive", format="parquet")
+a   = ann.to_table(filter=ds.field("uid") == chosen_uid).to_pylist()[0]
+# tar: data/origin=original/{a['shard']}.tar, members {chosen_uid}.mp3 / .json / .moss.npy / .vclap.npy
+```
+`uid` in the annotated corpus **contains dots** — do not split on the first one. Its
+`audio_key` is not unique across runs; join on `uid`.
+---
+## MOSS codes
+`codes`, `rej_codes`, `ref_codes` are raw little-endian `uint16`, `(frames, 12)` after reshape:
+**12 codebooks × 1024 entries at 12.5 fps, one frame = 12 tokens = 80 ms.** There is no 32-token
+block and no interleaving; the 32 associated with this stack is the codec's `num_quantizers`, of
+which the TTS model consumes the first 12. Every `cut` boundary is a whole frame. The `p2` builder drops
+rejected sides longer than 620 frames (49.6 s); the training corpus caps chosen takes the same way.
+**These codes are from the corrected tokenisation.** The voice-profile corpus once carried codes
+computed on a half-speed decode (a stereo-to-mono bug that doubled every duration and frame count
+in the first annotation tree). The frame counts here were compared, clip by clip, with
+`moss_frames` of the released annotated index for 1,322 clip references of voice `anime_000`
+(its first three index parts): ratio **1.00 on every one**, and `dur_s` likewise. Nothing in this set comes from the broken tree.
+---
+## The material this is built from
+500 synthetic **voice profiles**, each one reference speaker driven through a fixed matrix of 842
+named acting conditions in English and German, keeping every candidate take. Generator
+[`laion/moss-tts-local-transformer-4.55b-voice-acting-v2`](https://huggingface.co/laion/moss-tts-local-transformer-4.55b-voice-acting-v2),
+codec [`OpenMOSS-Team/MOSS-Audio-Tokenizer-v2`](https://huggingface.co/OpenMOSS-Team/MOSS-Audio-Tokenizer-v2),
+run `vprof_base`. The full corpus with audio and the complete annotation stack is
+`laion/laion-voice-profiles-annotated`; the per-voice LoRAs and reference clips are
+[`laion/moss-voice-profile-loras-500`](https://huggingface.co/laion/moss-voice-profile-loras-500).
+The clip pool for both builds is the voice-profile part of the project's second training corpus
+(`src = 0`, 1,199,355 clips) — the same top-3-per-cell takes that make up
+`laion/laion-voice-profiles-sft` (1,200,531 rows), minus the corpus's 1-in-1000 held-out rows, joined
+with the corrected re-annotation. The source clips span every block of the matrix — for
+the `cfg` high side, 115,656 come from emotion cells, 88,904 from VoiceNet cells, 22,562 from edge
+cases, 6,532 from character voices, 2,957 from isolated bursts, 380 sports and 218 explicit cells —
+because the ranking is by the measured value, not by the cell.
+The measured values that rank the clips are the 40 Empathic-Insight emotion intensities and the 57
+VoiceNet regressions of the corrected re-annotation (`laion/voiceclap-commercial` →
+`laion/voicenet-dimension-predictors-commercial`), with the percentiles taken from the project's
+tie-aware ECDF over 132.8 M rows pooled across its corpora. The same caveat as on the sister cards
+applies: these are model outputs, not human ratings, and the VoiceNet heads were trained on
+Gemini perceptual estimates (mean r 0.79).
+---
+## Limitations, honestly
+* **No human has listened to any pair in a controlled study.** "High" and "low" are model
+  measurements on model output.
+* **The high side is only as intense as the corpus gets.** These pairs teach the *direction* of a
+  dimension within a voice's own range; they cannot teach a level the generator never produced.
+  That is exactly the result the `cfg` run showed.
+* **Language is not matched within a `cfg` / `p2_emox` pair** (54.6 % / 59.1 % same-language).
+  The prompt states the chosen clip's language and the words are absent, so the mismatch is not
+  visible in the prompt — but the rejected side may be a German clip against an English prompt.
+* **The `p2_emox` mirror rows are looser than the original direction** (20.0 % of rows with the
+  rejected side above 0.50 on the named head; 4.6 % at or above 0.90). Filter on `rj_pct` if you
+  want the strict version.
+* **`p2_len` negatives are constructed, not observed**, and the `ext` splice has no crossfade.
+  Its preference accuracy saturated at 1.000 during training; it carries little signal for a model
+  that already handles timing tags.
+* **The rendered prompts are not shipped**, only their ingredients; reproducing them exactly needs
+  the project's renderer. The example strings above are what the trainer saw.
+* **Speaker identity is weak against the nominal reference, everywhere**, as inherited from the
+  generation run (per-voice mean `spk_sim` 0.18–0.69 in the sister set). Same voice within a pair
+  is guaranteed by `voice_key`, not by a similarity threshold.
+---
+## What is, and is not, in the sister sets
+| repository | families | relation to this set |
+|---|---|---|
+| [`laion/laion-voice-profiles-dpo`](https://huggingface.co/datasets/laion/laion-voice-profiles-dpo) | `emotion`, `truncation`, `continuation` — 3,451,531 pairs | the `vp_*` families of the training corpora; **none of the four families here** |
+| [`laion/tts-realspeech-dpo-en-de`](https://huggingface.co/datasets/laion/tts-realspeech-dpo-en-de) | `too_short`, `too_long` on real speech — 3,959,192 pairs | the `rs_*` families; real recordings, disjoint by construction (`src ≠ 0`) |
+| **this set** | `cfg_high`, `cfg_low`, `p2_emox`, `p2_len` — 842,935 pairs | the remainder |
+The training corpora were nested unions: `dpo_corpus2` (1,853,486, sister families) ⊂
+`dpo_corpus_cfg` (+ `cfg`, 2,327,904) ⊂ `dpo_corpus_p2` (+ `p2`, 2,696,421). `code/mix_cfg.py` and
+`code/mix_pairs2.py` are the two concatenations. Overlap was checked, not assumed:
+every `uid`,
+`chosen_uid`, `rejected_uid`, `ref_uid` and `donor_uid` of all 1,922 parquet files of both sister sets
+(7,410,723 rows) was read, and **none of the 237,209 `cfg` base pairs and none of the 154,564
+`p2_emox` base pairs is a `(chosen, rejected)` tuple of the sister `emotion` family (1,064,594
+tuples), in either order.** What *is* shared is the pool: all 332,576 / 342,284 source clips appear
+in the sister set as a chosen take, because both are built from the same top-3 selection, and every
+`p2_len` chosen clip also has a `truncation` and a `continuation` negative there — cut at a sentence
+boundary in the 30–85 % window rather than at 50–75 % of the frames, so the pairs differ. No row of
+this set is a copy of a row there.
+---
+## Verification run on the shipped files
+| check | result |
+|---|---|
+| rows shipped | `cfg` **474,418** (`cfg_high` 237,209 · `cfg_low` 237,209) · `p2` **368,517** (`p2_emox` 309,128 · `p2_len` 59,389) — counted with `pyarrow` over all 256 shards |
+| languages (of the chosen clip) | `cfg` en 227,068 / de 247,350 · `p2` en 179,649 / de 188,868 |
+| `uid` unique across each config | 474,418 / 474,418 · 368,517 / 368,517 |
+| `src == 0` | 474,418 / 474,418 · 368,517 / 368,517 |
+| `voice_key` is one of the 500 published profiles | 474,418 / 474,418 · 368,517 / 368,517 (500 voices in each config) |
+| every source-clip reference is `<voice>__<block>__<cell>__<lang>.cNNN` with `voice` in the 500 | 1,423,254 / 1,423,254 (`cfg`, index + `caption_tpl`) · 737,034 / 737,034 (`p2`); **0** matches to any real-speech or broadcast uid pattern |
+| every row has an entry in its `pairs_index.parquet` | 474,418 / 474,418 · 368,517 / 368,517 |
+| sample join, 200 rows per family: role, `voice_key`, `frames`, `rej_frames` agree with the index | 200 / 200 on `cfg_high`, `cfg_low`, `p2_emox`; 82 / 82 on `p2_len` |
+| code buffer length `== frames × 12 × 2` for `codes`, `rej_codes`, `ref_codes` | 682 / 682 sampled rows |
+| all codes in 0..1023 | 682 / 682 |
+| `abs(frames − round(dur_s × 12.5)) ≤ 1` | 682 / 682 |
+| `cut`: `rej_codes` is a frame-aligned prefix of `codes` | 41 / 41 sampled |
+| `ext`: `rej_codes` begins with all of `codes` | 41 / 41 sampled |
+| frame tolerance `|f_hi − f_lo| ≤ 0.10 · min` | 237,209 / 237,209 `cfg` base pairs · 309,128 / 309,128 `p2_emox` rows |
+| frames and `dur_s` against the released annotated index (`moss_frames`, `dur_s`) | 1,322 / 1,322 clip references at ratio 1.00 — the corrected tokenisation |
+| `has_ref` | true on every row |
+| `in_extreme`, `caption_script`, `caption_tpl_text` | always false / empty / empty, all rows |
+| overlap with `laion/laion-voice-profiles-dpo` and `laion/tts-realspeech-dpo-en-de` | 7,410,723 sister rows read; **0** identical pairs; 0 / 800 sampled row uids present there |
+| files on the Hub vs. local, `HfApi.repo_info(files_metadata=True)` | **258 / 258** files, size and LFS sha256 identical, **6,509,255,583 bytes** |
+Each check re-derives a property from a quantity other than the one the writer used — frames
+against `dur_s`, code length against the declared frame count, the row's frames against the pair
+index, the pair index against the released annotated index — rather than re-running the builders.
+---
+## Licence and attribution
+**CC-BY-4.0.** Credit **Christoph Schuhmann** and **LAION**, and the upstream sources listed in
+`laion/laion-voice-profiles-annotated`. Every clip referenced here is model output from one of the
+500 synthetic profiles; no take is a recording of a person, and no clip, transcript or timeline from
+the project's real-speech or broadcast corpora is included.
+```bibtex
+@misc{schuhmann2026voiceprofilesdpocfg,
+  title  = {LAION Voice Profiles -- contrastive DPO pairs (CFG + phase 2)},
+  author = {Schuhmann, Christoph and LAION},
+  year   = {2026},
+  url    = {https://huggingface.co/datasets/laion/laion-voice-profiles-dpo-cfg}
+}
+```

code/build_cfg.py ADDED Viewed

	@@ -0,0 +1,401 @@

+#!/usr/bin/env python3
+"""Classifier-free-guidance CONTRAST PAIRS for the DPO corpus.
+THE MEASURED PROBLEM.  The round-3 evaluation asks for percentile 0.90-0.98 of a named emotion and
+the model lands at 0.34 on the zero-point-corrected scale.  Everything the model has been trained
+on told it ABOUT an emotion; nothing ever made two clips compete on HOW STRONGLY one dimension is
+expressed.  Intensity was described, never contrasted.
+THE PAIR.  For one voice and one measured dimension, take a clip in the top 1 % of THAT VOICE's
+own distribution and a clip in its bottom 1 %, and put them against each other under ONE prompt:
+  * SAME VOICE (`voice_key`).  Across voices the preference would be decidable from speaker
+    identity, and the model would learn to pick a speaker rather than a level.
+  * FRAME BUDGET within 10 %.  A DPO pair shares one prompt and therefore one `Tokens:` value.
+    If the two clips differ in length the preference is decidable from length -- which is the one
+    thing the round-1 corpus already over-taught -- and nothing about intensity would be learned.
+  * NO WORDS.  `cfg_free_text` renders every speech chunk as `...` and keeps every tag: the
+    pauses, the per-segment durations, the burst labels and lengths, the delivery direction and
+    the token budget.  Two clips of the same voice say different words; leaving the words in
+    would make the preference decidable from the transcript.
+  * BOTH ROLES.  Every pair is emitted TWICE, flipped: with the instruction asking for the
+    dimension HIGH the high clip is chosen, and with the instruction asking for it LOW the low
+    clip is chosen.  This is the whole point.  Each clip therefore appears as chosen in one row
+    and as rejected in another, so a policy that simply prefers louder/denser audio scores 50 %
+    and the only way to win is to condition on the instruction.
+THE MEASURED VALUE IS THE HINDSIGHT ONE.  Clips are ranked by the value the annotation model
+MEASURED on the finished audio (`emo40` / `vn57` in corpus v2), never by what the generating
+prompt asked for and never by the uid's intended emotion bucket.  For the voice-profile corpus
+those two disagree often enough to matter: a clip generated "for Anger" is not necessarily in the
+top of the Anger head.
+DIMENSIONS.  All 40 emotion heads, plus the 15 VoiceNet ordinal ladders from the project's own
+caption vocabulary (`tokcorpus/code/caption2.py` L7) that describe HOW something is spoken.  The
+identity, recording-quality and content heads (AGEV, GEND, RCQL, BKGN, ESTH, EXPL) are excluded:
+they are not things a performer can be asked to do.  The ladder-to-column mapping and its polarity
+were verified empirically on 147,190 corpus rows -- mean `vn57` value rises monotonically with the
+caption's own ladder bucket on every one of the 15.
+HOW THE LEVEL IS STATED IN THE PROMPT.
+  * emotion dims: through the two channels the corpus already uses, so the surface stays in
+    distribution.  `caption_general` gets the corpus's own opening sentence for that emotion at
+    the requested band plus a `reads as <emotion>` clause, which is what `directions.
+    emotions_from_row` reads; `emo_strength` is set so `prompt_lib2._band` returns the requested
+    band, which is what picks the intensity adverb of the inline direction.  The two rows of a
+    pair differ in the band word and in nothing else.
+  * VoiceNet dims: those have no emotion to name, so the row carries `cfg_neutral`, which
+    overrides `directions.NEUTRAL` for the emotion-free branch and states the ladder tag the
+    clip actually measured at ("very tense, and hold it there").
+"""
+import argparse, glob, hashlib, json, os, random, re, sys, time
+from collections import defaultdict
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+NB = "/e/data1/datasets/playground/mmlaion/schuhmann1/dramabox"
+sys.path[:0] = [f"{NB}/train2/code", f"{NB}/train2/code/grpo"]
+import directions as DIR
+from select_emo1 import VN_ORDER, emo_names
+import reward as RW
+SRC = f"{NB}/train2/corpus"
+WORK = "/e/scratch/reformo/schuhmann1_moss/cfg_work"
+PAIRS = f"{WORK}/cfg_pairs.parquet"
+ROWS = "/e/scratch/reformo/schuhmann1_moss/cfg_rows"
+NBUCKET = 128
+TAIL_MIN = 24            # "top N / bottom N" floor when 1 % of the voice is smaller than this
+TAIL_FRAC = 0.01
+PAIRS_PER_CELL = 9       # base pairs; each is emitted twice (flipped), so 18 rows per cell
+FRAME_TOL = 0.10         # |f_hi - f_lo| <= FRAME_TOL * min(f_hi, f_lo)
+GAP_IQR = 0.25           # emotion dims: required separation, as a fraction of the corpus IQR
+# The 15 VoiceNet ordinal ladders that describe HOW something is spoken, with the caption clause
+# they belong to.  Verbatim from tokcorpus/code/caption2.py L7 (post-2026-08-22 polarity fix).
+VN_LADDER = {
+ "AROU": ("delivery", ["lethargic","very low-energy","subdued","normally alert","energised","highly aroused","frantic"]),
+ "VALN": ("affect",   ["deeply negative","negative","mildly negative","neutral","mildly positive","positive","elated"]),
+ "TEMP": ("delivery", ["very slow","slow","measured","normal-paced","brisk","fast","very fast"]),
+ "WARM": ("timbre",   ["cold","cool","slightly cool","neutral-toned","slightly warm","warm","very warm"]),
+ "BRGT": ("timbre",   ["very dark","dark","slightly dark","neutral-bright","slightly bright","bright","very bright"]),
+ "TENS": ("delivery", ["fully relaxed","relaxed","slightly relaxed","neutral tension","slightly tense","tense","very tense"]),
+ "VOLT": ("delivery", ["completely steady","steady","fairly steady","moderately variable","variable","volatile","highly volatile"]),
+ "ROUG": ("timbre",   ["very smooth","smooth","fairly smooth","slightly rough","rough","very rough","gravelly"]),
+ "CLRT": ("speech",   ["very slurred","slurred","somewhat unclear","average clarity","clear","very clear","crisply articulate"]),
+ "DFLU": ("speech",   ["no disfluency","almost no disfluency","little disfluency","some disfluency","frequent disfluency","heavy disfluency","severely disfluent"]),
+ "RESP": ("speech",   ["no audible breath","minimal breath","light breath","normal breath","audible breath","heavy breath","breathless"]),
+ "RANG": ("speech",   ["monotone pitch","narrow pitch range","fairly narrow pitch","moderate pitch range","wide pitch range","very wide pitch range","extreme pitch range"]),
+ "FULL": ("timbre",   ["very thin","thin","slightly thin","balanced body","full","very full","booming"]),
+ "VULN": ("affect",   ["guarded","fairly guarded","slightly guarded","neutral openness","slightly vulnerable","vulnerable","very vulnerable"]),
+ "STNC": ("affect",   ["very submissive","submissive","slightly submissive","neutral stance","slightly dominant","dominant","very dominant"]),
+}
+VN_DIMS = list(VN_LADDER)
+SCHEMA = pa.schema([
+    ("uid", pa.string()), ("family", pa.string()), ("src", pa.int8()),
+    ("voice_key", pa.string()), ("lang", pa.string()),
+    ("text", pa.string()), ("text_bursts", pa.string()),
+    ("caption_general", pa.string()), ("caption_script", pa.string()),
+    ("caption_tpl_text", pa.string()), ("caption_tpl", pa.string()),
+    ("speaker_name", pa.string()), ("spoken_dur_s", pa.float32()), ("dur_s", pa.float32()),
+    ("words_json", pa.string()),
+    ("burst_starts", pa.list_(pa.float32())), ("burst_ends", pa.list_(pa.float32())),
+    ("burst_labels", pa.list_(pa.string())), ("in_extreme", pa.bool_()),
+    ("frames", pa.int32()), ("codes", pa.binary()),
+    ("rej_frames", pa.int32()), ("rej_codes", pa.binary()),
+    ("ref_frames", pa.int32()), ("ref_codes", pa.binary()), ("has_ref", pa.bool_()),
+    ("is_val", pa.bool_()),
+    # ---- new in the CFG build; both are no-ops when absent/False/null
+    ("cfg_free_text", pa.bool_()), ("cfg_neutral", pa.string()),
+    ("emo_strength", pa.float32()),
+])
+PAIR_SCHEMA = pa.schema([
+    ("pair_id", pa.string()), ("voice_key", pa.string()), ("dim", pa.string()),
+    ("kind", pa.string()),                       # "emo" | "vn"
+    ("hi_uid", pa.string()), ("lo_uid", pa.string()),
+    ("hi_val", pa.float32()), ("lo_val", pa.float32()),
+    ("hi_frames", pa.int32()), ("lo_frames", pa.int32()),
+    ("hi_pct", pa.float32()), ("lo_pct", pa.float32()),      # corrected ecdf pct (emo) or bucket (vn)
+])
+def _uid_hash(u):
+    return int.from_bytes(hashlib.blake2b(u.encode(), digest_size=8).digest(), "big")
+# ------------------------------------------------------------------ stage 1: choose the pairs
+LIGHT = ["uid", "src", "voice_key", "frames", "dur_s", "is_val", "emo40", "vn57"]
+def stage_select():
+    E = emo_names()
+    ecdf = RW.Ecdf()
+    fs = sorted(glob.glob(f"{SRC}/shard-*.parquet"))
+    uids, vk, fr, dur, Em, Vm = [], [], [], [], [], []
+    t0 = time.time()
+    st = defaultdict(int)
+    for k, f in enumerate(fs):
+        d = pq.read_table(f, columns=LIGHT).to_pydict()
+        keep = [i for i in range(len(d["uid"]))
+                if d["src"][i] == 0 and not d["is_val"][i] and (d["frames"][i] or 0) > 0]
+        st["rows_total"] += len(d["uid"])
+        st["rows_vp_train"] += len(keep)
+        if not keep:
+            continue
+        uids += [d["uid"][i] for i in keep]
+        vk += [d["voice_key"][i] for i in keep]
+        fr += [int(d["frames"][i]) for i in keep]
+        dur += [float(d["dur_s"][i] or 0.0) for i in keep]
+        Em.append(np.stack([np.frombuffer(d["emo40"][i], np.float32) for i in keep]))
+        Vm.append(np.stack([np.frombuffer(d["vn57"][i], np.float32) for i in keep]))
+        if k % 32 == 0:
+            print(f"[sel] {k+1}/{len(fs)} rows={len(uids):,} {time.time()-t0:.0f}s", flush=True)
+    Em = np.concatenate(Em, 0)
+    Vm = np.concatenate(Vm, 0)
+    fr = np.asarray(fr, np.int32)
+    dur = np.asarray(dur, np.float32)
+    n = len(uids)
+    print(f"[sel] voice-profile training clips {n:,}  emo40={Em.shape} vn57={Vm.shape}", flush=True)
+    # corpus IQR per emotion head -> the minimum separation a pair must show
+    emo_gap = {}
+    for j, h in enumerate(E):
+        q1, q3 = np.percentile(Em[:, j], [25, 75])
+        emo_gap[h] = float(GAP_IQR * max(q3 - q1, 1e-9))
+    by_voice = defaultdict(list)
+    for i, v in enumerate(vk):
+        by_voice[v].append(i)
+    print(f"[sel] voices {len(by_voice):,}", flush=True)
+    rows = []
+    rng = random.Random(90210)
+    for vi, (voice, idx) in enumerate(sorted(by_voice.items())):
+        idx = np.asarray(idx)
+        N = max(TAIL_MIN, int(round(TAIL_FRAC * len(idx))))
+        if len(idx) < 2 * N:
+            st["voice_too_small"] += 1
+            continue
+        st["voices_used"] += 1
+        for kind, dims in (("emo", E), ("vn", VN_DIMS)):
+            for dj, dim in enumerate(dims):
+                jj = -1 if kind == "emo" else VN_ORDER.index(dim)
+                col = (Em[idx, dj] if kind == "emo" else Vm[idx, jj])
+                order = np.argsort(col, kind="stable")
+                lo_i = idx[order[:N]]
+                hi_i = idx[order[-N:]][::-1]          # strongest first
+                st["cells"] += 1
+                # value gate
+                if kind == "emo":
+                    gap = emo_gap[dim]
+                    ok_pair = lambda a, b: (Em[a, dj] - Em[b, dj]) >= gap
+                else:
+                    L = VN_LADDER[dim][1]
+                    nb = len(L) - 1
+                    bk = lambda x: int(min(nb, max(0, round(float(x)))))
+                    ok_pair = lambda a, b, _j=jj: bk(Vm[a, _j]) > bk(Vm[b, _j])
+                # greedy: strongest high first, matched to the weakest low whose frame budget is
+                # within tolerance and whose value gap clears the gate
+                used = set()
+                got = []
+                for a in hi_i:
+                    if len(got) >= PAIRS_PER_CELL:
+                        break
+                    best, bestd = None, 1e18
+                    for b in lo_i:
+                        if b in used or not ok_pair(a, b):
+                            continue
+                        fa, fb = int(fr[a]), int(fr[b])
+                        if abs(fa - fb) > FRAME_TOL * min(fa, fb):
+                            continue
+                        d2 = abs(fa - fb)
+                        if d2 < bestd:
+                            best, bestd = b, d2
+                    if best is None:
+                        st[f"{kind}_no_partner"] += 1
+                        continue
+                    used.add(best)
+                    got.append((int(a), int(best)))
+                if not got:
+                    st[f"{kind}_cell_empty"] += 1
+                    continue
+                st[f"{kind}_cell_ok"] += 1
+                st[f"{kind}_pairs"] += len(got)
+                for (a, b) in got:
+                    if kind == "emo":
+                        hv, lv = float(Em[a, dj]), float(Em[b, dj])
+                        hp = ecdf.emo_pct(dim, hv)
+                        lp = ecdf.emo_pct(dim, lv)
+                    else:
+                        hv, lv = float(Vm[a, jj]), float(Vm[b, jj])
+                        L = VN_LADDER[dim][1]
+                        hp = float(min(len(L) - 1, max(0, round(hv))))
+                        lp = float(min(len(L) - 1, max(0, round(lv))))
+                    pid = hashlib.blake2b(f"{dim}|{uids[a]}|{uids[b]}".encode(),
+                                          digest_size=10).hexdigest()
+                    rows.append((pid, voice, dim, kind, uids[a], uids[b], hv, lv,
+                                 int(fr[a]), int(fr[b]), hp, lp))
+        if vi % 50 == 0:
+            print(f"[sel] voice {vi+1}/{len(by_voice)} pairs={len(rows):,} "
+                  f"{time.time()-t0:.0f}s", flush=True)
+    os.makedirs(WORK, exist_ok=True)
+    cols = list(zip(*rows))
+    pq.write_table(pa.Table.from_arrays([pa.array(c, type=f.type)
+                                         for c, f in zip(cols, PAIR_SCHEMA)],
+                                        schema=PAIR_SCHEMA), PAIRS, compression="zstd")
+    st["base_pairs"] = len(rows)
+    st["emitted_rows"] = 2 * len(rows)
+    json.dump(dict(st), open(f"{WORK}/select_stats.json", "w"), indent=1)
+    print(json.dumps(dict(st), indent=1), flush=True)
+    print(f"[sel] wrote {PAIRS}  base_pairs={len(rows):,}  rows={2*len(rows):,}", flush=True)
+# ------------------------------------------------------------------ stage 2: materialise rows
+FULL = ["uid", "voice_key", "lang", "text", "text_bursts", "speaker_name", "words_json",
+        "burst_starts", "burst_ends", "burst_labels", "spoken_dur_s", "dur_s",
+        "frames", "codes", "ref_frames", "ref_codes", "has_ref"]
+BANDS = (("extreme", 0.98), ("intense", 0.90), ("moderate", 0.70), ("faint", 0.0))
+def _band_of(es):
+    for name, lo in BANDS:
+        if es >= lo:
+            return name
+    return "faint"
+# `directions.EMO_PROSE` is written for the EXPRESSED extreme of each emotion ("a furious voice,
+# seething and exploding into a rant").  Pasted behind a faint band phrase it produces "A voice
+# faintly expressing anger, a furious voice, seething and exploding into a rant" -- two
+# instructions in one sentence, which is the exact failure `directions.py` exists to remove.  The
+# faint side therefore gets its own tail instead of the corpus prose.  It is generic on purpose:
+# there is no harvested suppressed-side prose per emotion, and inventing forty of them would put
+# forty untested sentences into a fifth of the corpus.
+FAINT_TAIL = ["only a trace of it, kept almost out of the voice, the rest an ordinary plain read",
+              "barely there, held down and mostly absent, otherwise a plain everyday delivery",
+              "just a hint of it and no more, the delivery otherwise unremarkable and level"]
+def _emo_caption(emo, band, rng):
+    """The corpus's own opening sentence for `emo` at `band`, plus the `reads as` clause that
+    `directions.emotions_from_row` reads back.  The high and the low row of a pair differ in the
+    band phrase and in the prose tail that matches it, and in nothing else."""
+    head = rng.choice(DIR.BAND_PHRASE.get(band, DIR.BAND_PHRASE["moderate"]))
+    noun = DIR.NOUN.get(emo, DIR.pretty(emo))
+    prose = rng.choice(FAINT_TAIL) if band == "faint" else DIR.EMO_PROSE.get(emo, "")
+    reads = emo.replace("_", " ").lower()
+    return f"A voice {head} expressing {noun}, {prose}; reads as {reads}"
+def _vn_caption(dim, bucket):
+    clause, L = VN_LADDER[dim]
+    tag = L[int(bucket)]
+    return f"A voice; {clause} is {tag}", tag
+def stage_rows():
+    P = pq.read_table(PAIRS).to_pydict()
+    npair = len(P["pair_id"])
+    need = set(P["hi_uid"]) | set(P["lo_uid"])
+    print(f"[rows] {npair:,} base pairs, {len(need):,} distinct clips needed", flush=True)
+    # what the chosen role needs (everything) and what the rejected role needs (codes only)
+    rec, rej = {}, {}
+    need_ch = set(P["hi_uid"]) | set(P["lo_uid"])          # both roles appear as chosen
+    fs = sorted(glob.glob(f"{SRC}/shard-*.parquet"))
+    t0 = time.time()
+    for k, f in enumerate(fs):
+        t = pq.read_table(f, columns=FULL)
+        u = t["uid"].to_pylist()
+        sel = [i for i, x in enumerate(u) if x in need_ch]
+        if sel:
+            d = t.take(pa.array(sel)).to_pylist()
+            for r in d:
+                rec[r["uid"]] = r
+        if k % 16 == 0:
+            print(f"[rows] shard {k+1}/{len(fs)} cached={len(rec):,} {time.time()-t0:.0f}s",
+                  flush=True)
+    print(f"[rows] cached {len(rec):,}/{len(need):,} clips {time.time()-t0:.0f}s", flush=True)
+    st = defaultdict(int)
+    buckets = defaultdict(list)
+    rng = random.Random(31337)
+    for i in range(npair):
+        hi, lo = P["hi_uid"][i], P["lo_uid"][i]
+        a, b = rec.get(hi), rec.get(lo)
+        if a is None or b is None or not a["codes"] or not b["codes"]:
+            st["missing_clip"] += 1
+            continue
+        dim, kind, pid = P["dim"][i], P["kind"][i], P["pair_id"][i]
+        for role in ("high", "low"):
+            ch, rj = (a, b) if role == "high" else (b, a)
+            uid = f"cfg{pid}{'h' if role == 'high' else 'l'}"
+            uh = _uid_hash(uid)
+            rr = random.Random(uh & 0xFFFFFFFF)
+            if kind == "emo":
+                pct = float(P["hi_pct"][i] if role == "high" else P["lo_pct"][i])
+                # THE BAND WORD.  A CFG pair teaches a DIRECTION on one dimension: the two clips
+                # are the top and the bottom of ONE VOICE's own range, and the high clip is at
+                # corrected corpus percentile 0.998 (median) as well, so both "intensely" and
+                # "overwhelmingly" are true of it.  The round-3 failure is that BOTH words produce
+                # 0.34, so both are given the same contrastive target and the high role alternates
+                # between them by uid hash.  Absolute calibration BETWEEN intense and extreme is
+                # not something a two-point contrast can teach and is not what is broken.
+                es = (0.99 if (uh & 1) else 0.95) if role == "high" else min(pct, 0.60)
+                band = _band_of(es)
+                cap = _emo_caption(dim, band, rr)
+                neutral = ""
+                st[f"band_{band}"] += 1
+            else:
+                bucket = int(P["hi_pct"][i] if role == "high" else P["lo_pct"][i])
+                cap, tag = _vn_caption(dim, bucket)
+                neutral = (f"{tag}, and hold it there; otherwise exactly as this voice "
+                           f"normally speaks")
+                es = None
+            buckets[uh % NBUCKET].append({
+                "uid": uid, "family": f"cfg_{role}", "src": 0,
+                "voice_key": ch["voice_key"] or "", "lang": ch["lang"] or "en",
+                "text": ch["text"] or "", "text_bursts": ch["text_bursts"] or ch["text"] or "",
+                "caption_general": cap, "caption_script": "",
+                "caption_tpl_text": "", "caption_tpl": f"cfg|{kind}|{dim}|{hi}|{lo}",
+                "speaker_name": ch["speaker_name"] or "",
+                "spoken_dur_s": float(ch["spoken_dur_s"] or 0.0),
+                "dur_s": float(ch["dur_s"] or 0.0), "words_json": ch["words_json"] or "[]",
+                "burst_starts": [float(x) for x in (ch["burst_starts"] or [])],
+                "burst_ends": [float(x) for x in (ch["burst_ends"] or [])],
+                "burst_labels": [str(x) for x in (ch["burst_labels"] or [])],
+                "in_extreme": False,
+                "frames": int(ch["frames"]), "codes": ch["codes"],
+                "rej_frames": int(rj["frames"]), "rej_codes": rj["codes"],
+                "ref_frames": int(ch["ref_frames"] or 0) if ch["has_ref"] else 0,
+                "ref_codes": ch["ref_codes"] if ch["has_ref"] else b"",
+                "has_ref": bool(ch["has_ref"]),
+                "is_val": uh % 1000 == 0,
+                "cfg_free_text": True, "cfg_neutral": neutral,
+                "emo_strength": es,
+            })
+            st[f"rows_{kind}_{role}"] += 1
+    os.makedirs(ROWS, exist_ok=True)
+    tot = 0
+    for b in range(NBUCKET):
+        rs = buckets.get(b, [])
+        cols = {n: [r[n] for r in rs] for n in SCHEMA.names}
+        pq.write_table(pa.Table.from_pydict(cols, schema=SCHEMA),
+                       f"{ROWS}/shard-{b:03d}.parquet", compression="zstd", row_group_size=150)
+        tot += len(rs)
+    st["rows_written"] = tot
+    json.dump(dict(st), open(f"{WORK}/rows_stats.json", "w"), indent=1)
+    print(json.dumps(dict(st), indent=1), flush=True)
+    print(f"[rows] wrote {tot:,} rows to {ROWS}", flush=True)
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("stage", choices=("select", "rows"))
+    a = ap.parse_args()
+    (stage_select if a.stage == "select" else stage_rows)()

code/build_pairs2.py ADDED Viewed

	@@ -0,0 +1,287 @@

+#!/usr/bin/env python3
+"""Two new DPO pair families: emotion-contrastive (selectivity) and length-contrastive (duration).
+WHY THESE TWO, AND WHY NOW.
+The round-3 measurements say two different things are broken, and they need two different contrasts.
+  1. SELECTIVITY.  The per-emotion LoRAs raise their own emotion by +0.047 when it is asked for --
+     and by +0.033 when it is NOT (17 adapters, same three speakers, identical prompts).  A ratio
+     of 1.4 : 1 is not control, it is tinting.  Every contrast built so far pits an INTENSE clip
+     against a MILD one, so a model can win by being generically expressive.  Family A pits
+     intense against intense: same speaker, same length, emotion A against emotion B, and the
+     instruction names A.  Turning the intensity up is then worth nothing; only listening to the
+     instruction is.
+  2. DURATION, CONDITIONED ON THE DIMENSION.  The corpus already has truncation and continuation
+     families, but they know nothing about emotion, so they teach "the right length is better" in
+     the abstract.  Family B keeps the speaker, the text and the emotion fixed and varies ONLY the
+     length: chosen is the clip at its true duration, rejected is the same clip cut short or run
+     long.  The prompt states that emotion and that duration, so what is learned is "this emotion
+     AT this length" rather than a length prior.
+THE TEXT FIELD DIFFERS BETWEEN THE TWO, DELIBERATELY.
+  * Family A: chosen and rejected are DIFFERENT recordings with different words, and there is only
+    one prompt for the pair, so the words must not be in it -- otherwise the preference is
+    decidable from the text alone.  Free text (`...`), like the existing CFG rows.
+  * Family B: chosen and rejected are the SAME recording at two lengths, so the words are shared
+    and belong in the prompt.  The full timed script is used, because the timing tags are exactly
+    what the rejected side violates.
+Both families take the emotion from the MEASURED value, never from the prompt that generated the
+clip: the chosen side's top emotion has to be the dimension being asked for.
+"""
+import argparse, glob, json, os, random, sys, time
+from collections import defaultdict
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+NB = "/e/data1/datasets/playground/mmlaion/schuhmann1/dramabox"
+SC = "/e/scratch/reformo/schuhmann1_moss"
+sys.path[:0] = [f"{NB}/train2/code", f"{NB}/train2/code/grpo"]
+import reward as RW
+from build_cfg import (SCHEMA, LIGHT, FULL, SRC, NBUCKET, emo_names, _uid_hash, _emo_caption,
+                       _band_of)
+WORK = f"{SC}/pairs2_work"
+PAIRS = f"{WORK}/pairs2.parquet"
+ROWS = f"{SC}/pairs2_rows"
+HI_PCT = 0.90            # the chosen side must actually be intense on the asked-for head
+LO_PCT = 0.50            # ... and the rejected side must not be
+FRAME_TOL = 0.10
+EMOX_PER_CELL = 8        # base pairs per (voice, emotion); each is emitted once per direction
+LEN_PER_CELL = 6
+CUT_LO, CUT_HI = 0.50, 0.75      # truncation keeps this fraction of the frames
+EXT_LO, EXT_HI = 1.25, 1.50      # extension runs this many times the frames
+PAIR_SCHEMA = pa.schema([
+    ("pair_id", pa.string()), ("family", pa.string()), ("voice_key", pa.string()),
+    ("dim", pa.string()), ("ch_uid", pa.string()), ("rj_uid", pa.string()),
+    ("ch_pct", pa.float32()), ("rj_pct", pa.float32()),
+    ("ch_frames", pa.int32()), ("rj_frames", pa.int32()),
+    ("mode", pa.string()),                       # emox | cut | ext
+    ("cut_frames", pa.int32()),
+])
+def log(m):
+    print(f"[{time.strftime('%H:%M:%S')}] {m}", flush=True)
+def stage_select():
+    E = emo_names()
+    ecdf = RW.Ecdf()
+    fs = sorted(glob.glob(f"{SRC}/shard-*.parquet"))
+    uids, vk, fr = [], [], []
+    Em = []
+    st = defaultdict(int)
+    for k, f in enumerate(fs):
+        d = pq.read_table(f, columns=LIGHT).to_pydict()
+        keep = [i for i in range(len(d["uid"]))
+                if d["src"][i] == 0 and not d["is_val"][i] and (d["frames"][i] or 0) > 0]
+        st["rows_total"] += len(d["uid"]); st["rows_vp_train"] += len(keep)
+        if not keep:
+            continue
+        uids += [d["uid"][i] for i in keep]
+        vk += [d["voice_key"][i] for i in keep]
+        fr += [int(d["frames"][i]) for i in keep]
+        Em.append(np.stack([np.frombuffer(d["emo40"][i], np.float32) for i in keep]))
+        if k % 32 == 0:
+            log(f"[sel] {k+1}/{len(fs)} rows={len(uids):,}")
+    Em = np.concatenate(Em, 0)
+    fr = np.asarray(fr, np.int32)
+    n = len(uids)
+    log(f"[sel] {n:,} voice-profile training clips")
+    # corrected percentile per head, once
+    P = np.zeros_like(Em)
+    for j, h in enumerate(E):
+        P[:, j] = [ecdf.emo_pct(h, float(x)) for x in Em[:, j]]
+    top = P.argmax(1)
+    topv = P.max(1)
+    log("[sel] percentiles done")
+    by_voice = defaultdict(list)
+    for i, v in enumerate(vk):
+        by_voice[v].append(i)
+    rows = []
+    rng = random.Random(4711)
+    for voice, idx in sorted(by_voice.items()):
+        idx = np.asarray(idx)
+        # ---------- family A: emotion vs emotion, same voice, same length
+        for j, h in enumerate(E):
+            hi = idx[(P[idx, j] >= HI_PCT) & (top[idx] == j)]
+            if len(hi) == 0:
+                continue
+            # partners: intense on SOMETHING ELSE, weak on h
+            other = idx[(P[idx, j] <= LO_PCT) & (topv[idx] >= HI_PCT) & (top[idx] != j)]
+            if len(other) == 0:
+                st["emox_no_partner"] += 1
+                continue
+            made = 0
+            for a in rng.sample(list(hi), min(len(hi), EMOX_PER_CELL * 4)):
+                cand = other[np.abs(fr[other] - fr[a]) <= FRAME_TOL * np.minimum(fr[other], fr[a])]
+                if len(cand) == 0:
+                    continue
+                b = int(rng.choice(list(cand)))
+                rows.append(("emox", voice, h, uids[a], uids[b], float(P[a, j]), float(P[b, j]),
+                             int(fr[a]), int(fr[b]), "emox", 0))
+                # the mirror: name the partner's own top emotion, roles swap
+                hb = E[int(top[b])]
+                rows.append(("emox", voice, hb, uids[b], uids[a], float(P[b, top[b]]),
+                             float(P[a, top[b]]), int(fr[b]), int(fr[a]), "emox", 0))
+                made += 1
+                if made >= EMOX_PER_CELL:
+                    break
+            st["emox_cells"] += 1
+            st["emox_pairs"] += made
+        # ---------- family B: same clip, right length vs wrong length
+        strong = idx[topv[idx] >= HI_PCT]
+        if len(strong) == 0:
+            continue
+        for a in rng.sample(list(strong), min(len(strong), LEN_PER_CELL * 20)):
+            h = E[int(top[a])]
+            f0 = int(fr[a])
+            if f0 < 40:
+                continue
+            if rng.random() < 0.5:
+                cut = max(20, int(f0 * rng.uniform(CUT_LO, CUT_HI)))
+                rows.append(("len", voice, h, uids[a], uids[a], float(topv[a]), float(topv[a]),
+                             f0, cut, "cut", cut))
+            else:
+                donor = idx[np.abs(fr[idx] - f0) <= 0.6 * f0]
+                donor = donor[donor != a]
+                if len(donor) == 0:
+                    continue
+                d = int(rng.choice(list(donor)))
+                extra = max(8, int(f0 * rng.uniform(EXT_LO - 1.0, EXT_HI - 1.0)))
+                rows.append(("len", voice, h, uids[a], uids[d], float(topv[a]), float(topv[a]),
+                             f0, extra, "ext", extra))
+            st["len_pairs"] += 1
+            if st["len_pairs"] % max(1, LEN_PER_CELL) == 0:
+                pass
+        st["len_cells"] += 1
+    log(f"[sel] {len(rows):,} base pairs")
+    os.makedirs(WORK, exist_ok=True)
+    cols = list(zip(*rows)) if rows else [[]] * 11
+    pq.write_table(pa.Table.from_pydict({
+        "pair_id": [f"{i:09d}" for i in range(len(rows))],
+        "family": list(cols[0]), "voice_key": list(cols[1]), "dim": list(cols[2]),
+        "ch_uid": list(cols[3]), "rj_uid": list(cols[4]),
+        "ch_pct": [float(x) for x in cols[5]], "rj_pct": [float(x) for x in cols[6]],
+        "ch_frames": [int(x) for x in cols[7]], "rj_frames": [int(x) for x in cols[8]],
+        "mode": list(cols[9]), "cut_frames": [int(x) for x in cols[10]],
+    }, schema=PAIR_SCHEMA), PAIRS, compression="zstd")
+    json.dump(dict(st), open(f"{WORK}/select_stats.json", "w"), indent=1)
+    log(json.dumps(dict(st), indent=1))
+def _slice_blob(b, frames, keep, n_vq=12):
+    a = np.frombuffer(b, np.int16).reshape(int(frames), n_vq)
+    return a[:int(keep)].tobytes(), int(keep)
+def _cat_blob(b1, f1, b2, f2, extra, n_vq=12):
+    a = np.frombuffer(b1, np.int16).reshape(int(f1), n_vq)
+    c = np.frombuffer(b2, np.int16).reshape(int(f2), n_vq)[:int(extra)]
+    return np.concatenate([a, c], 0).tobytes(), int(f1) + int(c.shape[0])
+def stage_rows():
+    P = pq.read_table(PAIRS).to_pydict()
+    npair = len(P["pair_id"])
+    need = set(P["ch_uid"]) | set(P["rj_uid"])
+    log(f"[rows] {npair:,} pairs, {len(need):,} distinct clips")
+    rec = {}
+    fs = sorted(glob.glob(f"{SRC}/shard-*.parquet"))
+    for k, f in enumerate(fs):
+        t = pq.read_table(f, columns=FULL)
+        u = t["uid"].to_pylist()
+        sel = [i for i, x in enumerate(u) if x in need]
+        if sel:
+            for r in t.take(pa.array(sel)).to_pylist():
+                rec[r["uid"]] = r
+        if k % 16 == 0:
+            log(f"[rows] shard {k+1}/{len(fs)} cached={len(rec):,}")
+    log(f"[rows] cached {len(rec):,}/{len(need):,}")
+    st = defaultdict(int)
+    buckets = defaultdict(list)
+    for i in range(npair):
+        ch = rec.get(P["ch_uid"][i]); rj = rec.get(P["rj_uid"][i])
+        if ch is None or rj is None or not ch["codes"] or not rj["codes"]:
+            st["missing"] += 1
+            continue
+        fam, dim, mode = P["family"][i], P["dim"][i], P["mode"][i]
+        uid = f"p2{P['pair_id'][i]}{mode[0]}"
+        uh = _uid_hash(uid)
+        rr = random.Random(uh & 0xFFFFFFFF)
+        try:
+            if mode == "emox":
+                rb, rf = rj["codes"], int(rj["frames"])
+                free_text = True
+            elif mode == "cut":
+                rb, rf = _slice_blob(ch["codes"], ch["frames"], P["cut_frames"][i])
+                free_text = False
+            else:
+                rb, rf = _cat_blob(ch["codes"], ch["frames"], rj["codes"], rj["frames"],
+                                   P["cut_frames"][i])
+                free_text = False
+        except Exception:
+            st["blob_error"] += 1
+            continue
+        if rf <= 0 or rf > 620:
+            st["rej_len"] += 1
+            continue
+        # the band word alternates by uid hash: a two-point contrast cannot calibrate BETWEEN
+        # intense and extreme, and both are true of a clip at corrected percentile >= 0.90
+        es = 0.99 if (uh & 1) else 0.95
+        cap = _emo_caption(dim, _band_of(es), rr)
+        buckets[uh % NBUCKET].append({
+            "uid": uid, "family": f"p2_{fam}", "src": 0,
+            "voice_key": ch["voice_key"] or "", "lang": ch["lang"] or "en",
+            "text": ch["text"] or "", "text_bursts": ch["text_bursts"] or ch["text"] or "",
+            "caption_general": cap, "caption_script": "", "caption_tpl_text": "",
+            "caption_tpl": f"p2|{fam}|{mode}|{dim}",
+            "speaker_name": ch["speaker_name"] or "",
+            "spoken_dur_s": float(ch["spoken_dur_s"] or 0.0),
+            "dur_s": float(ch["dur_s"] or 0.0), "words_json": ch["words_json"] or "[]",
+            "burst_starts": [float(x) for x in (ch["burst_starts"] or [])],
+            "burst_ends": [float(x) for x in (ch["burst_ends"] or [])],
+            "burst_labels": [str(x) for x in (ch["burst_labels"] or [])],
+            "in_extreme": False,
+            "frames": int(ch["frames"]), "codes": ch["codes"],
+            "rej_frames": int(rf), "rej_codes": rb,
+            "ref_frames": int(ch["ref_frames"] or 0) if ch["has_ref"] else 0,
+            "ref_codes": ch["ref_codes"] if ch["has_ref"] else b"",
+            "has_ref": bool(ch["has_ref"]),
+            "is_val": uh % 1000 == 0,
+            "cfg_free_text": free_text, "cfg_neutral": "",
+            "emo_strength": es,
+        })
+        st[f"rows_{mode}"] += 1
+    os.makedirs(ROWS, exist_ok=True)
+    tot = 0
+    for b in range(NBUCKET):
+        rs = buckets.get(b, [])
+        cols = {nme: [r[nme] for r in rs] for nme in SCHEMA.names}
+        pq.write_table(pa.Table.from_pydict(cols, schema=SCHEMA),
+                       f"{ROWS}/shard-{b:03d}.parquet", compression="zstd", row_group_size=150)
+        tot += len(rs)
+    st["rows_written"] = tot
+    json.dump(dict(st), open(f"{WORK}/rows_stats.json", "w"), indent=1)
+    log(json.dumps(dict(st), indent=1))
+    log(f"[rows] wrote {tot:,} rows to {ROWS}")
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("stage", choices=("select", "rows"))
+    a = ap.parse_args()
+    (stage_select if a.stage == "select" else stage_rows)()

code/mix_cfg.py ADDED Viewed

	@@ -0,0 +1,44 @@

+#!/usr/bin/env python3
+"""Concatenate the CFG contrast pairs into the round-3 DPO corpus.
+Shard b of the mix is shard b of `dpo_corpus2` (1,853,486 pairs, already globally shuffled at
+build time) plus shard b of `cfg_rows` (the CFG pairs, bucketed by uid hash, so also globally
+shuffled), permuted together.  The three columns the CFG build adds are filled in for the legacy
+rows with the values that make `prompt_lib2` render them byte-identically to before:
+`cfg_free_text=False`, `cfg_neutral=""`, `emo_strength=null` (so `_band` keeps falling back to
+`in_extreme`, exactly as it does when the column is absent).
+`is_val` is carried through untouched from both sides -- both were assigned by the same
+`uid_hash % 1000 == 0` rule -- so the holdout logic is the one every earlier run used.
+"""
+import glob, json, os, sys, time
+import numpy as np, pyarrow as pa, pyarrow.parquet as pq
+sys.path[:0] = ["/e/data1/datasets/playground/mmlaion/schuhmann1/dramabox/train2/code"]
+from build_cfg import SCHEMA, NBUCKET
+OLD = "/e/scratch/reformo/schuhmann1_moss/dpo_corpus2"
+CFG = "/e/scratch/reformo/schuhmann1_moss/cfg_rows"
+OUT = "/e/scratch/reformo/schuhmann1_moss/dpo_corpus_cfg"
+def run(task, ntask):
+    os.makedirs(OUT, exist_ok=True)
+    t0 = time.time()
+    for b in range(task, NBUCKET, ntask):
+        o = pq.read_table(f"{OLD}/shard-{b:03d}.parquet")
+        n = o.num_rows
+        o = o.append_column("cfg_free_text", pa.array(np.zeros(n, bool)))
+        o = o.append_column("cfg_neutral", pa.array([""] * n, pa.string()))
+        o = o.append_column("emo_strength", pa.array([None] * n, pa.float32()))
+        o = o.select(SCHEMA.names).cast(SCHEMA)
+        c = pq.read_table(f"{CFG}/shard-{b:03d}.parquet", schema=SCHEMA)
+        t = pa.concat_tables([o, c])
+        t = t.take(pa.array(np.random.RandomState(7000 + b).permutation(t.num_rows)))
+        pq.write_table(t, f"{OUT}/shard-{b:03d}.parquet", compression="zstd", row_group_size=150)
+        print(f"[mix.{task}] shard-{b:03d} old={n} cfg={c.num_rows} out={t.num_rows} "
+              f"{time.time()-t0:.0f}s", flush=True)
+if __name__ == "__main__":
+    run(int(sys.argv[1]), int(sys.argv[2]))

code/mix_pairs2.py ADDED Viewed

	@@ -0,0 +1,54 @@

+#!/usr/bin/env python3
+"""Mix the two new pair families into the CFG corpus.
+The base is `dpo_corpus_cfg` (2,327,904 pairs) rather than `dpo_corpus2`, because the CFG corpus
+produced the best checkpoint measured so far (reward 0.4708, WER 0.0950). Everything the CFG
+corpus already teaches is kept; the new families are added on top, so a difference in the trained
+model is attributable to them alone.
+"""
+import glob, json, os, sys
+import numpy as np
+import pyarrow as pa
+import pyarrow.parquet as pq
+SC = "/e/scratch/reformo/schuhmann1_moss"
+BASE = f"{SC}/dpo_corpus_cfg"
+NEW = f"{SC}/pairs2_rows"
+DST = f"{SC}/dpo_corpus_p2"
+NBUCKET = 128
+def main():
+    bs = sorted(glob.glob(f"{BASE}/shard-*.parquet"))
+    ns = sorted(glob.glob(f"{NEW}/shard-*.parquet"))
+    assert bs and ns, (len(bs), len(ns))
+    schema = pq.ParquetFile(bs[0]).schema_arrow
+    nsch = pq.ParquetFile(ns[0]).schema_arrow
+    missing = [f for f in schema.names if f not in nsch.names]
+    extra = [f for f in nsch.names if f not in schema.names]
+    print(f"base fields {len(schema.names)}, new fields {len(nsch.names)}; "
+          f"missing in new {missing}; extra in new {extra}", flush=True)
+    os.makedirs(DST, exist_ok=True)
+    nb = sum(pq.ParquetFile(f).metadata.num_rows for f in bs)
+    nn = sum(pq.ParquetFile(f).metadata.num_rows for f in ns)
+    print(f"base {nb:,} + new {nn:,} = {nb+nn:,}  (new share {nn/(nb+nn):.1%})", flush=True)
+    for b in range(NBUCKET):
+        parts = []
+        for src in (f"{BASE}/shard-{b:03d}.parquet", f"{NEW}/shard-{b:03d}.parquet"):
+            if os.path.exists(src):
+                t = pq.read_table(src)
+                parts.append(t.select(schema.names) if t.schema != schema else t)
+        if not parts:
+            continue
+        t = pa.concat_tables(parts, promote_options="permissive")
+        t = t.take(pa.array(np.random.RandomState(7000 + b).permutation(t.num_rows)))
+        pq.write_table(t, f"{DST}/shard-{b:03d}.parquet", compression="zstd", row_group_size=150)
+        if b % 16 == 0:
+            print(f"[mix] shard {b} rows={t.num_rows}", flush=True)
+    tot = sum(pq.ParquetFile(f).metadata.num_rows
+              for f in glob.glob(f"{DST}/shard-*.parquet"))
+    print(f"[mix] wrote {tot:,} rows to {DST}", flush=True)
+if __name__ == "__main__":
+    main()

verify.json ADDED Viewed

	@@ -0,0 +1,204 @@

+{
+ "local": {
+  "rows": {
+   "cfg": 474418,
+   "p2": 368517,
+   "families": {
+    "cfg_low": 237209,
+    "cfg_high": 237209,
+    "p2_emox": 309128,
+    "p2_len": 59389
+   },
+   "lang": {
+    "cfg": {
+     "en": 227068,
+     "de": 247350
+    },
+    "p2": {
+     "en": 179649,
+     "de": 188868
+    }
+   }
+  },
+  "files": {
+   "cfg_shards": 128,
+   "p2_shards": 128,
+   "cfg_bytes": 3668193909,
+   "p2_bytes": 2822830198
+  },
+  "uid_unique": {
+   "cfg": 474418,
+   "p2": 368517
+  },
+  "src0_all_rows": {
+   "cfg": 474418,
+   "p2": 368517
+  },
+  "voice_in_500": {
+   "cfg": 474418,
+   "p2": 368517
+  },
+  "source_uid_allowlisted": {
+   "cfg_mentions": 1423254,
+   "p2_mentions": 737034,
+   "restricted_pattern_hits": 0
+  },
+  "rows_with_index_entry": {
+   "cfg": 474418,
+   "p2": 368517
+  },
+  "distinct_source_clips": {
+   "cfg": 332576,
+   "p2": 342284
+  },
+  "has_ref_all": {
+   "cfg": 474418,
+   "p2": 368517
+  },
+  "is_val": {
+   "cfg": 490,
+   "p2": 373
+  },
+  "constants": {
+   "cfg_rows|in_extreme_true": 0,
+   "cfg_rows|caption_script_nonempty": 0,
+   "cfg_rows|caption_tpl_text_nonempty": 0,
+   "cfg_rows|text_bursts_differs": 127992,
+   "cfg_rows|speaker_name_empty": 0,
+   "cfg_rows|rows": 474418,
+   "pairs2_rows|in_extreme_true": 0,
+   "pairs2_rows|caption_script_nonempty": 0,
+   "pairs2_rows|caption_tpl_text_nonempty": 0,
+   "pairs2_rows|text_bursts_differs": 92235,
+   "pairs2_rows|speaker_name_empty": 0,
+   "pairs2_rows|rows": 368517
+  },
+  "sample_join_200_per_family": {
+   "cfg_high": {
+    "tpl_hi_lo_match": 200,
+    "fam_role_match": 200,
+    "n": 200,
+    "voice_match": 200,
+    "frames_match_chosen": 200,
+    "frames_match_rejected": 200,
+    "codes_len_ok": 200,
+    "rej_len_ok": 200,
+    "codes_range_ok": 200,
+    "ref_len_ok": 200,
+    "has_ref": 200,
+    "frames_vs_dur": 200,
+    "ch_uid_shape_ok": 200,
+    "rj_uid_shape_ok": 200,
+    "ch_voice_prefix": 200,
+    "rj_voice_prefix": 200
+   },
+   "cfg_low": {
+    "tpl_hi_lo_match": 200,
+    "fam_role_match": 200,
+    "n": 200,
+    "voice_match": 200,
+    "frames_match_chosen": 200,
+    "frames_match_rejected": 200,
+    "codes_len_ok": 200,
+    "rej_len_ok": 200,
+    "codes_range_ok": 200,
+    "ref_len_ok": 200,
+    "has_ref": 200,
+    "frames_vs_dur": 200,
+    "ch_uid_shape_ok": 200,
+    "rj_uid_shape_ok": 200,
+    "ch_voice_prefix": 200,
+    "rj_voice_prefix": 200
+   },
+   "p2_emox": {
+    "mode_match": 200,
+    "fam_match": 200,
+    "tpl_dim_match": 200,
+    "n": 200,
+    "voice_match": 200,
+    "frames_match_chosen": 200,
+    "frames_match_rejected": 200,
+    "codes_len_ok": 200,
+    "rej_len_ok": 200,
+    "codes_range_ok": 200,
+    "ref_len_ok": 200,
+    "has_ref": 200,
+    "frames_vs_dur": 200,
+    "ch_uid_shape_ok": 200,
+    "rj_uid_shape_ok": 200,
+    "ch_voice_prefix": 200,
+    "rj_voice_prefix": 200
+   },
+   "p2_len": {
+    "mode_match": 82,
+    "fam_match": 82,
+    "tpl_dim_match": 82,
+    "n": 82,
+    "voice_match": 82,
+    "frames_match_chosen": 82,
+    "frames_match_rejected": 82,
+    "codes_len_ok": 82,
+    "rej_len_ok": 82,
+    "codes_range_ok": 82,
+    "ref_len_ok": 82,
+    "has_ref": 82,
+    "frames_vs_dur": 82,
+    "ch_uid_shape_ok": 82,
+    "rj_uid_shape_ok": 82,
+    "ch_voice_prefix": 82,
+    "rj_voice_prefix": 82,
+    "cut_is_prefix": 41,
+    "ext_has_chosen_prefix": 41
+   }
+  },
+  "frame_tolerance_10pct": {
+   "cfg_base_pairs": 237209,
+   "p2_emox_rows": 309128
+  },
+  "same_language_within_pair": {
+   "cfg": 0.5458098132870169,
+   "p2_emox": 0.5912049377604099
+  },
+  "p2_emox_rejected_pct": {
+   "le_0.5": 247324,
+   "gt_0.5": 61804,
+   "ge_0.9": 14281,
+   "gap_negative": 3372,
+   "gap_median": 0.7619638368487358
+  },
+  "frames_vs_annotated_index": {
+   "clip_refs_compared": 1322,
+   "ratio_1.00": 1322,
+   "voice": "anime_000 (index parts 0-2)"
+  },
+  "overlap_with_sisters": {
+   "sister_rows_read": 7410723,
+   "sister_files": 1922,
+   "row_uid_sample_hits": {
+    "sample_cfg_low": 0,
+    "sample_cfg_high": 0,
+    "sample_p2_emox": 0,
+    "sample_p2_len": 0
+   },
+   "identical_pairs_cfg": 0,
+   "identical_pairs_p2_emox": 0,
+   "source_clips_present_as_sister_chosen": {
+    "cfg": 332576,
+    "p2": 342284
+   }
+  }
+ },
+ "remote": {
+  "repo": "laion/laion-voice-profiles-dpo-cfg",
+  "private": false,
+  "sha": "145e617015eac33cd2c25b50472f6759052757f4",
+  "n_remote_files": 259,
+  "checked": 258,
+  "size_ok": 258,
+  "sha_ok": 258,
+  "missing": [],
+  "bytes_local": 6509255583,
+  "bytes_remote": 6509255583,
+  "ok": true
+ }
+}