README.md

---
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<n<10K
task_categories:
- text-classification
annotations_creators:
- expert-generated
- machine-generated
language_creators:
- found
source_datasets:
- EmoTweetID
task_ids:
- multi-class-classification
configs:
- config_name: balanced
  default: true
  data_files:
  - split: train
    path: balanced/train.parquet
  - split: valid
    path: balanced/valid.parquet
  - split: test
    path: balanced/test.parquet
- config_name: full
  data_files:
  - split: train
    path: full/train.parquet
- config_name: anger_split
  data_files:
  - split: train
    path: anger_split/train.parquet
- config_name: anger_split_balanced
  data_files:
  - split: train
    path: anger_split_balanced/train.parquet
  - split: valid
    path: anger_split_balanced/valid.parquet
  - split: test
    path: anger_split_balanced/test.parquet
---

# 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 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
trained on them - fold contempt into anger. That loses exactly the distinction that matters when a
system has to tell "you wronged me, put it right" from "you are beneath me".

| class | rows | share | origin |
|---|---|---|---|
| `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 |

## How each class got its label

| source label (EmoTweetID, human) | rows | treatment here |
|---|---|---|
| `joy` | 429 | kept, renamed to Ekman's `enjoyment` |
| `fear` | 395 | kept |
| `disgust` | 355 | kept |
| `sadness` | 303 | kept |
| `surprise` | 286 | kept |
| `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
EmoTweetID did not tag one (its keyword sampling deliberately selected emotional tweets), unlike
GoEmotions - which is why this card has 7 classes where the reference has 8.

## Source

* [EmoTweetID](https://doi.org/10.1016/j.dib.2026.113119) - Nugroho, Bachtiar, Mahmudy, Henry, Isnan,
  Pangestu, Pardamean, *Data in Brief* 68:113119 (2026), [PMC13495581](https://pmc.ncbi.nlm.nih.gov/articles/PMC13495581/).
  2,243 Indonesian X/Twitter posts annotated into Ekman's six basic emotions by three psychology
  students, lexicon-assisted, majority vote, substantial inter-annotator agreement (Fleiss' kappa).
  Files: the labelled CSV (`tweet`, `label`) and its English translation (`tweet_en`) from
  [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. 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

> **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_<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`), 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 <namespace>/<name>        # 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.