---
license: [apache-2.0, cc-by-4.0, cc-by-sa-4.0, other]
language: [tr, en]
task_categories: [question-answering]
tags: [long-context, aggregation, turkish, benchmark, oolong, cross-lingual]
configs:
  - config_name: tr_intent
    data_files:
      - split: test
        path: tr_intent/questions.jsonl
  - config_name: en_intent
    data_files:
      - split: test
        path: en_intent/questions.jsonl
  - config_name: tr_intent_paired
    data_files:
      - split: test
        path: tr_intent_paired/questions.jsonl
  - config_name: en_intent_paired
    data_files:
      - split: test
        path: en_intent_paired/questions.jsonl
  - config_name: vitamins_tr
    data_files:
      - split: test
        path: vitamins_tr/questions.jsonl
  - config_name: musteri_tr
    data_files:
      - split: test
        path: musteri_tr/questions.jsonl
  - config_name: marc_en
    data_files:
      - split: test
        path: marc_en/questions.jsonl
  - config_name: amazon_hpc_en
    data_files:
      - split: test
        path: amazon_hpc_en/questions.jsonl
  - config_name: sikayet_tr
    data_files:
      - split: test
        path: sikayet_tr/questions.jsonl
  - config_name: interpress_tr
    data_files:
      - split: test
        path: interpress_tr/questions.jsonl
  - config_name: sinema_tr
    data_files:
      - split: test
        path: sinema_tr/questions.jsonl
---

# TR-OOLONG

A long-context **aggregation** benchmark for Turkish, with English counterparts
built by the same pipeline. Each document joins thousands of real records
(reviews, complaints, news articles, voice commands) into one text of 36K to 1M
tokens, and each question asks about the whole collection:

```
Bu kayıtlarda hangisi daha çok: 'turizm' etiketli kayıtlar mı,
'magazin' etiketli kayıtlar mı?                              -> magazin  (44 vs 41 of 266)
Bu kayıtlarda kaç tane 'ulaşım' etiketli kayıt var?          -> 166
```

The label of a record is never written in the text, so a model has to decide
what each record is about and then count. The core questions (the first
example) compare two categories whose counts are so close that neither
sampling part of the document nor searching for the relevant records answers
them. Every answer is computed from the
source dataset's own labels, twice, by independent code. The construction
follows [OOLONG](https://arxiv.org/abs/2511.02817) (Bertsch et al., 2025).

Built with [`tr-oolong`](https://github.com/yigitates17/tr-oolong) v0.10.0. Developed at the Institute for
Data Science & Artificial Intelligence (DSAI), Boğaziçi University, as MSc
thesis work. Full details: `DATACARD.md` in this repository.

## At a glance

**11 subsets · 347 documents · 2,362 questions · 102.5M tokens · 7 question types**

| subset | lang | classes | docs | questions | shortest | longest | max records in one doc |
|---|---|---:|---:|---:|---:|---:|---:|
| `sikayet_tr` | tr | **29** | 49 | 366 | 99,861 | 1,016,268 | 10,000 |
| `interpress_tr` | tr | **16** | 43 | 337 | 99,091 | 998,305 | 2,941 |
| `amazon_hpc_en` | en | 3 | 43 | 237 | 98,426 | 987,208 | 17,087 |
| `sinema_tr` | tr | 3 | 38 | 212 | 99,176 | 720,375 | 6,000 |
| `marc_en` | en | 3 | 38 | 216 | 98,244 | 522,220 | 12,000 |
| `vitamins_tr` | tr | 3 | 38 | 187 | 99,223 | 496,474 | 12,946 |
| `musteri_tr` | tr | 3 | 38 | 213 | 88,854 | 496,144 | 13,825 |
| `tr_intent` | tr | **48** | 10 | 139 | 49,981 | 99,998 | 6,169 |
| `en_intent` | en | **48** | 10 | 133 | 49,921 | 99,871 | 8,122 |
| `tr_intent_paired` | tr | **48** | 20 | 161 | 47,629 | 99,057 | 6,000 |
| `en_intent_paired` | en | **48** | 20 | 161 | 36,250 | 75,187 | 6,000 |

Lengths are tokens under `Qwen/Qwen3-8B`. `classes` is the number of labels.

**Question types and roles.** Every question has a `role`:

| role | question types | questions | what it shows |
|---|---|---:|---|
| `core` | `close_comparison`: which are there more of, A or B? (both frequent, told apart from the text, counts very close) | 309 | that the model read and judged the whole document |
| `retrieval` | `count` with `"rare": true` (answer 5 to 30) | 237 | that it can find a few records by meaning |
| `control` | `count` 587, `proportion` 483, `label_vs_label` 299, `most_common` 156, `least_common` 147, `second_most` 144 | 1,816 | that it can classify the records at all |

**Turkish/English pairs.** Compare languages within a pair, never by totals
(three subsets are Turkish only). `tr_intent_paired` and `en_intent_paired`
contain the same utterances (MASSIVE is a human translation) in the same order,
so all 161 questions, 41 of them core, are identical in both languages.
`tr_intent`/`en_intent` match on token budget instead. `musteri_tr`/`marc_en`
and `vitamins_tr`/`amazon_hpc_en` are different corpora with the same task;
their core documents are built with identical sizes and identical
positive/negative counts, so their 18 core questions each are identical too.
In total 77 core questions are identical across the two languages.
`sikayet_tr`, `interpress_tr` and `sinema_tr` are Turkish only.

### Why the Turkish intent questions use English label names

In `tr_intent` and `tr_intent_paired` the question is Turkish but the label is
MASSIVE's English identifier (`transport_taxi`, `play_music`). Translating the
labels would put the answer back into the text: Turkish is verb-final, so a
label like `alarm_kur` appears word for word in utterances such as *"iki saat
sonrasına alarm kur"*. On all 15,075 utterances, records containing their own
label: English identifiers (shipped) 0.00%, Turkish imperative (`müzik_çal`)
3.13%, Turkish dictionary form (`müzik_çalmak`) 0.14%. The Turkish is in the
text being classified; the label only names the bucket.

## Relation to OOLONG

| | OOLONG | TR-OOLONG |
|---|---|---|
| languages | English | Turkish, with English counterparts built the same way |
| document length | 1K to 4M tokens (synthetic split) | 36K to 1M tokens |
| labels per dataset | 2 to 10 | 3, 10, 16, 29, 48 |
| narrowing to a subset | to users or months printed on every record | none |
| questions over dates | yes, its hardest group | none yet (`interpress_tr` has dates) |
| same question, same answer in two languages | no | yes (`*_intent_paired`) |
| numeric score | `partial` (0.75 per unit of error) | `partial`, plus `relative` for large answers |
| questions that resist sampling and search | none found | 309 close comparisons |
| published shortcut checks | none | yes, in the GitHub repository |

OOLONG's construction code was not released; this is an independent
implementation from the paper. OOLONG narrows questions to listed users or a
month, both printed on every record, so a string search finds the relevant
records: for user-narrowed questions it reads a median of 0.8% of the document
and gets the exact answer 99% of the time. Its whole-document comparisons have a
median gap of 38% between the two counts, so sampling answers them.

## Loading and scoring

```python
from datasets import load_dataset
qs = load_dataset("yigitates17/tr-oolong", "sikayet_tr", split="test")
```

- **Join and pool on `uid`.** `id` is unique only inside one subset.
- Give the model only the `haystack` text and the `question`.
- Score with `src/scoring.py` from the GitHub repository. It returns `exact`,
  `partial` (OOLONG's `0.75 ** |error|`), `relative` (`1 - |error| / answer`)
  and `primary`, the one to report: `exact` for word answers (all core
  questions), `partial` for rare-label counts, `relative` for other numbers.
- Report the `primary` score per role, never pooled, and state how the model
  saw the document (one prompt, or an agent with code tools that can sample or
  search it).

## Files

- `questions.jsonl`: `uid`, `dataset`, `id`, `haystack_uid`, `haystack_id`,
  `language`, `target_tokens`, `kind`, `label` / `candidates` / `label_a` /
  `label_b`, `unit`, `answer`, `answer_key`, `rare`, `question`, `role`,
  `core_document`.
- `haystacks.jsonl` (where the licence allows): `uid`, `haystack_id`,
  `haystack`, plus build metadata.
- `manifest.json`: seed, config, source hash, tokenizer, per-document lengths.

## Subsets and licences

Each subset keeps the licence of its source.

| subset | lang | source | license | text included | questions | note |
|---|---|---|---|---|---|---|
| `tr_intent` | tr | AmazonScience/massive (tr-TR) | `cc-by-4.0` | yes | 139 | MASSIVE is CC-BY-4.0: redistribution of derived data is permitted with attribution and a statement of changes. |
| `en_intent` | en | AmazonScience/massive (en-US) | `cc-by-4.0` | yes | 133 | As above; this is the parallel English twin. |
| `tr_intent_paired` | tr | AmazonScience/massive (tr-TR), record-matched | `cc-by-4.0` | yes | 161 | Record-matched with en_intent_paired: the same utterances in the same order, so all 161 questions (41 core) have the same answer in both languages (word answers via answer_key). |
| `en_intent_paired` | en | AmazonScience/massive (en-US), record-matched | `cc-by-4.0` | yes | 161 | The English half of the record-matched pair. Sized in records, not tokens, so its documents are shorter in tokens than the Turkish half (1.34x under the Qwen3-8B tokenizer). |
| `vitamins_tr` | tr | turkish-nlp-suite/vitamins-supplements-reviews (Vitaminler.com) | `cc-by-sa-4.0` | yes | 187 | CC-BY-SA-4.0 is SHARE-ALIKE: this subset and anything derived from it must stay CC-BY-SA-4.0. Cite Altinok (ACL 2023). |
| `musteri_tr` | tr | turkish-nlp-suite/MusteriYorumlari (Hepsiburada, Trendyol) | `cc-by-sa-4.0` | yes | 213 | CC-BY-SA-4.0 is SHARE-ALIKE: this subset and anything derived from it must stay CC-BY-SA-4.0. Labels are the customer's own 1-5 star rating. |
| `marc_en` | en | SetFit/amazon_reviews_multi_en (Multilingual Amazon Reviews Corpus) | `apache-2.0` | yes | 216 | Apache-2.0: redistribution permitted. The English half of the cleanest pair; labels are the reviewer's own 1-5 star rating. |
| `amazon_hpc_en` | en | McAuley-Lab/Amazon-Reviews-2023 (Health_and_Personal_Care) | `other` | **no** | 237 | Review text is governed by Amazon's Conditions of Use, not by the repository's license. Text withheld; rebuild locally with scripts/health.py + configs/amazon_hpc_en.json. |
| `sikayet_tr` | tr | Kaggle savasy/multiclass-classification-data-for-turkish-tc32 | `other` | **no** | 366 | 29 categories of Turkish consumer complaints. The uploader declares NO license and the text is scraped from a complaints site, so the text is withheld. Rebuild locally with scripts/sikayet_tr.py, which takes the path to a copy of ticaret-yorum.csv downloaded from Kaggle. Three of the original 32 categories were dropped because their names appear in over 30% of their complaints. |
| `interpress_tr` | tr | Interpress Turkish news category corpus, 270k | `other` | **no** | 337 | 16 sections of Turkish news (17 in the source), with daily publication dates. The upstream card declares no license. Text withheld; rebuild locally with scripts/interpress_tr.py, which fetches the archive the Hugging Face loading script points at and verifies its sha256. The Apache header on that loading script covers the SCRIPT, not the data, and must not be cited as the data's license. |
| `sinema_tr` | tr | turkish-nlp-suite/BuyukSinema | `cc-by-sa-4.0` | yes | 212 | Turkish film reviews; sentiment from the reviewer's own 10-point rating (1-4 negative, 5-6 neutral, 7-10 positive; exact ratings cannot be read from the text). Share-alike: anything derived from this subset stays CC-BY-SA-4.0. |

### Subsets without text

- **amazon_hpc_en** (McAuley-Lab/Amazon-Reviews-2023 (Health_and_Personal_Care)) -- Review text is governed by Amazon's Conditions of Use, not by the repository's license. Text withheld; rebuild locally with scripts/health.py + configs/amazon_hpc_en.json.
- **sikayet_tr** (Kaggle savasy/multiclass-classification-data-for-turkish-tc32) -- 29 categories of Turkish consumer complaints. The uploader declares NO license and the text is scraped from a complaints site, so the text is withheld. Rebuild locally with scripts/sikayet_tr.py, which takes the path to a copy of ticaret-yorum.csv downloaded from Kaggle. Three of the original 32 categories were dropped because their names appear in over 30% of their complaints.
- **interpress_tr** (Interpress Turkish news category corpus, 270k) -- 16 sections of Turkish news (17 in the source), with daily publication dates. The upstream card declares no license. Text withheld; rebuild locally with scripts/interpress_tr.py, which fetches the archive the Hugging Face loading script points at and verifies its sha256. The Apache header on that loading script covers the SCRIPT, not the data, and must not be cited as the data's license.

For these, the text is rebuilt locally. The build is deterministic, so the
result is byte-identical:

```bash
git clone https://github.com/yigitates17/tr-oolong && cd tr-oolong
python scripts/<fetch_script>.py
python src/build_tr_oolong.py --config configs/<set>.json --build
```

## What each role measures, and limitations

No model has been run on this benchmark yet. The statements below come from
simulated readers: short programs that are told the true label of every record
they read, so they show what a reading strategy can achieve.

| role | strongest shortcut found | reader of everything |
|---|---|---|
| core | sampling half the document 0.62; the 10% most relevant records by topic search 0.54; guessing 0.50 | 0.86 at 95% labelling accuracy, 0.76 at 90% |
| retrieval | topic search reading 5%: 0.53 under `partial` | depends strongly on labelling accuracy |
| control | sampling 5%: about 0.8 under `relative` | about 0.9 or more |

- Every release also passes four checks: searching the text for label names
  (0 of 856,798 shipped records contain one), always giving the most common
  answer, answering from the source corpus's label shares, and guessing labels
  from record length and punctuation.
- Control questions are not evidence of reading: a 5% sample answers them
  almost as well as the whole document, and under `relative` a longer document
  is not harder.
- 309 questions are core (margin of error about ±0.06 on a model's core score).
  They only compare label pairs that can be told apart from the text (lists in
  the GitHub repository). The 214 from core documents (`core_document: true`),
  built from exact label counts with which label is larger and which is named
  first balanced by design, are the cleaner group: first-named 0.50,
  source-dataset shares 0.50, topic search 0.49. The 95 from ordinary
  documents are slightly exposed (source-dataset shares 0.62, topic search
  0.67). Report the two groups separately.
- Cleaning (v0.10.0): newspaper mastheads, reviews that write their score
  ("7/10", "5 stars") and HTML are removed.
- Wrong labels in the source data decide some close comparisons, so even a
  perfect model scores below 1.0 on core questions (about 0.85 with 5% of
  labels wrong).
- Brand questions (in v0.7.x) were removed in v0.8.0: searching for the printed
  brand answered all of them. The v0.7.x per-question difficulty grades were
  withdrawn as well.
- Questions on one document overlap (337 are a count and a proportion of the
  same thing); treat the document as the unit of evidence.
- Documents of the same subset and length share 20-39% of their records.
- Intent labels: 2.7-9.3% judged wrong on a 150-record check, partly from
  translation, which affects only the Turkish half.
- Every record comes from a public dataset; a model that memorised a dataset's
  labels could label records without reading them (not tested).
- No time-based questions. Lengths use one tokenizer; the Turkish/English token
  ratio on the same sentences ranges from 0.57x to 2.16x across tokenizers.

## Citation

```bibtex
@misc{troolong,
  title  = {TR-OOLONG: A Turkish Long-Context Aggregation Benchmark},
  author = {Ate{\c{s}}, Yi{\u{g}}it},
  year   = {2026},
  note   = {Bo{\u{g}}azi{\c{c}}i University, Institute for Data Science \& Artificial Intelligence},
  url    = {https://github.com/yigitates17/tr-oolong}
}
```

Please also cite OOLONG (Bertsch et al., 2025, arXiv:2511.02817) and the source
corpus of each subset you use.