Esta página se ha traducido con Cloud Translation API.

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ñada para satisfacer las necesidades de los usuarios en función de sus comentarios y su experiencia. Mejora el modelo Chirp original en cuanto a precisión y velocidad, además de incorporar nuevas funciones clave, como marcas de tiempo a nivel de palabra, adaptación de modelos y traducción de voz.

Probar un cuaderno de Colab

Ver cuaderno en GitHub

Detalles del modelo

Chirp 2 solo está disponible en la versión 2 de la API Speech-to-Text.

Identificadores de modelo

Puedes usar Chirp 2 como cualquier otro modelo. Para ello, especifica el identificador de modelo adecuado en tu solicitud de reconocimiento al usar la API o el nombre del modelo en la Google Cloud consola.

Modelo	Identificador de modelo
Chirp 2	`chirp_2`

Métodos de la API

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

Modelo	Identificador de modelo	Idiomas disponibles
`V2`	`Speech.StreamingRecognize` (ideal para streaming y audio en tiempo real)	Limitado*
`V2`	`Speech.Recognize` (ideal para audios cortos de menos de 1 minuto)	A la altura de Chirp
`V2`	`Speech.BatchRecognize` (ideal para audios largos, de 1 minuto a 8 horas)	A la altura de Chirp

*Siempre puedes consultar la lista más reciente de idiomas y funciones admitidos de cada modelo de transcripción mediante la API Locations.

Disponibilidad regional

Chirp 2 está disponible en las siguientes zonas:

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

Puedes consultar la lista más reciente de regiones, idiomas y funciones admitidos Google Cloud para cada modelo de transcripción mediante la API Locations, tal como se explica aquí.

Idiomas disponibles para la transcripción

Chirp 2 admite la transcripción en los métodos de reconocimiento StreamingRecognize, Recognize y BatchRecognize. Sin embargo, la disponibilidad de idiomas varía en función del método utilizado. En concreto, 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 (EE. UU.)	`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`

Idiomas disponibles para traducir

Estos son los idiomas disponibles para la traducción por voz. Ten en cuenta que la compatibilidad con idiomas de Chirp 2 para la traducción no es simétrica. Esto significa que, aunque podamos traducir del idioma A al idioma B, es posible que no podamos traducir del idioma B al idioma A. Se admiten los siguientes pares de idiomas para la traducción por voz.

Para traducir al inglés:

Idioma de origen -> Idioma de destino	Código de idioma de origen -> Código de idioma de destino
Árabe (Egipto) -> Inglés	`ar-EG` -> `en-US`
Árabe (Golfo) -> Inglés	`ar-x-gulf` -> `en-US`
Árabe (levantino) -> 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`
Neerlandé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 traducir del inglés:

Idioma de origen -> Idioma de destino	Código de idioma de origen -> Código de idioma de destino
Inglés -> Árabe (Egipto)	`en-US` -> `ar-EG`
Inglés -> Árabe (Golfo)	`en-US` -> ar-`x-gulf`
Inglés -> Árabe (levantino)	`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 (Turquía)	`en-US` -> `tr-TR`
Inglés -> Chino (simplificado, China)	`en-US` -> `cmn-Hans-CN`

Asistencia 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)	Ofrece sugerencias al modelo en forma de palabras o frases sencillas para mejorar la precisión del reconocimiento de términos o nombres propios específicos. No se admiten tokens de clase ni clases personalizadas.
Tiempos de las palabras (marcas de tiempo)	Se genera automáticamente mediante el modelo y se puede habilitar de forma opcional. Es posible que la calidad y la velocidad de la transcripción se reduzcan ligeramente.
Filtro de palabras malsonantes	Detecta palabras malsonantes y devuelve solo la primera letra seguida de asteriscos en la transcripción (por ejemplo, c***).
Transcripción de audio independiente del idioma	El modelo infiere automáticamente el idioma hablado en tu archivo de audio y lo transcribe al idioma más predominante.
Traducción específica de un 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 sustituirá cadenas de texto por términos o frases específicos para asegurar la coherencia de la transcripción.
Puntuaciones de confianza a nivel de palabra	La API devuelve un valor, pero no es una puntuación de confianza. En el caso de la traducción, no se devuelven las puntuaciones de confianza.
Cancelación de ruido y filtrado de SNR	Elimina el ruido del audio antes de enviarlo al modelo. Filtrar 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 se admite
Detección de idioma	No se admite

Transcribir con Chirp 2

Descubre cómo usar Chirp 2 para transcribir y traducir.

Realizar el reconocimiento de voz en streaming

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

Realizar un 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

Realizar el 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

Usar las funciones de Chirp 2

Descubre cómo puedes usar las últimas funciones con ejemplos de código:

Hacer una transcripción sin tener en cuenta el 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

Hacer una 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

Habilitar 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

Mejorar la precisión 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 relación señal/ruido

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 eliminador de ruido no puede eliminar las voces humanas de fondo.

Puedes definir snr_threshold=X para controlar el volumen mínimo de la voz necesario para la transcripción. De esta forma, se filtra el audio que no es de 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 tiene que hablar más alto para que el modelo transcriba las expresiones.

El filtrado de SNR se puede utilizar en casos prácticos de streaming en tiempo real para evitar enviar sonidos innecesarios a un modelo para la transcripción. Si el valor de este ajuste es más alto, el volumen de tu voz debe ser más alto en relación con el ruido de fondo para que se envíe 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 elimina el ruido de fondo y la voz se oye con más claridad. La relación señal/ruido general del audio aumenta.

Si tu caso práctico solo implica la voz del usuario sin que hablen otras personas, define denoise_audio=true para aumentar la sensibilidad del filtro de SNR, que puede filtrar el ruido que no sea del habla. Si tu caso práctico implica que hay personas hablando en segundo plano y quieres evitar que se transcriba lo que dicen, te recomendamos que definas denoise_audio=false y que reduzcas el umbral de la relación señal/ruido.

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

Reducir el ruido del audio	Umbral de SNR	Sensibilidad de la voz
true	10,0	alto
true	20,0	medio
true	40,0	bajo
true	100,0	muy baja
falso	0,5	alto
falso	1.0	medio
falso	2,0	bajo
falso	5,0	muy baja

Habilitar la reducción de ruido y el filtro 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

Usar Chirp 2 en la Google Cloud consola

Asegúrate de que te has registrado para obtener una cuenta de Google Cloud y has creado un proyecto.
Ve a Voz en la consola de Google Cloud .
Habilita la API si aún no lo has hecho.
Asegúrate de tener una consola de STT Workspace. Si aún no tienes uno, debes crear un espacio de trabajo.
1. Ve a la página de transcripciones y haz clic en Nueva transcripción.
2. Abre el menú desplegable Espacio de trabajo y haz clic en Nuevo espacio de trabajo para crear un espacio de trabajo para la transcripción.
3. En la barra lateral de navegación Crear un espacio de trabajo, haz clic en Buscar.
4. Haga clic para crear un nuevo contenedor.
5. Escribe el nombre del contenedor y haz clic en Continuar.
6. Haz clic en Crear para crear el segmento de Cloud Storage.
7. Una vez creado el segmento, haz clic en Seleccionar para usarlo.
8. Haz clic en Crear para terminar de crear tu espacio de trabajo en la consola de la API Speech-to-Text V2.
Transcribe el audio.

En la página Nueva transcripción, selecciona el archivo de audio que quieras subir (Subida local) o especifica un archivo de Cloud Storage (Cloud Storage).
Haz clic en Continuar para ir a las Opciones de transcripción.
1. Selecciona el idioma hablado que quieras usar para el reconocimiento con Chirp en el reconocedor que hayas creado.
2. En el menú desplegable de modelos, selecciona Chirp - Universal Speech Model (Chirp - Modelo universal de voz).
3. En el menú desplegable Reconocedor, selecciona el reconocedor que acabas de crear.
4. Haz clic en Enviar para ejecutar tu primera solicitud de reconocimiento con Chirp.
Consulta el resultado de la transcripción de Chirp 2.
1. En la página Transcripciones, haga clic en el nombre de la transcripción para ver el resultado.
2. En la página Detalles de la transcripción, consulta el resultado de la transcripción y, si quieres, reproduce el audio en el navegador.

Limpieza

Para evitar que se apliquen cargos en tu cuenta de Google Cloud por los recursos utilizados 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
```

Consola

Precaución: Eliminar un proyecto tiene los siguientes efectos:

Se elimina todo el contenido del proyecto. Si has usado un proyecto que ya existía para las tareas de este documento, cuando lo elimines, también se eliminará cualquier otro trabajo que hayas realizado en él.
Se pierden los IDs de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID de proyecto personalizado que quieras usar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, elimina los recursos seleccionados dentro del proyecto en lugar de eliminar todo el proyecto.

Si tienes previsto consultar varias arquitecturas, tutoriales o guías de inicio rápido, reutilizar los proyectos puede ayudarte a no superar los límites de cuota de proyectos.

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