Kaldi Chain TDNN vs GMM-HMM: A Practical Engineering Decision

The accuracy wall in a custom ASR project

You are building a speech recognizer for a specialized domain—perhaps clinical notes, a regional language, or noisy factory audio. You start with a Kaldi GMM-HMM recipe because it is the most documented path: extract MFCC features, train a Gaussian Mixture Model–Hidden Markov Model system, generate forced alignments, and decode. The baseline works, but word error rate stops improving after you add more data or tune the language model.

GMM-HMM models acoustic frames independently within a Markov framework. It is reliable for small corpora, but it cannot easily capture long-range acoustic context or optimize the full sequence directly. That is where Kaldi's chain architecture enters the decision.

What the chain pipeline changes

Kaldi's chain models train a Time Delay Neural Network (TDNN)—a feed-forward network that looks at a window of frames around each decision—using lattice-free Maximum Mutual Information (MMI). Instead of building expensive denominator lattices for every utterance, the chain method uses a simplified phone-level denominator graph to approximate competing word sequences. This makes sequence-discriminative training practical on commodity hardware.

The important engineering detail is that the chain pipeline is not a replacement for data preparation. You still need MFCC or filterbank features, cepstral mean and variance normalization (CMVN), and a prior GMM-HMM system to produce forced alignments and the denominator graph. The chain model consumes those GMM outputs as its starting point.

Decoding graph versus denominator graph

A common mistake is treating the chain denominator graph as the final decoding graph. It is not. The denominator graph is a training-time approximation of phone-level competition. For decoding, you still build an HCLG graph (HMM context, context-dependent phones, lexicon, grammar) and run a lattice-free decode, often followed by a second pass with an RNN language model for rescoring.

Worked example: moving from GMM to chain

Assume you have a Kaldi checkout at KALDI_ROOT, a prepared data directory at data/train, and a language directory at data/lang. The exact script names vary by recipe and Kaldi version, so treat the following as a pattern from standard egs/ recipes, not a guaranteed command list.

Run these from a Unix-like shell inside KALDI_ROOT/egs/your_recipe/s5. You need read access to the audio and transcripts and write access to data/ and exp/.

1. Run the shared feature and alignment stages:

./steps/train_mono.sh --nj 4 data/train data/lang exp/mono
./steps/align_si.sh --nj 4 data/train data/lang exp/mono exp/mono_ali

Expected check: exp/mono_ali/ should contain alignment files and the training log should end without ERROR.

1. Build the chain topology and train the TDNN:

./chain/train_tdnn.sh --stage 0 --train-stage -10 --data data/train --lang data/lang --ali-dir exp/mono_ali --dir exp/chain/tdnn

This is the state-changing step: it writes model checkpoints and logs under exp/chain/tdnn/. Training can run for hours or days depending on data size and hardware. A practical risk is disk exhaustion if you retain every checkpoint.

Expected check: after completion, exp/chain/tdnn/ should include final.mdl and a denominator artifact. If the directory is empty or the log shows a missing alignment path, stop and verify that exp/mono_ali/ matches the same data/train split.

1. Decode and score:

./chain/decode.sh --nj 4 data/test data/lang exp/chain/tdnn exp/chain/tdnn/decode_test
./steps/scoring/score_kaldi_wer.sh data/test data/lang exp/chain/tdnn/decode_test

Compare the reported WER against your GMM-HMM baseline decoded the same way. If the chain model does not improve held-out WER, the denominator graph, alignment quality, or TDNN architecture is the first place to investigate, not the decode script itself.

Trade-offs and limitations

• Dependency on GMM: You cannot skip the GMM-HMM alignment stage for a new language without either existing alignments or a forced-alignment substitute.
• Script brittleness: Kaldi recipes assume a Unix-like environment and hard-code many paths in conf/, local/, and path.sh. Adapting to a new domain usually means editing shell variables, not editing a single config file.
• Not a deployable service: Kaldi is a research toolkit. Production integration typically means wrapping binaries, exporting model parameters, or serving through a custom inference layer.
• Community forks: Active development in the main repository has slowed. Exact flags and script names differ across forks and versions, so pin your toolchain version before customizing.

How to verify before you commit

Run a public recipe such as yesno or mini_librispeech end-to-end first. Confirm that the chain stages generate exp/chain/tdnn*/ directories with model files and that score_kaldi_wer.sh produces a WER number you can compare to the GMM baseline. Only then copy the recipe structure into your own local/ and conf/ files.

Decision checklist

• Do you have at least several hours of transcribed audio? If not, start with GMM-HMM.
• Can you afford CPU or GPU time for TDNN training and a second decode pass?
• Do you have a team comfortable debugging shell recipes and FST graphs?
• Is your target WER improvement worth the operational complexity of wrapping Kaldi for production?

If the answer to most of these is yes, the lattice-free MMI chain TDNN pipeline is a defensible engineering choice. If not, ship the GMM-HMM baseline first and revisit chain training once you have more data and alignment artifacts.