Blame for README.md

---
language:
- da
license: cc-by-4.0
pipeline_tag: automatic-speech-recognition
library_name: nemo
base_model: nvidia/parakeet-tdt-0.6b-v3
base_model_relation: finetune
tags:
- speech
- audio
- fastconformer
- tdt
- danish
metrics:
- wer
---

# Klang Pianissimo for Danish

**Pianissimo-da is our open speech recognition model for Danish.** Across three Danish evaluation sets, it achieved **11.8% mean word error rate**, the best result among the open and closed models we tested.

Built on [NVIDIA Parakeet v3](https://huggingface.co/nvidia/parakeet-tdt-0.6b-v3), Pianissimo has 600 million parameters and runs at **over 3,600× realtime on one NVIDIA H100, or 500× on one L4**. It supports punctuation, capitalization and word-level timestamps. We release it under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/), with versions for servers, laptops and phones so you can run it on your own hardware and keep control of your recordings.

[**Try Pianissimo**](https://klang.ai/pianissimo-da/#try-pianissimo) or read [how we trained it](https://research.klang.ai/papers/klang-pianissimo-da). We also release [Pianissimo for Swedish](https://huggingface.co/KlangAI/pianissimo-sv).

## Usage

Install PyTorch and `nemo_toolkit[asr]`.

Load the model and transcribe a 16 kHz mono audio file:

```python
import torch
from nemo.collections.asr.models import ASRModel

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
model = ASRModel.from_pretrained(
    model_name="KlangAI/pianissimo-da",
    map_location=device,
).eval()

with torch.inference_mode():
    hypotheses = model.transcribe(
        audio=["audio.wav"],
        batch_size=1,
        return_hypotheses=True,
    )

print(hypotheses[0].text)
```

For multiple files, pass a list of paths and increase `batch_size` to suit your GPU.

### Timestamps

Add `timestamps=True` to obtain word and segment timestamps:

```python
with torch.inference_mode():
    hypotheses = model.transcribe(
        audio=["audio.wav"],
        batch_size=1,
        return_hypotheses=True,
        timestamps=True,
    )

for word in hypotheses[0].timestamp["word"]:
    print(word["start"], word["end"], word["word"])
```

### Vocabulary

NeMo's built-in phrase boosting supports custom vocabulary: list names and terms to help the model spell them correctly. The [ONNX](https://huggingface.co/KlangAI/pianissimo-da-onnx#vocabulary) and [MLX](https://huggingface.co/KlangAI/pianissimo-da-mlx-8bit#vocabulary) versions support it with our own implementation. The words and phrases are case sensitive.

```python
import copy
from omegaconf import open_dict

decoding = copy.deepcopy(model.cfg.decoding)
with open_dict(decoding):
    decoding.strategy = "greedy_batch"
    decoding.greedy.boosting_tree = {
        "key_phrases_list": [
            "Klang AI", "Pianissimo", "Folketinget", "Aarhus Universitet",
        ],
        "context_score": 1.0,
        "depth_scaling": 2.0,
        "use_triton": False,
    }
    decoding.greedy.boosting_tree_alpha = 1.0
model.change_decoding_strategy(decoding)
```

### Quantized versions

Run Pianissimo on a CPU with ONNX or GGUF, on an Apple silicon GPU with MLX, or on the Apple Neural Engine with CoreML. The table compares word error rates on 200 Danish FLEURS clips (38 minutes); lower is better.

| Version | Runs on | Download | WER (%) | Speed |
|---|---|---:|---:|---:|
| Original fp32 (this model) | PyTorch and NeMo | 2.51 GB | 6.5 | — |
| [ONNX int8](https://huggingface.co/KlangAI/pianissimo-da-onnx) | CPU | 684 MB | 6.7 | 35× (Intel), 74× (Mac) |
| [ONNX int4](https://huggingface.co/KlangAI/pianissimo-da-onnx) | CPU | 525 MB | 7.2 | 12× (Intel), 37× (Mac) |
| [ONNX fp16](https://huggingface.co/KlangAI/pianissimo-da-onnx) | CPU | 1.46 GB | 6.5 | 18× (Intel), 55× (Mac) |
| [ONNX fp32](https://huggingface.co/KlangAI/pianissimo-da-onnx) | CPU | 2.56 GB | 6.5 | 18× (Intel), 55× (Mac) |
| [MLX 8-bit](https://huggingface.co/KlangAI/pianissimo-da-mlx-8bit) | Apple silicon GPU | 759 MB | 6.6 | 151× |
| [MLX 4-bit](https://huggingface.co/KlangAI/pianissimo-da-mlx-4bit) | Apple silicon GPU | 528 MB | 7.1 | 126× |
| [MLX bf16](https://huggingface.co/KlangAI/pianissimo-da-mlx) | Apple silicon GPU | 1.25 GB | 6.5 | 140× |
| [MLX fp32](https://huggingface.co/KlangAI/pianissimo-da-mlx-fp32) | Apple silicon GPU | 2.51 GB | 6.5 | 173× |
| [GGUF Q8_0](https://huggingface.co/KlangAI/pianissimo-da-gguf) | CPU or GPU with transcribe.cpp | 740 MB | 6.4 | — |
| [GGUF Q5_K_M](https://huggingface.co/KlangAI/pianissimo-da-gguf) | CPU or GPU with transcribe.cpp | 549 MB | 6.5 | — |
| [GGUF Q4_K_M](https://huggingface.co/KlangAI/pianissimo-da-gguf) | CPU or GPU with transcribe.cpp | 485 MB | 6.5 | — |
| [GGUF F16](https://huggingface.co/KlangAI/pianissimo-da-gguf) | CPU or GPU with transcribe.cpp | 1.26 GB | 6.6 | — |
| [GGUF F32](https://huggingface.co/KlangAI/pianissimo-da-gguf) | CPU or GPU with transcribe.cpp | 2.51 GB | 6.6 | — |
| [CoreML 8-bit](https://huggingface.co/KlangAI/pianissimo-da-coreml) | Apple Neural Engine | 632 MB | 6.9 | 183× (M5) |
| [CoreML fp16](https://huggingface.co/KlangAI/pianissimo-da-coreml/tree/main/fp16) | Apple Neural Engine | 1.22 GB | 7.0 | 174× (M5) |

All versions are scored after lowercasing and removing punctuation.

Speed is measured in multiples of realtime (RTFx), with the model loaded. ONNX and MLX timings use the Swedish model with the same architecture and a 30-second clip: an Intel Xeon Platinum 8481C with 4 CPU threads, an Apple M5 Pro with 6 CPU threads, or the M5 Pro GPU for MLX. CoreML timings use the 200 Danish clips on an Apple M5 Neural Engine.

The ONNX versions run on Windows, Linux and Mac, with Intel, AMD or ARM processors:

```python
import onnx_asr  # pip install onnx-asr[cpu,hub]

model = onnx_asr.load_model("KlangAI/pianissimo-da-onnx", quantization="int8")
print(model.recognize("audio.wav"))
```

The MLX versions run on the GPU of Macs with Apple silicon. They use a small loader file included in each MLX repository; see the [MLX 8-bit model card](https://huggingface.co/KlangAI/pianissimo-da-mlx-8bit) for how to use it.

## Quality and speed

### Danish speech recognition

We tested Pianissimo on European Parliament speeches, DR television programmes and spontaneous speech from DanPASS: 11.55 hours across 10,933 segments, held out of its fine-tuning. The table shows word error rates (%), with equal weight given to the three sets in the mean. Lower is better.

| Model | Mean | EU Parliament | DR TV | Spontaneous (DanPASS) |
|---|---:|---:|---:|---:|
| **Pianissimo-da** | **11.8** | **7.9** | **18.2** | 9.4 |
| ElevenLabs Scribe v2 (closed) | 12.3 | 8.6 | 19.1 | **9.3** |
| edda-v0.2-duo | 13.1 | 9.2 | 20.4 | 9.6 |
| brage-v1 | 13.2 | 9.1 | 19.9 | 10.7 |
| saga-2-m | 13.3 | 8.8 | 20.1 | 10.9 |
| hviske-v6 | 13.5 | 8.4 | 21.4 | 10.7 |
| Mistral Voxtral Small (closed) | 13.8 | 8.8 | 19.1 | 13.6 |
| OpenAI GPT Transcribe (closed) | 14.2 | 10.0 | 19.9 | 12.6 |
| Google Gemini 3.5 Transcribe (closed) | 14.9 | 9.1 | 21.1 | 14.3 |
| Whisper large-v3 | 17.0 | 10.5 | 22.8 | 17.7 |
| Parakeet TDT 0.6B v3 | 25.5 | 16.3 | 32.3 | 28.0 |

- **EU Parliament**: Danish parliamentary speeches.
- **DR TV**: Danish television programmes.
- **DanPASS**: people speaking freely and having conversations.

All models received the same audio and were scored against the same references. See the [release article](https://research.klang.ai/papers/klang-pianissimo-da) for the full comparison.

### Throughput

Pianissimo-da reaches **over 3,600× realtime on one NVIDIA H100, or 542× on one NVIDIA L4**—1 second to process over one hour of audio on the H100.

## Architecture

Pianissimo-da uses a **FastConformer encoder and Token-and-Duration Transducer (TDT) decoder**, retaining Parakeet v3's architecture and tokenizer.

| Property | Value |
|---|---|
| Parameters | Approximately 600 million |
| Audio input | 16 kHz, mono |
| Features | 128-band log-mel spectrogram |
| Encoder | 24 layers, 8× subsampling |
| Default attention | Local, 256 encoder frames on each side per layer |
| Checkpoint size | 2.51 GB |

Unlike the original Parakeet checkpoint's full attention, Pianissimo-da defaults to local attention with approximately 20.5 seconds of context in each direction per layer. This keeps attention computation linear in recording length and makes long recordings practical.

## Training

We fine-tuned Pianissimo-da on approximately **70,000 hours of Danish speech**, including public datasets such as CoRal, Common Voice, FLEURS and FT Speech, alongside our own collection of publicly available speech. Training ran in three phases, moving from the broad dataset to its highest-quality subset, for 470,000 steps.
Augmentation included reverberation, noise, compression, reduced bandwidth, and gain changes.

## License and citation

Pianissimo-da is released under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/).

```bibtex
@misc{klang2026pianissimoda,
  title = {Klang Pianissimo for Danish},
  author = {{Klang}},
  year = {2026},
  howpublished = {Hugging Face model repository},
  url = {https://huggingface.co/KlangAI/pianissimo-da}
}
```