IBM Granite Speech 5.0 2B: Open model for transcription and translation

IBM has released Granite Speech 5.0 2B, an open speech model with 2 billion parameters under Apache 2.0. It converts speech in six languages to text, translates, and also runs on Mac and CPU. It ranks second among open models on the Open ASR Leaderboard.

Model releases Try it yourself Oct 22, 2026 5 min read Source: MarkTechPost

What's it about

IBM has released Granite Speech 5.0 2B, an open model that converts spoken language to text (transcription) and translates speech. It has 2 billion parameters (roughly, the knobs learned during training), is dense, is released under the Apache 2.0 license and supports 6 languages. At the same time, IBM updated two existing models: Turbo CTC, designed for edge devices, and Granite Speech 4.1 2B Plus, built for speaker recognition. Most of the details come from IBM's Model Card.

Architecture and training

According to the Model Card, the model has three parts:

A speech encoder made of 16 Conformer blocks, trained with CTC (a training method for speech recognition). It uses block attention over 4-second audio chunks.
A 2-layer window Q-Former that projects and shrinks the acoustic embeddings. Overall, the audio is downsampled 10x, so the language model sees 10 embeddings per second.
A language model (LLM): an intermediate checkpoint of granite-4.0-1b-base, extended to 16,000 positions with YaRN and fine-tuned with LoRA adapters (small extra weights trained afterward).

It was trained on 390,000 hours of public audio plus synthetic data for Japanese speech recognition, keyword biasing and translation. That took 40 days on 8 H100 GPUs. IBM recommends audio segments of up to about 2 minutes.

What's new compared with Granite Speech 4.1 2B

Language ID via prompt: you name the input language in the prompt to steer the transcription.
Keyword lists of up to 2,000 terms, to favor product names, people and abbreviations.
Punctuation and capitalization on request; capitalization F1 ranges from 90.16 to 99.51 depending on the test set.
More robustness against noise, reverberation and distant microphones.

Benchmarks

On the Open ASR Leaderboard, IBM's chart shows an average word error rate (WER, the share of misrecognized words; lower is better) of 5.68% for English, averaged over 9 public and 2 private test sets, as of October 21, 2026. Only Qwen3-ASR-1.7B is better at 5.40%. IBM's blog, by contrast, cites 5.06%; according to the source, that is an unofficial figure from October 15 that averages only public short-form sets.

Individual scores vary widely: 0.99% on LibriSpeech Clean, 2.21% on LibriSpeech Other, 13.79% on the private conversational test set. On the noise leaderboard FFASR, the model ranks 4th of 42 at 14.80% (Qwen3-ASR-1.7B: 13.41%). On CommonVoice, WER is 2.60% for Portuguese and 3.50% for Spanish; Japanese is weakest at 10.74%. For translation into English (CoVoST, BLEU), it scores 53.6 for Portuguese and 40.1 for German; English→Mandarin was not evaluated. The clearest gain comes from keyword biasing: on Earnings-22, keyword F1 rises from 67.2 to 90.1 with correct lists, and still reaches 82.8 with 2,000 mixed correct and incorrect terms.

Feature	Granite Speech 5.0 2B	Qwen3-ASR-1.7B	Cohere Transcribe 03-2026	Canary-Qwen-2.5B
Size	2B	2.35B	2.07B	2.5B
License	Apache 2.0	Apache 2.0	Apache 2.0 (gated)	CC-BY-4.0
ASR languages	6	30 + 22 Chinese dialects	14	English only
Translation	Yes	n/a	n/a	No
Open ASR WER	5.68%	5.40%	5.77%	5.94%
FFASR WER	14.80%	13.41%	15.03%	n/a

Updates for Turbo CTC and 4.1 2B Plus

Granite Speech 5.0 Turbo CTC stays at 470 million parameters but now transcribes 7 languages with punctuation and capitalization. IBM compiled a single Conformer block and reused its graph across the whole stack; throughput rose to 19,870 RTFx (multiples of real time), up from about 12,600. The 4.1 2B Plus is a drop-in weights update: mean timestamp deviation falls from 210.86 to 98.54, WER on long recordings from 13.53 to 10.22, and WER with keyword biasing from 11.79 to 6.48.

What you need to try it

The model runs on a GPU with Transformers or vLLM. At 2 billion parameters, 4-bit needs roughly 3–4 GB of VRAM, and the recommended Q8_0 quantization more like 4–6 GB. On Apple Silicon, use mlx-audio; on CPU and Mac, use llama.cpp with GGUF. Disk space: a few GB. The source gives no specific Colab requirements, but a free GPU should be enough.

Our take

Granite Speech 5.0 2B is a cleanly licensed, compact model that combines transcription, translation and keyword steering, and it runs locally. On raw accuracy, Qwen3-ASR-1.7B is ahead, especially on noisy audio, and covers far more languages with 30. With 6 languages and segments of about 2 minutes, IBM's model is narrower in scope. Keep in mind that, according to IBM, quantization below Q8_0 loses accuracy on audio longer than about 1 minute, and some leaderboard figures are vendor presentations with conflicting numbers (5.68% vs. 5.06%). The source doesn't explicitly say whether German is supported as an input language; German appears only for translation.

Terms explained simply

WER (word error rate): The share of words a speech recognition system gets wrong. Lower is better.
Diarization: Assigning speech to individual speakers, so a transcript shows who said what.
YaRN: A method that lets a language model handle longer inputs after the fact.
LoRA: A fine-tuning technique that trains only small extra weights instead of the whole model.
GGUF / quantization: GGUF is a file format for llama.cpp. Quantization stores weights at lower precision so the model needs less memory, at the possible cost of accuracy.
Keyword biasing: You supply a list of important terms that the model favors when transcribing, such as product or people's names.
RTFx: How many times faster than real time a model processes audio. 19,870 RTFx means many hours of audio per hour of compute.

Sources

MarkTechPost marktechpost.com
Hugging Face Blog huggingface.co
Google News (US) news.google.com

#ibm#granite#speech-recognition#open-source#transcription

Read the original source

Try it yourself: Granite Speech 5.0 2B

Explained step by step, no prior knowledge needed – on your own computer or free in your browser.

What can I do with it?

You can turn recordings such as meetings, interviews or voice messages into text locally and have them translated into English. With a keyword list, it recognizes names, products and abbreviations more reliably. You can request punctuation and capitalization via the prompt.

Who is it worth it for?

Worthwhile for developers and users who want open, locally running speech recognition with translation and control over technical terms. If you need many languages or very noisy audio, also look at Qwen3-ASR-1.7B.

Size2.3 B parameters

Download5 GB (about 7 min at 100 Mbit/s)

Licenseapache-2.0

TypeSpeech recognition (speech to text)

Hugging Faceibm-granite/granite-speech-5.0-2b

What your computer needs

Graphics card (NVIDIA) at least 7 GB VRAMCalculated, not measured: weights of 5.0 GB in bf16 × 1.2 + 1 GB ≈ 7 GB. Without a graphics card, the script falls back to the CPU; with more video memory it runs faster and longer recordings are easier to handle.

Mac (Apple Silicon M1–M5) from 16 GB unified memoryThe GPU and CPU share the memory – the model can use about 70% of it

CPU only (no graphics card) Runningusable without a graphics card, according to the developers – at least 8 GB of RAM

Storage approx. 7 GB freeModel download plus programs

For GPUs: the standard model via Transformers or vLLM. For Mac or CPU: GGUF in Q8_0, which IBM recommends because lower quantizations lose accuracy on audio longer than about 1 minute. For very fast on-device transcription: Turbo CTC (470M).

GPU use via Transformers or vLLM; for 2B parameters, roughly 4–6 GB of VRAM is enough.
Apple Silicon: via mlx-audio.
Mac and CPU: llama.cpp with GGUF, Q8_0 recommended.
Split audio into segments of up to about 2 minutes.
Training ran on 8 H100s; you don't need that to use the model.

How do I find out what my computer has?

Windows: Press Ctrl + Shift + Esc → Task Manager → Performance tab → click GPU on the left. At the bottom you'll see Dedicated GPU memory (that's your VRAM). You'll find system memory under Memory.
Mac: Apple menu at the top left → About This Mac. You'll see your chip (e.g. M2) and memory (e.g. 16 GB). On Apple chips, graphics and processor share this memory.
Linux: Type nvidia-smi in the terminal (shows your graphics card and its memory) and free -h for system memory.

Guide

This model runs with its developers' own program. The commands below come from the Model Card and the developers' instructions.

Windows 10 / 11

Windows 10 / 11: not officially tested. The source says nothing about Windows. The transformers route should work but is untested. Without an NVIDIA card, the model runs on the CPU and is slower.

Check the prerequisites. You need Python 3 (version 3.10 or later), about 6 GB of free space and roughly 8 GB of RAM. With an NVIDIA graphics card, the current driver should be installed. It also works without a card, just more slowly.
```
py --version
```
Create a folder and environment. Open PowerShell. A virtual environment (venv) keeps the packages separate from the rest of your PC. If activation is blocked, the command Set-ExecutionPolicy -Scope Process RemoteSigned helps once.
```
mkdir granite-speech
cd granite-speech
py -m venv .venv
.venv\Scripts\Activate.ps1
```
Install the packages. This installs transformers, torchaudio (including PyTorch) and soundfile. It takes a few minutes.
```
pip install transformers torchaudio soundfile
```
Download the model. The model is about 5 GB. The download is saved and reused at startup.
```
hf download ibm-granite/granite-speech-5.0-2b
```

Save the test script. Save this code as demo.py in the granite-speech folder. It fetches the sample file multilingual_sample.wav from the model repo itself.

import torch, torchaudio
from huggingface_hub import hf_hub_download
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor

device = "cuda" if torch.cuda.is_available() else "cpu"
name = "ibm-granite/granite-speech-5.0-2b"
processor = AutoProcessor.from_pretrained(name)
tokenizer = processor.tokenizer
model = AutoModelForSpeechSeq2Seq.from_pretrained(name, device_map=device, torch_dtype=torch.bfloat16)

path = hf_hub_download(repo_id=name, filename="multilingual_sample.wav")
wav, sr = torchaudio.load(path, normalize=True)
assert wav.shape[0] == 1 and sr == 16000

chat = [{"role": "user", "content": "<|audio|>transcribe the speech with proper punctuation and capitalization."}]
prompt = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
inputs = processor(prompt, wav, device=device, return_tensors="pt").to(device)
out = model.generate(**inputs, max_new_tokens=200, do_sample=False, num_beams=1)
new = out[0, inputs["input_ids"].shape[-1]:].unsqueeze(0)
print("STT output =", tokenizer.batch_decode(new, add_special_tokens=False, skip_special_tokens=True)[0])

Run the script. The first run takes a while because the model has to load. After that, the recognized text appears in the window.
```
python demo.py
```
Result. The terminal shows the recognized text of the sample file multilingual_sample.wav, with punctuation and capitalization.

macOS

macOS: supported. For Apple Silicon Macs (M1 and newer), the Model Card describes a route via mlx-audio. Intel Macs aren't covered.

Check the prerequisites. You need a Mac with an M-series chip, Python 3 (version 3.10 or later) and about 6 GB of free space. Install the Xcode command line tools with the command below. A window will then ask for your consent.
```
xcode-select --install
python3 --version
```
Create a folder and environment. Open Terminal. A virtual environment (venv) keeps the packages separate from the rest of your Mac.
```
mkdir granite-speech
cd granite-speech
python3 -m venv .venv
source .venv/bin/activate
```
Install the packages. mlx-audio is the package for Apple chips. According to the Model Card, you have to install jinja2 separately.
```
pip install -U mlx-audio jinja2
```
Get the sample audio. The Model Card comes with a short sample file. It lands in your folder. Later you can also use your own WAV file (mono, 16 kHz, up to about 2 minutes).
```
hf download ibm-granite/granite-speech-5.0-2b multilingual_sample.wav --local-dir .
```

Recognize the text. On the first run, the program downloads the model (about 5 GB). This can take a while.

python -m mlx_audio.stt.generate --model ibm-granite/granite-speech-5.0-2b --verbose --audio "multilingual_sample.wav" --output-path "transcript"

Result. The terminal shows the recognized text of the sample file multilingual_sample.wav, with punctuation and capitalization.

Linux

Linux: supported. This guide uses the transformers route from the Model Card. It runs with an NVIDIA card (CUDA) or without a card on the CPU, but then more slowly.

Check the prerequisites. You need Python 3 (version 3.10 or later) with the python3-venv package, about 6 GB of free space and roughly 8 GB of RAM. With an NVIDIA graphics card, the current driver should be installed. It also works without a card, just more slowly.
```
python3 --version
```
Create a folder and environment. A virtual environment (venv) keeps the packages separate from the rest of your system.
```
mkdir granite-speech
cd granite-speech
python3 -m venv .venv
source .venv/bin/activate
```
Install the packages. This installs transformers, torchaudio (including PyTorch) and soundfile. It takes a few minutes.
```
pip install transformers torchaudio soundfile
```
Download the model. The model is about 5 GB. The download is saved and reused at startup.
```
hf download ibm-granite/granite-speech-5.0-2b
```

Save the test script. Save this code as demo.py in the granite-speech folder. It fetches the sample file multilingual_sample.wav from the model repo itself.

import torch, torchaudio
from huggingface_hub import hf_hub_download
from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor

device = "cuda" if torch.cuda.is_available() else "cpu"
name = "ibm-granite/granite-speech-5.0-2b"
processor = AutoProcessor.from_pretrained(name)
tokenizer = processor.tokenizer
model = AutoModelForSpeechSeq2Seq.from_pretrained(name, device_map=device, torch_dtype=torch.bfloat16)

path = hf_hub_download(repo_id=name, filename="multilingual_sample.wav")
wav, sr = torchaudio.load(path, normalize=True)
assert wav.shape[0] == 1 and sr == 16000

chat = [{"role": "user", "content": "<|audio|>transcribe the speech with proper punctuation and capitalization."}]
prompt = tokenizer.apply_chat_template(chat, tokenize=False, add_generation_prompt=True)
inputs = processor(prompt, wav, device=device, return_tensors="pt").to(device)
out = model.generate(**inputs, max_new_tokens=200, do_sample=False, num_beams=1)
new = out[0, inputs["input_ids"].shape[-1]:].unsqueeze(0)
print("STT output =", tokenizer.batch_decode(new, add_special_tokens=False, skip_special_tokens=True)[0])

Run the script. The first run takes a while because the model has to load. After that, the recognized text appears in the terminal.
```
python demo.py
```
Result. The terminal shows the recognized text of the sample file multilingual_sample.wav, with punctuation and capitalization.

Try it

Transcribe this recording in English with punctuation and capitalization.

Translate this Portuguese voice recording into English.

Transcribe this meeting and pay attention to these terms: Tokenstrom, Kubernetes, Q3 forecast.

If something goes wrong

Cut long recordings into pieces of about 2 minutes beforehand.

With GGUF, don't quantize below Q8_0, or accuracy drops on longer audio.

Only 6 languages are supported; check beforehand whether yours is included.

Name the input language in the prompt to steer the transcription.

“out of memory,” a crash, or your computer freezes

The model is too big for your VRAM (video memory). Pick a smaller variant from the table above and close other programs, especially games and browsers with lots of tabs.

It runs, but extremely slowly

Your CPU is probably doing the work instead of your graphics card. In Ollama, the PROCESSOR column of ollama ps shows how much runs on the GPU. If it says "100% CPU", update your graphics driver or pick a smaller variant that fits entirely into VRAM (video memory).

“ollama” or “python” is not found

Close the terminal window and open it again so it recognizes the newly installed program. For Python on Windows: reinstall it and check Add python.exe to PATH.

Windows: "Running scripts is disabled on this system"

Run the script with exactly the command above: powershell -ExecutionPolicy Bypass -File try_windows.ps1. This allows execution for this one time only.

Error message when loading the model (version, "trust_remote_code", unknown architecture)

Brand-new models often need the latest software version. With Ollama: update Ollama. With Python: pip install -U transformers in the activated environment. The Model Card usually lists the exact version.

Tokenstrom generates the scripts and notebook automatically. Please take a quick look before running them – they're plain, readable text. Mind the model's license: apache-2.0.

Ask the AI assistant

Questions about this article, installation or background? Our assistant knows this page and runs on our own machine, not in someone else's cloud.

Connecting …

The Assistant is an AI (Gemma 4) and can make mistakes – please check important details against the source. Questions are used only to generate an answer and are deleted after one hour. Please don't enter any personal data.

Comments

What do you think? Already tried it? Write it here, no sign-up needed.

Loading comments …

Comments are public. Links aren't allowed, and we delete abusive posts. You can delete your own comment at any time in this browser. Learn more in the Privacy Policy.