README.md

---
language:
  - bn
  - en
license: cc-by-nc-sa-4.0
annotations_creators:
  - machine-generated
language_creators:
  - machine-generated
  - expert-generated
multilinguality:
  - multilingual
size_categories:
  - 1K<n<10K
source_datasets:
  - original
task_categories:
  - text-classification
task_ids:
  - intent-classification
  - multi-class-classification
pretty_name: Badhon/BanglaBankingIntent
tags:
  - bangla
  - bengali
  - banglish
  - code-mixing
  - transliteration
  - low-resource
  - intent-detection
  - out-of-scope-detection
  - customer-support
  - banking
  - finance
  - synthetic
configs:
  - config_name: default
    data_files:
      - split: train
        path: train.csv
      - split: validation
        path: val.csv
      - split: test
        path: test.csv
dataset_info:
  features:
    - name: text
      dtype: string
    - name: intent
      dtype:
        class_label:
          names:
            '0': greeting
            '1': goodbye
            '2': thanks
            '3': balance_inquiry
            '4': transaction_history
            '5': fund_transfer
            '6': transaction_failed
            '7': card_issue
            '8': loan_inquiry
            '9': account_opening
            '10': account_issue
            '11': login_issue
            '12': branch_atm_info
            '13': charges_fees
            '14': complaint
            '15': agent_request
            '16': out_of_scope
    - name: script
      dtype: string
  splits:
    - name: train
      num_examples: 4277
    - name: validation
      num_examples: 692
    - name: test
      num_examples: 718
---

# Bangla / English / Banglish Banking Intent Classification

A 17-intent classification dataset for a Bangladeshi retail-banking chatbot,
covering the three ways customers actually write:

| script | example | rows |
|---|---|---|
| `bn` Bengali script | `আমার ব্যালেন্স কত` | 1,817 |
| `en` English | `what is my balance` | 1,817 |
| `bl` Banglish (romanized Bangla) | `amar balance koto` | 1,700 |
| `mx` code-mixed mid-sentence | `taka katlo kintu transfer hoyni নাই` | 353 |

**5,687 rows, 17 intents** — including an explicit `out_of_scope` reject class.

> ⚠️ **This is synthetic data.** It is a bootstrap for getting a CPU intent
> classifier off the ground when you have no logs yet, not a substitute for real
> ones. See [Limitations](#limitations-and-bias) before you rely on a number
> measured here. The companion hand-written holdout is the honest signal.

## Dataset structure

### Fields

| field | type | description |
|---|---|---|
| `text` | `string` | the user message, 1–16 words |
| `intent` | `class_label` | one of 17 labels (below) |
| `script` | `string` | `bn` \| `en` \| `bl` \| `mx` — writing system, useful for per-script error analysis |

`script` is metadata, not a training feature. It exists so you can report
accuracy per writing system, which is where the interesting failures hide —
Banglish and code-mixed rows are consistently harder than either monolingual
form.

### Splits

```python
from datasets import load_dataset
ds = load_dataset("Badhon/BanglaBankingIntent")
# DatasetDict({train: 4277, validation: 692, test: 718})
```

**The splits are disjoint at template level, not row level.** Each template is
assigned to exactly one split *before* it expands into surface rows, so no test
row is a respelling, recasing, code-mixing or politeness-affixed variant of a
training row. Leakage is also blocked on a punctuation/case/affix-insensitive
canonical form, so `balance` in train does not permit `Balance??` in test.

A dataset built the naive way — expand first, split rows randomly — reports
~99.9% test accuracy that is pure memorization. Under template-level splitting
the shipped transformer scores **0.715** on `test` and **0.518** on the
hand-written holdout. That gap is the honest measure of how much of the test
score is convention-following rather than generalization.

### Label distribution

| intent | train | val | test | total | description |
|---|---|---|---|---|---|
| `fund_transfer` | 325 | 44 | 49 | 418 | wants to move money now — send/transfer/pay |
| `balance_inquiry` | 305 | 37 | 44 | 386 | a read of current state — "how much is in there" |
| `card_issue` | 291 | 48 | 46 | 385 | card blocked, lost, stolen, PIN, activation, expiry |
| `loan_inquiry` | 295 | 43 | 47 | 385 | loans, EMI, interest rates, eligibility, repayment |
| `branch_atm_info` | 268 | 60 | 49 | 377 | where is a branch/ATM, hours, is it open |
| `transaction_failed` | 280 | 38 | 43 | 361 | a specific payment debited but did not arrive, or was declined |
| `greeting` | 261 | 49 | 47 | 357 | opener, whole message |
| `goodbye` | 264 | 46 | 46 | 356 | sign-off |
| `account_opening` | 249 | 42 | 53 | 344 | wants to open a new account; documents, minimum deposit |
| `transaction_history` | 268 | 35 | 33 | 336 | a read of past events — statements, "last 5 transactions" |
| `thanks` | 230 | 32 | 36 | 298 | gratitude, whole message |
| `complaint` | 221 | 37 | 39 | 297 | grievance with no specific remedy asked |
| `charges_fees` | 217 | 36 | 41 | 294 | maintenance fee, transfer charge, annual fee, excise duty |
| `account_issue` | 207 | 44 | 39 | 290 | an existing account is frozen, dormant, locked, KYC expired |
| `login_issue` | 211 | 38 | 41 | 290 | cannot get into the app — password, OTP, app PIN reset |
| `out_of_scope` | 206 | 34 | 38 | 278 | chitchat, other domains, noise |
| `agent_request` | 179 | 29 | 27 | 235 | escalate to a human |

Roughly balanced by design (per-intent row caps during generation).

### Label boundaries

Several intents share vocabulary (`taka`, `account`, `transaction`) and differ
only in what the user wants done. The tie-breaks used to label consistently,
documented in full in the `domains/banking.py` docstring:

- **`balance_inquiry` vs `transaction_history`** — current state vs past events.
  A question about *one* specific transaction that went wrong is
  `transaction_failed`, not history.
- **`fund_transfer` vs `transaction_failed`** — wants to move money *now* vs the
  money already moved and is missing. The defining feature of
  `transaction_failed` is a broken transaction, not a general grievance.
- **`login_issue` vs `card_issue`** — app/internet-banking access (password, OTP,
  app PIN) vs the physical/virtual card (including *card* PIN). This split is
  deliberate and is the most common labeling mistake in this set.
- **`account_issue` vs `account_opening`** — an existing account is broken vs
  wants a new one.
- **`complaint`** — angry with no actionable request that fits above. If the user
  is angry *and* names a failed transfer, label `transaction_failed`: the
  actionable intent wins.

Rule that overrides all of the above: **a greeting glued onto a real request is
labeled by the request, never the greeting.** `assalamu alaikum vai amar card
block hoye gese` is `card_issue`.

### `out_of_scope`

The reject class, and the reason to prefer this dataset over a 16-intent one. A
closed-set softmax must put ~1.0 of its probability mass on *some* label, so a
model without a reject class answers `tomar basa kothay?` as a confident
`complaint`. No confidence threshold fixes that, because the model was never
given a way to express "none of the above".

Coverage spans bot-directed chitchat (`tumi ki manush`), other industries and
domains (weather, cricket, prayer times, politics), general-assistant requests
(write a poem, do this maths), and meta/noise (`test test`, keyboard mash,
emoji-only, `hmm`).

Deliberately **not** `out_of_scope`: profanity aimed at the bank (that is
`complaint` — actionable, route to a human), and vague-but-financial fragments
(`koto ache?` is `balance_inquiry`).

The class is capped at the same size as the others on purpose. An oversized
reject class raises the false-fallback rate — real customers routed to "I don't
understand" — which costs more in production than a missed rejection.

## Evaluation

**Do not report the `test` split alone.** It is template-disjoint from train,
which makes it honest, but it still only answers "can you generalize across our
own templates". Pair it with the hand-written banking holdout (156 items, not
shipped as a split because it must never be trained on):

```bash
INTENT_DOMAIN=banking python transformer_model/eval_holdout.py
```

Every holdout item is written by hand to share no template with the generated
data, and the generator enforces this: any generated row matching a holdout item
is dropped at source, so promoting a good holdout sentence into a template
cannot silently contaminate training.

For a reject class, accuracy is the wrong headline. Track the two numbers that
trade off against each other:

- **OOS recall** — off-domain inputs correctly routed to fallback
- **false-fallback rate** — in-scope inputs wrongly sent to fallback (the real
  cost; this is what annoys customers)

A model at 99% on the 16 business intents with 0% OOS recall is worse in
production than one a point lower with 85%.

## How it was built

Templates → bounded slot fills → sampled surface variants, with the split
assigned at step one. Stages that exist because real messages have properties
templates don't:

- **Code-mixing** — a Banglish→Bengali lexicon flips a random 40–80% subset of
  words mid-sentence. Latin loanwords (`account`, `balance`, `transfer`, `card`,
  `OTP`, `EMI`) are deliberately excluded from the lexicon: Bangladeshi users
  type those in Latin even inside an otherwise-Bengali sentence, and that
  asymmetry is the pattern worth learning.
- **Phonetic noise** — Banglish misspelling is sound-level substitution
  (`bh↔v`, `sh↔s`, `ph↔f`), dropped vowels (`kemon`→`kmon`) and word-boundary
  drift (`koto taka`→`kototaka`), not random character swaps.
- **Fragments** — context-free follow-up turns (`koto?`, `kothay`, `hoyni`)
  where the intent rides on 1–4 words.
- **Glued social openers** — `assalamu alaikum vai amar balance koto`, labelled
  `balance_inquiry`.
- **Rambling preambles** — a sentence of context before the actual question, so
  the model sees inputs longer than 8 words.

Reproduce with `python generate_domain_data.py banking` (seeded, deterministic).
Adding a template to one intent does not reshuffle any other intent's split
assignment.

## Limitations and bias

Please read this section before using the dataset as a benchmark.

- **Synthetic.** Generated from hand-written templates, not collected from users.
  It encodes one author's model of how customers write, including its blind
  spots. A model at 0.71 here is not a model at 0.71 in production.
- **Short inputs.** Mean under 5 words. Models trained here will be poorly
  calibrated on long multi-paragraph messages.
- **Under-represented code-mixing.** 353 `mx` rows (6%) versus a real inbox
  where code-mixing is far more common than that. It is seasoning here, not a
  first-class script.
- **Bangladesh-specific.** Payment wallets (bKash, Nagad, Rocket), local bank
  and branch vocabulary, cities, festivals (Eid, Puja), and honorifics (`vai`,
  `apu`) are all local. Indian retail-banking vocabulary is absent entirely.
- **Romanization is not standardized.** Banglish has no orthography. The
  phonetic-variant generator covers a fraction of real spelling space, and its
  substitution rules are hand-picked rather than learned from data.
- **Label noise on the overlapping boundaries.** The tie-breaks above are applied
  consistently by construction, but they are one defensible reading of genuinely
  ambiguous cases. Your product may want them drawn elsewhere.
- **No inter-annotator agreement figure**, because there was one annotator.
- **No PII** — no real account numbers, names, phone numbers or addresses.
  Account and transaction references are made-up strings from a fixed list.

### Intended and out-of-scope uses

**Intended:** bootstrapping a Bangla/Banglish banking intent classifier before
you have logs; benchmarking small CPU models (fastText, distilled transformers)
on code-mixed short text.

**Not intended:** as evidence of production accuracy; as a general Bangla NLP
benchmark; for any high-stakes routing (payments, disputes, fraud, legal)
without a human in the loop and a calibrated reject threshold. Money movement in
particular should never be triggered by this classifier alone.

## Citation

```bibtex
@misc{banglabankingintent,
  title  = {BanglaBankingIntent: Bangla / English / Banglish Banking Intent Classification},
  year   = {2026},
  note   = {Synthetic dataset, 17 intents, template-disjoint splits},
  howpublished = {\url{https://huggingface.co/datasets/Badhon/BanglaBankingIntent}}
}
```

## Licensing

**CC BY-NC-SA 4.0** ([Creative Commons Attribution-NonCommercial-ShareAlike
4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/)).

The content is wholly generated from templates written for this repository, so
there is no upstream corpus license to inherit. What the terms mean in practice:

- **BY** — attribute the source when you use or redistribute it.
- **NC** — **no commercial use.** Training a classifier that serves a commercial
  bank is a commercial use. If this dataset is meant to be deployable inside a
  business, `cc-by-sa-4.0` or `apache-2.0` is the licence you want instead.
- **SA** — derivatives, including modified or extended versions of the data, must
  carry the same licence. Whether a *model* trained on it counts as a derivative
  work is legally unsettled and jurisdiction-dependent.

Add a `LICENSE` file containing the full CC BY-NC-SA 4.0 text alongside this
card; HuggingFace renders the tag either way, but the file is what makes the
grant explicit to anyone who downloads the CSVs on their own.