Module L30 · Partie K · Ingénierie de l’IA

ASR : de l’onde sonore au texte.

Une seconde de parole = 16 000 nombres. Les transformer en mots demande de comprendre le signal (échantillonnage, transformée de Fourier, spectrogramme, mel, MFCC), les modèles (HMM-GMM historiques, CTC, encodeur-décodeur avec attention, Whisper, wav2vec 2.0 auto-supervisé), le décodage avec modèle de langue, et l’évaluation (WER et ses pièges, robustesse au bruit, accents, latence pour le temps réel). Tout est implémenté ici sur des signaux synthétiques, avec les mathématiques exactes.

Durée : 3 séances · Prérequis : L10, L11, L18 (Nyquist), L19, L29 (CTC). Objectifs : calculer un spectrogramme mel et des MFCC ; expliquer et coder la STFT ; comprendre CTC vs attention vs transducteur (RNN-T) ; évaluer par WER avec normalisation ; déployer Whisper localement et le mesurer ; lire les articles.

Ce que vous saurez faire à la fin

Passer d’une onde à un spectrogramme mel et l’interpréter (formants, harmoniques).
Expliquer le théorème d’échantillonnage, la résolution temps-fréquence, et le rôle des fenêtres.
Décrire l’architecture de Whisper et de wav2vec 2.0 et leurs objectifs d’entraînement.
Mesurer un système ASR proprement (WER normalisé, par condition, IC) et choisir entre local et API.

Fiche de cours · Définitions

Définitions

Définition (signal audio numérique). Suite x[n] = x(n/f_e) d’échantillons à la fréquence f_e (16 kHz pour la parole, 44,1 kHz pour la musique), quantifiés sur 16 bits. Un fichier WAV mono d’une minute à 16 kHz : 960 000 échantillons, 1,9 Mo.

Définition (transformée de Fourier discrète, STFT). DFT : X[k] = Σ_n x[n]e^−2iπkn/N, k-ième coefficient = amplitude et phase à la fréquence k·f_e/N. STFT : DFT sur des fenêtres glissantes (25 ms, pas 10 ms) pondérées (Hann) → spectrogramme |X[t, k]|² (temps × fréquence).

Définition (échelle mel, MFCC). mel(f) = 2595 log₁₀(1 + f/700) : perception humaine, résolution plus fine dans les graves. Banc de filtres triangulaires sur l’échelle mel (80 bandes) → log-mel spectrogramme, entrée standard des modèles. MFCC : DCT du log-mel, on garde 13 coefficients (décorrélés) — entrée des systèmes classiques.

Définition (phonème, lexique, modèle de langue). Phonème : unité sonore distinctive (≈ 36 en français). Lexique : mots → suites de phonèmes. Modèle de langue : p(mot_t | historique). Systèmes classiques : modèle acoustique (HMM-GMM ou HMM-DNN sur les phonèmes) × lexique × modèle de langue, décodés par Viterbi dans un graphe WFST.

Définition (de bout en bout). Un seul réseau du log-mel au texte : CTC (L29 ; sorties par trame, conditionnellement indépendantes), encodeur-décodeur avec attention (Whisper, LAS ; autorégressif, un modèle de langue implicite), transducteur RNN-T (streaming : émet des tokens au fil des trames avec un prédicteur).

Définition (auto-supervision, wav2vec 2.0). Pré-entraîner un encodeur sur de l’audio non transcrit en prédisant des unités quantifiées masquées (contrastif), puis affiner avec CTC sur peu de données transcrites (10 min–100 h).

Définition (WER, normalisation, diarisation). WER = (S + I + D)/N sur les mots après normalisation (casse, ponctuation, nombres en chiffres ou lettres, contractions). Diarisation : « qui parle quand ». Ponctuation et casse : tâche à part, ou incluse (Whisper).

Définition (streaming, latence). Temps réel : émettre la transcription pendant la parole, avec une latence bornée (200–800 ms) ; exige des modèles causaux ou à fenêtres (RNN-T, CTC en blocs, Whisper par segments avec recouvrement).

Fiche de cours · Formules

Formules à connaître

Nyquist-Shannon : f_e > 2f_max ; la parole est intelligible jusqu’à ≈ 4 kHz (téléphone : 8 kHz), riche jusqu’à 8 kHz (16 kHz)

DFT : X[k] = Σ_n=0^N−1 x[n] e^−2iπkn/N ; FFT en O(N log N) ; résolution fréquentielle Δf = f_e/N ; fenêtre de 25 ms à 16 kHz : N = 400, Δf = 40 Hz

Incertitude temps-fréquence : Δt·Δf ≥ 1/(4π) — une fenêtre courte localise le temps, une longue la fréquence ; 25 ms est le compromis pour la parole (stationnaire ~20–30 ms)

Fenêtre de Hann : w[n] = ½(1 − cos(2πn/N)) ; réduit les fuites spectrales (lobes secondaires −31 dB contre −13 dB pour la rectangulaire)

mel(f) = 2595 log₁₀(1 + f/700) ; f(mel) = 700(10^mel/2595 − 1) ; 80 filtres triangulaires entre 0 et f_e/2

MFCC : c[q] = Σ_m log(E_m) cos(πq(m + ½)/M), q = 0..12 (DCT-II) ; deltas Δc et ΔΔc

Whisper : 30 s → log-mel 80 × 3000 → conv ×2 (pas 2) → 1500 positions → encodeur transformer → décodeur autorégressif avec tokens spéciaux (langue, tâche, horodatages)

wav2vec 2.0 : L = −log [e^{sim(c_t, q_t)/κ} / Σ_{q̃ ∈ distracteurs} e^{sim(c_t, q̃)/κ}] + α·diversité (InfoNCE sur les unités quantifiées masquées)

WER = (S + I + D)/N ; IC à 95 % ≈ ± 1,96 √(WER(1 − WER)/N) (approximation, mots supposés indépendants — sous-estime)

Facteur temps réel RTF = temps de calcul / durée audio ; streaming exige RTF < 1 avec latence = taille de bloc + calcul

Fiche de cours · Théorèmes et démonstrations

Démonstrations à savoir refaire

Théorème 1 (repliement : une sinusoïde au-dessus de f_e/2 est indiscernable d’une sinusoïde plus basse). Pour tout entier m, les signaux cos(2πf·n/f_e) et cos(2π(f + m·f_e)·n/f_e) ont les mêmes échantillons ; de même f et m·f_e − f.

cos(2π(f + mf_e)n/f_e) = cos(2πfn/f_e + 2πmn) = cos(2πfn/f_e) car cos est 2π-périodique et mn entier. Pour mf_e − f : cos(2π(mf_e − f)n/f_e) = cos(2πmn − 2πfn/f_e) = cos(2πfn/f_e) (parité). Donc, après échantillonnage, toute fréquence se « replie » dans [0, f_e/2] : un sifflement à 12 kHz échantillonné à 16 kHz apparaît à 4 kHz. D’où le filtre anti-repliement analogique avant l’ADC (L18) et le rééchantillonnage avec filtre (pas une simple décimation) quand on passe de 44,1 à 16 kHz.

Théorème 2 (la DFT est un changement de base orthogonal ; Parseval). Les vecteurs e_k[n] = e^2iπkn/N/√N forment une base orthonormée de ℂ^N ; donc x se reconstruit exactement (IDFT) et Σ|x[n]|² = (1/N)Σ|X[k]|².

⟨e_k, e_l⟩ = (1/N)Σ_n e^{2iπ(k−l)n/N} : si k = l, chaque terme vaut 1, somme N/N = 1 ; sinon c’est une somme géométrique de raison r = e^{2iπ(k−l)/N} ≠ 1 avec r^N = 1 : (1 − r^N)/(1 − r) = 0. Base orthonormée ⇒ x = Σ ⟨x, e_k⟩e_k (IDFT) et conservation de la norme (Parseval) : l’énergie du signal est la somme des énergies par fréquence — le spectrogramme est une répartition de l’énergie. L’orthogonalité est aussi ce qui rend la FFT possible (structure de groupe des racines de l’unité, diviser pour régner : L04).

Théorème 3 (une fenêtre courte étale le spectre). Multiplier un signal par une fenêtre w de durée T revient à convoluer son spectre par W = DFT(w), dont le lobe principal a une largeur ≈ 2/T (Hann) : deux fréquences distantes de moins de ≈ 1/T ne sont pas séparables.

Théorème de convolution : DFT(x·w) = DFT(x) ∗ DFT(w)/N. Une sinusoïde pure (spectre = une raie) devient une copie de W centrée sur sa fréquence. Pour la fenêtre rectangulaire de N points, W est un noyau de Dirichlet de lobe principal 2f_e/N ; pour Hann, 4f_e/N mais lobes secondaires bien plus bas. À 25 ms : lobe ≈ 80–160 Hz — les harmoniques d’une voix (espacées de f₀ ≈ 100–250 Hz) sont tout juste résolues ; pour analyser la hauteur on prend des fenêtres plus longues, pour les transitoires (plosives) plus courtes. C’est l’incertitude temps-fréquence en pratique.

Théorème 4 (CTC suppose l’indépendance conditionnelle ; l’attention non). Sous CTC, p(y | X) = Σ_π Π_t p(π_t | X) : les sorties de trames différentes sont indépendantes sachant X, ce qui interdit au modèle d’apprendre p(y_t | y_<t) ; un décodeur autorégressif modélise p(y_t | y_<t, X) directement.

Par définition de la factorisation CTC, aucun terme ne dépend d’une autre sortie π_t′. Donc le modèle ne peut pas préférer « the cat » à « the kat » autrement que par l’acoustique : la connaissance linguistique doit venir d’un modèle de langue externe au décodage (faisceau + LM, L29 Théorème 4). Un décodeur à attention conditionne chaque token sur les précédents : il inclut un LM implicite (appris sur les transcriptions) — c’est pourquoi Whisper produit ponctuation, casse et mots rares sans LM externe, mais aussi pourquoi il peut « halluciner » des phrases plausibles sur du silence ou du bruit (le LM implicite prend le dessus quand l’acoustique n’informe pas). RNN-T est intermédiaire : un prédicteur sur y_<t joint à l’encodeur acoustique, tout en restant streamable.

01 / Le signal

Synthétiser une « voyelle », échantillonner, repliement

import numpy as np
import matplotlib.pyplot as plt
fe = 16000; t = np.arange(0, 0.5, 1 / fe)
# Une voyelle synthétique : fondamentale f0 = 140 Hz avec harmoniques, modulée par une enveloppe de formants (résonances du conduit vocal)
f0 = 140; formants = [(700, 80), (1200, 100), (2600, 150)]                   # (fréquence, largeur) — proche d'un "a"
def enveloppe(f): return sum(np.exp(-0.5 * ((f - fc) / bw) ** 2) for fc, bw in formants)
harm = np.arange(1, int(7000 / f0)); amp = enveloppe(harm * f0) / harm ** 0.3
voyelle = sum(a * np.sin(2 * np.pi * h * f0 * t) for h, a in zip(harm, amp)); voyelle /= np.abs(voyelle).max()
voyelle *= np.minimum(1, t / 0.05) * np.minimum(1, (0.5 - t) / 0.05)         # attaque et extinction
rng = np.random.default_rng(0); signal = voyelle + 0.02 * rng.normal(0, 1, len(t))
# Repliement : un sifflement à 12 kHz "vu" à 16 kHz d'échantillonnage
sifflet = 0.3 * np.sin(2 * np.pi * 12000 * t)
X = np.abs(np.fft.rfft(sifflet * np.hanning(len(t)))); f = np.fft.rfftfreq(len(t), 1 / fe)
print(f"sifflement à 12 000 Hz échantillonné à 16 kHz : pic mesuré à {f[X.argmax()]:.0f} Hz (Théorème 1 : 16 000 − 12 000)")
fig, ax = plt.subplots(1, 3, figsize=(13, 3.2))
ax[0].plot(t[:400] * 1000, signal[:400]); ax[0].set_title("25 ms de signal (≈ 3,5 périodes de f0 = 140 Hz)"); ax[0].set_xlabel("ms")
Xv = np.abs(np.fft.rfft(signal[2000:2400] * np.hanning(400))); fv = np.fft.rfftfreq(400, 1 / fe)
ax[1].plot(fv, 20 * np.log10(Xv + 1e-6)); ax[1].set_title("spectre d'une fenêtre de 25 ms (dB)"); ax[1].set_xlabel("Hz"); ax[1].set_xlim(0, 4000)
Xl = np.abs(np.fft.rfft(signal[1000:4200] * np.hanning(3200))); fl = np.fft.rfftfreq(3200, 1 / fe)
ax[2].plot(fl, 20 * np.log10(Xl + 1e-6)); ax[2].set_title("fenêtre de 200 ms : harmoniques résolues (Théorème 3)"); ax[2].set_xlabel("Hz"); ax[2].set_xlim(0, 4000)
plt.tight_layout(); plt.show()

Sur 25 ms, on voit l’enveloppe (les formants, qui identifient la voyelle) ; sur 200 ms, les harmoniques (la hauteur, f₀). L’ASR veut les formants : d’où les fenêtres courtes et l’échelle mel qui lisse les harmoniques.

01 / Le signal

STFT, spectrogramme log-mel, MFCC — implémentés

import numpy as np
import matplotlib.pyplot as plt
def stft(x, n_fft=400, hop=160):
    w = np.hanning(n_fft); n = 1 + (len(x) - n_fft) // hop
    return np.array([np.fft.rfft(x[i * hop:i * hop + n_fft] * w) for i in range(n)])          # (trames, n_fft/2 + 1)
def mel(f): return 2595 * np.log10(1 + f / 700)
def mel_inv(m): return 700 * (10 ** (m / 2595) - 1)
def banc_mel(n_mels=40, n_fft=400, fe=16000):
    pts = mel_inv(np.linspace(mel(0), mel(fe / 2), n_mels + 2)); bins = np.floor((n_fft + 1) * pts / fe).astype(int)
    F = np.zeros((n_mels, n_fft // 2 + 1))
    for m in range(1, n_mels + 1):
        a, b, c = bins[m - 1], bins[m], bins[m + 1]
        F[m - 1, a:b] = (np.arange(a, b) - a) / max(1, b - a); F[m - 1, b:c] = (c - np.arange(b, c)) / max(1, c - b)
    return F
S = np.abs(stft(signal)) ** 2; F = banc_mel(); logmel = np.log(S @ F.T + 1e-10)                # (trames, 40)
def dct2(x, k=13):
    M = x.shape[-1]; n = np.arange(M); return np.array([(x * np.cos(np.pi * q * (n + 0.5) / M)).sum(-1) for q in range(k)]).T
mfcc = dct2(logmel)
print("spectrogramme :", S.shape, "| log-mel :", logmel.shape, "| MFCC :", mfcc.shape, "— 10 ms par trame")
fig, ax = plt.subplots(1, 3, figsize=(13, 3.2))
ax[0].imshow(10 * np.log10(S.T + 1e-10), origin="lower", aspect="auto", extent=[0, 0.5, 0, 8000]); ax[0].set_title("spectrogramme (dB)"); ax[0].set_ylabel("Hz")
ax[1].imshow(logmel.T, origin="lower", aspect="auto", extent=[0, 0.5, 0, 40]); ax[1].set_title("log-mel (40 bandes) : entrée des modèles"); ax[1].set_ylabel("bande mel")
ax[2].imshow(mfcc[:, 1:].T, origin="lower", aspect="auto", extent=[0, 0.5, 1, 13]); ax[2].set_title("MFCC 1–12 : entrée des systèmes classiques"); ax[2].set_ylabel("coefficient")
for a in ax: a.set_xlabel("s")
plt.tight_layout(); plt.show()
# Sur PC : librosa.feature.melspectrogram / mfcc, ou torchaudio.transforms.MelSpectrogram — mêmes formules.

02 / Reconnaître

Un reconnaisseur de voyelles par CTC : un modèle minuscule entraîné sur des trames synthétiques

import numpy as np
rng = np.random.default_rng(1)
# Trois "voyelles" définies par leurs formants ; un énoncé = suite de voyelles de durées variables + silences. Le modèle : régression logistique
# par trame (log-mel → {ε, a, i, u}) entraînée par la perte CTC (L29) via son gradient exact (algorithme avant-arrière).
VOY = {"a": [(700, 80), (1200, 100)], "i": [(300, 60), (2300, 120)], "u": [(350, 60), (800, 80)]}; sym = ["ε", "a", "i", "u"]
def trames_voyelle(v, n, bruit=0.4):
    f = np.linspace(0, 8000, 201)[None, :]; env = sum(np.exp(-0.5 * ((f - fc) / bw) ** 2) for fc, bw in VOY[v])
    return np.log(env @ banc_mel().T + 0.02) + bruit * rng.normal(0, 1, (n, 40)) + 0.5 * rng.normal(0, 1, (1, 40))   # variabilité du locuteur
def trames_silence(n): return np.log(np.full((n, 40), 0.02)) + 0.4 * rng.normal(0, 1, (n, 40))
def enonce():
    y = list(rng.choice(["a", "i", "u"], rng.integers(1, 4))); X = [trames_silence(rng.integers(2, 5))]
    for v in y: X += [trames_voyelle(v, rng.integers(4, 9)), trames_silence(rng.integers(1, 4))]
    return np.vstack(X), [sym.index(v) for v in y]
def ctc_grad(logp, y, blanc=0):
    """Retourne log p(y|X) et ∂(−log p)/∂logits via avant-arrière (Graves 2006)."""
    yp = [blanc]
    for c in y: yp += [c, blanc]
    S, T = len(yp), len(logp); NEG = -1e30
    def lse(v): v = np.asarray(v); m = v.max(); return m + np.log(np.exp(v - m).sum()) if m > NEG / 2 else NEG
    al = np.full((T, S), NEG); al[0, 0] = logp[0, blanc]; al[0, 1] = logp[0, yp[1]]
    for t in range(1, T):
        for s in range(S):
            c = [al[t-1, s]] + ([al[t-1, s-1]] if s >= 1 else []) + ([al[t-1, s-2]] if s >= 2 and yp[s] != blanc and yp[s] != yp[s-2] else [])
            al[t, s] = lse(c) + logp[t, yp[s]]
    be = np.full((T, S), NEG); be[T-1, S-1] = 0; be[T-1, S-2] = 0
    for t in range(T - 2, -1, -1):
        for s in range(S):
            c = [be[t+1, s] + logp[t+1, yp[s]]] + ([be[t+1, s+1] + logp[t+1, yp[s+1]]] if s + 1 < S else []) + ([be[t+1, s+2] + logp[t+1, yp[s+2]]] if s + 2 < S and yp[s+2] != blanc and yp[s+2] != yp[s] else [])
            be[t, s] = lse(c)
    ll = lse([al[T-1, S-1], al[T-1, S-2]]); g = np.exp(logp)                       # ∂(−log p)/∂logit_k = p_k − (occupation de k à t)
    for t in range(T):
        for s in range(S): g[t, yp[s]] -= np.exp(al[t, s] + be[t, s] - ll)
    return ll, g
W = rng.normal(0, 0.1, (40, 4)); b = np.zeros(4); lr = 0.05
for it in range(400):
    X, y = enonce(); z = X @ W + b; logp = z - np.log(np.exp(z).sum(1, keepdims=True)); ll, g = ctc_grad(logp, y)
    W -= lr * X.T @ g / len(X); b -= lr * g.mean(0)
    if it % 100 == 0 or it == 399: print(f"itération {it:3d} : −log p(y|X) = {-ll:6.2f}  (T = {len(X)}, |y| = {len(y)})")
def reduire(ch):
    out, prev = [], None
    for c in ch:
        if c != prev and c != 0: out.append(c)
        prev = c
    return out
ok = 0
for _ in range(100):
    X, y = enonce(); pred = reduire((X @ W + b).argmax(1)); ok += (pred == y)
print(f"exactitude de séquence sur 100 énoncés de test (décodage glouton) : {ok} %")

Un modèle de 164 paramètres apprend à transcrire des suites de voyelles sans jamais savoir où elles commencent : c’est la promesse de CTC. Les vrais systèmes remplacent la régression logistique par un encodeur de 10⁸–10⁹ paramètres et les voyelles synthétiques par 10⁵ heures d’audio.

03 / Modèles

Vue informatique : les architectures de l’ASR moderne

Système	Architecture / objectif	Données	Forces	Limites
Kaldi (HMM-DNN)	Modèle acoustique par phonème + lexique + LM n-gramme, décodage WFST	100–1000 h transcrites + lexique	Contrôlable, léger, streaming	Pipeline complexe ; lexique à maintenir
DeepSpeech 2 (2015)	Conv + RNN + CTC + LM externe	10 000 h	Premier bout-en-bout à l’échelle	Indépendance conditionnelle (Théorème 4)
wav2vec 2.0 (2020)	Encodeur conv + transformer, pré-entraîné par contraste sur audio brut ; affinage CTC	60 000 h non transcrites + 10 min–100 h	Peu de données étiquetées ; langues rares	Pas de LM implicite ; ponctuation à part
Conformer / RNN-T (Google)	Conv + attention, transducteur streaming	Propriétaires	Temps réel sur téléphone	Entraînement délicat
Whisper (2022)	Encodeur-décodeur transformer, supervision faible multitâche (transcription, traduction, langue, horodatages)	680 000 h web (multilingue)	Robuste (accents, bruit), zero-shot, ponctuation, 99 langues, libre	Pas streaming natif ; hallucinations sur silence ; 30 s fixes ; lourd (1,5B) — versions distillées, faster-whisper
Modèles audio-LLM (2024+)	Encodeur audio + LLM (Qwen-Audio, Gemini)	Massives	Compréhension au-delà de la transcription	Coût ; évaluation difficile

04 / Évaluer

WER : normalisation, conditions, intervalles — et ce qu’il ne dit pas

import numpy as np, re, unicodedata
def levenshtein(a, b):
    D = list(range(len(b) + 1))
    for i, ca in enumerate(a, 1):
        prev, D[0] = D[0], i
        for j, cb in enumerate(b, 1): prev, D[j] = D[j], min(D[j] + 1, D[j - 1] + 1, prev + (ca != cb))
    return D[-1]
NOMBRES = {"deux": "2", "trois": "3", "douze": "12", "vingt": "20"}
def normaliser(s):
    s = s.lower(); s = "".join(c for c in unicodedata.normalize("NFD", s) if unicodedata.category(c) != "Mn")
    s = re.sub(r"[^\w\s]", " ", s); s = " ".join(NOMBRES.get(w, w) for w in s.split()); return s
def wer(hyp, ref): r, h = normaliser(ref).split(), normaliser(hyp).split(); return levenshtein(r, h) / len(r)
ref = "Le robot avance de douze mètres, puis s'arrête : batterie faible."
hyps = {"A (mot-à-mot)": "le robot avance de 12 mètres puis s'arrête batterie faible", "B (sens ok, mots changés)": "Le robot avance de 12 mètres et il s'arrête, la batterie est faible.", "C (mot critique faux)": "Le robot avance de deux mètres, puis s'arrête : batterie faible."}
for n, h in hyps.items(): print(f"{n:28s} WER = {wer(h, ref):.3f}")
print("\nB a un WER élevé mais transmet le sens ; C a un WER minuscule (1 mot) mais change une valeur critique : le WER n'est pas une mesure de sens.")
# Par condition et avec IC : un jeu de test doit être stratifié (bruit, accent, micro, domaine)
rng = np.random.default_rng(0)
conditions = {"studio": (0.04, 2000), "voiture (bruit)": (0.15, 800), "accent régional": (0.11, 600), "termes techniques": (0.22, 400)}
for c, (w, n) in conditions.items():
    ic = 1.96 * np.sqrt(w * (1 - w) / n); print(f"{c:20s} WER {100*w:5.1f} % ± {100*ic:.1f} (n = {n} mots)")
tot = sum(w * n for w, n in conditions.values()) / sum(n for _, n in conditions.values()); print(f"\nWER global {100*tot:.1f} % — trompeur : il dépend du mélange des conditions dans le jeu de test, pas seulement du système.")

Un WER se rapporte avec sa normalisation, par condition, avec n. Compléter par : taux d’erreur sur les entités (nombres, noms), latence (p50/p95, RTF), robustesse (SNR variable), et pour les assistants, le taux de commandes correctement exécutées — la métrique que l’utilisateur ressent.

05 / Articles

Les articles à lire

Article	Contribution	À retenir
Davis & Mermelstein, Comparison of parametric representations for monosyllabic word recognition, IEEE TASSP 1980	MFCC	40 ans de représentation standard ; remplacée par le log-mel + apprentissage
Rabiner, A Tutorial on Hidden Markov Models and Selected Applications in Speech Recognition, Proc. IEEE 1989	HMM pour la parole ; avant-arrière, Viterbi, Baum-Welch	Les mêmes récurrences que CTC (L29) ; à lire pour la culture et la PD
Graves et al., CTC, ICML 2006 ; Graves, Sequence Transduction with RNNs (RNN-T), 2012 — 1211.3711	Pertes de séquence ; transducteur streamable	Théorème 4 : CTC vs autorégressif
Amodei et al., Deep Speech 2, ICML 2016 — 1512.02595	Bout-en-bout à l’échelle, anglais et mandarin	Les données et le calcul, plus que l’architecture
Chan et al., Listen, Attend and Spell, ICASSP 2016 — 1508.01211	Encodeur-décodeur avec attention pour l’ASR	Le LM implicite ; ancêtre de Whisper
Baevski et al., wav2vec 2.0, NeurIPS 2020 — 2006.11477	Auto-supervision contrastive sur audio brut ; 10 min de données étiquetées suffisent	Le pré-entraînement change l’économie des langues peu dotées
Gulati et al., Conformer, Interspeech 2020 — 2005.08100	Convolution + attention dans chaque bloc	Architecture dominante avant Whisper
Radford et al., Robust Speech Recognition via Large-Scale Weak Supervision (Whisper), 2022 — 2212.04356	680 kh de données web faiblement supervisées ; robustesse zero-shot	La distribution des données d’entraînement (diversité) explique la robustesse ; section sur les hallucinations
Panayotov et al., LibriSpeech, ICASSP 2015 ; Ardila et al., Common Voice, LREC 2020	Corpus de référence ; corpus participatif multilingue	Les benchmarks « propres » saturent ; mesurer sur du réel
Bredin, pyannote.audio, Interspeech 2023	Diarisation	« Qui parle quand » reste un problème à part, avec sa métrique (DER)

TP guidé

TP — Whisper local : mesurer, dégrader, améliorer (4 h)

Installer. pip install faster-whisper librosa jiwer sounddevice ; enregistrer 30 phrases (vous et deux autres personnes, dont une avec accent), transcriptions de référence tapées.
Signal. Avec librosa : forme d’onde, spectrogramme, log-mel 80 bandes ; identifier vos formants sur une voyelle tenue ; rééchantillonner 44,1 → 16 kHz avec et sans filtre et écouter le repliement.
Baseline. faster-whisper tiny/small/large-v3 : WER (jiwer, normalisation déclarée), RTF CPU et GPU, par locuteur.
Robustesse. Ajouter du bruit (SNR 20, 10, 0 dB), de la réverbération, du silence (30 s) : courbes WER vs SNR ; compter les hallucinations sur silence ; tester vad_filter=True.
Domaine. 20 phrases avec vos termes techniques : WER sur les entités ; améliorer avec initial_prompt (vocabulaire) et un post-traitement par dictionnaire ; mesurer.
Streaming. Transcrire au fil du micro par blocs de 2 s avec recouvrement ; mesurer la latence ; observer les coupures de mots aux frontières.
Livrable. Dépôt (audio, références, scripts), tableau WER × modèle × condition avec IC, courbes SNR, et une recommandation de déploiement (modèle, matériel, coût par heure d’audio).

Exercices

Exercices auto-corrigés

Exercice 1 — Fréquence repliée

Écrivez frequence_apparente(f, fe) : la fréquence dans [0, fe/2] à laquelle apparaît une sinusoïde de fréquence f échantillonnée à fe (Théorème 1), puis vérifiez-la numériquement par FFT sur trois cas.

Correction

def frequence_apparente(f, fe):
    r = f % fe; return r if r <= fe / 2 else fe - r

Exercice 2 — Fuites spectrales et fenêtre

Pour une sinusoïde de 1 000 Hz observée sur 25 ms à 16 kHz, calculez le rapport entre l’énergie dans les 3 bins autour du pic et l’énergie totale, avec une fenêtre rectangulaire puis de Hann. Écrivez concentration(x, fenetre) et vérifiez que Hann concentre davantage l’énergie lorsque la fréquence tombe entre deux bins (fuite maximale).

Correction

def concentration(x, fenetre):
    X = np.abs(np.fft.rfft(x * fenetre)) ** 2; k = X.argmax()
    return X[max(0, k - 1):k + 2].sum() / X.sum()

Exercices

Exercices auto-corrigés (suite)

Exercice 3 — Banc de filtres mel et son inverse approché

Écrivez frequences_centrales_mel(n_mels, fe) (les n_mels fréquences centrales, en Hz, équiréparties sur l’échelle mel entre 0 et fe/2) et vérifiez : espacement croissant avec la fréquence, première bande sous 100 Hz pour 80 bandes à 16 kHz, et que les centres sont symétriques sur l’échelle mel.

Correction

def frequences_centrales_mel(n_mels, fe=16000):
    mel = lambda f: 2595 * np.log10(1 + f / 700); inv = lambda m: 700 * (10 ** (m / 2595) - 1)
    return inv(np.linspace(mel(0), mel(fe / 2), n_mels + 2))[1:-1]

Exercice 4 — WER par entité et intervalle de confiance

Écrivez wer_entites(refs, hyps, entites) : pour une liste de paires (référence, hypothèse), le taux d’erreur restreint aux mots de entites (un mot d’entité de la référence est « correct » s’il apparaît dans l’hypothèse au même rang parmi les entités), et ic_wer(wer, n) = demi-largeur à 95 % (approximation binomiale).

Correction

def wer_entites(refs, hyps, entites):
    err = tot = 0
    for r, h in zip(refs, hyps):
        er = [w for w in r.split() if w in entites]; eh = [w for w in h.split() if w in entites]
        for i, w in enumerate(er): tot += 1; err += (i >= len(eh) or eh[i] != w)
    return err / tot, tot
def ic_wer(w, n): return 1.96 * np.sqrt(w * (1 - w) / n)

Fiche de cours · Exercices corrigés

Exercices corrigés (rédaction)

Exercice 1. Pourquoi les modèles d’ASR utilisent-ils 80 bandes mel de 10 ms plutôt que le spectre brut de 201 bins ? Donner trois raisons (perception, statistique, calcul).

Correction. (1) Perception : l’oreille résout mieux les graves ; l’échelle mel alloue la résolution là où l’information phonétique est (formants sous 4 kHz) et lisse les harmoniques (la hauteur f₀ varie entre locuteurs sans changer les mots). (2) Statistique : 80 dimensions au lieu de 201 réduisent la variance de l’estimation et la sensibilité au bruit fin ; le log compresse la dynamique (l’énergie varie de 60 dB) et rend les distributions plus gaussiennes ; les MFCC décorrèlent en plus (utile pour les GMM diagonaux). (3) Calcul : 2,5× moins d’entrées ; 100 trames/s × 80 = 8 000 valeurs/s, contre 16 000 échantillons/s bruts. Les modèles auto-supervisés (wav2vec 2.0) partent de l’onde brute et apprennent leur propre banc de filtres — qui ressemble au mel.

Exercice 2. Whisper transcrit « merci d’avoir regardé, abonnez-vous » sur 20 s de silence. Expliquer par le Théorème 4 et proposer trois parades.

Correction. Le décodeur autorégressif contient un modèle de langue implicite appris sur des sous-titres web ; quand l’encodeur n’apporte pas d’information (silence, bruit), le décodeur échantillonne des phrases fréquentes dans les données d’entraînement (fins de vidéos). Un modèle CTC, par indépendance conditionnelle, émettrait des blancs. Parades : (1) détection d’activité vocale (VAD) en amont — ne transcrire que les segments parlés ; (2) seuils sur la log-probabilité moyenne et sur le ratio de compression du texte (répétitions), rejet des segments suspects (options no_speech_threshold, compression_ratio_threshold) ; (3) contrainte de décodage (horodatages, longueur maximale par segment) et vérification croisée par un second système (CTC) sur les segments douteux.

Exercice 3. Un assistant vocal pour robot doit reconnaître 50 commandes dans un atelier bruyant, en moins de 500 ms, sans connexion internet. Concevoir le système et son évaluation.

Correction. Le problème est fermé (50 commandes) : pas besoin d’un ASR général. Options : (a) Whisper tiny/base local avec initial_prompt listant les commandes + correspondance floue (Levenshtein) vers la commande la plus proche, seuil de rejet ; (b) mieux : un petit modèle de classification de commandes (wav2vec 2.0 affiné ou un CNN sur log-mel) entraîné sur 50 commandes × 20 locuteurs × augmentations de bruit d’atelier — latence < 100 ms sur CPU ; (c) mot de réveil (« robot ») par un détecteur léger en continu, puis reconnaissance. Évaluation : taux de commandes correctes par condition de bruit (SNR mesuré dans l’atelier), taux de faux déclenchements par heure (critique pour la sécurité), latence p95, matrice de confusion entre commandes (les paires dangereuses « avance »/« arrête » doivent être ≈ 0 : ajouter une confirmation pour les commandes de mouvement). Jeu de test enregistré sur place, avec les vrais micros.

Vérification

Pourquoi un modèle encodeur-décodeur (Whisper) peut-il « halluciner » du texte sur du silence, et pas un modèle CTC ?

Deux questions supplémentaires

1. Pourquoi 25 ms de fenêtre ? Compromis temps-fréquence : la parole est quasi stationnaire sur 20–30 ms ; plus court, on perd la résolution fréquentielle des formants.

2. Que signifie un RTF de 0,3 ? Le calcul prend 30 % de la durée de l’audio : 1 h transcrite en 18 min ; le streaming exige RTF < 1 avec une latence bornée.

Référence

Les mots à retenir

Mot	Définition
Nyquist	f_e > 2f_max ; sinon repliement.
STFT / spectrogramme	FFT sur fenêtres glissantes ; énergie temps × fréquence.
Log-mel, MFCC	Banc de filtres perceptif ; DCT décorrélante.
CTC / attention / RNN-T	Trois façons d’aligner audio et texte ; indépendance conditionnelle ou non ; streaming.
wav2vec 2.0	Pré-entraînement contrastif sur audio brut.
Whisper	Encodeur-décodeur multitâche, 680 kh, robuste, non streaming.
WER	Taux d’erreur mots ; normalisation, condition, IC, entités.
RTF	Temps de calcul / durée audio.

Suite

Vous avez vu des CNN, des LSTM, des transformers, des CTC. Il est temps de faire la carte.

Chapitre suivant : les familles de réseaux de neurones, leurs biais inductifs, leurs coûts, et comment choisir — avec les mathématiques qui les distinguent.

← L29 Sommaire L31 : familles de réseaux →