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

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 para el reconocimiento de voz automático (ASR) de Google, diseñados para satisfacer las necesidades de los usuarios en función de sus comentarios y experiencias. Chirp 3 ofrece mayor precisión y velocidad que los modelos anteriores de Chirp, y proporciona diarización y detección automática de idiomas.

Detalles del modelo

Chirp 3: Transcripción, está disponible exclusivamente en la API de Speech-to-Text V2.

Identificadores de modelo

Puedes usar Chirp 3: Transcription como cualquier otro modelo. Para ello, especifica 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 . Especifica el identificador adecuado en tu reconocimiento.

Modelo	Identificador del 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 de Speech-to-Text V2, admite los siguientes métodos de reconocimiento:

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

Disponibilidad regional

Chirp 3 está disponible en las siguientes Google Cloud regiones, y se planean más:

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

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

Disponibilidad de idiomas 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`	DG
Chino (simplificado, China)	`cmn-Hans-CN`	DG
Croata (Croacia)	`hr-HR`	DG
Danés (Dinamarca)	`da-DK`	DG
Holandés (Países Bajos)	`nl-NL`	DG
inglés (Australia)	`en-AU`	DG
Inglés (Reino Unido)	`en-GB`	DG
Inglés (India)	`en-IN`	DG
Inglés (Estados Unidos)	`en-US`	DG
Finés (Finlandia)	`fi-FI`	DG
Francés (Canadá)	`fr-CA`	DG
Francés (Francia)	`fr-FR`	DG
Alemán (Alemania)	`de-DE`	DG
Griego (Grecia)	`el-GR`	DG
Hindi (India)	`hi-IN`	DG
Italiano (Italia)	`it-IT`	DG
Japonés (Japón)	`ja-JP`	DG
Coreano (Corea)	`ko-KR`	DG
Polaco (Polonia)	`pl-PL`	DG
Portugués (Brasil)	`pt-BR`	DG
Portugués (Portugal)	`pt-PT`	DG
Rumano (Rumania)	`ro-RO`	DG
Ruso (Rusia)	`ru-RU`	DG
Español (España)	`es-ES`	DG
Español (Estados Unidos)	`es-US`	DG
Sueco (Suecia)	`sv-SE`	DG
Turco (Turquía)	`tr-TR`	DG
Ucraniano (Ucrania)	`uk-UA`	DG
Vietnamita (Vietnam)	`vi-VN`	DG
Á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 (Catar)	`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 (Birmania)	`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
Inglés (Filipinas)	`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
Malabar (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
Suajili	`sw`	Vista previa
Tamil (India)	`ta-IN`	Vista previa
Telugu (India)	`te-IN`	Vista previa
Tailandés (Tailandia)	`th-TH`	Vista previa
Uzbeko (Uzbekistán)	`uz-UZ`	Vista previa

Idiomas disponibles para la identificación del interlocutor

Chirp 3 admite la transcripción y la diarización solo 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
Español (Latinoamérica)	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

Compatibilidad y limitaciones de funciones

Chirp 3 admite las siguientes funciones:

Función	Descripción	Etapa de lanzamiento
Puntuación automática	Se genera automáticamente por el modelo y se puede inhabilitar de forma opcional.	DG
Uso automático de mayúsculas	Se genera automáticamente por el modelo y se puede inhabilitar de forma opcional.	DG
Marcas de tiempo a nivel de la expresión	El modelo la genera automáticamente.	DG
Identificación de interlocutores	Identifica automáticamente los diferentes interlocutores en una muestra de audio de un solo canal. Solo disponible en `BatchRecognize`	DG
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 específicos o nombres propios.	DG
Transcripción de audio independiente del idioma	Infiere y transcribe automáticamente en el idioma más frecuente.	DG

Chirp 3 no admite las siguientes funciones:

Función	Descripción
Marcas de tiempo a nivel de palabra	Se genera automáticamente con el modelo y se puede habilitar de forma opcional, lo que genera cierta degradación 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.

Transcribe con Chirp 3

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

Realiza reconocimiento de voz en vivo

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

Realiza 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

Realiza 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

Usa las funciones de Chirp 3

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

Realiza una transcripción independiente del idioma

Chirp 3 puede identificar y transcribir automáticamente el idioma dominante que se habla en el audio, lo que es esencial para las aplicaciones multilingües. Para lograr esto, establece 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

Realiza una transcripción restringida por idioma

Chirp 3 puede identificar y transcribir automáticamente el idioma dominante en un archivo de audio. También puedes condicionarlo a configuraciones regionales específicas que esperas, por ejemplo: ["en-US", "fr-FR"], que enfocaría los recursos del modelo en los idiomas más probables para obtener resultados más confiables, como se demuestra 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

Realiza la transcripción y la identificación de interlocutores

Usa Chirp 3 para tareas de transcripción y segmentación por orador.

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

Mejora la exactitud con la adaptación de modelos

Chirp 3 puede mejorar la exactitud de la transcripción de tu audio específico con la adaptación del modelo. Esto te permite 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 del 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

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

Chirp 3 puede 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 integrado y el filtro de relación señal-ruido (SNR).

El ajuste denoiser_audio=true puede ayudarte a reducir la música o los ruidos de fondo, como la lluvia y el tráfico de la calle.

Puedes configurar snr_threshold=X para controlar el volumen mínimo del habla necesario 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. El SNR general del audio aumenta.

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.

Cancelar ruido del audio	Umbral de SNR	Sensibilidad a 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

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

Usa Chirp 3 en la consola de Google Cloud

Regístrate para obtener una cuenta de Google Cloud y crea un proyecto.
Ve a Speech en la consola de Google Cloud .
Si la API no está habilitada, habilítala.
Asegúrate de tener un lugar de trabajo de la consola de STT. Si no tienes un espacio de trabajo, debes crear uno.
1. Ve a 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_3.
3. En el menú desplegable Reconocimiento, selecciona el reconocedor que creaste recientemente.
4. Haz clic en Enviar para ejecutar tu primera solicitud de reconocimiento con chirp_3.
Visualiza el resultado de la transcripción de Chirp 3.
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.

¿Qué sigue?

Obtén más información para transcribir archivos de audio cortos.
Obtén más información sobre cómo transcribir audio con transmisión continua.
Obtén información sobre cómo transcribir archivos de audio largos.
Para mejorar el rendimiento y la exactitud, así como ver otras sugerencias, consulta la documentación de prácticas recomendadas.

Transcripción de Chirp 3: Mayor precisión en varios idiomas Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Detalles del modelo

Identificadores de modelo

Métodos de la API

Disponibilidad regional

Disponibilidad de idiomas para la transcripción

Idiomas disponibles para la identificación del interlocutor

Compatibilidad y limitaciones de funciones

Transcribe con Chirp 3

Realiza reconocimiento de voz en vivo

Python

Realiza reconocimiento de voz síncrono

Python

Realiza reconocimiento de voz por lotes

Python

Usa las funciones de Chirp 3

Realiza una transcripción independiente del idioma

Python

Realiza una transcripción restringida por idioma

Python

Realiza la transcripción y la identificación de interlocutores

Python

Mejora la exactitud con la adaptación de modelos

Python

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

Python

Usa Chirp 3 en la consola de Google Cloud

¿Qué sigue?

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