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

Transcripción de Chirp 3: mayor precisión en varios idiomas

Chirp 3 es la última generación de modelos generativos multilingües específicos de reconocimiento automático del habla (RAA) de Google, diseñados para satisfacer las necesidades de los usuarios en función de sus comentarios y experiencia. Chirp 3 ofrece una mayor precisión y velocidad que los modelos de Chirp anteriores, así como la diarización y la detección automática de idiomas.

Detalles del modelo

Chirp 3: transcripción, solo está disponible en la API Speech-to-Text V2.

Identificadores de modelo

Puedes usar Chirp 3: Transcripción 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. Especifica el identificador adecuado en tu reconocimiento.

Modelo	Identificador de modelo
Chirp 3	`chirp_3`

Métodos de la API

No todos los métodos de reconocimiento admiten los mismos conjuntos de disponibilidad de idiomas. Como Chirp 3 está disponible en la API Speech-to-Text V2, admite los siguientes métodos de reconocimiento:

Versión de la API	Método de la API	Asistencia
V2	Speech.StreamingRecognize (ideal para audio en streaming y en tiempo real)	Compatible
V2	Speech.Recognize (adecuado para audio de menos de un minuto)	Compatible
V2	Speech.BatchRecognize (adecuado para audio largo, de 1 minuto a 1 hora)	Compatible

Disponibilidad regional

Chirp 3 está disponible en las siguientes Google Cloud regiones y tenemos previsto ampliar la lista:

Google Cloud Zona	Preparación para el lanzamiento
`us(multi-region)`	GA
`eu(multi-region)`	GA
`asia-southeast1`	GA
`asia-northeast1`	GA

Si usas la API Locations, tal como se explica en este artículo, puedes consultar la lista más reciente de Google Cloud regiones, idiomas, configuraciones regionales y funciones admitidos para cada modelo de transcripción.

Idiomas disponibles para la transcripción

Chirp 3 admite la transcripción en StreamingRecognize, Recognize y BatchRecognize en los siguientes idiomas:

Idioma	`BCP-47 Code`	Preparación para el lanzamiento
Catalán (España)	`ca-ES`	GA
Chino (simplificado, China)	`cmn-Hans-CN`	GA
Croata (Croacia)	`hr-HR`	GA
Danés (Dinamarca)	`da-DK`	GA
Neerlandés (Países Bajos)	`nl-NL`	GA
Inglés (Australia)	`en-AU`	GA
Inglés (Reino Unido)	`en-GB`	GA
Inglés (India)	`en-IN`	GA
Inglés (EE. UU.)	`en-US`	GA
Finés (Finlandia)	`fi-FI`	GA
Francés (Canadá)	`fr-CA`	GA
Francés (Francia)	`fr-FR`	GA
Alemán (Alemania)	`de-DE`	GA
Griego (Grecia)	`el-GR`	GA
Hindi (India)	`hi-IN`	GA
Italiano (Italia)	`it-IT`	GA
Japonés (Japón)	`ja-JP`	GA
Coreano (Corea)	`ko-KR`	GA
Polaco (Polonia)	`pl-PL`	GA
Portugués (Brasil)	`pt-BR`	GA
Portugués (Portugal)	`pt-PT`	GA
Rumano (Rumanía)	`ro-RO`	GA
Ruso (Rusia)	`ru-RU`	GA
Español (España)	`es-ES`	GA
Español (Estados Unidos)	`es-US`	GA
Sueco (Suecia)	`sv-SE`	GA
Turco (Turquía)	`tr-TR`	GA
Ucraniano (Ucrania)	`uk-UA`	GA
Vietnamita (Vietnam)	`vi-VN`	GA
Árabe	`ar-XA`	Vista previa
Árabe (Argelia)	`ar-DZ`	Vista previa
Árabe (Baréin)	`ar-BH`	Vista previa
Árabe (Egipto)	`ar-EG`	Vista previa
Árabe (Israel)	`ar-IL`	Vista previa
Árabe (Jordania)	`ar-JO`	Vista previa
Árabe (Kuwait)	`ar-KW`	Vista previa
Árabe (Líbano)	`ar-LB`	Vista previa
Árabe (Mauritania)	`ar-MR`	Vista previa
Árabe (Marruecos)	`ar-MA`	Vista previa
Árabe (Omán)	`ar-OM`	Vista previa
Árabe (Qatar)	`ar-QA`	Vista previa
Árabe (Arabia Saudita)	`ar-SA`	Vista previa
Árabe (Estado de Palestina)	`ar-PS`	Vista previa
Árabe (Siria)	`ar-SY`	Vista previa
Árabe (Túnez)	`ar-TN`	Vista previa
Árabe (Emiratos Árabes Unidos)	`ar-AE`	Vista previa
Árabe (Yemen)	`ar-YE`	Vista previa
Armenio (Armenia)	`hy-AM`	Vista previa
Bengalí (Bangladés)	`bn-BD`	Vista previa
Bengalí (India)	`bn-IN`	Vista previa
Búlgaro (Bulgaria)	`bg-BG`	Vista previa
Birmano (Myanmar)	`my-MM`	Vista previa
Kurdo central (Irak)	`ar-IQ`	Vista previa
Chino cantonés (tradicional, Hong Kong)	`yue-Hant-HK`	Vista previa
Chino mandarín (tradicional, Taiwán)	`cmn-Hant-TW`	Vista previa
Checo (República Checa)	`cs-CZ`	Vista previa
English (Philippines)	`en-PH`	Vista previa
Estonio (Estonia)	`et-EE`	Vista previa
Filipino (Filipinas)	`fil-PH`	Vista previa
Guyaratí (India)	`gu-IN`	Vista previa
Hebreo (Israel)	`iw-IL`	Vista previa
Húngaro (Hungría)	`hu-HU`	Vista previa
Indonesio (Indonesia)	`id-ID`	Vista previa
Canarés (India)	`kn-IN`	Vista previa
Jemer (Camboya)	`km-KH`	Vista previa
Lao (Laos)	`lo-LA`	Vista previa
Letón (Letonia)	`lv-LV`	Vista previa
Lituano (Lituania)	`lt-LT`	Vista previa
Malayo (Malasia)	`ms-MY`	Vista previa
Malayalam (India)	`ml-IN`	Vista previa
Maratí (India)	`mr-IN`	Vista previa
Nepalí (Nepal)	`ne-NP`	Vista previa
Noruego (Noruega)	`no-NO`	Vista previa
Persa (Irán)	`fa-IR`	Vista previa
Serbio (Serbia)	`sr-RS`	Vista previa
Eslovaco (Eslovaquia)	`sk-SK`	Vista previa
Esloveno (Eslovenia)	`sl-SI`	Vista previa
Español (México)	`es-MX`	Vista previa
Swahili	`sw`	Vista previa
Tamil (India)	`ta-IN`	Vista previa
Telugu (India)	`te-IN`	Vista previa
Tailandés (Tailandia)	`th-TH`	Vista previa
Uzbeco (Uzbekistán)	`uz-UZ`	Vista previa

Idiomas disponibles para la diarización

Chirp 3 solo admite la transcripción y la diarización en BatchRecognize y Recognize en los siguientes idiomas:

Idioma	Código BCP-47
Chino (simplificado, China)	cmn-Hans-CN
Alemán (Alemania)	de-DE
Inglés (Reino Unido)	en-GB
Inglés (India)	en-IN
Inglés (EE. UU.)	en-US
Español (España)	es-ES
Español (Estados Unidos)	es-US
Francés (Canadá)	fr-CA
Francés (Francia)	fr-FR
Hindi (India)	hi-IN
Italiano (Italia)	it-IT
Japonés (Japón)	ja-JP
Coreano (Corea)	ko-KR
Portugués (Brasil)	pt-BR

Asistencia y limitaciones de funciones

Chirp 3 admite las siguientes funciones:

Función	Descripción	Fase de lanzamiento
Puntuación automática	Se genera automáticamente por el modelo y se puede inhabilitar de forma opcional.	GA
Uso de mayúsculas automático	Se genera automáticamente por el modelo y se puede inhabilitar de forma opcional.	GA
Marcas de tiempo a nivel de enunciado	Generado automáticamente por el modelo.	GA
Diarización de interlocutores	Identifica automáticamente a los diferentes interlocutores en una muestra de audio de un solo canal. Disponible solo en `BatchRecognize`	GA
Adaptación de voz (sesgo)	Proporciona sugerencias al modelo en forma de frases o palabras para mejorar la precisión del reconocimiento de términos o nombres propios específicos.	GA
Transcripción de audio independiente del idioma	Infiere y transcribe automáticamente en el idioma más habitual.	GA

Chirp 3 no admite las siguientes funciones:

Función	Descripción
Marcas de tiempo a nivel de palabra	El modelo lo genera automáticamente y se puede habilitar de forma opcional, aunque es posible que la transcripción se vea afectada.
Puntuaciones de confianza a nivel de palabra	La API devuelve un valor, pero no es una puntuación de confianza.

Transcribir con Chirp 3

Descubre cómo usar Chirp 3 para tareas de transcripción.

Realizar el reconocimiento de voz en streaming

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

Realizar un reconocimiento de voz síncrono

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

Realizar el reconocimiento de voz por lotes

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

Usar las funciones de Chirp 3

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

Hacer una transcripción sin tener en cuenta el idioma

Chirp 3 puede identificar y transcribir automáticamente el idioma predominante que se habla en el audio, lo cual es esencial para las aplicaciones multilingües. Para ello, defina language_codes=["auto"] como se indica en el ejemplo de código:

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

Hacer una transcripción en un idioma concreto

Chirp 3 puede identificar y transcribir automáticamente el idioma predominante de un archivo de audio. También puedes condicionarlo a las configuraciones regionales específicas que esperas, por ejemplo: ["en-US", "fr-FR"], que centraría los recursos del modelo en los idiomas más probables para obtener resultados más fiables, como se muestra en el ejemplo de código:

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

Realizar la transcripción y la diarización de interlocutores

Usa Chirp 3 para las tareas de transcripción y diarización.

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

Mejorar la precisión con la adaptación de modelos

Chirp 3 puede mejorar la precisión de las transcripciones de tu audio específico mediante la adaptación de modelos. De esta forma, puedes proporcionar una lista de palabras y frases específicas, lo que aumenta la probabilidad de que el modelo las reconozca. Es especialmente útil para términos específicos de un dominio, nombres propios o vocabulario único.

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

Habilitar la reducción de ruido y el filtro de SNR

Los Chirp 3 pueden mejorar la calidad del audio reduciendo el ruido de fondo y filtrando los sonidos no deseados antes de la transcripción. Puedes mejorar los resultados en entornos ruidosos habilitando el filtro de reducción de ruido y la relación señal/ruido (SNR) integrados.

Configurar 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.

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

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

Usar Chirp 3 en la Google Cloud consola

Regístrate para obtener una cuenta de Google Cloud y crea un proyecto.
Ve a Voz en la Google Cloud consola.
Si la API no está habilitada, habilítala.
Asegúrate de tener una consola de STT Workspace. Si no tienes un espacio de trabajo, debes crear uno.
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_3.
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_3.
Consulta el resultado de la transcripción de Chirp 3.
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.

Siguientes pasos

Consulta cómo transcribir archivos de audio cortos.
Consulta cómo transcribir audio de streaming.
Consulta cómo transcribir archivos de audio largos.
Para obtener el mejor rendimiento, precisión y otros consejos, consulta la documentación sobre las prácticas recomendadas.

Transcripción de Chirp 3: mayor precisión en varios idiomas Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Detalles del modelo

Identificadores de modelo

Métodos de la API

Disponibilidad regional

Idiomas disponibles para la transcripción

Idiomas disponibles para la diarización

Asistencia y limitaciones de funciones

Transcribir con Chirp 3

Realizar el reconocimiento de voz en streaming

Python

Realizar un reconocimiento de voz síncrono

Python

Realizar el reconocimiento de voz por lotes

Python

Usar las funciones de Chirp 3

Hacer una transcripción sin tener en cuenta el idioma

Python

Hacer una transcripción en un idioma concreto

Python

Realizar la transcripción y la diarización de interlocutores

Python

Mejorar la precisión con la adaptación de modelos

Python

Habilitar la reducción de ruido y el filtro de SNR

Python

Usar Chirp 3 en la Google Cloud consola

Siguientes pasos

Transcripción de Chirp 3: mayor precisión en varios idiomas