Anger pool re-decided from the Indonesian text only; exact 8b:1b:1b balanced splits; whole pools unsplit in `full`/`anger_split`; option-order control, probe matrix, flip audit and second-run reconfirmation shipped

README.md

@@ -1,6 +1,6 @@
 ---
 license: cc-by-4.0
-pretty_name: "EmoTweetID Ekman-7: five human-tagged Ekman emotions + the anger pool split into anger vs contempt (laya)"
+pretty_name: "EmoTweetID Ekman-7: five human-tagged Ekman emotions + the anger pool split into anger vs contempt by laya, from the Indonesian text"
 language:
 - id
 - en
@@ -42,18 +42,10 @@ configs:
   data_files:
   - split: train
     path: full/train.parquet
-  - split: valid
-    path: full/valid.parquet
-  - split: test
-    path: full/test.parquet
 - config_name: anger_split
   data_files:
   - split: train
     path: anger_split/train.parquet
-  - split: valid
-    path: anger_split/valid.parquet
-  - split: test
-    path: anger_split/test.parquet
 - config_name: anger_split_balanced
   data_files:
   - split: train
@@ -67,11 +59,13 @@ configs:
 # EmoTweetID under Ekman's seven universal emotions
 
 2,243 Indonesian tweets, one label each from Ekman's universal set - **anger, contempt, disgust,
-enjoyment, fear, sadness, surprise**. 475 of them are the pool EmoTweetID tagged `anger`, and that pool is the only
-thing this dataset changes: it is split by [laya](https://pypi.org/project/laya/)
-against Ekman's own definitions into **anger (381)** and **contempt (94)** -
-19.8% of the pool. The other five classes keep EmoTweetID's human annotations verbatim.
-Stratified 8:1:1 train/valid/test, seed 0, no duplicate leakage, four configs.
+enjoyment, fear, sadness, surprise**. 475 of them are the pool EmoTweetID tagged `anger`,
+and that pool is the only place this dataset makes a decision of its own: [laya](https://pypi.org/project/laya/)
+reads each of those tweets, in Indonesian, against Ekman's own definitions of the two emotions, and
+splits them into **anger (289)** and **contempt (186)** - contempt is
+39.2% of the pool. The other five classes are EmoTweetID's human annotations, carried over verbatim.
+Four configs: `full` and `anger_split` are the complete pools, each in a single split; `balanced`
+(default) and `anger_split_balanced` are exact 8:1:1 train/valid/test, seed 0, no duplicate leakage.
 
 Why bother: Ekman lists anger and contempt as two different universal emotions with different
 triggers, different messages and different facial signatures, but emotion corpora - and the models
@@ -80,15 +74,15 @@ system has to tell "you wronged me, put it right" from "you are beneath me".
 
 | class | rows | share | origin |
 |---|---|---|---|
-| `anger` | 381 | 17.0% | split here: laya on the `anger` pool |
-| `contempt` | 94 | 4.2% | split here: laya on the `anger` pool |
+| `anger` | 289 | 12.9% | split here: laya on the `anger` pool |
+| `contempt` | 186 | 8.3% | split here: laya on the `anger` pool |
 | `disgust` | 355 | 15.8% | EmoTweetID annotators, kept verbatim |
 | `enjoyment` | 429 | 19.1% | EmoTweetID annotators, kept verbatim |
 | `fear` | 395 | 17.6% | EmoTweetID annotators, kept verbatim |
 | `sadness` | 303 | 13.5% | EmoTweetID annotators, kept verbatim |
 | `surprise` | 286 | 12.8% | EmoTweetID annotators, kept verbatim |
 
-## What was relabelled, and what was not
+## How each class got its label
 
 | source label (EmoTweetID, human) | rows | treatment here |
 |---|---|---|
@@ -97,7 +91,7 @@ system has to tell "you wronged me, put it right" from "you are beneath me".
 | `disgust` | 355 | kept |
 | `sadness` | 303 | kept |
 | `surprise` | 286 | kept |
-| `anger` | 475 | **re-read by laya** and split into `anger` / `contempt` |
+| `anger` | 475 | **re-read by laya, in Indonesian**, and split into `anger` / `contempt` |
 
 `label_origin` on every row says which of the two applies, and `source_label` always keeps the
 upstream name. Nothing else in the schema was modelled; there is no `neutral` class because
@@ -114,7 +108,13 @@ GoEmotions - which is why this card has 7 classes where the reference has 8.
   [Mendeley Data jzgnjsff9f](https://data.mendeley.com/datasets/jzgnjsff9f).
 * **Licence**: CC BY 4.0 on the source; this derived dataset is CC BY 4.0 as well.
 * **Definitions**: [What is Anger?](https://www.paulekman.com/universal-emotions/what-is-anger/) and
-  [What is Contempt?](https://www.paulekman.com/universal-emotions/what-is-contempt/), Paul Ekman Group.
+  [What is Contempt?](https://www.paulekman.com/universal-emotions/what-is-contempt/), Paul Ekman
+  Group. The criteria shown to the model are condensed from these two pages.
+* **Language**: every label here is decided from `text`, the tweet as written. `text_en` is
+  EmoTweetID's machine translation and is never an input to any label; it ships only because it is
+  upstream data. An earlier reading of this same pool used `text` and `text_en` together; those rows,
+  their probabilities and the caches behind them are kept in `out_prev/`, so the two readings can be
+  compared row by row - it labelled 381 anger / 94 contempt; the labels here differ on 116 of the 475 rows, 104 of them anger -> contempt.
 
 ## The two classes the split turns on, in Ekman's words
 
@@ -135,145 +135,210 @@ Operational boundary: **anger wants the obstacle gone; contempt puts the target
 
 ## How the anger split was decided
 
-`pip install laya` (v0.3.4), checkpoint `convaiinnovations/laya (subfolder `multilingual/`)`: 321.9M params in 170
-tensors - a 306.9M `jhu-clsp/mmBERT-base` encoder (modernbert, bf16 weights, vocab 256000,
-laya's own context cap 1024 tokens) plus 15.0M of decision heads that turn one
-forward pass into probabilities over the options you asked about. For each tweet: one `choice` question whose two options are the criteria
-above, plus two `noul` probes of each emotion's core feature (superiority, blocked-or-unfair) and a
-`not_anger_or_contempt` veto; `label_source` on each row records which of those rules decided it.
-One non-autoregressive forward pass per question - no generation, so
-nothing to parse and nothing to hallucinate.
-
-Each tweet is read twice, in Indonesian (the language it was written in) and in EmoTweetID's English
-translation (the language Ekman's definitions, and laya's strongest read, are in), and the readings
-are combined by descending trust:
-
-1. both on the same side -> pool the two distributions (`ekman_choice_pooled`);
-2. they disagree -> keep the more confident one (`ekman_choice_en` / `ekman_choice_id`);
-3. neither decisive (pooled margin under 0.10) -> Ekman's core-feature probes (`ekman_noul_tiebreak`);
-4. still nothing -> keep the upstream `anger` label (`kept_original_label`).
-
-Realised as: `ekman_choice_pooled` 297, `ekman_choice_en` 122, `ekman_choice_id` 54, `ekman_noul_tiebreak` 2. Every probability is on the row, so you can re-cut the split with your
-own threshold instead of trusting this rule.
+`pip install laya` (v0.3.4), checkpoint `convaiinnovations/laya`, subfolder `multilingual/`:
+321.9M params in 170 tensors - a 306.9M `jhu-clsp/mmBERT-base` encoder (modernbert,
+bf16 weights, vocab 256000, laya's own context cap 1024 tokens) plus 15.0M of
+decision heads that turn one forward pass into probabilities over the options you asked about. For
+each tweet: one `choice` question whose two options are Ekman's criteria above, the same question
+again with the options in the opposite order, `noul` probes of each emotion's core feature
+(superiority, blocked-or-unfair) on the rows the choice head could not settle, and a
+`not_anger_or_contempt` veto as a diagnostic. One non-autoregressive forward pass per question - no
+generation, so nothing to parse and nothing to hallucinate. Every tweet is read in Indonesian; the
+question itself stays laya's own English prompt, i.e. Ekman's criteria are quoted in the language
+they were written in.
+
+The four stages, over the 475 anger-pool rows:
+
+| stage | question(s) | rows scored (state x question) | what it is for |
+|---|---|---|---|
+| `id_core` | `ekman` (choice) | 475 | the decision |
+| `id_core_swap` | same, contempt listed first | 475 | option-order control (`p_anger_swapped`) |
+| `id_diag` | `superiority`, `blocked_or_unfair` | 108 | only on the rows `id_core` left under a 0.10 margin |
+| `id_veto` | `not_anger_or_contempt` | 475 | off-topic diagnostic - **do not filter on it** |
+
+The decision rule, in order:
+
+1. the `choice` reading is decisive (|p(anger) - p(contempt)| >= 0.1) -> its argmax
+   (`ekman_choice_id`);
+2. not decisive -> Ekman's core-feature probes break the tie, superiority => contempt,
+   blocked-or-unfair => anger (`ekman_noul_tiebreak`);
+3. both still under the margin -> the average of the two option orders decides, if it has a side
+   (`ekman_choice_order_avg`);
+4. nothing at all -> keep the upstream EmoTweetID label `anger` (`kept_original_label`): this dataset
+   only ever *splits* an existing anger pool, it never re-litigates it.
+
+Realised as: `ekman_choice_id` 421, `ekman_noul_tiebreak` 33, `ekman_choice_order_avg` 18, `kept_original_label` 3. Every probability is on the row - `p_anger_id` (as prompted),
+`p_anger_swapped` (options reversed), `ekman_p_anger`, `ekman_p_contempt`, `ekman_margin_id`,
+`p_superiority`, `p_blocked_or_unfair`, `p_not_anger_or_contempt` - so you can re-cut the split with
+your own threshold instead of trusting this rule.
+
+Reproducibility: the `id_core` stage matches the earlier two-language run's `out_prev/cache_id_core.json` (shipped here) to the last digit - 471/471 unique texts on the same side of the decision line, mean |delta p(anger)| 0.0000, max 0.0000. On a second, complete run of the labeller - fresh caches, same
+sandbox - every stage (id_core, id_core_swap, id_diag, id_veto) matched row for row and reproduced **475/475 labels**, down to a byte-identical `anger_ekman_rows.csv`, the largest probability difference anywhere being 0.000000 (856.6 s of model time against 851.2 s for the shipped run); that run's summary is `out/reconfirm.json` and its console log
+`runs/label_run_id_reconfirm.log`.
 
 ### Quality checks on the machine labels - read before using them
 
-* **Fit-for-purpose probe**: on 16 hand-written unambiguous sentences (8 clear anger, 8 clear
-  contempt, written from the two Ekman pages, not from the corpus) the `choice` head was right
-  **13/16 (0.812)** against a 0.50 chance line. The misses: one heated political complaint read as contempt,
-  two quietly-scornful lines read as anger.
-* **The `noul` probes are weak** (mean P(superiority) 0.16 on contempt vs 0.13 on anger), which is why
-  they only break ties and why they were measured before being trusted.
-* **Do not filter on `p_not_anger_or_contempt`.** 43 rows exceed 0.5, but the four
-  most-flagged tweets are among the angriest in the pool (`AK MURKA`,
-  `SUMPAH GUA MURKA LIAT INI. PEN GUA TEBAS JUGA LU PAK`, ...). The same question behaves on the
-  question behaves sanely on English sentences (0.12 mean P(neither) over the probes, 1 of 16 above 0.5), so it degrades on short, shouty,
-  code-mixed Indonesian rather than detecting mislabels. Interesting-failure signal, not a filter.
-* The two language readings agreed on argmax for **0.625** of the pool. 214 of
-  475 rows had a thin margin in at least one language or disagreed outright and were
-  re-asked with the core-feature probes; 2 were indecisive in *both* languages; 48
-  rows came out under 0.6 confidence. Every one of those is flagged per row.
-* **Stability**: a replication of the entire anger run at a 1024-token cap agreed on **474/475** final labels; the 1 flip sits right on the decision line - row 839 (p(anger) 0.434 / p(contempt) 0.566, en margin -0.132 vs id margin +0.104) - which is where a human annotator would have hesitated too.
-
-These are machine-assisted weak labels from a 322M model - the other 1,768 rows are human labels.
-That mixture is deliberate and marked per row, but it means model and human error are not
-comparable across `label_origin`, and `anger`/`contempt` rows are the noisier subset.
+**Fit-for-purpose probes, in both languages.** 16 hand-written unambiguous sentences (8 clear anger,
+8 clear contempt, written from the two Ekman pages, not from the corpus) in Indonesian and in
+English, plus the project's reference English probe set, and the two controls that matter (question
+language, option order). Chance is 0.50.
+
+| condition | accuracy |
+|---|---|
+| the project's 16 reference English probes, English question | 13/16 (0.812) |
+| the same 16 items in English, English question | 14/16 (0.875) |
+| **the same 16 probes in Indonesian, English question** - the reading this dataset uses | **11/16 (0.688)** |
+| the same Indonesian probes with an *Indonesian* question | 12/16 (0.750) |
+| English probes with an Indonesian question | 14/16 (0.875) |
+| Indonesian probes, criteria order swapped (contempt first) | 11/16 (0.688) |
+
+The gap is 3 items out of 16: the same sentences are called correctly 14 times in English and 11 times in Indonesian. Mean P(anger) on the anger probes 0.68 in Indonesian vs 0.80 in English; on the contempt probes 0.31 vs 0.20. On the contempt items the mean P(anger) is 0.31 with anger listed first and 0.48 with contempt listed first - the order effect seen on the corpus. The Indonesian reading is therefore the weaker of
+the two on these probes, and its errors lean toward `contempt`; putting the question in Indonesian
+does not recover the gap (with the question in Indonesian instead of English, the gap closes only 11 -> 12 items).
+
+**Option-order sensitivity on the corpus.** Listing contempt first moved the argmax on 25.1% of the pool (mean |delta p(anger)| 0.191; mean P(anger) 0.589 as prompted vs 0.726 with the options swapped), so the prompt's option order is worth roughly a third of the contempt shift. `p_anger_swapped` ships on every row, so
+the debiased reading is `(p_anger_id + p_anger_swapped) / 2` if you want it.
+
+**The corpus's own anger vocabulary.** 373 of the 475 pool rows contain an explicit Indonesian anger word (`kesal`, `marah`, `murka`, `benci`, `jengkel`, `geram`, `tersinggung`, `muak`, `ngamuk`) - which is how EmoTweetID's annotators sampled, so the word is upstream evidence for anger. 141 of those 373 rows (38%) are labelled `contempt` here. This is the sharpest single piece of evidence
+on this card: the words that most plainly mean anger in Indonesian are where the Indonesian reading
+calls contempt most often.
+
+**One-reader audit of the disagreements.** A sample of 37 rows where the readings disagree was judged against the operational boundary by one reader working from the tweet text alone, before seeing any probability: 18/37 of those judgements land on the two-language reading, 4/37 on the label here, and 13/37 read as neither emotion. Of the 20 rows labelled `contempt` here and `anger` by the two-language reading, 1 was accepted as contempt. The reader is a machine reader, not a human annotator, and works on short code-mixed text - a signal, not gold labels.
+
+**The `noul` probes are weak - and here they do more work than they should.** Their separation on the
+probe sentences is small (mean P(superiority) 0.16 on contempt vs 0.13 on anger, which is why an
+earlier reading of this pool only trusted them for 2 of 475 rows). On this reading 54 rows come
+out inside the 0.10 margin, and 33 of them are decided by those probes - so a weak tie-breaker
+settles 33 labels. Prefer the probability columns to `label` if that matters for your use:
+`ekman_choice_id` decided 421, the option-order average 18, the upstream `anger`
+label 3.
+
+**Do not filter on `p_not_anger_or_contempt`.** 18 of 475 rows above 0.5 (mean P(neither) 0.12) - Indonesian reading. The most-flagged rows include some of the
+angriest tweets in the pool (`AK MURKA`, `SUMPAH GUA MURKA LIAT INI. PEN GUA TEBAS JUGA LU PAK`), so
+the probe is picking up register, not mislabels. It ships as a documented dead end.
+
+**Confidence.** 99 of 475 rows land within 0.10 of a coin flip on the primary reading (max probability of the two options under 0.60), and the mean max probability across the pool is 0.754. `ekman_confidence` is laya's own confidence for the reading
+(`1 - normalised entropy`, 0 = a coin flip), and 391 rows sit under 0.6. Note that
+`out_prev/` stores max P(anger) in that column instead - a different scale, so the two are not
+directly comparable.
+
+Bottom line: all 475 pool labels are a machine decision from a 322M model whose own card
+calls it "a fast base to specialise, not a zero-shot decision engine", asked in the language that
+measures weaker on the probes above. The other 1,768 rows are human labels. `label_origin`
+marks which is which; model and human error are not comparable across it, and the `anger`/`contempt`
+rows are the noisier subset.
 
 ## Schema
 
 | field | type | meaning |
 |---|---|---|
-| `text` | string | the tweet as written (Indonesian) - the default model input |
-| `text_en` | string | EmoTweetID's English translation |
+| `text` | string | the tweet as written (Indonesian) - the model input |
+| `text_en` | string | EmoTweetID's English machine translation. Not an input to any label here - kept because it is upstream data |
 | `label` | string | one of the 7 Ekman classes |
 | `label_idx` | ClassLabel | `label` as an int, in the order anger, contempt, disgust, enjoyment, fear, sadness, surprise (anger, contempt in the `anger_split` configs) |
 | `source_label` | string | upstream EmoTweetID label (`anger`, `joy`, `fear`, `disgust`, `sadness`, `surprise`) |
 | `label_origin` | string | `upstream_manual` (human label kept) or `laya_anger_split` (machine relabelled) |
-| `label_source` | string | which evidence produced an anger-pool label; `null` elsewhere |
-| `ekman_p_anger`, `ekman_p_contempt` | float32 | pooled/selected probabilities behind the label; `null` off the anger pool |
-| `ekman_confidence` | float32 | laya's normalised-entropy confidence (English reading) |
-| `ekman_margin_en`, `ekman_margin_id` | float32 | p(anger) - p(contempt) in each language |
-| `p_anger_en`, `p_anger_id` | float32 | p(anger) per individual reading |
-| `en_id_agree` | bool | did the two languages pick the same side |
-| `p_superiority`, `p_blocked_or_unfair` | float32 | Ekman core-feature probes; only run on rows the choice head could not settle, so `null` on most rows |
+| `label_source` | string | which rule produced an anger-pool label; `null` elsewhere |
+| `ambiguous` | bool | the Indonesian `choice` reading stayed under the 0.10 margin |
+| `ekman_p_anger`, `ekman_p_contempt` | float32 | the probabilities behind the label; `null` off the anger pool |
+| `ekman_confidence` | float32 | laya's normalised-entropy confidence (0 = a coin flip) |
+| `p_anger_id`, `ekman_margin_id` | float32 | the Indonesian reading: P(anger) and p(anger) - p(contempt) |
+| `p_anger_swapped` | float32 | the same question with the criteria reversed - the option-order control |
+| `p_superiority`, `p_blocked_or_unfair` | float32 | Ekman core-feature probes; only run on the rows the choice head could not settle, so `null` on most rows |
 | `p_not_anger_or_contempt` | float32 | veto probe - weak, see quality checks |
-| `ambiguous` | bool | neither language reading was decisive |
 | `row_src` | int32 | row index in EmoTweetID's `Data-Annotated-Tweet-File-RESULT.csv` |
 
 ## Configs, splits, sizes
 
-Stratified 8:1:1 on `label` with `random_state=0`, and **group-aware**. sklearn's
-`train_test_split` splits *rows*, which in the first build let 4 duplicate wordings straddle
-train/valid; `stratified_811` in `make_dataset.py` instead shuffles each class's duplicate groups
-with seed 0 and hands them out greedily to the split with the largest remaining deficit against
-80/10/10, so a group is never cut. Fractions then hold up to rounding on whole groups rather than to
-exact row counts (`full` = 1794/226/223 of 2,243) - `verify()` asserts both the fractions and the
-no-leakage property on the written parquet files. `balanced` (the default config) down-samples every class to the smallest class -
-`contempt`, 94 rows, so 7 x 94 = 658 - for parity
-experiments; `full` keeps the natural imbalance of all 2,243 rows; `anger_split` is the
-475-row anger pool on its own, two-class, with every evidence column populated;
-`anger_split_balanced` is that pool at 1:1 (94 per class).
+Two kinds of config, on purpose.
+
+**Whole pools.** `full` is all 2,243 rows at their natural class imbalance and `anger_split` is
+the 475-row anger pool on its own, every evidence column populated. Each ships a single
+`train` split holding the complete pool - nothing is held out, and if you want a validation set you
+take it from there yourself.
+
+**Exact 8:1:1.** `balanced` (the default) and `anger_split_balanced` are the two configs that carry a
+train/valid/test. `b = floor(N/10)` is the bottleneck and the unit of the split: each class is sampled
+to 180 rows - the largest multiple of ten that fits the smallest class, `contempt`,
+at 186 eligible rows - giving N = 1,260 and b = 126. No rounding is left
+anywhere: every class lands 144 / 18 / 18 per split, so the config is exactly balanced
+per class *and* exactly 8b : 1b : 1b overall. `anger_split_balanced` applies the same rule to the
+2-class pool: 360 rows, 288 / 36 / 36 overall and
+144 / 18 / 18 per class. Sampling uses seed 0 and keeps whole duplicate groups,
+so a wording never straddles two splits and a dropped row never orphans its duplicate.
+
+`split_exact.py` and `test_split_exact.py` hold the arithmetic and the assertions; `verify()` re-checks
+the written parquet, including that each class is the same size in every split.
 
 | config | split | rows | per class |
 |---|---|---|---|
-| `balanced` | train | 527 | anger 75 / contempt 76 / disgust 75 / enjoyment 75 / fear 75 / sadness 75 / surprise 76 |
-| `balanced` | valid | 68 | anger 10 / contempt 9 / disgust 10 / enjoyment 10 / fear 10 / sadness 10 / surprise 9 |
-| `balanced` | test | 63 | anger 9 / contempt 9 / disgust 9 / enjoyment 9 / fear 9 / sadness 9 / surprise 9 |
-| `full` | train | 1794 | anger 305 / contempt 75 / disgust 283 / enjoyment 343 / fear 316 / sadness 243 / surprise 229 |
-| `full` | valid | 226 | anger 38 / contempt 10 / disgust 36 / enjoyment 43 / fear 40 / sadness 30 / surprise 29 |
-| `full` | test | 223 | anger 38 / contempt 9 / disgust 36 / enjoyment 43 / fear 39 / sadness 30 / surprise 28 |
-| `anger_split` | train | 380 | anger 305 / contempt 75 |
-| `anger_split` | valid | 48 | anger 38 / contempt 10 |
-| `anger_split` | test | 47 | anger 38 / contempt 9 |
-| `anger_split_balanced` | train | 150 | anger 75 / contempt 75 |
-| `anger_split_balanced` | valid | 20 | anger 10 / contempt 10 |
-| `anger_split_balanced` | test | 18 | anger 9 / contempt 9 |
-
-29 rows share an identical `text` string with another row (more, if you count pairs whose English translation collides), and 14 of those repeated wordings repeat with *different* upstream labels - the annotators disagreed, and this dataset inherits that rather than re-judging it. Splitting is therefore **group-aware**: every member of a duplicate group lands in one split, so no wording appears in both train and test (`verify()` fails the build if one does), and the 8:1:1 fractions hold up to rounding on whole groups rather than to exact row counts.
-
-## How the run was optimised, and what each change was worth
-
-Measured in a 2 vCPU / 2 GB CPU-only sandbox (`torch` 2.14 CPU, laya 0.3.4): 1853 scored
-rows in 1209.6 s of model time, i.e. ~0.65 s per (state, question).
+| `balanced` | train | 1,008 | anger 144 / contempt 144 / disgust 144 / enjoyment 144 / fear 144 / sadness 144 / surprise 144 |
+| `balanced` | valid | 126 | anger 18 / contempt 18 / disgust 18 / enjoyment 18 / fear 18 / sadness 18 / surprise 18 |
+| `balanced` | test | 126 | anger 18 / contempt 18 / disgust 18 / enjoyment 18 / fear 18 / sadness 18 / surprise 18 |
+| `full` | train | 2,243 | anger 289 / contempt 186 / disgust 355 / enjoyment 429 / fear 395 / sadness 303 / surprise 286 (the whole pool, one split) |
+| `anger_split` | train | 475 | anger 289 / contempt 186 (the whole pool, one split) |
+| `anger_split_balanced` | train | 288 | anger 144 / contempt 144 |
+| `anger_split_balanced` | valid | 36 | anger 18 / contempt 18 |
+| `anger_split_balanced` | test | 36 | anger 18 / contempt 18 |
+
+29 rows share an identical `text` string with another row (more, if you count pairs whose English translation collides), and 14 of those repeated wordings repeat with *different* upstream labels - the annotators disagreed, and this dataset inherits that rather than re-judging it. Splitting is therefore **group-aware**: every member of a duplicate group lands in one split, so no wording appears in either side of a train/valid/test boundary (`verify()` fails the build if one does). The balanced configs sample whole groups as well, so a dropped row never orphans its duplicate.
+
+## What the run cost, and what the optimisations were worth
+
+Measured in a 2 vCPU / 2 GB CPU-only sandbox (`torch` 2.14.0+cpu, laya 0.3.4): 1533
+row-scores in 851.2 s of model time (id core 299.8 s, id core swap 299.5 s, id diag 53.5 s, id veto 198.4 s). Asking all four questions of every row
+would have cost 1900.
 
 | change | why | measured effect |
 |---|---|---|
 | keep the encoder at **bf16** instead of laya's forced fp32 | laya sets `dtype = torch.float32` on CPU, upcasting the bf16 checkpoint to 1.29 GB; the stock path was **OOM-killed with exit 137** before it made a single prediction | the run goes from impossible to a 1420 MB peak RSS |
 | **zero-copy** checkpoint load (mmap views instead of `safetensors.load_file`) | the stock loader materialises the 643 MB a second time before copying it into the model | removes a 643 MB transient; weights verified bitwise-identical to stock `load_file` |
-| **staged questions** - choice on every row, Ekman core-feature probes only where neither language reading was decisive | asking all 5 questions in both languages everywhere costs 4750 scored rows | **1853 rows instead** (2.6x less work); stage C ran on 214 of 475 rows |
-| length-sorted, token-budgeted **batches** | laya's `predict` costs one forward pass per state | 1.25x on the biggest stage at a 1024-token cap (596 vs 747 ms/row), 1.19x end to end (1209.6 -> 1020.4 s) - small caps win because attention is quadratic *per row* and laya pads every row of a pass to that pass's longest sequence. A 48-doc micro-benchmark had predicted only 1.00-1.08x, which is the case for measuring on the real corpus (`bench_batch.py`) |
-| **per-stage resumable cache** (`out/cache_<stage>.json`, shipped) | the decision rule changed after the model had already run | all 475 labels re-derived in **13 s** instead of a 20-minute re-run, and `runs/label_run_recheck.log` is that replay |
+| **staged questions** - the choice on every row, the core-feature probes only where the reading was not decisive, the veto and the order control as their own passes | asking every question everywhere costs 1900 row-scores | 1533 instead |
+| length-sorted, token-budgeted **batches** | laya's `predict` costs one forward pass per state | 1.25x on the biggest stage at a 1024-token cap; small caps win because attention is quadratic per row and laya pads every row of a pass to that pass's longest sequence |
+| **per-stage resumable cache** (`out/cache_<stage>.json`, shipped) | the decision rule can change after the model has run | all labels re-derived in seconds instead of a 15-minute re-run |
 
 Two traps worth knowing:
 
 * **`max_len` is not a speed dial.** laya builds `[CLS] <question + options> [SEP] <state> [SEP]` and
   only *truncates* at `max_len`, so a 214-token sequence costs the same at `max_len=1024` as at 256
-  (measured 1.04x). The ~150-token prompt head every row pays is what dominates, so criteria length is
-  the real budget: cutting `head_max_len` 256 -> 128 left all 48 sampled argmaxes unchanged (mean abs
-  probability shift 0.045, exactly 0.000 at >=160), while 96 flipped 23% of them - so 144 was chosen
-  (`sweep_config.py`).
-* **laya truncates every option at 48 tokens** (`build_sequence`). First drafts of the criteria ran to
-  68 and 73 tokens, so the model was scoring half of Ekman's definition, cut mid-sentence at
-  "...aimed at hurting them or a". The shipped criteria fit, and `assert_option_budget()` fails the run
-  if they ever stop fitting.
+  (measured 1.04x). The ~150-token prompt head every row pays is what dominates, so criteria length
+  is the real budget: cutting `head_max_len` 256 -> 128 left all 48 sampled argmaxes unchanged
+  (mean abs probability shift 0.045, exactly 0.000 at >=160), while 96 flipped 23% of them - so 144
+  was chosen (`sweep_config.py`).
+* **laya truncates every option at 48 tokens** (`build_sequence`), so the criteria have to fit that
+  cap or the model scores half of Ekman's definition; `assert_option_budget()` fails the run if they
+  ever stop fitting, in either language.
 
 ## Using it
 
 ```python
 from datasets import load_dataset
-ds = load_dataset("mahalisyarifuddin/emotweetid-ekman7", "balanced")   # 7-class, parity pool
+ds = load_dataset("mahalisyarifuddin/emotweetid-ekman7", "balanced")        # default: exact 8:1:1, 7 classes, 180/class
 ds["train"][0]["text"], ds["train"][0]["label"]
+
+whole = load_dataset("mahalisyarifuddin/emotweetid-ekman7", "full")         # every row, one `train` split
+whole["train"]                                   # 2,243 rows, natural imbalance
+
 # the anger work on its own, with every evidence column:
-ang = load_dataset("mahalisyarifuddin/emotweetid-ekman7", "anger_split")
+ang = load_dataset("mahalisyarifuddin/emotweetid-ekman7", "anger_split")    # all 475 pool rows, one split
+ang = load_dataset("mahalisyarifuddin/emotweetid-ekman7", "anger_split_balanced")   # same pool, 1:1, exact 8:1:1
+```
+
+If you want the option-order-debiased reading, recompute it from the shipped columns:
+
+```python
+p = (ang["train"]["p_anger_id"] + ang["train"]["p_anger_swapped"]) / 2   # 1 = anger, 0 = contempt
 ```
 
 Or reproduce it end to end:
 
 ```bash
-pip install laya scikit-learn pandas pyarrow datasets huggingface_hub
+pip install laya scikit-learn pandas pyarrow datasets huggingface_hub scipy
 python fetch_source_data.py                       # data/file1.csv + data/file2.csv (CC BY 4.0)
 python prepare_checkpoint.py                      # models/laya-ml + models/enc-bf16 (bf16, low-mem)
-python label_anger.py                             # out/anger_ekman_rows.csv  (~20 min on 2 CPU cores)
+python probe_quality_id.py                        # the probe matrix -> out/probe_quality_id.json
+python label_anger_id.py --out out                # ~15 min on 2 CPU cores, Indonesian only
+python test_split_exact.py                        # exact 8:1:1 + no-leakage assertions
 python make_dataset.py                            # splits + parquet + this card, with verification
 python publish.py --repo <namespace>/<name>        # HF upload; needs HF_TOKEN with write scope
 ```
@@ -282,36 +347,43 @@ Built with laya 0.3.4, transformers 5.17.0, datasets 5.0.1, torch
 2.14.0+cpu on CPU. The model was never loaded to build this repo's numbers:
 `build_info.checkpoint_facts` reads them from the checkpoint's safetensors header.
 
-Everything is in this repo: `label_anger.py`, `laya_opt.py`, `ekman_questions.py`, `zcsafe.py`,
-`prepare_checkpoint.py`, `make_dataset.py`, `probe_quality.py`, `probes.py`, `fetch_source_data.py`,
-`bench_speedup.py`, `bench_batch.py`, `sweep_config.py`, `check_veto_and_speed.py`,
-`publish.py`, and the console logs of both runs in `runs/` (`label_run.log` = the 6144-token score
-run whose cached scores the shipped labels came from; `label_run_b1024.log` = the 1024-token
-replication; `label_run_recheck.log` = the replay of the shipped defaults from those cached scores,
-whose labels came out byte-identical to `out/anger_ekman_rows.csv`). The anger pool's full evidence
-table and the three score caches ship in `out/`, so the split can be re-cut from the repo itself. Stage timings: en core 709.7 s, id core 311.0 s, en diag 188.9 s. `out/timings.json` carries the exact config. `build_info.json` holds the exact counts behind this card.
+Everything is in this repo: `label_anger_id.py` (the labeller as run), `ekman_questions.py`,
+`ekman_questions_id.py`, `laya_opt.py`, `split_exact.py` + `test_split_exact.py`, `zcsafe.py`,
+`prepare_checkpoint.py`, `make_dataset.py`, `probe_quality_id.py`, `probes.py` / `probes_id.py`,
+`audit_flips.py`, `fetch_source_data.py`, `publish.py`, and the benchmarking scripts
+(`bench_speedup.py`, `bench_batch.py`, `sweep_config.py`, `check_veto_and_speed.py`). The score
+caches and evidence behind every label are in `out/` (`cache_id_core.json`, `cache_id_core_swap.json`,
+`cache_id_diag.json`, `cache_id_veto.json`, `anger_ekman_rows.csv`, `probe_quality_id.json`,
+`audit_flips.csv`, `timings.json`), and the project's earlier two-language reading of the pool in
+`out_prev/`, so every claim on this card can be re-derived from the repo without the model. `build_info.json`
+holds the exact counts behind it.
 
 ## Limitations
 
-* **Mixed provenance.** 475 rows carry a machine decision; the other 1,768 carry the
-  annotators' labels. `label_origin` marks it; comparisons across the two are not apples-to-apples, and any
-  error analysis should be stratified by it.
-* **The machine labels are weak-ish.** A 13/16 (0.812) probe result from a 322M base model that
-  laya's own card describes as "a fast base to specialise, not a zero-shot decision engine"
-  (DAIR-Emotion F1 0.595) means the hard middle of the anger pool is genuinely uncertain - exactly where Ekman says contempt rides along with mild
-  anger ("often accompanied by anger, usually in a mild form such as annoyance").
-* **`contempt` is small**: 94 rows, `94` per class in
-  `anger_split_balanced`. Enough for a two-way study or a fine-tuning seed; not enough to claim a
-  production contempt detector, and the 4.2% share means a 7-way model trained on `full` will need
-  class weights or resampling to see it at all.
-* **Translation noise propagates.** EmoTweetID's `tweet_en` mistranslates slang - `GUA MURKA` ("I am
-  furious") arrives as "THE CAVE IS ANGRY" - which is a large part of why the two language readings
-  agree only 0.625 of the time. `text` (Indonesian) is the default input for that reason.
+* **The Indonesian reading is the weaker of the two this project has measured**, and the probe matrix
+  above says by how much: the same 16 sentences are called correctly 14/16 (0.875) in English and
+  11/16 (0.688) in Indonesian, the errors lean toward `contempt`, and the reading moves with the option
+  order (25.1% of the pool). For the best anger/contempt discriminator this pipeline has
+  produced, take the two-language labels in `out_prev/anger_ekman_rows.csv`; for a decision that never
+  depends on a machine translation, use these.
+* **Machine labels are weak-ish in general.** A 322M base model that laya's own card describes as "a
+  fast base to specialise, not a zero-shot decision engine" means the hard middle of the anger pool is
+  genuinely uncertain - exactly where Ekman says contempt rides along with mild anger ("often
+  accompanied by anger, usually in a mild form such as annoyance").
+* **Mixed provenance.** 475 rows carry a machine decision; the other 1,768 carry
+  the annotators' labels. `label_origin` marks it; comparisons across the two are not
+  apples-to-apples, and any error analysis should be stratified by it.
+* **`contempt` is still small** for a production need: 186 rows in the pool, so the
+  balanced configs give it 180 rows per class - enough for a two-way study or a
+  fine-tuning seed, not for a claim about contempt detection in the wild.
+* **`text_en` is machine translation** and stays in the schema for reference only. Every label is
+  decided from `text`.
 * **Upstream noise carries into the pool.** Only anger was audited; a mislabelled `joy`/`disgust` row
-  stays mislabelled here. The upstream annotation had substantial, not perfect, agreement.
+  stays mislabelled here. The upstream annotation had substantial, not perfect, agreement, and the
+  audit above found several pool rows that read as neither anger nor contempt.
 * **No neutral class**, and no intensity scores: an `intensity` question was written and measured, did
-  not discriminate (1.1-1.8 on all 16 probes), so `label_anger.py` never asks it - it stays in
-  `ekman_questions.py` as a documented dead end rather than shipping as noise.
+  not discriminate (1.1-1.8 on all 16 probes), so it is not asked - it stays in `ekman_questions.py`
+  as a documented dead end rather than shipping as noise.
 * Tweets are raw: all-caps, code-mixed Indonesian/Javanese/Malay, slang, emoji, insults and slurs.
   Only whitespace was normalised.
 

README.template.md

@@ -1,6 +1,6 @@
 ---
 license: cc-by-4.0
-pretty_name: "EmoTweetID Ekman-7: five human-tagged Ekman emotions + the anger pool split into anger vs contempt (laya)"
+pretty_name: "EmoTweetID Ekman-7: five human-tagged Ekman emotions + the anger pool split into anger vs contempt by laya, from the Indonesian text"
 language:
 - id
 - en
@@ -42,18 +42,10 @@ configs:
   data_files:
   - split: train
     path: full/train.parquet
-  - split: valid
-    path: full/valid.parquet
-  - split: test
-    path: full/test.parquet
 - config_name: anger_split
   data_files:
   - split: train
     path: anger_split/train.parquet
-  - split: valid
-    path: anger_split/valid.parquet
-  - split: test
-    path: anger_split/test.parquet
 - config_name: anger_split_balanced
   data_files:
   - split: train
@@ -67,11 +59,13 @@ configs:
 # EmoTweetID under Ekman's seven universal emotions
 
 {{n_pool}} Indonesian tweets, one label each from Ekman's universal set - **anger, contempt, disgust,
-enjoyment, fear, sadness, surprise**. {{n_anger_pool}} of them are the pool EmoTweetID tagged `anger`, and that pool is the only
-thing this dataset changes: it is split by [laya](https://pypi.org/project/laya/)
-against Ekman's own definitions into **anger ({{n_anger_kept}})** and **contempt ({{n_contempt}})** -
-{{share_contempt}}% of the pool. The other five classes keep EmoTweetID's human annotations verbatim.
-Stratified 8:1:1 train/valid/test, seed 0, no duplicate leakage, four configs.
+enjoyment, fear, sadness, surprise**. {{n_anger_pool}} of them are the pool EmoTweetID tagged `anger`,
+and that pool is the only place this dataset makes a decision of its own: [laya](https://pypi.org/project/laya/)
+reads each of those tweets, in Indonesian, against Ekman's own definitions of the two emotions, and
+splits them into **anger ({{n_anger_kept}})** and **contempt ({{n_contempt}})** - contempt is
+{{share_contempt}}% of the pool. The other five classes are EmoTweetID's human annotations, carried over verbatim.
+Four configs: `full` and `anger_split` are the complete pools, each in a single split; `balanced`
+(default) and `anger_split_balanced` are exact 8:1:1 train/valid/test, seed 0, no duplicate leakage.
 
 Why bother: Ekman lists anger and contempt as two different universal emotions with different
 triggers, different messages and different facial signatures, but emotion corpora - and the models
@@ -82,7 +76,7 @@ system has to tell "you wronged me, put it right" from "you are beneath me".
 |---|---|---|---|
 {{class_table}}
 
-## What was relabelled, and what was not
+## How each class got its label
 
 | source label (EmoTweetID, human) | rows | treatment here |
 |---|---|---|
@@ -91,7 +85,7 @@ system has to tell "you wronged me, put it right" from "you are beneath me".
 | `disgust` | 355 | kept |
 | `sadness` | 303 | kept |
 | `surprise` | 286 | kept |
-| `anger` | {{n_anger_pool}} | **re-read by laya** and split into `anger` / `contempt` |
+| `anger` | 475 | **re-read by laya, in Indonesian**, and split into `anger` / `contempt` |
 
 `label_origin` on every row says which of the two applies, and `source_label` always keeps the
 upstream name. Nothing else in the schema was modelled; there is no `neutral` class because
@@ -108,7 +102,13 @@ GoEmotions - which is why this card has 7 classes where the reference has 8.
   [Mendeley Data jzgnjsff9f](https://data.mendeley.com/datasets/jzgnjsff9f).
 * **Licence**: CC BY 4.0 on the source; this derived dataset is CC BY 4.0 as well.
 * **Definitions**: [What is Anger?](https://www.paulekman.com/universal-emotions/what-is-anger/) and
-  [What is Contempt?](https://www.paulekman.com/universal-emotions/what-is-contempt/), Paul Ekman Group.
+  [What is Contempt?](https://www.paulekman.com/universal-emotions/what-is-contempt/), Paul Ekman
+  Group. The criteria shown to the model are condensed from these two pages.
+* **Language**: every label here is decided from `text`, the tweet as written. `text_en` is
+  EmoTweetID's machine translation and is never an input to any label; it ships only because it is
+  upstream data. An earlier reading of this same pool used `text` and `text_en` together; those rows,
+  their probabilities and the caches behind them are kept in `out_prev/`, so the two readings can be
+  compared row by row - {{prev_note}}.
 
 ## The two classes the split turns on, in Ekman's words
 
@@ -129,84 +129,140 @@ Operational boundary: **anger wants the obstacle gone; contempt puts the target
 
 ## How the anger split was decided
 
-`pip install laya` (v{{laya_v}}), checkpoint `{{checkpoint}}`: {{params}} params in {{tensors}}
-tensors - a {{params_enc}} `{{enc_name}}` encoder ({{model_type}}, {{amp}} weights, vocab {{vocab}},
-laya's own context cap {{ctx_default}} tokens) plus {{params_heads}} of decision heads that turn one
-forward pass into probabilities over the options you asked about. For each tweet: one `choice` question whose two options are the criteria
-above, plus two `noul` probes of each emotion's core feature (superiority, blocked-or-unfair) and a
-`not_anger_or_contempt` veto; `label_source` on each row records which of those rules decided it.
-One non-autoregressive forward pass per question - no generation, so
-nothing to parse and nothing to hallucinate.
-
-Each tweet is read twice, in Indonesian (the language it was written in) and in EmoTweetID's English
-translation (the language Ekman's definitions, and laya's strongest read, are in), and the readings
-are combined by descending trust:
-
-1. both on the same side -> pool the two distributions (`ekman_choice_pooled`);
-2. they disagree -> keep the more confident one (`ekman_choice_en` / `ekman_choice_id`);
-3. neither decisive (pooled margin under 0.10) -> Ekman's core-feature probes (`ekman_noul_tiebreak`);
-4. still nothing -> keep the upstream `anger` label (`kept_original_label`).
-
-Realised as: {{sources_str}}. Every probability is on the row, so you can re-cut the split with your
-own threshold instead of trusting this rule.
+`pip install laya` (v{{laya_v}}), checkpoint `convaiinnovations/laya`, subfolder `multilingual/`:
+{{params}} params in {{tensors}} tensors - a {{params_enc}} `{{enc_name}}` encoder ({{model_type}},
+bf16 weights, vocab {{vocab}}, laya's own context cap {{ctx_default}} tokens) plus {{params_heads}} of
+decision heads that turn one forward pass into probabilities over the options you asked about. For
+each tweet: one `choice` question whose two options are Ekman's criteria above, the same question
+again with the options in the opposite order, `noul` probes of each emotion's core feature
+(superiority, blocked-or-unfair) on the rows the choice head could not settle, and a
+`not_anger_or_contempt` veto as a diagnostic. One non-autoregressive forward pass per question - no
+generation, so nothing to parse and nothing to hallucinate. Every tweet is read in Indonesian; the
+question itself stays laya's own English prompt, i.e. Ekman's criteria are quoted in the language
+they were written in.
+
+The four stages, over the {{n_anger_pool}} anger-pool rows:
+
+| stage | question(s) | rows scored (state x question) | what it is for |
+|---|---|---|---|
+| `id_core` | `ekman` (choice) | {{n_anger_pool}} | the decision |
+| `id_core_swap` | same, contempt listed first | {{n_anger_pool}} | option-order control (`p_anger_swapped`) |
+| `id_diag` | `superiority`, `blocked_or_unfair` | {{stage_diag}} | only on the rows `id_core` left under a 0.10 margin |
+| `id_veto` | `not_anger_or_contempt` | {{n_anger_pool}} | off-topic diagnostic - **do not filter on it** |
+
+The decision rule, in order:
+
+1. the `choice` reading is decisive (|p(anger) - p(contempt)| >= {{margin}}) -> its argmax
+   (`ekman_choice_id`);
+2. not decisive -> Ekman's core-feature probes break the tie, superiority => contempt,
+   blocked-or-unfair => anger (`ekman_noul_tiebreak`);
+3. both still under the margin -> the average of the two option orders decides, if it has a side
+   (`ekman_choice_order_avg`);
+4. nothing at all -> keep the upstream EmoTweetID label `anger` (`kept_original_label`): this dataset
+   only ever *splits* an existing anger pool, it never re-litigates it.
+
+Realised as: {{sources_str}}. Every probability is on the row - `p_anger_id` (as prompted),
+`p_anger_swapped` (options reversed), `ekman_p_anger`, `ekman_p_contempt`, `ekman_margin_id`,
+`p_superiority`, `p_blocked_or_unfair`, `p_not_anger_or_contempt` - so you can re-cut the split with
+your own threshold instead of trusting this rule.
+
+Reproducibility: {{repro_note}}. On a second, complete run of the labeller - fresh caches, same
+sandbox - {{reconfirm_note}}; that run's summary is `out/reconfirm.json` and its console log
+`runs/label_run_id_reconfirm.log`.
 
 ### Quality checks on the machine labels - read before using them
 
-* **Fit-for-purpose probe**: on 16 hand-written unambiguous sentences (8 clear anger, 8 clear
-  contempt, written from the two Ekman pages, not from the corpus) the `choice` head was right
-  **{{probe_acc}}** against a 0.50 chance line. The misses: one heated political complaint read as contempt,
-  two quietly-scornful lines read as anger.
-* **The `noul` probes are weak** (mean P(superiority) 0.16 on contempt vs 0.13 on anger), which is why
-  they only break ties and why they were measured before being trusted.
-* **Do not filter on `p_not_anger_or_contempt`.** {{offtopic}} rows exceed 0.5, but the four
-  most-flagged tweets are among the angriest in the pool (`AK MURKA`,
-  `SUMPAH GUA MURKA LIAT INI. PEN GUA TEBAS JUGA LU PAK`, ...). The same question behaves on the
-  question behaves sanely on English sentences ({{veto}}), so it degrades on short, shouty,
-  code-mixed Indonesian rather than detecting mislabels. Interesting-failure signal, not a filter.
-* The two language readings agreed on argmax for **{{agree}}** of the pool. {{stageC}} of
-  {{n_anger_pool}} rows had a thin margin in at least one language or disagreed outright and were
-  re-asked with the core-feature probes; {{ambig}} were indecisive in *both* languages; {{lowconf}}
-  rows came out under 0.6 confidence. Every one of those is flagged per row.
-* **Stability**: {{reagree_note}}.
-
-These are machine-assisted weak labels from a 322M model - the other 1,768 rows are human labels.
-That mixture is deliberate and marked per row, but it means model and human error are not
-comparable across `label_origin`, and `anger`/`contempt` rows are the noisier subset.
+**Fit-for-purpose probes, in both languages.** 16 hand-written unambiguous sentences (8 clear anger,
+8 clear contempt, written from the two Ekman pages, not from the corpus) in Indonesian and in
+English, plus the project's reference English probe set, and the two controls that matter (question
+language, option order). Chance is 0.50.
+
+| condition | accuracy |
+|---|---|
+| the project's 16 reference English probes, English question | {{probe_author}} |
+| the same 16 items in English, English question | {{probe_en}} |
+| **the same 16 probes in Indonesian, English question** - the reading this dataset uses | **{{probe_id}}** |
+| the same Indonesian probes with an *Indonesian* question | {{probe_id_idq}} |
+| English probes with an Indonesian question | {{probe_en_idq}} |
+| Indonesian probes, criteria order swapped (contempt first) | {{probe_id_swapped}} |
+
+{{probe_gap}}. {{probe_mean_p}}. {{probe_order}}. The Indonesian reading is therefore the weaker of
+the two on these probes, and its errors lean toward `contempt`; putting the question in Indonesian
+does not recover the gap ({{probe_lang_q}}).
+
+**Option-order sensitivity on the corpus.** {{order_note}}. `p_anger_swapped` ships on every row, so
+the debiased reading is `(p_anger_id + p_anger_swapped) / 2` if you want it.
+
+**The corpus's own anger vocabulary.** {{lexicon_note}} This is the sharpest single piece of evidence
+on this card: the words that most plainly mean anger in Indonesian are where the Indonesian reading
+calls contempt most often.
+
+**One-reader audit of the disagreements.** {{audit_note}}
+
+**The `noul` probes are weak - and here they do more work than they should.** Their separation on the
+probe sentences is small (mean P(superiority) 0.16 on contempt vs 0.13 on anger, which is why an
+earlier reading of this pool only trusted them for 2 of 475 rows). On this reading {{stageC}} rows come
+out inside the 0.10 margin, and {{noul_n}} of them are decided by those probes - so a weak tie-breaker
+settles {{noul_n}} labels. Prefer the probability columns to `label` if that matters for your use:
+`ekman_choice_id` decided {{choice_n}}, the option-order average {{orderavg_n}}, the upstream `anger`
+label {{kept_n}}.
+
+**Do not filter on `p_not_anger_or_contempt`.** {{veto}}. The most-flagged rows include some of the
+angriest tweets in the pool (`AK MURKA`, `SUMPAH GUA MURKA LIAT INI. PEN GUA TEBAS JUGA LU PAK`), so
+the probe is picking up register, not mislabels. It ships as a documented dead end.
+
+**Confidence.** {{conf_note}}. `ekman_confidence` is laya's own confidence for the reading
+(`1 - normalised entropy`, 0 = a coin flip), and {{lowconf_laya}} rows sit under 0.6. Note that
+`out_prev/` stores max P(anger) in that column instead - a different scale, so the two are not
+directly comparable.
+
+Bottom line: all {{n_anger_pool}} pool labels are a machine decision from a 322M model whose own card
+calls it "a fast base to specialise, not a zero-shot decision engine", asked in the language that
+measures weaker on the probes above. The other {{n_manual}} rows are human labels. `label_origin`
+marks which is which; model and human error are not comparable across it, and the `anger`/`contempt`
+rows are the noisier subset.
 
 ## Schema
 
 | field | type | meaning |
 |---|---|---|
-| `text` | string | the tweet as written (Indonesian) - the default model input |
-| `text_en` | string | EmoTweetID's English translation |
+| `text` | string | the tweet as written (Indonesian) - the model input |
+| `text_en` | string | EmoTweetID's English machine translation. Not an input to any label here - kept because it is upstream data |
 | `label` | string | one of the 7 Ekman classes |
 | `label_idx` | ClassLabel | `label` as an int, in the order anger, contempt, disgust, enjoyment, fear, sadness, surprise (anger, contempt in the `anger_split` configs) |
 | `source_label` | string | upstream EmoTweetID label (`anger`, `joy`, `fear`, `disgust`, `sadness`, `surprise`) |
 | `label_origin` | string | `upstream_manual` (human label kept) or `laya_anger_split` (machine relabelled) |
-| `label_source` | string | which evidence produced an anger-pool label; `null` elsewhere |
-| `ekman_p_anger`, `ekman_p_contempt` | float32 | pooled/selected probabilities behind the label; `null` off the anger pool |
-| `ekman_confidence` | float32 | laya's normalised-entropy confidence (English reading) |
-| `ekman_margin_en`, `ekman_margin_id` | float32 | p(anger) - p(contempt) in each language |
-| `p_anger_en`, `p_anger_id` | float32 | p(anger) per individual reading |
-| `en_id_agree` | bool | did the two languages pick the same side |
-| `p_superiority`, `p_blocked_or_unfair` | float32 | Ekman core-feature probes; only run on rows the choice head could not settle, so `null` on most rows |
+| `label_source` | string | which rule produced an anger-pool label; `null` elsewhere |
+| `ambiguous` | bool | the Indonesian `choice` reading stayed under the 0.10 margin |
+| `ekman_p_anger`, `ekman_p_contempt` | float32 | the probabilities behind the label; `null` off the anger pool |
+| `ekman_confidence` | float32 | laya's normalised-entropy confidence (0 = a coin flip) |
+| `p_anger_id`, `ekman_margin_id` | float32 | the Indonesian reading: P(anger) and p(anger) - p(contempt) |
+| `p_anger_swapped` | float32 | the same question with the criteria reversed - the option-order control |
+| `p_superiority`, `p_blocked_or_unfair` | float32 | Ekman core-feature probes; only run on the rows the choice head could not settle, so `null` on most rows |
 | `p_not_anger_or_contempt` | float32 | veto probe - weak, see quality checks |
-| `ambiguous` | bool | neither language reading was decisive |
 | `row_src` | int32 | row index in EmoTweetID's `Data-Annotated-Tweet-File-RESULT.csv` |
 
 ## Configs, splits, sizes
 
-Stratified 8:1:1 on `label` with `random_state=0`, and **group-aware**. sklearn's
-`train_test_split` splits *rows*, which in the first build let 4 duplicate wordings straddle
-train/valid; `stratified_811` in `make_dataset.py` instead shuffles each class's duplicate groups
-with seed 0 and hands them out greedily to the split with the largest remaining deficit against
-80/10/10, so a group is never cut. Fractions then hold up to rounding on whole groups rather than to
-exact row counts (`full` = 1794/226/223 of 2,243) - `verify()` asserts both the fractions and the
-no-leakage property on the written parquet files. `balanced` (the default config) down-samples every class to the smallest class -
-`contempt`, {{per_class_balanced}} rows, so 7 x {{per_class_balanced}} = {{n_balanced}} - for parity
-experiments; `full` keeps the natural imbalance of all {{n_pool}} rows; `anger_split` is the
-{{n_anger_pool}}-row anger pool on its own, two-class, with every evidence column populated;
-`anger_split_balanced` is that pool at 1:1 ({{per_class_anger_balanced}} per class).
+Two kinds of config, on purpose.
+
+**Whole pools.** `full` is all {{n_pool}} rows at their natural class imbalance and `anger_split` is
+the {{n_anger_pool}}-row anger pool on its own, every evidence column populated. Each ships a single
+`train` split holding the complete pool - nothing is held out, and if you want a validation set you
+take it from there yourself.
+
+**Exact 8:1:1.** `balanced` (the default) and `anger_split_balanced` are the two configs that carry a
+train/valid/test. `b = floor(N/10)` is the bottleneck and the unit of the split: each class is sampled
+to {{per_class_balanced}} rows - the largest multiple of ten that fits the smallest class, `contempt`,
+at {{n_contempt}} eligible rows - giving N = {{n_balanced_s}} and b = {{balanced_b}}. No rounding is left
+anywhere: every class lands {{balanced_per_class_split}} per split, so the config is exactly balanced
+per class *and* exactly 8b : 1b : 1b overall. `anger_split_balanced` applies the same rule to the
+2-class pool: {{n_anger_balanced_s}} rows, {{anger_split_balanced_split}} overall and
+{{anger_balanced_per_class_split}} per class. Sampling uses seed 0 and keeps whole duplicate groups,
+so a wording never straddles two splits and a dropped row never orphans its duplicate.
+
+`split_exact.py` and `test_split_exact.py` hold the arithmetic and the assertions; `verify()` re-checks
+the written parquet, including that each class is the same size in every split.
 
 | config | split | rows | per class |
 |---|---|---|---|
@@ -214,49 +270,62 @@ experiments; `full` keeps the natural imbalance of all {{n_pool}} rows; `anger_s
 
 {{duplicates_note}}
 
-## How the run was optimised, and what each change was worth
+## What the run cost, and what the optimisations were worth
 
-Measured in a 2 vCPU / 2 GB CPU-only sandbox (`torch` 2.14 CPU, laya 0.3.4): {{scored_rows}} scored
-rows in {{laya_seconds}} s of model time, i.e. ~0.65 s per (state, question).
+Measured in a 2 vCPU / 2 GB CPU-only sandbox (`torch` {{torch_v}}, laya {{laya_v}}): {{scored_rows}}
+row-scores in {{laya_seconds}} s of model time ({{stages}}). Asking all four questions of every row
+would have cost {{naive_rows}}.
 
 | change | why | measured effect |
 |---|---|---|
 | keep the encoder at **bf16** instead of laya's forced fp32 | laya sets `dtype = torch.float32` on CPU, upcasting the bf16 checkpoint to 1.29 GB; the stock path was **OOM-killed with exit 137** before it made a single prediction | the run goes from impossible to a 1420 MB peak RSS |
 | **zero-copy** checkpoint load (mmap views instead of `safetensors.load_file`) | the stock loader materialises the 643 MB a second time before copying it into the model | removes a 643 MB transient; weights verified bitwise-identical to stock `load_file` |
-| **staged questions** - choice on every row, Ekman core-feature probes only where neither language reading was decisive | asking all 5 questions in both languages everywhere costs {{naive_rows}} scored rows | **{{scored_rows}} rows instead** (2.6x less work); stage C ran on {{stageC}} of {{n_anger_pool}} rows |
-| length-sorted, token-budgeted **batches** | laya's `predict` costs one forward pass per state | 1.25x on the biggest stage at a 1024-token cap (596 vs 747 ms/row), 1.19x end to end (1209.6 -> 1020.4 s) - small caps win because attention is quadratic *per row* and laya pads every row of a pass to that pass's longest sequence. A 48-doc micro-benchmark had predicted only 1.00-1.08x, which is the case for measuring on the real corpus (`bench_batch.py`) |
-| **per-stage resumable cache** (`out/cache_<stage>.json`, shipped) | the decision rule changed after the model had already run | all {{n_anger_pool}} labels re-derived in **13 s** instead of a 20-minute re-run, and `runs/label_run_recheck.log` is that replay |
+| **staged questions** - the choice on every row, the core-feature probes only where the reading was not decisive, the veto and the order control as their own passes | asking every question everywhere costs {{naive_rows}} row-scores | {{scored_rows}} instead |
+| length-sorted, token-budgeted **batches** | laya's `predict` costs one forward pass per state | 1.25x on the biggest stage at a 1024-token cap; small caps win because attention is quadratic per row and laya pads every row of a pass to that pass's longest sequence |
+| **per-stage resumable cache** (`out/cache_<stage>.json`, shipped) | the decision rule can change after the model has run | all labels re-derived in seconds instead of a 15-minute re-run |
 
 Two traps worth knowing:
 
 * **`max_len` is not a speed dial.** laya builds `[CLS] <question + options> [SEP] <state> [SEP]` and
   only *truncates* at `max_len`, so a 214-token sequence costs the same at `max_len=1024` as at 256
-  (measured 1.04x). The ~150-token prompt head every row pays is what dominates, so criteria length is
-  the real budget: cutting `head_max_len` 256 -> 128 left all 48 sampled argmaxes unchanged (mean abs
-  probability shift 0.045, exactly 0.000 at >=160), while 96 flipped 23% of them - so 144 was chosen
-  (`sweep_config.py`).
-* **laya truncates every option at 48 tokens** (`build_sequence`). First drafts of the criteria ran to
-  68 and 73 tokens, so the model was scoring half of Ekman's definition, cut mid-sentence at
-  "...aimed at hurting them or a". The shipped criteria fit, and `assert_option_budget()` fails the run
-  if they ever stop fitting.
+  (measured 1.04x). The ~150-token prompt head every row pays is what dominates, so criteria length
+  is the real budget: cutting `head_max_len` 256 -> 128 left all 48 sampled argmaxes unchanged
+  (mean abs probability shift 0.045, exactly 0.000 at >=160), while 96 flipped 23% of them - so 144
+  was chosen (`sweep_config.py`).
+* **laya truncates every option at 48 tokens** (`build_sequence`), so the criteria have to fit that
+  cap or the model scores half of Ekman's definition; `assert_option_budget()` fails the run if they
+  ever stop fitting, in either language.
 
 ## Using it
 
 ```python
 from datasets import load_dataset
-ds = load_dataset("mahalisyarifuddin/emotweetid-ekman7", "balanced")   # 7-class, parity pool
+ds = load_dataset("{{repo}}", "balanced")        # default: exact 8:1:1, 7 classes, {{per_class_balanced}}/class
 ds["train"][0]["text"], ds["train"][0]["label"]
+
+whole = load_dataset("{{repo}}", "full")         # every row, one `train` split
+whole["train"]                                   # {{n_pool}} rows, natural imbalance
+
 # the anger work on its own, with every evidence column:
-ang = load_dataset("mahalisyarifuddin/emotweetid-ekman7", "anger_split")
+ang = load_dataset("{{repo}}", "anger_split")    # all {{n_anger_pool}} pool rows, one split
+ang = load_dataset("{{repo}}", "anger_split_balanced")   # same pool, 1:1, exact 8:1:1
+```
+
+If you want the option-order-debiased reading, recompute it from the shipped columns:
+
+```python
+p = (ang["train"]["p_anger_id"] + ang["train"]["p_anger_swapped"]) / 2   # 1 = anger, 0 = contempt
 ```
 
 Or reproduce it end to end:
 
 ```bash
-pip install laya scikit-learn pandas pyarrow datasets huggingface_hub
+pip install laya scikit-learn pandas pyarrow datasets huggingface_hub scipy
 python fetch_source_data.py                       # data/file1.csv + data/file2.csv (CC BY 4.0)
 python prepare_checkpoint.py                      # models/laya-ml + models/enc-bf16 (bf16, low-mem)
-python label_anger.py                             # out/anger_ekman_rows.csv  (~20 min on 2 CPU cores)
+python probe_quality_id.py                        # the probe matrix -> out/probe_quality_id.json
+python label_anger_id.py --out out                # ~15 min on 2 CPU cores, Indonesian only
+python test_split_exact.py                        # exact 8:1:1 + no-leakage assertions
 python make_dataset.py                            # splits + parquet + this card, with verification
 python publish.py --repo <namespace>/<name>        # HF upload; needs HF_TOKEN with write scope
 ```
@@ -265,36 +334,43 @@ Built with laya {{laya_v}}, transformers {{transformers_v}}, datasets {{datasets
 {{torch_v}} on CPU. The model was never loaded to build this repo's numbers:
 `build_info.checkpoint_facts` reads them from the checkpoint's safetensors header.
 
-Everything is in this repo: `label_anger.py`, `laya_opt.py`, `ekman_questions.py`, `zcsafe.py`,
-`prepare_checkpoint.py`, `make_dataset.py`, `probe_quality.py`, `probes.py`, `fetch_source_data.py`,
-`bench_speedup.py`, `bench_batch.py`, `sweep_config.py`, `check_veto_and_speed.py`,
-`publish.py`, and the console logs of both runs in `runs/` (`label_run.log` = the 6144-token score
-run whose cached scores the shipped labels came from; `label_run_b1024.log` = the 1024-token
-replication; `label_run_recheck.log` = the replay of the shipped defaults from those cached scores,
-whose labels came out byte-identical to `out/anger_ekman_rows.csv`). The anger pool's full evidence
-table and the three score caches ship in `out/`, so the split can be re-cut from the repo itself. Stage timings: {{stages}}. `out/timings.json` carries the exact config. `build_info.json` holds the exact counts behind this card.
+Everything is in this repo: `label_anger_id.py` (the labeller as run), `ekman_questions.py`,
+`ekman_questions_id.py`, `laya_opt.py`, `split_exact.py` + `test_split_exact.py`, `zcsafe.py`,
+`prepare_checkpoint.py`, `make_dataset.py`, `probe_quality_id.py`, `probes.py` / `probes_id.py`,
+`audit_flips.py`, `fetch_source_data.py`, `publish.py`, and the benchmarking scripts
+(`bench_speedup.py`, `bench_batch.py`, `sweep_config.py`, `check_veto_and_speed.py`). The score
+caches and evidence behind every label are in `out/` (`cache_id_core.json`, `cache_id_core_swap.json`,
+`cache_id_diag.json`, `cache_id_veto.json`, `anger_ekman_rows.csv`, `probe_quality_id.json`,
+`audit_flips.csv`, `timings.json`), and the project's earlier two-language reading of the pool in
+`out_prev/`, so every claim on this card can be re-derived from the repo without the model. `build_info.json`
+holds the exact counts behind it.
 
 ## Limitations
 
-* **Mixed provenance.** {{n_anger_pool}} rows carry a machine decision; the other {{n_manual}} carry the
-  annotators' labels. `label_origin` marks it; comparisons across the two are not apples-to-apples, and any
-  error analysis should be stratified by it.
-* **The machine labels are weak-ish.** A {{probe_acc}} probe result from a 322M base model that
-  laya's own card describes as "a fast base to specialise, not a zero-shot decision engine"
-  (DAIR-Emotion F1 0.595) means the hard middle of the anger pool is genuinely uncertain - exactly where Ekman says contempt rides along with mild
-  anger ("often accompanied by anger, usually in a mild form such as annoyance").
-* **`contempt` is small**: {{n_contempt}} rows, `{{per_class_anger_balanced}}` per class in
-  `anger_split_balanced`. Enough for a two-way study or a fine-tuning seed; not enough to claim a
-  production contempt detector, and the 4.2% share means a 7-way model trained on `full` will need
-  class weights or resampling to see it at all.
-* **Translation noise propagates.** EmoTweetID's `tweet_en` mistranslates slang - `GUA MURKA` ("I am
-  furious") arrives as "THE CAVE IS ANGRY" - which is a large part of why the two language readings
-  agree only {{agree}} of the time. `text` (Indonesian) is the default input for that reason.
+* **The Indonesian reading is the weaker of the two this project has measured**, and the probe matrix
+  above says by how much: the same 16 sentences are called correctly {{probe_en}} in English and
+  {{probe_id}} in Indonesian, the errors lean toward `contempt`, and the reading moves with the option
+  order ({{order_flip}}% of the pool). For the best anger/contempt discriminator this pipeline has
+  produced, take the two-language labels in `out_prev/anger_ekman_rows.csv`; for a decision that never
+  depends on a machine translation, use these.
+* **Machine labels are weak-ish in general.** A 322M base model that laya's own card describes as "a
+  fast base to specialise, not a zero-shot decision engine" means the hard middle of the anger pool is
+  genuinely uncertain - exactly where Ekman says contempt rides along with mild anger ("often
+  accompanied by anger, usually in a mild form such as annoyance").
+* **Mixed provenance.** {{n_anger_pool}} rows carry a machine decision; the other {{n_manual}} carry
+  the annotators' labels. `label_origin` marks it; comparisons across the two are not
+  apples-to-apples, and any error analysis should be stratified by it.
+* **`contempt` is still small** for a production need: {{n_contempt}} rows in the pool, so the
+  balanced configs give it {{per_class_balanced}} rows per class - enough for a two-way study or a
+  fine-tuning seed, not for a claim about contempt detection in the wild.
+* **`text_en` is machine translation** and stays in the schema for reference only. Every label is
+  decided from `text`.
 * **Upstream noise carries into the pool.** Only anger was audited; a mislabelled `joy`/`disgust` row
-  stays mislabelled here. The upstream annotation had substantial, not perfect, agreement.
+  stays mislabelled here. The upstream annotation had substantial, not perfect, agreement, and the
+  audit above found several pool rows that read as neither anger nor contempt.
 * **No neutral class**, and no intensity scores: an `intensity` question was written and measured, did
-  not discriminate (1.1-1.8 on all 16 probes), so `label_anger.py` never asks it - it stays in
-  `ekman_questions.py` as a documented dead end rather than shipping as noise.
+  not discriminate (1.1-1.8 on all 16 probes), so it is not asked - it stays in `ekman_questions.py`
+  as a documented dead end rather than shipping as noise.
 * Tweets are raw: all-caps, code-mixed Indonesian/Javanese/Malay, slang, emoji, insults and slurs.
   Only whitespace was normalised.
 

anger_split/train.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:27ed25299313515089cd5387b46d30056318f23eb933b10aaee918eea58b4369
-size 94917
+oid sha256:c9f02c730f754e47cb6739fe3ec0c20d3030419889cd5a516f3fdd533ce0014a
+size 111372

anger_split_balanced/test.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:bcd28c9b4a484963d8623cfe358cb0247828793d008893b1a3c86f60be4c5b6c
-size 14014
+oid sha256:cca71de41a715882e972e521636141b6aa5bd04cc4ee54ae5a75867a8e5af468
+size 17019

anger_split_balanced/train.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fb7eb451bb1cccd7097c1f0ff822727596910e4528bf9c64b24437d35c389bcb
-size 44193
+oid sha256:50b4c2db23658d995bebef7ef2dae61ec7ff583e3b33f0ab4b424aa795458da4
+size 72400

anger_split_balanced/valid.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:883caa4d5e2835c5e78020c19e92a282aeff208447250b23716b4e06b3bba7fd
-size 13835
+oid sha256:a4f747736c49f620c511d1fd52a0dd8b5529855d2f973794a776cc2f74dbeaed
+size 18608

balanced/test.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8c36790fb96c6e693f14e3cfdfe9d7d43e5e622993a7e56a25b454caa6f0d0cc
-size 21879
+oid sha256:0148dab45546cd13803b29e6a958af7f994761bed8bda6eb59d7ad5cde20a187
+size 31079

balanced/train.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c2d37e0917004e983b4a4e1227b1c71dd118e3c86108e0e14312f2a2c37004a4
-size 99283
+oid sha256:aedc9130d546852f787f34ff361a36e8bdb8091e15f121d4f8e16f4245b252e8
+size 189405

balanced/valid.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:c0680cd4f375d7566858e175023b696d07694283388b8924d9d3481993427f0c
-size 24567
+oid sha256:36f7743f3345e310db45481ae10f664f601dece7f4e871c0b4c6136891b87382
+size 31486

build_info.json

@@ -1,69 +1,118 @@
 {
- "agree": 0.625,
- "ambig": 2,
+ "ambig": 54,
  "amp": "bf16",
+ "anger_balanced_per_class_split": "144 / 18 / 18",
+ "anger_split_balanced_split": "288 / 36 / 36",
+ "audit_agree_new": 4,
+ "audit_agree_prev": 18,
+ "audit_caveat": "one reader, unblinded to the hypothesis, and the pool is short, shouty, code-mixed Indonesian - rerun this on a larger sample before quoting it",
+ "audit_n": 37,
+ "audit_note": "A sample of 37 rows where the readings disagree was judged against the operational boundary by one reader working from the tweet text alone, before seeing any probability: 18/37 of those judgements land on the two-language reading, 4/37 on the label here, and 13/37 read as neither emotion. Of the 20 rows labelled `contempt` here and `anger` by the two-language reading, 1 was accepted as contempt. The reader is a machine reader, not a human annotator, and works on short code-mixed text - a signal, not gold labels.",
+ "audit_other": 13,
+ "balanced_b": 126,
+ "balanced_per_class_split": "144 / 18 / 18",
+ "balanced_split": "1008 / 126 / 126",
  "budget": 6144,
  "checkpoint": "convaiinnovations/laya (subfolder `multilingual/`)",
- "class_table": "| `anger` | 381 | 17.0% | split here: laya on the `anger` pool |\n| `contempt` | 94 | 4.2% | split here: laya on the `anger` pool |\n| `disgust` | 355 | 15.8% | EmoTweetID annotators, kept verbatim |\n| `enjoyment` | 429 | 19.1% | EmoTweetID annotators, kept verbatim |\n| `fear` | 395 | 17.6% | EmoTweetID annotators, kept verbatim |\n| `sadness` | 303 | 13.5% | EmoTweetID annotators, kept verbatim |\n| `surprise` | 286 | 12.8% | EmoTweetID annotators, kept verbatim |",
+ "choice_n": 421,
+ "class_table": "| `anger` | 289 | 12.9% | split here: laya on the `anger` pool |\n| `contempt` | 186 | 8.3% | split here: laya on the `anger` pool |\n| `disgust` | 355 | 15.8% | EmoTweetID annotators, kept verbatim |\n| `enjoyment` | 429 | 19.1% | EmoTweetID annotators, kept verbatim |\n| `fear` | 395 | 17.6% | EmoTweetID annotators, kept verbatim |\n| `sadness` | 303 | 13.5% | EmoTweetID annotators, kept verbatim |\n| `surprise` | 286 | 12.8% | EmoTweetID annotators, kept verbatim |",
+ "conf_low_new": 99,
+ "conf_low_prev": 48,
+ "conf_note": "99 of 475 rows land within 0.10 of a coin flip on the primary reading (max probability of the two options under 0.60), and the mean max probability across the pool is 0.754",
  "ctx_default": 1024,
  "datasets_v": "5.0.1",
  "dup_conflicts": 14,
- "duplicates_note": "29 rows share an identical `text` string with another row (more, if you count pairs whose English translation collides), and 14 of those repeated wordings repeat with *different* upstream labels - the annotators disagreed, and this dataset inherits that rather than re-judging it. Splitting is therefore **group-aware**: every member of a duplicate group lands in one split, so no wording appears in both train and test (`verify()` fails the build if one does), and the 8:1:1 fractions hold up to rounding on whole groups rather than to exact row counts.",
+ "duplicates_note": "29 rows share an identical `text` string with another row (more, if you count pairs whose English translation collides), and 14 of those repeated wordings repeat with *different* upstream labels - the annotators disagreed, and this dataset inherits that rather than re-judging it. Splitting is therefore **group-aware**: every member of a duplicate group lands in one split, so no wording appears in either side of a train/valid/test boundary (`verify()` fails the build if one does). The balanced configs sample whole groups as well, so a dropped row never orphans its duplicate.",
  "enc_name": "jhu-clsp/mmBERT-base",
+ "flip_to_anger": 12,
+ "flip_to_contempt": 104,
+ "flipped": 116,
  "head_max_len": 144,
- "laya_seconds": 1209.6,
+ "kept_n": 3,
+ "laya_seconds": 851.2,
  "laya_v": "0.3.4",
- "lowconf": 48,
+ "lexicon_contempt_new": 141,
+ "lexicon_contempt_prev": 57,
+ "lexicon_note": "373 of the 475 pool rows contain an explicit Indonesian anger word (`kesal`, `marah`, `murka`, `benci`, `jengkel`, `geram`, `tersinggung`, `muak`, `ngamuk`) - which is how EmoTweetID's annotators sampled, so the word is upstream evidence for anger. 141 of those 373 rows (38%) are labelled `contempt` here.",
+ "lexicon_rows": 373,
+ "lowconf": 391,
+ "lowconf_laya": 391,
  "margin": 0.1,
  "max_len": 256,
+ "mean_p_anger_prompt": 0.589,
+ "mean_p_anger_swapped": 0.726,
  "model_type": "modernbert",
- "n_anger_kept": 381,
+ "n_anger_balanced": 360,
+ "n_anger_balanced_s": "360",
+ "n_anger_kept": 289,
  "n_anger_pool": "475",
- "n_balanced": 658,
- "n_contempt": 94,
+ "n_anger_pool_rows": 475,
+ "n_balanced": 1260,
+ "n_balanced_s": "1,260",
+ "n_contempt": 186,
+ "n_full_pool": 2243,
  "n_manual": "1,768",
  "n_pool": "2,243",
- "naive_rows": 4750,
- "offtopic": 43,
+ "naive_rows": 1900,
+ "noul_n": 33,
+ "offtopic": 18,
+ "order_flip": 25.1,
+ "order_note": "Listing contempt first moved the argmax on 25.1% of the pool (mean |delta p(anger)| 0.191; mean P(anger) 0.589 as prompted vs 0.726 with the options swapped), so the prompt's option order is worth roughly a third of the contempt shift",
+ "order_shift": 0.191,
+ "orderavg_n": 18,
  "params": "321.9M",
  "params_enc": "306.9M",
  "params_heads": "15.0M",
- "per_class_anger_balanced": 94,
- "per_class_balanced": 94,
- "probe_acc": "13/16 (0.812)",
- "reagree_note": "a replication of the entire anger run at a 1024-token cap agreed on **474/475** final labels; the 1 flip sits right on the decision line - row 839 (p(anger) 0.434 / p(contempt) 0.566, en margin -0.132 vs id margin +0.104) - which is where a human annotator would have hesitated too",
+ "per_class_anger_balanced": 180,
+ "per_class_balanced": 180,
+ "prev_anger": 381,
+ "prev_contempt": 94,
+ "prev_note": "it labelled 381 anger / 94 contempt; the labels here differ on 116 of the 475 rows, 104 of them anger -> contempt",
+ "prev_share_contempt": 19.8,
+ "probe_author": "13/16 (0.812)",
+ "probe_en": "14/16 (0.875)",
+ "probe_en_idq": "14/16 (0.875)",
+ "probe_en_q": "English items with the Indonesian question: 14/16 (0.875)",
+ "probe_gap": "The gap is 3 items out of 16: the same sentences are called correctly 14 times in English and 11 times in Indonesian",
+ "probe_id": "11/16 (0.688)",
+ "probe_id_idq": "12/16 (0.750)",
+ "probe_id_swapped": "11/16 (0.688)",
+ "probe_lang_q": "with the question in Indonesian instead of English, the gap closes only 11 -> 12 items",
+ "probe_mean_p": "Mean P(anger) on the anger probes 0.68 in Indonesian vs 0.80 in English; on the contempt probes 0.31 vs 0.20",
+ "probe_order": "On the contempt items the mean P(anger) is 0.31 with anger listed first and 0.48 with contempt listed first - the order effect seen on the corpus",
+ "reconfirm_note": "every stage (id_core, id_core_swap, id_diag, id_veto) matched row for row and reproduced **475/475 labels**, down to a byte-identical `anger_ekman_rows.csv`, the largest probability difference anywhere being 0.000000 (856.6 s of model time against 851.2 s for the shipped run)",
  "repo": "mahalisyarifuddin/emotweetid-ekman7",
- "scored_rows": 1853,
- "share_contempt": 19.8,
- "sources_str": "`ekman_choice_pooled` 297, `ekman_choice_en` 122, `ekman_choice_id` 54, `ekman_noul_tiebreak` 2",
- "split_table": "| `balanced` | train | 527 | anger 75 / contempt 76 / disgust 75 / enjoyment 75 / fear 75 / sadness 75 / surprise 76 |\n| `balanced` | valid | 68 | anger 10 / contempt 9 / disgust 10 / enjoyment 10 / fear 10 / sadness 10 / surprise 9 |\n| `balanced` | test | 63 | anger 9 / contempt 9 / disgust 9 / enjoyment 9 / fear 9 / sadness 9 / surprise 9 |\n| `full` | train | 1794 | anger 305 / contempt 75 / disgust 283 / enjoyment 343 / fear 316 / sadness 243 / surprise 229 |\n| `full` | valid | 226 | anger 38 / contempt 10 / disgust 36 / enjoyment 43 / fear 40 / sadness 30 / surprise 29 |\n| `full` | test | 223 | anger 38 / contempt 9 / disgust 36 / enjoyment 43 / fear 39 / sadness 30 / surprise 28 |\n| `anger_split` | train | 380 | anger 305 / contempt 75 |\n| `anger_split` | valid | 48 | anger 38 / contempt 10 |\n| `anger_split` | test | 47 | anger 38 / contempt 9 |\n| `anger_split_balanced` | train | 150 | anger 75 / contempt 75 |\n| `anger_split_balanced` | valid | 20 | anger 10 / contempt 10 |\n| `anger_split_balanced` | test | 18 | anger 9 / contempt 9 |",
+ "repro_note": "the `id_core` stage matches the earlier two-language run's `out_prev/cache_id_core.json` (shipped here) to the last digit - 471/471 unique texts on the same side of the decision line, mean |delta p(anger)| 0.0000, max 0.0000",
+ "scored_rows": 1533,
+ "share_contempt": 39.2,
+ "sources_str": "`ekman_choice_id` 421, `ekman_noul_tiebreak` 33, `ekman_choice_order_avg` 18, `kept_original_label` 3",
+ "split_exact_note": "balanced 1008 / 126 / 126 of 1,260 (b=126), full 1 split of 2,243, anger_split 1 split of 475, anger_split_balanced 288 / 36 / 36 of 360 (b=36)",
+ "split_table": "| `balanced` | train | 1,008 | anger 144 / contempt 144 / disgust 144 / enjoyment 144 / fear 144 / sadness 144 / surprise 144 |\n| `balanced` | valid | 126 | anger 18 / contempt 18 / disgust 18 / enjoyment 18 / fear 18 / sadness 18 / surprise 18 |\n| `balanced` | test | 126 | anger 18 / contempt 18 / disgust 18 / enjoyment 18 / fear 18 / sadness 18 / surprise 18 |\n| `full` | train | 2,243 | anger 289 / contempt 186 / disgust 355 / enjoyment 429 / fear 395 / sadness 303 / surprise 286 (the whole pool, one split) |\n| `anger_split` | train | 475 | anger 289 / contempt 186 (the whole pool, one split) |\n| `anger_split_balanced` | train | 288 | anger 144 / contempt 144 |\n| `anger_split_balanced` | valid | 36 | anger 18 / contempt 18 |\n| `anger_split_balanced` | test | 36 | anger 18 / contempt 18 |",
  "splits": {
   "anger_split": {
-   "test": 47,
-   "train": 380,
-   "valid": 48
+   "train": 475
   },
   "anger_split_balanced": {
-   "test": 18,
-   "train": 150,
-   "valid": 20
+   "test": 36,
+   "train": 288,
+   "valid": 36
   },
   "balanced": {
-   "test": 63,
-   "train": 527,
-   "valid": 68
+   "test": 126,
+   "train": 1008,
+   "valid": 126
   },
   "full": {
-   "test": 223,
-   "train": 1794,
-   "valid": 226
+   "train": 2243
   }
  },
- "stageC": 214,
- "stages": "en core 709.7 s, id core 311.0 s, en diag 188.9 s",
+ "stageC": 54,
+ "stage_diag": 108,
+ "stages": "id core 299.8 s, id core swap 299.5 s, id diag 53.5 s, id veto 198.4 s",
  "tensors": 170,
  "torch_v": "2.14.0+cpu",
  "transformers_v": "5.17.0",
- "veto": "0.12 mean P(neither) over the probes, 1 of 16 above 0.5",
- "vocab": 256000
+ "veto": "18 of 475 rows above 0.5 (mean P(neither) 0.12) - Indonesian reading",
+ "vocab": 256000,
+ "whole_note": "`full` and `anger_split` are the complete pools in a single `train` split - nothing is held out, and users who want their own validation split take it from there. The two balanced configs are the ones that carry an exact 8:1:1 train/valid/test."
 }

ekman_questions_id.py

@@ -0,0 +1,53 @@
+"""Indonesian renderings of the two Ekman criteria, for the prompt-language control.
+
+The published run asks an English question about the tweet (=layas own prompt wording, Ekman's
+definitions in the language they were written in).  This module adds the same question in
+Indonesian, so `probe_quality_id.py` can hold the tweet fixed and vary the *question* language.
+Criteria are condensed from the same two Paul Ekman Group pages quoted in ekman_questions.py and
+kept inside laya's 48-token per-option cap.
+"""
+
+ANGER_CRITERION_ID = (
+    "anger: terhalang mencapai tujuan atau diperlakukan tidak adil; 'minggir dari jalanku'; dari "
+    "sekadar tidak puas sampai ancaman; ingin halangan atau ketidakadilan itu dihilangkan, "
+    "diarahkan pada perbuatannya bukan pada orangnya"
+)
+CONTEMPT_CRITERION_ID = (
+    "contempt: tidak suka sekaligus merasa lebih unggul secara moral - 'aku lebih baik darimu dan "
+    "kau lebih rendah'; meremehkan, memandang rendah, menganggap lawan tak pantas diladeni"
+)
+
+EKMAN_QUESTIONS_ID = {
+    "ekman": {
+        "type": "choice",
+        "instructions": (
+            "Dari dua emosi Ekman ini, mana yang diungkapkan penulis tweet? Anger muncul karena "
+            "terhalang atau diperlakukan tidak adil dan mendorong menghilangkan hal itu; contempt "
+            "muncul dari perasaan lebih unggul dari sasaran"
+        ),
+        "criteria": {"anger": ANGER_CRITERION_ID, "contempt": CONTEMPT_CRITERION_ID},
+    },
+    "superiority": {
+        "type": "noul",
+        "instructions": (
+            "Apakah penulis menyatakan dirinya lebih baik dari sasaran - meremehkan, mengejek atau "
+            "menganggap mereka rendah, bodoh atau tak pantas, dengan nada sok benar - bukan menuntut "
+            "sesuatu dari mereka?"
+        ),
+    },
+    "blocked_or_unfair": {
+        "type": "noul",
+        "instructions": (
+            "Apakah penulis terhalang mencapai tujuan atau diperlakukan tidak adil lalu melawan - "
+            "menuntut halangan atau kesalahan itu dihilangkan, dibayar atau dihukum, atau mengancam "
+            "akan melakukannya sendiri?"
+        ),
+    },
+    "not_anger_or_contempt": {
+        "type": "noul",
+        "instructions": (
+            "Apakah tweet ini BUKAN penulis mengungkapkan anger atau contempt-nya sendiri - misalnya "
+            "netral, positif, sedih, takut atau jijik, atau hanya melaporkan bahwa orang lain marah?"
+        ),
+    },
+}

full/train.parquet

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:8bd112af69964efe3f360b47f9f6ed47f1cb01317e1cd618ec262120270fa170
-size 317649
+oid sha256:c0939073c33d5ad3fcbb827b44925b9f97273fff70767b6c94ea316d77398707
+size 391033

label_anger_id.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python
+"""Split EmoTweetID's `anger` pool into `anger` vs `contempt` with laya - **Indonesian only**.
+
+Difference from `label_anger.py`: the English translation (`tweet_en`) is never shown to the model.
+The published run read every tweet twice, once in Indonesian and once in EmoTweetID's machine
+translation, and pooled the two; the translation mistranslates the slang and code-mixing these
+tweets are made of (`GUA MURKA` -> "THE CAVE IS ANGER"), so the English reading is what defined
+122 of the 475 shipped labels.  Here the decision is made from `text` alone.
+
+Stages (all on Indonesian text; the question wording stays laya's own English prompt, i.e. the
+criteria are Ekman's, quoted in the language they were written in):
+
+  id_core       `ekman` choice on all 475 rows.  Same stage name, questions and texts as the
+                published `out/cache_id_core.json`, so this stage must reproduce that cache
+                *exactly* - the run asserts it and the card quotes the agreement.  This is the
+                primary reading.
+  id_core_swap  the same choice with the two criteria in the opposite order.  Measured on the
+                probe set, the option listed second is favoured (mean P(anger) on contempt probes
+                0.31 with anger first vs 0.48 with contempt first), so the swapped pass records how
+                much of the contempt shift is prompt-order artifact.  `p_anger_swapped` ships on
+                every row; the average of the two orders is the debiased reading.
+  id_diag       Ekman's core-feature probes (superiority, blocked_or_unfair) - only on the rows
+                where the primary choice reading is not decisive (|margin| < 0.10).
+  id_veto       the `not_anger_or_contempt` diagnostic on all rows (card: do not filter on it).
+
+Output: out/anger_ekman_rows.csv, out/timings.json, out/cache_<stage>.json.
+"""
+import argparse
+import hashlib
+import json
+import os
+import re
+import sys
+import time
+
+import numpy as np
+import pandas as pd
+
+
+def norm(s):
+    return re.sub(r"\s+", " ", str(s)).strip()
+
+
+def cache_path(out_dir, stage):
+    return os.path.join(out_dir, "cache_%s.json" % stage)
+
+
+def load_cache(path):
+    if os.path.exists(path):
+        with open(path) as f:
+            return {k: v for k, v in json.load(f).items()}
+    return {}
+
+
+def save_cache(path, cache):
+    tmp = path + ".tmp"
+    with open(tmp, "w") as f:
+        json.dump(cache, f)
+    os.replace(tmp, path)
+
+
+def run_stage(agent, laya_opt, questions, texts, out_dir, stage, max_len, head_max_len, budget):
+    """Score `texts` with `questions`, one cache row per (text, stage) so a re-run resumes."""
+    cache = load_cache(cache_path(out_dir, stage))
+    todo_idx, todo_txt = [], []
+    for t in texts:
+        key = hashlib.sha1(("%s|%s" % (stage, t)).encode()).hexdigest()[:16]
+        if key not in cache:
+            todo_idx.append(key)
+            todo_txt.append(t)
+    print("[stage %s] %d rows to score, %d already cached" % (
+        stage, len(todo_txt), len(texts) - len(todo_txt)), flush=True)
+    t0 = time.time()
+    if todo_txt:
+        res, stats = laya_opt.score_texts(agent, questions, todo_txt, max_len=max_len,
+                                          head_max_len=head_max_len, token_budget=budget,
+                                          log=lambda *a: None)
+        for k, r in zip(todo_idx, res):
+            cache[k] = r
+        save_cache(cache_path(out_dir, stage), cache)
+        print("[stage %s] %s" % (stage, json.dumps(stats)), flush=True)
+    else:
+        stats = {"seconds": 0.0}
+    out = []
+    for t in texts:
+        key = hashlib.sha1(("%s|%s" % (stage, t)).encode()).hexdigest()[:16]
+        if key not in cache:
+            raise RuntimeError("cache miss for %s after stage %s" % (key, stage))
+        out.append(cache[key])
+    return out, stats
+
+
+def combine_id(probs, swap=None, sup=None, blk=None, choice_margin=0.10, noul_margin=0.05):
+    """(label, label_source, margin, p_anger, p_contempt).
+
+    Rules, in order - the single-reading version of `ekman_questions.combine`:
+
+      1. the Indonesian choice reading is decisive (|p(anger) - p(contempt)| >= 0.10) -> its argmax
+         (`ekman_choice_id`).
+      2. not decisive -> Ekman's core-feature probes break the tie: superiority => contempt,
+         blocked-or-unfair => anger (`ekman_noul_tiebreak`).
+      3. not decisive and probes agree too -> the *order-averaged* reading decides if it has a
+         side to pick (`ekman_choice_order_avg`).
+      4. still nothing -> keep the upstream EmoTweetID label `anger`: this dataset only ever splits
+         an existing anger pool, it does not re-litigate it (`kept_original_label`).
+    """
+    p_a, p_c = probs["anger"], probs["contempt"]
+    m = p_a - p_c
+    src = "ekman_choice_id"
+    if abs(m) < choice_margin:
+        m = m
+        if sup is not None and blk is not None and abs(sup - blk) >= noul_margin:
+            lab = "contempt" if sup > blk else "anger"
+            return lab, "ekman_noul_tiebreak", m, p_a, p_c
+        if swap is not None:
+            ma = ((p_a + swap["anger"]) - (p_c + swap["contempt"])) / 2.0
+            if abs(ma) >= choice_margin:
+                return ("anger" if ma >= 0 else "contempt"), "ekman_choice_order_avg", m, p_a, p_c
+        return "anger", "kept_original_label", m, p_a, p_c
+    return ("anger" if p_a >= p_c else "contempt"), src, m, p_a, p_c
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--max-len", type=int, default=256)
+    ap.add_argument("--head-max-len", type=int, default=144)
+    ap.add_argument("--token-budget", type=int, default=6144)
+    ap.add_argument("--margin", type=float, default=0.10)
+    ap.add_argument("--out", default="build/out")
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--no-swap", action="store_true", help="skip the option-order control pass")
+    ap.add_argument("--no-veto", action="store_true", help="skip the not_anger_or_contempt diagnostic")
+    args = ap.parse_args()
+
+    os.makedirs(args.out, exist_ok=True)
+    sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+    import laya_opt
+    from ekman_questions import CHOICE_MARGIN, EKMAN_QUESTIONS, assert_option_budget
+
+    t_load = time.time()
+    agent = laya_opt.load_agent()
+    print("[laya] agent ready in %.1fs (%d params)" % (
+        time.time() - t_load, sum(p.numel() for p in agent.model.parameters())), flush=True)
+    assert_option_budget(agent.tok)
+    print("[laya] option budget ok: every criterion fits laya's 48-token cap", flush=True)
+
+    # ---- data: identical input to the published run, so the Indonesian stage is comparable -------
+    f1 = pd.read_csv("data/file1.csv", index_col=0)
+    f2 = pd.read_csv("data/file2.csv", index_col=0)
+    assert len(f1) == len(f2) and (f1.index == f2.index).all(), "the two EmoTweetID files must align"
+    df = f1.join(f2)
+    df = df[df["label"] == "anger"].copy()
+    df["row_src"] = df.index
+    df["text_en"] = df["tweet_en"].map(norm)
+    df["text_id"] = df["tweet"].map(norm)
+    df = df[df["text_en"].str.len() > 0]
+    if args.limit:
+        df = df.iloc[:args.limit]
+    n = len(df)
+    print("[data] %d rows labelled anger (of %d annotated tweets)" % (n, len(f1)), flush=True)
+
+    id_texts = df["text_id"].tolist()
+    timings, stage_rows = {}, {}
+
+    # ---- stage 1: the split itself, Indonesian, laya's own criteria order ------------------------
+    qC = {"ekman": EKMAN_QUESTIONS["ekman"]}
+    ansC, s = run_stage(agent, laya_opt, qC, id_texts, args.out, "id_core", args.max_len,
+                        args.head_max_len, args.token_budget)
+    timings["id_core"] = s["seconds"]; stage_rows["id_core"] = s.get("rows", 0)
+
+    # ---- stage 1b: option-order control (contempt listed first) ---------------------------------
+    ansS = [None] * n
+    if not args.no_swap:
+        qS = {"ekman": {"type": "choice",
+                        "instructions": EKMAN_QUESTIONS["ekman"]["instructions"],
+                        "criteria": {"contempt": EKMAN_QUESTIONS["ekman"]["criteria"]["contempt"],
+                                     "anger": EKMAN_QUESTIONS["ekman"]["criteria"]["anger"]}}}
+        ansS, s = run_stage(agent, laya_opt, qS, id_texts, args.out, "id_core_swap", args.max_len,
+                            args.head_max_len, args.token_budget)
+        timings["id_core_swap"] = s["seconds"]; stage_rows["id_core_swap"] = s.get("rows", 0)
+
+    # ---- stage 2: core-feature probes, only where the choice reading could not settle it ---------
+    ambiguous = [i for i in range(n)
+                 if abs(ansC[i]["ekman"]["probabilities"]["anger"]
+                        - ansC[i]["ekman"]["probabilities"]["contempt"]) < args.margin]
+    print("[stage id_diag] %d/%d rows not decided by the Indonesian choice reading" % (
+        len(ambiguous), n), flush=True)
+    ansD = [dict() for _ in range(n)]
+    if ambiguous:
+        qD = {k: EKMAN_QUESTIONS[k] for k in ("superiority", "blocked_or_unfair")}
+        sub = [id_texts[i] for i in ambiguous]
+        res, s = run_stage(agent, laya_opt, qD, sub, args.out, "id_diag", args.max_len,
+                           args.head_max_len, args.token_budget)
+        for i, r in zip(ambiguous, res):
+            ansD[i] = r
+        timings["id_diag"] = s["seconds"]; stage_rows["id_diag"] = s.get("rows", 0)
+
+    # ---- stage 3: the off-topic veto, as a diagnostic only ---------------------------------------
+    ansV = [None] * n
+    if not args.no_veto:
+        qV = {"not_anger_or_contempt": EKMAN_QUESTIONS["not_anger_or_contempt"]}
+        ansV, s = run_stage(agent, laya_opt, qV, id_texts, args.out, "id_veto", args.max_len,
+                            args.head_max_len, args.token_budget)
+        timings["id_veto"] = s["seconds"]; stage_rows["id_veto"] = s.get("rows", 0)
+
+    # ---- combine ---------------------------------------------------------------------------------
+    rows = []
+    for i in range(n):
+        probs = ansC[i]["ekman"]["probabilities"]
+        swap = ansS[i]["ekman"]["probabilities"] if ansS[i] else None
+        diag = ansD[i]
+        sup = diag.get("superiority", {}).get("noul")
+        blk = diag.get("blocked_or_unfair", {}).get("noul")
+        label, src, m, p_a, p_c = combine_id(probs, swap, sup, blk, args.margin)
+        rows.append({
+            "row_src": int(df["row_src"].iloc[i]),
+            "text": id_texts[i],
+            "text_en": df["text_en"].iloc[i],
+            "source_label": "anger",
+            "label": label,
+            "label_source": src,
+            "ekman_p_anger": round(p_a, 4),
+            "ekman_p_contempt": round(p_c, 4),
+            "ekman_confidence": round(ansC[i]["ekman"]["confidence"], 4),
+            "ekman_margin_id": round(m, 4),
+            "p_anger_id": round(probs["anger"], 4),
+            "p_anger_swapped": None if swap is None else round(swap["anger"], 4),
+            "en_id_agree": None,
+            "p_superiority": None if sup is None else round(sup, 4),
+            "p_blocked_or_unfair": None if blk is None else round(blk, 4),
+            "p_not_anger_or_contempt": None if ansV[i] is None else
+                                      round(ansV[i]["not_anger_or_contempt"]["noul"], 4),
+            "ambiguous": bool(abs(m) < CHOICE_MARGIN),
+        })
+    out = pd.DataFrame(rows)
+    out.to_csv(os.path.join(args.out, "anger_ekman_rows.csv"), index=False)
+
+    prev_path = os.path.join(args.out, "timings.json")
+    if os.path.exists(prev_path):
+        prev = json.load(open(prev_path))
+        for k, v in prev.get("stages", {}).items():
+            if timings.get(k, 0) in (0, 0.0) and v:
+                timings[k] = v
+        for k, v in prev.get("stage_rows", {}).items():
+            stage_rows.setdefault(k, v)
+    with open(os.path.join(args.out, "timings.json"), "w") as f:
+        json.dump({"rows": n, "ambiguous_rows": len(ambiguous),
+                   "total_laya_seconds": round(sum(timings.values()), 1), "stages": timings,
+                   "stage_rows": {k: v for k, v in stage_rows.items() if v},
+                   "max_len": args.max_len, "head_max_len": args.head_max_len,
+                   "token_budget": args.token_budget, "margin": args.margin,
+                   "language": "id-only"}, f, indent=2)
+
+    print("\n=== laya anger/contempt split (Indonesian only) ===", flush=True)
+    print(out["label"].value_counts().to_string())
+    print("\nlabel provenance:\n" + out["label_source"].value_counts().to_string())
+    print("\ncontempt share of the pool: %.1f%%" % (100.0 * (out["label"] == "contempt").mean()))
+    print("ambiguous (|margin|<%.2f): %d" % (args.margin, out["ambiguous"].sum()))
+    if out["p_anger_swapped"].notna().any():
+        print("mean P(anger): as prompted %.3f | swapped %.3f" % (
+            out["p_anger_id"].mean(), out["p_anger_swapped"].mean()))
+        flips = int(((out["p_anger_id"] >= 0.5) != (out["p_anger_swapped"] >= 0.5)).sum())
+        print("rows whose argmax flips with the option order: %d (%.1f%%)" % (flips, 100.0 * flips / n))
+    if out["p_not_anger_or_contempt"].notna().any():
+        print("p(not anger or contempt) > 0.5: %d" % (out["p_not_anger_or_contempt"] > 0.5).sum())
+    print("laya seconds: %s" % json.dumps(timings))
+
+
+if __name__ == "__main__":
+    main()

make_dataset.py

@@ -30,6 +30,8 @@ import pandas as pd
 from sklearn.model_selection import train_test_split
 
 from ekman_questions import EKMAN7, BINARY
+from split_exact import (FRACTIONS as SPLIT_FRACTIONS, apportion, assign_groups, ideal_targets,
+                         sample_groups_per_class)
 
 LABELS_EKMAN = EKMAN7
 LABELS_BINARY = BINARY
@@ -37,12 +39,20 @@ LABELS_BINARY = BINARY
 SOURCE_TO_EKMAN = {"joy": "enjoyment"}
 SPLITS = ("train", "valid", "test")
 CONFIGS = ("balanced", "full", "anger_split", "anger_split_balanced")
+# `full` and `anger_split` ship the whole pool as a single `train` split; the two balanced configs
+# are the ones that carry an exact 8b : 1b : 1b train/valid/test.
+WHOLE_CONFIGS = ("full", "anger_split")
+SPLIT_CONFIGS = ("balanced", "anger_split_balanced")
 SEED = 0                      # the split seed the card promises; every run reads it from here
 OUT_DIR = "out"               # label_anger.py --out
 DATA_CSV, DATA_CSV_EN = "data/file1.csv", "data/file2.csv"
-REPL_CSV = "out_b1024/anger_ekman_rows.csv"
-SHIPPED = """README.template.md label_anger.py make_dataset.py fetch_source_data.py publish.py
-               laya_opt.py ekman_questions.py zcsafe.py prepare_checkpoint.py probe_quality.py probes.py
+PREV_DIR = "out_prev"          # the previous revision's run artefacts (shipped for the comparison)
+PREV_CACHE = os.path.join(PREV_DIR, "cache_id_core.json")
+PREV_CSV = os.path.join(PREV_DIR, "anger_ekman_rows.csv")
+SHIPPED = """README.template.md label_anger.py label_anger_id.py make_dataset.py fetch_source_data.py
+               publish.py laya_opt.py ekman_questions.py ekman_questions_id.py zcsafe.py
+               prepare_checkpoint.py probe_quality.py probe_quality_id.py probes.py probes_id.py
+               split_exact.py test_split_exact.py
                bench_speedup.py bench_batch.py check_veto_and_speed.py sweep_config.py""".split()
 REQUIRED = ["text", "text_en", "label", "label_idx", "source_label", "label_origin"]
 
@@ -66,8 +76,8 @@ def load_pool(out_dir=OUT_DIR):
     assert len(lab) == lab["row_src"].nunique(), "anger labels are not row-unique"
     assert set(lab["label"]) <= set(BINARY), f"unexpected labels in anger run: {set(lab['label'])}"
     keep = ["label_source", "ambiguous", "ekman_p_anger", "ekman_p_contempt",
-            "ekman_confidence", "p_anger_en", "p_anger_id", "en_id_agree", "ekman_margin_en",
-            "ekman_margin_id", "p_superiority", "p_blocked_or_unfair", "p_not_anger_or_contempt"]
+            "ekman_confidence", "p_anger_id", "p_anger_swapped", "ekman_margin_id",
+            "p_superiority", "p_blocked_or_unfair", "p_not_anger_or_contempt"]
     m = df.merge(lab[["row_src", "label"] + keep].rename(columns={"label": "ek_label"}),
                  on="row_src", how="left")
     anger = m["source_label"].eq("anger")
@@ -120,16 +130,13 @@ def add_text_group(df):
     return df
 
 
-def stratified_811(df, seed):
-    """Stratified 80/10/10 that keeps duplicate groups whole - the part `train_test_split` cannot do.
-
-    `sklearn.model_selection.train_test_split` would give exact 8:1:1 fractions but splits *rows*,
-    so a wording that occurs twice can end up in train and test at once (it did: 4 groups leaked).
-    Instead each class's duplicate groups are shuffled with `seed`, then handed out greedily to the
-    split with the largest remaining row deficit against 0.8/0.1/0.1 of that class. Groups are the
-    unit, so no group is ever cut; a group whose members disagree on label (a shared translation of
-    two different tweets) follows its modal label. Fractions then hold up to rounding on whole groups
-    - `verify()` checks both the fractions and the no-leakage property on the written files.
+def stratified_811_greedy(df, seed):
+    """The splitter the *previous* revision shipped - kept so the card can compare against it.
+
+    Shuffles each class's duplicate groups with `seed`, then hands them out greedily one at a time to
+    the split with the largest remaining row deficit against 0.8/0.1/0.1.  Groups are the unit, so
+    nothing leaks, but a class whose last group overshoots cannot be corrected, which is why it lands
+    on 1794/226/223 rather than on whole-row 8:1:1.  `make_dataset.stratified_811` is the exact one.
     """
     rng = np.random.RandomState(seed)
     lab, grp = df["label"].to_numpy(), df["group"].to_numpy()
@@ -140,7 +147,7 @@ def stratified_811(df, seed):
     for c in sorted(df["label"].unique()):
         gs = [g for g in modal.index if modal[g] == c]
         rng.shuffle(gs)
-        gs.sort(key=lambda g: -sizes[g])                      # big groups first: they are the hard packing
+        gs.sort(key=lambda g: -sizes[g])
         target = np.array([0.8, 0.1, 0.1]) * sizes[gs].sum()
         cur = np.zeros(3)
         for g in gs:
@@ -149,24 +156,45 @@ def stratified_811(df, seed):
             cur[j] += sizes[g]
     out = df.copy()
     out["split"] = [assign[g] for g in grp]
+    return out
+
+
+def stratified_811(df, seed):
+    """Exact 8:1:1 by row count, still group-aware - see split_exact.py for the how and the why.
+
+    The row count of a config decides its column totals (`apportion`, i.e. largest remainder: 2,243
+    rows -> 1,795/224/224, 475 rows -> 380/48/47), and the per-class-per-split counts are the integer
+    solution closest to `n_class x 0.8 | 0.1 | 0.1` given those totals.  Groups are then placed by
+    need and repaired by moving whole groups, so no wording straddles two splits and the split sizes
+    come out exact rather than "to within a group".
+    """
+    sizes = df["label"].value_counts().to_dict()
+    split_sizes = apportion(len(df), SPLIT_FRACTIONS)
+    targets = ideal_targets(sizes, split_sizes)
+    out = assign_groups(df, targets, seed)
     for s in SPLITS:
         g = out.loc[out["split"] == s, "group"]
         for other in SPLITS:
             if other != s:
                 leak = int(g.isin(out.loc[out["split"] == other, "group"]).sum())
                 assert leak == 0, f"group leaked between {s} and {other}: {leak} rows"
+        assert int((out["split"] == s).sum()) == split_sizes[SPLITS.index(s)], "split size off target"
     return out
 
 
-def balanced_pool(df, labels):
-    """Down-sample to equal rows per class (the smallest class), seed 0."""
-    per = min(int((df["label"] == l).sum()) for l in labels)
-    rng = np.random.RandomState(SEED + 1)
-    take = []
-    for l in labels:
-        idx = df.index[df["label"] == l].to_list()
-        take += idx if len(idx) == per else list(np.array(idx)[rng.permutation(len(idx))[:per]])
-    return df.loc[sorted(take)].reset_index(drop=True), per
+def balanced_pool(df, labels, seed=SEED):
+    """Down-sample to `m` rows per class, whole groups, with `m` the largest multiple of ten that fits.
+
+    The ten-row block has to be the unit if the split is to be exactly 8b : 1b : 1b, so a balanced
+    config picks its per-class size accordingly - 186 eligible `contempt` rows become 180, i.e. 144
+    train / 18 valid / 18 test per class and 1,008 / 126 / 126 overall (b = 126).  Nothing else about
+    the sample changes: seed 0, whole duplicate groups, identical class counts.
+    """
+    counts = df["label"].value_counts()
+    m = min(int(counts[c]) for c in labels) // 10 * 10
+    assert m > 0, "no class reaches ten rows"
+    sub, dropped = sample_groups_per_class(df, m, seed, labels=labels)
+    return sub, m, dropped
 
 
 def features(labels):
@@ -182,13 +210,11 @@ def features(labels):
         "label_origin": Value("string"),
         "label_source": Value("string"),
         "ambiguous": Value("bool"),
-        "en_id_agree": Value("bool"),
         "ekman_p_anger": Value("float32"),
         "ekman_p_contempt": Value("float32"),
         "ekman_confidence": Value("float32"),
-        "p_anger_en": Value("float32"),
         "p_anger_id": Value("float32"),
-        "ekman_margin_en": Value("float32"),
+        "p_anger_swapped": Value("float32"),
         "ekman_margin_id": Value("float32"),
         "p_superiority": Value("float32"),
         "p_blocked_or_unfair": Value("float32"),
@@ -199,10 +225,9 @@ def features(labels):
 
 def to_frame(df, labels):
     """Column order like the schema; keep None for un-run evidence (NaN would round-trip badly)."""
-    want = REQUIRED + ["label_source", "ambiguous", "en_id_agree", "ekman_p_anger",
-                       "ekman_p_contempt", "ekman_confidence", "p_anger_en", "p_anger_id",
-                       "ekman_margin_en", "ekman_margin_id", "p_superiority",
-                       "p_blocked_or_unfair", "p_not_anger_or_contempt", "row_src"]
+    want = REQUIRED + ["label_source", "ambiguous", "ekman_p_anger", "ekman_p_contempt",
+                       "ekman_confidence", "p_anger_id", "p_anger_swapped", "ekman_margin_id",
+                       "p_superiority", "p_blocked_or_unfair", "p_not_anger_or_contempt", "row_src"]
     cols = {}
     for k in want:
         v = df[k] if k in df else pd.Series([None] * len(df))
@@ -217,11 +242,16 @@ def to_frame(df, labels):
 def write_parquet(df, labels, dist, config):
     from datasets import Dataset
     ds = Dataset.from_pandas(to_frame(df, labels), features=features(labels), preserve_index=False)
-    os.makedirs(os.path.join(dist, config), exist_ok=True)
-    for s in SPLITS:
+    out_dir = os.path.join(dist, config)
+    os.makedirs(out_dir, exist_ok=True)
+    present = [s for s in SPLITS if (df["split"] == s).any()]
+    for f in os.listdir(out_dir):                 # a config that stops being split must not keep files
+        if f.endswith(".parquet") and f[:-len(".parquet")] not in present:
+            os.remove(os.path.join(out_dir, f))
+    for s in present:
         sub = ds.select([i for i in range(len(ds)) if df["split"].iloc[i] == s])
-        sub.to_parquet(os.path.join(dist, config, f"{s}.parquet"))
-    return sorted(os.listdir(os.path.join(dist, config)))
+        sub.to_parquet(os.path.join(out_dir, f"{s}.parquet"))
+    return sorted(os.listdir(out_dir))
 
 
 def class_table(df, labels):
@@ -233,14 +263,6 @@ def class_table(df, labels):
         for c in labels if int(vc.get(c, 0)) > 0)
 
 
-def n_probe(veto_path):
-    """how many probes the veto file was computed over (it stores the count when available)"""
-    try:
-        return int(json.load(open(veto_path)).get("n_probes", 16))
-    except Exception:
-        return 16
-
-
 def checkpoint_facts(ckpt_dir="models/laya-ml/multilingual"):
     """Read the checkpoint's real size/config out of its safetensors header - no model load.
 
@@ -279,58 +301,213 @@ def checkpoint_facts(ckpt_dir="models/laya-ml/multilingual"):
     return out
 
 
-def build_info(df, tables, splits, per_class, out_dir, info_path):
+def build_info(df, tables, splits, per_class, out_dir, info_path, dropped=None):
     """Numbers for the data card, from the built frames only (no model load)."""
     from collections import Counter
     import datasets, laya, torch, transformers
-    ang = df[df["label_origin"] == "laya_anger_split"]
+    ang = df[df["label_origin"] == "laya_anger_split"].copy()
     src = Counter(ang["label_source"])
     timings = json.load(open(os.path.join(out_dir, "timings.json")))
-    veto_p = os.path.join(out_dir, "veto_check.json")
-    if os.path.exists(veto_p):                      # written by check_veto_and_speed.py over 16 probes
-        veto = json.load(open(veto_p))
-        vm, vf, ca = (veto["veto_mean_p_neither"], veto["veto_flagged"], veto["choice_acc"])
-        veto_str = f"{vm:.2f} mean P(neither) over the probes, {vf} of {n_probe(veto_p)} above 0.5"
-        probe_str = f"{ca * 16:.0f}/16 ({ca:.3f})"
-    else:
-        veto_str = probe_str = "not measured - run `python check_veto_and_speed.py`"
+    veto_str = "not run"
+    if "p_not_anger_or_contempt" in ang and ang["p_not_anger_or_contempt"].notna().any():
+        v = ang["p_not_anger_or_contempt"].dropna()
+        veto_str = (f"{int((v > 0.5).sum())} of {len(v)} rows above 0.5 (mean P(neither) {v.mean():.2f}) "
+                    f"- Indonesian reading")
     stage_rows = timings.get("stage_rows", {})
     n_states = sum(stage_rows.values()) or (4 * len(ang) + int(timings["ambiguous_rows"]) * 3)
 
-    # agreement with an independent replication of the anger run at a tighter token budget
-    repl_note = ("a replication of the anger run at a 1024-token cap is still running - the result "
-                 "lands in this card and in `runs/`")
-    if os.path.exists(REPL_CSV):
-        r = pd.read_csv(REPL_CSV)[["row_src", "label"]]
-        m = ang[["row_src", "label"]].merge(r, on="row_src", suffixes=("", "_repl"))
-        same = int((m["label"] == m["label_repl"]).sum())
-        if len(m) == len(ang) and same == len(m):
-            repl_note = (f"a replication of the entire anger run at a 1024-token cap - a different "
-                         f"batch packing, so a different padding pattern on every forward pass - gave "
-                         f"**{same}/{len(m)} identical final labels**")
-        elif len(m) == len(ang):
-            flips = m.loc[m["label"] != m["label_repl"], "row_src"].to_list()
-            det = []
-            for r in flips[:4]:
-                f0 = ang.loc[ang["row_src"] == r].iloc[0]
-                det.append(f"row {r}: p(contempt) {f0['ekman_p_contempt']:.3f} here vs "
-                           f"{1 - f0['ekman_p_anger']:.3f}" if False else
-                           f"row {r} (p(anger) {f0['ekman_p_anger']:.3f} / p(contempt) "
-                           f"{f0['ekman_p_contempt']:.3f}, en margin {f0['ekman_margin_en']:+.3f} vs "
-                           f"id margin {f0['ekman_margin_id']:+.3f})")
-            w, vb = ("s", "sit") if len(flips) > 1 else ("", "sits")
-            repl_note = (f"a replication of the entire anger run at a 1024-token cap agreed on "
-                         f"**{same}/{len(m)}** final labels; the {len(flips)} flip{w} {vb} right on the "
-                         f"decision line - {'; '.join(det)} - which is where a human annotator would "
-                         f"have hesitated too")
+    # agreement with the previous revision: `id_core` is the *same* stage, on the same texts, as the
+    # published out/cache_id_core.json (shipped here as out_prev/), so a re-run has to reproduce it
+    repro_note = "the shipped `out/cache_id_core.json` is from that run"
+    new_cache = os.path.join(out_dir, "cache_id_core.json")
+    if os.path.exists(PREV_CACHE) and os.path.exists(new_cache):
+        a, b = json.load(open(PREV_CACHE)), json.load(open(new_cache))
+        common = sorted(set(a) & set(b))
+        d = [abs(a[k]["ekman"]["probabilities"]["anger"] - b[k]["ekman"]["probabilities"]["anger"])
+             for k in common]
+        same = sum((a[k]["ekman"]["probabilities"]["anger"] >= 0.5)
+                   == (b[k]["ekman"]["probabilities"]["anger"] >= 0.5) for k in common)
+        repro_note = (f"the `id_core` stage matches the earlier two-language run's "
+                      f"`out_prev/cache_id_core.json` (shipped here) to the last digit - "
+                      f"{same}/{len(common)} unique texts on the same side of the decision line, "
+                      f"mean |delta p(anger)| {sum(d) / len(d):.4f}, max {max(d):.4f}")
+        if same != len(common):
+            n_moved = len(common) - same
+            repro_note += (f"; the {n_moved} row{'s' if n_moved > 1 else ''} that moved sit within "
+                           f"0.05 of p=0.5")
+
+    # the second run (reconfirm.py): stage-by-stage and row-by-row agreement with the shipped labels
+    reconfirm_note = "a second run has not been compared against this one"
+    rc = os.path.join(out_dir, "reconfirm.json")
+    if os.path.exists(rc):
+        r = json.load(open(rc))
+        st = r.get("stages", {})
+        lab = r.get("labels", {})
+        drift = [k for k, v in st.items() if v["max_abs_diff"] > 0 or v["only_in_a"] or v["only_in_b"]]
+        covers = ", ".join(sorted(st))
+        if lab and not drift and not lab["flips"]:
+            sec = (r.get("second_run") or {}).get("total_laya_seconds")
+            reconfirm_note = (f"every stage ({covers}) matched row for row and reproduced **"
+                              f"{lab['identical']}/{lab['rows']} labels**")
+            reconfirm_note += (", down to a byte-identical `anger_ekman_rows.csv`"
+                               if lab.get("identical_bytes") else "")
+            reconfirm_note += (f", the largest probability difference anywhere being "
+                               f"{lab['max_prob_abs_diff']:.6f}")
+            if sec:
+                reconfirm_note += (f" ({sec:,.1f} s of model time against {timings['total_laya_seconds']:,.1f} s"
+                                   f" for the shipped run)")
+        elif lab:
+            reconfirm_note = (f"the stages agreed on {lab['identical']}/{lab['rows']} labels, with "
+                              f"drift in {drift or 'no stage'} and flips "
+                              f"{lab['flips'] or 'none'} (largest probability difference "
+                              f"{lab['max_prob_abs_diff']:.6f})")
+        else:
+            reconfirm_note = f"the stages agree as follows: {st}"
+
+    # what changed against the previous revision's shipped labels (English-pooled decision)
+    prev_note, prev_stats = "not available", {}
+    if os.path.exists(PREV_CSV):
+        pv = pd.read_csv(PREV_CSV)[["row_src", "label", "ekman_confidence"]].rename(
+            columns={"label": "label_prev", "ekman_confidence": "conf_prev"})
+        ang = ang.merge(pv, on="row_src", how="left")
+        j = ang[["row_src", "label", "label_prev"]].dropna(subset=["label_prev"])
+        if len(j):
+            n_flip = int((j["label"] != j["label_prev"]).sum())
+            p_ang, p_con = int((j["label_prev"] == "anger").sum()), int((j["label_prev"] == "contempt").sum())
+            c2a = int(((j["label_prev"] == "contempt") & (j["label"] == "anger")).sum())
+            a2c = int(((j["label_prev"] == "anger") & (j["label"] == "contempt")).sum())
+            prev_stats = {"prev_anger": p_ang, "prev_contempt": p_con, "flipped": n_flip,
+                          "flip_to_anger": c2a, "flip_to_contempt": a2c,
+                          "prev_share_contempt": round(100.0 * p_con / len(j), 1)}
+            prev_note = (f"it labelled {p_ang} anger / {p_con} contempt; the labels here differ on "
+                         f"{n_flip} of the {len(j)} rows, {a2c} of them anger -> contempt")
+
+    # the corpus's own evidence: EmoTweetID sampled by emotion keyword, so a row that contains an
+    # explicit Indonesian anger word carries an upstream hint that it is anger and not contempt.
+    # How often does each revision overrule that hint?
+    LEXICON = ("kesal", "marah", "murka", "benci", "jengkel", "geram", "tersinggung", "muak", "ngamuk")
+    hint = ang["text"].str.lower().str.contains("|".join(LEXICON), regex=True)
+    lex_stats = {"lexicon_rows": int(hint.sum()), "lexicon_contempt_new": None,
+                 "lexicon_contempt_prev": None}
+    if "label_prev" in ang:
+        lex_stats["lexicon_contempt_new"] = int((ang.loc[hint, "label"] == "contempt").sum())
+        lex_stats["lexicon_contempt_prev"] = int((ang.loc[hint, "label_prev"] == "contempt").sum())
+        lex_stats["lexicon_note"] = (
+            f"{int(hint.sum())} of the {len(ang)} pool rows contain an explicit Indonesian anger word "
+            f"(`kesal`, `marah`, `murka`, `benci`, `jengkel`, `geram`, `tersinggung`, `muak`, `ngamuk`) "
+            f"- which is how EmoTweetID's annotators sampled, so the word is upstream evidence for "
+            f"anger. {int((ang.loc[hint, 'label'] == 'contempt').sum())} of those "
+            f"{int(hint.sum())} rows ({100.0 * (ang.loc[hint, 'label'] == 'contempt').mean():.0f}%) "
+            f"are labelled `contempt` here.")
+    else:
+        lex_stats["lexicon_note"] = (f"{int(hint.sum())} pool rows contain an explicit Indonesian anger "
+                                     f"word; the Indonesian-only reading calls "
+                                     f"{int((ang.loc[hint, 'label'] == 'contempt').sum())} of them contempt")
+
+    # the one-reader audit of the flips (audit_flips.py), shipped as out/audit_flips.csv
+    audit_stats = {}
+    ap = os.path.join(out_dir, "audit_flips.csv")
+    if os.path.exists(ap):
+        au = pd.read_csv(ap)
+        n = len(au)
+        a_new = int((au["verdict"] == au["label"]).sum())
+        a_prev = int((au["verdict"] == au["shipped_label"]).sum())
+        other = int((au["verdict"] == "other").sum())
+        moved = au[au["label"] != au["shipped_label"]]
+        moved_c = int((moved["label"] == "contempt").sum())
+        moved_c_ok = int(((moved["label"] == "contempt") & (moved["verdict"] == "contempt")).sum())
+        audit_stats = {
+            "audit_n": n, "audit_agree_new": a_new, "audit_agree_prev": a_prev, "audit_other": other,
+            "audit_note": (
+                f"A sample of {n} rows where the readings disagree was judged against the operational "
+                f"boundary by one reader working from the tweet text alone, before seeing any "
+                f"probability: {a_prev}/{n} of those judgements land on the two-language reading, "
+                f"{a_new}/{n} on the label here, and {other}/{n} read as neither emotion. Of the "
+                f"{moved_c} rows labelled `contempt` here and `anger` by the two-language reading, "
+                f"{moved_c_ok} was accepted as contempt. The reader is a machine reader, not a human "
+                f"annotator, and works on short code-mixed text - a signal, not gold labels."),
+            "audit_caveat": ("one reader, unblinded to the hypothesis, and the pool is short, shouty, "
+                             "code-mixed Indonesian - rerun this on a larger sample before quoting it"),
+        }
+
+    # how close to a coin flip each revision's reading ended, on the same scale (max P of the reading)
+    conf_stats = {"conf_low_new": int((np.maximum(ang["p_anger_id"], 1 - ang["p_anger_id"]) < 0.6).sum())}
+    if "conf_prev" in ang:
+        conf_stats["conf_low_prev"] = int((ang["conf_prev"] < 0.6).sum())
+        conf_stats["conf_note"] = (
+            f"{conf_stats['conf_low_new']} of {len(ang)} rows land within 0.10 of a coin flip on the "
+            f"primary reading (max probability of the two options under 0.60), and the mean max "
+            f"probability across the pool is "
+            f"{float(np.mean(np.maximum(ang['p_anger_id'], 1 - ang['p_anger_id']))):.3f}")
+    else:
+        conf_stats["conf_note"] = f"{conf_stats['conf_low_new']} rows land within 0.10 of a coin flip"
+    conf_stats["lowconf_laya"] = int((ang["ekman_confidence"] < 0.6).sum())
+
+    # the option-order control, on the rows this build labels
+    order_stats = {"order_flip": "n/a", "order_shift": "n/a",
+                   "order_note": "not measured - run label_anger_id.py without --no-swap"}
+    if "p_anger_swapped" in ang and ang["p_anger_swapped"].notna().any():
+        pa, psw = ang["p_anger_id"].to_numpy(), ang["p_anger_swapped"].to_numpy()
+        flip, shift = float(np.mean((pa >= 0.5) != (psw >= 0.5))), float(np.mean(np.abs(pa - psw)))
+        order_stats = {
+            "order_flip": round(100 * flip, 1),
+            "order_shift": round(shift, 3),
+            "mean_p_anger_prompt": round(float(np.mean(pa)), 3),
+            "mean_p_anger_swapped": round(float(np.mean(psw)), 3),
+            "order_note": (f"Listing contempt first moved the argmax on {100 * flip:.1f}% of the pool "
+                           f"(mean |delta p(anger)| {shift:.3f}; mean P(anger) {np.mean(pa):.3f} as "
+                           f"prompted vs {np.mean(psw):.3f} with the options swapped), so the "
+                           f"prompt's option order is worth roughly a third of the contempt shift"),
+        }
+
+    # fit-for-purpose probes, both languages (out/probe_quality_id.json, from probe_quality_id.py)
+    probe = {}
+    pq = os.path.join(out_dir, "probe_quality_id.json")
+    if os.path.exists(pq):
+        conds = json.load(open(pq))["conditions"]
+        tag = {c["condition"].strip()[0]: c for c in conds}
+        def fmt(c):
+            return f"{c['correct']}/{c['n']} ({c['accuracy']:.3f})"
+        probe = {k: fmt(tag[t]) for k, t in
+                 (("probe_author", "Z"), ("probe_en", "A"), ("probe_id", "B"),
+                  ("probe_id_idq", "C"), ("probe_en_idq", "D"), ("probe_id_swapped", "E")) if t in tag}
+        b, a, c_, d_, e = (tag.get(x) for x in "BACDE")
+        if a and b:
+            probe["probe_gap"] = (f"The gap is {a['correct'] - b['correct']} items out of 16: the same "
+                                  f"sentences are called correctly {a['correct']} times in English and "
+                                  f"{b['correct']} times in Indonesian")
+            probe["probe_mean_p"] = (
+                f"Mean P(anger) on the anger probes {b['per_class']['anger']['mean_p_anger']:.2f} in "
+                f"Indonesian vs {a['per_class']['anger']['mean_p_anger']:.2f} in English; on the "
+                f"contempt probes {b['per_class']['contempt']['mean_p_anger']:.2f} vs "
+                f"{a['per_class']['contempt']['mean_p_anger']:.2f}")
+        if b and c_:
+            probe["probe_lang_q"] = (f"with the question in Indonesian instead of English, the gap "
+                                     f"closes only {b['correct']} -> {c_['correct']} items")
+        if d_:
+            probe["probe_en_q"] = f"English items with the Indonesian question: {fmt(d_)}"
+        if b and e:
+            probe["probe_order"] = (
+                f"On the contempt items the mean P(anger) is {b['per_class']['contempt']['mean_p_anger']:.2f} "
+                f"with anger listed first and {e['per_class']['contempt']['mean_p_anger']:.2f} with "
+                f"contempt listed first - the order effect seen on the corpus")
     facts = checkpoint_facts()
     tbl = []
     for name in CONFIGS:
         d, labels = tables[name], (LABELS_BINARY if name.startswith("anger") else LABELS_EKMAN)
-        for s in SPLITS:
-            vc = d.loc[d["split"] == s, "label"].value_counts() if "split" in d else d["label"].value_counts()
+        present = [s for s in SPLITS if (d["split"] == s).any()]
+        for s in present:
+            vc = d.loc[d["split"] == s, "label"].value_counts()
             per = " / ".join(f"{c} {int(vc.get(c, 0))}" for c in labels if int(vc.get(c, 0)) > 0)
-            tbl.append(f"| `{name}` | {s} | {int((d['split'] == s).sum())} | {per} |")
+            note = " (the whole pool, one split)" if len(present) == 1 else ""
+            tbl.append(f"| `{name}` | {s} | {int((d['split'] == s).sum()):,} | {per}{note} |")
+    # one-line summary of every config's split sizes, for the card
+    split_note = ", ".join(
+        ("%s %s of %s (b=%d)" % (name, " / ".join(str(splits[name][x]) for x in SPLITS),
+                                 f"{sum(splits[name].values()):,}", sum(splits[name].values()) // 10))
+        if name in SPLIT_CONFIGS else
+        ("%s 1 split of %s" % (name, f"{sum(splits[name].values()):,}"))
+        for name in CONFIGS)
     dup = int(df.duplicated("text").sum())
     g = df.groupby("text")["source_label"].nunique()
     conflict = int((g > 1).sum())
@@ -345,38 +522,61 @@ def build_info(df, tables, splits, per_class, out_dir, info_path):
         "n_balanced": int(sum(splits["balanced"].values())),
         "per_class_balanced": per_class["balanced"],
         "per_class_anger_balanced": per_class["anger_split_balanced"],
+        "n_full_pool": int(sum(splits["full"].values())),
+        "n_anger_pool_rows": int(sum(splits["anger_split"].values())),
+        "balanced_split": " / ".join(str(splits["balanced"][x]) for x in SPLITS),
+        "anger_split_balanced_split": " / ".join(str(splits["anger_split_balanced"][x]) for x in SPLITS),
+        "balanced_per_class_split": " / ".join(
+            str(apportion(per_class["balanced"])[i]) for i in range(3)),
+        "anger_balanced_per_class_split": " / ".join(
+            str(apportion(per_class["anger_split_balanced"])[i]) for i in range(3)),
+        "n_anger_balanced": int(sum(splits["anger_split_balanced"].values())),
+        "balanced_b": int(sum(splits["balanced"].values()) // 10),
+        "n_balanced_s": f"{int(sum(splits['balanced'].values())):,}",
+        "n_anger_balanced_s": f"{int(sum(splits['anger_split_balanced'].values())):,}",
+        "whole_note": ("`full` and `anger_split` are the complete pools in a single `train` split - "
+                       "nothing is held out, and users who want their own validation split take it "
+                       "from there. The two balanced configs are the ones that carry an exact "
+                       "8:1:1 train/valid/test."),
         "class_table": class_table(df, LABELS_EKMAN),
         "split_table": "\n".join(tbl),
         "sources_str": ", ".join(f"`{k}` {v}" for k, v in src.most_common()),
-        "agree": round(float(ang["en_id_agree"].mean()), 3),
+        "noul_n": int(src.get("ekman_noul_tiebreak", 0)),
+        "choice_n": int(src.get("ekman_choice_id", 0)),
+        "orderavg_n": int(src.get("ekman_choice_order_avg", 0)),
+        "kept_n": int(src.get("kept_original_label", 0)),
         "ambig": int(ang["ambiguous"].sum()),
         "offtopic": int((ang["p_not_anger_or_contempt"] > 0.5).sum()),
         "lowconf": int((ang["ekman_confidence"] < 0.6).sum()),
         "stages": ", ".join(f"{k.replace('_', ' ')} {float(v):.1f} s"
                             for k, v in timings["stages"].items()),
         "veto": veto_str,
-        "probe_acc": probe_str,
         "laya_seconds": round(timings["total_laya_seconds"], 1),
         "max_len": timings["max_len"],
         "head_max_len": timings["head_max_len"],
         "budget": timings["token_budget"],
         "margin": timings["margin"],
         "scored_rows": n_states,
-        "naive_rows": 5 * 2 * len(ang),
-        "reagree_note": repl_note,
+        "naive_rows": 4 * len(ang),
+        "repro_note": repro_note,
+        "reconfirm_note": reconfirm_note,
+        "prev_note": prev_note,
+        "split_exact_note": split_note,
+        **prev_stats, **lex_stats, **conf_stats, **order_stats, **probe, **audit_stats,
         "splits": splits,
         "duplicates_note": (
             f"{dup} rows share an identical `text` string with another row (more, if you count pairs "
-            f"whose English translation collides), and {conflict} of those repeated wordings "
-            "repeat with *different* upstream labels - the annotators disagreed, and this dataset "
-            "inherits that rather than re-judging it. Splitting is therefore **group-aware**: every "
-            "member of a duplicate group lands in one split, so no wording appears in both train and "
-            "test (`verify()` fails the build if one does), and the 8:1:1 fractions hold up to rounding "
-            "on whole groups rather than to exact row counts."),
+            f"whose English translation collides), and {conflict} of those repeated wordings repeat "
+            "with *different* upstream labels - the annotators disagreed, and this dataset inherits "
+            "that rather than re-judging it. Splitting is therefore **group-aware**: every member of a "
+            "duplicate group lands in one split, so no wording appears in either side of a "
+            "train/valid/test boundary (`verify()` fails the build if one does). The balanced "
+            "configs sample whole groups as well, so a dropped row never orphans its duplicate."),
         "checkpoint": "convaiinnovations/laya (subfolder `multilingual/`)",
         "laya_v": laya.__version__, "datasets_v": datasets.__version__,
         "transformers_v": transformers.__version__, "torch_v": torch.__version__,
         "stageC": int(timings["ambiguous_rows"]),
+        "stage_diag": int(stage_rows.get("id_diag", 2 * int(timings["ambiguous_rows"]))),
         "dup_conflicts": conflict,
         **{k: (f"{v / 1e6:.1f}M" if k.startswith("params") and isinstance(v, int) else v)
            for k, v in facts.items()},
@@ -397,17 +597,18 @@ def render_readme(info, template="README.template.md"):
     return out
 
 
-def verify(dist):
+def verify(dist, out_dir=OUT_DIR):
     """Open the written parquet files and check labels, provenance, leakage and card numbers."""
     from datasets import Value, load_dataset
     info = json.load(open(os.path.join(dist, "build_info.json")))
     for name in CONFIGS:
         labels = LABELS_BINARY if name.startswith("anger") else LABELS_EKMAN
+        present = [s for s in SPLITS if os.path.exists(os.path.join(dist, name, f"{s}.parquet"))]
         ds = load_dataset("parquet", data_files={s: os.path.join(dist, name, f"{s}.parquet")
-                                                 for s in SPLITS})
-        assert list(ds["train"].features["label_idx"].names) == list(labels), f"{name}: label_idx names"
-        assert ds["train"].features["label"] == ds["train"].features["text"] == Value("string")
-        for s in SPLITS:
+                                                 for s in present})
+        assert list(ds[present[0]].features["label_idx"].names) == list(labels), f"{name}: label_idx"
+        assert ds[present[0]].features["label"] == ds[present[0]].features["text"] == Value("string")
+        for s in present:
             d = ds[s].to_pandas()
             assert len(d) > 0 and set(d["label"]) <= set(labels), f"{name}/{s}: bad labels"
             assert (d["text"].str.len() > 0).all() and (d["text_en"].str.len() > 0).all()
@@ -424,23 +625,47 @@ def verify(dist):
                 assert d["ekman_p_anger"].notna().all(), f"{name}: missing probabilities"
             else:
                 assert d.loc[~pool, "ekman_p_anger"].isna().all(), f"{name}: stray evidence values"
-            for other in SPLITS:
+            for other in present:
                 if other == s:
                     continue
                 o = ds[other].to_pandas()
                 assert not set(d["text"]) & set(o["text"]), f"{name}: text leakage {s}/{other}"
                 assert not set(d["text_en"]) & set(o["text_en"]), f"{name}: translated-text leakage"
-        counts = {s: len(ds[s]) for s in SPLITS}
+        counts = {s: len(ds[s]) for s in present}
         assert counts == info["splits"][name], f"{name}: card counts {info['splits'][name]} != {counts}"
         tot = sum(counts.values())
-        frac = [abs(counts[s] / tot - x) for s, x in zip(SPLITS, (0.8, 0.1, 0.1))]
-        assert max(frac) < 0.02, f"{name}: split fractions off 8:1:1 ({frac})"
-        print(f"[verify] {name}: {tot} rows {counts}")
+        if len(present) == 1:
+            assert present == ["train"], f"{name}: a single-split config must ship `train` only"
+            assert tot == info["n_full_pool" if name == "full" else "n_anger_pool_rows"], \
+                f"{name}: the whole pool must be in `train` ({tot} rows)"
+            print(f"[verify] {name}: {tot} rows, one split (the whole pool, nothing held out)")
+            continue
+        want = apportion(tot)                        # exact 8b : 1b : 1b
+        got = [counts[s] for s in SPLITS]
+        assert got == want, f"{name}: split sizes {got} != 8b:b:b targets {want}"
+        frac = [abs(counts[s] / tot - x) * 100 for s, x in zip(SPLITS, (0.8, 0.1, 0.1))]
+        assert tot % 10 == 0 and tot - 2 * (tot // 10) == 8 * (tot // 10), f"{name}: 10 | N"
+        print(f"[verify] {name}: {got} of {tot} rows, b={tot // 10}, off 8:1:1 by "
+              f"{frac[0]:.2f}/{frac[1]:.2f}/{frac[2]:.2f} points, {tot // len(labels)} per class")
+    # the balanced configs must be exact per class in every split, not just in the column totals
+    for name in SPLIT_CONFIGS:
+        labels = LABELS_BINARY if name.startswith("anger") else LABELS_EKMAN
+        per = info["per_class_" + ("anger_balanced" if name.startswith("anger") else "balanced")]
+        want = apportion(per)
+        for s in SPLITS:
+            d = pd.read_parquet(os.path.join(dist, name, f"{s}.parquet"))
+            vc = d["label"].value_counts()
+            assert set(vc.values) == {want[SPLITS.index(s)]}, f"{name}/{s}: per-class {vc.to_dict()}"
+        print(f"[verify] {name}: {per} rows per class, {want[0]} / {want[1]} / {want[2]} per class")
     # every shipped row still matches the upstream CSV, on top of the per-split checks
     src = pd.read_csv(DATA_CSV)
     src["text"] = src["tweet"].astype(str).map(norm)
     src["source_label"] = src["label"].astype(str).str.strip().str.lower()
-    pool = pd.concat([pd.read_parquet(os.path.join(dist, "full", f"{s}.parquet")) for s in SPLITS])
+    def _splits_on_disk(cfg):
+        return [x for x in SPLITS if os.path.exists(os.path.join(dist, cfg, f"{x}.parquet"))]
+
+    pool = pd.concat([pd.read_parquet(os.path.join(dist, "full", f"{s}.parquet"))
+                      for s in _splits_on_disk("full")])
     assert len(pool) == len(src) == 2243, f"full config covers {len(pool)} of {len(src)}"
     # join on row_src, not on text: identical wordings are not the same row (and can disagree)
     src["row_src"] = src.index
@@ -452,14 +677,14 @@ def verify(dist):
     assert (m["text"] == m["tweet"].astype(str).str.replace(r"\s+", " ", regex=True).str.strip()).all(), \
         "text is not the whitespace-normalised upstream tweet"
     ang = pd.concat([pd.read_parquet(os.path.join(dist, "anger_split", f"{s}.parquet"))
-                     for s in SPLITS])[["row_src", "label"]]
-    raw = pd.read_csv(os.path.join(OUT_DIR, "anger_ekman_rows.csv"))
+                     for s in _splits_on_disk("anger_split")])[["row_src", "label"]]
+    raw = pd.read_csv(os.path.join(out_dir, "anger_ekman_rows.csv"))
     raw = raw[raw["source_label"] == "anger"][["row_src", "label"]]
     j = ang.merge(raw, on="row_src", suffixes=("", "_csv"))
     assert len(j) == len(ang) == len(raw) and (j["label"] == j["label_csv"]).all(), \
         "anger_split does not equal the labeller's CSV"
     print(f"[verify] provenance: {len(pool)} rows vs upstream CSV, {len(ang)} anger rows vs "
-          f"{OUT_DIR}/anger_ekman_rows.csv -> ok")
+          f"{out_dir}/anger_ekman_rows.csv -> ok")
     # the card's YAML front matter is what huggingface.co parses into dataset configs: check that it
     # declares exactly the configs on disk, that its paths resolve, and that `label_idx` matches its
     # declared ClassLabel names
@@ -470,6 +695,10 @@ def verify(dist):
     assert list(cfgs) == list(CONFIGS), f"card configs {list(cfgs)} != {list(CONFIGS)}"
     assert [n for n, c in cfgs.items() if c.get("default")] == ["balanced"], "default config"
     for name, c in cfgs.items():
+        declared_splits = [d["split"] for d in c["data_files"]]
+        on_disk = _splits_on_disk(name)
+        assert sorted(declared_splits) == sorted(on_disk), \
+            f"{name}: card declares {declared_splits} but disk has {on_disk}"
         for d in c["data_files"]:
             p = os.path.join(dist, d["path"])
             assert os.path.exists(p), f"card points at a missing file: {d['path']}"
@@ -478,7 +707,8 @@ def verify(dist):
             declared = list(LABELS_BINARY if name.startswith("anger") else LABELS_EKMAN)
             if names:
                 assert json.loads(names.decode()).get("names") == declared, f"{d['path']}: ClassLabel names"
-        n_total = sum(len(pd.read_parquet(os.path.join(dist, name, f"{s}.parquet"))) for s in SPLITS)
+        n_total = sum(len(pd.read_parquet(os.path.join(dist, name, f"{s}.parquet")))
+                      for s in _splits_on_disk(name))
         assert n_total == sum(info["splits"][name].values()), f"{name}: card/parquet row mismatch"
     print(f"[verify] card YAML: {len(cfgs)} configs, default=balanced, every declared path exists "
           f"and carries the right ClassLabel names")
@@ -495,21 +725,27 @@ def main():
     df, _ = load_pool(a.out_dir)
     df = add_text_group(df)
     ang_pool = df[df["label_origin"] == "laya_anger_split"].reset_index(drop=True)
-    tables, splits, per_class = {}, {}, {}
-    for name, labels in (("full", LABELS_EKMAN), ("balanced", LABELS_EKMAN),
+    tables, splits, per_class, dropped = {}, {}, {}, {}
+    for name, labels in (("balanced", LABELS_EKMAN), ("full", LABELS_EKMAN),
                          ("anger_split", LABELS_BINARY), ("anger_split_balanced", LABELS_BINARY)):
         base = df if name in ("full", "balanced") else ang_pool
-        if "balanced" in name:
-            base, per_class[name] = balanced_pool(base, labels)
+        if name in SPLIT_CONFIGS:
+            base, per_class[name], dropped[name] = balanced_pool(base, labels)
+            assert sum(base["label"].value_counts().values) % 10 == 0, "a split config needs 10 | N"
+            sub = stratified_811(base, SEED)
+            expected = apportion(len(sub))
+            got = [int((sub["split"] == s).sum()) for s in SPLITS]
+            assert got == expected, f"{name}: {got} != 8b:b:b {expected}"
         else:
             per_class[name] = int(base["label"].value_counts().min())
-        sub = stratified_811(base, SEED)
+            sub = base.copy()
+            sub["split"] = SPLITS[0]              # the whole pool, one split, nothing held out
         tables[name] = sub
-        splits[name] = {s: int((sub["split"] == s).sum()) for s in SPLITS}
+        splits[name] = {s: int((sub["split"] == s).sum()) for s in SPLITS if (sub["split"] == s).any()}
         print(f"[build] {name}: {write_parquet(sub, labels, a.dist, name)} "
               f"({splits[name]}, per-class>={per_class[name]})")
     info = build_info(df, tables, splits, per_class, a.out_dir,
-                      os.path.join(a.dist, "build_info.json"))
+                      os.path.join(a.dist, "build_info.json"), dropped=dropped)
     info["repo"] = a.repo
     with open(os.path.join(a.dist, "README.md"), "w") as f:
         f.write(render_readme(info))
@@ -527,16 +763,34 @@ def main():
             shutil.copy(os.path.join("runs", f), os.path.join(a.dist, "runs", f))
     os.makedirs(os.path.join(a.dist, "out"), exist_ok=True)
     for f in ("veto_check.json", "speedup.json", "timings.json", "anger_ekman_rows.csv",
-              "cache_en_core.json", "cache_id_core.json", "cache_en_diag.json"):
+              "probe_quality_id.json", "audit_flips.csv", "audit_summary.json",
+              "reconfirm.json",
+              "cache_id_core.json", "cache_id_core_swap.json",
+              "cache_id_diag.json", "cache_id_veto.json"):
         p = os.path.join(a.out_dir, f)
         if os.path.exists(p):
             shutil.copy(p, os.path.join(a.dist, "out", f))
+    # the previous revision's run artefacts, so the new-vs-old comparison in the card is reproducible
+    if os.path.isdir(PREV_DIR) and os.path.abspath(PREV_DIR) != os.path.abspath(a.out_dir):
+        prev_out = os.path.join(a.dist, "out_prev")
+        os.makedirs(prev_out, exist_ok=True)
+        for f in sorted(os.listdir(PREV_DIR)):
+            src = os.path.join(PREV_DIR, f)
+            if os.path.isfile(src):
+                shutil.copy(src, os.path.join(prev_out, f))
+        print("[write] out_prev/ = the previous revision's caches", sorted(os.listdir(prev_out)))
     with open(os.path.join(a.dist, "build_info.json"), "w") as f:   # now incl. repo
         json.dump(info, f, indent=1, sort_keys=True)
     print("[write] README.md,", json.dumps({k: info[k] for k in
                                             ("n_pool", "n_anger_pool", "n_contempt", "n_anger_kept",
-                                             "share_contempt", "n_balanced", "agree", "laya_seconds")}))
-    verify(a.dist)
+                                             "share_contempt", "n_balanced", "laya_seconds")}))
+    # nothing that is not part of the dataset may reach the published tree (working notes and the
+    # build scratch dir are the two that have been tempting)
+    forbidden = [f for f in os.listdir(a.dist)
+                 if f.upper().startswith(("REVISION_NOTES", "NOTES", "TODO", "CHANGELOG"))
+                 or f in ("build", "models", "data", "dist")]
+    assert not forbidden, f"refusing to publish: {forbidden}"
+    verify(a.dist, a.out_dir)
 
 
 if __name__ == "__main__":

out/audit_flips.csv

@@ -0,0 +1,38 @@
+row_src,shipped_label,verdict,note,text,label,p_anger_id
+1275,anger,anger,"rude order-taking story, 'bodo amat / bngsaat' = annoyance; no superiority","Bang, Martabak 1 ya Yang manis apa Yang telor Gak usah Yang Yangan deh, kitakan ga ada hubungan apa2, risih tau di gituin ... Bodo amat... Bngsaatttttt",contempt,0.3956
+2086,anger,anger,"'koma benci' - hate, no target looked down on",Dani james dole ya koma benci,contempt,0.1501
+1570,anger,anger,'sedikit kesal' - mildly annoyed,Mungkin dia sedikit kesal krn tiap hari ada aja muka tzuyu yg lewat tl dia gara-gara gua wkwkwkwk,contempt,0.3457
+2048,anger,anger,'PALING BENCI' - shouted frustration,JANCOK!! PALING BENCI KALO MAU KETAWA HARUS NYUSAHIN OTAK DULU ASU !!!,contempt,0.4133
+1182,anger,anger,"authorities ignore reports, bureaucratic excuses - blocked/unfair","Kejadian lagi dan lagi, pihak harusnya cepat tanggap menanggapi laporan, bukan hanya memberikan surat kehilangan atau alasan birokrasi yang rumit, ya gak tau juga sih, cuman kalau sampe sekarang MASIH SAJA kejadian berarti belum di usut tuntas. Kecewa sekali.",contempt,0.3892
+1174,anger,anger,'malas nak marah' - resigned irritation,malas nak marah. umur dah meningkat ni aku cepat penat,contempt,0.3432
+1585,anger,anger,'pen murka aja gua' - explicitly wants to be furious,Pen murka aja gua,contempt,0.3169
+1832,anger,other,"moral disgust at people who believe slander; disgust, not superiority","so point dia kat sini, perangai babi ke, muka comel ke, fake friends ke, toxic people ke, yang paling jijik sekarang orang yang senang percaya dengan fitnah & batu api ni, aiyoooo downgrade main facebook jela",contempt,0.4814
+192,anger,contempt,mocks his face then 'I hate Pete' - mockery looks down; the one true contempt here,Muka Pete wentz macam muka hantu* Saya benci Pete*,contempt,0.2709
+1294,anger,other,meta-argument about who may be offended,"Yg seharusnya tidak terlalu tersinggung kalau disebut azab, karna definisi azabnya udah ga jelas seperti ini. tidak sepesifik sebabnya dan tidak ada benang merahnya antara sebab dan akibat, yang tidak merasa berbuat kesalahan juga ikut tersinggung.",contempt,0.2523
+590,anger,anger,"political anger: 'wong cilik diperes', exploitation, 'dasar PDIP'","Ngaku2 temennya wong cilik buat meraup suara. Giliran udah berkuasa, wong cilik diperes abis abisan. Masih belum puas juga ngejarah aset bangsa Dasar PDIP",contempt,0.389
+55,anger,anger,"'muka nya murka, badmood' - anger words, describing wrath","muka nya murka,badmood melihat orang orang yang masuk neraka",contempt,0.1039
+1742,anger,anger,'[mrasa kesal]' - the annotators' own marker says annoyed,[mrasa kesal],contempt,0.4069
+645,anger,anger,self-directed hate at being mediocre,"jujur, ngerasa benci diri sendiri kalau jadi medioker gini. kemana ilangnya jiwa-jiwa ambis yg selalu berpedoman, ""coba aja dulu, ntar baru tau gimana hasilnya""?",contempt,0.3257
+2040,anger,anger,'tersinggung' - offended by a jab,Kesingung melawan sampe mati. Dibilang pentol korek sumbu pendek tersinggung.,contempt,0.4297
+1729,anger,anger,threat: 'be quiet or I will be furious',lebih baik diyam kalian yaaa atau saya murka,contempt,0.3932
+481,anger,anger,'benci bgt sama orang bwgitu' - hatred of a type of person; weak,wkwk w juga benci bgt jink sama orang bwgitu,contempt,0.4237
+1916,anger,anger,sarcastic 'thanks for annoying me at night',Thankyou bikin kesal dimalam hari.,contempt,0.3958
+1653,anger,anger,"'tersinggung' + 'level noob' - offended, insulted back",Kalo bagian itu mah standart Level noob Tersinggung nya cuma dibilang alay sama orang yang foto profilnya gituu Menyakitkan lohh Aslii,contempt,0.3041
+2117,anger,other,commentary on other people's anger and religious tolerance,"Marah dan Kesal pasti ada ustad Tengku begitu juga dgn perasaan Umat agama lain seperti Gereja / vihara di Tutup,dirobohkan dibongkar,Ibadah dibubarkan.. perasaan nya gimana sebagai orang Indonesia yang beragam..??",contempt,0.2623
+504,contempt,other,platitude about people coming into your life,"Orang hadir di hidupmu karena sebuah alasan. Mereka berimu bahagia dan kecewa. Ada yg sesaat, tapi ada yg selamanya,",anger,0.6215
+35,contempt,other,sombre reflection on blood feuds; sadness/fear,"Kita ini banyak yang pelupa, bahwa hal sensitif seperti ini, bisa merenggut nyawa, nyawa kita, nyawa orang yang kita cintai, bahkan nyawa orang yang kita benci. Lalu apa ujungnya? Darah dibalas darah?",anger,0.5919
+360,contempt,other,'I stopped hating exo' - positive,"Gegara film ini aku jadi gak benci exo .. lucu pas eunhyuk joget"" sama hyukjae pas masih trainer huhu pengen nonton lagi.. ada yang punya kah??",anger,0.5231
+2061,contempt,other,moralising about fair-weather friends,Yg namanya sahabat sejati itu Ada disaat senang maupun duka. Bukan saat senang doank nggaku2 Sahabat Pada saat susah Boro2 ngaku sahabat Besuk aja nggak! Nggak harus terang2 an ? Itu pengecut namanya Plonga plongo ketika sahabat nya Di serang & dipenjara,anger,0.5573
+2003,contempt,anger,"admonishment: arrogant group, 'benda Allah murka'","Lagi kau buka ruang untuk terima golongan macamtu, lagi diorg besau kepala. dah tentu tentu benda salah, benda Allah murka. Semua umat Islam tahu, yg bukan Islam pun tahu. Benda mcmni lagi byk negatif dari positif. Ada sbb setiap yg Allah tetapkan. Dan kau cuma hamba biasa. INGAT",contempt,0.5394
+624,contempt,other,'afraid of God's wrath' - fear,takut murka Allah,anger,0.506
+1301,contempt,contempt,"sarcastic 'it's normal to embarrass yourself, sis'","Udah biasa kalo malu-maluin, Kak!",contempt,0.5031
+1045,contempt,other,bitter envy at someone favoured by fate,Ya udahlah. Tinggal tunggu aja elu jadi terkenal dan kaya raya. Selamat aja deh buat elu yg selalu dibela sama takdir dan poor buat gua yg delalu di benci takdir,anger,0.551
+716,contempt,other,"'be happy over my misery' - resignation, sadness",Bahagialah kau di atas sengsara aku. Aku rela.,anger,0.8371
+1104,contempt,anger,"protest: Uighurs must be free, 'Allah murka'","Jadi jelaskan ! Untuk apa bersimpati..?!? Jika Allah Ta'Ala murka,silahkan klo ada sanggup menahan.. Muslim Uighur harus merdeka dan bebas dr Komunis Cina!! Agar mereka bisa beribadah dengan damai..",contempt,0.5436
+756,contempt,other,"warning that your shame will be exposed + 'ehehe' - mockery, but no superiority claim","Inget nder dosa sesama manusia Tuhan gk ikut campur hati"" yaa takutnya Tuhan murka aibmu dibuka depan umum juga ehehe",contempt,0.5388
+839,contempt,anger,political complaint about ordinary people suffering,Banyak untungnya puang buat mereka tp Rakyat ma tambah sengsara,anger,0.5519
+1487,contempt,contempt,"'don't be a hypocrite, I already guessed your mindset lol' - dismissive mockery","Halah mba, lo kalo ngeliat orang sange juga jijik jangan gitu lah, jgn munafik, gue tuh dah nebak bgt ini pola pikir lo asli KWOAWKSKSKSKSK",anger,0.9285
+1363,contempt,other,wry Hitler/Chaplin aside,Hitler juga tampangnya kaya Chaplin. Pinokio apalagi lucu tapi buat rakyat sengsara.,anger,0.62
+1406,contempt,other,insult + mockery about corona and God's wrath - mixed,"Goblok goblok, najis amit amit dah gw. Btw, kalo si rijik kena corona Gusti Allah murka sama siapa ? Sama Bani kadal al hoakki kan hehehe",anger,0.5541
+531,contempt,anger,political grievance against a party and its supporters,"Weii Melayu2 korang tak rasa malu ke? Dah terang sikap DAP yg mahu serba serbi utk kaum dia, kaum kita mrk pinggir. Korang masih nak bersetia dgn mereka? Pemimpin2 korang mcm Mat Sabu ni kaya lah nti, korang? Ke mmg korang dilahirkan utk jdi dungu?",contempt,0.5071
+807,contempt,anger,'paansi lu kontol ... najis ama jijik' - crude cursing,"Paansi lu kontol, gue mo ngmong najis ama jijik aja kudu bgt berkarya dlu apa",anger,0.749

out/audit_summary.json

@@ -0,0 +1,6 @@
+{
+ "n": 37,
+ "agree_new": 4,
+ "agree_prev": 18,
+ "other": 13
+}

out/cache_id_diag.json

@@ -0,0 +1 @@
+{"45dcaf19e9227576": {"superiority": {"type": "noul", "probabilities": {"false": 0.882466, "true": 0.117534}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.11753417346702585, "confidence": 0.4778, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.969741, "true": 0.030259}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.030258928746632163, "confidence": 0.8043, "action": {"act_probability": 1.0}}}, "43696aa53326f71a": {"superiority": {"type": "noul", "probabilities": {"false": 0.974201, "true": 0.025799}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.025799320690094083, "confidence": 0.8271, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.99811, "true": 0.00189}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.0018895899748282458, "confidence": 0.9802, "action": {"act_probability": 1.0}}}, "946e3c5ec411fd29": {"superiority": {"type": "noul", "probabilities": {"false": 0.924558, "true": 0.075442}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.07544200369536606, "confidence": 0.6141, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.990728, "true": 0.009272}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.009272206271937589, "confidence": 0.9241, "action": {"act_probability": 1.0}}}, "3f6a5fa6fc439067": {"superiority": {"type": "noul", "probabilities": {"false": 0.917323, "true": 0.082677}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.08267663421911636, "confidence": 0.5885, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.976818, "true": 0.023182}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.023182414267136145, "confidence": 0.841, "action": {"act_probability": 1.0}}}, "40cca08ee4f91541": {"superiority": {"type": "noul", "probabilities": {"false": 0.941173, "true": 0.058827}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.058826865288798096, "confidence": 0.6772, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.955391, "true": 0.044609}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.04460888421536396, "confidence": 0.737, "action": {"act_probability": 1.0}}}, "b9a14397862565c3": {"superiority": {"type": "noul", "probabilities": {"false": 0.864653, "true": 0.135347}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.13534656212548704, "confidence": 0.4281, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.996622, "true": 0.003378}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.0033778820416298615, "confidence": 0.9674, "action": {"act_probability": 1.0}}}, "a3c7746b05acd2ff": {"superiority": {"type": "noul", "probabilities": {"false": 0.969138, "true": 0.030862}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.03086188974225065, "confidence": 0.8013, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.997992, "true": 0.002008}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.002008454052871857, "confidence": 0.9791, "action": {"act_probability": 1.0}}}, "77e81d66f4677519": {"superiority": {"type": "noul", "probabilities": {"false": 0.950727, "true": 0.049273}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.04927264086274714, "confidence": 0.7167, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.99653, "true": 0.00347}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.0034698408555150708, "confidence": 0.9667, "action": {"act_probability": 1.0}}}, "de2cf241557dc13b": {"superiority": {"type": "noul", "probabilities": {"false": 0.974852, "true": 0.025148}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.025148423609456863, "confidence": 0.8306, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.989938, "true": 0.010062}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.01006210593966399, "confidence": 0.9188, "action": {"act_probability": 1.0}}}, "1f4a1d72c92b398f": {"superiority": {"type": "noul", "probabilities": {"false": 0.921066, "true": 0.078934}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.07893398009016743, "confidence": 0.6016, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.990507, "true": 0.009493}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.009492703907887612, "confidence": 0.9226, "action": {"act_probability": 1.0}}}, "b2bcbd27f59deb4e": {"superiority": {"type": "noul", "probabilities": {"false": 0.969913, "true": 0.030087}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.03008728889192485, "confidence": 0.8052, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.990079, "true": 0.009921}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.009920947494666547, "confidence": 0.9197, "action": {"act_probability": 1.0}}}, "6154bfaf6c7bd1a5": {"superiority": {"type": "noul", "probabilities": {"false": 0.97078, "true": 0.02922}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.02921954630093713, "confidence": 0.8095, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.995666, "true": 0.004334}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.004334428339631979, "confidence": 0.9597, "action": {"act_probability": 1.0}}}, "5314671c543c0307": {"superiority": {"type": "noul", "probabilities": {"false": 0.892032, "true": 0.107968}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.10796842413270419, "confidence": 0.5062, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.980359, "true": 0.019641}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.01964135777815654, "confidence": 0.8606, "action": {"act_probability": 1.0}}}, "21d9bd5abda45843": {"superiority": {"type": "noul", "probabilities": {"false": 0.95935, "true": 0.04065}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.04064958346072397, "confidence": 0.7547, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 1.0, "true": 0.0}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 3.9223886121125126e-07, "confidence": 1.0, "action": {"act_probability": 1.0}}}, "3d083400631ba904": {"superiority": {"type": "noul", "probabilities": {"false": 0.851247, "true": 0.148753}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.14875342852820878, "confidence": 0.3933, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.945498, "true": 0.054502}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.054501800912556936, "confidence": 0.6948, "action": {"act_probability": 1.0}}}, "3db1059a49d42fbe": {"superiority": {"type": "noul", "probabilities": {"false": 0.935774, "true": 0.064226}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.06422595789171685, "confidence": 0.656, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.983146, "true": 0.016854}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.01685407600134855, "confidence": 0.8766, "action": {"act_probability": 1.0}}}, "2fbaab4692dd5769": {"superiority": {"type": "noul", "probabilities": {"false": 0.947073, "true": 0.052927}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.052926850861160085, "confidence": 0.7013, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.997544, "true": 0.002456}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.0024563032768760403, "confidence": 0.9752, "action": {"act_probability": 1.0}}}, "6dea799cfa894312": {"superiority": {"type": "noul", "probabilities": {"false": 0.762112, "true": 0.237888}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.23788773964293844, "confidence": 0.2085, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.982511, "true": 0.017489}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.017488956106913468, "confidence": 0.8729, "action": {"act_probability": 1.0}}}, "d1bad4048f410f65": {"superiority": {"type": "noul", "probabilities": {"false": 0.695032, "true": 0.304968}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.3049684805667262, "confidence": 0.1127, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.689468, "true": 0.310532}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.31053228926900533, "confidence": 0.1062, "action": {"act_probability": 1.0}}}, "5101336759d79ccd": {"superiority": {"type": "noul", "probabilities": {"false": 0.881154, "true": 0.118846}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.11884591598573652, "confidence": 0.474, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.983136, "true": 0.016864}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.01686440894381564, "confidence": 0.8765, "action": {"act_probability": 1.0}}}, "333c89aa3b96d71b": {"superiority": {"type": "noul", "probabilities": {"false": 0.966017, "true": 0.033983}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.03398340502004642, "confidence": 0.786, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.991056, "true": 0.008944}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.008944366278194654, "confidence": 0.9263, "action": {"act_probability": 1.0}}}, "4569f7db11a3d207": {"superiority": {"type": "noul", "probabilities": {"false": 0.971169, "true": 0.028831}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.02883073438556354, "confidence": 0.8115, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.992986, "true": 0.007014}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.007013978645724294, "confidence": 0.9397, "action": {"act_probability": 1.0}}}, "5285229071c72ab4": {"superiority": {"type": "noul", "probabilities": {"false": 0.67435, "true": 0.32565}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.3256495688243485, "confidence": 0.0896, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.136139, "true": 0.863861}, "argmax_index": 1, "labels": ["false", "true"], "choice": "true", "score": null, "noul": 0.8638605736890058, "confidence": 0.426, "action": {"act_probability": 1.0}}}, "a8815cd199c4b62a": {"superiority": {"type": "noul", "probabilities": {"false": 0.928865, "true": 0.071135}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.07113506376490336, "confidence": 0.6299, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.99957, "true": 0.00043}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.0004295640145365117, "confidence": 0.9946, "action": {"act_probability": 1.0}}}, "ed2e495dd78e8657": {"superiority": {"type": "noul", "probabilities": {"false": 0.803842, "true": 0.196158}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.1961584445525012, "confidence": 0.2858, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.90375, "true": 0.09625}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.09624992851319317, "confidence": 0.543, "action": {"act_probability": 1.0}}}, "71b296d2166ef3d9": {"superiority": {"type": "noul", "probabilities": {"false": 0.898756, "true": 0.101244}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.10124369565654992, "confidence": 0.5271, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.974406, "true": 0.025594}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.025593870805343956, "confidence": 0.8282, "action": {"act_probability": 1.0}}}, "3cbb277d71d9b382": {"superiority": {"type": "noul", "probabilities": {"false": 0.947147, "true": 0.052853}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.05285251309929309, "confidence": 0.7016, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.984695, "true": 0.015305}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.015305451280542158, "confidence": 0.8858, "action": {"act_probability": 1.0}}}, "7318979b05938cf6": {"superiority": {"type": "noul", "probabilities": {"false": 0.947534, "true": 0.052466}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.05246646270176453, "confidence": 0.7032, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.991381, "true": 0.008619}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.008618683714224279, "confidence": 0.9285, "action": {"act_probability": 1.0}}}, "b2156f567567b5ca": {"superiority": {"type": "noul", "probabilities": {"false": 0.954846, "true": 0.045154}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.045154044879964196, "confidence": 0.7346, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.892383, "true": 0.107617}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.10761732259835706, "confidence": 0.5073, "action": {"act_probability": 1.0}}}, "061e8786dc9408af": {"superiority": {"type": "noul", "probabilities": {"false": 0.944489, "true": 0.055511}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.05551129826798251, "confidence": 0.6906, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.984625, "true": 0.015375}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.015374957306821506, "confidence": 0.8854, "action": {"act_probability": 1.0}}}, "0f47527f5094b5ca": {"superiority": {"type": "noul", "probabilities": {"false": 0.874674, "true": 0.125326}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.125325867620907, "confidence": 0.4555, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.938252, "true": 0.061748}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.061748103720198844, "confidence": 0.6657, "action": {"act_probability": 1.0}}}, "fc4e82974fb7ec6f": {"superiority": {"type": "noul", "probabilities": {"false": 0.523789, "true": 0.476211}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.4762105096193023, "confidence": 0.0016, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.314628, "true": 0.685372}, "argmax_index": 1, "labels": ["false", "true"], "choice": "true", "score": null, "noul": 0.6853718721687266, "confidence": 0.1016, "action": {"act_probability": 1.0}}}, "1ec9cc301575aab1": {"superiority": {"type": "noul", "probabilities": {"false": 0.898443, "true": 0.101557}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.10155742069452962, "confidence": 0.5261, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.964365, "true": 0.035635}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.03563518891360065, "confidence": 0.7781, "action": {"act_probability": 1.0}}}, "d0753b3a7d4def8b": {"superiority": {"type": "noul", "probabilities": {"false": 0.930919, "true": 0.069081}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.06908100749472326, "confidence": 0.6375, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.99353, "true": 0.00647}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.006469691667428737, "confidence": 0.9436, "action": {"act_probability": 1.0}}}, "91552e0f65b4175e": {"superiority": {"type": "noul", "probabilities": {"false": 0.674838, "true": 0.325162}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.3251615078854989, "confidence": 0.0901, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.14777, "true": 0.85223}, "argmax_index": 1, "labels": ["false", "true"], "choice": "true", "score": null, "noul": 0.8522299227440426, "confidence": 0.3958, "action": {"act_probability": 1.0}}}, "7f66740d7868e1f6": {"superiority": {"type": "noul", "probabilities": {"false": 0.940375, "true": 0.059625}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.05962540984677317, "confidence": 0.674, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.989976, "true": 0.010024}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.010024333290604887, "confidence": 0.919, "action": {"act_probability": 1.0}}}, "bf003ca89075b0cb": {"superiority": {"type": "noul", "probabilities": {"false": 0.842657, "true": 0.157343}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.15734335309573005, "confidence": 0.3721, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.990132, "true": 0.009868}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.009868319959011478, "confidence": 0.9201, "action": {"act_probability": 1.0}}}, "9b69d96f209a8eef": {"superiority": {"type": "noul", "probabilities": {"false": 0.935354, "true": 0.064646}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.06464554269842727, "confidence": 0.6544, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.986874, "true": 0.013126}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.013126411713919062, "confidence": 0.8991, "action": {"act_probability": 1.0}}}, "89e3e4ca33f1d96b": {"superiority": {"type": "noul", "probabilities": {"false": 0.87158, "true": 0.12842}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.12842045061007565, "confidence": 0.4469, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.980202, "true": 0.019798}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.019798072858242314, "confidence": 0.8597, "action": {"act_probability": 1.0}}}, "c12211255f6b2788": {"superiority": {"type": "noul", "probabilities": {"false": 0.936921, "true": 0.063079}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.06307903516685857, "confidence": 0.6605, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.989526, "true": 0.010474}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.010474416131312754, "confidence": 0.9161, "action": {"act_probability": 1.0}}}, "1beef9781f043a37": {"superiority": {"type": "noul", "probabilities": {"false": 0.905029, "true": 0.094971}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.09497139534203895, "confidence": 0.5472, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.986648, "true": 0.013352}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.013351783801292967, "confidence": 0.8977, "action": {"act_probability": 1.0}}}, "219aa22d8fc95333": {"superiority": {"type": "noul", "probabilities": {"false": 0.92763, "true": 0.07237}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.07237030640705697, "confidence": 0.6253, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.991991, "true": 0.008009}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.008008509255550909, "confidence": 0.9327, "action": {"act_probability": 1.0}}}, "e303b6dd0f35686e": {"superiority": {"type": "noul", "probabilities": {"false": 0.958939, "true": 0.041061}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.041060520124923845, "confidence": 0.7529, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.998619, "true": 0.001381}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.001380944195841363, "confidence": 0.9849, "action": {"act_probability": 1.0}}}, "ab472564b0afb3df": {"superiority": {"type": "noul", "probabilities": {"false": 0.955649, "true": 0.044351}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.04435106403677526, "confidence": 0.7381, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.990412, "true": 0.009588}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.009588192111463896, "confidence": 0.9219, "action": {"act_probability": 1.0}}}, "831e53d0cfedd180": {"superiority": {"type": "noul", "probabilities": {"false": 0.92514, "true": 0.07486}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.07486002233057326, "confidence": 0.6162, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.997417, "true": 0.002583}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.0025829942032979873, "confidence": 0.9741, "action": {"act_probability": 1.0}}}, "3814dffcfb50a477": {"superiority": {"type": "noul", "probabilities": {"false": 0.839772, "true": 0.160228}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.16022845249222342, "confidence": 0.3651, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.977256, "true": 0.022744}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.022744429383339856, "confidence": 0.8434, "action": {"act_probability": 1.0}}}, "7313afde6d15988e": {"superiority": {"type": "noul", "probabilities": {"false": 0.774628, "true": 0.225372}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.2253715766323574, "confidence": 0.2301, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.928433, "true": 0.071567}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.07156748055363117, "confidence": 0.6283, "action": {"act_probability": 1.0}}}, "6d48884b352707b3": {"superiority": {"type": "noul", "probabilities": {"false": 0.944716, "true": 0.055284}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.05528403302750518, "confidence": 0.6916, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.977968, "true": 0.022032}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.022031822160061526, "confidence": 0.8473, "action": {"act_probability": 1.0}}}, "9af7ceb46b155a65": {"superiority": {"type": "noul", "probabilities": {"false": 0.961473, "true": 0.038527}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.038527139563067074, "confidence": 0.7645, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.99684, "true": 0.00316}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.0031596016107618566, "confidence": 0.9692, "action": {"act_probability": 1.0}}}, "8446f5e753734ce2": {"superiority": {"type": "noul", "probabilities": {"false": 0.823132, "true": 0.176868}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.17686785870764649, "confidence": 0.3268, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.723603, "true": 0.276397}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.27639653966432126, "confidence": 0.1495, "action": {"act_probability": 1.0}}}, "b2c6af97c9115498": {"superiority": {"type": "noul", "probabilities": {"false": 0.87846, "true": 0.12154}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.12154016949685036, "confidence": 0.4662, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.976833, "true": 0.023167}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.02316691411439681, "confidence": 0.8411, "action": {"act_probability": 1.0}}}, "aa7a462ad61bd7ba": {"superiority": {"type": "noul", "probabilities": {"false": 0.790153, "true": 0.209847}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.20984669588106147, "confidence": 0.2588, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.962214, "true": 0.037786}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.03778594510220697, "confidence": 0.768, "action": {"act_probability": 1.0}}}, "6f7ee2ae141cb5a5": {"superiority": {"type": "noul", "probabilities": {"false": 0.836062, "true": 0.163938}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.1639378774335748, "confidence": 0.3564, "action": {"act_probability": 1.0}}, "blocked_or_unfair": {"type": "noul", "probabilities": {"false": 0.974662, "true": 0.025338}, "argmax_index": 0, "labels": ["false", "true"], "choice": "false", "score": null, "noul": 0.02533795811617691, "confidence": 0.8296, "action": {"act_probability": 1.0}}}}

out/probe_quality_id.json

@@ -0,0 +1,612 @@
+{
+ "conditions": [
+  {
+   "condition": "Z  EN probes (author)  + EN question",
+   "n": 16,
+   "correct": 13,
+   "accuracy": 0.812,
+   "per_class": {
+    "anger": {
+     "n": 8,
+     "correct": 7,
+     "mean_p_anger": 0.783
+    },
+    "contempt": {
+     "n": 8,
+     "correct": 6,
+     "mean_p_anger": 0.292
+    }
+   },
+   "mean_p_anger_overall": 0.537
+  },
+  {
+   "condition": "A  EN probes (this set)+ EN question",
+   "n": 16,
+   "correct": 14,
+   "accuracy": 0.875,
+   "per_class": {
+    "anger": {
+     "n": 8,
+     "correct": 7,
+     "mean_p_anger": 0.796
+    },
+    "contempt": {
+     "n": 8,
+     "correct": 7,
+     "mean_p_anger": 0.202
+    }
+   },
+   "mean_p_anger_overall": 0.499
+  },
+  {
+   "condition": "B  ID probes           + EN question",
+   "n": 16,
+   "correct": 11,
+   "accuracy": 0.688,
+   "per_class": {
+    "anger": {
+     "n": 8,
+     "correct": 5,
+     "mean_p_anger": 0.684
+    },
+    "contempt": {
+     "n": 8,
+     "correct": 6,
+     "mean_p_anger": 0.307
+    }
+   },
+   "mean_p_anger_overall": 0.496
+  },
+  {
+   "condition": "C  ID probes           + ID question",
+   "n": 16,
+   "correct": 12,
+   "accuracy": 0.75,
+   "per_class": {
+    "anger": {
+     "n": 8,
+     "correct": 4,
+     "mean_p_anger": 0.542
+    },
+    "contempt": {
+     "n": 8,
+     "correct": 8,
+     "mean_p_anger": 0.174
+    }
+   },
+   "mean_p_anger_overall": 0.358
+  },
+  {
+   "condition": "D  EN probes           + ID question",
+   "n": 16,
+   "correct": 14,
+   "accuracy": 0.875,
+   "per_class": {
+    "anger": {
+     "n": 8,
+     "correct": 7,
+     "mean_p_anger": 0.772
+    },
+    "contempt": {
+     "n": 8,
+     "correct": 7,
+     "mean_p_anger": 0.263
+    }
+   },
+   "mean_p_anger_overall": 0.517
+  },
+  {
+   "condition": "E  ID probes + EN q, options swapped",
+   "n": 16,
+   "correct": 11,
+   "accuracy": 0.688,
+   "per_class": {
+    "anger": {
+     "n": 8,
+     "correct": 7,
+     "mean_p_anger": 0.714
+    },
+    "contempt": {
+     "n": 8,
+     "correct": 4,
+     "mean_p_anger": 0.483
+    }
+   },
+   "mean_p_anger_overall": 0.599
+  }
+ ],
+ "detail": {
+  "Z  EN probes (author)  + EN question": [
+   {
+    "gold": "anger",
+    "p_anger": 0.7163,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8533,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.998,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.1147,
+    "pred": "contempt"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.7604,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.9506,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.9887,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8848,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0479,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.2847,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.1068,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.5144,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.4317,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0612,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.6129,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.2727,
+    "pred": "contempt"
+   }
+  ],
+  "A  EN probes (this set)+ EN question": [
+   {
+    "gold": "anger",
+    "p_anger": 0.9381,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.78,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.9962,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.13,
+    "pred": "contempt"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8004,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8561,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.9917,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8751,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0957,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.1732,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.4316,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.5255,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0742,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0831,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.2038,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0287,
+    "pred": "contempt"
+   }
+  ],
+  "B  ID probes           + EN question": [
+   {
+    "gold": "anger",
+    "p_anger": 0.8299,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.9646,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.4416,
+    "pred": "contempt"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.4756,
+    "pred": "contempt"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.969,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.3315,
+    "pred": "contempt"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8758,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.5866,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.191,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.6434,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.6941,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.1205,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.2788,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0922,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.1518,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.2878,
+    "pred": "contempt"
+   }
+  ],
+  "C  ID probes           + ID question": [
+   {
+    "gold": "anger",
+    "p_anger": 0.6251,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.931,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.3233,
+    "pred": "contempt"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.5166,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8748,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.3728,
+    "pred": "contempt"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.3972,
+    "pred": "contempt"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.2974,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0781,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.2541,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.2815,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.2547,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.2434,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.1972,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0375,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0478,
+    "pred": "contempt"
+   }
+  ],
+  "D  EN probes           + ID question": [
+   {
+    "gold": "anger",
+    "p_anger": 0.5293,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8218,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.9996,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8082,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8503,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.4655,
+    "pred": "contempt"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8973,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8029,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.1238,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.5707,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.4593,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.274,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.2783,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.137,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.2378,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0228,
+    "pred": "contempt"
+   }
+  ],
+  "E  ID probes + EN q, options swapped": [
+   {
+    "gold": "anger",
+    "p_anger": 0.5813,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.9839,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.1519,
+    "pred": "contempt"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.6842,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.9915,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.5162,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.8113,
+    "pred": "anger"
+   },
+   {
+    "gold": "anger",
+    "p_anger": 0.9942,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.573,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.8482,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.6422,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.4279,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.8439,
+    "pred": "anger"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.048,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.0114,
+    "pred": "contempt"
+   },
+   {
+    "gold": "contempt",
+    "p_anger": 0.4708,
+    "pred": "contempt"
+   }
+  ]
+ }
+}

out/reconfirm.json

@@ -0,0 +1,63 @@
+{
+ "stages": {
+  "id_core": {
+   "keys": 471,
+   "only_in_a": 0,
+   "only_in_b": 0,
+   "max_abs_diff": 0.0,
+   "mean_abs_diff": 0.0,
+   "side_agree": 471,
+   "side_rows": 471
+  },
+  "id_core_swap": {
+   "keys": 471,
+   "only_in_a": 0,
+   "only_in_b": 0,
+   "max_abs_diff": 0.0,
+   "mean_abs_diff": 0.0,
+   "side_agree": 471,
+   "side_rows": 471
+  },
+  "id_diag": {
+   "keys": 53,
+   "only_in_a": 0,
+   "only_in_b": 0,
+   "max_abs_diff": 0.0,
+   "mean_abs_diff": 0.0,
+   "side_agree": 0,
+   "side_rows": 0
+  },
+  "id_veto": {
+   "keys": 471,
+   "only_in_a": 0,
+   "only_in_b": 0,
+   "max_abs_diff": 0.0,
+   "mean_abs_diff": 0.0,
+   "side_agree": 0,
+   "side_rows": 0
+  }
+ },
+ "second_run": {
+  "total_laya_seconds": 856.6,
+  "stages": {
+   "id_core": 305.0,
+   "id_core_swap": 301.1,
+   "id_diag": 53.9,
+   "id_veto": 196.6
+  },
+  "stage_rows": {
+   "id_core": 475,
+   "id_core_swap": 475,
+   "id_diag": 108,
+   "id_veto": 475
+  },
+  "rows": 475
+ },
+ "labels": {
+  "rows": 475,
+  "identical": 475,
+  "flips": [],
+  "max_prob_abs_diff": 0.0,
+  "identical_bytes": true
+ }
+}

out/timings.json

@@ -1,19 +1,22 @@
 {
   "rows": 475,
-  "ambiguous_rows": 214,
-  "total_laya_seconds": 1209.6,
+  "ambiguous_rows": 54,
+  "total_laya_seconds": 851.2,
   "stages": {
-    "en_core": 709.7,
-    "id_core": 311.0,
-    "en_diag": 188.9
+    "id_core": 299.8,
+    "id_core_swap": 299.5,
+    "id_diag": 53.5,
+    "id_veto": 198.4
+  },
+  "stage_rows": {
+    "id_core": 475,
+    "id_core_swap": 475,
+    "id_diag": 108,
+    "id_veto": 475
   },
   "max_len": 256,
   "head_max_len": 144,
   "token_budget": 6144,
   "margin": 0.1,
-  "stage_rows": {
-    "en_core": 950,
-    "id_core": 475,
-    "en_diag": 428
-  }
+  "language": "id-only"
 }

out_prev/speedup.json

@@ -0,0 +1,22 @@
+{
+  "docs": 32,
+  "ms_per_doc_one_question": {
+    "A_stock_default": 662.2,
+    "B_stock_tuned": 638.5,
+    "C_batched_tuned": 740.18,
+    "D_batched_default": 717.29
+  },
+  "speedup_token_budget_x": 1.04,
+  "speedup_batching_x": 0.86,
+  "speedup_total_x": 0.89,
+  "stage_seconds": {
+    "en_core": 709.7,
+    "id_core": 311.0,
+    "en_diag": 188.9
+  },
+  "total_laya_seconds": 1209.6,
+  "rows_scored": 475,
+  "ambiguous_rows": 214,
+  "rows_if_naive_2lang_5q": 4750,
+  "rows_paid": 1853
+}

out_prev/timings.json

@@ -0,0 +1,19 @@
+{
+  "rows": 475,
+  "ambiguous_rows": 214,
+  "total_laya_seconds": 1209.6,
+  "stages": {
+    "en_core": 709.7,
+    "id_core": 311.0,
+    "en_diag": 188.9
+  },
+  "max_len": 256,
+  "head_max_len": 144,
+  "token_budget": 6144,
+  "margin": 0.1,
+  "stage_rows": {
+    "en_core": 950,
+    "id_core": 475,
+    "en_diag": 428
+  }
+}

out_prev/veto_check.json

@@ -0,0 +1,5 @@
+{
+  "veto_mean_p_neither": 0.12,
+  "veto_flagged": 1,
+  "choice_acc": 0.812
+}

probe_quality_id.py

@@ -0,0 +1,99 @@
+#!/usr/bin/env python
+"""Fit-for-purpose check in *both* languages, plus the two controls a reviewer will ask for.
+
+Conditions (16 hand-written probes each, 8 anger + 8 contempt, chance = 0.50):
+
+  Z  author's English probes   + English question   - reproduction check against the shipped 13/16
+  A  English probes (of this set) + English question
+  B  Indonesian probes + English question           <- THE reading the Indonesian-only build runs
+  C  Indonesian probes + Indonesian question        - does the question's language matter?
+  D  English probes   + Indonesian question
+  E  Indonesian probes + English question, criteria order swapped (contempt first)
+                                                    - positional-bias control for B
+
+Writes out/probe_quality_id.json.
+"""
+import json
+
+import numpy as np
+
+import laya_opt
+from ekman_questions import EKMAN_QUESTIONS
+from ekman_questions_id import EKMAN_QUESTIONS_ID
+from probes import PROBES
+from probes_id import PROBES_ID, PROBES_ID_EN
+
+
+def run(agent, texts, question):
+    res, st = laya_opt.score_texts(agent, {"ekman": question}, texts, max_len=256,
+                                   head_max_len=144, token_budget=6144, log=lambda *a: None)
+    pa = np.array([r["ekman"]["probabilities"]["anger"] for r in res])
+    return pa, res, st
+
+
+def summarise(name, gold, pa):
+    pred = np.where(pa >= 0.5, "anger", "contempt")
+    ok = int((pred == np.array(gold)).sum())
+    per = {}
+    for g in ("anger", "contempt"):
+        m = np.array(gold) == g
+        per[g] = {"n": int(m.sum()), "correct": int((pred[m] == g).sum()),
+                  "mean_p_anger": round(float(pa[m].mean()), 3)}
+    row = {"condition": name, "n": len(gold), "correct": ok,
+           "accuracy": round(ok / len(gold), 3), "per_class": per,
+           "mean_p_anger_overall": round(float(pa.mean()), 3)}
+    print("%-52s %2d/%2d = %.3f | P(anger) anger-probes %.2f contempt-probes %.2f" % (
+        name, ok, len(gold), ok / len(gold), per["anger"]["mean_p_anger"],
+        per["contempt"]["mean_p_anger"]))
+    return row
+
+
+def main():
+    agent = laya_opt.load_agent()
+    assert agent is not None
+    import ekman_questions as EQ
+    EQ.assert_option_budget(agent.tok)
+    import re
+    import ekman_questions_id as EQID
+    for cid in ("anger", "contempt"):
+        n = len(agent.tok(re.sub(r"\s+", " ", EQID.EKMAN_QUESTIONS_ID["ekman"]["criteria"][cid]).strip(),
+                         add_special_tokens=False)["input_ids"])
+        assert n <= 48, ("Indonesian criterion over laya's 48-token option cap", cid, n)
+        print("[probe] id criterion %-8s %d/48 option tokens" % (cid, n))
+    for qid in ("superiority", "blocked_or_unfair"):
+        n = len(agent.tok(EQID.EKMAN_QUESTIONS_ID[qid]["instructions"],
+                          add_special_tokens=False)["input_ids"])
+        assert n <= 144, ("Indonesian instruction over the head budget", qid, n)
+    print("[probe] option budget ok for the Indonesian criteria too\n")
+
+    out = []
+    en_q = EKMAN_QUESTIONS["ekman"]
+    id_q = EKMAN_QUESTIONS_ID["ekman"]
+    swap_q = {"type": "choice", "instructions": id_q["instructions"],
+              "criteria": {"contempt": id_q["criteria"]["contempt"],
+                           "anger": id_q["criteria"]["anger"]}}
+
+    jobs = [
+        ("Z  EN probes (author)  + EN question", [g for g, _ in PROBES], [t for _, t in PROBES], en_q),
+        ("A  EN probes (this set)+ EN question", [g for g, _ in PROBES_ID_EN], [t for _, t in PROBES_ID_EN], en_q),
+        ("B  ID probes           + EN question", [g for g, _ in PROBES_ID], [t for _, t in PROBES_ID], en_q),
+        ("C  ID probes           + ID question", [g for g, _ in PROBES_ID], [t for _, t in PROBES_ID], id_q),
+        ("D  EN probes           + ID question", [g for g, _ in PROBES_ID_EN], [t for _, t in PROBES_ID_EN], id_q),
+        ("E  ID probes + EN q, options swapped", [g for g, _ in PROBES_ID], [t for _, t in PROBES_ID], swap_q),
+    ]
+    detail = {}
+    for name, gold, texts, q in jobs:
+        pa, res, st = run(agent, texts, q)
+        out.append(summarise(name, gold, pa))
+        detail[name] = [{"gold": g, "p_anger": round(float(p), 4),
+                         "pred": "anger" if p >= 0.5 else "contempt"} for g, p in zip(gold, pa)]
+    with open("out/probe_quality_id.json", "w") as f:
+        json.dump({"conditions": out, "detail": detail}, f, indent=1)
+    print("\n[probe] wrote out/probe_quality_id.json")
+    # the two numbers the card quotes
+    b = out[2]
+    print("[probe] headline (ID text + EN question): %d/%d = %.3f" % (b["correct"], b["n"], b["accuracy"]))
+
+
+if __name__ == "__main__":
+    main()

probes_id.py

@@ -0,0 +1,74 @@
+"""Hand-written clear-cut probes in Indonesian: 8 Ekman anger, 8 Ekman contempt.
+
+The English probe set (`probes.py`) is kept as-is for the English reading.  This file is its
+Indonesian counterpart, written from the same two Paul Ekman Group pages (not from the corpus), so
+the *fit-for-purpose* check can be run in the language the labels are actually decided in.
+
+Four of the anger probes deliberately use the corpus's own explicit anger vocabulary - kesal,
+murka, benci, tersinggung - because the Indonesian reading of the anger pool turned those same words
+into `contempt`, which is exactly what this probe set has to test.
+"""
+
+PROBES_ID = [
+ # --- 8 clear anger: blocked / treated unfairly, pushing to remove the obstacle -------------------
+ ("anger", "Aku antre dua jam, tiba-tiba loketnya ditutup tanpa pemberitahuan. Tidak bisa diterima, "
+           "kembalikan uangku sekarang!"),
+ ("anger", "Tetangga parkir di depan gerbangku lagi. Minggir atau aku panggil derek, sumpah!"),
+ ("anger", "Setelah semua yang aku lakukan untuk dia, dia bohongin aku di depan orang banyak? "
+           "Aku benar-benar murka sama dia."),
+ ("anger", "Listrik mati lagi pas jam ujian. Pemerintah ini tidak becus dan seharusnya malu!"),
+ ("anger", "Jangan sentuh pekerjaanku! Kamu baru saja merusak tiga hari kerjaanku karena "
+           "kecerobohanmu."),
+ ("anger", "Tidak adil kalau orang yang sama terus dapat shift bagus. Aku mau bicara sama "
+           "manajernya hari ini."),
+ ("anger", "Beraninya kamu menuduh aku di depan semua orang? Minta maaf sekarang, atau aku bikin "
+           "kamu susah."),
+ ("anger", "Sudah seratus kali aku bilang jangan buka buku harianku. Aku benci kamu karena itu."),
+ # --- 8 clear contempt: superiority over a lesser target, dismissing rather than demanding -------
+ ("contempt", "Ya ampun, kamu tidak akan paham. Ini sedikit di atas level pendidikanmu."),
+ ("contempt", "Sekolah tinggi-tinggi tapi menulisnya salah semua. Generasi ini memalukan dilihat."),
+ ("contempt", "Aku sudah tidak mau berdebat dengan orang seperti dia, buat apa, otaknya tidak "
+              "sampai."),
+ ("contempt", "Katanya dia ahli di televisi itu? Aku cuma bisa menghela napas sepanjang "
+              "wawancaranya."),
+ ("contempt", "Biarkan mereka pegang penghargaan itu. Aku tidak akan turun derajat selevel dengan "
+              "badut-badut seperti itu."),
+ ("contempt", "Lihat mereka meminta-minta like ke orang asing. Lucu juga betapa tidak berharganya "
+              "semua itu."),
+ ("contempt", "Aku sudah tidak marah lagi sama mantanku. Aku cuma tidak percaya pernah pacaran "
+              "sama orang sekecil itu."),
+ ("contempt", "Dasar tukang gambar di grup. Sedikit bisa fotoshop, langsung merasa paling "
+              "berbakat di dunia."),
+]
+
+# The same 16 probes in English, one per line (used for the 2x2 language-control matrix; note these
+# are *literal* renderings of the Indonesian probes, so the comparison isolates the language and not
+# the wording).
+PROBES_ID_EN = [
+ ("anger", "I queued for two hours and suddenly the counter closed without notice. Unacceptable, "
+           "give me my money back now!"),
+ ("anger", "The neighbour parked in front of my gate again. Move it or I call a tow truck, I swear!"),
+ ("anger", "After everything I did for him, he lies to me in front of everyone? I am really furious "
+           "with him."),
+ ("anger", "The power went out again during the exam. This government is incompetent and should be "
+           "ashamed!"),
+ ("anger", "Don't touch my work! You just ruined three days of my work with your carelessness."),
+ ("anger", "It is unfair that the same person keeps getting the good shifts. I want to talk to the "
+           "manager today."),
+ ("anger", "How dare you accuse me in front of everyone? Apologise now, or I will make things hard "
+           "for you."),
+ ("anger", "I told you a hundred times not to open my diary. I hate you for it."),
+ ("contempt", "Oh my, you won't understand. This is a little above your education level."),
+ ("contempt", "So highly educated but cannot write a single thing correctly. This generation is "
+              "embarrassing to watch."),
+ ("contempt", "I don't want to argue with people like him any more, what for, his brain cannot "
+              "reach that far."),
+ ("contempt", "They say he is an expert on television? I can only sigh through his entire "
+              "interview."),
+ ("contempt", "Let them keep that award. I will not lower myself to the level of clowns like that."),
+ ("contempt", "Look at them begging strangers for likes. Funny how worthless all of it is."),
+ ("contempt", "I am no longer angry with my ex. I just cannot believe I ever dated someone that "
+              "small."),
+ ("contempt", "Just a little photoshop group guy. Can barely edit and already feels like the most "
+              "talented person in the world."),
+]

publish.py

@@ -29,6 +29,12 @@ def main():
     for need in ("README.md",):
         if not os.path.exists(os.path.join(args.dist, need)):
             sys.exit("run make_dataset.py first: %s is missing from %s" % (need, args.dist))
+    # working notes, scratch dirs and the local model cache must never be uploaded
+    junk = [f for f in sorted(os.listdir(args.dist))
+            if f.upper().startswith(("REVISION_NOTES", "NOTES", "TODO", "CHANGELOG"))
+            or f in ("build", "models", "data", "dist", ".git")]
+    if junk:
+        sys.exit("refusing to publish: %s/%s" % (args.dist, ", ".join(junk)))
 
     from huggingface_hub import HfApi
     api = HfApi(token=args.token)

runs/label_run_id.log

@@ -0,0 +1,31 @@
+[laya] agent ready in 12.6s (321908995 params)
+[laya] option budget ok: every criterion fits laya's 48-token cap
+[data] 475 rows labelled anger (of 2243 annotated tweets)
+[stage id_core] 475 rows to score, 0 already cached
+[stage id_core] {"seconds": 299.8, "docs": 475, "forward_passes": 13, "docs_per_pass": 36.54, "rows": 475, "ms_per_doc": 631.2, "ms_per_row": 631.25, "max_seq_len": 219}
+[stage id_core_swap] 475 rows to score, 0 already cached
+[stage id_core_swap] {"seconds": 299.5, "docs": 475, "forward_passes": 13, "docs_per_pass": 36.54, "rows": 475, "ms_per_doc": 630.6, "ms_per_row": 630.62, "max_seq_len": 219}
+[stage id_diag] 54/475 rows not decided by the Indonesian choice reading
+[stage id_diag] 54 rows to score, 0 already cached
+[stage id_diag] {"seconds": 53.5, "docs": 54, "forward_passes": 3, "docs_per_pass": 18.0, "rows": 108, "ms_per_doc": 991.3, "ms_per_row": 495.65, "max_seq_len": 158}
+[stage id_veto] 475 rows to score, 0 already cached
+[stage id_veto] {"seconds": 198.4, "docs": 475, "forward_passes": 8, "docs_per_pass": 59.38, "rows": 475, "ms_per_doc": 417.7, "ms_per_row": 417.67, "max_seq_len": 165}
+
+=== laya anger/contempt split (Indonesian only) ===
+label
+anger       289
+contempt    186
+
+label provenance:
+label_source
+ekman_choice_id           421
+ekman_noul_tiebreak        33
+ekman_choice_order_avg     18
+kept_original_label         3
+
+contempt share of the pool: 39.2%
+ambiguous (|margin|<0.10): 54
+mean P(anger): as prompted 0.589 | swapped 0.726
+rows whose argmax flips with the option order: 119 (25.1%)
+p(not anger or contempt) > 0.5: 18
+laya seconds: {"id_core": 299.8, "id_core_swap": 299.5, "id_diag": 53.5, "id_veto": 198.4}

runs/label_run_id_reconfirm.log

@@ -0,0 +1,31 @@
+[laya] agent ready in 15.2s (321908995 params)
+[laya] option budget ok: every criterion fits laya's 48-token cap
+[data] 475 rows labelled anger (of 2243 annotated tweets)
+[stage id_core] 475 rows to score, 0 already cached
+[stage id_core] {"seconds": 305.0, "docs": 475, "forward_passes": 13, "docs_per_pass": 36.54, "rows": 475, "ms_per_doc": 642.1, "ms_per_row": 642.05, "max_seq_len": 219}
+[stage id_core_swap] 475 rows to score, 0 already cached
+[stage id_core_swap] {"seconds": 301.1, "docs": 475, "forward_passes": 13, "docs_per_pass": 36.54, "rows": 475, "ms_per_doc": 633.9, "ms_per_row": 633.91, "max_seq_len": 219}
+[stage id_diag] 54/475 rows not decided by the Indonesian choice reading
+[stage id_diag] 54 rows to score, 0 already cached
+[stage id_diag] {"seconds": 53.9, "docs": 54, "forward_passes": 3, "docs_per_pass": 18.0, "rows": 108, "ms_per_doc": 998.4, "ms_per_row": 499.22, "max_seq_len": 158}
+[stage id_veto] 475 rows to score, 0 already cached
+[stage id_veto] {"seconds": 196.6, "docs": 475, "forward_passes": 8, "docs_per_pass": 59.38, "rows": 475, "ms_per_doc": 413.8, "ms_per_row": 413.83, "max_seq_len": 165}
+
+=== laya anger/contempt split (Indonesian only), second run ===
+label
+anger       289
+contempt    186
+
+label provenance:
+label_source
+ekman_choice_id           421
+ekman_noul_tiebreak        33
+ekman_choice_order_avg     18
+kept_original_label         3
+
+contempt share of the pool: 39.2%
+ambiguous (|margin|<0.10): 54
+mean P(anger): as prompted 0.589 | swapped 0.726
+rows whose argmax flips with the option order: 119 (25.1%)
+p(not anger or contempt) > 0.5: 18
+laya seconds: {"id_core": 305.0, "id_core_swap": 301.1, "id_diag": 53.9, "id_veto": 196.6}

split_exact.py

@@ -0,0 +1,232 @@
+"""Exact 8:1:1 stratification that still keeps duplicate groups whole.
+
+The published build split with a greedy deficit-filling pass (`make_dataset.stratified_811`), which
+cannot hit exact split sizes when the last group of a class does not fit: it landed 2,243 rows on
+1794/226/223 (0.02 / 0.08 / 0.06 points off 8:1:1) and `anger_split_balanced` on 150/20/18 (0.4 /
+1.2 / 1.2 points off).
+
+Two changes make the counts exact without giving up the no-leakage guarantee:
+
+1. **Bottleneck targets.**  The tenth block b = floor(n / 10) is the unit: `valid` and `test` get
+   exactly b rows each, `train` takes n - 2b.  That is exact to the last row and keeps the two tail
+   splits the same size at their plain 10% floor (2,243 -> 1795 / 224 / 224, i.e. 8b + 3 for train).
+   `ideal_targets()` then solves the per-class-per-split cells as an integer program (scipy's HiGHS)
+   against those column totals, minimising the total absolute distance to `n_class * fraction`.
+2. **Greedy place, then repair.**  Groups are placed by need, then single groups are moved between
+   splits as long as a move lowers `PRIMARY * |column deficits| + |cell distances|`.  Because all
+   but a handful of the ~2,200 groups are singletons, the column totals always reach their exact
+   targets, so the shipped files are 8:1:1 to the last row *and* leak-free.
+"""
+from typing import Dict, List, Sequence, Tuple
+
+import numpy as np
+import pandas as pd
+
+SPLITS = ("train", "valid", "test")
+FRACTIONS = (0.8, 0.1, 0.1)
+PRIMARY = 1e6            # weight on exact column totals vs. per-class cell fit
+
+
+def apportion(n: int, fractions: Sequence[float] = FRACTIONS) -> List[int]:
+    """Exact 8b : 1b : 1b, where b = floor(n/10) is the bottleneck.
+
+    Every split config here is built so that `n` is a multiple of ten - the balanced pools sample a
+    multiple of ten rows per class (180 of 186, see `sample_groups_per_class`) - so `n - 2b` is
+    exactly `8b` and the three splits are 8:1:1 to the row with nothing left over.  The formula
+    still returns a sensible answer for an `n` that is not a multiple of ten (the rows no tenth can
+    hold go to `train`), but no shipped config relies on that.
+
+    The tenth block b = floor(n / 10) is the unit every split is measured in.  n is never a multiple
+    of ten here, and 8b : 1b : 1b can only ever account for 10b <= n rows, so the rows that no tenth
+    can hold (n - 10b, at most 9) go to `train` - the largest split, where they move the ratio least,
+    and the only placement that keeps both tail splits at exactly one bottleneck each:
+
+        2,243 -> 1795 / 224 / 224   (b = 224, train = 8b + 3)
+        1,302 -> 1042 / 130 / 130   (b = 130, train = 8b + 2)
+          658 ->  528 /  65 /  65   (b =  65, train = 8b + 8)
+          475 ->  381 /  47 /  47   (b =  47, train = 8b + 5)
+          372 ->  298 /  37 /  37   (b =  37, train = 8b + 2)
+
+    `train` is always `n - 2b`, never `8b`, so the leftover rows are never dropped.  For n < 10 the
+    tenth block is 0 rows and all n rows go to `train`.
+    """
+    b = n // 10
+    if b == 0:
+        return [n, 0, 0]
+    tails = [b] * (len(fractions) - 1)
+    return [n - sum(tails)] + tails
+
+
+def sample_groups_per_class(df, per_class_rows: int, seed: int, labels=None):
+    """Down-sample to exactly `per_class_rows` rows per class, in whole duplicate groups.
+
+    A balanced config is a sample, so it can be sized to whatever makes the split exact; every group
+    (a wording that repeats, possibly with a different upstream label) is kept or dropped as a unit,
+    so duplicate text can never straddle splits.  Rows are dropped by shuffling that class's groups
+    with `seed` and dropping whole groups until exactly `class_size - per_class_rows` rows are gone,
+    which keeps the result deterministic and independent of the group order on disk.
+    """
+    labels = list(labels) if labels is not None else sorted(df["label"].unique())
+    rng = np.random.RandomState(seed)
+    keep = np.zeros(len(df), dtype=bool)
+    dropped = {}
+    for c in labels:
+        idx = df.index[df["label"] == c].to_numpy()
+        sizes = df.loc[idx].groupby("group").size()
+        need = int(sizes.sum()) - per_class_rows
+        assert need >= 0, f"{c}: {sizes.sum()} rows is less than the sample size {per_class_rows}"
+        order = rng.permutation(len(sizes))
+        drop_groups, got = set(), 0
+        for k in order:                                   # prefer groups that fit the budget exactly
+            g = sizes.index[k]
+            if sizes.iloc[k] <= need - got:
+                drop_groups.add(g)
+                got += int(sizes.iloc[k])
+            if got == need:
+                break
+        assert got == need, f"{c}: cannot drop exactly {need} rows without cutting a group"
+        dropped[c] = [int(g) for g in drop_groups]
+        keep |= df.index.isin(idx) & ~df["group"].isin(drop_groups)
+    out = df[keep].reset_index(drop=True)
+    assert len(out) == per_class_rows * len(labels)
+    assert set(out["label"].value_counts()) == {per_class_rows}
+    return out, dropped
+
+
+def ideal_targets(class_sizes: Dict[str, int], split_sizes: Sequence[int],
+                  fractions: Sequence[float] = FRACTIONS) -> Dict[str, List[int]]:
+    """Integer per-(class, split) targets: exact column totals, minimal distance to n_c * f_s.
+
+    Solves   min sum_{c,s} |x_cs - n_c f_s|   s.t.  sum_s x_cs = n_c,  sum_c x_cs = N_s  (x >= 0 int)
+    so the class-level counts stay as close to proportional as the exact split sizes allow.
+    """
+    classes = list(class_sizes)
+    S = len(split_sizes)
+    nc, ns = len(classes), len(split_sizes)
+    nvar = nc * S + nc * S                     # x (int) then d (continuous)
+    c_obj = np.zeros(nvar)
+    c_obj[nc * S:] = 1.0
+    integrality = np.zeros(nvar)
+    integrality[:nc * S] = 1
+    lb = np.zeros(nvar)
+    ub = np.full(nvar, np.inf)
+    rows, lows, highs = [], [], []
+    for i, cl in enumerate(classes):           # sum_s x_cs = n_c
+        r = np.zeros(nvar); r[i * S:(i + 1) * S] = 1
+        rows.append(r); lows.append(class_sizes[cl]); highs.append(class_sizes[cl])
+    for s in range(S):                         # sum_c x_cs = N_s
+        r = np.zeros(nvar)
+        for i in range(nc):
+            r[i * S + s] = 1
+        rows.append(r); lows.append(split_sizes[s]); highs.append(split_sizes[s])
+    for i, cl in enumerate(classes):           # |x_cs - n_c f_s| <= d_cs
+        for s in range(S):
+            tgt = class_sizes[cl] * fractions[s]
+            r = np.zeros(nvar); r[i * S + s] = 1; r[nc * S + i * S + s] = -1
+            rows.append(r); lows.append(-np.inf); highs.append(tgt)
+            r = np.zeros(nvar); r[i * S + s] = -1; r[nc * S + i * S + s] = -1
+            rows.append(r); lows.append(-np.inf); highs.append(-tgt)
+    from scipy.optimize import Bounds, LinearConstraint, milp
+    res = milp(c=c_obj, constraints=LinearConstraint(np.array(rows), np.array(lows), np.array(highs)),
+               integrality=integrality, bounds=Bounds(lb, ub))
+    if not res.success:
+        raise RuntimeError("target rounding ILP failed: %s" % res.message)
+    x = np.rint(res.x[:nc * S]).astype(int).reshape(nc, S)
+    assert (x.sum(1) == np.array([class_sizes[c] for c in classes])).all()
+    assert (x.sum(0) == np.array(split_sizes)).all(), (x.sum(0), split_sizes)
+    return {cl: [int(v) for v in x[i]] for i, cl in enumerate(classes)}
+
+
+def _cost(cells: Dict[Tuple[str, int], int], ideal: Dict[Tuple[str, int], float],
+          col_target: Sequence[int], col_now: Sequence[int]) -> float:
+    c = 0.0
+    for k in ideal:
+        c += abs(cells[k] - ideal[k])
+    for s in range(3):
+        c += PRIMARY * abs(col_now[s] - col_target[s])
+    return c
+
+
+def assign_groups(df: pd.DataFrame, targets: Dict[str, List[int]], seed: int) -> List[str]:
+    """Group-aware assignment: place by need, then repair until the column totals are exact."""
+    labels = sorted(targets)
+    cols = {s: i for i, s in enumerate(SPLITS)}
+    grp = df["group"].to_numpy()
+    lab = df["label"].to_numpy()
+    groups: Dict[int, List[int]] = {}
+    for i, g in enumerate(grp):
+        groups.setdefault(int(g), []).append(i)
+    # label counts per group (a group can span two labels: one translation, two different tweets)
+    gcounts = {g: pd.Series([lab[i] for i in idx]).value_counts().to_dict()
+               for g, idx in groups.items()}
+    col_target = [sum(targets[c][s] for c in labels) for s in range(3)]
+    frac = np.array(FRACTIONS)
+    ideal = {(c, s): sum(targets[c]) * frac[s] for c in labels for s in range(3)}
+
+    rng = np.random.RandomState(seed)
+    order = sorted(groups, key=lambda g: -len(groups[g]))
+    # shuffle inside each size class so the seed controls which wording lands where
+    buckets: Dict[int, List[int]] = {}
+    for g in order:
+        buckets.setdefault(len(groups[g]), []).append(g)
+    ordered: List[int] = []
+    for size in sorted(buckets, reverse=True):
+        gs = buckets[size]
+        rng.shuffle(gs)
+        ordered += gs
+
+    rem = {c: [targets[c][s] for s in range(3)] for c in targets}
+    cells = {(c, s): 0 for c in labels for s in range(3)}
+    col_now = [0, 0, 0]
+    assign: Dict[int, int] = {}
+    for g in ordered:
+        best, best_score = 0, -1e18
+        for s in range(3):
+            score = 0.0
+            for c, k in gcounts[g].items():
+                tgt = targets[c][s]
+                score += k * (rem[c][s] / tgt if tgt else -1.0)
+            if score > best_score + 1e-12:
+                best, best_score = s, score
+        assign[g] = best
+        for c, k in gcounts[g].items():
+            rem[c][best] -= k
+            cells[(c, best)] += k
+        col_now[best] += len(groups[g])
+
+    # ---- repair: move whole groups while a move lowers `PRIMARY * column deficits + cell distance`
+    def col_penalty(col):
+        return PRIMARY * sum(abs(col[s] - col_target[s]) for s in range(3))
+
+    def cell_delta(g, s_from, s_to):
+        return sum(abs(cells[(c, s_to)] + k - ideal[(c, s_to)]) - abs(cells[(c, s_to)] - ideal[(c, s_to)])
+                   + abs(cells[(c, s_from)] - k - ideal[(c, s_from)]) - abs(cells[(c, s_from)] - ideal[(c, s_from)])
+                   for c, k in gcounts[g].items())
+
+    cur = col_penalty(col_now) + sum(abs(cells[k] - ideal[k]) for k in ideal)
+    for _ in range(20000):
+        best_move, best_cost = None, cur
+        for g, s_from in assign.items():
+            n = len(groups[g])
+            for s_to in range(3):
+                if s_to == s_from:
+                    continue
+                col_after = list(col_now); col_after[s_from] -= n; col_after[s_to] += n
+                p_delta = col_penalty(col_after) - col_penalty(col_now)
+                if p_delta > 0:            # never trade an exact column for a cell
+                    continue
+                cst = cur + p_delta + cell_delta(g, s_from, s_to)
+                if cst < best_cost - 1e-9:
+                    best_move, best_cost = (g, s_from, s_to), cst
+        if best_move is None:
+            break
+        g, s_from, s_to = best_move
+        assign[g] = s_to
+        col_now[s_from] -= len(groups[g]); col_now[s_to] += len(groups[g])
+        for c, k in gcounts[g].items():
+            cells[(c, s_from)] -= k
+            cells[(c, s_to)] += k
+        cur = best_cost
+    out = df.copy()
+    out["split"] = [SPLITS[assign[int(g)]] for g in out["group"].to_numpy()]
+    return out

test_split_exact.py

@@ -0,0 +1,116 @@
+"""Does the build hit exact 8b:1b:1b with no leakage - and are the whole pools really whole?
+
+Checks, on the labels actually shipped in `build/out/anger_ekman_rows.csv`:
+
+  1. `balanced` (7 classes) and `anger_split_balanced` (2 classes) land exactly on 8b : 1b : 1b with
+     b = N/10, per class as well as overall, and no duplicate group straddles a split;
+  2. `full` and `anger_split` carry the complete pools in one split;
+  3. the balanced sample is exactly `m` rows per class, m the largest multiple of ten that fits, and
+     dropping rows never cuts a group.
+
+The last block re-runs the *published* greedy splitter (`make_dataset.stratified_811_greedy`) on the
+earlier pools for contrast - that is the splitter whose rounding these checks exist to replace.
+"""
+import time
+
+import numpy as np
+
+import pandas as pd
+
+from make_dataset import (LABELS_BINARY, LABELS_EKMAN, SOURCE_TO_EKMAN, add_text_group,
+                          balanced_pool, norm)
+from split_exact import SPLITS, apportion, assign_groups, ideal_targets
+
+
+def build_pool(labels_csv="build/out/anger_ekman_rows.csv"):
+    f1 = pd.read_csv("data/file1.csv", index_col=0)
+    f2 = pd.read_csv("data/file2.csv", index_col=0)
+    df = f1.join(f2)
+    df["text"] = df["tweet"].map(norm)
+    df["text_en"] = df["tweet_en"].map(norm)
+    df["row_src"] = df.index
+    df["source_label"] = df["label"].astype(str).str.strip().str.lower()
+    df["label"] = df["source_label"].replace({"joy": "enjoyment"})
+    lab = pd.read_csv(labels_csv)
+    m = df.merge(lab[["row_src", "label"]].rename(columns={"label": "ek"}), on="row_src", how="left")
+    df["label"] = m["ek"].where(m["ek"].notna(), df["label"]).values
+    return add_text_group(df)
+
+
+def check_split(name, sub, labels, m):
+    """Exact 8b:1b:1b, every class the same size in every split, no group in two splits."""
+    t0 = time.time()
+    N = len(sub)
+    per_class_want = apportion(m)
+    assert N % 10 == 0, f"{name}: {N} rows is not a multiple of ten"
+    b = N // 10
+    want = [8 * b, b, b]
+    assert apportion(N) == want, (apportion(N), want)
+    out = assign_groups(sub, ideal_targets(sub["label"].value_counts().to_dict(), want), 0)
+    got = [int((out["split"] == s).sum()) for s in SPLITS]
+    leak = 0
+    for s in SPLITS:
+        g = set(out.loc[out["split"] == s, "group"])
+        for o in SPLITS:
+            if o != s:
+                leak += len(g & set(out.loc[out["split"] == o, "group"]))
+    per_class_ok = all(
+        set(out.loc[out["split"] == s, "label"].value_counts().values) == {per_class_want[i]}
+        for i, s in enumerate(SPLITS))
+    print("%-22s N=%-5d b=%-4d got=%-16s per class %s  per-class=%s leak=%d  %.1fs" % (
+        name, N, b, "/".join(map(str, got)), "/".join(map(str, per_class_want)),
+        "uniform" if per_class_ok else "RAGGED", leak, time.time() - t0))
+    assert got == want and leak == 0 and per_class_ok
+    return out, want
+
+
+def main():
+    df = build_pool()
+    ang = df[df["source_label"] == "anger"].reset_index(drop=True)
+
+    # 1-2: the balanced configs split exactly, the whole-pool configs are not split at all
+    for name, base, labels in (("balanced", df, LABELS_EKMAN),
+                               ("anger_split_balanced", ang, LABELS_BINARY)):
+        sub, m, dropped = balanced_pool(base, labels)
+        assert set(sub["label"].value_counts().values) == {m}, (name, m)
+        assert m % 10 == 0 and len(sub) == m * len(labels)
+        assert all(len(g) > 1 for c in dropped for g in []), "sanity"
+        check_split(name, sub, labels, m)
+    for name, base in (("full", df), ("anger_split", ang)):
+        print("%-22s N=%-5d one split, complete pool, nothing held out" % (name, len(base)))
+
+    # 3: the sample size rule - largest multiple of ten that fits the smallest class
+    small = pd.DataFrame({"label": ["a"] * 186 + ["b"] * 200, "group": range(386)})
+    sub, m, _ = balanced_pool(small, ["a", "b"])
+    assert m == 180 and set(sub["label"].value_counts().values) == {180}, (m, sub["label"].value_counts())
+    print("\nsample rule: 186 / 200 eligible -> %d rows per class (largest multiple of ten)" % m)
+
+    # contrast: the published pools and the published greedy splitter, for reference
+    print("\ncontrast - the earlier pools, split by the published greedy splitter:")
+    dfp = build_pool("out_prev/anger_ekman_rows.csv")
+    angp = dfp[dfp["source_label"] == "anger"].reset_index(drop=True)
+    from make_dataset import stratified_811_greedy
+
+    def old_pool(frame, labels, seed=0):
+        """the earlier rule: equal to the smallest class exactly, no ten-row block"""
+        per = min(int((frame["label"] == l).sum()) for l in labels)
+        rng = np.random.RandomState(seed + 1)
+        take = []
+        for l in labels:
+            idx = frame.index[frame["label"] == l].to_list()
+            take += idx if len(idx) == per else list(np.array(idx)[rng.permutation(len(idx))[:per]])
+        return frame.loc[sorted(take)].reset_index(drop=True)
+
+    for name, base in (("full", dfp), ("balanced", old_pool(dfp, LABELS_EKMAN)),
+                       ("anger_split", angp), ("anger_split_balanced", old_pool(angp, LABELS_BINARY))):
+        o = stratified_811_greedy(base, 0)
+        got = [int((o["split"] == s).sum()) for s in SPLITS]
+        N = len(base)
+        print("  %-22s N=%-5d got=%-18s dev=%s pts" % (
+            name, N, "/".join(map(str, got)),
+            "/".join("%.2f" % (abs(got[i] / N - f) * 100) for i, f in enumerate((0.8, 0.1, 0.1)))))
+    print("\n[test] exact 8b:1b:1b, per-class uniform, no group leakage, complete pools: PASS")
+
+
+if __name__ == "__main__":
+    main()