Reconhecimento de Fala — o que é, tecnologias e princípio de funcionamento

O que é Reconhecimento de Fala: princípios do ASR

Automatic Speech Recognition (ASR) é um pipeline: áudio → pré-processamento (16 kHz mono, redução de ruído, VAD — detecção de atividade de voz) → extração de características (MFCC, LogMel FilterBank) → modelo acústico (rede neural: CTC / RNNT / Transducer) → modelo de linguagem (LM) → decodificação (texto). Modelos modernos de ponta a ponta (Whisper, Google USM, Conformer CTC) combinam o modelo acústico e de linguagem em um único Transformer, simplificando o pipeline e melhorando a precisão.

Arquiteturas ASR para dispositivos móveis: CTC (Connectionist Temporal Classification) — rápida, não requer alinhamento áudio-texto, usada no Vosk e Android nativo. RNNT (Recurrent Neural Network Transducer) — ASR em streaming, baixa latência (Google USM). Conformer — híbrido de CNN + Transformer, melhor precisão mas mais pesado: Whisper Medium (769M params) — latência 30–60x. Para no dispositivo, CTC é preferível: modelos CTC do Vosk ocupam 50–100 MB, latência 0.3–0.8x tempo real.

Métricas ASR: WER (Word Error Rate) — percentual de palavras substituídas, excluídas e inseridas em relação à referência. Google Cloud ASR — 7% WER (EN), 12% (RU). Vosk — 13% (RU), 9% (EN). Whisper Small — 6% (EN), 10% (RU). CER (Character Error Rate) — similar, ao nível de caracteres. Real-Time Factor (RTF) — tempo de processamento / duração do áudio. RTF < 1 — mais rápido que o tempo real. RTF < 0.3 — ASR em tempo real. Entrada de voz requer RTF < 1, transcrição requer RTF < 3.

VAD (Voice Activity Detection) — detecção de atividade de voz, separando a fala do silêncio e do ruído. WebRTC VAD é o padrão para ASR móvel: quadros de 30 ms, três modos (0, 1, 2 — de conservador a agressivo). VAD reduz o RTF em 1.5–3x (ignora segmentos não falados). Silero VAD (MIT) é um VAD neural, mais preciso que o WebRTC (94% vs 85% ROC AUC), latência 5–10 ms, TFLite e Core ML. Para ASR em produção, use a cascata VAD → ASR: isso reduz falsos positivos e acelera o processamento.

Android SpeechRecognizer API

Android SpeechRecognizer é uma classe embutida do SDK Android para reconhecimento de fala. Funciona em dois modos: nuvem (servidor Google) — alta precisão, requer internet; no dispositivo (desde Android 10+) — modelo ASR embutido do GBoard, 20+ idiomas, WER 15–18%. SpeechRecognizer retorna resultados parciais durante a fala e o texto final. Suporta 60+ idiomas via RecognizerIntent.EXTRA_LANGUAGE. Recomendado para entrada de voz — integração rápida, gratuito.

API SpeechRecognizer: criado via SpeechRecognizer.createSpeechRecognizer(context). Intent com RecognizerIntent.ACTION_RECOGNIZE_SPEECH com extras: LANGUAGE_MODEL_FREE_FORM (texto livre) ou LANGUAGE_MODEL_WEB_SEARCH (consultas de pesquisa). Resultados via RecognitionListener: onReadyForSpeech → onBeginningOfSpeech → onRmsChanged → onPartialResults → onResults. Para reconhecimento contínuo (modo sempre ouvindo) — reinicie o recognizer após onResults. Para economizar bateria, use 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)

No dispositivo vs Nuvem no Android: no dispositivo funciona sem internet (Android 10+, Pixel 4+, Samsung S20+). A nuvem é mais precisa (Google Neural Network ASM Model) mas tem latência maior (300–800 ms incluindo rede). Para entrada de voz, use uma abordagem híbrida: nuvem com fallback para no dispositivo quando não houver rede. Android SpeechRecognizer seleciona automaticamente o modo com base em RecognizerIntent.EXTRA_PREFER_OFFLINE. Para máxima privacidade — defina onDeviceOnly = true (mas a precisão é 15–18% WER para russo).

iOS SFSpeechRecognizer e Speech Framework

SFSpeechRecognizer é o framework da Apple para reconhecimento de fala no iOS, macOS e watchOS. Disponível desde iOS 10. Modo no dispositivo — desde iOS 17 (modelo local, sem internet). Suporta 60+ idiomas. Precisão: WER 7–12% (no dispositivo — 12–15%). SFSpeechRecognizer está disponível via Speech.framework — não requer SDKs adicionais. Solicitação de permissão via SFSpeechRecognizer.requestAuthorization.

API SFSpeechRecognizer: SFSpeechRecognizer(locale: Locale(identifier: "ru_RU")) → SFSpeechAudioBufferRecognitionRequest (áudio ao vivo) ou SFSpeechURLRecognitionRequest (arquivo de áudio). Streaming via recognitionTask(with:delegate:) com SFSpeechRecognitionTaskDelegate (didHypothesizeTranscription — parcial, didFinishRecognition — final). Modo no dispositivo: request.requiresOnDeviceRecognition = true. Para iOS 15+: request.shouldReportPartialResults = true (resultado em streaming com baixa latência).

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 tem streaming nativo sem reinicialização (Android requer startListening repetido). No dispositivo no iOS está disponível desde iOS 17 (Android desde Android 10). Ambos exigem permissão do usuário (NSMicrophoneUsageDescription + NSSpeechRecognitionUsageDescription para iOS, RECORD_AUDIO para Android). SFSpeechRecognizer é mais preciso em inglês (no dispositivo), Android SpeechRecognizer é mais preciso em russo (nuvem). Para iOS anterior a 17, no dispositivo não está disponível — requer internet. Para iOS 17+, no dispositivo dá WER 12–14% para russo.

Vosk: reconhecimento offline em 20+ idiomas

Vosk é uma biblioteca ASR de código aberto da Alpha Cephei para reconhecimento de fala offline. Baseada no Kaldi ASR toolkit + modelos CTC. Suporta 20+ idiomas: russo, inglês, alemão, francês, espanhol, chinês, árabe. Modelos de 50 MB (pequeno — 50 MB, ru) a 1.2 GB (grande — 1.2 GB, en). Vosk funciona no Android (JNI), iOS (wrapper C++), Linux, Windows, Raspberry Pi. RTF: 0.3–0.8 em dispositivos emblemáticos. Vosk é a melhor escolha para ASR offline completo.

API Vosk: VoskWaveformModelLoader (carregamento do modelo) → VoskWaveformRecognizer (criação do reconhecedor) → recognizer.createGrammar(list) ou recognizer.getResult() / recognizer.getPartialResult(). Suporte a gramáticas (conjunto finito de comandos) — GrammarRecogniser — fornece RTF 0.1–0.3 (3x mais rápido). Para entrada de voz, use reconhecimento livre (getResult). Para comandos de voz — GrammarRecogniser (99% de precisão em comandos). Vosk também suporta identificação de locutor (análise vetorial de voz).

// 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 em nuvem: Vosk é completamente offline — privacidade, latência zero, gratuito. A nuvem (Google, Yandex) é mais precisa em cenários complexos (ruído, sotaque) — WER 3–5% menor. Vosk é ideal para: entrada de voz sem internet, aplicativos de acessibilidade, transcrição de chamadas (privacidade). ASR em nuvem é para assistentes de voz onde a precisão importa mais que a privacidade. Recomendação: Vosk para offline, SFSpeechRecognizer (iOS) / SpeechRecognizer (Android) para online — combine abordagens para diferentes cenários.

Whisper OpenAI em dispositivos móveis

Whisper é um modelo da OpenAI para reconhecimento de fala, treinado em 680.000 horas de áudio (multilíngue, 99 idiomas). Disponível em tamanhos: tiny (39M, WER 10% EN, 15% RU), small (244M, WER 6% EN, 10% RU), medium (769M, WER 4.5% EN, 8% RU). Whisper funciona em dispositivos móveis via Core ML (iOS, ANE) e TFLite (Android, GPU). Whisper tiny: RTF 4–10 na CPU, RTF 0.5–2 na GPU (Android). Whisper small: RTF 2–6 na GPU. Whisper medium — RTF 8–15, apenas para não tempo real.

Whisper no iOS (Core ML): Apple MLX Whisper — uma implementação do Whisper para Core ML e MLX (Apple Neural Engine). Whisper tiny Core ML no iPhone 15 Pro: RTF 0.3–0.8 (mais rápido que o tempo real!). Whisper small Core ML: RTF 1–3. Whisper Core ML usa ANE no A17 Pro (Neural Engine 35 TOPS). Hugging Face Transformers → Exportar para Core ML via coremltools-whisper. Para streaming, use WhisperStitcher (fragmentação + junção). Whisper no iOS é o ASR no dispositivo mais preciso (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 é mais preciso (6% vs 9% WER EN), suporta 99 idiomas, inclui detecção de idioma, pontuação e reconhecimento de emoções. Whisper é mais pesado (39M–769M vs 50M Vosk), mais lento em tempo real (RTF 0.5–6 vs 0.3–0.8). Whisper tiny é comparável ao Vosk em velocidade (RTF 0.5–2 GPU). Vosk é mais leve, mais rápido, melhor para streaming em tempo real. Whisper é para transcrição única onde a precisão é priorizada sobre a velocidade. Vosk é para entrada de voz em tempo real. Use Whisper para texto final, Vosk para uso interativo.

Aplicações do Reconhecimento de Fala em dispositivos móveis

Entrada de texto por voz — o uso mais difundido de ASR: ditar mensagens, consultas de pesquisa, notas. Requisito: RTF < 1 (tempo real), resultados parciais (ver texto enquanto fala). Android Gboard e o teclado iOS têm ASR integrado (no dispositivo, WER 12–18%). Para implementação personalizada, use Android SpeechRecognizer / SFSpeechRecognizer. Para máxima precisão — ASR em nuvem + Vosk como fallback. Para entrada de voz com 98% de precisão em russo — combine Vosk (offline) + Yandex SpeechKit (online).

Transcrição de chamadas e reuniões — ASR para geração automática de transcrições. Requisitos: sem requisito de latência, WER < 10%, diarização de locutores (quem está falando). Whisper Small (offline) + pyannote-audio (diarização) é a pilha padrão para transcrição. No iOS — Whisper Core ML (RTF 1–3, WER 6–10%). No Android — Whisper TFLite (RTF 2–6, WER 8–12%) ou Google Cloud ASR + diarização. Para privacidade (chamadas não vão para o servidor) — Whisper no dispositivo. Precisão da diarização: 80–90% DER.

Assistentes de voz — Siri (SFSpeechRecognizer), Google Assistant (Android SpeechRecognizer), Alexa (ASR no dispositivo). Assistente personalizado: ASR → NLU (Natural Language Understanding) → Ação → TTS. ASR é o primeiro estágio — determina a precisão de toda a cadeia. Para NLU, use RASA, Snips NLU (no dispositivo) ou NLU em nuvem (Dialogflow, Amazon Lex). Para TTS: Android TTS / iOS AVSpeechSynthesizer. Um assistente de voz no dispositivo (Vosk + RASA + TTS) é totalmente privado, funciona sem internet, latência < 2 segundos por requisição.

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

Acessibilidade para pessoas com limitações motoras — Reconhecimento de Fala permite controlar o aplicativo por voz: abrir contatos, enviar mensagem, discar número. Android Voice Access e iOS Switch Control + VoiceOver são soluções integradas. Para implementação personalizada: GrammarRecogniser (Vosk) com um conjunto fixo de comandos (50–100 frases) — RTF 0.1–0.3, 99% de precisão. Vosk Grammar permite definir a gramática no formato BNF. A velocidade é crítica para acessibilidade — Vosk Grammar é 5x mais rápido que o reconhecimento livre e consome menos bateria.