Diese Seite wurde von der Cloud Translation API übersetzt.

Chirp 2: Verbesserte mehrsprachige Genauigkeit

Chirp 2 ist die neueste Generation der mehrsprachigen ASR-Modelle von Google, die auf Feedback und Erfahrung basieren und auf die Bedürfnisse der Nutzer zugeschnitten sind. Es bietet im Vergleich zum ursprünglichen Chirp-Modell eine höhere Genauigkeit und Geschwindigkeit und umfasst wichtige neue Funktionen wie Zeitstempel auf Wortebene, Modellanpassung und Übersetzung von Gesprochenem.

Colab-Notebook ausprobieren

Notebook auf GitHub ansehen

Modelldetails

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

Modell-Kennzeichnungen

Sie können Chirp 2 wie jedes andere Modell verwenden, indem Sie den entsprechenden Modell-Identifier in Ihrer Erkennungsanfrage angeben, wenn Sie die API verwenden, oder den Modellnamen in der Google Cloud -Konsole.

Modell	Modellkennung
Chirp 2	`chirp_2`

API-Methoden

Da Chirp 2 ausschließlich in der Speech-to-Text API V2 verfügbar ist, werden die folgenden Erkennungsmethoden unterstützt:

Modell	Modellkennung	Sprachunterstützung
`V2`	`Speech.StreamingRecognize` (gut für Streaming und Echtzeit-Audio)	Eingeschränkt*
`V2`	`Speech.Recognize` (gut für kurze Audioaufnahmen < 1 Min.)	Auf Augenhöhe mit Chirp
`V2`	`Speech.BatchRecognize` (gut für lange Audioaufnahmen 1 Min. bis 8 Std.)	Auf Augenhöhe mit Chirp

*Die aktuelle Liste der unterstützten Sprachen und Funktionen für jedes Transkriptionsmodell finden Sie immer in der Locations API.

Regionale Verfügbarkeit

Chirp 2 wird in den folgenden Regionen unterstützt:

Google Cloud Zone	Einführungsreife
`us-central1`	GA
`europe-west4`	GA
`asia-southeast1`	GA

Die aktuelle Liste der unterstützten Google Cloud Regionen, Sprachen und Funktionen für jedes Transkriptionsmodell finden Sie jederzeit über die Locations API, wie hier beschrieben.

Verfügbare Sprachen für die Transkription

Chirp 2 unterstützt die Transkription in den Spracherkennungsmethoden StreamingRecognize, Recognize und BatchRecognize. Die Sprachunterstützung hängt jedoch von der verwendeten Methode ab. Insbesondere bietet BatchRecognize die umfangreichste Sprachunterstützung. StreamingRecognize unterstützt die folgenden Sprachen:

Sprache	BCP-47-Code
Chinesisch, vereinfacht (China)	`cmn-Hans-CN`
Chinese Traditional Taiwan	`cmn-Hant-TW`
Chinesisch, Kantonesisch (traditionell, Hongkong)	`yue-Hant-HK`
Englisch (Australien)	`en-AU`
Englisch (Indien)	`en-IN`
Englisch (Vereinigtes Königreich)	`en-GB`
Englisch (USA)	`en-US`
Französisch (Kanada)	`fr-CA`
Französisch (Frankreich)	`fr-FR`
Deutsch (Deutschland)	`de-DE`
Italienisch (Italien)	`it-IT`
Japanisch (Japan)	`ja-JP`
Koreanisch (Südkorea)	`ko-KR`
Portugiesisch (Brasilien)	`pt-BR`
Spanisch (Spanien)	`es-ES`
Spanisch (USA)	`es-US`

Verfügbare Sprachen für die Übersetzung

Dies sind die unterstützten Sprachen für die Sprachübersetzung. Die Sprachunterstützung für die Übersetzung in Chirp 2 ist nicht symmetrisch. Das bedeutet, dass wir möglicherweise von Sprache A in Sprache B übersetzen können, aber nicht von Sprache B in Sprache A. Die folgenden Sprachpaare werden für die Sprachübersetzung unterstützt.

Zur Übersetzung ins Englische:

Ausgangssprache -> Zielsprache	Code der Ausgangssprache -> Code der Zielsprache
Arabisch (Ägypten) -> Englisch	`ar-EG` -> `en-US`
Arabisch (Golfregion) -> Englisch	`ar-x-gulf` -> `en-US`
Arabisch (Levantinisch) -> Englisch	`ar-x-levant` -> `en-US`
Arabisch (Maghreb) -> Englisch	`ar-x-maghrebi` -> `en-US`
Katalanisch (Spanien) -> Englisch	`ca-ES` -> `en-US`
Walisisch (Vereinigtes Königreich) -> Englisch	`cy-GB` -> `en-US`
Deutsch (Deutschland) -> Englisch	`de-DE` -> `en-US`
Spanisch (Lateinamerika) –> Englisch	`es-419` -> `en-US`
Spanisch (Spanien) -> Englisch	`es-ES` -> `en-US`
Spanisch (USA) -> Englisch	`es-US` -> `en-US`
Estnisch (Estland) -> Englisch	`et-EE` -> `en-US`
Französisch (Kanada) -> Englisch	`fr-CA` -> `en-US`
Französisch (Frankreich) -> Englisch	`fr-FR` -> `en-US`
Persisch (Iran) -> Englisch	`fa-IR` -> `en-US`
Indonesisch (Indonesien) -> Englisch	`id-ID` -> `en-US`
Italienisch (Italien) -> Englisch	`it-IT` -> `en-US`
Japanisch (Japan) -> Englisch	`ja-JP` -> `en-US`
Lettisch (Lettland) -> Englisch	`lv-LV` -> `en-US`
Mongolisch (Mongolei) -> Englisch	`mn-MN` -> `en-US`
Niederländisch (Niederlande) -> Englisch	`nl-NL` -> `en-US`
Portugiesisch (Brasilien) -> Englisch	`pt-BR` -> `en-US`
Russisch (Russland) -> Englisch	`ru-RU` -> `en-US`
Slowenisch (Slowenien) -> Englisch	`sl-SI` -> `en-US`
Schwedisch (Schweden) -> Englisch	`sv-SE` -> `en-US`
Tamil (Indien) -> Englisch	`ta-IN` -> `en-US`
Türkisch (Türkei) -> Englisch	`tr-TR` -> `en-US`
Chinesisch (vereinfacht, China) -> Englisch	`cmn-Hans-CN` -> `en-US`

Für die Übersetzung aus dem Englischen:

Ausgangssprache -> Zielsprache	Code der Ausgangssprache -> Code der Zielsprache
Englisch -> Arabisch (Ägypten)	`en-US` -> `ar-EG`
Englisch -> Arabisch (Golfregion)	`en-US` -> ar-`x-gulf`
Englisch -> Arabisch (Levantinisch)	`en-US` -> ar-`x-levant`
Englisch -> Arabisch (Maghreb)	`en-US` -> ar-`x-maghrebi`
Englisch -> Katalanisch (Spanien)	`en-US` -> `ca-ES`
Englisch -> Walisisch (Vereinigtes Königreich)	`en-US` -> `cy-GB`
Englisch -> Deutsch (Deutschland)	`en-US` -> `de-DE`
Englisch –> Estnisch (Estland)	`en-US` -> `et-EE`
Englisch -> Persisch (Iran)	`en-US` -> `fa-IR`
Englisch –> Indonesisch (Indonesien)	`en-US` -> `id-ID`
Englisch -> Japanisch (Japan)	`en-US` -> `ja-JP`
Englisch -> Lettisch (Lettland)	`en-US` -> `lv-LV`
Englisch –> Mongolisch (Mongolei)	`en-US` -> `mn-MN`
Englisch -> Slowenisch (Slowenien)	`en-US` -> `sl-SI`
Englisch -> Schwedisch (Schweden)	`en-US` -> `sv-SE`
Englisch -> Tamil (Indien)	`en-US` -> `ta-IN`
Englisch -> Türkisch (Türkei)	`en-US` -> `tr-TR`
Englisch –> Chinesisch (vereinfacht, China)	`en-US` -> `cmn-Hans-CN`

Funktionsunterstützung und Einschränkungen

Chirp 2 unterstützt die folgenden Funktionen:

Funktion	Beschreibung
Automatische Zeichensetzung	Sie werden automatisch vom Modell generiert und können optional deaktiviert werden.
Automatische Großschreibung	Sie werden automatisch vom Modell generiert und können optional deaktiviert werden.
Sprachanpassung (Biasing)	Geben Sie dem Modell Hinweise in Form von einfachen Wörtern oder Wortgruppen, um die Erkennungsgenauigkeit für bestimmte Begriffe oder Eigennamen zu verbessern. Klassentokens oder benutzerdefinierte Klassen werden nicht unterstützt.
Zeitstempel für Worte	Sie werden automatisch vom Modell generiert und können optional aktiviert werden. Möglicherweise verschlechtert sich die Qualität und Geschwindigkeit der Transkription leicht.
Obszönitätenfilter	Anstößige Wörter erkennen und nur den ersten Buchstaben gefolgt von Sternchen im Transkript zurückgeben (z. B. f***).
Sprachunabhängige Audiotranskription	Das Modell leitet die gesprochene Sprache in Ihrer Audiodatei automatisch ab und transkribiert in der vorherrschenden Sprache.
Sprachspezifische Übersetzung	Das Modell übersetzt automatisch von der gesprochenen Sprache in die Zielsprache.
Erzwungene Normalisierung	Wenn sie im Anfragetext definiert sind, führt die API String-Ersetzungen für bestimmte Begriffe oder Wortgruppen durch, um die Konsistenz der Transkription zu gewährleisten.
Konfidenzwerte auf Wortebene	Die API gibt einen Wert zurück, es ist jedoch kein echter Konfidenzwert. Bei der Übersetzung werden keine Konfidenzwerte zurückgegeben.
Geräuschfilter und SNR-Filterung	Entfernen Sie Rauschen aus dem Audio, bevor Sie es an das Modell senden. Audio-Segmente herausfiltern, wenn das SNR unter dem angegebenen Schwellenwert liegt.

Chirp 2 unterstützt die folgenden Funktionen nicht:

Funktion	Beschreibung
Diarisierung	Nicht unterstützt
Spracherkennung	Nicht unterstützt

Mit Chirp 2 transkribieren

Hier erfahren Sie, wie Sie Chirp 2 für Ihre Transkriptions- und Übersetzungsanforderungen verwenden können.

Streamingspracherkennung ausführen

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")

def transcribe_streaming_chirp2(
    audio_file: str
) -> cloud_speech.StreamingRecognizeResponse:
    """Transcribes audio from audio file stream using the Chirp 2 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="us-central1-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_2",
    )
    streaming_config = cloud_speech.StreamingRecognitionConfig(
        config=recognition_config
    )
    config_request = cloud_speech.StreamingRecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/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

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")

def transcribe_sync_chirp2(
    audio_file: str
) -> cloud_speech.RecognizeResponse:
    """Transcribes an audio file using the Chirp 2 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="us-central1-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_2",
    )

    request = cloud_speech.RecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/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

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")

def transcribe_batch_chirp2(
    audio_uri: str,
) -> cloud_speech.BatchRecognizeResults:
    """Transcribes an audio file from a Google Cloud Storage URI using the Chirp 2 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="us-central1-speech.googleapis.com",
        )
    )

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

    file_metadata = cloud_speech.BatchRecognizeFileMetadata(uri=audio_uri)

    request = cloud_speech.BatchRecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/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 2-Funktionen verwenden

Hier finden Sie Codebeispiele für die Verwendung der neuesten Funktionen:

Sprachunabhängige Transkription durchführen

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")

def transcribe_sync_chirp2_auto_detect_language(
    audio_file: str
) -> cloud_speech.RecognizeResponse:
    """Transcribes an audio file and auto-detect spoken language using Chirp 2.
    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="us-central1-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_2",
    )

    request = cloud_speech.RecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/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

Live-Dolmetscher verwenden

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")

def translate_sync_chirp2(
    audio_file: str
) -> cloud_speech.RecognizeResponse:
    """Translates an audio file using Chirp 2.
    Args:
        audio_file (str): Path to the local audio file to be translated.
            Example: "resources/audio.wav"
    Returns:
        cloud_speech.RecognizeResponse: The response from the Speech-to-Text API containing
        the translated results.
    """

    # Instantiates a client
    client = SpeechClient(
        client_options=ClientOptions(
            api_endpoint="us-central1-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=["fr-FR"],  # Set language code to targeted to detect language.
        translation_config=cloud_speech.TranslationConfig(target_language="fr-FR"), # Set target language code.
        model="chirp_2",
    )

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

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

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

    return response

Zeitstempel auf Wortebene aktivieren

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")

def transcribe_sync_chirp2_with_timestamps(
    audio_file: str
) -> cloud_speech.RecognizeResponse:
    """Transcribes an audio file using the Chirp 2 model of Google Cloud Speech-to-Text V2 API, providing 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="us-central1-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_2",
        features=cloud_speech.RecognitionFeatures(
            enable_word_time_offsets=True, # Enabling word-level timestamps
        )
    )

    request = cloud_speech.RecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/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

Genauigkeit durch Modellanpassung verbessern

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")

def transcribe_sync_chirp2_model_adaptation(
    audio_file: str
) -> cloud_speech.RecognizeResponse:
    """Transcribes an audio file using the Chirp 2 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="us-central1-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_2",
        # 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/us-central1/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

Details zu Denoiser und SNR-Filterung

Mit denoiser_audio=true können Sie Hintergrundmusik oder Geräusche wie Regen und Straßenverkehr effektiv reduzieren. Hinweis: Hintergrundstimmen können nicht entfernt werden.

Mit snr_threshold=X können Sie die Mindestlautstärke für die Transkription festlegen. So werden Audioinhalte, die keine Sprache enthalten, 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 gesamte SNR des Audiosignals wird erhöht.

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-Rauschen entfernen	SNR-Grenzwert	Empfindlichkeit für Sprache
wahr	10	hoch
wahr	20,0	Mittel
wahr	40,0	niedrig
wahr	100,0	sehr niedrig
falsch	0,5	hoch
falsch	1,0	Mittel
falsch	2.0	niedrig
falsch	5,0	sehr niedrig

Rauschunterdrückung und SNR-Filterung aktivieren

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")

def transcribe_sync_chirp2_with_timestamps(
    audio_file: str
) -> cloud_speech.RecognizeResponse:
    """Transcribes an audio file using the Chirp 2 model of Google Cloud Speech-to-Text V2 API, providing 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="us-central1-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_2",
        denoiser_config={
            denoise_audio: True,
            # Medium snr threshold
            snr_threshold: 20.0,
        }
    )

    request = cloud_speech.RecognizeRequest(
        recognizer=f"projects/{PROJECT_ID}/locations/us-central1/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 2 in der Google Cloud Console verwenden

Achten Sie darauf, dass Sie sich für ein Google Cloud-Konto registriert und ein Projekt erstellt haben.
Rufen Sie in der Google Cloud Console Speech auf.
Aktivieren Sie die API, falls sie noch nicht aktiviert ist.
Sie benötigen einen STT-Konsolen-Arbeitsbereich. Erstellen Sie einen Arbeitsbereich, falls Sie noch keinen haben.
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 – Universal Speech Model 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 auszuführen.
Sehen Sie sich das Chirp 2-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.

Bereinigen

Mit den folgenden Schritten vermeiden Sie, dass Ihrem Google Cloud -Konto die auf dieser Seite verwendeten Ressourcen in Rechnung gestellt werden:

Optional: Revoke the authentication credentials that you created, and delete the local credential file.
```
gcloud auth application-default revoke
```
Optional: Revoke credentials from the gcloud CLI.
```
gcloud auth revoke
```

Console

Achtung: Das Löschen von Projekten hat folgende Auswirkungen:

Alle Inhalte des Projekts werden gelöscht. Wenn Sie für die Aufgaben in diesem Dokument ein bereits bestehendes Projekt verwendet haben und dieses löschen, werden auch alle anderen im Rahmen des Projekts erstellten Daten gelöscht.
Benutzerdefinierte Projekt-IDs gehen verloren. Beim Erstellen dieses Projekts haben Sie möglicherweise eine benutzerdefinierte Projekt-ID erstellt, die Sie weiterhin verwenden möchten. Damit die URLs, die die Projekt-ID nutzen, z. B. eine appspot.com-URL, erhalten bleiben, sollten Sie ausgewählte Ressourcen innerhalb des Projekts löschen, statt das gesamte Projekt.

Wenn Sie mehrere Architekturen, Anleitungen und Kurzanleitungen durcharbeiten möchten, können Sie die Überschreitung von Projektkontingenten verhindern, indem Sie Projekte wiederverwenden.

In the Google Cloud console, go to the Manage resources page.

Go to Manage resources

In the project list, select the project that you want to delete, and then click Delete.

In the dialog, type the project ID, and then click Shut down to delete the project.

gcloud