script	example	rows
`bn` Bengali script	`আমার অর্ডার কোথায়`	2,227
`en` English	`where is my order`	2,245
`bl` Banglish (romanized Bangla)	`amar order kothay`	2,137
`mx` code-mixed mid-sentence	`taka katlo kintu confirmation ashe নাই`	418

7,027 rows, 1,566 distinct templates, 15 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 15 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/BanglaEComIntent")
# DatasetDict({train: 5404, validation: 817, test: 806})

split	rows	templates
`train`	5,404	1,200
`validation`	817	183
`test`	806	183

The splits are disjoint at template level, not row level. This is the most important property of the dataset and the thing most synthetic intent corpora get wrong. 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 coupon in train does not permit Coupon?? 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 same fastText model scores 0.754, which matches its score on unseen hand-written sentences (0.730). Those two numbers agreeing is what tells you the benchmark is measuring generalization.

Label distribution

intent	train	val	test	total	description
`product_search`	629	77	86	792	discovery — "what do you have"
`product_availability`	428	67	74	569	a specific item/size/colour in stock?
`shipping_delivery`	393	60	48	501	delivery policy, charge, coverage, timing
`price_inquiry`	393	51	48	492	what does it cost
`order_status`	364	49	51	464	where is my order
`complaint`	349	52	52	453	grievance with no specific remedy asked
`payment_issue`	357	43	48	448	failed/duplicate/pending transaction
`order_cancel`	330	67	51	448	cancel before receipt
`return_refund`	331	47	52	430	return/exchange/refund after receipt
`out_of_scope`	311	62	56	429	chitchat, other domains, noise
`agent_request`	327	51	51	429	escalate to a human
`discount_offer`	321	54	52	427	does a discount mechanism exist
`goodbye`	303	46	43	392	sign-off
`greeting`	297	44	46	387	opener, whole message
`thanks`	271	47	48	366	gratitude, whole message

Roughly balanced by design (per-intent row caps during generation). Several of these boundaries genuinely overlap — order_status/shipping_delivery, complaint/return_refund, price_inquiry/discount_offer, product_search/product_availability — and the tie-break rules used to label consistently are documented in LABELING.md. Read it before adding data or disputing a label.

`out_of_scope`

The reject class, and the reason to prefer this dataset over a 14-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? ("where do you live?") 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 four distinct kinds of off-domain input, because a model trained only on chitchat negatives still answers confidently on gibberish:

Bot-directed chitchat — tumi ki manush, tomake ke baniyeche, what model are you
Other domains — weather, cricket, prayer times, exchange rates, politics, jobs
General-assistant requests — write a poem, tell a joke, teach me English, do this maths
Meta and noise — test test, sent by mistake, keyboard mash, emoji-only, digit-only, hmm

Deliberately not out_of_scope: profanity aimed at the shop (that is complaint — actionable, route to a human), and vague-but-commercial fragments (ache? is product_availability).

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 holdout in shared/holdout.py (330 items, not shipped as a split because it must never be trained on):

DEV_HOLDOUT (165) — tune against this: thresholds, hyperparameters, model selection
TEST_HOLDOUT (165) — read once, when you are done

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.

Reference numbers, quantized fastText (6 MB, ~0.1 ms/input on CPU), with hyperparameters not retuned for this version of the data:

metric	value
`test` accuracy	0.754
holdout accuracy (330)	0.730
macro F1 (test)	0.749
`out_of_scope` recall	0.455
false-fallback rate	3–4 / 154

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 14 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 (ei t-shirt tar price koto → এই t-shirt tar price koto). Latin loanwords (order, delivery, payment, stock, discount) 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 dam→kotodam), not random character swaps.
Fragments — context-free follow-up turns (koto?, ache?, kothay) where the intent rides on 1–4 words with no product noun present.
Glued social openers — assalamu alaikum vai ei saree tar dam koto, labelled price_inquiry. The label always follows the actionable request, never the greeting.
Rambling preambles — a sentence of context before the actual question, so the model sees inputs longer than 8 words.

Reproduce with python generate_data.py (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 ~1,570 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.75 here is not a model at 0.75 in production.
Vocabulary ceiling. ~2,400 unique tokens. Product nouns come from a 10-item list; brand names, regional dialect, and domain-specific jargon are absent. Expect degradation on any catalogue that isn't generic apparel and electronics.
Short inputs. Mean 4.7 words, 95th percentile 8, max 16. Models trained here will be poorly calibrated on long multi-paragraph messages.
Under-represented code-mixing. 418 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), couriers, cities, festivals (Eid, Puja), and honorifics (vai, apu) are all local. West Bengal Bangla differs in vocabulary and register; Indian payment and courier 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 LABELING.md tie-breaks 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 order IDs, names, phone numbers or addresses. Order IDs are made-up strings from a fixed list.

Intended and out-of-scope uses

Intended: bootstrapping a Bangla/Banglish intent classifier before you have logs; benchmarking small CPU models (fastText, distilled transformers) on code-mixed short text; a worked example of template-level splitting and out-of-scope class construction.

Not intended: as evidence of production accuracy; as a general Bangla NLP benchmark; for any high-stakes routing (payments, disputes, legal) without a human in the loop and a calibrated reject threshold.

Citation

@misc{banglaecomintent,
  title  = {BanglaEComIntent: Bangla / English / Banglish E-commerce Intent Classification},
  year   = {2026},
  note   = {Synthetic dataset, 15 intents, template-disjoint splits},
  howpublished = {\url{https://huggingface.co/datasets/Badhon/BanglaEComIntent}}
}

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. This is the clause to notice: training a classifier that serves a commercial storefront 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.

Downloads last month: -

Total file size:

417 kB