Cette page a été traduite par l'API Cloud Translation.

Transcription Chirp 3 : précision multilingue améliorée

Chirp 3 est la dernière génération de modèles génératifs multilingues de reconnaissance vocale automatique (ASR) de Google. Ils sont conçus pour répondre aux besoins des utilisateurs en fonction de leurs commentaires et de leur expérience. Chirp 3 offre une précision et une vitesse améliorées par rapport aux modèles Chirp précédents, ainsi que la diarisation et la détection automatique de la langue.

Informations sur le modèle

Chirp 3 : Transcription est disponible exclusivement dans l'API Speech-to-Text V2.

Identifiants de modèle

Vous pouvez utiliser Chirp 3 : Transcription comme n'importe quel autre modèle en spécifiant l'identifiant de modèle approprié dans votre requête de reconnaissance lorsque vous utilisez l'API ou le nom du modèle dans la console Google Cloud . Spécifiez l'identifiant approprié dans votre reconnaissance.

Modèle	Identifiant du modèle
Chirp 3	`chirp_3`

Méthodes d'API

Les ensembles de langues disponibles ne sont pas les mêmes pour toutes les méthodes de reconnaissance. Étant donné que Chirp 3 est disponible dans l'API Speech-to-Text V2, il est compatible avec les méthodes de reconnaissance suivantes :

Version de l'API	Méthode API	Assistance
V2	Speech.StreamingRecognize (idéal pour le streaming et l'audio en temps réel)	Compatible
V2	Speech.Recognize (compatible avec les contenus audio de moins d'une minute)	Compatible
V2	Speech.BatchRecognize (compatible avec les contenus audio longs de 1 minute à 1 heure)	Compatible

Disponibilité en fonction des régions

Chirp 3 est disponible dans les Google Cloud régions suivantes, et d'autres sont prévues :

ZoneGoogle Cloud	Disponibilité pour le lancement
`us(multi-region)`	DG
`eu(multi-region)`	DG
`asia-southeast1`	DG
`asia-northeast1`	DG

En utilisant l'API Locations comme expliqué ici, vous pouvez trouver la liste la plus récente des régions, langues, paramètres régionaux et fonctionnalités Google Cloud compatibles pour chaque modèle de transcription.

Langues disponibles pour la transcription

Chirp 3 est compatible avec la transcription en StreamingRecognize, Recognize et BatchRecognize dans les langues suivantes :

Langue	`BCP-47 Code`	Aptitude au lancement
Catalan (Espagne)	`ca-ES`	DG
Chinois (simplifié, Chine)	`cmn-Hans-CN`	DG
Croate (Croatie)	`hr-HR`	DG
Danois (Danemark)	`da-DK`	DG
Néerlandais (Pays-Bas)	`nl-NL`	DG
Anglais (Australie)	`en-AU`	DG
Anglais (Royaume-Uni)	`en-GB`	DG
Anglais (Inde)	`en-IN`	DG
Anglais (États-Unis)	`en-US`	DG
Finnois (Finlande)	`fi-FI`	DG
Français (Canada)	`fr-CA`	DG
Français (France)	`fr-FR`	DG
Allemand (Allemagne)	`de-DE`	DG
Grec (Grèce)	`el-GR`	DG
Hindi (Inde)	`hi-IN`	DG
Italien (Italie)	`it-IT`	DG
Japonais (Japon)	`ja-JP`	DG
Coréen (Corée)	`ko-KR`	DG
Polonais (Pologne)	`pl-PL`	DG
Portugais (Brésil)	`pt-BR`	DG
Portugais (Portugal)	`pt-PT`	DG
Roumain (Roumanie)	`ro-RO`	DG
Russe (Russie)	`ru-RU`	DG
Espagnol (Espagne)	`es-ES`	DG
Espagnol (États-Unis)	`es-US`	DG
Suédois (Suède)	`sv-SE`	DG
Turc (Turquie)	`tr-TR`	DG
Ukrainien (Ukraine)	`uk-UA`	DG
Vietnamien (Viêt Nam)	`vi-VN`	DG
Arabe	`ar-XA`	Aperçu
Arabe (Algérie)	`ar-DZ`	Aperçu
Arabe (Bahreïn)	`ar-BH`	Aperçu
Arabe (Égypte)	`ar-EG`	Aperçu
Arabe (Israël)	`ar-IL`	Aperçu
Arabe (Jordanie)	`ar-JO`	Aperçu
Arabe (Koweït)	`ar-KW`	Aperçu
Arabe (Liban)	`ar-LB`	Aperçu
Arabe (Mauritanie)	`ar-MR`	Aperçu
Arabe (Maroc)	`ar-MA`	Aperçu
Arabe (Oman)	`ar-OM`	Aperçu
Arabe (Qatar)	`ar-QA`	Aperçu
Arabe (Arabie saoudite)	`ar-SA`	Aperçu
Arabe (État de Palestine)	`ar-PS`	Aperçu
Arabe (Syrie)	`ar-SY`	Aperçu
Arabe (Tunisie)	`ar-TN`	Aperçu
Arabe (Émirats arabes unis)	`ar-AE`	Aperçu
Arabe (Yémen)	`ar-YE`	Aperçu
Arménien (Arménie)	`hy-AM`	Aperçu
Bengali (Bangladesh)	`bn-BD`	Aperçu
Bengali (Inde)	`bn-IN`	Aperçu
Bulgare (Bulgarie)	`bg-BG`	Aperçu
Birman (Myanmar)	`my-MM`	Aperçu
Sorani (Irak)	`ar-IQ`	Aperçu
Chinois cantonais (traditionnel, Hong Kong)	`yue-Hant-HK`	Aperçu
Chinois mandarin (traditionnel, Taïwan)	`cmn-Hant-TW`	Aperçu
Tchèque (République tchèque)	`cs-CZ`	Aperçu
Anglais (Philippines)	`en-PH`	Aperçu
Estonien (Estonie)	`et-EE`	Aperçu
Philippin (Philippines)	`fil-PH`	Aperçu
Gujarati (Inde)	`gu-IN`	Aperçu
Hébreu (Israël)	`iw-IL`	Aperçu
Hongrois (Hongrie)	`hu-HU`	Aperçu
Indonésien (Indonésie)	`id-ID`	Aperçu
Kannada (Inde)	`kn-IN`	Aperçu
Khmer (Cambodge)	`km-KH`	Aperçu
Laotien (Laos)	`lo-LA`	Aperçu
Letton (Lettonie)	`lv-LV`	Aperçu
Lituanien (Lituanie)	`lt-LT`	Aperçu
Malais (Malaisie)	`ms-MY`	Aperçu
Malayalam (Inde)	`ml-IN`	Aperçu
Marathi (Inde)	`mr-IN`	Aperçu
Népalais (Népal)	`ne-NP`	Aperçu
Norvégien (Norvège)	`no-NO`	Aperçu
Persan (Iran)	`fa-IR`	Aperçu
Serbe (Serbie)	`sr-RS`	Aperçu
Slovaque (Slovaquie)	`sk-SK`	Aperçu
Slovène (Slovénie)	`sl-SI`	Aperçu
Espagnol (Mexique)	`es-MX`	Aperçu
Swahili	`sw`	Aperçu
Tamoul (Inde)	`ta-IN`	Aperçu
Télougou (Inde)	`te-IN`	Aperçu
Thaï (Thaïlande)	`th-TH`	Aperçu
Ouzbek (Ouzbékistan)	`uz-UZ`	Aperçu

Langues disponibles pour l'identification des locuteurs

Chirp 3 n'est compatible avec la transcription et la segmentation par locuteur qu'en BatchRecognize et Recognize dans les langues suivantes :

Langue	Code BCP-47
Chinois (simplifié, Chine)	cmn-Hans-CN
Allemand (Allemagne)	de-DE
Anglais (Royaume-Uni)	en-GB
Anglais (Inde)	en-IN
Français (France)	en-US
Espagnol (Espagne)	es-ES
Espagnol (États-Unis)	es-US
Français (Canada)	fr-CA
Français (France)	fr-FR
Hindi (Inde)	hi-IN
Italien (Italie)	it-IT
Japonais (Japon)	ja-JP
Coréen (Corée)	ko-KR
Portugais (Brésil)	pt-BR

Compatibilité des fonctionnalités et limites

Chirp 3 est compatible avec les fonctionnalités suivantes :

Fonctionnalité	Description	Étape de lancement
Ponctuation automatique	Générées automatiquement par le modèle, elles peuvent être désactivées.	DG
Mise en majuscules automatique	Générées automatiquement par le modèle, elles peuvent être désactivées.	DG
Codes temporels au niveau de l'énoncé	Généré automatiquement par le modèle.	DG
Identification du locuteur	Identifie automatiquement les différents locuteurs dans un extrait audio monocanal. Disponible uniquement dans `BatchRecognize`	DG
Adaptation vocale (biais)	Fournit des suggestions au modèle sous forme d'expressions ou de mots pour améliorer la précision de la reconnaissance de termes ou de noms propres spécifiques.	DG
Transcription audio indépendante de la langue	Déduit et transcrit automatiquement la langue la plus courante.	DG

Chirp 3 n'est pas compatible avec les fonctionnalités suivantes :

Fonctionnalité	Description
Codes temporels au niveau du mot	Générée automatiquement par le modèle et peut être activée en option, ce qui peut entraîner une dégradation de la transcription.
Scores de confiance au niveau du mot	L'API renvoie une valeur, mais ce n'est pas réellement un score de confiance.

Transcrire avec Chirp 3

Découvrez comment utiliser Chirp 3 pour les tâches de transcription.

Effectuer une reconnaissance vocale 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

Effectuer une reconnaissance vocale synchrone

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

Effectuer une reconnaissance vocale par lot

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

Utiliser les fonctionnalités de Chirp 3

Découvrez comment utiliser les dernières fonctionnalités grâce à des exemples de code :

Effectuer une transcription indépendante de la langue

Chirp 3 peut identifier et transcrire automatiquement la langue dominante parlée dans l'audio, ce qui est essentiel pour les applications multilingues. Pour ce faire, définissez language_codes=["auto"] comme indiqué dans l'exemple de code :

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

Effectuer une transcription limitée à une langue

Chirp 3 peut identifier et transcrire automatiquement la langue dominante d'un fichier audio. Vous pouvez également le conditionner à des paramètres régionaux spécifiques que vous attendez, par exemple : ["en-US", "fr-FR"]. Cela permettrait de concentrer les ressources du modèle sur les langues les plus probables pour obtenir des résultats plus fiables, comme le montre l'exemple de code :

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

Effectuer la transcription et l'identification des locuteurs

Utilisez Chirp 3 pour les tâches de transcription et de segmentation par locuteur.

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

Améliorer la précision grâce à l'adaptation de modèle

Chirp 3 peut améliorer la précision de la transcription pour vos contenus audio spécifiques grâce à l'adaptation de modèle. Cela vous permet de fournir une liste de mots et d'expressions spécifiques, ce qui augmente la probabilité que le modèle les reconnaisse. Cela est particulièrement utile pour les termes spécifiques à un domaine, les noms propres ou le vocabulaire unique.

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

Activer la suppression du bruit et le filtrage du SNR

Chirp 3 peut améliorer la qualité audio en réduisant le bruit de fond et en filtrant les sons indésirables avant la transcription. Vous pouvez améliorer les résultats dans les environnements bruyants en activant le débruiteur intégré et le filtrage du rapport signal/bruit (SNR).

Le paramètre denoiser_audio=true peut vous aider à réduire la musique de fond ou les bruits de fond, comme la pluie et la circulation.

Vous pouvez définir snr_threshold=X pour contrôler le volume sonore vocal minimal requis pour la transcription. Cela permet de filtrer les éléments audio non vocaux ou le bruit de fond, ce qui évite d'obtenir du texte indésirable dans vos résultats. Un snr_threshold élevé signifie que l'utilisateur doit parler plus fort pour que le modèle transcrive les énoncés.

Le filtrage du SNR peut être utilisé dans les cas d'utilisation de streaming en temps réel pour éviter d'envoyer des sons inutiles à un modèle pour la transcription. Plus la valeur de ce paramètre est élevée, plus le volume de votre voix doit être élevé par rapport au bruit de fond pour être envoyé au modèle de transcription.

La configuration de snr_threshold interagira avec la valeur de denoise_audio (true ou false). Lorsque denoise_audio=true, le bruit de fond est supprimé et la voix devient relativement plus claire. Le SNR global de l'audio augmente.

Si votre cas d'utilisation n'implique que la voix de l'utilisateur sans que d'autres personnes parlent, définissez denoise_audio=true pour augmenter la sensibilité du filtrage du rapport signal/bruit, qui peut filtrer les bruits non vocaux. Si votre cas d'utilisation implique des personnes qui parlent en arrière-plan et que vous souhaitez éviter de transcrire les paroles en arrière-plan, envisagez de définir denoise_audio=false et d'abaisser le seuil de SNR.

Voici les seuils de SNR recommandés. Une valeur snr_threshold raisonnable peut être définie entre 0 et 1000. La valeur 0 signifie qu'aucun filtre n'est appliqué, et la valeur 1000 signifie que tout est filtré. Ajustez la valeur si le paramètre "Ajuster la valeur si recommandé" ne fonctionne pas pour vous.

Supprimer le bruit de l'audio	Seuil SNR	Sensibilité vocale
vrai	10,0	high
vrai	20.0	modérés
vrai	40,0	faibles
vrai	100	très faible
faux	0,5	high
faux	1.0	modérés
faux	2.0	faibles
faux	5.0	très faible

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

Utiliser Chirp 3 dans la console Google Cloud

Créez un compte Google Cloud et un projet.
Accédez à Speech dans la console Google Cloud .
Si l'API n'est pas activée, activez-la.
Assurez-vous de disposer d'un espace de travail de la console STT. Si vous n'avez pas d'espace de travail, vous devez en créer un.
1. Accédez à la page des transcriptions, puis cliquez sur Nouvelle transcription.
2. Ouvrez le menu déroulant Espace de travail et cliquez sur Nouvel espace de travail pour créer un espace de travail pour la transcription.
3. Dans la barre latérale de navigation Créer un espace de travail, cliquez sur Parcourir.
4. Cliquez pour créer un nouveau bucket.
5. Saisissez un nom pour ce bucket, puis cliquez sur Continuer.
6. Cliquez sur Créer pour créer votre bucket Cloud Storage.
7. Une fois le bucket créé, cliquez sur Sélectionner pour le sélectionner.
8. Cliquez sur Créer pour terminer la création de votre espace de travail pour la console Speech-to-Text API V2.
Effectuez une transcription de votre contenu audio.

Sur la page Nouvelle transcription, sélectionnez votre fichier audio via une importation (importation locale) ou en spécifiant un fichier Cloud Storage existant (Cloud Storage).
Cliquez sur Continuer pour passer aux Options de transcription.
1. Sélectionnez la Langue parlée que vous prévoyez d'utiliser pour la reconnaissance avec le modèle Chirp à partir de l'outil de reconnaissance que vous avez créé précédemment.
2. Dans la liste déroulante des modèles, sélectionnez chirp_3.
3. Dans le menu déroulant Outil de reconnaissance, sélectionnez l'outil de reconnaissance que vous venez de créer.
4. Cliquez sur Envoyer pour exécuter votre première requête de reconnaissance à l'aide de chirp_3.
Affichez le résultat de la transcription Chirp 3.
1. Sur la page Transcriptions, cliquez sur le nom de la transcription pour afficher son résultat.
2. Sur la page Détails de la transcription, observez le résultat de votre transcription et, éventuellement, lancez la lecture du contenu audio dans le navigateur.

Étapes suivantes

Découvrez comment transcrire des fichiers audio courts.
Découvrez comment transcrire du contenu audio diffusé en streaming.
Découvrez comment transcrire des fichiers audio longs.
Pour obtenir des conseils, entre autres sur l'optimisation des performances et l'amélioration de la précision, consultez la documentation relative aux bonnes pratiques.

Transcription Chirp 3 : précision multilingue améliorée Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

Informations sur le modèle

Identifiants de modèle

Méthodes d'API

Disponibilité en fonction des régions

Langues disponibles pour la transcription

Langues disponibles pour l'identification des locuteurs

Compatibilité des fonctionnalités et limites

Transcrire avec Chirp 3

Effectuer une reconnaissance vocale en streaming

Python

Effectuer une reconnaissance vocale synchrone

Python

Effectuer une reconnaissance vocale par lot

Python

Utiliser les fonctionnalités de Chirp 3

Effectuer une transcription indépendante de la langue

Python

Effectuer une transcription limitée à une langue

Python

Effectuer la transcription et l'identification des locuteurs

Python

Améliorer la précision grâce à l'adaptation de modèle

Python

Activer la suppression du bruit et le filtrage du SNR

Python

Utiliser Chirp 3 dans la console Google Cloud

Étapes suivantes

Transcription Chirp 3 : précision multilingue améliorée