README.md

metadata

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 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

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):

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

@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).

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.