Se usó la API de Cloud Translation para traducir esta página.

Chirp 2: Precisión multilingüe mejorada

Chirp 2 es la última generación de modelos multilingües específicos de ASR de Google, diseñados para satisfacer las necesidades de los usuarios en función de sus comentarios y experiencias. Mejora el modelo original de Chirp en cuanto a exactitud y velocidad, además de expandirse a nuevas funciones clave, como marcas de tiempo a nivel de palabras, adaptación de modelos y traducción de voz.

Probar un notebook de Colab

Ver el notebook en GitHub

Detalles del modelo

Chirp 2 está disponible exclusivamente en la API de Speech-to-Text V2.

Identificadores de modelo

Puedes utilizar Chirp 2 como cualquier otro modelo especificando el identificador de modelo adecuado en tu solicitud de reconocimiento cuando uses la API o el nombre del modelo en la consola de Google Cloud .

Modelo	Identificador del modelo
Chirp 2	`chirp_2`

Métodos de la API

Como Chirp 2 está disponible exclusivamente en la API de Speech-to-Text V2, admite los siguientes métodos de reconocimiento:

Modelo	Identificador del modelo	Idiomas admitidos
`V2`	`Speech.StreamingRecognize` (bueno para transmisiones y audio en tiempo real)	Limitado*
`V2`	`Speech.Recognize` (bueno para audio corto <1 min)	A la par de Chirp
`V2`	`Speech.BatchRecognize` (bueno para audio largo de 1 minuto a 8 horas)	A la par de Chirp

*Siempre puedes encontrar la lista más reciente de idiomas y funciones compatibles para cada modelo de transcripción con la API de Locations.

Disponibilidad regional

Chirp 2 es compatible con las siguientes regiones:

Google Cloud Zona	Preparación para el lanzamiento
`us-central1`	DG
`europe-west4`	DG
`asia-southeast1`	DG

Siempre puedes encontrar la lista más reciente de Google Cloud regiones, idiomas y funciones admitidos para cada modelo de transcripción con la API de Locations, como se explica aquí.

Disponibilidad de idiomas para la transcripción

Chirp 2 admite la transcripción en los métodos de reconocimiento StreamingRecognize, Recognize y BatchRecognize. Sin embargo, la compatibilidad con idiomas varía según el método utilizado. Específicamente, BatchRecognize ofrece la compatibilidad con idiomas más amplia. StreamingRecognize admite los siguientes idiomas:

Idioma	Código BCP-47
Chino (simplificado, China)	`cmn-Hans-CN`
Chino (tradicional, Taiwán)	`cmn-Hant-TW`
Chino, Cantonés (Tradicional Hong Kong)	`yue-Hant-HK`
inglés (Australia)	`en-AU`
Inglés (India)	`en-IN`
Inglés (Reino Unido)	`en-GB`
Inglés (Estados Unidos)	`en-US`
Francés (Canadá)	`fr-CA`
Francés (Francia)	`fr-FR`
Alemán (Alemania)	`de-DE`
Italiano (Italia)	`it-IT`
Japonés (Japón)	`ja-JP`
Coreano (Corea del Sur)	`ko-KR`
Portugués (Brasil)	`pt-BR`
Español (España)	`es-ES`
Español (Estados Unidos)	`es-US`

Disponibilidad de idiomas para la traducción

Estos son los idiomas admitidos para la traducción de voz. Ten en cuenta que la compatibilidad con idiomas de Chirp 2 para la traducción no es simétrica. Esto significa que, si bien es posible que podamos traducir del idioma A al idioma B, es posible que la traducción del idioma B al idioma A no esté disponible. Los siguientes pares de idiomas son compatibles con la función de Speech-Translation.

Para la traducción al inglés:

Idioma de origen -> Idioma de destino	Código de idioma de origen -> destino
Árabe (Egipto) -> inglés	`ar-EG` -> `en-US`
Árabe () -> Inglés	`ar-x-gulf` -> `en-US`
Árabe (Levante) -> Inglés	`ar-x-levant` -> `en-US`
Árabe (magrebí) -> inglés	`ar-x-maghrebi` -> `en-US`
Catalán (España) -> Inglés	`ca-ES` -> `en-US`
Galés (Reino Unido) -> Inglés	`cy-GB` -> `en-US`
Alemán (Alemania) -> Inglés	`de-DE` -> `en-US`
Español (Latinoamérica) -> Inglés	`es-419` -> `en-US`
Español (España) -> Inglés	`es-ES` -> `en-US`
Español (Estados Unidos) -> Inglés	`es-US` -> `en-US`
Estonio (Estonia) -> Inglés	`et-EE` -> `en-US`
Francés (Canadá) -> Inglés	`fr-CA` -> `en-US`
Francés (Francia) -> Inglés	`fr-FR` -> `en-US`
Persa (Irán) -> inglés	`fa-IR` -> `en-US`
Indonesio (Indonesia) -> Inglés	`id-ID` -> `en-US`
Italiano (Italia) -> Inglés	`it-IT` -> `en-US`
Japonés (Japón) -> Inglés	`ja-JP` -> `en-US`
Letón (Letonia) -> Inglés	`lv-LV` -> `en-US`
Mongol (Mongolia) -> Inglés	`mn-MN` -> `en-US`
Holandés (Países Bajos) -> Inglés	`nl-NL` -> `en-US`
Portugués (Brasil) -> inglés	`pt-BR` -> `en-US`
Ruso (Rusia) -> Inglés	`ru-RU` -> `en-US`
Esloveno (Eslovenia) -> Inglés	`sl-SI` -> `en-US`
Sueco (Suecia) -> Inglés	`sv-SE` -> `en-US`
Tamil (India) -> Inglés	`ta-IN` -> `en-US`
Turco (Turquía) -> Inglés	`tr-TR` -> `en-US`
Chino (simplificado, China) -> inglés	`cmn-Hans-CN` -> `en-US`

Para la traducción del inglés:

Idioma de origen -> Idioma de destino	Código de idioma de origen -> destino
Inglés -> árabe (Egipto)	`en-US` -> `ar-EG`
Inglés -> Árabe ()	`en-US` -> ar-`x-gulf`
Inglés -> Árabe (Levante)	`en-US` -> ar-`x-levant`
Inglés -> Árabe (magrebí)	`en-US` -> ar-`x-maghrebi`
Inglés -> catalán (España)	`en-US` -> `ca-ES`
Inglés -> galés (Reino Unido)	`en-US` -> `cy-GB`
Inglés -> alemán (Alemania)	`en-US` -> `de-DE`
Inglés -> estonio (Estonia)	`en-US` -> `et-EE`
Inglés -> persa (Irán)	`en-US` -> `fa-IR`
Inglés -> indonesio (Indonesia)	`en-US` -> `id-ID`
Inglés -> Japonés (Japón)	`en-US` -> `ja-JP`
Inglés -> letón (Letonia)	`en-US` -> `lv-LV`
Inglés -> Mongol (Mongolia)	`en-US` -> `mn-MN`
Inglés -> esloveno (Eslovenia)	`en-US` -> `sl-SI`
Inglés -> sueco (Suecia)	`en-US` -> `sv-SE`
Inglés -> Tamil (India)	`en-US` -> `ta-IN`
Inglés -> turco (Türkiye)	`en-US` -> `tr-TR`
Inglés -> Chino (simplificado, China)	`en-US` -> `cmn-Hans-CN`

Compatibilidad y limitaciones de funciones

Chirp 2 admite las siguientes funciones:

Función	Descripción
Puntuación automática	Se genera automáticamente por el modelo y se puede inhabilitar de forma opcional.
Uso de mayúsculas automático	Se genera automáticamente por el modelo y se puede inhabilitar de forma opcional.
Adaptación de voz (sesgo)	Proporciona sugerencias al modelo en forma de palabras o frases simples para mejorar la precisión del reconocimiento de términos específicos o nombres propios. No se admiten los tokens de clase ni las clases personalizadas.
Sincronización de palabras (marcas de tiempo)	Se genera automáticamente con el modelo y se puede habilitar de forma opcional. Es posible que la calidad y la velocidad de la transcripción se degraden ligeramente.
Filtro de lenguaje obsceno	Detectar palabras obscenas y mostrar solo la primera letra seguida de asteriscos en la transcripción (por ejemplo, f***).
Transcripción de audio independiente del idioma	El modelo infiere automáticamente el idioma hablado en tu archivo de audio y transcribe en el idioma más frecuente.
Traducción específica para cada idioma	El modelo traduce automáticamente del idioma hablado al idioma de destino.
Normalización forzada	Si se define en el cuerpo de la solicitud, la API realizará reemplazos de cadenas en términos o frases específicos, lo que garantizará la coherencia en la transcripción.
Puntuaciones de confianza a nivel de palabra	La API devuelve un valor, pero no es realmente una puntuación de confianza. En el caso de la traducción, no se devuelven las puntuaciones de confianza.
Cancelador de ruido y filtrado de SNR	Quita el ruido del audio antes de enviarlo al modelo. Filtra los segmentos de audio si la relación señal-ruido es inferior al umbral especificado.

Chirp 2 no admite las siguientes funciones:

Función	Descripción
Diarización	No compatible
Reconocimiento de idioma	No compatible

Transcribe con Chirp 2

Descubre cómo usar Chirp 2 para tus necesidades de transcripción y traducción.

Realiza reconocimiento de voz en vivo

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

Realiza reconocimiento de voz síncrono

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

Realiza reconocimiento de voz por lotes

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

Usa las funciones de Chirp 2

Explora cómo puedes usar las funciones más recientes con ejemplos de código:

Realiza una transcripción independiente del idioma

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

Realizar la traducción de voz

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

Habilita las marcas de tiempo a nivel de palabra

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

Mejora la exactitud con la adaptación de modelos

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

Detalles del filtro de reducción de ruido y del filtro de SNR

denoiser_audio=true puede ayudarte a reducir la música de fondo o los ruidos, como la lluvia y el tráfico de la calle. Ten en cuenta que un reductor de ruido no puede quitar las voces humanas de fondo.

Puedes configurar snr_threshold=X para controlar la sonoridad mínima del habla requerida para la transcripción. Esto ayuda a filtrar el audio que no es voz o el ruido de fondo, lo que evita que aparezca texto no deseado en los resultados. Un valor de snr_threshold más alto significa que el usuario debe hablar más alto para que el modelo transcriba las expresiones.

El filtrado de SNR se puede utilizar en casos de uso de transmisión en tiempo real para evitar enviar sonidos innecesarios a un modelo para su transcripción. Un valor más alto para este parámetro de configuración significa que el volumen de tu voz debe ser más alto en relación con el ruido de fondo para enviarse al modelo de transcripción.

La configuración de snr_threshold interactuará con si denoise_audio es true o false. Cuando denoise_audio=true, se quita el ruido de fondo y la voz se vuelve relativamente más clara. Mejora la relación señal-ruido general del audio.

Si tu caso de uso solo involucra la voz del usuario sin que hablen otras personas, configura denoise_audio=true para aumentar la sensibilidad del filtrado de la relación señal-ruido, que puede filtrar el ruido que no es voz. Si tu caso de uso involucra personas hablando en segundo plano y quieres evitar transcribir el habla en segundo plano, considera configurar denoise_audio=false y reducir el umbral de SNR.

A continuación, se indican los valores de umbral de SNR recomendados. Se puede establecer un valor de snr_threshold razonable entre 0 y 1000. Un valor de 0 significa que no se filtra nada, y 1000 significa que se filtra todo. Ajusta el valor si la configuración recomendada no te funciona.

Cómo quitar el ruido del audio	Umbral de SNR	Sensibilidad de la voz
verdadero	10.0	alto
verdadero	20.0	medio
verdadero	40.0	bajo
verdadero	100.0	muy baja
falso	0.5	alto
falso	1.0	medio
falso	2.0	bajo
falso	5.0	muy baja

Habilita la cancelación de ruido y el filtrado de SNR

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

Usa Chirp 2 en la consola de Google Cloud

Asegúrate de haberte registrado en una cuenta de Google Cloud y creado un proyecto.
Ve a Speech en la consola de Google Cloud .
Habilita la API si aún no está habilitada.
Asegúrate de tener un lugar de trabajo de la consola de STT. Si aún no tienes uno, debes crear un lugar de trabajo.
1. Visita la página de transcripciones y haz clic en Transcripción nueva.
2. Abre el menú desplegable Workspace y haz clic en New Workspace para crear un espacio de trabajo para la transcripción.
3. Desde la barra lateral de navegación Crear un lugar de trabajo nuevo, haz clic en Explorar.
4. Haz clic para crear un bucket nuevo.
5. Ingresa un nombre para tu bucket y haz clic en Continuar.
6. Haz clic en Crear para crear un bucket de Cloud Storage.
7. Una vez que se haya creado el bucket, haz clic en Seleccionar para seleccionar su bucket.
8. Haz clic en Crear para terminar de crear tu lugar de trabajo para la consola de la API de Speech-to-Text V2.
Realiza una transcripción en tu audio real.

En la página Nueva transcripción, selecciona el archivo de audio mediante la carga (Carga local) o especificando un archivo de Cloud Storage existente (Cloud Storage).
Haz clic en Continuar para ir a Opciones de transcripción.
1. Selecciona el lenguaje de voz que planeas usar para el reconocimiento con Chirp de tu reconocedor creado previamente.
2. En el menú desplegable del modelo, selecciona Chirp - Modelo de voz universal.
3. En el menú desplegable Reconocimiento, selecciona el reconocedor que creaste recientemente.
4. Haz clic en Enviar para ejecutar tu primera solicitud de reconocimiento mediante Chirp.
Visualiza el resultado de la transcripción de Chirp 2.
1. En la página Transcripciones, haz clic en el nombre de la transcripción para ver su resultado.
2. En la página Detalles de la transcripción, visualiza el resultado de la transcripción. También tienes la opción de reproducir el audio en el navegador.

Limpia

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos que usaste en esta página, sigue estos pasos.

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

Precaución: Borrar un proyecto tiene las siguientes consecuencias:

Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.

Si planeas explorar varias infraestructuras, instructivos y guías de inicio rápido la reutilización de proyectos puede ayudarte a evitar exceder los límites de las cuotas del proyecto.

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