Chirp 2 est la dernière génération de modèles multilingues de reconnaissance vocale automatique de Google, conçus pour répondre aux besoins des utilisateurs en fonction de leurs commentaires et de leur expérience. Il améliore la précision et la vitesse du modèle Chirp d'origine, et propose de nouvelles fonctionnalités clés telles que les codes temporels au niveau du mot, l'adaptation du modèle et la traduction vocale.
 Essayer un notebook Colab
|
 Afficher le notebook sur GitHub
|
Informations sur le modèle
Chirp 2 est disponible exclusivement dans l'API Speech-to-Text V2.
Identifiants de modèle
Vous pouvez utiliser Chirp 2 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.
| Modèle | Identifiant du modèle |
|---|---|
| Chirp 2 | chirp_2 |
Méthodes d'API
Comme Chirp 2 est disponible exclusivement dans l'API Speech-to-Text V2, il est compatible avec les méthodes de reconnaissance suivantes:
| Modèle | Identifiant du modèle | Langues acceptées |
|---|---|---|
V2 |
Speech.StreamingRecognize (adapté au streaming et à l'audio en temps réel) |
Limité* |
V2 |
Speech.Recognize (compatible avec les contenus audio courts < 1 min) |
Comparable à Chirp |
V2 |
Speech.BatchRecognize (compatible avec les contenus audio longs de 1 min à 8 heures) |
Équivalent à Chirp |
*Vous pouvez toujours consulter la dernière liste des langues et fonctionnalités compatibles pour chaque modèle de transcription à l'aide de l'API Locations.
Disponibilité en fonction des régions
Chirp 2 est compatible avec les régions suivantes:
| Zone Google Cloud | Disponibilité pour le lancement |
|---|---|
us-central1 |
DG |
europe-west4 |
DG |
asia-southeast1 |
Aperçu privé |
Vous pouvez toujours consulter la dernière liste des régions, langues et fonctionnalités Google Cloud compatibles pour chaque modèle de transcription à l'aide de l'API Locations, comme expliqué ici.
Langues disponibles pour la transcription
Chirp 2 est compatible avec la transcription dans les méthodes de reconnaissance StreamingRecognize, Recognize et BatchRecognize. Toutefois, la prise en charge des langues varie selon la méthode utilisée. Plus précisément, BatchRecognize offre la compatibilité linguistique la plus étendue. StreamingRecognize est disponible dans les langues suivantes:
| Langue | Code BCP-47 |
|---|---|
| Chinois (simplifié, Chine) | cmn-Hans-CN |
| Chinois (traditionnel, Taïwan) | cmn-hant-tw |
| Chinois cantonais (traditionnel, Hong Kong) | yue-Hant-HK |
| Anglais (Australie) | en-AU |
| Anglais (Inde) | en-IN |
| Anglais (Royaume-Uni) | en-GB |
| Français (France) | en-US |
| Français (Canada) | fr-CA |
| Français (France) | fr-FR |
| Allemand (Allemagne) | de-DE |
| Italien (Italie) | it-IT |
| Japonais (Japon) | ja-JP |
| Portugais (Brésil) | pt-BR |
| Espagnol (Espagne) | es-ES |
| Espagnol (États-Unis) | es-US |
Langues disponibles pour la traduction
Voici les langues acceptées pour la traduction vocale. Notez que la prise en charge des langues pour la traduction dans Chirp 2 n'est pas symétrique. Cela signifie que nous pouvons être en mesure de traduire de la langue A vers la langue B, mais que la traduction de la langue B vers la langue A n'est pas forcément disponible. Les combinaisons linguistiques suivantes sont compatibles avec la traduction vocale.
Pour traduction en anglais:
| Source -> Langue cible | Source -> Code de la langue cible |
|---|---|
| Arabe (Égypte) -> Anglais | ar-EG -> en-US |
| Arabe (Golfe) -> Anglais | ar-x-gulf -> en-US |
| Arabe (Levant) -> Anglais | ar-x-levant -> en-US |
| Arabe (Maghreb) -> Anglais | ar-x-maghrebi -> en-US |
| Catalan (Espagne) -> Anglais | ca-ES -> en-US |
| Gallois (Royaume-Uni) -> Anglais | cy-GB -> en-US |
| Allemand (Allemagne) -> Anglais | de-DE -> en-US |
| Espagnol (Amérique latine) -> Anglais | es-419 -> en-US |
| Espagnol (Espagne) -> Anglais | es-ES -> en-US |
| Espagnol (États-Unis) -> Anglais | es-US -> en-US |
| Estonien (Estonie) -> Anglais | et-EE -> en-US |
| Français (Canada) -> Anglais | fr-CA -> en-US |
| Français (France) -> Anglais | fr-FR -> en-US |
| Persan (Iran) -> Anglais | fa-IR -> en-US |
| Indonésien (Indonésie) -> Anglais | id-ID -> en-US |
| Italien (Italie) -> Anglais | it-IT -> en-US |
| Japonais (Japon) -> Anglais | ja-JP -> en-US |
| Letton (Lettonie) -> Anglais | lv-LV -> en-US |
| Mongol (Mongolie) -> Anglais | mn-MN -> en-US |
| Néerlandais (Pays-Bas) -> Anglais | nl-NL -> en-US |
| Portugais (Brésil) -> Anglais | pt-BR -> en-US |
| Russe (Russie) -> Anglais | ru-RU -> en-US |
| Slovène (Slovénie) -> Anglais | sl-SI -> en-US |
| Suédois (Suède) -> Anglais | sv-SE -> en-US |
| Tamoul (Inde) -> Anglais | ta-IN -> en-US |
| Turc (Turquie) -> Anglais | tr-TR -> en-US |
| Chinois (simplifié, Chine) -> Anglais | zh-Hans-CN -> en-US |
Pour traduire de l'anglais:
| Source -> Langue cible | Source -> Code de la langue cible |
|---|---|
| Anglais -> Arabe (Égypte) | en-US -> ar-EG |
| Anglais -> Arabe (Golfe) | en-US -> ar-x-gulf |
| Anglais -> Arabe (Levant) | en-US -> ar-x-levant |
| Anglais -> Arabe (Maghreb) | en-US -> ar-x-maghrebi |
| Anglais -> Catalan (Espagne) | en-US -> ca-ES |
| Anglais -> Gallois (Royaume-Uni) | en-US -> cy-GB |
| Anglais -> Allemand (Allemagne) | en-US -> de-DE |
| Anglais -> Estonien (Estonie) | en-US -> et-EE |
| Anglais -> Persan (Iran) | en-US -> fa-IR |
| Anglais -> Indonésien (Indonésie) | en-US -> id-ID |
| Anglais -> Japonais (Japon) | en-US -> ja-JP |
| Anglais -> Letton (Lettonie) | en-US -> lv-LV |
| Anglais -> Mongol (Mongolie) | en-US -> mn-MN |
| Anglais -> Slovène (Slovénie) | en-US -> sl-SI |
| Anglais -> Suédois (Suède) | en-US -> sv-SE |
| Anglais -> Tamoul (Inde) | en-US -> ta-IN |
| Anglais -> Turc (Turquie) | en-US -> tr-TR |
| Anglais -> Chinois (simplifié, Chine) | en-US -> zh-Hans-CN |
Compatibilité des fonctionnalités et limites
Chirp 2 est compatible avec les fonctionnalités suivantes:
| Caractéristique | Description |
|---|---|
| Ponctuation automatique | Généré automatiquement par le modèle et peut être désactivé. |
| Mettre automatiquement les mots en majuscules | Généré automatiquement par le modèle et peut être désactivé. |
| Adaptation vocale (biais) | Fournissez des indices au modèle sous la forme de mots ou d'expressions simples pour améliorer la précision de la reconnaissance de termes spécifiques ou de noms propres. Les jetons de classe ou les classes personnalisées ne sont pas acceptés. |
| Temps de parole (codes temporels) | Généré automatiquement par le modèle et peut être activé. Il est possible que la qualité et la vitesse de la transcription soient légèrement dégradées. |
| Transcription audio indépendante du langage | Le modèle déduit automatiquement la langue parlée dans votre fichier audio et la transcrit dans la langue la plus courante. |
| Traduction spécifique à une langue | Le modèle traduit automatiquement la langue parlée dans la langue cible. |
| Normalisation forcée | Si elles sont définies dans le corps de la requête, l'API effectuera des remplacements de chaînes sur des termes ou des expressions spécifiques, ce qui garantira la cohérence 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. Dans le cas de la traduction, les scores de confiance ne sont pas renvoyés. |
Chirp 2 n'est pas compatible avec les fonctionnalités suivantes:
| Caractéristique | Description |
|---|---|
| Diarisation | Non compatible |
| Détection de la langue | Non compatible |
| Filtre de langage grossier | Non compatible |
Transcrire à l'aide de Chirp 2
Découvrez comment utiliser Chirp 2 pour vos besoins en transcription et en traduction.
Effectuer une reconnaissance vocale 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
Effectuer une reconnaissance vocale synchrone
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
Effectuer une reconnaissance vocale par lot
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
Utiliser les fonctionnalités de Chirp 2
Découvrez comment utiliser les dernières fonctionnalités, avec des exemples de code:
Effectuer une transcription indépendante du langage
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
Effectuer une traduction vocale
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
Activer les codes temporels au niveau du mot
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
Améliorer la précision avec l'adaptation de modèle
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
Utiliser Chirp 2 dans la console Google Cloud
- Assurez-vous d'avoir créé un compte Google Cloud et d'avoir créé un projet.
- Accédez à Speech dans la console Google Cloud.
- Si ce n'est pas déjà fait, activez l'API.
Assurez-vous de disposer d'un espace de travail de console STT. Si vous n'en possédez pas déjà un, vous devez créer un espace de travail.
Accédez à la page des transcriptions, puis cliquez sur Nouvelle transcription.
Ouvrez la liste déroulante Espace de travail, puis cliquez sur Nouvel espace de travail pour créer un espace de travail pour la transcription.
Dans la barre latérale de navigation Créer un espace de travail, cliquez sur Parcourir.
Cliquez pour créer un nouveau bucket.
Saisissez un nom pour ce bucket, puis cliquez sur Continuer.
Cliquez sur Créer pour créer votre bucket Cloud Storage.
Une fois le bucket créé, cliquez sur Sélectionner pour le sélectionner.
Cliquez sur Créer pour terminer la création de votre espace de travail pour la console de l'API Speech-to-Text 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.
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.
Dans le menu déroulant des modèles, sélectionnez Chirp - Modèle de reconnaissance vocale universel.
Dans le menu déroulant Outil de reconnaissance, sélectionnez l'outil de reconnaissance que vous venez de créer.
Cliquez sur Envoyer pour exécuter votre première requête de reconnaissance à l'aide de Chirp.
Affichez le résultat de la transcription Chirp 2.
Sur la page Transcriptions, cliquez sur le nom de la transcription pour afficher son résultat.
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.
Effectuer un nettoyage
Pour éviter que les ressources utilisées sur cette page soient facturées sur votre compte Google Cloud, suivez les étapes ci-dessous :
-
Optional: Revoke the authentication credentials that you created, and delete the local credential file.
gcloud auth application-default revoke
-
Optional: Revoke credentials from the gcloud CLI.
gcloud auth revoke
Console
gcloud
Delete a Google Cloud project:
gcloud projects delete PROJECT_ID
Étapes suivantes
- Entraînez-vous à 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.