Polyglot-Lion: Efficient Multilingual ASR for Singapore via Balanced Fine-Tuning of Qwen3-ASR

🎯 Pitch

A 1.7B ASR model matches a 10B specialist system across Singapore's four languages while training for just $81 on a single GPU—233× cheaper than the 128-GPU baseline. The trick? Simply balancing per-language training samples and stripping out language tags forces the model to decode speech implicitly, proving raw scale isn't the only path to multilinguality.

1. Executive Summary

This paper introduces Polyglot-Lion, a family of compact multilingual ASR models for Singapore's four official languages—English, Mandarin, Tamil, and Malay—built by fine-tuning Qwen3-ASR-0.6B and Qwen3-ASR-1.7B exclusively on publicly available corpora. The method's effectiveness hinges on two design choices: a balanced multilingual sampling strategy that upsamples under-represented languages to achieve exactly 25% per-language training coverage (equalizing utterance counts across English, Mandarin, Tamil, and Malay via deterministic two-stage replication and subsampling), and language-agnostic decoding that deliberately omits language-tag conditioning to force the model to identify languages implicitly from acoustic features (no <|en|>, <|zh|>, or similar tokens at training or inference time). Polyglot-Lion-1.7B achieves an average error rate of 14.85 across 12 benchmarks, closely matching MERaLiON-2-10B-ASR (14.32)—a model 6× larger—while requiring 233× lower estimated training cost ( $81 on a single GPU versus$ 18,862 on 128 GPUs) and delivering approximately 20× faster inference (0.10 s/sample versus 2.02 s/sample), establishing that linguistically balanced fine-tuning of moderate-scale pretrained models can yield near-SOTA multilingual ASR at dramatically reduced computational expense only when the base model already encodes some target-language priors—performance on severely under-represented languages like Tamil remains bounded by pretraining exposure.

2. Context and Motivation

The Core Problem: Singapore's Linguistic Landscape Breaks Standard Multilingual ASR

The fundamental problem this paper tackles is deceptively simple to state but exceptionally difficult to solve: how do you build an ASR system that works well across Singapore's four official languages when the languages are wildly imbalanced in available training data, typologically diverse, and constantly intermixed in everyday speech?

Singapore presents what might be the most demanding real-world test for multilingual ASR. The country has four official languages—English, Mandarin Chinese, Tamil, and Malay—that span three entirely different language families (Indo-European, Sino-Tibetan, Dravidian, and Austronesian). These languages don't just coexist in separate social domains; they intermingle within single conversations and even single utterances through pervasive code-switching. The resulting speech, particularly Singlish (Singapore Colloquial English), draws lexical and phonological material from all four languages, creating acoustic patterns that no single-language ASR system was designed to handle.

This linguistic reality creates a direct collision between what practitioners need and what existing systems deliver. Government services, broadcast media monitoring, educational transcription, and customer service operations all require ASR that seamlessly handles any of the four languages without failing when speakers switch between them mid-sentence. Yet the publicly available models that approach this capability are either too expensive to fine-tune (requiring hundreds of GPUs), too large to deploy at scale (10B+ parameters), or accurate only on the high-resource languages (English and Mandarin) while catastrophically failing on Tamil and Malay.

The paper frames this as both a technical challenge and an accessibility problem: can you build a competitive multilingual ASR system for Singapore using only publicly available data and modest compute, or is high-quality coverage of all four languages fundamentally dependent on proprietary data and industrial-scale training budgets?

Why This Problem Matters

The paper's motivation extends beyond publishing a new model checkpoint. The stakes touch on research accessibility, deployment practicality, and linguistic equity.

Research accessibility. The strongest existing specialist system for Singapore multilingual ASR is MERaLiON-2-10B-ASR, a 10B-parameter model trained on approximately 120,000 hours of speech using 128 H100 GPUs for 48 hours. The authors estimate this costs $18,862 in cloud GPU rentals. This price tag fundamentally gates who can participate in Singapore ASR research: academic groups at well-resourced institutions can replicate and build on MERaLiON, but smaller labs, independent researchers, and organizations in Southeast Asia with limited compute budgets are effectively locked out. If competitive multilingual ASR requires six-figure training budgets, the research ecosystem cannot be healthy or diverse. The paper is explicitly motivated by lowering this barrier.

Deployment practicality. Even if a large model like MERaLiON is available as a pretrained checkpoint, deploying it in production imposes ongoing costs. The authors measure MERaLiON's inference latency at approximately 2.02 seconds per sample on a single NVIDIA RTX PRO 4500 GPU—roughly 20× slower than their target of ~0.10 s/sample. For real-time transcription applications (call centers, live captioning, classroom assistance), 2 seconds per utterance is unacceptable. For batch processing at scale (indexing thousands of hours of parliamentary proceedings or media archives), the cost multiplies. The paper therefore pursues not just accuracy parity but deployment efficiency: a model small enough that inference is fast and cheap enough for production use.

Linguistic equity. The paper documents a pattern that should disturb anyone working on multilingual NLP: all eight baseline systems the authors evaluate—ranging from the 0.6B Qwen3-ASR base to the 7B Qwen2.5-Omni—fail catastrophically on Tamil. The unmodified Qwen3-ASR-0.6B achieves 2.74 WER on Librispeech (English) and 2.08 CER on AISHELL-1 (Mandarin) but 121.10 WER on Tamil Common Voice. This is not a small degradation; this is complete system failure. Tamil is an official language of Singapore with roughly 3.5% of the resident population speaking it as their primary household language. A multilingual ASR system that achieves state-of-the-art English and Mandarin performance while being functionally unusable for Tamil is not truly multilingual—it is bilingual with token coverage of two others. The paper is motivated by closing this gap without sacrificing performance on the high-resource languages, treating all four official languages as first-class citizens.

Where Existing Approaches Fall Short

The paper identifies specific limitations across three broad categories of prior systems.

General-purpose multilingual models lack regional depth. Whisper (Radford et al., 2023) and Meta's MMS (Pratap et al., 2024) represent the dominant approach to multilingual ASR: train one enormous model on hundreds of thousands of hours of web-crawled speech covering dozens to thousands of languages. These models achieve impressively broad coverage, but the coverage is shallow for typologically distant, low-resource languages. Whisper-large-v3-turbo—which the paper evaluates as a baseline—achieves 74.50 WER on Tamil Common Voice and 69.56 WER on Tamil SLR127. These error rates mean the model produces roughly three incorrect words for every four spoken, which is not usable for transcription. On Singapore-accented English (NSC), Whisper scores 32.02 WER, confirming that regional accent variation compounds the low-resource problem even for a "high-resource" language. The root cause is implicit in the training data: the web audio used to pretrain Whisper and MMS is heavily skewed toward English and Mandarin (the languages with the most internet content), and even when Tamil or Malay audio is included, it represents a tiny fraction of total training hours. Without explicit mitigation, the model's representational capacity gets allocated almost entirely to the dominant languages.

As the paper puts it:

"Despite their breadth, all of these systems share a common weakness: recognition quality on typologically distant, low-resource languages—such as Tamil and Malay—and on non-native or regional accents remains substantially below that achieved on high-resource languages."

Audio-language models are too large and underperform on regional languages. A newer class of systems—which the paper calls Audio-Language Models (ALMs)—integrates speech encoders with large language model decoders to jointly handle speech recognition and general language understanding. Representative examples include Qwen2.5-Omni (Xu et al., 2025), SeaLLMs-Audio (Liu et al., 2025), and SALMONN (Tang et al., 2024). These models benefit from the rich linguistic priors encoded in their LLM backbones and often achieve strong ASR as a byproduct of general audio understanding capabilities.

However, the paper identifies two critical shortcomings for the Singapore setting. First, scale: the largest ALMs (7B–72B parameters) are expensive to fine-tune and deploy, limiting their practical accessibility. Second, and more damning, Southeast Asian performance is highly variable. The paper's own evaluation reveals this starkly: Qwen2.5-Omni-7B achieves 13.80 WER on Librispeech (competitive) but 252.06 WER on Tamil Common Voice and 303.96 WER on Tamil SLR127—numbers so high the authors exclude them from the computed average because they would "distort cross-system comparison." SeaLLMs-Audio-7B, despite being specifically developed for Southeast Asian languages, scores 126.70 WER on Tamil Common Voice and 94.74 WER on Librispeech (while doing much better on NSC at 9.53), suggesting its training prioritization of conversational speech over read speech introduces its own coverage gaps.

The Qwen3-ASR series (Shi et al., 2026), from which the paper's models are fine-tuned, represents a partial solution: it distills ASR-focused capabilities into smaller checkpoints (0.6B–1.7B) while preserving multilingual coverage. But the paper's baseline evaluation shows that even these models, in their pretrained form, completely fail on Tamil (WER > 120% on Common Voice). The pretraining data imbalance problem is not solved by architectural innovation alone.

Specialist systems are effective but inaccessible. MERaLiON-2-10B-ASR (He et al., 2025) and its predecessor represent the most comprehensive published systems purpose-built for Singapore multilingual ASR. They cover all four official languages within a unified 10B-parameter model, are trained on both proprietary and public corpora (over 120,000 hours), and achieve the strongest aggregate accuracy across all four languages—serving as the paper's primary comparison point and accuracy ceiling.

The problem is not performance; it is reproducibility and accessibility. The paper estimates MERaLiON-2's training at $18,862 on 128 H100 GPUs. This cost is not just a number—it is a structural barrier. It means that:

Iterative development cycles (train, evaluate, adjust hyperparameters, retrain) are prohibitively expensive.
Ablation studies to understand which design choices matter most are infeasible.
Adaptation to new domains, dialects, or low-resource languages within the Southeast Asian region requires resources most regional institutions lack.
Deployment at scale incurs ongoing inference costs that compound with the model's size and latency.

The paper positions itself squarely against this barrier: can you achieve competitive performance without access to proprietary data or industrial compute?

A Deeper Problem: Training Data Imbalance Is Structural, Not Incidental

The paper identifies language imbalance as a pervasive failure mode that existing approaches either ignore or address with methods the authors find unsatisfying.

The raw statistics from the paper's own training corpus (Table 1) illustrate the scale of the problem. Across the 607,839 utterances and 968.83 hours of audio the authors assemble from public sources, English and Mandarin collectively account for approximately 65% of all training hours (248.56 and 259.87 hours, respectively), while Malay contributes only 58.98 hours—less than 8% of the total. Tamil, despite having four contributing corpora and 215.58 training hours, faces a compounding problem: it is typologically distant from the Indo-European and Sino-Tibetan languages that dominate the base model's pretraining data, meaning the base model's representations for Tamil are poor before fine-tuning even begins.

This imbalance is not a quirk of the authors' data collection; it reflects the fundamental reality that speech data availability on the internet is massively skewed toward English and Mandarin. Any system trained on web-crawled or publicly available audio inherits this skew. The authors cite established prior work showing that without explicit mitigation, multilingual models "converge to high-resource language attractors" during fine-tuning (Conneau et al., 2020; Wang et al., 2020a)—the gradient signal from English and Mandarin overwhelms the signal from Tamil and Malay, effectively training the model to be bilingual with noise.

Prior work proposed temperature-based multinomial sampling (Arivazhagan et al., 2019) to address this: you sample training batches from languages according to a smoothed distribution $p(l)^{1/\tau} / \sum_{l'} p(l')^{1/\tau}$ , where $\tau > 1$ upsamples low-resource languages and $\tau < 1$ sharpens the distribution toward high-resource ones. The paper finds this approach unsatisfying for two practical reasons: (1) the temperature parameter $\tau$ is sensitive and requires tuning—a process that is itself expensive when each training run is costly; and (2) even with appropriate $\tau$ , the method does not guarantee exact per-language parity, only a probabilistic approximation. During any given training epoch, some languages may still be under-sampled relative to others due to the stochastic nature of multinomial sampling.

The authors cite Zhou et al. (2022) as showing that language-balanced batching yields consistent WER reductions for low-resource languages without degrading high-resource ones, but note that this prior work did not operate in a setting where the imbalance was as extreme as Singapore's four-language mix with Tamil starting from near-zero base model capability.

Language Tag Conditioning: A Hidden Dependency That Fails in Singapore

A design pattern so common it is rarely questioned: most multilingual ASR systems prepend a special language-identification token (e.g., <|en|>, <|zh|>, <|ta|>) to the decoder input at both training and inference time. Whisper does this. Many end-to-end multilingual systems do this. The token tells the model which language to expect, allowing it to switch between language-specific decoding modes.

This works well when the language of each audio segment is known in advance—for example, when processing a labeled dataset or when a user explicitly selects their language. But Singapore's speech environment breaks this assumption in three ways the paper identifies:

Code-switching within utterances: A speaker might begin a sentence in English, insert a Mandarin phrase, and end in English. A single language tag for the entire utterance is ambiguous at best and misleading at worst.
Unknown language at inference time: In many deployment settings—broadcast media monitoring, classroom transcription, customer service call routing—the language of each incoming audio segment is not known in advance. Pre-labeling would require running a separate language identification system before ASR, adding latency, complexity, and a new point of failure.
Silent failure under misidentification: If a language tag is incorrect or absent, recognition quality degrades sharply (a finding the paper attributes to Winata et al., 2021). The model has been trained to rely on the tag as a strong conditioning signal; without it, or with the wrong one, the decoder produces outputs misaligned with the actual acoustic content.

The paper's response is to train entirely without language conditioning—no language tags at training time, none expected at inference time. This forces the model to identify the spoken language implicitly from acoustic and linguistic patterns in the audio signal alone. The approach is not entirely novel—the authors cite Toshniwal et al. (2018) and Li et al. (2013) as prior work on language-agnostic multilingual ASR and implicit language identification—but has become uncommon in recent large-scale systems that default to explicit language tags. The paper revisits this design choice specifically for its practical advantages in Singapore's code-switching environment, and demonstrates that a moderate-scale model (1.7B parameters) can perform reliable implicit language identification across four typologically diverse languages when trained on balanced data.

How This Paper Positions Itself

The paper does not claim to propose a novel architecture or a new training objective. Its contribution is a recipe: take a strong publicly available pretrained base model, assemble a multilingual corpus from only publicly available sources, apply a simple two-stage deterministic upsampling strategy to guarantee exact per-language parity, remove language tag conditioning, and fine-tune on a single consumer GPU for two days. The result is a model competitive with a specialist system 6× larger and 233× more expensive to train.

This positions the paper at the intersection of two research conversations. In the multilingual fairness conversation, it contributes evidence that simple data balancing—requiring no hyperparameter tuning beyond standard fine-tuning defaults—can dramatically close the gap between high-resource and low-resource languages in a multilingual ASR setting, taking Tamil from unusable (>120% WER) to functional (39% WER) without degrading English and Mandarin. In the research accessibility conversation, it contributes a concrete cost analysis ( $81 vs.$ 18,862) that makes the resource barrier explicit and demonstrates a path around it.

The paper does not claim to beat MERaLiON-2 across the board. It acknowledges remaining gaps on Singapore-accented English (NSC: 5.28 vs. 4.62 WER) and Tamil (CV: 39.19 vs. 31.78 WER), attributing these to MERaLiON's access to proprietary Singapore-specific training data and larger model capacity. The paper's claim is more nuanced: that the accuracy gap is small enough, and the cost and speed advantages large enough, that Polyglot-Lion represents a genuinely practical alternative for researchers and organizations that cannot afford the MERaLiON-scale approach. This is an engineering contribution motivated by deployment realities, not a claim of methodological superiority.

3. Technical Approach

3.1 Reader Orientation

This paper is primarily an empirical methods and systems paper whose core idea is that two simple, intentional design choices—deterministic language-balanced upsampling and language-agnostic decoding—are sufficient to transform a moderate-scale pretrained multilingual ASR model into a near-SOTA specialist for Singapore's four official languages, without requiring proprietary data, novel architectures, or industrial compute budgets.

The system being built is a family of compact (0.6B and 1.7B parameter) speech recognition models that take raw audio as input and produce transcribed text as output. The problem it solves is: given a heavily imbalanced collection of publicly available speech corpora where English and Mandarin dominate (~65% of training hours) and Tamil/Malay are severely under-represented (~8% for Malay), and given a pretrained base model that already catastrophically fails on Tamil (WER > 120%), how do you fine-tune to achieve competitive accuracy across all four languages? The "shape" of the solution is: (1) preprocess all audio identically; (2) deterministically replicate and subsample the training data until every language contributes exactly the same number of utterances; (3) strip out all language-identifying tokens so the model must learn to recognize languages from audio alone; (4) fine-tune using standard hyperparameters on a single consumer GPU for 48 hours.

3.2 Big-Picture Architecture (Diagram in Words)

The Polyglot-Lion training and inference pipeline has five major components, arranged in a linear flow from raw data to deployed model:

Data Collection and Preprocessing Pipeline — assembles 12 publicly available speech corpora across four languages (607,839 total utterances, 968.83 hours), normalizes all transcripts (lowercase, punctuation-stripped), filters out utterances longer than 30 seconds, and produces a unified format ready for training. This component has no learnable parameters; it is a deterministic data engineering step.
Two-Stage Balanced Upsampling Module — takes the preprocessed but heavily imbalanced training set and applies Algorithm 1 to guarantee that the final training corpus contains exactly 25% of utterances from each language, with equal representation across all constituent datasets within each language. This module operates entirely on dataset indices (replication counts, subsampling masks); it does not modify any audio or text content.
Base Encoder-Decoder ASR Model (Qwen3-ASR) — a transformer-based Conformer encoder + autoregressive decoder pretrained on large-scale multilingual speech data. Takes log-Mel filterbank features as input, produces text tokens as output. Available in two sizes (0.6B and 1.7B parameters). This is the pretrained checkpoint that provides the initial representation space; all weights are updated during fine-tuning.
Language-Agnostic Decoding Interface — a modification to the standard training and inference protocol: no language-identification tokens are prepended to decoder inputs, and no language-specific conditioning signals are provided. The model receives only the acoustic encoder outputs and must infer the language implicitly. This is not a separate component but a design constraint enforced at both training and inference time.
Fine-Tuning Orchestrator — runs the training loop for 48 hours on a single NVIDIA RTX PRO 6000 GPU using AdamW with cosine annealing, peak learning rate $2 \times 10^{-5}$ , effective batch size 32 (per-device batch size 8 × 4 gradient accumulation steps). Produces the final Polyglot-Lion-0.6B and Polyglot-Lion-1.7B checkpoints.

Information flows as follows: raw audio and transcripts from 12 corpora → preprocessing (duration filtering, text normalization) → two-stage balanced upsampling (intra-language balancing, then inter-language balancing) → shuffled training batches fed to the Qwen3-ASR encoder-decoder → decoder generates text without any language tag prompt → cross-entropy loss computed against reference transcripts → gradients update all model parameters → final checkpoints evaluated on held-out test sets using WER (English, Tamil, Malay) or CER (Mandarin).

3.3 Roadmap for the Deep Dive

First, the data preprocessing pipeline (Section 3.4.1): how raw corpora are normalized, filtered, and prepared for training, because this uniform preprocessing ensures all languages are treated identically before the upsampling stage addresses imbalance.
Second, the two-stage balanced upsampling algorithm (Section 3.4.2): the mathematical formulation of intra-language and inter-language balancing, because this is the core methodological contribution that enables Tamil and Malay to receive equal gradient signal despite being severely under-represented in the raw data.
Third, the base model architecture and pretraining (Section 3.4.3): what the Qwen3-ASR checkpoints provide, their encoder-decoder structure, and what capabilities they bring (and lack) before fine-tuning, because understanding the starting point is essential to interpreting what fine-tuning contributes.
Fourth, the language-agnostic decoding design (Section 3.4.4): the deliberate removal of language tag conditioning, what this forces the model to learn, and why this matters for Singapore's code-switching environment, because this is the second key design choice that distinguishes Polyglot-Lion from most multilingual ASR systems.
Fifth, the training configuration and hyperparameters (Section 3.4.5): the optimizer, learning rate schedule, batch size, hardware, training duration, and total cost, because these details define the reproducibility envelope and the claimed 233× cost reduction.
Sixth, the evaluation protocol (Section 3.4.6): what metrics are used, why different metrics apply to different languages, how baselines are selected, and how inference speed is measured, because the paper's claims rest on fair comparison methodology.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily an empirical methods paper whose core idea is that deterministic language-balanced upsampling combined with language-agnostic decoding, applied to a strong pretrained base model using only publicly available data, can yield near-SOTA multilingual ASR at dramatically reduced cost. The technical contribution is the recipe—the specific combination and configuration of these components—rather than any single novel algorithm or architecture.

3.4.1 Data Preprocessing Pipeline

Before any training occurs, all 12 speech corpora (listed in Table 1) undergo a uniform preprocessing pipeline designed to eliminate spurious variation across datasets that could confound multilingual training. This preprocessing is applied identically to every corpus regardless of language, dataset origin, or recording conditions.

Duration filtering. Every audio file exceeding 30 seconds in length is discarded from the training, validation, and test splits. The paper states the rationale explicitly:

"Audio files exceeding 30 seconds are discarded to avoid memory overflow during training and to exclude utterances that are disproportionately long relative to the target sequence length of most ASR decoders."

This threshold is cited as following the convention established by Whisper (Radford et al., 2023). The practical effect is twofold: (1) it prevents individual training examples from consuming excessive GPU memory during forward and backward passes, which is critical when training on a single 48 GB GPU; (2) it aligns the utterance length distribution with what the Qwen3-ASR base models were designed to handle, since these models were pretrained on similarly truncated segments. Utterances longer than 30 seconds would require either truncation (losing audio content) or gradient accumulation tricks (adding implementation complexity), so filtering is the simplest and most reproducible choice. The paper does not report what fraction of utterances were discarded by this filter, but Table 1 shows that the total corpus comprises 968.83 hours across 607,839 utterances, implying a mean utterance duration of approximately 5.7 seconds—well within the 30-second bound, suggesting the filter primarily removes outliers.

Text normalization. All reference transcripts are lowercased and stripped of punctuation before training. The paper states:

"Transcripts are normalised to lowercase and stripped of punctuation, following the convention adopted by Whisper (Radford et al., 2023) and subsequent multilingual ASR systems (Shi et al., 2026), which has been shown to reduce spurious token-level errors arising from inconsistent punctuation annotation across corpora."

This is a critical design choice that deserves unpacking. The 12 corpora in the training set were created by different research groups under different annotation guidelines. Some corpora (like Librispeech) include punctuation and capitalization; others (like Common Voice crowdsourced recordings) may have inconsistent or missing punctuation; still others may use language-specific punctuation conventions (e.g., Chinese punctuation marks versus English ones). If the model were trained on transcripts with heterogeneous punctuation, it would need to learn both the speech-to-text mapping and the arbitrary punctuation conventions of each corpus—a source of noise that increases token-level error rates without improving speech recognition quality. By stripping all punctuation and lowercasing all text, the model's task reduces to pure phonetic-to-graphemic mapping: given this audio, produce the sequence of words/characters, ignoring orthographic formatting. This is consistent with the paper's evaluation metrics (WER and CER), which also operate on lowercased, punctuation-stripped text, so the normalization does not artificially inflate reported accuracy.

A subtle consequence: this normalization means the model never learns to produce punctuation or capitalization, which would be a limitation for applications requiring formatted output (e.g., generating subtitles with proper sentence boundaries). However, for the paper's target deployment scenarios—transcription for search, indexing, or downstream NLP where punctuation can be restored via a separate post-processing model—this limitation is acceptable. The paper does not discuss this tradeoff explicitly.

No speaker-level filtering or data selection. The paper states that "no speaker-level filtering or data selection is applied; all remaining utterances are used." This is notable because many ASR pipelines apply additional filtering steps—removing utterances with high word error rate under an existing model, filtering out non-native speakers, or balancing speaker demographics. The paper's decision to use all available data maximizes coverage and keeps the preprocessing pipeline simple and reproducible, though it may include low-quality or noisy recordings that a more selective approach would exclude.

Dataset assembly. The final preprocessed training set comprises 479,364 utterances (782.99 hours) distributed across the four languages as shown in Table 1. The validation set contains 57,208 utterances (86.61 hours) and the test set contains 71,267 utterances (99.23 hours). These are the raw counts and durations before any upsampling is applied.

3.4.2 Two-Stage Balanced Multilingual Upsampling

This is the paper's central methodological innovation. The problem it addresses is: the raw training corpus is massively imbalanced—English and Mandarin together account for approximately 65% of training hours, while Malay represents fewer than 8%—and naive joint training on this skewed distribution would bias gradient updates toward high-resource languages, causing the model to underfit Tamil and Malay.

Why not temperature-based sampling? The paper explicitly rejects the most common alternative approach—temperature-based multinomial sampling (Arivazhagan et al., 2019)—for two reasons. First, the temperature parameter $\tau$ requires tuning: values of $\tau > 1$ upsample low-resource languages by flattening the sampling distribution, but the optimal $\tau$ depends on the specific imbalance ratio and dataset sizes, and finding it requires multiple expensive training runs. Second, even with appropriate $\tau$ , temperature sampling provides only a probabilistic guarantee of language balance—during any given training epoch, some languages may still be under-sampled relative to others because the sampling is stochastic. The paper instead opts for a deterministic approach that guarantees exact per-language parity with zero hyperparameter tuning.

Algorithm 1: Two-Stage Balanced Multilingual Upsampling. The algorithm operates in two sequential stages, first balancing datasets within each language group (so that every dataset for a given language contributes equally), and then balancing language groups against each other (so that every language contributes equally to the final training set).

Let $L = \{l_1, l_2, l_3, l_4\} = \{\text{English}, \text{Mandarin}, \text{Tamil}, \text{Malay}\}$ be the set of four languages. For each language $l$ , let $D_l = \{D_{l,1}, \dots, D_{l,K_l}\}$ be the collection of $K_l$ datasets in that language, and let $N_{l,k} = |D_{l,k}|$ be the number of training utterances in dataset $D_{l,k}$ .

Stage 1: Intra-language balancing. Within each language group, every dataset is upsampled to match the size of the largest dataset in that group. Formally, for each language $l$ :

$N^*_l = \max_k N_{l,k}$

where $N^*_l$ is the target size for all datasets in language $l$ , defined as the maximum number of training utterances among all datasets belonging to that language.

$r_{l,k} = \left\lceil \frac{N^*_l}{N_{l,k}} \right\rceil$

where $r_{l,k}$ is the integer replication factor for dataset $D_{l,k}$ , computed as the ceiling of the ratio between the target size and the dataset's original size.

What physically happens: for each dataset $D_{l,k}$ , the system creates $r_{l,k}$ identical copies of the dataset (replication) and concatenates them, then randomly subsamples the concatenated result down to exactly $N^*_l$ utterances. The concatenated-and-subsampled dataset $\tilde{D}_{l,k}$ now contains exactly $N^*_l$ utterances. All such datasets for language $l$ are then merged:

$\tilde{D}_l = \bigcup_k \tilde{D}_{l,k}$

producing a balanced per-language corpus $\tilde{D}_l$ of size $N^*_l$ .

Why the ceiling and random subsampling? The ceiling function $\lceil \cdot \rceil$ ensures that every dataset is replicated at least once (even if it is already larger than $N^*_l$ , the ceiling of a ratio less than 1 is 1, meaning the dataset is used once and then subsampled down). The random subsampling to exactly $N^*_l$ ensures uniform size. An alternative would be to replicate by rounding down and accepting slight size variations—but that would violate the guarantee of exact parity that the paper prioritizes. The ceiling-and-subsample approach is slightly wasteful (some data is discarded in the subsampling step), but the discarded data is a random subset, minimizing bias.

Concrete example for English. English has two training datasets: Librispeech ( $N_{\text{en, Libri}} = 28,539$ ) and NSC ( $N_{\text{en, NSC}} = 100,000$ ). The maximum is $N^*_{\text{en}} = 100,000$ . Librispeech gets replicated $r = \lceil 100,000 / 28,539 \rceil = \lceil 3.504 \rceil = 4$ times, producing $4 \times 28,539 = 114,156$ utterances, then randomly subsampled down to 100,000. NSC (already at 100,000) gets $r = \lceil 100,000 / 100,000 \rceil = 1$ , replicated once, and subsampled to 100,000 (which is a no-op since it's already exactly 100,000). After merging, $\tilde{D}_{\text{en}}$ contains 200,000 utterances—100,000 each from Librispeech and NSC.

Concrete example for Malay. Malay has two training datasets: Mesolitica ( $N_{\text{ms, Meso}} = 17,851$ ) and Fleurs ( $N_{\text{ms, Fleurs}} = 2,667$ ). The maximum is $N^*_{\text{ms}} = 17,851$ . Mesolitica gets $r = 1$ (already at max) and remains at 17,851. Fleurs gets $r = \lceil 17,851 / 2,667 \rceil = \lceil 6.694 \rceil = 7$ , producing $7 \times 2,667 = 18,669$ utterances, then subsampled down to 17,851. After merging, $\tilde{D}_{\text{ms}}$ contains 35,702 utterances.

Stage 2: Inter-language balancing. After Stage 1, each language $l$ has a balanced internal corpus $\tilde{D}_l$ of size $N^*_l$ , but these sizes differ across languages because the largest dataset in English (NSC at 100,000) is much bigger than the largest dataset in Malay (Mesolitica at 17,851). Stage 2 equalizes these cross-language totals.

First, compute the maximum per-language size after Stage 1:

$N^{**} = \max_l N^*_l$

where $N^{**}$ is the global target size—every language will be upsampled to contribute exactly this many utterances to the final training set.

Then, for each language $l$ , compute the replication factor:

$R_l = \left\lceil \frac{N^{**}}{N^*_l} \right\rceil$

where $R_l$ is the integer number of times the entire per-language corpus $\tilde{D}_l$ must be replicated to reach or exceed $N^{**}$ .

What physically happens: the entire balanced corpus $\tilde{D}_l$ is replicated $R_l$ times (creating $R_l$ identical copies concatenated together), then randomly subsampled down to exactly $N^{**}$ utterances, producing the final per-language corpus $\hat{D}_l$ . The final training set is the union:

$\hat{D} = \bigcup_{l \in L} \hat{D}_l$

which contains exactly $4 \times N^{**}$ utterances, with each language contributing precisely $N^{**}$ utterances—exactly 25% of the total.

Concrete end-to-end example. After Stage 1, the per-language sizes $N^*_l$ depend on the largest dataset in each language. Based on Table 1 training split counts: English has NSC at 100,000, Mandarin has AISHELL-1 at 120,098, Tamil has SLR127 at 69,575, Malay has Mesolitica at 17,851. So $N^{**} = \max(100,000, 120,098, 69,575, 17,851) = 120,098$ . Every language must now reach 120,098 utterances.

English ( $N^*_{\text{en}} = 100,000$ ): $R = \lceil 120,098 / 100,000 \rceil = 2$ . The 200,000-utterance English corpus (100K Librispeech + 100K NSC, after Stage 1) is replicated twice to 400,000, then subsampled to 120,098. Note: this means each of the original English datasets contributes roughly 60,049 utterances to the final set.
Mandarin ( $N^*_{\text{zh}} = 120,098$ ): $R = 1$ . Already at the target, no replication needed. The internal balance from Stage 1 (where all four Mandarin datasets were equalized to 120,098) is preserved.
Tamil ( $N^*_{\text{ta}} = 69,575$ ): $R = \lceil 120,098 / 69,575 \rceil = 2$ . The Tamil corpus (which after Stage 1 has four datasets each at 69,575, total 278,300) is replicated twice to 556,600, then subsampled to 120,098.
Malay ( $N^*_{\text{ms}} = 17,851$ ): $R = \lceil 120,098 / 17,851 \rceil = 7$ . The Malay corpus (two datasets each at 17,851, total 35,702) is replicated 7 times to 249,914, then subsampled to 120,098.

The final training set contains $4 \times 120,098 = 480,392$ utterances. The original training set before upsampling had 479,364 utterances, so the total training set size increases by only about 0.2%—the upsampling primarily changes the distribution, not the total volume.

Why two stages rather than one global balancing step? A single-stage approach that directly targets $N^{**}$ across all datasets would destroy intra-language balance. For example, if the global target were applied directly to individual datasets, Librispeech (28,539) would be upsampled less aggressively than NSC (100,000) because the former is smaller—but within English, you want both datasets to contribute equally so the model sees diverse English accents and recording conditions. Stage 1 ensures that within each language, all constituent datasets are represented equally (preventing the largest dataset from dominating gradient updates for that language). Stage 2 ensures that across languages, all four languages contribute equally (preventing English and Mandarin from dominating overall). The two-stage design separates these concerns.

Properties of this scheme. The paper emphasizes that the approach is "deliberately simple: it requires no hyper-parameter tuning, is fully deterministic given a fixed random seed, and guarantees exact per-language parity regardless of how skewed the original corpus distribution is." The cost is "a modest increase in the number of training steps per epoch" because the total number of utterances increases from 479,364 to 480,392 (a 0.2% increase—trivially small in this case, though the replication factors mean the effective number of unique utterances per epoch is unchanged; the model simply sees some utterances multiple times).

What this does to gradient updates. The practical effect of balanced upsampling is that each training step's mini-batch, when sampled uniformly from $\hat{D}$ , contains (in expectation) exactly 25% of utterances from each language. This means the gradient signal—which determines how the model's parameters are updated—receives equal contribution from each language. Without upsampling, a random mini-batch would contain roughly 65% English+Mandarin utterances and only ~8% Malay utterances; the model would learn to optimize English and Mandarin recognition while treating Malay as noise. The upsampling forces the model to allocate representational capacity evenly across languages.

The paper validates that this approach does not introduce "negative transfer"—the phenomenon where improving performance on one language degrades performance on another—by showing that English and Mandarin performance is preserved or improved after fine-tuning (Table 2, comparing Polyglot-Lion to unmodified Qwen3-ASR bases).

3.4.3 Base Model Architecture and Pretraining

Polyglot-Lion is fine-tuned from publicly available checkpoints in the Qwen3-ASR series (Shi et al., 2026), specifically two size variants:

Qwen3-ASR-0.6B — approximately 600 million parameters
Qwen3-ASR-1.7B — approximately 1.7 billion parameters

The paper describes the architecture at a high level:

"These models follow a transformer-based encoder–decoder architecture (Vaswani et al., 2017) in which a Conformer (Gulati et al., 2020) or similar acoustic encoder maps log-Mel filterbank features to contextual representations, and an autoregressive decoder generates output tokens conditioned on those representations."

This description contains several architectural details worth unpacking for a reader unfamiliar with modern ASR model design.

The encoder: Conformer. The Conformer architecture (Gulati et al., 2020) augments the standard Transformer encoder with convolutional layers interleaved between self-attention and feed-forward blocks. The motivation is that speech recognition benefits from both: (1) self-attention captures long-range dependencies across the entire utterance (e.g., a phoneme at the beginning of a word may influence pronunciation at the end), and (2) convolution captures local patterns in the time-frequency representation (e.g., formant transitions within a single phoneme). The Conformer uses a macaron-style block structure: each encoder layer contains a feed-forward module, a self-attention module, a convolution module, and a second feed-forward module, with residual connections around each. This design has become standard in state-of-the-art ASR because it outperforms pure Transformer and pure convolutional encoders on most benchmarks.

Input representation: log-Mel filterbank features. The raw audio waveform (sampled at some rate, typically 16 kHz for speech) is converted to a sequence of acoustic feature vectors through the following pipeline: (1) the waveform is divided into overlapping frames (typically 25 ms windows with 10 ms shift), (2) a Fourier transform is applied to each frame to obtain the power spectrum, (3) the power spectrum is passed through a set of triangular filters spaced according to the Mel scale (a perceptually motivated frequency scale that approximates human auditory sensitivity), and (4) the logarithm of the filterbank energies is taken. The result is a sequence of vectors (one per ~10 ms of audio), each with dimension equal to the number of Mel filters (typically 80). This representation discards phase information (which humans can't consciously perceive) and compresses the frequency dimension in a way that emphasizes perceptually relevant frequency bands.

The autoregressive decoder. The decoder generates output text tokens one at a time, left to right, conditioned on: (1) the encoder's output representations (via cross-attention at each decoder layer), and (2) the previously generated tokens (via causal self-attention where each token can only attend to tokens before it). The model is trained with teacher forcing: during training, the ground-truth previous tokens are provided as input, and the model is optimized to predict the next token. The output vocabulary includes subword tokens (likely Byte-Pair Encoding or SentencePiece) covering all four target languages plus Mandarin characters.

What the pretrained checkpoints provide. The paper states that both Qwen3-ASR checkpoints are "pre-trained on large-scale multilingual speech data and already achieve competitive zero-shot performance on several standard benchmarks." The paper's own baseline evaluation (Table 2) quantifies this: Qwen3-ASR-0.6B achieves 2.74 WER on Librispeech (English), 2.08 CER on AISHELL-1 (Mandarin), but 121.10 WER on Tamil Common Voice and 47.29 WER on Malay Mesolitica. This pattern—excellent English and Mandarin, catastrophic Tamil, poor Malay—reveals the pretraining data distribution without the authors needing to know what data was used: the base models were clearly trained on corpora dominated by English and Mandarin, with minimal Tamil and Malay exposure.

Why use Qwen3-ASR specifically as the base? The paper does not explicitly justify the choice beyond noting that these models are publicly available, come in two sizes enabling efficiency comparisons, and achieve strong zero-shot performance on some benchmarks. The implicit rationale is: (1) Qwen3-ASR represents a modern, capable architecture (Conformer encoder + Transformer decoder) at a scale that can be fine-tuned on a single GPU (unlike 7B+ ALMs), (2) its open release means the fine-tuning recipe is fully reproducible by anyone with access to the same public checkpoints, and (3) the model already encodes rich phonetic and linguistic priors from pretraining, which the balanced fine-tuning can redirect toward the target languages rather than learning from scratch.

The two size variants serve a specific purpose. By releasing both 0.6B and 1.7B variants trained with identical procedures, the paper enables direct measurement of how model scale affects multilingual recognition. The results (Table 2) show that the 1.7B variant improves average error rate from 16.52 to 14.85—a 1.67-point gain from 2.8× more parameters. This is a modest improvement, suggesting that for this task, balanced training data matters more than raw parameter count (consistent with the paper's thesis). The 0.6B variant also serves as a practical deployment option: at 0.10 s/sample inference speed and 16.52 average error rate, it is faster and more accurate than the next-best sub-1B model (Whisper-large-v3-turbo at 33.04 and 0.28 s/sample).

3.4.4 Language-Agnostic Decoding Design

This is the second key design choice that distinguishes Polyglot-Lion from most multilingual ASR systems. The standard practice—which the paper describes as "a standard practice in multilingual ASR systems"—is to prepend a special language-identification token to the decoder input at both training and inference time. For example, Whisper uses tokens like <|en|>, <|zh|>, <|ta|> to signal the target language to the decoder. The decoder's first generated token is often trained to be this language token, and subsequent text generation is conditioned on it.

Why language tags are standard. The tag provides the model with an explicit signal about which language's phoneme-to-grapheme mapping, vocabulary, and language model to use. This is particularly helpful when languages share acoustic features but have different orthographic conventions—for instance, an English speaker saying "Los Angeles" produces similar sounds to a Spanish speaker saying "los ángeles," and the language tag disambiguates which writing system to produce. The tag also helps the model switch between language-specific decoding strategies: the optimal beam search width, the expected word length distribution, and the appropriate subword token inventory all differ by language.

The problem with language tags in Singapore. The paper identifies three failure modes that make language tags unsuitable for Singapore's speech environment:

Code-switching within utterances destroys the single-language assumption. When a speaker says "I went to the pasar malam and bought some makanan," the utterance contains English and Malay. A single <|en|> tag would bias the decoder toward English spellings of Malay words; a <|ms|> tag would bias toward Malay spellings of English words. Neither is correct. The paper cites Winata et al. (2021) for the finding that "if the language tag is absent, incorrect, or ambiguous—as is common in spontaneous conversational speech and code-switched utterances—recognition quality degrades sharply."
Language identity is unknown in many deployment settings. The paper specifically mentions "broadcast media monitoring, classroom transcription, customer service" as scenarios where "the language of each audio segment is not known in advance." Requiring a pre-ASR language identification step adds latency, introduces a new potential failure point (if the language ID is wrong, ASR quality degrades), and complicates the deployment pipeline.
Silent failure under misidentification. The model is trained to rely on the tag as a strong conditioning signal. If the wrong tag is provided—because a separate language ID system made an error, or because a user selected the wrong language—the decoder's outputs become misaligned with the acoustic content, and the error may not be obvious without listening to the audio and reading the transcript side by side.

What Polyglot-Lion does instead. The paper trains entirely without language tags:

"We therefore train Polyglot-Lion entirely without language conditioning: no language tags are prepended to decoder inputs at training time, and none are expected at inference time. The model is required to infer the spoken language implicitly from acoustic and linguistic patterns in the input signal."

This means the decoder's input at the first generation step is simply a start-of-sequence token (likely <|startoftranscript|> or equivalent from the Qwen3 tokenizer), with no language-specific information. The model must determine from the encoder's acoustic representations alone whether the speech is English, Mandarin, Tamil, or Malay—and then produce the appropriate transcription.

How this is implemented. The paper describes this as a modification to the standard protocol, but does not provide implementation-level details. The likely mechanism: during data preparation, no language tag is prepended to the reference transcripts that serve as decoder inputs during teacher forcing. The loss is computed only on the actual text tokens (words/characters), not on any language tag. At inference time, the decoder is prompted with only the start-of-sequence token, and the generated sequence begins directly with text content.

Why this works across four typologically diverse languages. The paper's results provide empirical evidence that a 1.7B-parameter model can perform reliable implicit language identification when trained on balanced data. Mandarin (Sino-Tibetan, tonal, character-based writing), Tamil (Dravidian, agglutinative, with a distinct abugida script), Malay (Austronesian, with relatively simple phonology and Latin script), and English (Indo-European, with complex phoneme-grapheme mapping and Latin script) are sufficiently acoustically distinct that the encoder's representations alone—without an explicit language tag—contain enough information for the decoder to disambiguate. This would not necessarily work for closely related languages (e.g., Serbian and Croatian, or Hindi and Urdu), but Singapore's languages are typologically distant enough that the implicit identification task is tractable.

Connection to prior work. The paper acknowledges that language-agnostic approaches "have been explored in the context of spoken language identification (Li et al., 2013) and multilingual ASR (Toshniwal et al., 2018), but remain less common in recent large-scale systems." The contribution is not the idea itself, but demonstrating that it works in a challenging four-language setting with severe data imbalance—and that when combined with balanced upsampling, it yields competitive results without the dependency on external language identification.

3.4.5 Training Configuration and Hyperparameters

The fine-tuning process is designed for reproducibility on modest hardware. The paper states the configuration concisely:

"Both model variants are fine-tuned for 48 hours on a single NVIDIA RTX PRO 6000 GPU (48 GB VRAM). We use the AdamW optimiser (Loshchilov & Hutter, 2019) with a cosine annealing learning-rate schedule (Loshchilov & Hutter, 2017), a peak learning rate of $2 \times 10^{-5}$ . Training uses a per-device batch size of 8 utterances accumulated over 4 gradient accumulation steps, yielding an effective batch size of 32. All other hyper-parameters follow the defaults from the Qwen3-ASR fine-tuning configuration (Shi et al., 2026)."

Optimizer: AdamW. AdamW (Loshchilov & Hutter, 2019) is a variant of the Adam optimizer that decouples weight decay from the gradient-based update. In standard Adam, weight decay (L2 regularization) is implemented by adding a penalty term to the loss, which interacts with the adaptive learning rates in ways that can reduce regularization effectiveness. AdamW instead applies weight decay directly to the weights after the gradient update, which provides more consistent regularization and has become the standard optimizer for transformer fine-tuning. The paper does not specify the weight decay coefficient, noting it follows Qwen3-ASR defaults.

Learning rate schedule: cosine annealing. The cosine annealing schedule (Loshchilov & Hutter, 2017) starts the learning rate at the peak value ( $2 \times 10^{-5}$ ) and smoothly decays it following a cosine curve:

$\eta_t = \eta_{\text{min}} + \frac{1}{2}(\eta_{\text{max}} - \eta_{\text{min}})\left(1 + \cos\left(\frac{t}{T}\pi\right)\right)$

where $\eta_t$ is the learning rate at step $t$ , $\eta_{\text{max}} = 2 \times 10^{-5}$ is the peak learning rate, $\eta_{\text{min}}$ is the minimum learning rate (likely close to 0), and $T$ is the total number of training steps (determined by the 48-hour training duration on the given hardware with the given batch size). The cosine schedule provides a smooth decay without sudden drops, which helps the model converge to a good minimum in the loss landscape.

Why cosine annealing over constant or step decay? Cosine annealing has become the default in transformer fine-tuning because it empirically produces better final performance than constant learning rates (which may oscillate around the minimum) or step decay (which introduces discontinuities that can destabilize training). The smooth decay allows the model to make large updates early in training when far from the optimum, then gradually refine parameters as it approaches convergence.

Batch size and gradient accumulation. The per-device batch size is 8 utterances—the number of audio-transcript pairs the GPU can process in one forward-backward pass without exceeding 48 GB of VRAM. Gradient accumulation over 4 steps means the optimizer updates weights only after every 4 forward-backward passes, using the accumulated gradients. This yields an effective batch size of $8 \times 4 = 32$ , matching what would be used if the GPU had enough memory to process 32 utterances simultaneously. Gradient accumulation is a standard technique to train with larger effective batch sizes on memory-constrained hardware; the tradeoff is that it takes more wall-clock time (4 forward-backward passes instead of 1 per optimizer step), but the total computational work is the same.

Training duration and hardware. The 48-hour training duration on a single RTX PRO 6000 GPU is a key number for the paper's accessibility claim. This GPU has 48 GB of VRAM, which is sufficient to hold the 0.6B or 1.7B parameter model plus optimizer states and activations for a batch of 8 utterances. The total training cost is estimated at $81, based on RunPod.io pricing. This is the figure used in the 233× cost reduction claim relative to MERaLiON-2's estimated$ 18,862 training cost.

What "48 hours" means in terms of epochs and steps. The paper does not report the number of training epochs or steps, but we can estimate. The balanced training set has 480,392 utterances. With an effective batch size of 32, one epoch requires $480,392 / 32 = 15,012$ training steps. The per-step wall-clock time depends on the model size and utterance length distribution, but the 48-hour duration implies that the model sees some number of epochs through the balanced data. The paper does not specify early stopping criteria, suggesting that training runs for the full 48 hours without validation-based stopping, which is a pragmatic choice when compute is cheap enough that running to a fixed time budget is simpler than implementing and monitoring validation-based early stopping.

Following Qwen3-ASR defaults. The paper states that all other hyperparameters—which likely include the AdamW betas (commonly $\beta_1 = 0.9, \beta_2 = 0.999$ ), weight decay coefficient, dropout rate, label smoothing, warmup steps, and gradient clipping threshold—follow the Qwen3-ASR fine-tuning defaults. This is important for reproducibility: it means anyone with access to the Qwen3-ASR codebase can exactly replicate the training run by only changing the data, the learning rate, and the batch size.

3.4.6 Evaluation Protocol

The evaluation is designed to measure two things: recognition accuracy (how many words or characters are correctly transcribed) and inference speed (how long it takes to process an audio sample). The paper evaluates on 12 test sets spanning the four target languages, comparing against eight baseline systems.

Metrics. The paper uses two metrics, selected per language:

Word Error Rate (WER) for English, Tamil, and Malay:

$\text{WER} = \frac{S + D + I}{N}$

where $S$ is the number of word substitutions (hypothesis word differs from reference word), $D$ is the number of deletions (reference word missing from hypothesis), $I$ is the number of insertions (extra word in hypothesis not in reference), and $N$ is the total number of words in the reference transcript.

What it computes: WER is the minimum edit distance between the hypothesis transcript and the reference transcript, normalized by the reference length. It is computed using dynamic programming (the Wagner-Fischer algorithm) to find the optimal alignment, then counting the operations. A WER of 0% means perfect transcription; a WER of 100% means the number of errors equals the number of reference words (the hypothesis is, on average, completely wrong—though WER can exceed 100% if there are many insertions).

Why WER for English, Tamil, and Malay: these languages conventionally use whitespace-delimited word tokenization in ASR evaluation. Words are a natural unit of comparison because they correspond to meaningful linguistic units and are well-defined by spacing conventions.

Character Error Rate (CER) for Mandarin:

$\text{CER} = \frac{S_c + D_c + I_c}{N_c}$

where $S_c$ , $D_c$ , $I_c$ are character-level substitutions, deletions, and insertions, and $N_c$ is the number of characters in the reference.

Why CER for Mandarin: Mandarin text does not use spaces between words. Word boundaries are ambiguous and depend on the segmentation algorithm used. Evaluating at the character level avoids introducing segmentation errors into the metric. A CER of 2% means that on average, 2 out of every 100 characters are incorrectly transcribed. CER is the standard metric for Mandarin ASR evaluation (the paper cites Shi et al., 2021 and Bu et al., 2017).

Preprocessing for evaluation. Both the hypothesis text (model output) and reference text (ground truth) are lowercased and stripped of punctuation before computing WER/CER. This matches the training preprocessing (Section 3.4.1) and ensures that the metric measures phonetic-to-graphemic transcription accuracy—not the model's ability to reproduce inconsistent original punctuation. The evaluation is performed using the asr-evalkit library (Dang, 2026).

Average error rate. The paper reports an "average error rate" that combines WER and CER across all 12 benchmarks, weighted equally (i.e., each of the 12 test sets contributes 1/12 to the average). This means: Librispeech WER (English, ~2,619 test utterances), NSC WER (English, ~3,000 utterances), and Common Voice Mandarin CER (~9,999 utterances) all contribute equally despite having different numbers of test utterances and using different metrics. This is a somewhat coarse aggregate—a WER point and a CER point are not directly comparable units—but the paper uses it as a single summary statistic for system ranking. The baseline models with anomalously high error rates (Qwen2.5-Omni-3B and -7B on Tamil, with WER > 200%) are excluded from the average calculation because they "would distort cross-system comparison."

Baselines. The eight baseline systems are selected to cover the full spectrum of relevant approaches:

Whisper-large-v3-turbo (0.8B parameters): the canonical general-purpose multilingual ASR system, distilled for efficiency.
SeaLLMs-Audio-7B (7B): an audio-language model specifically developed for Southeast Asian languages.
Qwen2.5-Omni-3B and -7B (3B, 7B): general-purpose omni-modal models integrating vision, audio, and language. Included to test whether general ALMs can perform regional multilingual ASR without task-specific fine-tuning.
Qwen3-ASR-0.6B and -1.7B (0.6B, 1.7B): the unmodified base checkpoints. These are the most important baselines because they isolate the effect of the paper's fine-tuning recipe.
MERaLiON-2-10B-ASR (10B): the specialist system purpose-built for Singapore multilingual ASR, representing the accuracy ceiling and primary comparison point.

All baselines are evaluated in inference-only mode using publicly released checkpoints, without any additional fine-tuning. Inference is conducted on the same hardware (single NVIDIA RTX PRO 4500 GPU) to ensure fair latency comparisons. This hardware differs from the training GPU (RTX PRO 6000); the paper uses the 4500 for inference benchmarking likely because it is more representative of deployment hardware (lower cost, lower power).

Inference speed measurement. The paper measures "mean inference latency per sample, measured on a single NVIDIA RTX PRO 4500 GPU across all evaluation sets" and reports the mean and standard deviation in seconds per sample (Table 3). The measurement likely includes: audio loading, feature extraction (log-Mel filterbank computation), encoder forward pass, autoregressive decoder generation (beam search or greedy decoding—the paper does not specify), and output text post-processing. The standard deviations are reported: Polyglot-Lion-0.6B at $0.0999 \pm 0.0561$ s/sample and Polyglot-Lion-1.7B at $0.1038 \pm 0.0621$ s/sample. The relatively large standard deviation (roughly 50-60% of the mean) indicates that inference time varies substantially with utterance length—longer utterances require more decoder generation steps, increasing latency proportionally.

Why this speed comparison matters. The paper's deployment argument rests on the claim that Polyglot-Lion is not just cheaper to train but also faster to run. At 0.10 s/sample, a 10-second utterance can be transcribed in roughly 0.1 seconds (real-time factor ~0.01, meaning the model processes audio 100× faster than real-time). In contrast, MERaLiON-2 at 2.02 s/sample would take 2 seconds to transcribe that same utterance—a 20× difference that compounds in batch processing scenarios (transcribing 100 hours of audio: ~1 hour with Polyglot-Lion vs. ~20 hours with MERaLiON-2 on a single GPU).

4. Key Insights and Innovations

Innovation 1: Exact-Per-Parity Upsampling as a Hyperparameter-Free Alternative to Temperature Sampling

The dominant approach to language imbalance in multilingual training is temperature-based multinomial sampling (Arivazhagan et al., 2019), which smooths the per-language sampling probability by a temperature parameter τ. This method has become a standard tool in the multilingual NLP toolkit, but the paper identifies a subtle weakness that the field has largely accepted as inevitable: temperature sampling provides only a probabilistic guarantee of language balance. During any given training epoch, some languages may still be under-sampled relative to others due to the stochastic nature of multinomial draws. Moreover, the temperature parameter τ requires tuning—a process that is itself expensive when each training run costs hundreds of GPU-hours—and the optimal τ depends on the specific imbalance ratio and dataset sizes in ways that are difficult to predict ex ante.

The paper's response is a deterministic two-stage upsampling algorithm (Algorithm 1) that replaces stochastic temperature sampling with explicit replication and subsampling. The algorithm guarantees exact per-language parity (precisely 25% of utterances from each language in the final training set) with zero hyperparameter tuning, zero distributional assumptions about the original corpus skew, and zero residual imbalance. The two-stage structure—first balancing datasets within each language, then balancing language groups against each other—is conceptually simple but addresses a real engineering problem that temperature sampling papers over: that within-language imbalance (e.g., one English dataset dominating another) can be just as harmful as cross-language imbalance, yet temperature sampling treats the language as the atomic unit and cannot correct for internal skew.

Why this is intellectually distinctive rather than just "simple data balancing." The paper's insight is that exact determinism matters when the imbalance is extreme and the low-resource languages start from near-zero base model capability. Tamil Common Voice WER drops from >120% to 39% after balanced fine-tuning—a 72% relative reduction. This magnitude of improvement suggests that the base model was not merely undertrained on Tamil; it was actively repelling Tamil gradient signal, converging to an English-Mandarin attractor that treated Tamil utterances as noise. In this regime, probabilistic balancing (where Tamil gets, say, 20% of batches on average but might get 10% in some epochs) is insufficient because the model never receives the consistent, sustained Tamil gradient signal needed to escape the high-resource attractor basin. The deterministic guarantee—Tamil gets exactly 25% of every epoch, every time—provides the stability required for the model to allocate representational capacity to a language it was never trained to handle.

The paper validates that this deterministic approach does not introduce negative transfer on high-resource languages (English and Mandarin performance is preserved or improved), which addresses the standard objection to aggressive upsampling: that forcing equal representation would dilute the model's ability to learn high-resource languages well. The finding that this objection does not materialize in practice—at least for this model scale and these languages—is itself a useful empirical result that should encourage more aggressive balancing in multilingual ASR.

Significance. This is an incremental methodological refinement rather than a fundamental advance—upsampling to address class imbalance is not novel—but it is a refinement with outsized practical impact because it eliminates a hyperparameter that has been a persistent source of friction in multilingual training pipelines. The paper effectively argues that the field's acceptance of temperature sampling as "good enough" has masked how much performance is left on the table for severely under-represented languages, and that a simpler, more deterministic approach can recover those gains at no additional tuning cost.

Innovation 2: Language-Agnostic Decoding as a Deliberate Constraint, Not a Fallback

The dominant design pattern in multilingual ASR is to condition the decoder on an explicit language-identification token—this is what Whisper does, what most end-to-end multilingual systems do, and what the Qwen3-ASR base models were almost certainly trained with. The paper breaks from this consensus not as a fallback ("we couldn't implement language tags") but as a deliberate design constraint motivated by Singapore's specific deployment reality: code-switching within utterances, unknown language identity at inference time, and silent failure modes under misidentification.

What makes this intellectually distinctive is how the paper frames the language tag not as a helpful inductive bias but as a hidden dependency that introduces brittleness. The standard argument for language tags is that they improve accuracy when the language is known—which is true in the controlled setting of benchmark evaluation, where each test utterance comes from a labeled dataset. But the paper argues this setting is a poor proxy for real Singapore deployment, where the language of each incoming audio segment is not known in advance and where speakers routinely mix languages within a single utterance. In these conditions, the language tag transforms from a helpful signal into a required input that, if wrong, silently degrades recognition quality.

The conceptual move. The paper repositions language-agnostic decoding from a limitation ("we can't provide a language tag") to a feature ("the model must learn to identify languages from audio alone, making it robust to the conditions that break tag-dependent systems"). This is not a new idea—the paper cites Toshniwal et al. (2018) and Li et al. (2013) as prior work on language-agnostic multilingual ASR and implicit language identification—but it has fallen out of favor in the large-scale pretraining era, where the dominant assumption is that language tags are cheap to provide and beneficial to include. The paper challenges this assumption not through theoretical argument but through empirical demonstration: a 1.7B-parameter model, trained on balanced data without language tags, achieves competitive or superior performance across four typologically diverse languages, including on the most challenging language (Tamil) where the base model with presumed language-tag training completely failed.

The relationship between balanced upsampling and language-agnostic decoding. These two design choices are not independent. Balanced upsampling ensures that the model receives equal gradient signal from each language during training, which is precisely what makes implicit language identification tractable. If the model saw English and Mandarin 65% of the time and Malay 8% of the time, it would learn to default to English-Mandarin acoustic-phonetic mappings and never develop the representational capacity to distinguish Tamil or Malay from noise. The balanced sampling forces the model to allocate capacity evenly, which in turn forces it to learn the acoustic features that distinguish the four languages—since failing to do so would result in poor performance on 50% of training examples (Tamil + Malay combined). The language-agnostic constraint then tests whether this capacity generalizes: at inference time, without any language hint, can the model activate the correct language-specific decoding pathway? The results suggest yes, and the balanced training is the enabling mechanism.

Practical significance beyond Singapore. The paper's argument for language-agnostic decoding generalizes to any deployment setting where language identity is unknown or ambiguous—which includes most real-world applications where audio comes from diverse, unlabeled sources. The standard counter-argument is that you can always run a separate language identification model before ASR, but this adds latency, complexity, and a new failure mode (if the LID model is wrong, the ASR model produces garbage). The paper demonstrates that with balanced training, the separate LID step may be unnecessary: the ASR model can perform both tasks jointly, with the language identification happening implicitly in the encoder representations.

Innovation 3: Reframing Multilingual ASR as a Resource-Accessibility Problem, Not Just an Accuracy Problem

The paper's most subversive contribution is not technical but framing: it treats the cost of training and deploying multilingual ASR as a first-class evaluation metric alongside accuracy. The direct comparison between Polyglot-Lion's estimated $81 training cost (single GPU, 48 hours) and MERaLiON-2-10B-ASR's estimated$ 18,862 training cost (128 GPUs, 48 hours) is not presented as an aside or a curiosity—it is central to the paper's argument and is given equal weight to the accuracy numbers in the abstract, Figure 1, and the conclusion.

Why this framing is intellectually significant. The field of multilingual ASR has been dominated by a scale-first paradigm: the solution to covering more languages with higher accuracy is to train larger models on more data using more compute. Whisper trained on 680,000 hours. MMS extended to 1,000+ languages. MERaLiON-2 used 120,000 hours and 128 GPUs. Each of these represents a genuine advance, but collectively they have established an implicit norm that competitive multilingual ASR requires industrial-scale resources. This norm gates participation: if you cannot afford a six-figure training budget, you cannot contribute to the state of the art.

Polyglot-Lion challenges this norm not by arguing that scale is unnecessary—the paper is explicit that the Qwen3-ASR base models are products of large-scale pretraining, and that MERaLiON-2 still wins on some benchmarks—but by demonstrating that the last mile of adaptation to a specific multilingual setting can be achieved at dramatically lower cost. The 233× cost reduction is possible because the base model already encodes rich multilingual speech representations from its own large-scale pretraining; the fine-tuning only needs to redirect those representations toward the target language distribution. The paper is essentially arguing that the field should distinguish between the pretraining cost (which may need to be large-scale and is amortized across all downstream users) and the adaptation cost (which can and should be small to enable broad participation).

The evidence that makes this argument stick. The paper's cost comparison is more persuasive than typical "our model is cheaper" claims because it includes specific, verifiable numbers: GPU model, count, training duration, cloud rental platform, and hourly rate. The $81 figure is not an estimate based on idealized throughput; it is based on RunPod.io pricing for the exact hardware configuration used, meaning anyone can verify or reproduce it. The$ 18,862 figure for MERaLiON-2 is similarly grounded in specific hardware and pricing. This concreteness transforms the cost comparison from a rhetorical device into a falsifiable claim.

The paper also extends the accessibility argument to inference: Polyglot-Lion's ~0.10 s/sample latency versus MERaLiON-2's ~2.02 s/sample makes the case that smaller models are not just cheaper to train but also cheaper to run, which matters for organizations operating at scale. A 20× inference speed difference means 20× lower GPU rental costs for batch transcription, or the ability to run real-time transcription on cheaper hardware.

Limits of this framing. The paper is careful not to overclaim. It acknowledges that MERaLiON-2 retains accuracy advantages on Singapore-accented English (NSC) and Tamil, attributing these to larger model capacity and access to proprietary Singapore-specific training data. The cost argument does not claim that Polyglot-Lion is strictly better—only that the accuracy gap is small enough, and the cost gap large enough, that Polyglot-Lion represents a genuine alternative for resource-constrained practitioners. This is a Pareto improvement in the accuracy-cost tradeoff space, not a claim of Pareto dominance.

Innovation 4: Diagnosing the "Catastrophic Failure Boundary" for Low-Resource Languages in Pretrained Models

The paper's baseline evaluation of the unmodified Qwen3-ASR base models reveals a pattern that is both striking and under-discussed in the multilingual ASR literature: a catastrophic failure boundary where model performance on a language transitions from state-of-the-art to functionally useless with no intermediate regime. Qwen3-ASR-0.6B achieves 2.74 WER on Librispeech (English) and 2.08 CER on AISHELL-1 (Mandarin)—both excellent. On Tamil Common Voice, the same model achieves 121.10 WER—worse than random guessing. There is no "mediocre but usable" intermediate performance (e.g., 40–60 WER); the model either transcribes the language well or produces complete garbage.

What this reveals about pretraining data distribution. This binary failure pattern is not a quirk of the Qwen3 architecture; it is a direct diagnostic of the pretraining data composition. The base model has clearly been trained on corpora dominated by English and Mandarin, with Tamil audio either entirely absent or present in such minuscule quantities that the model never learned to map Tamil phonemes to text. The transition from excellent to useless is sharp because the model's representational space is partitioned: English and Mandarin occupy well-learned regions where the encoder produces clean, discriminative features and the decoder has strong language-model priors; Tamil occupies an untrained region where the encoder outputs are essentially noise and the decoder falls back to whatever language model distribution it has, producing random word sequences.

The paper does not explicitly theorize this boundary, but the baseline results constitute a valuable empirical finding: pretrained multilingual models do not gracefully degrade on unseen or severely under-represented languages—they collapse entirely. This has implications for practitioners evaluating whether a pretrained model is suitable for their target language. A model that achieves 3 WER on English and 10 WER on Spanish tells you nothing about whether it will achieve 50 WER or 150 WER on Tamil; you must evaluate directly because the failure mode is binary, not continuous.

The connection to balanced fine-tuning. The paper's balanced upsampling can be understood as a mechanism for moving Tamil across the catastrophic failure boundary—from the "untrained noise" region into the "functional" region—by providing enough consistent gradient signal for the model to learn Tamil phonetic-to-graphemic mappings. The 72% relative WER reduction (121 → 39 on CV) is so large precisely because the starting point was catastrophic failure rather than moderate underperformance. Once the model has enough Tamil signal to escape the noise regime, further improvements become incremental (the gap to MERaLiON-2's 31.78 WER remains), consistent with the idea that the initial jump crosses a qualitative boundary while subsequent gains are quantitative refinements.

Implications beyond this paper. This diagnostic insight suggests that multilingual model evaluation should explicitly test for the catastrophic failure boundary. A model that reports "average WER across 100 languages" may hide the fact that 80 languages are in the <10 WER regime and 20 are in the >100 WER regime. The paper's practice of reporting per-language results and excluding catastrophic failures from the average (while noting the exclusion) is more honest than the common practice of reporting only aggregate metrics, and the field would benefit from adopting this transparency as standard.

5. Experimental Analysis

Evaluation Methodology

Dataset. All experiments use the assembled corpus of 12 publicly available speech corpora described in Section 3 and detailed in Table 1, totaling 607,839 utterances and 968.83 hours. The test partition comprises 71,267 utterances (99.23 hours) across all four languages, with per-corpus test splits as specified in Table 1.
Base model(s). Two checkpoints from the Qwen3-ASR series (Shi et al., 2026) are fine-tuned: Qwen3-ASR-0.6B and Qwen3-ASR-1.7B. Both use a Conformer encoder–Transformer decoder architecture pretrained on large-scale multilingual speech data. The paper selects Qwen3-ASR because these checkpoints are publicly available, come in two sizes enabling direct scale-comparison experiments, and achieve competitive zero-shot performance on English and Mandarin benchmarks (providing a strong but not saturated initialization where fine-tuning can demonstrate clear gains).
Metrics. Word Error Rate (WER) is used for English, Tamil, and Malay: $\text{WER} = (S + D + I) / N$ , where $S$ , $D$ , $I$ are substitution, deletion, and insertion counts, and $N$ is the number of reference words. Character Error Rate (CER) is used for Mandarin: $\text{CER} = (S_c + D_c + I_c) / N_c$ , where the operations are at the character level. WER is appropriate for whitespace-delimited languages; CER avoids the word segmentation ambiguity inherent to Mandarin. All hypotheses and references are lowercased and stripped of punctuation before scoring, consistent with the training preprocessing. Evaluation uses the asr-evalkit library (Dang, 2026). The paper reports a composite "average error rate" across all 12 benchmarks, computed as the unweighted mean of per-benchmark WER or CER values.
Baselines. Eight published systems are compared, representing the full spectrum from lightweight general-purpose models to large specialist systems:
1. Whisper-large-v3-turbo (0.8B params; Radford et al., 2023): a distilled multilingual ASR model, serving as the canonical general-purpose baseline.
2. SeaLLMs-Audio-7B (7B params; Liu et al., 2025): an audio-language model developed for Southeast Asian languages.
3. Qwen2.5-Omni-3B (3B params; Xu et al., 2025): a general-purpose omni-modal model integrating vision, audio, and language.
4. Qwen2.5-Omni-7B (7B params; Xu et al., 2025): the larger variant of the omni-modal model.
5. Qwen3-ASR-0.6B (0.6B params; Shi et al., 2026): the unmodified base checkpoint from which Polyglot-Lion-0.6B is fine-tuned. This is the most critical baseline for isolating the contribution of the fine-tuning recipe.
6. Qwen3-ASR-1.7B (1.7B params; Shi et al., 2026): the unmodified base checkpoint for the larger variant.
7. MERaLiON-2-10B-ASR (10B params; He et al., 2025): the specialist system purpose-built for Singapore multilingual ASR, trained on over 120,000 hours of speech. This serves as the accuracy ceiling and primary comparison point.
All baselines are evaluated in inference-only mode using publicly released checkpoints, without additional fine-tuning.
Generation budget / compute accounting. No generation budget in the LLM sense applies—this is supervised fine-tuning of an ASR model, not test-time compute scaling. Compute for training is measured in GPU-hours and dollar cost. Specifically: Polyglot-Lion uses 1 × NVIDIA RTX PRO 6000 GPU for 48 hours at an estimated $81 (priced via RunPod.io); MERaLiON-2-10B-ASR uses 128 × H100 GPUs for 48 hours at an estimated$ 18,862 (priced via the same platform). Inference speed is measured in seconds per sample (mean ± std) on a single NVIDIA RTX PRO 4500 GPU across all evaluation sets, enabling direct throughput comparison.
Cross-validation / statistical protocol. No cross-validation or statistical significance testing is reported. The paper evaluates on fixed held-out test splits from each corpus (as specified in Table 1) and reports single-run results. The average error rate across 12 benchmarks is reported as a point estimate without confidence intervals. No hyperparameter sweep results are reported beyond the stated configuration (peak learning rate $2 \times 10^{-5}$ , effective batch size 32, cosine annealing). The paper does not describe any early stopping based on validation performance; training runs for the full 48 hours.

Main Quantitative Results

The paper's experimental results are organized around two axes: per-language and per-benchmark recognition accuracy (Table 2), and inference speed (Table 3). A training cost comparison (Table 4) supplements these with resource utilization data. The results section does not contain separate ablation experiments; the analysis in Section 7 ("Analysis") examines the effects of the design choices through comparisons between Polyglot-Lion and the unmodified Qwen3-ASR baselines rather than through controlled removal of individual components.

Recognition Accuracy Across 12 Benchmarks

Headline result. Polyglot-Lion-1.7B achieves an average error rate of 14.85 across all 12 benchmarks, ranking second overall behind only MERaLiON-2-10B-ASR at 14.32—a model with 6× more parameters. Polyglot-Lion-0.6B achieves 16.52, making it the best-performing model at or below 1B parameters by a substantial margin (next best: Whisper-large-v3-turbo at 33.04).

English. Table 2 reports two English benchmarks: Librispeech (clean read speech) and NSC (Singapore-accented conversational and read speech). On Librispeech, Polyglot-Lion-1.7B achieves 2.10 WER, the best result among all evaluated systems including MERaLiON-2-10B-ASR (2.54) and the Qwen3-ASR-1.7B base (2.31). Polyglot-Lion-0.6B achieves 2.67 WER, comparable to the base Qwen3-ASR-0.6B (2.74) and MERaLiON-2 (2.54). On NSC, MERaLiON-2-10B-ASR achieves the best result at 4.62 WER, with Polyglot-Lion-1.7B at 5.28 and Polyglot-Lion-0.6B at 6.09. The base Qwen3-ASR-1.7B scores 6.22, meaning fine-tuning provides a 0.94 WER improvement. Whisper-large-v3-turbo scores 32.02 on NSC, confirming that general-purpose multilingual models struggle with Singapore-accented English despite strong Librispeech performance (3.04).

Mandarin. Table 2 reports four Mandarin benchmarks as CER. Polyglot-Lion-1.7B achieves the lowest CER on all four: AISHELL-1 (1.45 vs. MERaLiON-2 at 3.09 and Qwen3-ASR-1.7B base at 1.52), AISHELL-3 (1.86 vs. 4.07 and 2.08), Common Voice (4.91 vs. 8.83 and 7.50), and Fleurs (8.00 vs. 11.99 and 9.33). Polyglot-Lion-0.6B similarly leads among sub-1B models on all four benchmarks, with Common Voice at 6.16 CER (vs. Whisper at 17.91 and Qwen3-ASR-0.6B base at 10.06). Fine-tuning improves the 0.6B base's Common Voice CER from 10.06 to 6.16 (a 39% relative reduction) and the 1.7B base's Common Voice CER from 7.50 to 4.91 (a 35% relative reduction).

Tamil. Table 2 reports four Tamil benchmarks as WER. This is the most challenging language for all systems. The unmodified Qwen3-ASR bases produce catastrophic results: Qwen3-ASR-0.6B scores 121.10 on Common Voice, 127.00 on SLR65, 129.12 on SLR127, and 130.09 on Fleurs; Qwen3-ASR-1.7B scores 139.96, 134.63, 144.49, and 147.23 respectively. After fine-tuning, Polyglot-Lion-1.7B reduces these to 39.19, 19.75, 26.83, and 37.28—relative reductions of 72%, 85%, 81%, and 75% respectively. Polyglot-Lion-0.6B achieves 42.16, 23.07, 28.14, and 37.68. MERaLiON-2-10B-ASR remains the best system on all four Tamil benchmarks: 31.78 (CV), 19.29 (SLR65), 22.42 (SLR127), and 28.68 (Fleurs). Whisper-large-v3-turbo scores 74.50, 58.13, 69.56, and 66.90—better than the Qwen3-ASR bases but substantially worse than Polyglot-Lion. SeaLLMs-Audio-7B, despite being developed for Southeast Asian languages, scores 126.70, 127.24, 138.65, and 105.31 on the four Tamil benchmarks. Qwen2.5-Omni-3B and -7B produce WER exceeding 200% on multiple Tamil benchmarks and are excluded from the average error rate calculation.

Malay. Table 2 reports two Malay benchmarks as WER. On Mesolitica (conversational and domain-diverse Malay speech), Polyglot-Lion-1.7B achieves 21.51 WER, the best result among all evaluated systems, outperforming MERaLiON-2-10B-ASR (25.90), Whisper (28.47), and the Qwen3-ASR-1.7B base (39.00). Polyglot-Lion-0.6B achieves 24.33, also outperforming MERaLiON-2. On Malay Fleurs, the results are tighter: Polyglot-Lion-1.7B scores 9.98, compared to MERaLiON-2 at 8.55, Whisper at 8.88, and the Qwen3-ASR-1.7B base at 10.87. Fine-tuning reduces Malay Mesolitica WER by 49% for the 0.6B variant (47.29 → 24.33) and 45% for the 1.7B variant (39.00 → 21.51).

Effect of fine-tuning isolated. Comparing Polyglot-Lion to the unmodified Qwen3-ASR bases quantifies the contribution of balanced fine-tuning, independent of model architecture. Table 2 shows:

Language	Benchmark	Qwen3-ASR-0.6B base	Polyglot-Lion-0.6B	Qwen3-ASR-1.7B base	Polyglot-Lion-1.7B
English	Librispeech	2.74	2.67	2.31	2.10
English	NSC	7.64	6.09	6.22	5.28
Mandarin	CV (CER)	10.06	6.16	7.50	4.91
Tamil	CV	121.10	42.16	139.96	39.19
Tamil	SLR65	127.00	23.07	134.63	19.75
Tamil	SLR127	129.12	28.14	144.49	26.83
Malay	Mesolitica	47.29	24.33	39.00	21.51

On English and Mandarin—the high-resource languages—fine-tuning either preserves or slightly improves performance, with no evidence of negative transfer. On Tamil and Malay—the low-resource languages—fine-tuning provides massive improvements (Tamil CV WER reduced by 65–72%, Malay Mesolitica WER reduced by 45–49%). The paper's central claim that balanced fine-tuning closes the low-resource gap without harming high-resource languages is directly supported by these comparisons.

Average error rate ranking. The paper's composite metric (unweighted mean across 12 benchmarks, with anomalous baselines excluded) produces the following ranking from Table 2:

MERaLiON-2-10B-ASR: 14.32
Polyglot-Lion-1.7B: 14.85
Polyglot-Lion-0.6B: 16.52
Whisper-large-v3-turbo: 33.04
Qwen3-ASR-0.6B: 50.68
Qwen3-ASR-1.7B: 53.76
SeaLLMs-Audio-7B: 63.75
Qwen2.5-Omni-7B: 118.45 (excludes catastrophic Tamil results)
Qwen2.5-Omni-3B: 172.37 (excludes catastrophic Tamil results)

The gap between Polyglot-Lion-0.6B (16.52) and the next-best sub-1B model (Whisper at 33.04) is 16.52 points—essentially equal to Polyglot-Lion-0.6B's entire error rate. This underscores that balanced fine-tuning, not raw parameter count, is the dominant factor in these results.

Inference Speed Comparison

Headline result. Polyglot-Lion-0.6B and Polyglot-Lion-1.7B process audio at 0.10 and 0.10 s/sample respectively (Table 3), approximately 20× faster than MERaLiON-2-10B-ASR (2.02 s/sample), 3× faster than Whisper-large-v3-turbo (0.28 s/sample), and 5–6× faster than SeaLLMs-Audio-7B (0.64 s/sample, though with zero reported standard deviation, which is unusual and unexplained). The Qwen2.5-Omni models are substantially slower (1.34–1.78 s/sample) with high variance (std > 0.6 s), which the paper attributes to "omni-modal routing overhead."

Detailed latency measurements from Table 3 (mean ± std in seconds per sample):

Model	Time (s/sample)
MERaLiON-2-10B-ASR	2.0152 ± 0.8846
Qwen2.5-Omni-3B	1.7838 ± 1.0431
Qwen2.5-Omni-7B	1.3414 ± 0.6572
SeaLLMs-Audio-7B	0.6422 ± 0.0000
Whisper-large-v3-turbo	0.2822 ± 0.0230
Qwen3-ASR-1.7B	0.0809 ± 0.0290
Qwen3-ASR-0.6B	0.0686 ± 0.0251
Polyglot-Lion-0.6B	0.0999 ± 0.0561
Polyglot-Lion-1.7B	0.1038 ± 0.0621

Polyglot-Lion models are marginally slower than the unmodified Qwen3-ASR bases (0.10 vs. 0.07–0.08 s/sample), which is expected since fine-tuning does not change the architecture or inference graph—the small difference may reflect measurement noise or the specific batch of test utterances. The standard deviations for Polyglot-Lion (0.056 and 0.062) are roughly 50–60% of the mean, indicating that inference time scales approximately linearly with utterance length (longer audio requires more encoder frames and decoder steps). MERaLiON-2's standard deviation (0.885) is proportionally similar relative to its mean (44%), consistent with the same linear scaling.

Throughput implications. At 0.10 s/sample, Polyglot-Lion processes approximately 10 samples per second, or 36,000 samples per hour, on a single GPU. MERaLiON-2 at 2.02 s/sample processes approximately 0.5 samples per second, or 1,800 samples per hour—a 20× difference. For batch transcription of 100 hours of audio at the paper's reported mean utterance duration of ~5.7 seconds, this translates to roughly 63,000 utterances, requiring approximately 1.75 hours with Polyglot-Lion versus 35 hours with MERaLiON-2 on equivalent hardware.

Training Cost Comparison

Headline result. Table 4 reports that Polyglot-Lion incurs an estimated training cost of $81 (1 × RTX PRO 6000 GPU, 48 hours), compared to MERaLiON-2-10B-ASR's estimated$ 18,862 (128 × H100 GPUs, 48 hours), representing a 233× cost reduction. These estimates are sourced from RunPod.io pricing for the respective GPU types.

The paper explicitly does not estimate training costs for the other baseline models (Whisper, Qwen2.5-Omni, SeaLLMs-Audio, Qwen3-ASR base) since they are evaluated in inference-only mode. The comparison is specifically between the paper's fine-tuning cost and MERaLiON-2's full training cost—a comparison the paper acknowledges is somewhat asymmetric (fine-tuning vs. pretraining), but which the paper frames as practically relevant: if a practitioner can achieve near-MERaLiON-level accuracy by fine-tuning an existing pretrained model for $81, the relevant cost is$ 81, regardless of how much the pretrained model cost to produce (since that cost is amortized across all downstream users).

A nuance not discussed in the paper: the Qwen3-ASR base models themselves required substantial pretraining compute, which is not included in Polyglot-Lion's $81 budget. The 233× reduction is specifically in the adaptation cost from base model to Singapore specialist, not in the end-to-end cost from scratch to specialist. This is a valid framing if one accepts that pretrained base models are a shared resource, but it means the comparison is between fine-tuning cost and full-training cost—different categories of expenditure.

Ablation Studies and Robustness Checks

The paper does not contain a dedicated ablation section. Instead, several comparisons across the main results table serve as implicit ablations:

Effect of balanced fine-tuning vs. base model (implicit ablation via Table 2). As detailed in the Main Quantitative Results section above, the comparison between Polyglot-Lion checkpoints and the unmodified Qwen3-ASR bases reveals the effect of the full fine-tuning recipe (balanced upsampling + language-agnostic decoding). The effect is largest on Tamil (WER reduction of 65–72% on Common Voice) and Malay (45–49% on Mesolitica) and negligible-to-positive on English and Mandarin. The paper does not isolate the individual contributions of balanced upsampling versus language-agnostic decoding—they are always applied together. This means we cannot determine from these results whether, for example, balanced upsampling with language tags would perform better or worse than the current configuration, or whether language-agnostic decoding without upsampling would still produce gains on Tamil and Malay (it almost certainly would not, given the base models' catastrophic Tamil failures, but the paper does not run this ablation to confirm).

Effect of model scale (implicit ablation via the two size variants). The release of both 0.6B and 1.7B variants, trained identically, enables a controlled comparison of how model capacity affects multilingual recognition. Table 2 shows that scaling from 0.6B to 1.7B improves the average error rate from 16.52 to 14.85—a gain of 1.67 points from 2.8× more parameters. The per-benchmark pattern is instructive:

On Librispeech (English): 2.67 → 2.10 (gain of 0.57 WER)
On NSC (English): 6.09 → 5.28 (gain of 0.81 WER)
On Tamil CV: 42.16 → 39.19 (gain of 2.97 WER)
On Tamil SLR65: 23.07 → 19.75 (gain of 3.32 WER)
On Tamil SLR127: 28.14 → 26.83 (gain of 1.31 WER)
On Malay Mesolitica: 24.33 → 21.51 (gain of 2.82 WER)
On Malay Fleurs: 14.45 → 9.98 (gain of 4.47 WER)
On Mandarin CV: 6.16 → 4.91 (gain of 1.25 CER)
On AISHELL-1: 1.93 → 1.45 (gain of 0.48 CER)

The gains from scale are larger on the lower-resource languages (Tamil, Malay) than on the high-resource languages (English, Mandarin), where the base model already performs well and fine-tuning provides diminishing returns. This suggests that for severely under-represented languages, additional model capacity—when combined with balanced training—provides genuinely useful representational capacity for learning phonetic-to-graphemic mappings, rather than being wasted on the already-saturated high-resource languages. The paper does not explore whether further scaling (e.g., to the 7B range) would continue this trend or plateau.

Effect of balanced training on high-resource languages (robustness check via Table 2). A key concern with aggressive upsampling is negative transfer: forcing equal representation of low-resource languages might degrade performance on high-resource ones. The English and Mandarin results in Table 2 provide evidence against this concern. Polyglot-Lion-1.7B improves on Librispeech relative to the base (2.10 vs. 2.31), improves on NSC (5.28 vs. 6.22), improves on AISHELL-1 (1.45 vs. 1.52), and improves on AISHELL-3 (1.86 vs. 2.08). No English or Mandarin benchmark shows degradation after fine-tuning. This is consistent with the paper's claim that balanced upsampling "does not introduce negative transfer on high-resource languages." However, this is a single-data-point observation, not a systematic study of the tradeoff curve between upsampling aggressiveness and high-resource performance. The paper does not test intermediate upsampling ratios (e.g., 20% vs. 25% vs. 30% per language) to determine whether the equal-25% configuration is optimal or simply "good enough."

Baseline selection as coverage check. The paper evaluates eight diverse baselines spanning different architectures (encoder-decoder, ALM, omni-modal), scales (0.6B to 10B), and training paradigms (general-purpose pretraining, Southeast-Asia-specific training, Singapore-specific training). The pattern of results—where no baseline except MERaLiON-2 achieves usable Tamil performance, and where larger ALMs (Qwen2.5-Omni-7B) catastrophically fail on Tamil while a smaller, fine-tuned encoder-decoder (Polyglot-Lion-0.6B) succeeds—serves as a robustness check on the claim that targeted fine-tuning matters more than raw scale or architectural sophistication. The paper does not evaluate fine-tuned versions of the other baselines (e.g., Whisper fine-tuned on the same balanced corpus), which would provide a stronger test of whether the gains are due to the fine-tuning recipe or the specific base model's properties.

Language-agnostic decoding implicitly tested across four typologically diverse languages. The paper's evaluation across Mandarin (Sino-Tibetan, tonal, character-based), Tamil (Dravidian, agglutinative), Malay (Austronesian, Latin script), and English (Indo-European, Latin script) demonstrates that the model can perform implicit language identification across this typological range without language tags. The fact that recognition accuracy is competitive on all four languages—as opposed to, say, producing English text for Tamil audio—is evidence that the language-agnostic constraint succeeds. However, the paper does not explicitly evaluate language identification accuracy as a separate metric, does not test with code-switched utterances (acknowledged as a limitation in Section 8), and does not compare against a version of Polyglot-Lion trained with language tags to quantify the accuracy cost (if any) of the language-agnostic design.

Training cost estimate methodology. The $81 estimate is based on RunPod.io pricing for a single RTX PRO 6000 GPU with 48 GB VRAM for 48 hours. The$ 18,862 estimate for MERaLiON-2 is based on RunPod.io pricing for 128 H100 GPUs for 48 hours. The paper does not provide the per-hour rates used, making independent verification of the cost comparison difficult without looking up current RunPod pricing. Additionally, the comparison assumes equivalent utilization (the paper's single GPU runs at full utilization for 48 hours; MERaLiON-2's 128 GPUs presumably also run at full utilization). In practice, multi-GPU training often incurs communication overhead that reduces per-GPU utilization, meaning the effective cost per FLOP is higher for distributed training—which would make the 233× figure a lower bound (the actual cost advantage could be larger).

Critical Assessment

The paper makes four central claims in its contributions list (Section 1), and each can be assessed against the experimental evidence.

Claim 1: Balanced multilingual fine-tuning "substantially improves recognition accuracy on low-resource languages (Tamil, Malay) without requiring any proprietary data."

This claim is strongly supported by the Table 2 comparisons between Polyglot-Lion and the unmodified Qwen3-ASR bases. Tamil Common Voice WER drops from 121.10 → 42.16 (0.6B) and 139.96 → 39.19 (1.7B). Malay Mesolitica WER drops from 47.29 → 24.33 (0.6B) and 39.00 → 21.51 (1.7B). These are improvements of 45–72%, and they move Tamil from "effectively unusable" to "functional." The "without requiring proprietary data" part is supported by Table 1, which documents that all training corpora are publicly available (the sources and licenses are listed in Appendix A).

However, the claim conflates two mechanisms—balanced upsampling and language-agnostic decoding—that are never evaluated independently. It is possible that balanced upsampling alone (with language tags) would produce the same or better results, or that language-agnostic decoding without upsampling would fail entirely. The paper does not provide the evidence to distinguish these. The relevant ablation—Polyglot-Lion trained with the same balanced corpus but with language tags prepended to decoder inputs—is missing. This matters because language-agnostic decoding is presented as a key contribution, but its marginal contribution to accuracy is untested.

Additionally, "substantially improves" is relative to a very low baseline. The unmodified Qwen3-ASR bases are not a strong baseline for Tamil—they were clearly never trained on meaningful quantities of Tamil audio. The comparison demonstrates that balanced fine-tuning on Tamil data improves Tamil recognition, which is unsurprising. A stronger test of the contribution would be comparing against (a) a version of Polyglot-Lion trained on the unbalanced corpus (to isolate the effect of upsampling specifically), or (b) Whisper-large-v3-turbo fine-tuned on the same balanced data (to isolate the effect of the base model choice).

Claim 2: Language-agnostic decoding "makes the model robust to the code-switching patterns prevalent in Singapore speech."

This claim is not directly supported by the reported experiments. The paper evaluates on 12 monolingual test sets—each containing audio in a single language, with no code-switching within utterances. The evaluation demonstrates that the model can recognize each of the four languages individually without language tags, which is evidence for implicit language identification. But this does not constitute evidence for robustness to code-switching. Recognizing a monolingual Tamil utterance and recognizing an utterance that switches between English and Tamil mid-sentence are fundamentally different tasks—the latter requires the model to track two phonological systems simultaneously, handle language transitions, and produce mixed-language output. The paper acknowledges this gap explicitly in the limitations section:

"The current evaluation does not include any code-switched test sets—such as the SEAME corpus (Lyu et al., 2010) or the CS-Singlish benchmark—which is a significant limitation given that code-switching is the norm rather than the exception in everyday Singapore speech."

The claim about code-switching robustness is therefore aspirational—the design choice is motivated by code-switching scenarios, but the paper presents no experimental evidence that the design actually improves performance in those scenarios. This is a significant gap between the motivation and the validation.

Claim 3: Comprehensive multilingual benchmarking across 12 standard datasets with direct comparison against eight published baselines.

This claim is fully supported. The paper evaluates on exactly 12 test sets: 2 English (Librispeech, NSC), 4 Mandarin (AISHELL-1, AISHELL-3, Common Voice, Fleurs), 4 Tamil (Common Voice, SLR65, SLR127, Fleurs), and 2 Malay (Mesolitica, Fleurs). Eight baselines are evaluated on the same benchmarks under the same conditions (inference-only on the same GPU). The results are reported transparently, including catastrophic failures (Qwen2.5-Omni on Tamil) without sweeping them under an aggregate. The exclusion of the catastrophic Tamil results from the average is explicitly noted and justified (they would "distort cross-system comparison"), and the excluded values are still reported in full in Table 2. This is a robust and honest evaluation protocol.

A minor concern: the 12 benchmarks are not equally sized or equally difficult. The unweighted average error rate treats a 2,619-utterance Librispeech test set and a 9,999-utterance Mandarin Common Voice test set as equal contributors, which gives disproportionate weight to smaller benchmarks. The paper does not report a weighted average or a macro-average across languages that would account for this. In practice, the ranking between Polyglot-Lion-1.7B (14.85) and MERaLiON-2 (14.32) is close enough that a different weighting scheme could change the ordering—though the paper does not claim Polyglot-Lion beats MERaLiON-2, only that it "closely matches" it.

Claim 4: Polyglot-Lion achieves "233× lower estimated training cost" and "approximately 20× faster inference" than MERaLiON-2-10B-ASR.

The inference speed claim is well-supported. Table 3 shows Polyglot-Lion-1.7B at 0.1038 s/sample vs. MERaLiON-2 at 2.0152 s/sample—a 19.4× difference, which rounds to "approximately 20×." The measurement conditions are consistent (same GPU, same evaluation sets). The standard deviations are reported and reasonable. This claim is solid.

The training cost claim requires more careful scrutiny. The 233× figure compares Polyglot-Lion's fine-tuning cost ( $81) to MERaLiON-2's full training cost ($ 18,862). These are not comparable categories. MERaLiON-2's $18,862 covers training a 10B-parameter model from some initialization (likely continued pretraining from a base model) on 120,000 hours of speech using 128 GPUs. Polyglot-Lion's$ 81 covers fine-tuning a 1.7B-parameter pretrained model on 783 hours of speech using 1 GPU. A fair comparison would need to account for:

The cost of pretraining Qwen3-ASR. The base model was not free—it required large-scale pretraining. That cost is amortized across all downstream users of Qwen3-ASR, but it is not zero for the system as a whole. If the goal is to build a Singapore ASR system from scratch, the pretraining cost must be included (or at least estimated and discussed). If the goal is to adapt an existing pretrained model, the fine-tuning cost alone is the relevant metric—but then the comparison is between fine-tuning cost (Polyglot-Lion) and full training cost (MERaLiON-2), which overstates the advantage.
MERaLiON-2's possible fine-tuning cost. If MERaLiON-2 also started from a pretrained checkpoint and fine-tuned on Singapore-specific data, then its fine-tuning cost would likely be lower than $18,862 (since it would not require training from scratch). The paper does not specify whether MERaLiON-2 was trained from scratch or fine-tuned, but if it was fine-tuned, comparing its fine-tuning cost to Polyglot-Lion's would be more informative.
Hardware differences. RTX PRO 6000 and H100 are different GPU generations with different FLOP/s per dollar. The cost comparison conflates hardware efficiency with algorithmic efficiency. A more controlled comparison would measure total FLOPs used for training, which abstracts away hardware pricing and is more informative about the fundamental computational efficiency of the approaches. The paper does not report training FLOPs.
Training data differences. MERaLiON-2 was trained on approximately 120,000 hours of speech—153× more than Polyglot-Lion's 783 hours. Some of MERaLiON-2's accuracy advantage may come from this data volume rather than from model capacity or training methodology. The cost comparison does not account for data acquisition and curation costs, which can be substantial (especially for proprietary data).

These caveats do not invalidate the claim—$81 is genuinely and impressively cheap—but they qualify it. The 233× reduction should be understood as the cost difference between (a) fine-tuning a publicly available pretrained model on public data using a single consumer GPU, and (b) training a specialist model from scratch (or near-scratch) on a large proprietary-public corpus using an industrial GPU cluster. This is a specific type of cost advantage that primarily benefits practitioners who can leverage existing pretrained models and have access to (or can assemble) public training data for their target languages.

Experiments that would have strengthened the paper but were not run:

Ablation of balanced upsampling vs. unbalanced training. Training Polyglot-Lion on the raw (unbalanced) corpus with all else held equal would quantify how much of the Tamil and Malay improvement comes from upsampling specifically versus from the base model seeing any Tamil/Malay fine-tuning data at all. This is the most important missing experiment.
Ablation of language-agnostic decoding vs. tagged decoding. Training Polyglot-Lion with language tags (e.g., <|en|>, <|zh|>, <|ta|>, <|ms|>) on the balanced corpus would quantify whether language-agnostic decoding helps, hurts, or is neutral for monolingual recognition accuracy, and would provide a baseline for code-switching evaluation.
Fine-tuning Whisper on the same balanced corpus. This would test whether the gains are specific to the Qwen3-ASR base model or whether any strong pretrained encoder-decoder benefits similarly from balanced fine-tuning. The Qwen3-ASR bases catastrophically fail on Tamil; Whisper has moderate Tamil performance (74.50 WER on CV). Would balanced fine-tuning close the gap for Whisper too, or does the base model's initial Tamil capability matter?
Evaluation on code-switched benchmarks. As the paper acknowledges, this is a "significant limitation." Without code-switched evaluation, the language-agnostic design's main motivation remains untested.
Varying the upsampling ratio. Testing whether 25% per language is optimal, or whether a different distribution (e.g., 40% Tamil+Malay combined, 30% English, 30% Mandarin) would improve aggregate performance, would provide guidance for practitioners facing different imbalance ratios.
Multiple random seeds or cross-validation. The paper reports single-run results with no estimate of variance. Given the test sets are fixed and the fine-tuning is deterministic (the upsampling uses a fixed random seed), the reported numbers are point estimates with unknown sensitivity to training stochasticity (batch ordering, dropout, etc.).

Overall assessment. The experiments convincingly demonstrate that balanced fine-tuning of Qwen3-ASR on public data produces a Singapore multilingual ASR system that dramatically improves on the base models' low-resource language performance, achieves competitive accuracy with a much larger and more expensive specialist system, and does so at a training cost that makes the approach accessible to resource-constrained practitioners. The results on English, Mandarin, and Malay are strong; the Tamil results show massive improvement from a catastrophic baseline but leave a clear gap to MERaLiON-2. The inference speed advantage is well-documented and practically meaningful. However, two of the paper's key claims—that language-agnostic decoding contributes to code-switching robustness, and that the specific upsampling design is responsible for the gains rather than the mere presence of balanced fine-tuning data—are asserted but not experimentally isolated or validated. The cost comparison, while directionally correct, conflates fine-tuning with full training and would benefit from greater specificity about what is being compared. The most valuable contribution is the demonstration that a simple, deterministic recipe applied to a public base model and public data can produce a near-SOTA system at negligible cost—a result that, even with the above caveats, substantially lowers the barrier to entry for multilingual ASR research in linguistically diverse regions.

6. Limitations and Trade-offs

6.1 The Language-Agnostic Claim Is Not Validated Against Its Primary Motivation: Code-Switching

The assumption or constraint. The paper's second explicit contribution is "language-agnostic decoding"—removing language-tag conditioning so that the model "identifies the spoken language implicitly from acoustic features alone, making it robust to the code-switching patterns prevalent in Singapore speech" (Section 1). The motivation is explicitly deployment-focused: in Singapore, "speakers routinely alternate between English, Mandarin, Tamil, and Malay within a single interaction, and in many deployment settings... the language of each audio segment is not known in advance" (Section 4.3). The paper argues that language tags introduce a "critical dependency" that "fails silently under language misidentification or in code-switched settings" (Section 2), citing Winata et al. (2021).

The consequence. The entire evaluation consists of 12 monolingual test sets—each containing audio in exactly one language with no intra-utterance language switching. Demonstrating that the model can recognize Tamil audio as Tamil and English audio as English without a language tag is evidence for implicit language identification, but it is not evidence for robustness to code-switching. Recognizing a monolingual Tamil utterance (where every phoneme belongs to Tamil) and recognizing an utterance that begins in English, switches to Tamil mid-sentence, and returns to English are fundamentally different tasks. The latter requires the model to simultaneously track multiple phonological systems, detect language boundaries without explicit markers, handle cross-lingual phonetic interference (e.g., Tamil-influenced English pronunciation), and produce mixed-language output text. The paper's claim that language-agnostic decoding "makes [the model] robust to the code-switching patterns prevalent in Singapore speech" is therefore an untested assertion, not an experimentally supported finding.

What evidence exists in the paper. The paper implicitly demonstrates that the model can perform per-utterance language identification across four typologically diverse languages (supported by the fact that English audio produces English text, Tamil audio produces Tamil text, etc., across 12 test sets). However, the paper does not: (a) evaluate on any code-switched benchmark such as SEAME (Lyu et al., 2010) or a CS-Singlish corpus, (b) measure language identification accuracy as a separate metric to quantify how reliably the model detects language boundaries, (c) compare against a version of Polyglot-Lion trained with language tags to determine whether the language-agnostic design improves, degrades, or leaves unchanged code-switching performance, or (d) test with synthetically constructed code-switched utterances by concatenating monolingual segments. The paper acknowledges this gap explicitly in Section 8:

"The current evaluation does not include any code-switched test sets—such as the SEAME corpus (Lyu et al., 2010) or the CS-Singlish benchmark—which is a significant limitation given that code-switching is the norm rather than the exception in everyday Singapore speech."

This is an honest disclosure, but it means one of the paper's three main design contributions (language-agnostic decoding) is motivated entirely by a scenario on which zero experimental evidence is provided.

Mitigation status. The paper flags code-switching evaluation as "future work" (Section 8), suggesting exploration of "code-switch-aware training objectives (Winata et al., 2020)." The limitation is therefore acknowledged but unaddressed in the current version. A practitioner considering Polyglot-Lion for a code-switching-heavy deployment (e.g., Singapore classroom transcription, customer service call routing) should be aware that the model's performance on mixed-language utterances is entirely unknown—it may work well (the balanced training may have induced language-agnostic representations that generalize), it may silently default to the dominant language of the utterance and mangle the minority-language segments, or it may produce garbled output at language boundaries. The paper provides no evidence to distinguish these possibilities.

6.2 The Difficulty Estimation Cost (Difficulty of Obtaining Balanced Data) Is Unaccounted For

The assumption or constraint. The paper's central methodological contribution—two-stage balanced upsampling (Algorithm 1)—assumes access to a pre-assembled, language-labeled, pre-segmented training corpus where every utterance's language is known and every dataset is already organized by language. The algorithm equalizes utterance counts across languages, but it does not address how one obtains language-labeled audio in the first place. For the paper's specific setting, this is straightforward because the authors use existing public benchmarks (Librispeech is English, AISHELL is Mandarin, etc.) where language labels are implicit in the dataset identity. However, for a practitioner adapting this recipe to a new multilingual setting—say, a region with under-documented languages or dialect continua—assembling a language-labeled corpus of sufficient size is a substantial, non-trivial data engineering effort that the paper's cost analysis does not account for.

The consequence. The paper reports a training cost of $81, but this figure covers only GPU rental for fine-tuning. It does not include: (a) the cost of identifying, downloading, and preprocessing 12 public datasets (which the authors did, but which required significant human effort to locate appropriate corpora for each language, verify licenses, and standardize formats), (b) the cost of language labeling if one is starting from unlabeled or mixed-language audio (not the case here, but would be in many real deployments), (c) the cost of the pretrained Qwen3-ASR base model itself—which was produced by large-scale pretraining at unknown but certainly non-trivial expense, or (d) the cost of transcription for any custom or domain-specific audio that a deployer might need to add to improve performance on their specific use case (the paper acknowledges in Section 8 that closing the gap on Singapore-accented English and Tamil may require "Singapore-local speech data" not in the current training set). The$ 81 figure is therefore a lower bound on the cost of reproducing Polyglot-Lion from scratch, and the true cost for a practitioner starting without a pre-curated multilingual corpus could be substantially higher—potentially by orders of magnitude if data collection or annotation is required.

What evidence exists in the paper. Table 1 documents that the training data comprises 12 publicly available datasets, and Appendix A provides download links and licenses. This transparency is commendable and enables exact reproduction. But the paper does not estimate the human effort or cloud storage/bandwidth costs of assembling and preprocessing these datasets. The 233× cost reduction claim in Section 6.3 compares $81 (GPU rental) to$ 18,862 (GPU rental for MERaLiON-2), but these numbers are only directly comparable if both figures represent the same category of cost. MERaLiON-2's training likely also required data engineering effort not captured in its $18,862 estimate, so the comparison is not obviously biased in either direction—but neither figure is a comprehensive total cost of ownership.

The more subtle issue is that the paper's method depends on access to language-labeled training data with clear language boundaries—an assumption that holds for curated benchmarks but breaks in many real-world multilingual settings where audio is unlabeled or where languages are intermixed within recordings. The balanced upsampling algorithm cannot operate without knowing which utterances belong to which language, and the paper provides no guidance on how to obtain or approximate these labels in less curated settings.

Mitigation status. Not addressed. The paper does not discuss data acquisition costs, data labeling requirements, or strategies for handling unlabeled multilingual audio. The $81 figure is presented as the training cost without caveats about what it excludes. A practitioner should budget additional time and resources for data assembly, particularly if their target languages lack the wealth of public benchmarks available for Singapore's official languages. The implicit assumption—that public corpora sufficient for balanced training exist for the target languages—may not hold in many settings where the need for low-cost multilingual ASR is greatest.

6.3 The Accuracy Gap on Tamil and Singapore-Accented English Remains Substantial for Production Use

The assumption or constraint. The paper's central accuracy claim is that Polyglot-Lion-1.7B "closely matches" MERaLiON-2-10B-ASR (14.85 vs. 14.32 average error rate) while being 6× smaller. This aggregate masks significant per-language gaps on the two most practically important benchmarks for Singapore deployment: Singapore-accented English (NSC) and Tamil. On NSC, Polyglot-Lion-1.7B trails MERaLiON-2 by 0.66 WER (5.28 vs. 4.62)—a 14% relative gap. On Tamil Common Voice, the gap is 7.41 WER (39.19 vs. 31.78)—a 23% relative gap. On Tamil SLR127, the gap is 4.41 WER (26.83 vs. 22.42). These gaps are not random noise; they are consistent across all Tamil benchmarks and are large enough to matter in production transcription scenarios where every percentage point of WER translates to downstream errors in search, indexing, or subtitling.

The consequence. The paper frames Polyglot-Lion as a practical alternative to MERaLiON-2 for resource-constrained practitioners, but the decision depends critically on the deployment's language mix. For an application that primarily handles English and Mandarin (e.g., transcription of parliamentary proceedings, which are predominantly in English with some Mandarin), Polyglot-Lion-1.7B is arguably better than MERaLiON-2—it achieves lower error rates on Librispeech (2.10 vs. 2.54), AISHELL-1 (1.45 vs. 3.09), and AISHELL-3 (1.86 vs. 4.07), while being 20× faster and 233× cheaper to adapt. For an application that must handle Tamil reliably (e.g., a government service hotline serving Tamil-speaking citizens, or media monitoring that includes Tamil-language channels), the 23% relative gap on Tamil Common Voice and 20% gap on SLR127 may be unacceptable—a 39.19 WER means roughly 4 out of every 10 words are incorrect, which is functional for gist understanding but unreliable for verbatim transcription. A practitioner would need to weigh whether the 233× cost savings justify this accuracy degradation for their specific use case, and the paper provides no guidance on this tradeoff.

The paper attributes the Tamil gap to MERaLiON-2's "6× larger capacity and likely inclusion of larger Tamil-specific training data" (Section 6.1), which is plausible but unverified (MERaLiON-2's training data composition is not public). The NSC gap is attributed to "Singapore-specific pronunciation patterns, prosodic features, and code-mixed Singlish constructions" that "remain challenging at 1.7B parameter scale without access to the larger Singapore-specific training corpora that MERaLiON-2 likely leverages" (Section 8). These attributions are reasonable but highlight a fundamental tension in the paper's narrative: Polyglot-Lion achieves near-SOTA accuracy at dramatically lower cost by accepting a cap on performance for the most challenging languages and accents, and that cap may be below the threshold required for certain production deployments.

What evidence exists in the paper. Table 2 provides the per-benchmark breakdown that reveals these gaps. The paper is transparent about them—Section 6.1 reports the Tamil and NSC results without attempting to minimize the differences, and Section 8 explicitly lists "remaining accuracy gaps" as the first limitation. The Tamil gap is particularly well-documented: across all four Tamil benchmarks, MERaLiON-2 leads by margins of 7.41, 3.62, 4.41, and 8.60 WER on CV, SLR65, SLR127, and Fleurs respectively.

Mitigation status. The paper suggests two directions for closing these gaps in future work (Section 8): "(1) incorporating Singapore-local speech data such as the National Speech Corpus (Koh et al., 2019) for continued domain-adaptive pretraining, and (2) applying cross-lingual transfer from Tamil text corpora via speech-text joint training (Bapna et al., 2022)." These are sensible suggestions but are presented as future work, not as tested solutions. The paper does not report any experiments with additional Singapore-specific data or cross-lingual transfer, meaning the reported numbers represent the best achievable with the current recipe and public data alone. A practitioner needing Tamil WER below 30% or NSC WER below 5% cannot achieve it with Polyglot-Lion as released and would need to either invest in the suggested extensions (with uncertain payoff) or use MERaLiON-2 despite its cost.

6.4 The Contribution of Individual Design Choices Is Not Experimentally Isolated

The assumption or constraint. The paper presents two design choices as key contributions: balanced upsampling (Section 4.2) and language-agnostic decoding (Section 4.3). These are introduced as distinct mechanisms with distinct motivations—upsampling addresses data imbalance, language-agnostic decoding addresses code-switching robustness. However, the paper evaluates only the compound effect of applying both simultaneously: Polyglot-Lion is trained with both balanced upsampling and language-agnostic decoding applied together, and is compared against unmodified Qwen3-ASR bases that have neither (implicitly: they were trained on unbalanced data with language tags). There is no experiment training Polyglot-Lion with balanced upsampling but with language tags (to isolate the effect of upsampling alone), and no experiment training with language-agnostic decoding but without balanced upsampling (to isolate the effect of language-agnostic decoding alone).

The consequence. The paper cannot distinguish between three alternative hypotheses for why Polyglot-Lion works:

Balanced upsampling is responsible for nearly all gains, and language-agnostic decoding is neutral or slightly harmful for monolingual accuracy. Under this hypothesis, a version of Polyglot-Lion trained with language tags on the balanced corpus would achieve equal or better monolingual accuracy (since the language tag provides a helpful inductive bias), and the paper's language-agnostic design is motivated entirely by code-switching scenarios that were never tested.
Language-agnostic decoding is responsible for some of the gains by forcing the model to develop more robust language-specific representations. Under this hypothesis, the balanced upsampling provides equal data, but the language-agnostic constraint forces the model to learn acoustic features that distinguish the languages, which transfers to better recognition within each language.
Both components are necessary and interact synergistically. This is the paper's implicit claim, but it is untested.

This ambiguity matters for practitioners who want to adapt the recipe to their own setting. If balanced upsampling alone is sufficient, a practitioner can implement just Algorithm 1 and keep their existing language-tag conditioning, avoiding any changes to their inference pipeline. If language-agnostic decoding is necessary for the gains on low-resource languages, the practitioner must restructure their training and inference to remove language tags, which may require changes to tokenizers, data loaders, and downstream processing. Without an ablation, the practitioner cannot make an informed decision about which components to adopt.

The most critical missing ablation is Polyglot-Lion trained on the unbalanced (raw) corpus with all else held equal. This would quantify how much of the Tamil and Malay improvement comes from the model simply seeing any Tamil/Malay fine-tuning data at all, versus from the specific upsampling strategy that equalizes per-language coverage. The Qwen3-ASR bases produce catastrophic Tamil WER (~120–140%), suggesting they had essentially zero Tamil exposure during pretraining. It is possible that simply fine-tuning on the unbalanced corpus—where Tamil still constitutes ~20% of training hours (215.58 out of 968.83 total hours from Table 1)—would produce most of the observed Tamil improvement, and that the upsampling to exactly 25% provides only marginal additional gain. The paper cannot rule out this alternative because the experiment was not run.

What evidence exists in the paper. None. There are no ablation experiments in the paper. The Analysis section (Section 7) discusses the "Effect of Language Balancing" but does so by comparing Polyglot-Lion to the unmodified Qwen3-ASR bases—which differ in both upsampling and language tags—rather than by comparing to variants of Polyglot-Lion that ablate individual components. The paper reports only two training runs (0.6B and 1.7B), both using the full recipe. Given that each training run costs $81 and 48 hours, running the key ablations (with language tags, without upsampling) would cost at most a few hundred dollars and a few GPU-days—well within the paper's stated goal of making ASR research accessible. The absence of these ablations is therefore a missed opportunity rather than an infeasible requirement.

Mitigation status. Not addressed. The paper does not acknowledge this as a limitation, does not discuss which components are load-bearing, and does not suggest ablation experiments as future work. A practitioner seeking to understand which elements of the recipe are essential would need to run these ablations themselves.

6.5 Results Are From a Single Base Model Family on a Single Domain (Read and Semi-Spontaneous Speech)

The assumption or constraint. All experiments use the Qwen3-ASR base model family (Shi et al., 2026), specifically the 0.6B and 1.7B Conformer encoder–Transformer decoder checkpoints. The paper states that it selected Qwen3-ASR because these models are publicly available, come in two sizes, and achieve competitive zero-shot performance (Section 4.1). However, the paper does not test whether the balanced fine-tuning recipe transfers to other base model architectures (e.g., Whisper's encoder-decoder, HuBERT-based systems, or audio-language models like SeaLLMs-Audio) or to other base model families within the same architecture class. Furthermore, the training and evaluation data consist primarily of read speech (Librispeech, AISHELL, Fleurs) and semi-spontaneous elicited speech (Common Voice, NSC), with limited representation of fully spontaneous conversational speech, telephone-quality audio, or noisy far-field recordings.

The consequence. Two related but distinct generalization gaps arise:

Base model dependence. The paper's results may be specific to properties of the Qwen3-ASR pretraining that are not shared by other models. For instance, Qwen3-ASR's pretraining may have included some exposure to Tamil and Malay (the zero-shot WER of ~120–140% on Tamil suggests minimal but non-zero exposure—the model produces some structure rather than pure noise, though it's functionally unusable), and the balanced fine-tuning may be amplifying this latent knowledge. A base model with zero Tamil exposure during pretraining might not respond to balanced fine-tuning in the same way, because there would be no latent representations to amplify. Conversely, a base model with stronger initial Tamil performance (e.g., Whisper at 74.50 WER on Tamil CV) might benefit more or less from balanced fine-tuning. The paper's claim that "careful data balancing and lightweight fine-tuning of strong pretrained models can unlock near state-of-the-art multilingual ASR performance" (Section 8) implicitly assumes generalizability across base models that is not tested.

Domain dependence. The paper's training and evaluation corpora are overwhelmingly clean, read, or elicited speech recorded in controlled conditions. Librispeech is audiobook reading. AISHELL is studio-recorded read speech. Fleurs is read sentences from a translation benchmark. Common Voice is crowdsourced but typically recorded by volunteers in quiet environments reading prompted sentences. NSC includes conversational speech but in controlled collection settings. The paper does not evaluate on spontaneous conversational speech (e.g., meeting recordings, call center audio, broadcast interviews), noisy acoustic environments (e.g., street noise, cafeteria), or telephone-bandwidth audio. The 14.85 average error rate may not hold in these more challenging acoustic conditions, which are common in the deployment scenarios the paper targets (broadcast media monitoring, classroom transcription, customer service). The paper does not discuss this domain gap or report any robustness evaluations.

What evidence exists in the paper. The datasets listed in Table 1 and Appendix A are all standard benchmarks consisting primarily of read or prompted speech. The paper does not include any conversational speech corpora (e.g., Switchboard, AMI, or Singapore-specific conversational datasets), any noisy speech benchmarks (e.g., CHiME, LibriSpeech test-other is included but is still read speech), or any telephone-bandwidth corpora. The NSC corpus includes some conversational material but the paper does not break out performance by speaking style within NSC, reporting only aggregate WER. The inference speed measurement (Table 3) uses the same evaluation sets, meaning speed is measured on clean, relatively short utterances and may not reflect throughput on longer, more variable conversational audio.

Mitigation status. Not addressed. The paper does not discuss domain generalization as a limitation, does not test on conversational or noisy speech, and does not suggest domain robustness evaluation as future work. A practitioner planning to deploy Polyglot-Lion in a call center, classroom, or media monitoring setting should budget for additional evaluation on in-domain audio to determine whether the accuracy reported on clean benchmarks transfers to their acoustic conditions. The balanced fine-tuning recipe may still work well, but there is no evidence either way.

6.6 The Balanced Upsampling Strategy Assumes Language Labels Are Available and Boundaries Are Clear

The assumption or constraint. Algorithm 1 requires that every training utterance be assigned to exactly one language before upsampling begins. The algorithm's first line is "Require: Language set L; per-language dataset collections {D_l}," which assumes that the data has already been partitioned into language-specific subsets. For the paper's setting, this is satisfied because the training corpora are all language-specific benchmarks (Librispeech contains only English, AISHELL contains only Mandarin, etc.). However, in many real-world multilingual deployment scenarios, training audio comes from sources where language boundaries are unknown or ambiguous: broadcast recordings may contain multiple languages, user-submitted audio may not be language-tagged, and dialect continua may blur the distinction between "separate languages" that the model treats as independent.

The consequence. The balanced upsampling recipe is not directly applicable to unlabeled multilingual audio corpora. A practitioner with access to, say, 1,000 hours of Singapore television broadcasts (which contain English, Mandarin, Tamil, and Malay intermixed without segment-level language labels) cannot apply Algorithm 1 without first running a language identification system to segment and label the audio by language—which introduces exactly the kind of external dependency (a separate LID model) that the paper's language-agnostic decoding was designed to avoid. If the LID system makes errors (as it will, especially on short segments or code-switched utterances), those errors propagate into the training data: Tamil segments mislabeled as Malay will be upsampled into the Malay training set, teaching the model incorrect acoustic-phonetic mappings. The paper provides no guidance on how to handle unlabeled or weakly labeled multilingual data, nor does it discuss the sensitivity of the upsampling algorithm to language labeling errors.

This limitation is related to but distinct from Limitation 6.2 (data acquisition cost). Even if a practitioner has already assembled a large corpus of in-domain multilingual audio, they may not have utterance-level language labels, and the paper's recipe provides no mechanism for training without them. The paper implicitly assumes the availability of cleanly language-segmented corpora—an assumption that holds for academic benchmarks but not for many real-world data sources.

What evidence exists in the paper. Table 1 lists all training datasets as language-specific (each row is assigned to a single language). The paper does not discuss any mixed-language or unlabeled data, does not describe any language identification preprocessing step, and does not report the accuracy of language labels in the training data (they are assumed correct because the datasets are curated benchmarks). There is no discussion of how the approach would handle datasets like SEAME (Mandarin-English code-switched speech) where utterances inherently contain multiple languages—would these be excluded? Assigned to the dominant language? Split into monolingual segments? The paper does not address this.

Mitigation status. Not addressed. The paper does not acknowledge the language labeling assumption as a limitation, does not discuss scenarios where language labels are unavailable or noisy, and does not suggest methods for training on unlabeled multilingual data. The upsampling algorithm is presented as fully general ("regardless of how skewed the original corpus distribution is"), but this generality applies only to the distributional skew—the algorithm still requires that the original corpus be partitioned into language-specific subsets. A practitioner with unlabeled multilingual data would need to solve the language identification problem before applying the paper's recipe, and the paper provides no guidance on how to do so or how labeling errors would affect downstream ASR performance.

7. Implications and Future Directions

How This Work Changes the Landscape

The core shift: multilingual ASR adaptation is reframed as an accessibility problem, not a scale problem.

This paper does not introduce a novel architecture, a new training objective, or a theoretical breakthrough. What it introduces is a reframing of multilingual ASR development from a scale-first paradigm—where covering more languages with higher accuracy demands larger models, more GPUs, and bigger budgets—to an accessibility-first paradigm, where the relevant question is not "what is the state-of-the-art accuracy ceiling?" but "what accuracy can a practitioner achieve with public data and a single GPU, and is that accuracy good enough for real deployment?"

This reframing is not merely rhetorical. The paper makes it concrete through specific, verifiable numbers: $81 for fine-tuning versus$ 18,862 for the comparable specialist system, 0.10 s/sample inference versus 2.02 s/sample, a single RTX PRO 6000 GPU versus 128 H100s. These numbers transform the conversation from "larger models are better" to "larger models are better only if the accuracy gain justifies the cost multiplier, and for many deployment scenarios, it does not." The paper demonstrates this empirically: on English and Mandarin benchmarks, Polyglot-Lion-1.7B outperforms the 6× larger MERaLiON-2-10B-ASR (Librispeech: 2.10 vs. 2.54; AISHELL-1: 1.45 vs. 3.09; AISHELL-3: 1.86 vs. 4.07), meaning the larger model's additional capacity is not translating to better recognition on these languages—it may be allocated to capabilities (broader language coverage, general audio understanding) that are irrelevant to the Singapore-specific task. The paper thus makes the case that targeted specialization through balanced fine-tuning can be more accurate than generic scale for a specific deployment domain, while being dramatically cheaper.

What this means for the field's research priorities.

The paper redirects attention from frontier-pushing (training ever-larger models on ever-larger datasets to push the aggregate accuracy ceiling) toward gap-closing (taking existing strong pretrained models and efficiently adapting them to under-served languages and domains). This is not a rejection of large-scale pretraining—the paper is explicit that Qwen3-ASR's strong English and Mandarin priors are essential to the recipe—but a recognition that the last mile of adaptation has been systematically under-explored relative to pretraining scale. If a 1.7B model trained for $81 can achieve 39.19 WER on Tamil (down from 139.96), the bottleneck for low-resource language ASR is not fundamentally a capacity problem; it is a data distribution and training procedure problem that can be addressed at modest cost.

The paper also implicitly challenges the common practice of reporting only aggregate multilingual metrics. Table 2 reveals that the unmodified Qwen3-ASR-1.7B achieves an average error rate of 53.76—which sounds mediocre but not catastrophic—while being completely unusable on Tamil (WER > 120%). The paper's practice of reporting per-language, per-benchmark results and transparently noting exclusions (the catastrophic Tamil failures from Qwen2.5-Omni) sets a standard for honest multilingual evaluation that, if widely adopted, would prevent the field from celebrating models that are multilingual in name only. The "catastrophic failure boundary" documented in Section 4 (Innovation 4) is a diagnostic that the field should adopt: a model that achieves 3 WER on English and 130 WER on Tamil is not "multilingual with room for improvement"—it is bilingual with token coverage of other languages, and reporting only the average hides this.

Reconciling prior contradictions.

The paper does not resolve a specific active debate in the way that, for example, a paper showing that two conflicting findings are both true under different conditions might. However, it does reconcile an implicit tension in the multilingual ASR literature between two approaches: (1) training enormous general-purpose models on web-crawled data (Whisper, MMS) that achieve broad but shallow coverage, and (2) training expensive specialist systems on curated regional data (MERaLiON-2) that achieve deep but narrow coverage. The paper's implicit argument is that this is a false dichotomy: a third path exists—fine-tune a general-purpose pretrained model on balanced public data—that captures most of the specialist system's accuracy at a fraction of the cost, without requiring access to proprietary data or industrial compute. This path is not new in concept (fine-tuning pretrained models is standard practice across NLP), but the paper demonstrates that it is dramatically under-exploited in multilingual ASR, where the default assumptions have been that you either use the pretrained model as-is (accepting poor low-resource performance) or train a specialist from scratch (accepting high cost).

Which research directions become more attractive.

The paper makes data-centric efficiency research more attractive relative to architecture research. The finding that deterministic upsampling—a data preprocessing step with zero learnable parameters—produces a 72% relative WER reduction on Tamil suggests that improvements to data mixing strategies may yield larger gains per dollar than improvements to model architecture or training objectives. The finding that language-agnostic decoding works across four typologically diverse languages (without experimental isolation from upsampling, to be clear) suggests that explicit language conditioning may be an over-used inductive bias that papers over data imbalance problems rather than solving them. Researchers interested in low-resource multilingual ASR would be well-served by focusing on: (a) how to construct balanced training corpora from unlabeled or weakly labeled multilingual data, (b) how to estimate the optimal per-language sampling ratio without expensive hyperparameter sweeps, and (c) how to combine balanced sampling with other data efficiency techniques (curriculum learning, data augmentation, self-training).

Which research directions become less attractive.

The paper implicitly makes brute-force scaling of specialist multilingual ASR systems less attractive as a research direction, at least for settings where strong pretrained base models already exist. If a 1.7B model fine-tuned for $81 achieves 14.85 average error rate versus a 10B model trained for$ 18,862 achieving 14.32, the marginal return on the additional 9.5× parameters and 233× cost is 0.53 average error rate points—a gain that may not justify the investment for most deployment scenarios. This does not mean specialist systems are obsolete (MERaLiON-2 still leads on Tamil and Singapore English, and the paper does not test Polyglot-Lion on code-switching where specialist training data may matter more), but it shifts the burden of proof: a new specialist system must demonstrate that its accuracy advantage over a well-tuned fine-tuned general-purpose model is large enough and valuable enough to justify its cost premium. Papers that report only accuracy improvements without cost analysis will increasingly be seen as incomplete.

Follow-Up Research This Work Enables

Ablation of the individual contributions of balanced upsampling and language-agnostic decoding. The paper's two key design choices—deterministic language-balanced upsampling (Section 4.2) and language-agnostic decoding (Section 4.3)—are never evaluated independently. A direct follow-up would train four variants of Polyglot-Lion-1.7B on the same public corpus, all else held equal: (1) balanced upsampling + language-agnostic decoding (the current recipe), (2) balanced upsampling + language tags (e.g., <|en|>, <|zh|>, <|ta|>, <|ms|> prepended to decoder inputs), (3) unbalanced (raw) training + language-agnostic decoding, and (4) unbalanced training + language tags. This 2×2 ablation would cost approximately $324 (4 runs ×$ 81 each) and would definitively answer: does the upsampling account for nearly all the Tamil and Malay gains (in which case language-agnostic decoding is orthogonal and primarily valuable for code-switching), or does language-agnostic decoding itself contribute to monolingual accuracy by forcing the model to learn more robust language-specific representations? The comparison between variants 1 and 2 would also quantify the accuracy cost (or benefit) of removing language tags for monolingual recognition—which is essential information for a practitioner deciding whether to adopt the language-agnostic design for a deployment where code-switching is rare.

Evaluation on code-switched benchmarks to validate (or refute) the language-agnostic motivation. The paper's stated motivation for language-agnostic decoding is robustness to code-switching, but the evaluation uses only monolingual test sets. A follow-up study should evaluate Polyglot-Lion on standard code-switched benchmarks: SEAME (Mandarin-English code-switching; Lyu et al., 2010), the CS-Singlish benchmark if publicly available, and synthetically constructed code-switched utterances created by concatenating monolingual segments from the existing test sets with known language boundaries. The key comparison would be between Polyglot-Lion (language-agnostic) and a version trained with language tags on the same balanced corpus, evaluated on both monolingual and code-switched test sets. The hypothesis is that the language-agnostic variant should degrade less on code-switched utterances because it has no language-tag dependency to break. If this hypothesis is not supported—if both variants perform similarly, or if the language-tag variant actually performs better because the tag provides a useful prior that the model learns to override when acoustic evidence conflicts—then the paper's primary motivation for language-agnostic decoding would be falsified, and the design choice would be better justified on grounds of deployment simplicity (no need for pre-ASR language identification) rather than code-switching robustness.

Cross-base-model replication to test generalizability of the balanced fine-tuning recipe. The paper's results are specific to Qwen3-ASR base models. A follow-up should replicate the recipe with different base model families to determine which properties of the base model matter. Specifically: (1) fine-tune Whisper-large-v3-turbo on the same balanced public corpus (Whisper starts with 74.50 WER on Tamil CV versus Qwen3-ASR's 139.96—does balanced fine-tuning close the gap further, or does Whisper's already-stronger Tamil performance mean the marginal gain is smaller?), (2) fine-tune a HuBERT or wav2vec 2.0-based model that uses self-supervised pretraining rather than supervised multilingual pretraining (does the lack of explicit multilingual supervision during pretraining limit the gains from balanced fine-tuning, or can self-supervised representations be redirected just as effectively?), and (3) fine-tune an audio-language model like SeaLLMs-Audio-7B (does the larger capacity and LLM backbone provide additional benefit, or does the ALM architecture introduce optimization difficulties that make balanced fine-tuning less effective?). Each replication would cost roughly $81–$ 200 depending on model size, and collectively they would map the boundary conditions of the recipe: which pretraining paradigms, scales, and architectures benefit from balanced fine-tuning, and which do not.

Dynamic or learned upsampling ratios to optimize the accuracy-cost tradeoff across languages. The paper's 25%-per-language upsampling ratio is a fixed, uniform choice with no empirical justification beyond simplicity and the observation that it works. A follow-up could systematically sweep the per-language sampling ratios to map the tradeoff curve between high-resource and low-resource performance. For example, training variants where Tamil and Malay collectively receive 20%, 30%, 40%, 50%, and 60% of training utterances (split equally between them), with English and Mandarin splitting the remainder. This would answer: is the equal-25% configuration optimal, or would a more aggressive upsampling of Tamil and Malay (e.g., 35% each) further improve low-resource performance without unacceptable degradation on English and Mandarin? Going further, a learned approach could use a lightweight model to predict, for each training example, how much the current model would benefit from seeing it (based on the model's current per-language validation loss), and dynamically adjust the sampling distribution during training—essentially online curriculum learning for multilingual ASR. The paper's deterministic upsampling provides a strong baseline against which to compare such adaptive methods.

Incorporation of unlabeled or weakly labeled multilingual audio via semi-supervised balanced training. The paper's upsampling algorithm requires language-labeled training data, which limits its applicability to settings where cleanly segmented corpora exist. A follow-up could relax this requirement by integrating language identification into the training loop: start with a small amount of language-labeled data (the public benchmarks used in this paper) to train an initial Polyglot-Lion model, then use that model to pseudo-label a larger corpus of unlabeled Singapore-relevant audio (broadcast recordings, parliamentary proceedings, YouTube content), assigning each utterance a language label based on the model's implicit language identification. These pseudo-labeled utterances could then be added to the training set with the balanced upsampling algorithm applied to the combined labeled + pseudo-labeled corpus. The key question is whether pseudo-labeling errors (misidentified languages) compound during training or whether the balanced sampling provides enough robustness to tolerate some label noise. This would extend the paper's approach from "balanced fine-tuning on curated public benchmarks" to "balanced fine-tuning on any available in-domain audio," dramatically increasing the recipe's practical applicability.

Stress-testing on spontaneous conversational speech and noisy acoustic conditions. The paper evaluates on clean, primarily read speech. A follow-up should evaluate Polyglot-Lion on: (a) spontaneous conversational speech (e.g., meeting recordings from the AMI corpus, call center audio if available, or Singapore-specific conversational data from NSC's conversational partition), (b) noisy conditions (additive noise at varying signal-to-noise ratios, reverberation, or real-world noisy recordings), and (c) telephone-bandwidth audio (8 kHz sampling rate versus the 16 kHz the model was trained on). The goal is to determine how much of the 14.85 average error rate reflects genuine speech recognition capability versus the cleanliness of the evaluation data. If WER doubles on conversational speech (which is typical when moving from read to spontaneous speech), the model may still be practically useful; if it quadruples, the deployment scenarios the paper targets (classroom transcription, media monitoring) may require additional robustness training that the current recipe does not address. The inference speed measurements should also be repeated on longer, more variable conversational utterances to verify that the 0.10 s/sample figure holds outside the controlled benchmark setting.

Practical Applications and Downstream Use Cases

Low-cost Singapore multilingual ASR for academic research and small enterprises. The most direct application is as a drop-in replacement for MERaLiON-2-10B-ASR in settings where the 233× training cost reduction and 20× inference speed improvement outweigh the 0.53-point average error rate gap. A research group studying Singapore sociolinguistics, for example, could fine-tune Polyglot-Lion on their specific domain data (classroom recordings, sociolinguistic interviews, historical archives) for $81 per adaptation run, enabling iterative experimentation that would be impossible at MERaLiON-2's price point. A small enterprise building a Singapore-focused voice assistant or transcription service could deploy Polyglot-Lion-0.6B on edge devices (0.10 s/sample inference, 0.6B parameters fitting in <2 GB of memory) without the GPU cluster required to serve MERaLiON-2 at scale. The paper's finding that the 0.6B variant achieves 16.52 average error rate versus 14.85 for the 1.7B variant—a modest 1.67-point penalty for 2.8× fewer parameters—makes the smaller model particularly attractive for on-device deployment where memory and power constraints are binding.

Rapid prototyping of ASR for under-resourced languages in linguistically diverse regions. The paper's recipe is deliberately simple—deterministic upsampling, standard fine-tuning hyperparameters, no novel architecture—and can be applied to any region with a similar linguistic profile: multiple official or widely-spoken languages where public speech corpora exist but are imbalanced in size, and where a strong multilingual pretrained model is available. Examples include: Malaysia (Malay, Mandarin, Tamil, English—similar to Singapore but with different dialect distributions), India (Hindi, Tamil, Telugu, Bengali, etc., with extreme imbalance across languages), South Africa (11 official languages including English, Afrikaans, Zulu, Xhosa), and Switzerland (German, French, Italian, Romansh). In each case, a practitioner can: (1) assemble public corpora for the target languages (using Common Voice, Fleurs, and language-specific benchmarks), (2) apply Algorithm 1 to balance the corpus, (3) fine-tune Qwen3-ASR or Whisper on a single GPU for 48 hours, and (4) obtain a functional multilingual ASR system for roughly $81 plus data assembly effort. The paper's finding that deterministic upsampling does not degrade high-resource language performance (English and Mandarin improve or stay flat after fine-tuning) is particularly important here: it means practitioners do not need to carefully tune a temperature parameter to avoid negative transfer—they can apply the equal-25% recipe and be confident that the dominant languages will not be harmed.

Cost-efficient batch transcription for government and media archives. Singapore government agencies and media organizations maintain large archives of audio content in multiple languages (parliamentary proceedings, court recordings, broadcast news, oral history collections). Transcribing these archives with MERaLiON-2 would cost approximately 20× more in GPU time than with Polyglot-Lion-1.7B (2.02 vs. 0.10 s/sample), and the accuracy difference on English and Mandarin—which likely constitute the majority of the archival content—actually favors Polyglot-Lion (e.g., Librispeech 2.10 vs. 2.54 WER; AISHELL-1 1.45 vs. 3.09 CER). For an archive of 10,000 hours of predominantly English and Mandarin audio (~6.3 million utterances at the paper's mean duration of 5.7 seconds), Polyglot-Lion would transcribe the entire archive in approximately 175 GPU-hours (at 0.10 s/sample) versus 3,500 GPU-hours for MERaLiON-2—a difference of roughly $70 versus$ 1,400 at typical cloud GPU rates. The Tamil and Malay segments would be less accurate with Polyglot-Lion (39.19 vs. 31.78 WER on Tamil CV), but for archival indexing and search—where the goal is to locate relevant segments rather than produce perfect verbatim transcripts—a 39 WER is often sufficient, and the segments can be flagged for human review if higher accuracy is needed. This application directly leverages the paper's central tradeoff: accept a modest accuracy degradation on the hardest languages in exchange for a 20× cost reduction that makes large-scale transcription economically viable.

When to Prefer This Method

The paper articulates an explicit tradeoff between Polyglot-Lion and MERaLiON-2-10B-ASR along three dimensions: accuracy, training cost, and inference speed. The decision rule is not reducible to a simple "prefer A over B" because the optimal choice depends on the deployment's language mix, accuracy requirements, and budget constraints. However, the paper's own data support the following guidance:

Prefer Polyglot-Lion when the deployment is predominantly English and Mandarin, regardless of budget. Polyglot-Lion-1.7B outperforms MERaLiON-2 on Librispeech (2.10 vs. 2.54 WER), AISHELL-1 (1.45 vs. 3.09 CER), AISHELL-3 (1.86 vs. 4.07 CER), and Mandarin Common Voice (4.91 vs. 8.83 CER). If your application involves primarily English and Mandarin audio (e.g., parliamentary transcription, English-Mandarin customer service), Polyglot-Lion is both more accurate and substantially cheaper—there is no tradeoff to make.
Prefer Polyglot-Lion when training budget is severely constrained (e.g., academic lab, startup, individual researcher). The $81 versus$ 18,862 training cost difference is not a marginal improvement; it is the difference between feasible and infeasible. The paper demonstrates that for an additional $81 (and potentially a few hundred dollars to run the missing ablations), a practitioner can achieve 14.85 average error rate—close enough to MERaLiON-2's 14.32 that the remaining gap matters only for the most demanding applications.
Prefer MERaLiON-2 when Tamil accuracy is mission-critical and the deployment budget can absorb the cost. On every Tamil benchmark, MERaLiON-2 leads by meaningful margins: 7.41 WER on Common Voice (39.19 vs. 31.78), 3.62 on SLR65, 4.41 on SLR127, 8.60 on Fleurs. If the application involves verbatim transcription of Tamil-language content (e.g., legal proceedings, medical dictation) where a 39 WER is unacceptable, the cost premium for MERaLiON-2 is justified. The paper does not provide evidence that Polyglot-Lion can close this gap with additional public data or training—it is a known limitation acknowledged as future work.
Prefer MERaLiON-2 when Singapore-accented English accuracy is critical and alternative data sources are unavailable. The 0.66 WER gap on NSC (5.28 vs. 4.62) is smaller than the Tamil gap but may matter in applications requiring high-accuracy transcription of Singlish speakers (e.g., broadcast subtitling, educational assessment). The paper attributes this gap to MERaLiON-2's likely access to proprietary Singapore-specific training data; a practitioner without access to similar data cannot expect to close it through fine-tuning alone.
Prefer Polyglot-Lion when inference latency or throughput is a binding constraint. The 20× inference speed advantage (0.10 vs. 2.02 s/sample) is the paper's most robust finding, measured on identical hardware across the same evaluation sets. For real-time applications (live captioning, voice assistants) where sub-second latency is required, or for batch processing at scale where GPU costs accumulate linearly with processing time, Polyglot-Lion dominates regardless of the accuracy comparison.
Neither model is validated for code-switched speech. For deployments where code-switching is the dominant mode of communication (e.g., informal Singapore conversations, Singlish-heavy contexts), the paper provides no evidence that either model performs well, and the language-agnostic design's claimed robustness to code-switching is untested. A practitioner in this setting should budget for code-switched evaluation before committing to either system.