SFSpeechRecognizer — définition, API et intégration iOS

Qu’est-ce que SFSpeechRecognizer : aperçu des fonctionnalités

SFSpeechRecognizer est une classe de Speech.framework représentant un reconnaisseur vocal pour une langue spécifique. Il est initialisé avec un Locale (ru_RU, en_US, zh_CN). SFSpeechRecognizer gère une demande de reconnaissance (SFSpeechRecognitionRequest) et retourne un résultat (SFSpeechRecognitionResult) avec des transcriptions et des métadonnées. Il prend en charge deux types de demandes : SFSpeechAudioBufferRecognitionRequest (flux audio en direct) et SFSpeechURLRecognitionRequest (fichier audio). Les deux retournent SFTranscription — un tableau d’hypothèses alternatives de reconnaissance.

SFSpeechRecognitionResult contient : bestTranscription (meilleure hypothèse, SFTranscription), transcriptions (toutes les alternatives), isFinal (final/intermédiaire). SFTranscription contient : formattedString (texte), segments (tableau de SFTranscriptionSegment avec horodatages, confiance, substringRange, alternativeSubstrings). La confiance pour chaque segment (0..1) — permet de filtrer les fragments non fiables. Les segments sont une fonctionnalité clé de Speech.framework : ils fournissent un marquage mot par mot avec des scores de confiance.

Architecture de SFSpeechRecognizer : AVFoundation (capture audio) → Audio Buffer → SFSpeechAudioBufferRecognitionRequest → SFSpeechRecognizer (moteur ASR) → SFSpeechRecognitionResult → SFSpeechRecognitionTask (contrôle : cancel, finish, pause). Le moteur ASR d’Apple utilise une architecture hybride : Conformer (encodeur) + RNNT (décodeur) pour on-device, Transducer pour le cloud. Les modèles sont optimisés pour Apple Neural Engine (ANE). Sur A17 Pro, l’ASR on-device fonctionne avec un RTF de 0,3–0,6 (plus rapide que le temps réel).

Exigences audio : SFSpeechRecognizer accepte LPCM (16 kHz, 16 bit, mono) ou Opus (iOS 17+). AVFoundation peut capturer des tampons de tout format, la demande convertit automatiquement. Longueur minimale : 0,5 seconde (détection de silence). Maximale : 1 minute (cloud) / 2 minutes (on-device) par demande. Pour une transcription longue, divisez l’audio en morceaux de 30 à 60 secondes avec un chevauchement de 2 à 5 secondes.

Configuration et autorisations de SFSpeechRecognizer

Autorisations utilisateur : SFSpeechRecognizer nécessite deux autorisations explicites. NSMicrophoneUsageDescription (Privacy — Microphone Usage Description) — pour l’accès au microphone. NSSpeechRecognitionUsageDescription (Privacy — Speech Recognition Usage Description) — pour l’accès à la reconnaissance vocale. Les deux sont des chaînes expliquant la raison à l’utilisateur. SFSpeechRecognizer.requestAuthorization — affiche la boîte de dialogue d’autorisation. Statuts : notDetermined, denied, restricted, authorized. Sans le statut authorized, l’appel du recognizer retourne l’erreur 216 (Speech framework error).

Vérification de disponibilité : SFSpeechRecognizer.isAvailable — vérifie si l’ASR est disponible pour la langue actuelle. Sur iOS 16-, isAvailable = false sans Internet. Sur iOS 17+, isAvailable = true pour les langues on-device même hors ligne. SFSpeechRecognizer.supportedLocales — méthode statique pour obtenir la liste des langues prises en charge par l’appareil. Il est recommandé de vérifier isAvailable avant chaque lancement (l’utilisateur peut désactiver Siri/Dictée dans les réglages). La disponibilité dépend de la région : chinois — uniquement en Chine, arabe — aux Émirats arabes unis.

// Configuration de SFSpeechRecognizer
import Speech

SFSpeechRecognizer.requestAuthorization { status in
    guard status == .authorized else { return }
}

let recognizer = SFSpeechRecognizer(locale: Locale(identifier: "ru_RU"))!
guard recognizer.isAvailable else {
    print("ASR non disponible. Activez Siri et la Dictée dans les Réglages")
    return
}

let request = SFSpeechAudioBufferRecognitionRequest()
request.requiresOnDeviceRecognition = true

Gestion des erreurs : SFSpeechRecognizer est appelé avec un gestionnaire d’achèvement qui peut retourner une erreur. Erreurs principales : 203 — pas d’Internet (cloud, iOS 16-) ; 216 — non autorisé (pas de permission) ; 301 — erreur audio (problème de microphone/format) ; 401 — service indisponible (service surchargé) ; 601 — langue indisponible (langue non prise en charge sur l’appareil). Pour on-device iOS 17+, erreurs principales : 301 (audio), 601 (langue). Gérez toujours le gestionnaire d’achèvement — des erreurs peuvent survenir à tout moment pendant l’enregistrement.

Reconnaissance vocale en direct depuis le microphone

Pipeline ASR en direct : AVAudioEngine (capture microphone) → installTap (tampon audio) → request.append(buffer) → SFSpeechRecognizer → recognitionTask → delegate/resultHandler. AVAudioEngine offre une faible latence (5–10 ms du micro au tampon). SFSpeechRecognitionDelegate : didHypothesizeTranscription (toutes les 200–500 ms — texte partiel), didFinishRecognition (résultat final). Task.isFinishing — peut annuler lorsque la reconnaissance est terminée. Pour la reconnaissance continue (dicte illimitée), créez une nouvelle tâche après isFinal.

SFSpeechRecognitionTaskDelegate : méthodes optionnelles. speechRecognitionDidDetectSpeech (début de la parole) — pour indication dans l’interface utilisateur. didHypothesizeTranscription (texte intermédiaire) — pour affichage pendant la parole. didFinishRecognition (résultat final) — pour finaliser le texte. didFinishSuccessfully (succès/erreur) — pour l’achèvement. didProcessAudio (tampon audio traité) — pour le compteur RMS. Il est recommandé d’implémenter didHypothesizeTranscription — l’utilisateur voit le texte immédiatement sans délai. La transcription finale est pour la sauvegarde.

// Reconnaissance vocale en direct
let audioEngine = AVAudioEngine()
let request = SFSpeechAudioBufferRecognitionRequest()
request.shouldReportPartialResults = true

recognitionTask = recognizer.recognitionTask(with: request) { result, error in
    if let result = result {
        textView.text = result.bestTranscription.formattedString
    }
    if error != nil || result?.isFinal == true {
        audioEngine.stop()
        request.endAudio()
    }
}

let inputNode = audioEngine.inputNode
let recordingFormat = inputNode.outputFormat(forBus: 0)
inputNode.installTap(onBus: 0, bufferSize: 1024,
                     format: recordingFormat) { buffer, _ in
    request.append(buffer)
}
audioEngine.prepare()
try audioEngine.start()

Reconnaissance continue : pour le mode « écoute toujours » (entrée vocale, assistant), vous devez redémarrer la tâche après isFinal. Créez une boucle : finishTask → request = SFSpeechAudioBufferRecognitionRequest() → recognitionTask = recognizer.recognitionTask(with: request). Pour éviter les pauses, chevauchez la fin d’une tâche avec le début de la suivante (commencez une nouvelle demande 1 à 2 secondes avant la fin de la précédente). AVFoundation AVAudioSession — configurez .playAndRecord pour la lecture et l’enregistrement simultanés. Sur iOS 17+, l’ASR continu avec on-device consomme 2–5% de batterie par heure (A15+).

Reconnaissance de fichiers audio et d’enregistrements

SFSpeechURLRecognitionRequest — une demande de reconnaissance d’un fichier audio par URL. Prend en charge les formats : .wav (16 kHz, 16 bit, mono), .m4a (AAC), .mp4, .mov. Longueur maximale : ~1 minute pour le cloud, ~2 minutes pour on-device. Pour les fichiers plus longs, divisez en morceaux (AVAssetExportSession + trim). SFSpeechURLRecognitionRequest ne prend pas en charge le streaming (pas de résultats partiels) — seulement le résultat final. Pour des résultats partiels avec un fichier, convertissez en une demande de tampon audio.

Obtenir la transcription d’un fichier audio : SFSpeechRecognizer.recognitionTask(with: request) resultHandler. Extrayez bestTranscription.formattedString. Pour les horodatages au niveau du mot — segments de bestTranscription.segments (segment.duration, segment.timestamp, segment.substring). Confiance par segment — confiance ASR pour chaque mot (utilisez pour filtrer). Hypothèses alternatives — alternatives de transcriptionFormatter pour les mots à faible confiance. Pour les fichiers avec plusieurs locuteurs, SFSpeechRecognitionRequest peut retourner plusieurs demandes (une par locuteur, iOS 17+).

// Transcription de fichier audio
let audioURL = Bundle.main.url(forResource: "recording", withExtension: "m4a")!
let request = SFSpeechURLRecognitionRequest(url: audioURL)
request.requiresOnDeviceRecognition = true

recognizer.recognitionTask(with: request) { result, error in
    guard let result = result, error == nil else {
        print("Erreur : \(error?.localizedDescription ?? "unknown")")
        return
    }

    let transcription = result.bestTranscription
    let text = transcription.formattedString
    let words = transcription.segments.map { segment in
        Word(text: segment.substring,
              start: segment.timestamp,
              duration: segment.duration,
              confidence: segment.confidence)
    }
}

Division des fichiers audio longs : pour les fichiers > 1 minute, divisez en morceaux de 30 à 60 secondes avec un chevauchement de 2 à 3 secondes (assemblage). AVAssetExportSession + CMTimeRange — exportez les morceaux. Alternative : UISelectionView (l’utilisateur sélectionne un segment). Assemblage des transcriptions : concaténer les textes, assembler par chevauchement (les 2–3 derniers mots du morceau précédent sont comparés aux 2–3 premiers du suivant — supprimer les doublons). Vosk et Whisper prennent en charge l’audio long nativement, SFSpeechRecognizer non. Pour une transcription longue, je recommande Whisper (Core ML) — pas de limite de longueur.

On-device vs Cloud : comparaison des modes

Mode On-device (iOS 17+) : request.requiresOnDeviceRecognition = true. L’ASR s’exécute localement sur Apple Neural Engine (ANE). Avantages : pas d’Internet nécessaire, confidentialité (l’audio ne quitte jamais l’appareil), coût zéro (gratuit), faible latence (RTF 0,3–0,6). Inconvénients : précision inférieure (WER 12–14% contre 7–12%), limite de 2 minutes par demande, ensemble de langues limité (toutes les 60 langues ne sont pas disponibles on-device). Le modèle on-device occupe ~50–100 Mo sur l’appareil et est téléchargé lors de la première demande.

Cloud (iOS 16-) : request.requiresOnDeviceRecognition = false (ou paramètre absent). ASR sur les serveurs d’Apple — plus précis (WER 7% EN, 12% RU), plus de langues, jusqu’à 1 minute par demande. Nécessite Internet (WiFi ou cellulaire). Apple ne facture pas les développeurs pour l’ASR cloud (gratuit). Limites : 1 demande par minute par application (non spécifié), mais Apple peut limiter à l’échelle de la production. L’ASR cloud fournit une qualité au meilleur effort sans SLA. Pour les applications d’entreprise, utilisez Google Cloud ASR ou Whisper (Core ML).

Reconnaissance combinée (iOS 17+) : request.requiresOnDeviceRecognition = false avec Internet (cloud), = true hors ligne (fallback). Apple sélectionne automatiquement le mode. Pour les applications critiques en précision : vérifiez NetworkMonitor (NWPathMonitor) — utilisez le cloud avec Internet, on-device sans. Pour les applications critiques en confidentialité : toujours on-device. Pour la transcription : cloud (plus précis). Pour l’entrée vocale : on-device (plus rapide). Le combiné est recommandé : 80% cloud, 20% fallback on-device.

Utilisation de SFSpeechRecognizer dans les applications iOS

Entrée vocale dans un clavier personnalisé — SFSpeechRecognizer intégré dans les extensions de clavier (iOS 10+). L’utilisateur appuie sur le bouton microphone, l’ASR transcrit la parole en texte et l’insère dans le champ de texte. Exigences : résultats partiels (voir le texte en temps réel), on-device (le clavier doit fonctionner sans Internet). SFSpeechRecognizer + AVSpeechSynthesizer — entrée vocale + sortie vocale. Pour les claviers personnalisés sur iOS 17+, utilisez on-device. Limitations des extensions de clavier : AVAudioEngine est disponible mais avec des restrictions de temps (exécution en arrière-plan limitée).

Transcription de réunions et de conférences — applications pour enregistrer et transcrire l’audio (Otter.ai, Rev, Apple Voice Memos). SFSpeechURLRecognitionRequest traite les fichiers .m4a. Pour les enregistrements longs (30–60 minutes) — Whisper Core ML (pas de limite de longueur). Les segments de SFSpeechRecognizer avec horodatages — pour synchroniser le texte avec l’audio (surlignage du texte pendant la lecture). Confiance par segment — pour afficher les fragments non fiables (surlignage jaune). Pour la diarisation des locuteurs (qui a parlé) — Apple ne fournit pas d’API, utilisez pyannote-audio + Whisper sur le serveur.

Commandes vocales dans les applications iOS — SFSpeechRecognizer + framework VGS (Voice Grammar Services) pour exécuter des commandes : « ouvrir les réglages », « envoyer un message », « allumer la lumière ». Reconnaissance basée sur la grammaire : SFSpeechRecognitionRequest contextualStrings = tableau de commandes. Cela améliore la précision de reconnaissance des commandes à 95% (contre 85% en forme libre). SFSpeechRecognitionTask.cancel — pour interrompre après l’exécution de la commande. VGS + SFSpeechRecognizer + Shortcuts — commandes vocales personnalisées sans écrire d’interface utilisateur. Pour l’accessibilité : Voice Control (intégré) + SFSpeechRecognizer (commandes personnalisées).

// Commandes vocales avec chaînes contextuelles
let request = SFSpeechAudioBufferRecognitionRequest()
request.requiresOnDeviceRecognition = true
request.shouldReportPartialResults = true
request.contextualStrings = ["open contacts", "send message",
                             "show notifications", "allumer la lampe torche"]

recognitionTask = recognizer.recognitionTask(with: request) { result, _ in
    guard let text = result?.bestTranscription.formattedString.lowercased() else { return }
    voiceCommands.first { text.contains($0) }.map { command in
        DispatchQueue.main.async { self.executeCommand(command) }
        recognitionTask?.cancel()
    }
}

Dictée dans les applications médicales et juridiques — SFSpeechRecognizer pour créer des documents structurés par la voix. Adaptation de domaine : contextualStrings avec des termes médicaux/juridiques (500+ phrases). SFSpeechRecognitionRequest.customLmProbability — impact de contextualStrings (0,1–1,0). Pour la dictée médicale, utilisez on-device (confidentialité des données du patient). Whisper ajusté sur des données médicales — alternative avec un WER de 5% au lieu de 12% pour SFSpeechRecognizer de base. Conformité HIPAA : mode on-device (les données ne quittent jamais l’appareil). Pour la transcription de rendez-vous — SFSpeechURLRecognitionRequest + segments avec horodatages de locuteur.