Haas-ja

Haas-ja-v1.0 is a Japanese speech recognition model built to be both fast and accurate. It is based on NVIDIA's Parakeet-TDT architecture: a FastConformer encoder and a Token-and-Duration Transducer (TDT) decoder, here with a prediction network that uses Kimi Delta Attention (KDA). The name is an acronym of Hear Anything At Speed and a nod to Helmut Haas, the acoustician behind the Haas (precedence) effect used in stereo sound and other audio technology.

At release, Haas-ja-v1.0 sits on the Pareto frontier of speed and accuracy on a benchmark built from five public Japanese datasets, and is the most accurate of the open models we evaluated (CER strict 6.12%). Its accuracy is competitive with major commercial speech-to-text APIs at a small fraction of their cost.

The blog post covers the development in more detail, including a preliminary experiment comparing prediction networks, the evaluation design and the full results.

Model details

Haas-ja-v1.0 follows Parakeet-TDT: a FastConformer encoder and a TDT decoder. TDT extends RNN-T by also predicting how long each token lasts, so decoding can jump ahead several encoder frames at a time instead of visiting every frame. Haas-ja-v1.0 replaces the LSTM in Parakeet-TDT's prediction network with Kimi Delta Attention (KDA), which improves accuracy at almost the same inference speed.

The full architecture configuration is in config.yaml.

How to use

Requirements: Linux with an NVIDIA GPU, Python 3.11+ and NeMo 2.7. The prediction network runs on kernels from flash-linear-attention, which needs Triton and CUDA, so CPU and macOS are not supported.

Try it with the repository

Clone the GitHub repository and install it with uv, which installs the exact dependency versions we tested:

git clone https://github.com/third-intelligence/Haas-ASR.git
cd Haas-ASR
uv sync
uv run python examples/quickstart.py --model third-intelligence/Haas-ja-v1.0 example.wav

Use it in your own project

Install the inference package into your environment:

pip install "haas-asr @ git+https://github.com/third-intelligence/Haas-ASR.git"

Then transcribe:

import haas_asr

model = haas_asr.load_model("third-intelligence/Haas-ja-v1.0")
audio = haas_asr.load_audio("example.wav")
output = model.transcribe([audio])
print(output[0].text)

load_model returns a regular NeMo ASRModel and runs it in bfloat16 on a GPU, the precision used for the evaluation below. haas_asr.load_audio reads a WAV, FLAC, MP3 or OGG file, averages stereo to mono and resamples it to 16 kHz, the model's input.

For recordings longer than 30 seconds, use transcribe_longform. It splits the audio at quiet points (detected by volume) and transcribes the pieces in batches:

audio = haas_asr.load_audio("example.flac")
text = haas_asr.transcribe_longform(model, audio, batch_size=64)

Custom vocabulary

Names and terms the model rarely heard in training can be listed, so that it recognizes them more often and writes them as you want:

vocabulary = haas_asr.Vocabulary(
    {"Haas": ["ハース"], "Third Intelligence": ["サードインテリジェンス"]}
)
texts = haas_asr.transcribe(model, [audio], vocabulary=vocabulary)  # short clips
text = haas_asr.transcribe_longform(model, audio, vocabulary=vocabulary)

Each word maps its written form to its readings, the ways Haas would write it (usually in kana; several, or none if Haas already writes it as listed). The readings are boosted while decoding with NeMo's GPU phrase boosting, and replaced by the written form wherever found. Boosting can also change text where no listed word was said, so audio without speech is not boosted, and each audio is also decoded without the words: a change is kept only where it includes a whole listed word. Both decodes share one encoder pass, so a vocabulary costs about 1.3 times the time. See the repository for details.

Speaker labels

Combined with NVIDIA's speaker diarization model Nemotron-3-Diarization, Haas produces transcripts with speaker labels. The repository has a runnable example.

Training data

The model was trained on about 46,000 hours of audio from public corpora (ReazonSpeech, Common Voice 26.0 and YODAS) and internal data. An in-house filtering pipeline removed low-quality samples. To keep the evaluation fair, the benchmark