Diese Seite wurde von der Cloud Translation API übersetzt.

Chirp 3-Transkription: Verbesserte mehrsprachige Genauigkeit

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 die Bedürfnisse der Nutzer zu erfüllen. Chirp 3 bietet eine höhere Genauigkeit und Geschwindigkeit als frühere Chirp-Modelle und unterstützt die Sprecherzuordnung und die automatische Spracherkennung.

Modelldetails

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

Modell-Kennzeichnungen

Sie können Chirp 3: Transcription wie jedes andere Modell verwenden, indem Sie bei Verwendung der API die entsprechende Modellkennung in Ihrer Erkennungsanfrage oder in der Google Cloud Console den Modellnamen angeben. Geben Sie die entsprechende Kennung in Ihrer Bestätigung an.

Modell	Modellkennung
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	Support
V2	Speech.StreamingRecognize (gut für Streaming und Echtzeit-Audio)	Unterstützt
V2	Speech.Recognize (gut für Audioaufnahmen, die kürzer als eine Minute sind)	Unterstützt
V2	Speech.BatchRecognize (gut für lange Audioaufnahmen von 1 Minute bis 1 Stunde)	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-southeast1`	GA
`asia-northeast1`	GA

Mit der Locations API, wie hier beschrieben, können Sie die aktuelle Liste der unterstützten Google Cloud Regionen, Sprachen und Gebietsschemas sowie Funktionen für jedes Transkriptionsmodell abrufen.

Verfügbare Sprachen für die Transkription

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

Sprache	`BCP-47 Code`	Vorbereitung auf die Markteinführung
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
Birmanisch (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
Malaiisch (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
Suaheli	`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 die Sprecherzuordnung nur in 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	Startphase
Automatische Zeichensetzung	Sie werden automatisch vom Modell generiert und können optional deaktiviert werden.	GA
Automatische Großschreibung	Sie werden automatisch vom Modell generiert und können optional deaktiviert werden.	GA
Zeitstempel auf Äußerungsebene	Automatisch vom Modell generiert.	GA
Sprecherbestimmung	Erkennt automatisch die verschiedenen Sprecher in einem Einkanal-Audiobeispiel. Nur in `BatchRecognize` verfügbar	GA
Sprachanpassung (Biasing)	Gibt dem Modell Hinweise in Form von Formulierungen oder Wörtern, um die Erkennungsgenauigkeit für bestimmte Begriffe oder Eigennamen zu verbessern.	GA
Sprachunabhängige Audiotranskription	Die vorherrschende Sprache wird automatisch erkannt und transkribiert.	GA

Chirp 3 unterstützt die folgenden Funktionen nicht:

Feature	Beschreibung
Zeitstempel auf Wortebene	Wird automatisch vom Modell generiert und kann optional aktiviert werden. Dabei ist mit einer gewissen Verschlechterung der Transkription zu rechnen.
Konfidenzwerte auf Wortebene	Die API gibt einen Wert zurück, es ist jedoch kein echter Konfidenzwert.

Mit Chirp 3 transkribieren

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

Streamingspracherkennung ausfü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 ausfü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 finden Sie Codebeispiele für die Verwendung der neuesten Funktionen:

Sprachunabhängige Transkription durchführen

Chirp 3 kann die im Audio gesprochene Hauptsprache automatisch erkennen und transkribieren. Das ist für mehrsprachige Anwendungen unerlässlich. Setzen Sie dazu language_codes=["auto"] wie im Codebeispiel angegeben:

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/v2/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/v2/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

Verwenden Sie Chirp 3 für Transkriptions- und Sprecherzuordnungsaufgaben.

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

Genauigkeit durch Modellanpassung verbessern

Mit Chirp 3 lässt sich die Genauigkeit der Transkription für Ihre spezifischen Audiodaten durch Modellanpassung verbessern. So können Sie eine Liste mit bestimmten Wörtern und Wortgruppen angeben und die Wahrscheinlichkeit erhöhen, dass das Modell sie erkennt. Das ist besonders für fachspezifische Begriffe, Eigennamen oder einzigartige Vokabeln 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-Filterung aktivieren

Chirp 3 kann die Audioqualität verbessern, indem es Hintergrundgeräusche reduziert und unerwünschte Geräusche vor der Transkription herausfiltert. Sie können die Ergebnisse in lauten Umgebungen verbessern, indem Sie die integrierte Rauschunterdrückung und die Filterung des Signal-Rausch-Verhältnisses (SNR) aktivieren.

Mit der Einstellung denoiser_audio=true kannst du 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 Audiodaten ohne Sprache oder Hintergrundgeräusche herausgefiltert, um unerwünschten Text in den Ergebnissen zu vermeiden. Ein höherer snr_threshold-Wert bedeutet, dass der Nutzer lauter sprechen muss, damit das Modell die Äußerungen transkribieren kann.

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

Die Konfiguration von snr_threshold hängt davon ab, ob denoise_audio true oder false ist. Bei denoise_audio=true werden Hintergrundgeräusche entfernt und Sprache wird relativ klarer. Das allgemeine SNR des Audiosignals steigt.

Wenn Ihr Anwendungsfall nur die Stimme des Nutzers ohne andere Sprecher umfasst, legen Sie denoise_audio=true fest, um die Empfindlichkeit der SNR-Filterung zu erhöhen. So können Sie Rauschen herausfiltern, das nicht durch Sprache verursacht wird. Wenn in Ihrem Anwendungsfall Personen im Hintergrund sprechen und Sie vermeiden möchten, dass Hintergrundsprache transkribiert wird, sollten Sie denoise_audio=false festlegen und den SNR-Schwellenwert senken.

Im Folgenden finden Sie empfohlene SNR-Schwellenwerte. Ein angemessener snr_threshold-Wert kann 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 für Sie nicht funktioniert.

Audio-Rauschunterdrückung	SNR-Grenzwert	Sprachempfindlichkeit
wahr	10	hoch
wahr	20,0	Mittel
wahr	40,0	low
wahr	100,0	sehr niedrig
falsch	0,5	hoch
falsch	1,0	Mittel
falsch	2.0	low
falsch	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 für ein Google Cloud -Konto und erstellen Sie ein Projekt.
Rufen Sie in der Google Cloud Console Speech auf.
Wenn die API nicht aktiviert ist, aktivieren Sie sie.
Sie benötigen einen STT-Konsolen-Arbeitsbereich. Wenn Sie keinen Arbeitsbereich haben, müssen Sie einen erstellen.
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 ihn auszuwählen.
8. Klicken Sie auf Erstellen, um den Arbeitsbereich für die Speech-to-Text API V2-Konsole zu erstellen.
Führen Sie eine Transkription Ihres Audios durch.

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 Transkriptionsoptionen zu gelangen.
1. Wählen Sie die Gesprochene Sprache aus, die Sie für die Erkennung mit Chirp von Ihrem zuvor erstellten Erkennungsmodul verwenden möchten.
2. Wählen Sie im Drop-down-Menü des Modells chirp_3 aus.
3. Wählen Sie im Drop-down-Menü Erkennung Ihre neu erstellte Erkennung aus.
4. Klicken Sie auf Senden, um Ihre erste Erkennungsanfrage mit chirp_3 auszuführen.
Sehen Sie sich das Chirp 3-Transkriptionsergebnis 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 abspielen.

Nächste Schritte

Kurze Audiodateien transkribieren
Weitere Informationen zum Transkribieren von Audiostreams
Lange Audiodateien transkribieren
Best Practices-Dokumentation für maximale Leistung und Genauigkeit sowie für weitere Tipps

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

Modelldetails

Modell-Kennzeichnungen

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 ausführen

Python

Synchrone Spracherkennung durchführen

Python

Batch-Spracherkennung ausführen

Python

Chirp 3-Funktionen verwenden

Sprachunabhängige Transkription durchführen

Python

Sprachbeschränkte Transkription durchführen

Python

Transkription und Sprecherbestimmung durchführen

Python

Genauigkeit durch Modellanpassung verbessern

Python

Rauschunterdrückung und SNR-Filterung aktivieren

Python

Chirp 3 in der Google Cloud Console verwenden

Nächste Schritte

Chirp 3-Transkription: Verbesserte mehrsprachige Genauigkeit