--- license: cc-by-4.0 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 tags: - emotion - anger - contempt - ekman - universal-emotions - text-classification - tweets - indonesian - weak-labels - laya size_categories: - 1K contempt. ## The two classes the split turns on, in Ekman's words > **anger** "...arises when we are blocked from pursuing a goal and/or treated unfairly. ... The > primary message of anger is, 'Get out of my way!' and communicates anything from mere dissatisfaction > to threats." Triggers: interference, injustice, someone trying to hurt us or a loved one, another > person's anger, betrayal/abandonment/rejection, seeing someone break a law or cultural rule. The > constructive form "focus[es] on the action, not the actor". > **contempt** "...the feeling of dislike for and superiority (usually morally) over another person, > group of people, and/or their actions. ... The basic notion of contempt is: 'I'm better than you *and* > you are lesser than me.'" Its usual trigger is "immoral action by a person or group of people to whom > you feel superior"; it "asserts power or status" and signals "not needing to accomodate or engage". > Unlike disgust it carries that superiority component; unlike anger, "in contempt we don't necessarily > want to remove ourselves from the situation". Operational boundary: **anger wants the obstacle gone; contempt puts the target below the argument.** ## 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 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 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 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 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 | | `row_src` | int32 | row index in EmoTweetID's `Data-Annotated-Tweet-File-RESULT.csv` | ## Configs, splits, sizes 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 | 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** - 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_.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] [SEP] [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`), 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") # 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") # 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 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 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 / # HF upload; needs HF_TOKEN with write scope ``` 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_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 * **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, 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 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. ## Citation ```bibtex @article{NUGROHO2026113119, title = {EmoTweetID: A dataset of Indonesian tweets for emotion classification and word embedding construction}, author = {Kuncahyo Setyo Nugroho and Fitra Abdurrachman Bachtiar and Wayan Firdaus Mahmudy and Matthew Martianus Henry and Mahmud Isnan and Gusti Pangestu and Bens Pardamean}, journal = {Data in Brief}, volume = {68}, pages = {113119}, year = {2026}, doi = {10.1016/j.dib.2026.113119} } ``` ## Licence and ethics CC BY 4.0 (the source dataset's licence), with attribution to EmoTweetID and quoting of the Paul Ekman Group's definitions. The tweets are public posts but are **not** de-identified - handles and self-identifying details can appear inside `text`; EmoTweetID removed retweets, sensitive replies and duplicates, but re-publishing raw text carries residual privacy risk. Nothing here is a judgement about the people in the tweets: do not use these labels to infer anything about an individual.