Chirp 2: precisione multilingue migliorata

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.

Provare un notebook di Colab Visualizzare il notebook su GitHub

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

  1. Assicurati di aver creato un account Google Cloud e un progetto.
  2. Vai a Speech nella console Google Cloud.
  3. Abilita l'API se non è già abilitata.

  4. Assicurati di avere una console STT Workspace. Se non ne hai già uno, devi creare uno spazio di lavoro.

    1. Vai alla pagina delle trascrizioni e fai clic su Nuova trascrizione.

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

    3. Nella barra laterale di navigazione Crea una nuova area di lavoro, fai clic su Sfoglia.

    4. Fai clic per creare un nuovo bucket.

    5. Inserisci un nome per il bucket e fai clic su Continua.

    6. Fai clic su Crea per creare il bucket Cloud Storage.

    7. Una volta creato il bucket, fai clic su Seleziona per selezionarlo per l'utilizzo.

    8. Fai clic su Crea per completare la creazione dell'area di lavoro per la console dell'API Speech-to-Text V2.

  5. Esegui una trascrizione dell'audio effettivo.

    Screenshot della pagina di creazione della trascrizione di sintesi vocale, che mostra la selezione o il caricamento del file.

    Nella pagina Nuova trascrizione, seleziona il file audio tramite il caricamento (Carico locale) o specificando un file Cloud Storage esistente (Cloud Storage).

  6. Fai clic su Continua per passare alle Opzioni di trascrizione.

    Screenshot della pagina di creazione della trascrizione Speech-to-Text che mostra la selezione del modello Chirp e l'invio di un job di trascrizione.

    1. Seleziona la Lingua parlata che intendi utilizzare per il riconoscimento con Chirp dal tuo riconoscitore creato in precedenza.

    2. Nel menu a discesa del modello, seleziona Chirp - Universal Speech Model.

    3. Nel menu a discesa Rilevatore, seleziona il rilevatore appena creato.

    4. Fai clic su Invia per eseguire la tua prima richiesta di riconoscimento utilizzando Chirp.

  7. Visualizza il risultato della trascrizione di Chirp 2.

    1. Nella pagina Trascrizioni, fai clic sul nome della trascrizione per visualizzarne il risultato.

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

  1. Optional: Revoke the authentication credentials that you created, and delete the local credential file. 

    gcloud auth application-default revoke

  2. Optional: Revoke credentials from the gcloud CLI. 

    gcloud auth revoke

Console

  • In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  • In the project list, select the project that you want to delete, and then click Delete.
  • In the dialog, type the project ID, and then click Shut down to delete the project.

    • gcloud

    Delete a Google Cloud project:

    gcloud projects delete PROJECT_ID

    Passaggi successivi