GigaAM: one Conformer encoder, four model lines, and a 25-second ceiling

Four lines from one encoder, and pretraining hours that jump twentyfold

GigaAM is a Conformer-based foundational model with 220M to 600M parameters, and the family is organised as four lines that share an encoder idea and differ in how they were pretrained.

The `v1` line was pretrained with wav2vec 2.0 on 50,000 hours and fine-tuned with 2,000 hours of ASR data. `v2` and `v3` used a HuBERT plus CTC recipe, with `v2` at the same 50,000 hours and `v3` at 700,000 hours and 4,000 hours of ASR data. The `multilingual` line moved to two million pretraining hours and 50,000 hours of ASR data.

Those numbers explain the shape of the catalogue. The Russian lines are small and specific, and the ASR data grows slowly between them. The multilingual line then jumps by a factor of twelve and a half in fine-tuning hours, which is where its coverage of more than seventy languages comes from.

Within each line the suffixes are consistent: an `_ssl` checkpoint for embeddings, `_ctc` and `_rnnt` for the two decoder types. The `v3` line adds end-to-end variants whose distinguishing feature is punctuation and text normalisation, so the transcribed string needs no downstream cleanup.

The plain transcription call stops at twenty-five seconds

The audio inference API is short. You load a checkpoint by name, and depending on the suffix you get either an embedding or a transcription. Two utility functions download a short and a long test clip so the examples run without a local file.

The boundary that matters is stated in a note above the code rather than in the function: the `transcribe` function applies to audio only up to twenty-five seconds. Anything longer needs the `transcribe_longform` path, which is a separate install.

pip install -e ".[longform]"
# optionally run longform testing
pip install -e ".[tests]"
HF_TOKEN=<your hf token> pytest -v tests/test_longform.py

The longform path depends on an external voice activity detection component from pyannote, and that dependency is gated. You need a Hugging Face API token, and you need to accept the conditions on the pyannote segmentation model files before the token is useful. So long-form transcription is not a flag, it is a second installation with an account step in the middle.

That is a reasonable design for segmentation-based diarisation, where a hosted model really is gated, but it means the sentence in the README about long audio has three prerequisites attached to it rather than one.

The Whisper comparison is judged by another model, not by a WER table

This is the claim to read carefully, because the method is unusual. The end-to-end models are compared with Whisper in side-by-side judgements made by an independent LLM acting as a judge, and the reported outcome is an average win margin of 70 to 30 in GigaAM's favour.

That is a preference measurement, not an error rate. It can be a reasonable way to compare outputs that differ in formatting and punctuation, which is exactly what the end-to-end models add, but it is not interchangeable with the word error rate figures the project also reports elsewhere.

The other numbers are more conventional. The `v3` line was trained on new internal data covering call centre audio, music, speech with atypical characteristics and voice messages, and the claim is around 30 percent better performance on those new domains while holding the same quality as `v2` on public benchmarks. The emotion model is reported as outperforming existing models by 15 percent macro F1 score.

The language story is asymmetric and the project says so: best-in-class word error rates on Russian, Kazakh, Kyrgyz and Uzbek, and moderate results on English. A team choosing between this and a general multilingual model should read the detailed results document rather than the summary, since the summary line and the underlying tables answer different questions.

trust_remote_code means the model repository runs code in your process

There is a second way to load the models, through the Hugging Face transformers library, and it carries a decision you should make consciously.

from transformers import AutoModel

model = AutoModel.from_pretrained("ai-sage/GigaAM-v3", revision="e2e_rnnt", trust_remote_code=True)

The flag is required. It tells transformers to fetch the modelling code from the model repository and execute it in your Python process rather than using a built-in architecture. Without it, the custom Conformer configuration is not usable through the generic auto class.

That is the standard trade for gated or custom architectures, and it is worth being explicit about what it means: loading the model is equivalent to running code published in that repository, at the revision you named. Pin the revision deliberately, since that string is what decides which code you are agreeing to execute, and be aware that a revision label such as `e2e_rnnt` is a branch-like name rather than a commit hash.

The same caution applies more broadly to the gated segmentation model in the longform path, where the token unlocks files you are downloading for the first time.

ONNX export defaults to fp32, and GPU inference means replacing onnxruntime

Export is a method on the model object, and the precision default is the first thing to know about it: `to_onnx` writes fp32 by default. Passing a float16 dtype is what makes the exported model faster and smaller in video memory, which is why the documentation recommends it for GPU deployment and says so in the same sentence.

The runtime side is less obvious. Inference goes through a small pair of helpers, one that loads the exported sessions and the model configuration, and one that runs them against either a list of audio paths or an evaluation manifest as a tab-separated file. That manifest option is the useful one for batch scoring a dataset without writing a loop.

GPU support is described as a swap rather than a flag: uninstall `onnxruntime` and install a GPU build of the same library. Note the version, because the pinned runtime in the package metadata and the version named in that instruction are not the same, and a mismatched pair is the kind of thing that fails at load time rather than at install time.

There is a third deployment path for people who already run inference servers. Scripts for the Triton inference server and TensorRT are in the repository, added alongside fine-tuning support and word-level timestamps.

Two extras disagree about which PyTorch to install

The dependency metadata is careful and pinned almost everywhere, which makes the one inconsistency easier to spot.

The optional torch extra asks for PyTorch 2.6 or newer and torchaudio at the same floor, with a comment explaining why torch is optional at all: it is often already installed and reinstalling it is slow. The longform extra pins PyTorch exactly to the 2.10 line, along with torchaudio, and pulls in a specific pyannote release, a specific pyarrow floor, torchcodec and a major-pinned transformers.

So installing the longform extra on a machine that has, say, PyTorch 2.7 installed will replace it. That is a real consequence for shared environments and for anyone with a GPU driver matched to a specific build.

A smaller version of the same pattern shows up around ONNX: the ONNX exporter is pinned to one 1.19 series, the CPU runtime to a 1.23 series, and the GPU runtime instruction names a 1.22 series. Each is individually sensible and together they are a trap for anyone building a reproducible image.

Elsewhere the project is disciplined. The runtime list is exact for the configuration stack and the audio stack, the training extra covers lightning, tensorboard, wandb and an edit distance package, and the lint extra pins its three formatters and linters to exact versions. The test configuration declares two markers so you can run a lightweight subset of checkpoint tests or the full set that downloads everything.

MIT since December 2024, and no release tags at all

The changelog lives in the README rather than in releases, which is unusual for a project with this much history, and the repository has no GitHub releases. The package version in the metadata is 0.2.0, which tells you about the code rather than about the checkpoints.

The timeline in the README is nonetheless detailed. April 2024 brought the first release with the CTC model for Russian and the emotion model. May 2024 added the RNNT line with a reported 19 percent error reduction and long-form inference using external voice activity detection. December 2024 switched the licence to MIT, released version two of the family with 15 and 12 percent error reductions for the two decoder types, and added ONNX export. June 2025 was the InterSpeech acceptance. November 2025 brought version three with the 30 percent figure on new domains and the end-to-end models. April 2026 added fine-tuning, word-level timestamps and the Triton and TensorRT paths. June 2026 brought the multilingual line with its two million hours and a second InterSpeech acceptance.

Requirements are short and worth restating because ffmpeg is easy to miss: Python 3.10 or newer, and ffmpeg installed and on the system path. Installation is a clone and an editable install with the torch extra, and the optional test extra lets you verify it against real checkpoints.

The repository also carries a Russian-language README, a Colab example notebook, an evaluation document, training utilities with a README and a notebook, and the Triton scripts. With 834 stars, 108 forks and 18 open issues, it is a project people deploy rather than one they only read.

Editorial conclusion

GigaAM fits a team with Russian-first audio data, call centre recordings or atypical speech that a general-purpose multilingual model handles poorly, and the per-line checkpoints make it cheap to try the small encoder before the large one. Skip it if you need long-form transcription without extra setup, since the simple transcription path stops at twenty-five seconds and the longform path needs a gated model and a token. Before you choose, read evaluation.md rather than the comparison headline, and check which extras you install, because two of them disagree about the PyTorch version.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. README
4. salute-developers/GigaAM on GitHub