Reconnaissance vocale — définition, technologies et principe de fonctionnement

Qu'est-ce que la reconnaissance vocale : principes de l'ASR

Automatic Speech Recognition (ASR) est un pipeline : audio → prétraitement (16 kHz mono, réduction du bruit, VAD — détection d'activité vocale) → extraction de caractéristiques (MFCC, LogMel FilterBank) → modèle acoustique (réseau neuronal : CTC / RNNT / Transducer) → modèle de langage (LM) → décodage (texte). Les modèles modernes de bout en bout (Whisper, Google USM, Conformer CTC) combinent le modèle acoustique et le modèle de langage en un seul Transformer, simplifiant le pipeline et améliorant la précision.

Architectures ASR pour appareils mobiles : CTC (Connectionist Temporal Classification) — rapide, ne nécessite pas d'alignement audio-texte, utilisé dans Vosk et Android natif. RNNT (Recurrent Neural Network Transducer) — ASR en streaming, faible latence (Google USM). Conformer — un hybride de CNN + Transformer, meilleure précision mais plus lourd : Whisper Medium (769M params) — latence 30–60x. Pour sur appareil, CTC est préféré : les modèles CTC de Vosk occupent 50–100 Mo, latence 0,3–0,8x temps réel.

Métriques ASR : WER (Word Error Rate) — pourcentage de mots substitués, supprimés et insérés par rapport à la référence. Google Cloud ASR — 7 % WER (EN), 12 % (RU). Vosk — 13 % (RU), 9 % (EN). Whisper Small — 6 % (EN), 10 % (RU). CER (Character Error Rate) — similaire, au niveau des caractères. Real-Time Factor (RTF) — temps de traitement / durée audio. RTF < 1 — plus rapide que le temps réel. RTF < 0,3 — ASR en temps réel. La saisie vocale nécessite RTF < 1, la transcription nécessite RTF < 3.

VAD (Voice Activity Detection) — détection de l'activité vocale, séparant la parole du silence et du bruit. WebRTC VAD est la norme pour l'ASR mobile : trames de 30 ms, trois modes (0, 1, 2 — de conservateur à agressif). VAD réduit le RTF de 1,5 à 3x (ignore les segments non parlés). Silero VAD (MIT) est un VAD neuronal, plus précis que WebRTC (94 % contre 85 % ROC AUC), latence 5–10 ms, TFLite et Core ML. Pour l'ASR en production, utilisez la cascade VAD → ASR : cela réduit les faux positifs et accélère le traitement.

Android SpeechRecognizer API

Android SpeechRecognizer est une classe intégrée du SDK Android pour la reconnaissance vocale. Elle fonctionne en deux modes : cloud (serveur Google) — haute précision, nécessite Internet ; sur appareil (depuis Android 10+) — modèle ASR intégré de GBoard, 20+ langues, WER 15–18 %. SpeechRecognizer renvoie des résultats intermédiaires (résultats partiels) pendant la parole et le texte final. Prend en charge 60+ langues via RecognizerIntent.EXTRA_LANGUAGE. Recommandé pour la saisie vocale — intégration rapide, gratuit.

API SpeechRecognizer : création via SpeechRecognizer.createSpeechRecognizer(context). Intent avec RecognizerIntent.ACTION_RECOGNIZE_SPEECH avec extras : LANGUAGE_MODEL_FREE_FORM (texte libre) ou LANGUAGE_MODEL_WEB_SEARCH (requêtes de recherche). Résultats via RecognitionListener : onReadyForSpeech → onBeginningOfSpeech → onRmsChanged → onPartialResults → onResults. Pour la reconnaissance continue (mode écoute permanente) — redémarrez le recognizer après onResults. Pour économiser la batterie, utilisez onDeviceOnly = true.

// Android SpeechRecognizer
val recognizer = SpeechRecognizer.createSpeechRecognizer(context)
recognizer.setRecognitionListener(object : RecognitionListener {
    override fun onResults(results: Bundle) {
        val text = results
            .getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)
            ?.firstOrNull() ?: ""
        showResult(text)
    }
    override fun onPartialResults(partialResults: Bundle) {
        val partial = partialResults
            .getStringArrayList(SpeechRecognizer.RESULTS_RECOGNITION)
            ?.firstOrNull() ?: ""
        showPartial(partial)
    }
})

val intent = Intent(RecognizerIntent.ACTION_RECOGNIZE_SPEECH).apply {
    putExtra(RecognizerIntent.EXTRA_LANGUAGE_MODEL,
        RecognizerIntent.LANGUAGE_MODEL_FREE_FORM)
    putExtra(RecognizerIntent.EXTRA_LANGUAGE, "ru-RU")
}
recognizer.startListening(intent)

Sur appareil vs Cloud sous Android : sur appareil fonctionne sans Internet (Android 10+, Pixel 4+, Samsung S20+). Le cloud est plus précis (Google Neural Network ASM Model) mais a une latence plus élevée (300–800 ms réseau inclus). Pour la saisie vocale, utilisez une approche hybride : cloud avec repli sur appareil en l'absence de réseau. Android SpeechRecognizer sélectionne automatiquement le mode en fonction de RecognizerIntent.EXTRA_PREFER_OFFLINE. Pour une confidentialité maximale — définissez onDeviceOnly = true (mais la précision est de 15–18 % WER pour le russe).

iOS SFSpeechRecognizer et Speech Framework

SFSpeechRecognizer est le framework d'Apple pour la reconnaissance vocale sur iOS, macOS et watchOS. Disponible depuis iOS 10. Mode sur appareil — depuis iOS 17 (modèle local, sans Internet). Prend en charge 60+ langues. Précision : WER 7–12 % (sur appareil — 12–15 %). SFSpeechRecognizer est disponible via Speech.framework — aucun SDK supplémentaire requis. Demande d'autorisation via SFSpeechRecognizer.requestAuthorization.

API SFSpeechRecognizer : SFSpeechRecognizer(locale : Locale(identifier : "ru_RU")) → SFSpeechAudioBufferRecognitionRequest (audio en direct) ou SFSpeechURLRecognitionRequest (fichier audio). Streaming via recognitionTask(with:delegate:) avec SFSpeechRecognitionTaskDelegate (didHypothesizeTranscription — partiel, didFinishRecognition — final). Mode sur appareil : request.requiresOnDeviceRecognition = true. Pour iOS 15+ : request.shouldReportPartialResults = true (résultat en streaming avec faible latence).

let recognizer = SFSpeechRecognizer(locale: Locale(identifier: "ru_RU"))
guard recognizer.isAvailable else { return }

let request = SFSpeechAudioBufferRecognitionRequest()
request.requiresOnDeviceRecognition = true
request.shouldReportPartialResults = true

recognitionTask = recognizer.recognitionTask(with: request) { result, error in
    if let result = result {
        let text = result.bestTranscription.formattedString
        let isFinal = result.isFinal
        DispatchQueue.main.async {
            textView.text = text
        }
    }
}

audioEngine.inputNode.installTap(config: bufferConfig) { buffer, _ in
    request.append(buffer)
}
audioEngine.prepare()
try audioEngine.start()

SFSpeechRecognizer vs Android SpeechRecognizer : SFSpeechRecognizer dispose d'un streaming natif sans redémarrage (Android nécessite un startListening répété). Le mode sur appareil sur iOS est disponible depuis iOS 17 (Android depuis Android 10). Les deux nécessitent une autorisation utilisateur (NSMicrophoneUsageDescription + NSSpeechRecognitionUsageDescription pour iOS, RECORD_AUDIO pour Android). SFSpeechRecognizer est plus précis en anglais (sur appareil), Android SpeechRecognizer est plus précis en russe (cloud). Pour iOS antérieur à 17, le mode sur appareil n'est pas disponible — Internet requis. Pour iOS 17+, le mode sur appareil donne un WER de 12–14 % pour le russe.

Vosk : reconnaissance hors ligne en 20+ langues

Vosk est une bibliothèque ASR open source d'Alpha Cephei pour la reconnaissance vocale hors ligne. Basée sur Kaldi ASR toolkit + modèles CTC. Prend en charge 20+ langues : russe, anglais, allemand, français, espagnol, chinois, arabe. Modèles de 50 Mo (petit — 50 Mo, ru) à 1,2 Go (grand — 1,2 Go, en). Vosk fonctionne sur Android (JNI), iOS (wrapper C++), Linux, Windows, Raspberry Pi. RTF : 0,3–0,8 sur les appareils phares. Vosk est le meilleur choix pour un ASR hors ligne complet.

API Vosk : VoskWaveformModelLoader (chargement du modèle) → VoskWaveformRecognizer (création du reconnaisseur) → recognizer.createGrammar(list) ou recognizer.getResult() / recognizer.getPartialResult(). Prise en charge des grammaires (ensemble fini de commandes) — GrammarRecogniser — donne un RTF de 0,1–0,3 (3x plus rapide). Pour la saisie vocale, utilisez la reconnaissance libre (getResult). Pour les commandes vocales — GrammarRecogniser (99 % de précision sur les commandes). Vosk prend également en charge l'identification du locuteur (analyse vectorielle de la voix).

// Vosk offline ASR
val model = VoskModel("model/vosk-model-small-ru-0.22")
model.load()

val recognizer = VoskRecognizer(model, 16000.0f)
recognizer.setWords(true)

audioRecord.startRecording()
while (isListening) {
    val buffer = ByteArray(3200) // 100ms audio
    audioRecord.read(buffer, 0, buffer.size)
    if (recognizer.acceptWaveform(buffer)) {
        val result = recognizer.result // JSON
        text += JSONObject(result).getString("text")
    }
}

Vosk vs ASR cloud : Vosk est entièrement hors ligne — confidentialité, latence nulle, gratuit. Le cloud (Google, Yandex) est plus précis dans les scénarios complexes (bruit, accent) — WER 3–5 % inférieur. Vosk est idéal pour : la saisie vocale sans Internet, les applications d'accessibilité, la transcription d'appels (confidentialité). L'ASR cloud est pour les assistants vocaux où la précision prime sur la confidentialité. Recommandation : Vosk pour hors ligne, SFSpeechRecognizer (iOS) / SpeechRecognizer (Android) pour en ligne — combinez les approches pour différents scénarios.

Whisper OpenAI sur les appareils mobiles

Whisper est un modèle d'OpenAI pour la reconnaissance vocale, entraîné sur 680 000 heures d'audio (multilingue, 99 langues). Disponible en tailles : tiny (39M, WER 10 % EN, 15 % RU), small (244M, WER 6 % EN, 10 % RU), medium (769M, WER 4,5 % EN, 8 % RU). Whisper fonctionne sur les appareils mobiles via Core ML (iOS, ANE) et TFLite (Android, GPU). Whisper tiny : RTF 4–10 sur CPU, RTF 0,5–2 sur GPU (Android). Whisper small : RTF 2–6 sur GPU. Whisper medium — RTF 8–15, uniquement pour non temps réel.

Whisper sur iOS (Core ML) : Apple MLX Whisper — une implémentation de Whisper pour Core ML et MLX (Apple Neural Engine). Whisper tiny Core ML sur iPhone 15 Pro : RTF 0,3–0,8 (plus rapide que le temps réel !). Whisper small Core ML : RTF 1–3. Whisper Core ML utilise l'ANE sur A17 Pro (Neural Engine 35 TOPS). Hugging Face Transformers → Exportation vers Core ML via coremltools-whisper. Pour le streaming, utilisez WhisperStitcher (découpage + assemblage). Whisper sur iOS est l'ASR sur appareil le plus précis (WER 6 % EN, 10 % RU).

// Whisper Core ML on iOS
import MLXWhisper

let model = try WhisperModel(from: "whisper-tiny")
let audio = try AudioUtils.loadAudio(url: audioURL)
let segments = try model.transcribe(audio: Audio, options: TranscribeOptions(
    language: "ru",
    wordTimestamps: true,
    temperature: 0.0
))

for segment in segments {
    print(segment.text) // final text with timestamps
}

Whisper vs Vosk : Whisper est plus précis (6 % contre 9 % WER EN), prend en charge 99 langues, inclut la détection de langue, la ponctuation et la reconnaissance des émotions. Whisper est plus lourd (39M–769M contre 50M Vosk), plus lent en temps réel (RTF 0,5–6 contre 0,3–0,8). Whisper tiny est comparable à Vosk en vitesse (RTF 0,5–2 GPU). Vosk est plus léger, plus rapide, meilleur pour le streaming en temps réel. Whisper est pour la transcription unique où la précision prime sur la vitesse. Vosk est pour la saisie vocale en temps réel. Utilisez Whisper pour le texte final, Vosk pour une utilisation interactive.

Utilisations de la reconnaissance vocale dans les applications mobiles

Saisie de texte vocal — l'utilisation la plus répandue de l'ASR : dicter des messages, des requêtes de recherche, des notes. Exigence : RTF < 1 (temps réel), résultats partiels (voir le texte en parlant). Android Gboard et le clavier iOS ont un ASR intégré (sur appareil, WER 12–18 %). Pour une implémentation personnalisée, utilisez Android SpeechRecognizer / SFSpeechRecognizer. Pour une précision maximale — ASR cloud + repli Vosk. Pour une saisie vocale avec 98 % de précision en russe — combinez Vosk (hors ligne) + Yandex SpeechKit (en ligne).

Transcription d'appels et de réunions — ASR pour la génération automatique de transcriptions. Exigences : aucune exigence de latence, WER < 10 %, diarisation des locuteurs (qui parle). Whisper Small (hors ligne) + pyannote-audio (diarisation) est la pile standard pour la transcription. Sur iOS — Whisper Core ML (RTF 1–3, WER 6–10 %). Sur Android — Whisper TFLite (RTF 2–6, WER 8–12 %) ou Google Cloud ASR + diarisation. Pour la confidentialité (les appels ne vont pas sur le serveur) — Whisper sur l'appareil. Précision de la diarisation : 80–90 % DER.

Assistants vocaux — Siri (SFSpeechRecognizer), Google Assistant (Android SpeechRecognizer), Alexa (ASR sur appareil). Assistant personnalisé : ASR → NLU (Natural Language Understanding) → Action → TTS. L'ASR est la première étape — elle détermine la précision de toute la chaîne. Pour la NLU, utilisez RASA, Snips NLU (sur appareil) ou NLU cloud (Dialogflow, Amazon Lex). Pour la TTS : Android TTS / iOS AVSpeechSynthesizer. Un assistant vocal sur appareil (Vosk + RASA + TTS) est entièrement privé, fonctionne sans Internet, latence < 2 secondes par requête.

// Voice assistant with Android SpeechRecognizer + TTS
recognizer.setRecognitionListener(object : RecognitionListener {
    override fun onResults(results: Bundle) {
        val query = results.getStringArrayList(
            SpeechRecognizer.RESULTS_RECOGNITION
        )?.firstOrNull() ?: return

        val intentResult = nluService.classify(query)
        textToSpeech.speak(intentResult.response)
        executeAction(intentResult.action)
    }
})

Accessibilité pour les personnes ayant des limitations motrices — La reconnaissance vocale permet de contrôler l'application par la voix : ouvrir les contacts, envoyer un message, composer un numéro. Android Voice Access et iOS Switch Control + VoiceOver sont des solutions intégrées. Pour une implémentation personnalisée : GrammarRecogniser (Vosk) avec un ensemble fixe de commandes (50–100 phrases) — RTF 0,1–0,3, 99 % de précision. Vosk Grammar permet de définir la grammaire au format BNF. La vitesse est cruciale pour l'accessibilité — Vosk Grammar est 5x plus rapide que la reconnaissance libre et consomme moins de batterie.