Chirp 2 è l'ultima generazione di modelli specifici di ASR multilingue di Google, progettati per soddisfare le esigenze degli utenti in base a feedback ed esperienza. Migliora il modello Chirp originale in termini di precisione e velocità, oltre a espandersi in nuove funzionalità chiave come timestamp a livello di parola, adattamento del modello e traduzione vocale.
![]() |
![]() |
Dettagli modello
Chirp 2 è disponibile esclusivamente nell'API Speech-to-Text V2.
Identificatori modello
Puoi utilizzare Chirp 2 come qualsiasi altro modello specificando l'identificatore del modello appropriato nella richiesta di riconoscimento quando utilizzi l'API o il nome del modello nella console Google Cloud.
Modello | Identificatore modello |
---|---|
Chirp 2 | chirp_2 |
Metodi API
Poiché Chirp 2 è disponibile esclusivamente nell'API Speech-to-Text V2, supporta i seguenti metodi di riconoscimento:
Modello | Identificatore modello | Supporto dei linguaggi |
---|---|---|
V2 |
Speech.StreamingRecognize (adatto per lo streaming e l'audio in tempo reale) |
Con limitazioni* |
V2 |
Speech.Recognize (adatto per audio brevi di durata inferiore a 1 minuto) |
Al pari di Chirp |
V2 |
Speech.BatchRecognize (ideale per audio di durata superiore a 1 minuto e fino a 8 ore) |
Al pari di Chirp |
*Puoi sempre trovare l'elenco più recente delle lingue e delle funzionalità supportate per ogni modello di trascrizione utilizzando l'API Locations.
Disponibilità a livello di area geografica
Chirp 2 è supportato nelle seguenti regioni:
Google Cloud Zona | Preparazione al lancio |
---|---|
us-central1 |
GA |
europe-west4 |
GA |
asia-southeast1 |
GA |
Puoi sempre trovare l'elenco più recente delle regioni, delle lingue e delle funzionalità Google Cloud supportate per ogni modello di trascrizione utilizzando l'API Locations come spiegato qui.
Lingue disponibili per la trascrizione
Chirp 2 supporta la trascrizione nei metodi di riconoscimento StreamingRecognize
, Recognize
e BatchRecognize
. Tuttavia, il supporto delle lingue varia a seconda del metodo utilizzato. Nello specifico, BatchRecognize
offre il supporto linguistico più completo. StreamingRecognize
supporta le seguenti lingue:
Lingua | Codice BCP-47 |
---|---|
Cinese semplificato (Cina) | cmn-Hans-CN |
Cinese tradizionale (Taiwan) | cmn-hant-tw |
Cinese, cantonese (Hong Kong, tradizionale) | yue-Hant-HK |
Inglese (Australia) | en-AU |
Inglese (India) | en-IN |
Inglese (Regno Unito) | en-GB |
Inglese (Stati Uniti) | en-US |
Francese (Canada) | fr-CA |
Francese (Francia) | fr-FR |
Tedesco (Germania) | de-DE |
Italiano (Italia) | it-IT |
Giapponese (Giappone) | ja-JP |
Portoghese (Brasile) | pt-BR |
Spagnolo (Spagna) | es-ES |
Spagnolo (Stati Uniti) | es-US |
Lingue disponibili per la traduzione
Queste sono le lingue supportate per la traduzione vocale. Tieni presente che il supporto delle lingue per la traduzione di Chirp 2 non è simmetrico. Ciò significa che, anche se potremmo essere in grado di tradurre dalla lingua A alla lingua B, la traduzione dalla lingua B alla lingua A potrebbe non essere disponibile. Le seguenti coppie di lingue sono supportate per la funzionalità Traduzione vocale.
Per la traduzione in inglese:
Lingua di origine -> Lingua di destinazione | Origine -> Codice lingua di destinazione |
---|---|
Arabo (Egitto) -> Inglese | ar-EG -> en-US |
Arabo (Golfo) -> Inglese | ar-x-gulf -> en-US |
Arabo (Levante) -> Inglese | ar-x-levant -> en-US |
Arabo (Maghreb) -> Inglese | ar-x-maghrebi -> en-US |
Catalano (Spagna) -> Inglese | ca-ES -> en-US |
Gallese (Regno Unito) -> Inglese | cy-GB -> en-US |
Tedesco (Germania) -> Inglese | de-DE -> en-US |
Spagnolo (America Latina) -> Inglese | es-419 -> en-US |
Spagnolo (Spagna) -> Inglese | es-ES -> en-US |
Spagnolo (Stati Uniti) -> Inglese | es-US -> en-US |
Estone (Estonia) -> Inglese | et-EE -> en-US |
Francese (Canada) -> Inglese | fr-CA -> en-US |
Francese (Francia) -> Inglese | fr-FR -> en-US |
Persiano (Iran) -> Inglese | fa-IR -> en-US |
Indonesiano (Indonesia) -> Inglese | id-ID -> en-US |
Italiano (Italia) -> Inglese | it-IT -> en-US |
Giapponese (Giappone) -> Inglese | ja-JP -> en-US |
Lettone (Lettonia) -> Inglese | lv-LV -> en-US |
Mongolo (Mongolia) -> Inglese | mn-MN -> en-US |
Olandese (Paesi Bassi) -> Inglese | nl-NL -> en-US |
Portoghese (Brasile) -> Inglese | pt-BR -> en-US |
Russo (Russia) -> Inglese | ru-RU -> en-US |
Sloveno (Slovenia) -> Inglese | sl-SI -> en-US |
Svedese (Svezia) -> Inglese | sv-SE -> en-US |
Tamil (India) -> Inglese | ta-IN -> en-US |
Turco (Turchia) -> Inglese | tr-TR -> en-US |
Cinese (semplificato, Cina) -> Inglese | cmn-Hans-CN -> en-US |
Per la traduzione dall'inglese:
Lingua di origine -> Lingua di destinazione | Origine -> Codice lingua di destinazione |
---|---|
Inglese -> Arabo (Egitto) | en-US -> ar-EG |
Inglese -> Arabo (Golfo) | en-US -> ar-x-gulf |
Inglese -> Arabo (Levante) | en-US -> ar-x-levant |
Inglese -> Arabo (Maghreb) | en-US -> ar-x-maghrebi |
Inglese -> Catalano (Spagna) | en-US -> ca-ES |
Inglese -> Gallese (Regno Unito) | en-US -> cy-GB |
Inglese -> Tedesco (Germania) | en-US -> de-DE |
Inglese -> Estone (Estonia) | en-US -> et-EE |
Inglese -> Persiano (Iran) | en-US -> fa-IR |
Inglese -> Indonesiano (Indonesia) | en-US -> id-ID |
Inglese -> Giapponese (Giappone) | en-US -> ja-JP |
Inglese -> Lettone (Lettonia) | en-US -> lv-LV |
Inglese -> Mongolo (Mongolia) | en-US -> mn-MN |
Inglese -> Sloveno (Slovenia) | en-US -> sl-SI |
Inglese -> Svedese (Svezia) | en-US -> sv-SE |
Inglese -> Tamil (India) | en-US -> ta-IN |
Inglese -> Turco (Turchia) | en-US -> tr-TR |
Inglese -> Cinese (semplificato, Cina) | en-US -> cmn-Hans-CN |
Supporto e limitazioni delle funzionalità
Chirp 2 supporta le seguenti funzionalità:
Funzionalità | Descrizione |
---|---|
Punteggiatura automatica | Generato automaticamente dal modello e può essere disattivato facoltativamente. |
Lettere maiuscole automatiche | Generato automaticamente dal modello e può essere disattivato facoltativamente. |
Adattamento vocale (bias) | Fornisci suggerimenti al modello sotto forma di parole o frasi semplici per migliorare l'accuratezza del riconoscimento di termini specifici o nomi propri. I token di classe o le classi personalizzate non sono supportati. |
Tempi delle parole (timestamp) | Generato automaticamente dal modello e può essere attivato facoltativamente. È possibile che la qualità e la velocità della trascrizione peggiorino leggermente. |
Filtro per il linguaggio volgare | Rileva le parole offensive e restituisce solo la prima lettera seguita da asterischi nella trascrizione (ad esempio c****). |
Trascrizione audio indipendente dalla lingua | Il modello deducono automaticamente la lingua parlata nel file audio e la trascrizione viene eseguita nella lingua più prevalente. |
Traduzione specifica per lingua | Il modello traduce automaticamente dalla lingua parlata alla lingua di destinazione. |
Normalizzazione forzata | Se definita nel corpo della richiesta, l'API eseguirà sostituzioni di stringhe su termini o frasi specifici, garantendo la coerenza della trascrizione. |
Punteggi di confidenza a livello di parola | L'API restituisce un valore, ma non è un vero e proprio punteggio di affidabilità. Nel caso della traduzione, i punteggi di affidabilità non vengono restituiti. |
Chirp 2 non supporta le seguenti funzionalità:
Funzionalità | Descrizione |
---|---|
Distribuzione dei turni di parola | Non supportata |
Rilevamento della lingua | Non supportata |
Trascrivere utilizzando Chirp 2
Scopri come utilizzare Chirp 2 per le tue esigenze di trascrizione e traduzione.
Eseguire il riconoscimento vocale di audio in 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
Eseguire il riconoscimento vocale sincrono
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
Eseguire il riconoscimento vocale batch
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
Utilizzare le funzionalità di Chirp 2
Scopri come utilizzare le ultime funzionalità con esempi di codice:
Eseguire una trascrizione indipendente dalla lingua
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
Eseguire la traduzione 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
Attiva i timestamp a livello di parola
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
Migliorare la precisione con l'adattamento del modello
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
Utilizzare Chirp 2 nella console Google Cloud
- Assicurati di aver creato un account Google Cloud e un progetto.
- Vai a Speech nella console Google Cloud.
- Abilita l'API se non è già abilitata.
Assicurati di avere una console STT Workspace. Se non ne hai già uno, devi creare uno spazio di lavoro.
Vai alla pagina delle trascrizioni e fai clic su Nuova trascrizione.
Apri il menu a discesa Spazio di lavoro e fai clic su Nuovo spazio di lavoro per creare uno spazio di lavoro per la trascrizione.
Nella barra laterale di navigazione Crea una nuova area di lavoro, fai clic su Sfoglia.
Fai clic per creare un nuovo bucket.
Inserisci un nome per il bucket e fai clic su Continua.
Fai clic su Crea per creare il bucket Cloud Storage.
Una volta creato il bucket, fai clic su Seleziona per selezionarlo per l'utilizzo.
Fai clic su Crea per completare la creazione dell'area di lavoro per la console dell'API Speech-to-Text V2.
Esegui una trascrizione dell'audio effettivo.
Nella pagina Nuova trascrizione, seleziona il file audio tramite il caricamento (Carico locale) o specificando un file Cloud Storage esistente (Cloud Storage).
Fai clic su Continua per passare alle Opzioni di trascrizione.
Seleziona la Lingua parlata che intendi utilizzare per il riconoscimento con Chirp dal tuo riconoscitore creato in precedenza.
Nel menu a discesa del modello, seleziona Chirp - Universal Speech Model.
Nel menu a discesa Rilevatore, seleziona il rilevatore appena creato.
Fai clic su Invia per eseguire la tua prima richiesta di riconoscimento utilizzando Chirp.
Visualizza il risultato della trascrizione di Chirp 2.
Nella pagina Trascrizioni, fai clic sul nome della trascrizione per visualizzarne il risultato.
Nella pagina Dettagli della trascrizione, visualizza il risultato della trascrizione e, se vuoi, riproduci l'audio nel browser.
Esegui la pulizia
Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questa pagina, segui questi passaggi.
-
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
Passaggi successivi
- Fai pratica di trascrizione di file audio brevi.
- Scopri come trascrivere l'audio in streaming.
- Scopri come trascrivere file audio lunghi.
- Per ottenere il massimo rendimento e la massima precisione e altri suggerimenti, consulta la documentazione relativa alle best practice.