GenAI Speech Recognition API

Jetzt starten

Fügen Sie die ML Kit Speech Recognition API als Abhängigkeit in Ihrer build.gradle-Konfiguration hinzu:

implementation("com.google.mlkit:genai-speech-recognition:1.0.0-alpha1")

Wenn Sie die Speech Recognition API in Ihre Anwendung einbinden möchten, erstellen Sie einen SpeechRecognizer-Client. Prüfen Sie den Status der erforderlichen On-Device-Modellfunktionen und laden Sie das Modell herunter, falls es noch nicht auf dem Gerät vorhanden ist. Nachdem Sie Ihre Audioeingabe in einem SpeechRecognizerRequest vorbereitet haben, führen Sie die Inferenz mit dem Client aus, um die Streamingausgabe vom Kotlin-Flow zu erhalten. Denken Sie daran, den Client zu schließen, um Ressourcen freizugeben.

// 1. Create a SpeechRecognizer with desired options.
val options: SpeechRecognizerOptions =
    speechRecognizerOptions {
        locale = Locale.US
        preferredMode = SpeechRecognizerOptions.Mode.MODE_ADVANCED
    }
val speechRecognizer: SpeechRecognizer = SpeechRecognition.getClient(options)

// 2. Check if the recognition model is available or needs downloading.
launch {
    val status: Int = speechRecognizer.checkStatus()
    if (status == FeatureStatus.DOWNLOADABLE) {
        // 3. If needed, download the model and monitor progress.
        speechRecognizer.download.collect { downloadStatus ->
            when (downloadStatus) {
                is DownloadStatus.DownloadCompleted -> {
                    // Model is ready, start recognition.
                    startMyRecognition(speechRecognizer)
                }
                is DownloadStatus.DownloadFailed -> {
                    // Handle download failure (e.g., inform the user).
                }
                is DownloadStatus.DownloadProgress -> {
                    // Handle download progress (e.g., update a progress bar).
                }
            }
        }
    } else if (status == FeatureStatus.AVAILABLE) {
        // Model is already ready, start recognition immediately.
        startMyRecognition(speechRecognizer)
    } else {
        // Handle other statuses (e.g., DOWNLOADING, UNAVAILABLE).
    }
}

// 4. Define your recognition logic using a suspend function.
suspend fun startMyRecognition(recognizer: SpeechRecognizer) {
    // Create a request (e.g., specifying audio source).
    val request: SpeechRecognizerRequest
        = speechRecognizerRequest { audioSource = AudioSource.fromMic() }
    // Start recognition and process the continuous stream of responses.
    recognizer.startRecognition(request).collect {
        // Process the SpeechRecognitionResponse data here.
    }
}

// 5. Stop recognition and clean up resources when the session is complete.
launch {
    recognizer.stopRecognition()
    recognizer.close()
}

Anforderungen an die Audioeingabe

Die GenAI Speech Recognition API unterstützt Eingaben über das Mikrofon oder eine benutzerdefinierte Quelle über einen Dateideskriptor.

Wenn Sie AudioSource.fromPfd(parcelFileDescriptor) verwenden, muss die Audioeingabe die folgenden strengen Anforderungen erfüllen:

• Format: Rohdaten, 16-Bit-PCM ohne Header.
• Kanäle: Mono (einzelner Kanal).
• Abtastrate: 16 kHz.

Für die meisten Anwendungsfälle wird AudioSource.fromMic() empfohlen, da diese Einschränkungen automatisch berücksichtigt werden.

Unterstützte Audioeingabeformate

Die Speech Recognition API unterstützt die folgenden Audioeingabeformate:

• MP3-, WAV-, FLAC-, M4A- und OGG-Dateien werden automatisch auf dem Gerät decodiert.
• Unkomprimierte Audiodaten ohne Header (.raw oder .pcm) müssen im 16-Bit-PCM-Format mit 16 kHz und Mono vorliegen.

Wenn das Format ungültig ist oder nicht unterstützt wird, wird beim Start der Erkennung der Wert ErrorResponse zurückgegeben.

Speech Recognition API implementieren

Hier erfahren Sie, wie Sie die Speech Recognition API verwenden, um Audio zu transkribieren und das Wort-Timing zu nutzen.

Audio transkribieren

Die Speech Recognition API unterstützt Audioeingaben über das Gerätemikrofon, vorab aufgezeichnete Dateien oder benutzerdefinierte Pipelines mit einem ParcelFileDescriptor-Objekt.

Erstellen Sie zum Vorbereiten Ihrer Audiodaten ein AudioSource-Objekt mit einer der in der folgenden Tabelle aufgeführten Factory-Methoden:

Die Konstante AudioSource.Mode steuert, wie die API die eingehenden Audiodaten verarbeitet:

• Die Konstante AudioSource.Mode.STREAMING konfiguriert die Erkennung so, dass sie kontinuierlich Teil- und Endergebnisse der Transkription zurückgibt, sobald die Audiodaten eintreffen. Wenn Sie ein benutzerdefiniertes ParcelFileDescriptor-Objekt bereitstellen, müssen Sie Daten in Echtzeit in den Stream schreiben (ca. 32.000 Byte pro Sekunde für Standard-PCM-Audio mit 16 kHz, 16 Bit, Mono). Wenn Daten zu schnell geschrieben werden, kann der Zwischenspeicher überlaufen.
• Mit der Konstante AudioSource.Mode.ONE_SHOT wird die Erkennung so konfiguriert, dass sie auf die Übertragung der gesamten Audioquelle wartet, bevor die Inferenz durchgeführt und die endgültige Transkription geliefert wird. Sie können die Audiodaten so schnell wie möglich schreiben, müssen aber das Schreibende des Dateideskriptors schließen, um das Dateiende zu signalisieren. Das endgültige Transkriptionsergebnis wird erst geliefert, wenn dieses Signal für das Dateiende empfangen wurde.

Im folgenden Beispiel wird eine vorab aufgenommene Audiodatei transkribiert:

suspend fun recognizeFromFile(recognizer: SpeechRecognizer, audioFile: File) {
    val audioSource = AudioSource.fromFile(audioFile)
    val request = speechRecognizerRequest { this.audioSource = audioSource }
    try {
        recognizer.startRecognition(request).collect { response ->
            when (response) {
                is SpeechRecognizerResponse.FinalTextResponse -> {
                    // Process the transcription of the whole file.
                }
                is SpeechRecognizerResponse.ErrorResponse -> {
                    // Handle the error, for example an unsupported audio format.
                }
                else -> {}
            }
        }
    } finally {
        audioSource.close()
    }
}

Wort-Timing verwenden

Sie können die Startzeit jedes erkannten Wortes anfordern, indem Sie den Parameter enableWordTiming im Konfigurationsblock recognitionOptions Ihrer Anfrage auf true setzen.

Wenn das Wort-Timing aktiviert ist, enthält jedes SpeechRecognizerResponse.FinalTextResponse-Objekt ein wordTimings-Attribut mit einer Liste von SpeechRecognizerResponse.WordTiming-Objekten. Jedes Objekt enthält den erkannten Wortstring (text) und den Millisekunden-Offset (timestampMs) ab dem Beginn der Spracherkennungssitzung. Wenn das Wort-Timing deaktiviert ist (Standardeinstellung), wird die Liste wordTimings leer zurückgegeben.

Das folgende Codebeispiel zeigt, wie Sie das Wort-Timing konfigurieren und aktivieren:

suspend fun recognizeWithWordTiming(recognizer: SpeechRecognizer) {
    val request = speechRecognizerRequest {
        audioSource = AudioSource.fromMic()
        recognitionOptions { enableWordTiming = true }
    }
    recognizer.startRecognition(request).collect { response ->
        if (response is SpeechRecognizerResponse.FinalTextResponse) {
            for (wordTiming in response.wordTimings) {
                val word: String = wordTiming.text
                val timestamp: Long = wordTiming.timestampMs
            }
        }
    }
}

Unterstützte Sprachen

Unterstützte Geräte

Häufig auftretende Probleme bei der Einrichtung

Die GenAI APIs des ML Kit greifen über die Android AICore-App auf Gemini Nano zu. Wenn ein Gerät gerade erst eingerichtet (oder zurückgesetzt) wurde oder die AICore App gerade zurückgesetzt wurde (z.B. durch Löschen von Daten, Deinstallieren und Neuinstallieren), hat die AICore App möglicherweise nicht genügend Zeit, um die Initialisierung abzuschließen (einschließlich des Herunterladens der neuesten Konfigurationen vom Server). Daher funktionieren die ML Kit GenAI APIs möglicherweise nicht wie erwartet. Hier sind die häufigsten Fehlermeldungen bei der Einrichtung und wie du sie beheben kannst:

Beispielcode

• Codebeispiel für die ML Kit Speech Recognition API auf GitHub ansehen