Scicom-intl/Synthetic-User-Turn-TTS

Synthetic Malaysian Telco Call-Centre Speech

Synthetic Malaysian call-centre customer utterances, as text and as speech.

The text is fully synthetic dialogue styled after real Malaysian ISP/telco ("Unifi") call-centre recordings, containing no real customer data. The audio subsets take customer (user) turns and voice them with a voice-conversion model, keeping only clips an ASR round-trip confirms are accurate.

Subsets

subset	rows	content
default	4,260	source dialogues, text only (first batch, 213 topics)
dialogues_v2	7,780	source dialogues, text only — expanded batch, 389 topics
synthetic	5,102	generated speech, voices from Multilingual-TTS-DNSMOS
synthetic_podcast	growing	generated speech, voices from Clean-Podcast
dialogues_normalized	12,040	default + dialogues_v2 merged, plus a spoken-form column
dialogue_calls	growing	multi-turn call clips — both roles, two voices, silence, ≤30 s
hard_entities*	1,970	entity-dense dialogues (IC/phone/case/RM) — see below
hard_entities*_texts	growing	speech for those, both roles, one clip per turn

from datasets import load_dataset

text  = load_dataset("Scicom-intl/Synthetic-User-Turn-TTS", "dialogues_v2", split="train")
audio = load_dataset("Scicom-intl/Synthetic-User-Turn-TTS", "synthetic", split="train")

default — source dialogues (text)

Short call snippets, one row per dialogue:

• topic (string): the call-centre topic seeded for this dialogue
• category (string): one of 15 call-centre categories (billing, technical support, installation, account management, complaints, etc.)
• language (string): english, malay, or chinese — the dominant language of the call (Malay and Chinese rows naturally code-switch with English technical/business terms, matching real Malaysian call-centre register)
• num_turns (int, 1-3): number of assistant+user exchanges
• messages (list of {role, content}): alternating assistant (call-centre agent) and user (customer) turns, always starting with assistant (agent opens an inbound call). len(messages) == 2 * num_turns.

Seeded from 213 call-centre topics across 15 categories. For each topic, 20 dialogues were generated with a language split of 7 english / 12 malay / 1 chinese, matching the real observed language distribution of the source call-centre (~35% English, ~60% Malay, ~5% Chinese). Names, account/phone/IC numbers, dates, and amounts are all fictitious and vary across dialogues.

dialogues_v2 — expanded source dialogues (text)

Same schema and generation recipe as default, scaled up: 389 call-centre topics across the same 15 categories (213 from default plus 176 new ones — no topic overlap between the two), still 20 dialogues per topic at the 7 english / 12 malay / 1 chinese split. id is a fresh UUID per row and not comparable across subsets.

Deduplicated customer-turn (role=="user") text extracted from this subset yields 14,472 unique utterances (up from 7,667 in default), the pool used to seed further synthetic_podcast-style audio generation.

Audio subsets

Both audio subsets share a schema. One row is one verified clip:

column	type	description
audio	audio	24 kHz mono wav
text	string	the target text the clip was asked to say
transcription	string	what STT heard back from the generated audio
wer, cer	float	error rate of transcription against text
duration	float	clip length in seconds
takes	int	scored attempts spent before this one was accepted
temperature	float	sampling temperature of the accepted take
speaker, speaker_config	string	reference voice and its source corpus
speaker_ovrl	float	DNSMOS OVRL of the reference (null for podcast voices)
reference_text	string	transcription of the reference audio
reference_duration	float	reference prompt length in seconds
sample_rate	int	24000

How clips are produced

Each target text is synthesised by a voice-conversion model given a reference recording plus that recording's transcription. The result is transcribed back with Whisper and scored WER/CER against the target. A clip that misses the gate is regenerated at a different temperature, up to 10 scored takes; only clips that pass are kept.

Acceptance gate: WER ≤ 0.05 and CER ≤ 0.03. Scoring normalises case, punctuation and hesitation spellings (erm/um/uh are treated as equivalent), and scores Chinese per-character rather than per-word, since whitespace tokenisation would make a whole Chinese sentence a single token.

Roughly one generated take in four is unusable, so best-of-N rather than single-shot generation is what makes the gate meaningful.

synthetic — DNSMOS voices

5,102 clips, 14.68 h. Text is customer turns from Scicom-intl/Malaysian-Call-Center-Language-Switching (Malay/English/Chinese conversations; Tamil excluded).

Voices are sampled from Scicom-intl/Multilingual-TTS-DNSMOS, filtered to DNSMOS OVRL >= 4.0, with quota spread across source corpora by max-min fair share so no single corpus dominates.

• every clip has a distinct speaker — 5,102 unique (config, speaker) voices across 77 source corpora
• mean WER 0.0108, mean CER 0.0060
• 63.4% of clips score exactly zero on both
• mean 3.78 takes per accepted clip

The reference voices are overwhelmingly not Malaysian — Turkish, Hausa, Azerbaijani, Thai, Catalan, Malayalam, Persian, Japanese and more. Cross-lingual voice conversion holds up well here: Chinese targets scored a higher accept rate than English ones.

synthetic_podcast — podcast voices

Text is customer turns from this dataset's own default subset. Voices are 15-second chunks from Scicom-intl/Clean-Podcast (Malaysian/Singaporean podcasts), using the STT transcriptions published in that dataset's transcription subset as the reference text.

Speakers repeat in this subset. Clean-Podcast has roughly 676 distinct source videos, so a corpus of thousands of clips cannot give each one its own voice. Every clip uses a distinct reference segment, but each voice recurs on the order of ten times. Use synthetic if you need one unique speaker per clip.

The hard_entities family — entity-dense calls

A separate track from the subsets above, built for one specific failure: numbers and names. A finetune trained on the generic subsets still mis-hears the content that actually decides a call — measured errors like 102105 -> 2105, 950 -> 150, Credit card -> Kedipa. Those turns are exactly the ones a transcript-accuracy gate throws away, so they were scarce in the corpus precisely because they are hard.

Every dialogue here is written to carry an IC number, a mobile number, a case/reference number, and usually an RM amount, woven into natural conversation rather than listed.

Text subsets

subset	rows	messages	language mix
hard_entities	670	5,613	60% ms / 35% en / 5% zh
hard_entities_normalized	670	5,613	+ spoken-form column
hard_entities_v2	1,300	10,179	65% zh / 18% ms / 17% en
hard_entities_v2_normalized	1,300	10,179	+ spoken-form column

hard_entities and hard_entities_v2 are different dialogue sets, not versions of each other — v2 is a later generation round written at a deliberately Chinese-heavy mix, because Chinese was only 5% of the first round. Neither is a superset of the other; hard_entities_v2 does not contain hard_entities. Load both if you want all 1,970 dialogues.

Schema matches default (topic, category, language, num_turns, messages), across the same 15 call-centre categories. The _normalized variants add normalized_messages on the same terms as dialogues_normalized: messages stays the written ASR label, normalized_messages is the spoken form fed to a TTS.

Note num_turns counts messages in the v2 subsets and user turns in hard_entities. Prefer len(messages).

Audio subsets

subset	rows	hours	source text
hard_entities_texts	3,463	—	hard_entities_normalized
hard_entities_v2_texts	8,346	22.6	hard_entities_v2_normalized
hard_entities_calls	7	—	multi-turn calls, as dialogue_calls

hard_entities_v2_texts is 64% Chinese (5,311 zh / 1,562 en / 1,473 ms), roughly even across roles (4,308 assistant / 4,038 user), mean WER 0.0160 / CER 0.0110, and 100% of clips transcribed their digit sequences exactly. 738 of the 9,084 source texts (8.1%) produced no accepted clip and are simply absent.

One clip per unique turn, deduplicated by (language, text), and both roles are voiced — agent turns as well as customer turns. Each clip draws its own distinct reference voice.

The two *_texts subsets are effectively disjoint: they are built from the two different dialogue sets, and share exactly 1 utterance out of 9,084 (a generic closing line). They can be concatenated without meaningful duplication.

column	type	description
audio	audio	24 kHz mono wav, unprocessed
text	string	written form — the ASR label
spoken_text	string	spoken form actually fed to the TTS
role	string	user or assistant
wer, cer	float	of the accepted take
digits_ok	bool	the digit sequence was transcribed exactly
voice, voice_config	string	reference voice and its source corpus
topic, category, language	string	inherited from the source dialogue
source_dialogue_id	string	row id of the dialogue the turn came from
attempt, duration, sample_rate		take index, seconds, 24000

Why these need different scoring

Plain WER/CER cannot gate this content, and three fixes are applied:

• Digit runs are masked out of WER/CER. ASR regroups digits freely — 012-1579129, 012 1579 129 and 0121579129 are the same number, but a dash is a token boundary, so a correct readback scored a large false WER purely from grouping.
• digits_ok gates the digits exactly instead. A wrong digit is nearly free in CER — 880214-10-5566 heard as 8088214-10-5566 scores CER 0.043 and would sail through a 0.05 gate, while being precisely the error that breaks an IVR.
• The ASR hypothesis is LLM-normalized before re-scoring. The audio says the spoken form; Whisper writes back whatever its convention prefers, usually digits. On a failing take the hypothesis is rewritten into spoken form through the same prompt the targets used, so both sides are compared in one representation. Folding digit sequences alone would not cover money, dates or percentages: RM1,250.50 and "seribu dua ratus lima puluh ringgit lima puluh sen" share no digits at all.

Accepted clips satisfy WER ≤ 0.10, CER ≤ 0.05, and an exact digit match.

Caveats

• Accepted does not mean flawless. The gate bounds ASR disagreement, not perceptual quality. Spot-check before training.
• Clipping. Some clips peak at full scale (32767). Apply headroom if that matters.
• The WER floor is orthographic. Text containing unusual proper nouns or long digit strings (IC numbers, account numbers) cannot reach WER 0, because ASR spells names and formats numbers its own way regardless of whether the audio is correct. Such texts are under-represented in the audio subsets relative to the source text, since they are the ones most likely to be rejected. cer is the more reliable quality signal for them.
• Rejected text is not published. ~26% of candidate texts produced no accepted clip, so the audio subsets are not a complete rendering of the source text.

Licensing and provenance

Dialogue text is synthetic and contains no real customer data. Reference voices come from the upstream corpora linked above and retain their original licences.

dialogues_normalized — source dialogues with a spoken form (text)

default and dialogues_v2 merged into one table (12,040 rows, source_config records which they came from), with one added column:

• normalized_messages (list of {role, content}): every turn rewritten into the exact words a speaker would say — 880214-10-5566 becomes "eight eight zero two one four dash one zero dash five five six six", RM1,250.50 becomes "seribu dua ratus lima puluh ringgit lima puluh sen". Same shape and ordering as messages.

messages remains the written form and is the ASR label; normalized_messages is what a TTS should be fed. Splitting the two is what lets IC/phone/account turns into a speech corpus at all: a raw 880214-10-5566 is neither speakable by a TTS nor verifiable by an ASR round-trip, so pipelines gated on transcript accuracy had been dropping those turns — exactly the content an IVR most needs to get right.

Normalization is language-aware (a bare number carries no language, and would otherwise come back in Chinese numerals inside a Malay call). 8,247 turns were rewritten; the rest had nothing to normalize and pass through unchanged. Every rewrite is checked for dropped words, leftover digits, absurd length change and script drift — a rewrite that fails keeps the original text, so the corpus is never silently corrupted.

dialogue_calls — multi-turn call clips (speech)

Whole assistant+user exchanges rendered into a single clip, rather than one clip per isolated turn.

• audio: 24 kHz mono, unprocessed — no resampling, no loudness normalization, no band-limiting. Channel effects are augmentation and belong to whoever trains on this.
• text: the written transcript of the turns in the clip (the ASR label)
• spoken_text: the spoken form that was fed to the TTS
• original_speaker_assistant / original_speaker_user: <config>/<speaker> of the two reference voices — always two different speakers, from two different source corpora
• turns: per-turn detail (role, text, WER/CER of the accepted take, duration, voice)
• turns_used / turns_total, window_start: which slice of the dialogue was rendered
• onset, gaps, tail, speech_ratio, duration: the silence layout

Every clip is ≤ 30 s (whisper's feature window) and contains realistic silence: a randomized late onset, inter-turn gaps and a tail, filled with room tone rather than digital zeros. This is deliberate — models finetuned only on tightly-cut clips answer long non-speech with invented text, and real call recordings are fixed-length windows with sparse speech (measured on a real call-centre test set: median 30 s duration, 26 % of clips under 50 % speech, 24 % with a silence gap over 2 s).

Turn selection is content-aware: the window kept is the one carrying the most number/entity content that fits the 30 s budget, not simply the first turns — an account or IC readback usually sits in a later turn, and a prefix cut would discard it.