Skip to content

fr Canary 1B Deep Dive

Jump to bottom
rcspam edited this page Apr 24, 2026 · 2 revisions

🌐 Langue : English | Français

Canary-1B en profondeur

Logo Canary

NVIDIA Canary-1B v2 est un modèle d'attention encoder-decoder (AED) qui transcrit ET traduit en un seul forward pass. C'est le choix recommandé quand votre machine a au moins 6 Go de VRAM et que vous voulez une qualité supérieure (WER plus bas qu'avec Parakeet) ainsi qu'une traduction intégrée sans passer par Ollama, Google ou LibreTranslate.

Le port Rust dans dictée (fichiers src/canary.rs, src/model_canary.rs, src/decoder_canary.rs) a été initialement adapté depuis onnx-asr par Ivan Stupakov et est désormais entièrement autonome — les graphes ONNX sont chargés directement via ort, la tokenisation utilise tokenizers (crate officiel HuggingFace), et la construction du prompt du décodeur est maison.

Table des matières

Architecture

Canary utilise une architecture encoder-decoder (type Whisper, mais optimisée NVIDIA) :

Audio (16 kHz mono)
   ↓
Mel-spectrogramme (128 bins, n_fft=512, hop 10 ms, Hann)
   ↓
┌──────────────────────────────────┐
│ Encodeur FastConformer           │
│  - Sous-échantillonnage conv     │
│  - Blocs Conformer (multi-head)  │
│  - Sortie : embeddings acoust.   │
└──────────────────────────────────┘
   ↓
┌──────────────────────────────────┐
│ Décodeur Transformer             │
│  - Cross-attention sur encoder   │
│  - Génération autoregressive     │
│  - Prompt tokens : SOT + source  │
│    + target + PNC + NOITN + …    │
└──────────────────────────────────┘
   ↓
Vocabulaire SentencePiece
   ↓
Texte avec ponctuation et capitalisation natives

Différence clé avec Parakeet : Canary est un encoder-decoder, pas un transducer. Il génère les tokens de sortie de manière autoregressive en croisant l'attention sur les embeddings de l'encodeur, contrairement à Parakeet-TDT qui émet des paires (token, durée) en un seul pass. Conséquences pratiques :

  • Canary est plus précis (WER plus bas sur toutes les langues partagées)
  • Canary est plus lent (génération autoregressive vs TDT parallèle)
  • Canary supporte la traduction native via le prompt du décodeur

Trois graphes ONNX sont chargés à l'exécution :

  • encoder.onnx — encodeur FastConformer (~1 Go)
  • decoder.onnx — decoder Transformer (~3 Go)
  • tokenizer.json + vocab.txt — SentencePiece

Langues supportées (7 dans le port Rust)

Le modèle upstream NVIDIA Canary-1B v2 annonce 25 langues. Le port Rust dans dictée en expose 7 (verifiés dans src/canary.rs:33-47) :

ISO Langue Token ID Canary
en Anglais 64
fr Français 71
de Allemand 78
es Espagnol 171
it Italien 87
pt Portugais 138
uk Ukrainien 182

Les autres langues que le modèle peut théoriquement gérer ne sont pas exposées côté dictée — si vous en avez besoin, ouvrez une issue ou utilisez faster-whisper (99 langues).

Traduction native — le point différenciant

Contrairement à Parakeet (qui ne fait que transcrire et délègue la traduction à Ollama / Google / LibreTranslate), Canary fait les deux dans le même forward pass grâce au prompt du décodeur :

<|startoftranscript|><|emo:undefined|><source_lang><target_lang><|pnc|><|noitn|><|notimestamp|><|nodiarize|>

Les tokens <source_lang> et <target_lang> indiquent au décodeur :

  • Si égaux → transcription simple
  • Si différents → traduction (audio en source_lang, sortie textuelle en target_lang)

Paires de traduction supportées : chacune des 7 langues ↔ EN (12 paires dans les deux sens, soit 14 combinaisons non-identité). Les paires non-English-centric (FR → DE par exemple) ne sont pas testées officiellement — le modèle peut produire quelque chose mais la qualité n'est pas garantie.

Exemple CLI :

# Transcription FR
dictee-switch-backend asr canary
DICTEE_LANG_SOURCE=fr dictee

# Transcription FR → traduction EN (tout en un)
DICTEE_LANG_SOURCE=fr DICTEE_LANG_TARGET=en dictee --translate

# Transcription EN → traduction FR
DICTEE_LANG_SOURCE=en DICTEE_LANG_TARGET=fr dictee --translate

Pas besoin qu'Ollama/LibreTranslate tourne, pas besoin d'accès réseau : Canary fait tout localement.

Pipeline audio

Canary attend du 16 kHz mono en entrée. dictée gère le rééchantillonnage automatiquement.

Paramètres du préprocesseur (verifiés dans src/canary.rs:171-183) :

Paramètre Valeur
Feature size (mel bins) 128
n_fft 512
hop_length 160 (10 ms à 16 kHz)
win_length 400 (25 ms à 16 kHz)
Préemphasis 0,97
Fenêtre Hann
Padding side right
Padding value 0,0

Le mel-spectrogramme complet est chargé d'un bloc dans l'encodeur — pas de chunking interne. C'est ce qui impose les limites de durée pratiques (voir section suivante).

VRAM & limites de durée

Sur RTX 4070 Laptop (8 Go) — mesures réelles via nvidia-smi :

  • Daemon démarré, modèle chargé : ~5,3 Go VRAM
  • Pic pendant inférence sur utterance 5 s : ~5,3 Go (stable)
  • Pic pendant inférence sur utterance 60 s : ~6,3 Go (+1 Go pour les matrices d'attention)

L'attention de l'encodeur FastConformer est quadratique en longueur de séquence — la VRAM nécessaire au pic grandit avec la durée. Sur une 4070 Laptop de 8 Go, les limites pratiques dépendent de la VRAM libre au moment de l'appel :

Durée audio Pic VRAM estimé Besoin de VRAM libre (min) Résultat
3-10 s ~5,3 Go ~200 Mo Propre
30 s ~5,3 Go ~300 Mo Propre (voir benchs)
60 s ~6,3 Go ~1 Go Sortie tronquée (~780 chars)
300 s (5 min) OOM silencieux — Sortie vide (~340 chars)

Cas piégeux : si d'autres processus GPU tournent (Ollama, jeu, navigateur avec accélération, etc.) et mordent sur la VRAM disponible, Canary peut partir en boucle d'hallucination sur une durée qui passerait normalement. Observé sur un bench 30 s avec seulement ~4,2 Go libres au départ : latence 30,4 s et sortie répétée jusqu'au plafond de tokens (~2 432 chars). Le même bench avec ~2,5 Go libres au départ (Ollama arrêté) : latence 1,55 s, sortie propre.

Recommandations :

  • Sur 8 Go VRAM : Canary est fiable jusqu'à 30 s si rien d'autre ne tape sur le GPU
  • Au-delà : passer sur Parakeet (chunking interne, pas de plafond tangible) ou Whisper
  • Pour transcrire de longs fichiers audio (réunion, podcast), toujours utiliser Parakeet — Canary n'est pas conçu pour ça

Ponctuation & capitalisation natives

Canary produit nativement la ponctuation (., ,, ?, !) et la capitalisation des débuts de phrase + noms propres. Le token <|pnc|> est inclus dans le prompt par défaut — pour les désactiver il faudrait modifier le prompt (pas exposé côté config utilisateur).

Conséquence : l'étape Capitalisation du post-traitement n'a quasiment rien à faire sur la sortie Canary, contrairement à Vosk qui demande un cleanup massif.

GPU obligatoire en pratique

Canary fonctionne sur CPU (providers ONNX Runtime : CPUExecutionProvider en fallback), mais la latence est impraticable :

Durée audio GPU (RTX 4070) CPU (i7-13700H)
5 s 0,18 s ~4,5 s
10 s 0,36 s ~9 s

Le décodeur Transformer multicouche avec génération autoregressive 3× plus lente que le décodeur TDT de Parakeet sur CPU. Pour une utilisation interactive, GPU NVIDIA 6+ Go VRAM requis.

La langue source doit matcher l'audio

Différence importante avec Parakeet : Canary n'auto-détecte pas la langue. Vous devez fixer DICTEE_LANG_SOURCE=<code> avant de parler (via dictee-setup ou la combo langue du plasmoid). Si vous parlez français avec DICTEE_LANG_SOURCE=en, Canary va traduire vers l'anglais au lieu de transcrire en français — comportement conforme au modèle mais déroutant.

Exemple mesuré (bench WER 20 clips LibriSpeech anglais) :

  • DICTEE_LANG_SOURCE=fr : WER = 101 % (Canary retourne du français parce que source=fr + audio EN → traduction EN→FR)
  • DICTEE_LANG_SOURCE=en : WER = 1,8 %

Si vous basculez fréquemment entre langues, utilisez plutôt Parakeet qui gère l'auto-détection.

Arborescence des fichiers

Après téléchargement via dictee-setup ou la commande CLI dictee-setup --download-canary :

/usr/share/dictee/canary/
├── encoder.onnx           (~1 Go)
├── decoder.onnx           (~3 Go)
├── vocab.txt              (~50 Ko — tokens SentencePiece)
└── tokenizer.json         (~3 Mo — config HuggingFace tokenizer)

Ou en mode user-space :

~/.local/share/dictee/canary/
└── (même structure)

Le daemon dictee-canary.service pointe automatiquement vers le bon chemin via résolution dynamique.

Benchmarks

Mesurés sur TUXEDO InfinityBook Pro Gen8 (MK2) — Intel Core i7-13700H, RTX 4070 Laptop 8 Go, TUXEDO OS (kernel 6.17, NVIDIA 590.48.01), ONNX Runtime CUDA.

Latence chaude par durée d'utterance

5 runs par durée + 1 warm-up discardé, clips générés par concaténation LibriSpeech dev-clean. Canary chargé seul (Parakeet stoppé) pour maximiser la VRAM libre au moment de l'appel.

Longueur audio Canary (RTX 4070) Parakeet (RTX 4070) Observation Canary
3 s 0,203 s (min 0,200 · max 0,213) 0,039 s Propre
5 s 0,219 s (min 0,219 · max 0,237) 0,045 s Propre
10 s 0,401 s (min 0,396 · max 0,431) 0,081 s Propre
30 s 1,554 s (min 1,538 · max 1,566) 0,414 s Propre (721 chars)
60 s 4,05 s 0,711 s Tronqué (~780 chars)
300 s (5 min) 0,26 s 5,58 s Vide (~340 chars, OOM silencieux)

Parakeet reste linéaire sur toute la plage grâce à son chunking interne (RTF ~54× temps-réel même sur 5 min). Canary reste fiable jusqu'à 30 s puis décroche — l'encodeur a besoin de plus de VRAM que disponible pour faire rentrer toute l'attention.

Note sur la sensibilité à la VRAM : un premier bench avec seulement ~4,2 Go libres au départ (Ollama + Chrome actifs) donnait 30,4 s sur le clip 30 s (hallucination loop, 2 432 chars répétés). Avec Ollama arrêté (~2,5 Go libres au minimum pendant l'inférence), le même clip est traité proprement en 1,55 s. Sur une machine chargée, Canary peut basculer en mode dégradé bien avant d'atteindre sa « vraie » limite.

WER & CER (Mozilla Common Voice / LibriSpeech, 20 clips par langue)

Sortie brute, sans post-traitement :

Langue Dataset WER Canary CER Canary WER Parakeet CER Parakeet
FR MultiLingual LibriSpeech 5,4 % 2,1 % 7,4 % 4,0 %
EN LibriSpeech clean 1,8 % 0,5 % 2,0 % 0,6 %

Distribution de qualité (20 clips FR chacun) :

Canary FR Parakeet FR
Parfait (WER = 0 %) 8/20 4/20
Bon (WER < 10 %) 18/20 15/20
Acceptable (< 30 %) 20/20 19/20
Mauvais (≥ 30 %) 0/20 1/20

Verdict : Canary gagne en qualité sur les deux langues testées, à un coût latence 3-5× supérieur sur utterances courtes. Pour de la dictée courte (< 10 s), Canary est le choix idéal si vous avez la VRAM.

Étapes suivantes

📖 dictee Wiki

🇬🇧 Home · 🇫🇷 Accueil

Getting started / Premiers pas

Speech recognition / ASR

Translation / Traduction

Post-processing / Post-traitement

CLI

Reference / Référence

🏠 Repo · 📦 Releases · 🐛 Issues

Clone this wiki locally