Chirp 3-Transkription: verbesserte mehrsprachige Accuracy

Chirp 3 in der Google Cloud Console ausprobieren In Colab ausprobieren Notebook auf GitHub ansehen

Chirp 3 ist die neueste Generation der mehrsprachigen generativen Modelle von Google für die automatische Spracherkennung (Automatic Speech Recognition, ASR). Sie wurden auf Grundlage von Feedback und Erfahrungen entwickelt, um Nutzeranforderungen zu erfüllen. Chirp 3 bietet eine höhere Accuracy und Geschwindigkeit als frühere Chirp-Modelle und unterstützt die Sprecherbestimmung und automatische Spracherkennung.

Modelldetails

Chirp 3: Transcription ist ausschließlich in der Speech-to-Text API V2 verfügbar.

Modellbezeichnungen

Sie können Chirp 3: Transcription wie jedes andere Modell verwenden. Wenn Sie die API nutzen, geben Sie die entsprechende Modellbezeichnung in Ihrer Erkennungsanfrage an. Wenn Sie die Google Cloud Console nutzen, geben Sie den Modellnamen an. Geben Sie die entsprechende Modellbezeichnung in der Erkennung an.

Modell	Modellbezeichnung
Chirp 3	`chirp_3`

API-Methoden

Nicht alle Erkennungsmethoden unterstützen dieselben Sprachverfügbarkeitsgruppen. Da Chirp 3 in der Speech-to-Text API V2 verfügbar ist, werden die folgenden Erkennungsmethoden unterstützt:

API-Version	API-Methode	Unterstützung
V2	Speech.StreamingRecognize (geeignet für Audiostreams und Echtzeit-Audioinhalte)	Unterstützt
V2	Speech.Recognize (geeignet für Audioinhalte, die kürzer als 1 Minute sind)	Unterstützt
V2	Speech.BatchRecognize (geeignet für Audioinhalte, die zwischen 1 Minute und 1 Stunde lang sind)	Unterstützt

Regionale Verfügbarkeit

Chirp 3 ist in den folgenden Google Cloud -Regionen verfügbar. Weitere sind geplant.

Google Cloud -Zone	Einführungsreife
`us (multi-region)`	GA
`eu (multi-region)`	GA
`asia-northeast1`	GA
`asia-southeast1`	GA
`asia-south1`	Vorschau
`europe-west2`	Vorschau
`europe-west3`	Vorschau
`northamerica-northeast1`	Vorschau

Die aktuelle Liste der unterstützten Google Cloud -Regionen sowie der unterstützten Sprachen und Funktionen für jedes Transkriptionsmodell können Sie jederzeit mit der Locations API abrufen, wie hier erklärt wird.

Verfügbare Sprachen für die Transkription

Chirp 3 unterstützt die Transkription für StreamingRecognize, Recognize und BatchRecognize in den folgenden Sprachen:

Sprache	`BCP-47 Code`	Einführungsreife
Katalanisch (Spanien)	`ca-ES`	GA
Chinesisch, vereinfacht (China)	`cmn-Hans-CN`	GA
Kroatisch (Kroatien)	`hr-HR`	GA
Dänisch (Dänemark)	`da-DK`	GA
Niederländisch (Niederlande)	`nl-NL`	GA
Englisch (Australien)	`en-AU`	GA
Englisch (Vereinigtes Königreich)	`en-GB`	GA
Englisch (Indien)	`en-IN`	GA
Englisch (USA)	`en-US`	GA
Finnisch (Finnland)	`fi-FI`	GA
Französisch (Kanada)	`fr-CA`	GA
Französisch (Frankreich)	`fr-FR`	GA
Deutsch (Deutschland)	`de-DE`	GA
Griechisch (Griechenland)	`el-GR`	GA
Hindi (Indien)	`hi-IN`	GA
Italienisch (Italien)	`it-IT`	GA
Japanisch (Japan)	`ja-JP`	GA
Koreanisch (Korea)	`ko-KR`	GA
Polnisch (Polen)	`pl-PL`	GA
Portugiesisch (Brasilien)	`pt-BR`	GA
Portugiesisch (Portugal)	`pt-PT`	GA
Rumänisch (Rumänien)	`ro-RO`	GA
Russisch (Russland)	`ru-RU`	GA
Spanisch (Spanien)	`es-ES`	GA
Spanisch (USA)	`es-US`	GA
Schwedisch (Schweden)	`sv-SE`	GA
Türkisch (Türkei)	`tr-TR`	GA
Ukrainisch (Ukraine)	`uk-UA`	GA
Vietnamesisch (Vietnam)	`vi-VN`	GA
Arabisch	`ar-XA`	Vorschau
Arabisch (Algerien)	`ar-DZ`	Vorschau
Arabisch (Bahrain)	`ar-BH`	Vorschau
Arabisch (Ägypten)	`ar-EG`	Vorschau
Arabisch (Israel)	`ar-IL`	Vorschau
Arabisch (Jordanien)	`ar-JO`	Vorschau
Arabisch (Kuwait)	`ar-KW`	Vorschau
Arabisch (Libanon)	`ar-LB`	Vorschau
Arabisch (Mauretanien)	`ar-MR`	Vorschau
Arabisch (Marokko)	`ar-MA`	Vorschau
Arabisch (Oman)	`ar-OM`	Vorschau
Arabisch (Katar)	`ar-QA`	Vorschau
Arabisch (Saudi-Arabien)	`ar-SA`	Vorschau
Arabisch (Palästina)	`ar-PS`	Vorschau
Arabisch (Syrien)	`ar-SY`	Vorschau
Arabisch (Tunesien)	`ar-TN`	Vorschau
Arabisch (Vereinigte Arabische Emirate)	`ar-AE`	Vorschau
Arabisch (Jemen)	`ar-YE`	Vorschau
Armenisch (Armenien)	`hy-AM`	Vorschau
Bengalisch (Bangladesch)	`bn-BD`	Vorschau
Bengalisch (Indien)	`bn-IN`	Vorschau
Bulgarisch (Bulgarien)	`bg-BG`	Vorschau
Burmesisch (Myanmar)	`my-MM`	Vorschau
Zentralkurdisch (Irak)	`ar-IQ`	Vorschau
Chinesisch, Kantonesisch (traditionell, Hongkong)	`yue-Hant-HK`	Vorschau
Chinesisch, Mandarin (traditionell, Taiwan)	`cmn-Hant-TW`	Vorschau
Tschechisch (Tschechische Republik)	`cs-CZ`	Vorschau
Englisch (Philippinen)	`en-PH`	Vorschau
Estnisch (Estland)	`et-EE`	Vorschau
Philippinisch (Philippinen)	`fil-PH`	Vorschau
Gujarati (Indien)	`gu-IN`	Vorschau
Hebräisch (Israel)	`iw-IL`	Vorschau
Ungarisch (Ungarn)	`hu-HU`	Vorschau
Indonesisch (Indonesien)	`id-ID`	Vorschau
Kannada (Indien)	`kn-IN`	Vorschau
Khmer (Kambodscha)	`km-KH`	Vorschau
Lao (Laos)	`lo-LA`	Vorschau
Lettisch (Lettland)	`lv-LV`	Vorschau
Litauisch (Litauen)	`lt-LT`	Vorschau
Malaysisch (Malaysia)	`ms-MY`	Vorschau
Malayalam (Indien)	`ml-IN`	Vorschau
Marathi (Indien)	`mr-IN`	Vorschau
Nepalesisch (Nepal)	`ne-NP`	Vorschau
Norwegisch (Norwegen)	`no-NO`	Vorschau
Persisch (Iran)	`fa-IR`	Vorschau
Serbisch (Serbien)	`sr-RS`	Vorschau
Slowakisch (Slowakei)	`sk-SK`	Vorschau
Slowenisch (Slowenien)	`sl-SI`	Vorschau
Spanisch (Mexiko)	`es-MX`	Vorschau
Swahili	`sw`	Vorschau
Tamil (Indien)	`ta-IN`	Vorschau
Telugu (Indien)	`te-IN`	Vorschau
Thailändisch (Thailand)	`th-TH`	Vorschau
Usbekisch (Usbekistan)	`uz-UZ`	Vorschau

Verfügbare Sprachen für die Sprecherbestimmung

Chirp 3 unterstützt die Transkription und Sprecherbestimmung nur für BatchRecognize und Recognize in den folgenden Sprachen:

Sprache	BCP-47-Code
Chinesisch, vereinfacht (China)	cmn-Hans-CN
Deutsch (Deutschland)	de-DE
Englisch (Vereinigtes Königreich)	en-GB
Englisch (Indien)	en-IN
Englisch (USA)	en-US
Spanisch (Spanien)	es-ES
Spanisch (USA)	es-US
Französisch (Kanada)	fr-CA
Französisch (Frankreich)	fr-FR
Hindi (Indien)	hi-IN
Italienisch (Italien)	it-IT
Japanisch (Japan)	ja-JP
Koreanisch (Korea)	ko-KR
Portugiesisch (Brasilien)	pt-BR

Funktionsunterstützung und Einschränkungen

Chirp 3 unterstützt die folgenden Funktionen:

Funktion	Beschreibung	Einführungsphase
Automatische Zeichensetzung	Wird automatisch vom Modell generiert und kann optional deaktiviert werden.	GA
Automatische Großschreibung	Wird automatisch vom Modell generiert und kann optional deaktiviert werden.	GA
Zeitstempel auf Äußerungsebene	Werden automatisch vom Modell generiert.	GA
Sprecherbestimmung	Erkennt automatisch die verschiedenen Sprecher in Einkanal-Audiodaten. * Nur für `BatchRecognize` verfügbar.	GA
Sprachanpassung (Gewichtung)	Gibt dem Modell Hinweise in Form von einfachen Wörtern oder Wortgruppen, um die Accuracy der Erkennung für bestimmte Begriffe oder Eigennamen zu verbessern.	GA
Sprachunabhängige Audiotranskription	Das Modell leitet die am häufigsten verwendete Sprache automatisch ab und transkribiert in dieser Sprache.	GA

Chirp 3 unterstützt die folgenden Funktionen nicht:

Funktion	Beschreibung
Zeitstempel auf Wortebene	Werden automatisch vom Modell generiert und können optional aktiviert werden. Wenn diese Funktion aktiviert wird, ist eine Beeinträchtigung der Transkriptionsleistung zu erwarten.
Konfidenzwerte auf Wortebene	Die API gibt einen Wert zurück, der jedoch kein echter Konfidenzwert ist.

Mit Chirp 3 transkribieren

Erfahren Sie, wie Sie Chirp 3 für Transkriptionsaufgaben verwenden können.

Streamingspracherkennung durchführen

Python

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
REGION = "us"

def transcribe_streaming_chirp3(
   audio_file: str
) -> cloud_speech.StreamingRecognizeResponse:
   """Transcribes audio from audio file stream using the Chirp 3 model of Google Cloud Speech-to-Text v2 API.

   Args:
       audio_file (str): Path to the local audio file to be transcribed.
           Example: "resources/audio.wav"

   Returns:
       cloud_speech.RecognizeResponse: The response from the Speech-to-Text API V2 containing
       the transcription results.
   """

   # Instantiates a client
   client = SpeechClient(
       client_options=ClientOptions(
           api_endpoint=f"{REGION}-speech.googleapis.com",
       )
   )

   # Reads a file as bytes
   with open(audio_file, "rb") as f:
       content = f.read()

   # In practice, stream should be a generator yielding chunks of audio data
   chunk_length = len(content) // 5
   stream = [
       content[start : start + chunk_length]
       for start in range(0, len(content), chunk_length)
   ]
   audio_requests = (
       cloud_speech.StreamingRecognizeRequest(audio=audio) for audio in stream
   )

   recognition_config = cloud_speech.RecognitionConfig(
       auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
       language_codes=["en-US"],
       model="chirp_3",
   )
   streaming_config = cloud_speech.StreamingRecognitionConfig(
       config=recognition_config
   )
   config_request = cloud_speech.StreamingRecognizeRequest(
       recognizer=f"projects/{PROJECT_ID}/locations/{REGION}/recognizers/_",
       streaming_config=streaming_config,
   )

   def requests(config: cloud_speech.RecognitionConfig, audio: list) -> list:
       yield config
       yield from audio

   # Transcribes the audio into text
   responses_iterator = client.streaming_recognize(
       requests=requests(config_request, audio_requests)
   )
   responses = []
   for response in responses_iterator:
       responses.append(response)
       for result in response.results:
           print(f"Transcript: {result.alternatives[0].transcript}")

   return responses

Synchrone Spracherkennung durchführen

Python

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
REGION = "us"

def transcribe_sync_chirp3(
   audio_file: str
) -> cloud_speech.RecognizeResponse:
   """Transcribes an audio file using the Chirp 3 model of Google Cloud Speech-to-Text V2 API.
   Args:
       audio_file (str): Path to the local audio file to be transcribed.
           Example: "resources/audio.wav"
   Returns:
       cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
       the transcription results.
   """

   # Instantiates a client
   client = SpeechClient(
       client_options=ClientOptions(
           api_endpoint=f"{REGION}-speech.googleapis.com",
       )
   )

   # Reads a file as bytes
   with open(audio_file, "rb") as f:
       audio_content = f.read()

   config = cloud_speech.RecognitionConfig(
       auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
       language_codes=["en-US"],
       model="chirp_3",
   )

   request = cloud_speech.RecognizeRequest(
       recognizer=f"projects/{PROJECT_ID}/locations/{REGION}/recognizers/_",
       config=config,
       content=audio_content,
   )

   # Transcribes the audio into text
   response = client.recognize(request=request)

   for result in response.results:
       print(f"Transcript: {result.alternatives[0].transcript}")

   return response

Batch-Spracherkennung durchführen

Python

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
REGION = "us"

def transcribe_batch_3(
   audio_uri: str,
) -> cloud_speech.BatchRecognizeResults:
   """Transcribes an audio file from a Google Cloud Storage URI using the Chirp 3 model of Google Cloud Speech-to-Text v2 API.
   Args:
       audio_uri (str): The Google Cloud Storage URI of the input audio file.
           E.g., gs://[BUCKET]/[FILE]
   Returns:
       cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
       the transcription results.
   """

   # Instantiates a client
   client = SpeechClient(
       client_options=ClientOptions(
           api_endpoint=f"{REGION}-speech.googleapis.com",
       )
   )

   config = cloud_speech.RecognitionConfig(
       auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
       language_codes=["en-US"],
       model="chirp_3",
   )

   file_metadata = cloud_speech.BatchRecognizeFileMetadata(uri=audio_uri)

   request = cloud_speech.BatchRecognizeRequest(
       recognizer=f"projects/{PROJECT_ID}/locations/{REGION}/recognizers/_",
       config=config,
       files=[file_metadata],
       recognition_output_config=cloud_speech.RecognitionOutputConfig(
           inline_response_config=cloud_speech.InlineOutputConfig(),
       ),
   )

   # Transcribes the audio into text
   operation = client.batch_recognize(request=request)

   print("Waiting for operation to complete...")
   response = operation.result(timeout=120)

   for result in response.results[audio_uri].transcript.results:
       print(f"Transcript: {result.alternatives[0].transcript}")

   return response.results[audio_uri].transcript

Chirp 3-Funktionen verwenden

Hier erfahren Sie, wie Sie die neuesten Funktionen einsetzen. Sehen Sie sich auch die Codebeispiele an.

Sprachunabhängige Transkription durchführen

Chirp 3 kann die dominierende Sprache in Audioinhalten automatisch erkennen und transkribieren, was für mehrsprachige Anwendungen essenziell ist. Verwenden Sie dazu language_codes=["auto"], wie im folgenden Codebeispiel zu sehen.

Python

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
REGION = "us"

def transcribe_sync_chirp3_auto_detect_language(
   audio_file: str
) -> cloud_speech.RecognizeResponse:
   """Transcribes an audio file and auto-detect spoken language using Chirp 3.
   Please see https://cloud.google.com/speech-to-text/docs/encoding for more
   information on which audio encodings are supported.
   Args:
       audio_file (str): Path to the local audio file to be transcribed.
           Example: "resources/audio.wav"
   Returns:
       cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
       the transcription results.
   """
   # Instantiates a client
   client = SpeechClient(
       client_options=ClientOptions(
           api_endpoint=f"{REGION}-speech.googleapis.com",
       )
   )

   # Reads a file as bytes
   with open(audio_file, "rb") as f:
       audio_content = f.read()

   config = cloud_speech.RecognitionConfig(
       auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
       language_codes=["auto"],  # Set language code to auto to detect language.
       model="chirp_3",
   )

   request = cloud_speech.RecognizeRequest(
       recognizer=f"projects/{PROJECT_ID}/locations/{REGION}/recognizers/_",
       config=config,
       content=audio_content,
   )

   # Transcribes the audio into text
   response = client.recognize(request=request)

   for result in response.results:
       print(f"Transcript: {result.alternatives[0].transcript}")
       print(f"Detected Language: {result.language_code}")

   return response

Sprachbeschränkte Transkription durchführen

Chirp 3 kann die dominierende Sprache in einer Audiodatei automatisch erkennen und transkribieren. Sie können das Modell auch auf bestimmte erwartete Sprachen abstimmen, z. B. ["en-US", "fr-FR"]. Dadurch werden die Ressourcen des Modells auf die wahrscheinlichsten Sprachen konzentriert, um zuverlässigere Ergebnisse zu erzielen. Das folgende Codebeispiel zeigt, wie das funktioniert:

Python

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
REGION = "us"

def transcribe_sync_3_auto_detect_language(
   audio_file: str
) -> cloud_speech.RecognizeResponse:
   """Transcribes an audio file and auto-detect spoken language using Chirp 3.
   Please see https://cloud.google.com/speech-to-text/docs/encoding for more
   information on which audio encodings are supported.
   Args:
       audio_file (str): Path to the local audio file to be transcribed.
           Example: "resources/audio.wav"
   Returns:
       cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
       the transcription results.
   """
   # Instantiates a client
   client = SpeechClient(
       client_options=ClientOptions(
           api_endpoint=f"{REGION}-speech.googleapis.com",
       )
   )

   # Reads a file as bytes
   with open(audio_file, "rb") as f:
       audio_content = f.read()

   config = cloud_speech.RecognitionConfig(
       auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
       language_codes=["en-US", "fr-FR"],  # Set language codes of the expected spoken locales
       model="chirp_3",
   )

   request = cloud_speech.RecognizeRequest(
       recognizer=f"projects/{PROJECT_ID}/locations/{REGION}/recognizers/_",
       config=config,
       content=audio_content,
   )

   # Transcribes the audio into text
   response = client.recognize(request=request)

   for result in response.results:
       print(f"Transcript: {result.alternatives[0].transcript}")
       print(f"Detected Language: {result.language_code}")

   return response

Transkription und Sprecherbestimmung durchführen

Sie können Chirp 3 für Transkriptions- und Sprecherbestimmungsaufgaben verwenden.

Python

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
REGION = "us"

def transcribe_batch_chirp3(
   audio_uri: str,
) -> cloud_speech.BatchRecognizeResults:
   """Transcribes an audio file from a Google Cloud Storage URI using the Chirp 3 model of Google Cloud Speech-to-Text V2 API.
   Args:
       audio_uri (str): The Google Cloud Storage URI of the input
         audio file. E.g., gs://[BUCKET]/[FILE]
   Returns:
       cloud_speech.RecognizeResponse: The response from the
         Speech-to-Text API containing the transcription results.
   """

   # Instantiates a client.
   client = SpeechClient(
       client_options=ClientOptions(
           api_endpoint=f"{REGION}-speech.googleapis.com",
       )
   )

   config = cloud_speech.RecognitionConfig(
       auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
       language_codes=["en-US"],  # Use "auto" to detect language.
       model="chirp_3",
       features=cloud_speech.RecognitionFeatures(
           # Enable diarization by setting empty diarization configuration.
           diarization_config=cloud_speech.SpeakerDiarizationConfig(),
       ),
   )

   file_metadata = cloud_speech.BatchRecognizeFileMetadata(uri=audio_uri)

   request = cloud_speech.BatchRecognizeRequest(
       recognizer=f"projects/{PROJECT_ID}/locations/{REGION}/recognizers/_",
       config=config,
       files=[file_metadata],
       recognition_output_config=cloud_speech.RecognitionOutputConfig(
           inline_response_config=cloud_speech.InlineOutputConfig(),
       ),
   )

   # Creates audio transcription job.
   operation = client.batch_recognize(request=request)

   print("Waiting for transcription job to complete...")
   response = operation.result(timeout=120)

   for result in response.results[audio_uri].transcript.results:
       print(f"Transcript: {result.alternatives[0].transcript}")
       print(f"Detected Language: {result.language_code}")
       print(f"Speakers per word: {result.alternatives[0].words}")

   return response.results[audio_uri].transcript

Accuracy durch Modellanpassung verbessern

Chirp 3 kann die Accuracy der Transkription für Ihre spezifischen Audiodaten mithilfe der Modellanpassung verbessern. Sie können eine Liste mit bestimmten Wörtern und Wortgruppen angeben und so die Wahrscheinlichkeit erhöhen, dass das Modell sie erkennt. Das ist besonders für fachspezifische Begriffe, Eigennamen oder ungewöhnliches Vokabular nützlich.

Python

import os

from google.cloud.speech_v2 import SpeechClient
from google.cloud.speech_v2.types import cloud_speech
from google.api_core.client_options import ClientOptions

PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
REGION = "us"

def transcribe_sync_chirp3_model_adaptation(
   audio_file: str
) -> cloud_speech.RecognizeResponse:
   """Transcribes an audio file using the Chirp 3 model with adaptation, improving accuracy for specific audio characteristics or vocabulary.
   Args:
       audio_file (str): Path to the local audio file to be transcribed.
           Example: "resources/audio.wav"
   Returns:
       cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
       the transcription results.
   """

   # Instantiates a client
   client = SpeechClient(
       client_options=ClientOptions(
           api_endpoint=f"{REGION}-speech.googleapis.com",
       )
   )

   # Reads a file as bytes
   with open(audio_file, "rb") as f:
       audio_content = f.read()

   config = cloud_speech.RecognitionConfig(
       auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
       language_codes=["en-US"],
       model="chirp_3",
       # Use model adaptation
       adaptation=cloud_speech.SpeechAdaptation(
         phrase_sets=[
             cloud_speech.SpeechAdaptation.AdaptationPhraseSet(
                 inline_phrase_set=cloud_speech.PhraseSet(phrases=[
                   {
                       "value": "alphabet",
                   },
                   {
                         "value": "cell phone service",
                   }
                 ])
             )
         ]
       )
   )

   request = cloud_speech.RecognizeRequest(
       recognizer=f"projects/{PROJECT_ID}/locations/{REGION}/recognizers/_",
       config=config,
       content=audio_content,
   )

   # Transcribes the audio into text
   response = client.recognize(request=request)

   for result in response.results:
       print(f"Transcript: {result.alternatives[0].transcript}")

   return response

Rauschunterdrückung und SNR-Filter aktivieren

Chirp 3 kann die Audioqualität optimieren, indem es vor der Transkription Hintergrundgeräusche reduziert und unerwünschte Geräusche herausfiltert. Sie können die Ergebnisse in lauten Umgebungen verbessern, indem Sie die integrierte Rauschunterdrückung und den Filter für das Signal-Rausch-Verhältnis (Signal-to-Noise Ratio, SNR) aktivieren.

Mit denoiser_audio=true können Sie Hintergrundmusik oder Geräusche wie Regen und Straßenverkehr effektiv reduzieren.

Mit snr_threshold=X können Sie die Mindestlautstärke der Sprache festlegen, die für die Transkription erforderlich ist. So werden Audioinhalte, die keine Sprache enthalten, oder Hintergrundgeräusche herausgefiltert, um unerwünschten Text in den Ergebnissen zu vermeiden. Ein höherer Wert für snr_threshold bedeutet, dass der Nutzer lauter sprechen muss, damit das Modell die Äußerungen transkribiert.

Die SNR-Filterung kann in Anwendungsfällen mit Streaming in Echtzeit verwendet werden, um zu vermeiden, dass unnötige Geräusche zur Transkription an ein Modell gesendet werden. Ein höherer Wert für diese Einstellung bedeutet, dass Ihre Stimme im Verhältnis zu den Hintergrundgeräuschen lauter sein muss, damit sie an das Transkriptionsmodell gesendet wird.

Die Konfiguration von snr_threshold steht in Wechselwirkung mit der Konfiguration von denoise_audio (true oder false). Wenn denoise_audio=true konfiguriert ist, werden Hintergrundgeräusche entfernt und Sprache wird klarer. Das gesamte SNR des Audioinhalts steigt.

Wenn in Ihrem Anwendungsfall nur die Stimme des Nutzers ohne andere Sprecher vorliegt, legen Sie denoise_audio=true fest. Das erhöht die Empfindlichkeit des SNR-Filters, damit andere Geräusche als Sprache herausgefiltert werden können. Wenn in Ihrem Anwendungsfall Personen im Hintergrund sprechen und Sie deren Transkription vermeiden möchten, legen Sie denoise_audio=false fest und senken Sie den SNR-Grenzwert.

Im Folgenden finden Sie empfohlene SNR-Grenzwerte. Es kann für snr_threshold ein geeigneter Wert zwischen 0 und 1000 festgelegt werden. Ein Wert von 0 bedeutet, dass nichts gefiltert wird, und 1000 bedeutet, dass alles gefiltert wird. Passen Sie den Wert an, wenn die empfohlene Einstellung nicht für Ihre Anforderungen geeignet ist.

Audio-Rauschunterdrückung	SNR-Grenzwert	Sprachempfindlichkeit
true	10.0	hoch
true	20.0	mittel
true	40.0	niedrig
true	100.0	sehr niedrig
false	0.5	hoch
false	1.0	mittel
false	2.0	niedrig
false	5.0	sehr niedrig

Python

 import os

 from google.cloud.speech_v2 import SpeechClient
 from google.cloud.speech_v2.types import cloud_speech
 from google.api_core.client_options import ClientOptions

 PROJECT_ID = os.getenv("GOOGLE_CLOUD_PROJECT")
 REGION = "us"

def transcribe_sync_chirp3_with_timestamps(
   audio_file: str
) -> cloud_speech.RecognizeResponse:
   """Transcribes an audio file using the Chirp 3 model of Google Cloud Speech-to-Text v2 API, which provides word-level timestamps for each transcribed word.
   Args:
       audio_file (str): Path to the local audio file to be transcribed.
           Example: "resources/audio.wav"
   Returns:
       cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
       the transcription results.
   """

   # Instantiates a client
   client = SpeechClient(
       client_options=ClientOptions(
           api_endpoint=f"{REGION}-speech.googleapis.com",
       )
   )

   # Reads a file as bytes
   with open(audio_file, "rb") as f:
       audio_content = f.read()

   config = cloud_speech.RecognitionConfig(
       auto_decoding_config=cloud_speech.AutoDetectDecodingConfig(),
       language_codes=["en-US"],
       model="chirp_3",
       denoiser_config={
           denoise_audio: True,
           # Medium snr threshold
           snr_threshold: 20.0,
       }
   )

   request = cloud_speech.RecognizeRequest(
       recognizer=f"projects/{PROJECT_ID}/locations/{REGION}/recognizers/_",
       config=config,
       content=audio_content,
   )

   # Transcribes the audio into text
   response = client.recognize(request=request)

   for result in response.results:
       print(f"Transcript: {result.alternatives[0].transcript}")

   return response

Chirp 3 in der Google Cloud Console verwenden

Registrieren Sie sich bei Google Cloud für ein Konto und erstellen Sie ein Projekt.
Rufen Sie in der Google Cloud Console Sprache auf.
Wenn die API nicht aktiviert ist, aktivieren Sie sie.
Sie benötigen einen Arbeitsbereich in der STT Console. Wenn Sie noch keinen Arbeitsbereich haben, erstellen Sie einen.
1. Rufen Sie die Seite Transkriptionen auf und klicken Sie auf Neue Transkription.
2. Öffnen Sie das Drop-down-Menü Arbeitsbereich und klicken Sie auf Neuer Arbeitsbereich, um einen Arbeitsbereich für die Transkription zu erstellen.
3. Klicken Sie in der Navigationsleiste Neuen Arbeitsbereich erstellen auf Durchsuchen.
4. Klicken Sie, um einen neuen Bucket zu erstellen.
5. Geben Sie einen Namen für den Bucket ein und klicken Sie auf Weiter.
6. Klicken Sie auf Erstellen, um den Cloud Storage-Bucket zu erstellen.
7. Klicken Sie nach der Erstellung des Buckets auf Auswählen, um Ihren Bucket auszuwählen.
8. Klicken Sie auf Erstellen, um den Arbeitsbereich für die Speech-to-Text API V2 Console zu erstellen.
Transkribieren Sie Ihre Audiodatei.

Seite zum Erstellen von Speech-to-Text-Transkriptionen mit Optionen zum Auswählen oder Hochladen einer Datei

Wählen Sie auf der Seite Neue Transkription Ihre Audiodatei entweder durch einen Upload (Lokaler Upload) oder durch Angabe einer vorhandenen Cloud Storage-Datei (Cloud Storage) aus.
Klicken Sie auf Weiter, um zu den Sprache-zu-Text-Optionen zu gelangen.
1. Wählen Sie die Gesprochene Sprache aus, die Sie für die Erkennung mit Chirp und Ihrem zuvor erstellten Erkennungssystem verwenden möchten.
2. Wählen Sie im Drop-down-Menü für das Modell chirp_3 aus.
3. Wählen Sie im Drop-down-Menü Erkennungssystem Ihr neu erstelltes Erkennungssystem aus.
4. Klicken Sie auf Senden, um Ihre erste Erkennungsanfrage mit chirp_3 auszuführen.
Sehen Sie sich das Transkriptionsergebnis von Chirp 3 an.
1. Klicken Sie auf der Seite Transkriptionen auf den Namen der Transkription, um das Ergebnis aufzurufen.
2. Auf der Seite Transkriptionsdetails können Sie Ihr Transkriptionsergebnis anzeigen und optional die Audioinhalte im Browser wiedergeben.

Weitere Informationen

Kurze Audiodateien transkribieren

Audiostreams transkribieren

Lange Audiodateien transkribieren

Best Practices-Dokumentation mit Tipps zu Leistung, Accuracy und anderen Themen

Chirp 3-Transkription: verbesserte mehrsprachige Accuracy Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

Modelldetails

Modellbezeichnungen

API-Methoden

Regionale Verfügbarkeit

Verfügbare Sprachen für die Transkription

Verfügbare Sprachen für die Sprecherbestimmung

Funktionsunterstützung und Einschränkungen

Mit Chirp 3 transkribieren

Streamingspracherkennung durchführen

Python

Synchrone Spracherkennung durchführen

Python

Batch-Spracherkennung durchführen

Python

Chirp 3-Funktionen verwenden

Sprachunabhängige Transkription durchführen

Python

Sprachbeschränkte Transkription durchführen

Python

Transkription und Sprecherbestimmung durchführen

Python

Accuracy durch Modellanpassung verbessern

Python

Rauschunterdrückung und SNR-Filter aktivieren

Python

Chirp 3 in der Google Cloud Console verwenden

Weitere Informationen

Chirp 3-Transkription: verbesserte mehrsprachige Accuracy