SFSpeechRecognizer — vad är det, API och integration i iOS

Vad är SFSpeechRecognizer: översikt över funktioner

SFSpeechRecognizer — en klass från Speech.framework som representerar en taligenkännare för ett specifikt språk. Den initieras med Locale (ru_RU, en_US, zh_CN). SFSpeechRecognizer hanterar en igenkänningsbegäran (SFSpeechRecognitionRequest) och returnerar ett resultat (SFSpeechRecognitionResult) med transkriptioner och metadata. Stöder två typer av begäranden: SFSpeechAudioBufferRecognitionRequest (live-ljudström) och SFSpeechURLRecognitionRequest (ljudfil). Båda returnerar SFTranscription — en array av alternativa igenkänningsvarianter.

SFSpeechRecognitionResult innehåller: bestTranscription (bästa variant, SFTranscription), transcriptions (alla alternativ), isFinal (slutgiltig/tillfällig). SFTranscription innehåller: formattedString (text), segments (array av SFTranscriptionSegment med tidsstämplar, confidence, substringRange, alternativeSubstrings). Confidence för varje segment (0..1) — möjliggör filtrering av opålitliga fragment. segments — en nyckelfunktion i Speech.framework: ger annotering av varje ord med säkerhet.

Arkitektur för SFSpeechRecognizer: AVFoundation (ljudinspelning) → Audio Buffer → SFSpeechAudioBufferRecognitionRequest → SFSpeechRecognizer (ASR-motor) → SFSpeechRecognitionResult → SFSpeechRecognitionTask (kontroll: cancel, finish, pause). Apples ASR-motor använder en hybridarkitektur: Conformer (kodare) + RNNT (avkodare) för on-device, Transducer för cloud. Modellerna är optimerade för Apple Neural Engine (ANE). På A17 Pro fungerar on-device ASR med RTF 0.3–0.6 (snabbare än realtid).

Ljudkrav: SFSpeechRecognizer accepterar LPCM (16 kHz, 16 bit, mono) eller Opus (iOS 17+). AVFoundation kan fånga buffert i valfritt format, begäran konverterar automatiskt. Minsta längd: 0,5 sekunder (tystnadsdetektion). Maximal: 1 minut (cloud) / 2 minuter (on-device) per begäran. För lång transkription, dela upp ljudet i bitar på 30–60 sekunder med en överlappning på 2–5 sekunder.

Installation och behörigheter för SFSpeechRecognizer

Användarbehörigheter: SFSpeechRecognizer kräver två explicita behörigheter. NSMicrophoneUsageDescription (Privacy — Microphone Usage Description) — för åtkomst till mikrofonen. NSSpeechRecognitionUsageDescription (Privacy — Speech Recognition Usage Description) — för åtkomst till taligenkänning. Båda är strängar som förklarar för användaren varför. SFSpeechRecognizer.requestAuthorization — anropar behörighetsdialogrutan. Statusar: notDetermined, denied, restricted, authorized. Utan authorized returnerar recognizer-anropet fel 216 (Speech framework error).

Kontroll av tillgänglighet: SFSpeechRecognizer.isAvailable — kontrollerar om ASR är tillgängligt för det aktuella språket. På iOS 16- är isAvailable = false utan internet. På iOS 17+ är isAvailable = true för on-device-språk även offline. SFSpeechRecognizer.supportedLocales — statisk metod för att få listan över enhetens språk som stöds. Det rekommenderas att kontrollera isAvailable före varje start (användaren kan stänga av Siri/Diktering i inställningarna). Tillgängligheten beror på region: kinesiska — endast i Kina, arabiska — i Förenade Arabemiraten.

// SFSpeechRecognizer-inställning
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 inte tillgängligt. Aktivera Siri och Diktering i Inställningar")
    return
}

let request = SFSpeechAudioBufferRecognitionRequest()
request.requiresOnDeviceRecognition = true

Felhantering: SFSpeechRecognizer anropas med en completion handler som kan returnera ett Error. Huvudfel: 203 — no internet (cloud, iOS 16-); 216 — not authorized (ingen behörighet); 301 — audio error (problem med mikrofon/format); 401 — service unavailable (tjänsten överbelastad); 601 — language unavailable (språket stöds inte på enheten). För on-device iOS 17+ huvudfel: 301 (audio), 601 (language). Hantera alltid completion handler — fel kan uppstå när som helst under inspelningen.

Strömmande taligenkänning från mikrofon

Live ASR-pipeline: AVAudioEngine (inspelning från mikrofon) → installTap (ljudbuffert) → request.append(buffer) → SFSpeechRecognizer → recognitionTask → delegate/resultHandler. AVAudioEngine säkerställer låg latens (5–10 ms från mikrofon till buffert). SFSpeechRecognitionDelegate: didHypothesizeTranscription (var 200–500 ms — partiell text), didFinishRecognition (slutgiltigt resultat). Task.isFinishing — kan avbrytas när igenkänningen är klar. För kontinuerlig igenkänning (oändlig diktering) — skapa en ny task efter isFinal.

SFSpeechRecognitionTaskDelegate: valfria metoder. speechRecognitionDidDetectSpeech (början av tal) — för UI-indikering. didHypothesizeTranscription (tillfällig text) — för visning under tal. didFinishRecognition (slutgiltigt resultat) — för fastställande av text. didFinishSuccessfully (framgång/fel) — för slutförande. didProcessAudio (ljudbuffert bearbetad) — för RMS-mätare. Det rekommenderas att implementera didHypothesizeTranscription — användaren ser texten omedelbart, utan fördröjning. Slutgiltig transkription — för sparande.

// Live taligenkänning
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()

Kontinuerlig igenkänning: för läget “lyssna alltid” (röstinmatning, assistent) krävs omstart av uppgiften efter isFinal. Skapa en loop: finishTask → request = SFSpeechAudioBufferRecognitionRequest() → recognitionTask = recognizer.recognitionTask(with: request). För att undvika pauser, överlappa slutet av en uppgift med början av nästa (starta en ny begäran 1–2 sekunder innan den föregående slutförs). AVFoundation AVAudioSession — konfiguration .playAndRecord för samtidig uppspelning och inspelning. På iOS 17+ förbrukar kontinuerlig ASR med on-device 2–5% batteri per timme (A15+).

Igenkänning av ljudfiler och inspelningar

SFSpeechURLRecognitionRequest — begäran om igenkänning av en ljudfil via URL. Stöder format: .wav (16 kHz, 16 bit, mono), .m4a (AAC), .mp4, .mov. Maximal längd: ~1 minut för cloud, ~2 minuter för on-device. För längre filer — dela upp i bitar (AVAssetExportSession + trim). SFSpeechURLRecognitionRequest stöder inte strömning (inga partiella resultat) — endast slutgiltigt resultat. För partiella resultat med fil — konvertera till Audio Buffer Request.

Hämta transkription av ljudfil: SFSpeechRecognizer.recognitionTask(with: request) resultHandler. Extrahera bestTranscription.formattedString. För tidsstämplar på ordnivå — segments från bestTranscription.segments (segment.duration, segment.timestamp, segment.substring). Confidence per segment — ASR:ns säkerhet i varje ord (använd för filtrering). Alternativa varianter — transcriptionFormatter-alternativ för ord med låg confidence. För filer med flera talare — SFSpeechRecognitionRequest kan returnera flera begäranden (en per talare, iOS 17+).

// Transkribering av ljudfil
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("Fel: \(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)
    }
}

Dela upp långa ljudfiler: för filer > 1 minut, klipp i bitar på 30–60 sekunder med överlappning på 2–3 sekunder (sammanfogning). AVAssetExportSession + CMTimeRange — export av bitar. Alternativ: UISelectionView (användaren väljer segment). Sammanfogning av transkriptioner: konkatenering av texter, sammanfogning via överlappning (senaste 2–3 orden från föregående bit jämförs med första 2–3 orden från nästa — ta bort dubbletter). Vosk och Whisper stöder långt ljud inbyggt, SFSpeechRecognizer — inte. För lång transkription rekommenderar jag Whisper (Core ML) — ingen längdbegränsning.

On-device vs Cloud: jämförelse av lägen

On-device-läge (iOS 17+): request.requiresOnDeviceRecognition = true. ASR körs lokalt på Apple Neural Engine (ANE). Fördelar: utan internet, integritet (ljud lämnar inte enheten), noll kostnad (gratis), låg latens (RTF 0.3–0.6). Nackdelar: lägre noggrannhet (WER 12–14% vs 7–12%), begränsning på 2 minuter per begäran, begränsad språkuppsättning (inte alla 60 språk är tillgängliga on-device). On-device-modellen tar ~50–100 MB på enheten, laddas vid första begäran.

Cloud (iOS 16-): request.requiresOnDeviceRecognition = false (eller parametern saknas). ASR på Apples servrar — mer noggrann (WER 7% EN, 12% RU), fler språk, upp till 1 minut per begäran. Kräver internet (WiFi eller mobilt). Apple tar inte ut avgifter från utvecklaren för cloud ASR (gratis). Begränsningar: 1 begäran per minut per app (ej specificerat), men för produktionsskala kan Apple begränsa. cloud ASR — best-effort-kvalitet, utan SLA. För företagsappar, använd Google Cloud ASR eller Whisper (Core ML).

Combined Recognition (iOS 17+): request.requiresOnDeviceRecognition = false med internet (cloud), = true vid offline (fallback). Apple väljer automatiskt läge. För appar som är kritiska för noggrannhet: kontrollera NetworkMonitor (NWPathMonitor) — med internet cloud, utan on-device. För appar som är kritiska för integritet: alltid on-device. För transkription: cloud (mer noggrann). För röstinmatning: on-device (snabbare). Rekommenderad Combined: 80% cloud, 20% on-device fallback.

Användning av SFSpeechRecognizer i iOS-appar

Röstinmatning i anpassat tangentbord — SFSpeechRecognizer är inbäddat i tangentbordstillägg (iOS 10+). Användaren trycker på mikrofonknappen — ASR transkriberar tal till text och infogar den i textfältet. Krav: partiella resultat (se text i realtid), on-device (tangentbordet måste fungera utan internet). SFSpeechRecognizer + AVSpeechSynthesizer — röstinmatning + röstutmatning. För anpassat tangentbord på iOS 17+ använd on-device. Begränsningar för tangentbordstillägg: AVAudioEngine är tillgängligt, men med tidsbegränsningar (background execution limited).

Transkription av möten och föreläsningar — appar för inspelning och transkribering av ljud (Otter.ai, Rev, Apple Voice Memos). SFSpeechURLRecognitionRequest bearbetar .m4a-filen. För långa inspelningar (30–60 minuter) — Whisper Core ML (ingen längdbegränsning). SFSpeechRecognizer-segment med tidsstämplar — för synkronisering av text med ljud (markering av text under uppspelning). Confidence per segment — för visning av opålitliga fragment (gul markering). För talardiarisering (vem talade) — Apple tillhandahåller inte API, använd pyannote-audio + Whisper på servern.

Röstkommandon i iOS-appar — SFSpeechRecognizer + VGS framework (Voice Grammar Services) för att utföra kommandon: “öppna inställningar”, “skicka meddelande”, “sätt på ficklampan”. Grammatikbaserad igenkänning: SFSpeechRecognitionRequest contextualStrings = array av kommandon. Detta ökar noggrannheten för kommandotigenkänning till 95% (jämfört med 85% free-form). SFSpeechRecognitionTask.cancel — för avbrott efter att kommandot utförts. VGS + SFSpeechRecognizer + Shortcuts — anpassade röstkommandon utan att skriva gränssnitt. För tillgänglighet: Voice Control (inbyggt) + SFSpeechRecognizer (anpassade kommandon).

// Röstkommandon med kontextuella strängar
let request = SFSpeechAudioBufferRecognitionRequest()
request.requiresOnDeviceRecognition = true
request.shouldReportPartialResults = true
request.contextualStrings = ["open contacts", "send message",
                             "show notifications", "sätt på ficklampan"]

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()
    }
}

Diktering i medicinska och juridiska appar — SFSpeechRecognizer för att skapa strukturerade dokument med röst. Domain Adaptation: contextualStrings med medicinska/juridiska termer (500+ fraser). SFSpeechRecognitionRequest.customLmProbability — påverkan av contextualStrings (0.1–1.0). För medicinsk diktering använd on-device (integritet för patientdata). Whisper finjusterad på medicinsk data — alternativ med WER 5% istället för 12% för bas-SFSpeechRecognizer. HIPAA-efterlevnad: on-device-läge (data lämnar inte enheten). För transkription av konsultationer — SFSpeechURLRecognitionRequest + segments med talarens tidsstämplar.