Questa pagina è stata tradotta dall'API Cloud Translation.

Trascrizione di Chirp 3: maggiore accuratezza multilingue

Chirp 3 è l'ultima generazione di modelli generativi multilingue specifici per il riconoscimento vocale automatico (ASR) di Google, progettati per soddisfare le esigenze degli utenti in base al feedback e all'esperienza. Chirp 3 offre maggiore precisione e velocità rispetto ai modelli Chirp precedenti e fornisce la diarizzazione e il rilevamento automatico della lingua.

Dettagli modello

Chirp 3: Transcription è disponibile esclusivamente nell'API Speech-to-Text V2.

Identificatori modello

Puoi utilizzare Chirp 3: Transcription 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 . Specifica l'identificatore appropriato nel riconoscimento.

Modello	Identificatore modello
Chirp 3	`chirp_3`

Metodi API

Non tutti i metodi di riconoscimento supportano gli stessi set di disponibilità delle lingue. Poiché Chirp 3 è disponibile nell'API Speech-to-Text V2, supporta i seguenti metodi di riconoscimento:

Versione API	Metodo API	Assistenza
V2	Speech.StreamingRecognize (ideale per lo streaming e l'audio in tempo reale)	Supportato
V2	Speech.Recognize (ideale per audio di durata inferiore a un minuto)	Supportato
V2	Speech.BatchRecognize (ideale per audio lunghi da 1 minuto a 1 ora)	Supportato

Disponibilità a livello di regione

Chirp 3 è disponibile nelle seguenti Google Cloud regioni, con altre in programma:

Google Cloud Zona	Preparazione al lancio
`us(multi-region)`	GA
`eu(multi-region)`	GA
`asia-southeast1`	GA
`asia-northeast1`	GA

Utilizzando l'API Locations come spiegato qui, puoi trovare l'elenco più recente di regioni, lingue, impostazioni internazionali e funzionalità supportate per ogni modello di trascrizione. Google Cloud

Lingue disponibili per la trascrizione

Chirp 3 supporta la trascrizione in StreamingRecognize, Recognize e BatchRecognize nelle seguenti lingue:

Lingua	`BCP-47 Code`	Idoneità al lancio
Catalano (Spagna)	`ca-ES`	GA
Cinese semplificato (Cina)	`cmn-Hans-CN`	GA
Croato (Croazia)	`hr-HR`	GA
Danese (Danimarca)	`da-DK`	GA
Olandese (Paesi Bassi)	`nl-NL`	GA
Inglese (Australia)	`en-AU`	GA
Inglese (Regno Unito)	`en-GB`	GA
Inglese (India)	`en-IN`	GA
Inglese (Stati Uniti)	`en-US`	GA
Finlandese (Finlandia)	`fi-FI`	GA
Francese (Canada)	`fr-CA`	GA
Francese (Francia)	`fr-FR`	GA
Tedesco (Germania)	`de-DE`	GA
Greco (Grecia)	`el-GR`	GA
Hindi (India)	`hi-IN`	GA
Italiano (Italia)	`it-IT`	GA
Giapponese (Giappone)	`ja-JP`	GA
Coreano (Corea)	`ko-KR`	GA
Polacco (Polonia)	`pl-PL`	GA
Portoghese (Brasile)	`pt-BR`	GA
Portoghese (Portogallo)	`pt-PT`	GA
Rumeno (Romania)	`ro-RO`	GA
Russo (Russia)	`ru-RU`	GA
Spagnolo (Spagna)	`es-ES`	GA
Spagnolo (Stati Uniti)	`es-US`	GA
Svedese (Svezia)	`sv-SE`	GA
Turco (Turchia)	`tr-TR`	GA
Ucraino (Ucraina)	`uk-UA`	GA
Vietnamita (Vietnam)	`vi-VN`	GA
Arabo	`ar-XA`	Anteprima
Arabo (Algeria)	`ar-DZ`	Anteprima
Arabo (Bahrain)	`ar-BH`	Anteprima
Arabo (Egitto)	`ar-EG`	Anteprima
Arabo (Israele)	`ar-IL`	Anteprima
Arabo (Giordania)	`ar-JO`	Anteprima
Arabo (Kuwait)	`ar-KW`	Anteprima
Arabo (Libano)	`ar-LB`	Anteprima
Arabo (Mauritania)	`ar-MR`	Anteprima
Arabo (Marocco)	`ar-MA`	Anteprima
Arabo (Oman)	`ar-OM`	Anteprima
Arabo (Qatar)	`ar-QA`	Anteprima
Arabo (Arabia Saudita)	`ar-SA`	Anteprima
Arabo (Stato di Palestina)	`ar-PS`	Anteprima
Arabo (Siria)	`ar-SY`	Anteprima
Arabo (Tunisia)	`ar-TN`	Anteprima
Arabo (Emirati Arabi Uniti)	`ar-AE`	Anteprima
Arabo (Yemen)	`ar-YE`	Anteprima
Armeno (Armenia)	`hy-AM`	Anteprima
Bengalese (Bangladesh)	`bn-BD`	Anteprima
Bengalese (India)	`bn-IN`	Anteprima
Bulgaro (Bulgaria)	`bg-BG`	Anteprima
Birmano (Myanmar)	`my-MM`	Anteprima
Curdo centrale (Iraq)	`ar-IQ`	Anteprima
Cinese, cantonese (Hong Kong, tradizionale)	`yue-Hant-HK`	Anteprima
Cinese, mandarino (tradizionale, Taiwan)	`cmn-Hant-TW`	Anteprima
Ceco (Repubblica Ceca)	`cs-CZ`	Anteprima
Inglese (Filippine)	`en-PH`	Anteprima
Estone (Estonia)	`et-EE`	Anteprima
Filippino (Filippine)	`fil-PH`	Anteprima
Gujarati (India)	`gu-IN`	Anteprima
Ebraico (Israele)	`iw-IL`	Anteprima
Ungherese (Ungheria)	`hu-HU`	Anteprima
Indonesiano (Indonesia)	`id-ID`	Anteprima
Kannada (India)	`kn-IN`	Anteprima
Khmer (Cambogia)	`km-KH`	Anteprima
Lao (Laos)	`lo-LA`	Anteprima
Lettone (Lettonia)	`lv-LV`	Anteprima
Lituano (Lituania)	`lt-LT`	Anteprima
Malese (Malaysia)	`ms-MY`	Anteprima
Malayalam (India)	`ml-IN`	Anteprima
Marathi (India)	`mr-IN`	Anteprima
Nepalese (Nepal)	`ne-NP`	Anteprima
Norvegese (Norvegia)	`no-NO`	Anteprima
Persiano (Iran)	`fa-IR`	Anteprima
Serbo (Serbia)	`sr-RS`	Anteprima
Slovacco (Slovacchia)	`sk-SK`	Anteprima
Sloveno (Slovenia)	`sl-SI`	Anteprima
Spagnolo (Messico)	`es-MX`	Anteprima
Swahili	`sw`	Anteprima
Tamil (India)	`ta-IN`	Anteprima
Telugu (India)	`te-IN`	Anteprima
Thailandese (Thailandia)	`th-TH`	Anteprima
Uzbeco (Uzbekistan)	`uz-UZ`	Anteprima

Lingue disponibili per la diarizzazione

Chirp 3 supporta la trascrizione e la diarizzazione solo in BatchRecognize e Recognize nelle seguenti lingue:

Lingua	Codice BCP-47
Cinese semplificato (Cina)	cmn-Hans-CN
Tedesco (Germania)	de-DE
Inglese (Regno Unito)	en-GB
Inglese (India)	en-IN
Inglese (Stati Uniti)	en-US
Spagnolo (Spagna)	es-ES
Spagnolo (Stati Uniti)	es-US
Francese (Canada)	fr-CA
Francese (Francia)	fr-FR
Hindi (India)	hi-IN
Italiano (Italia)	it-IT
Giapponese (Giappone)	ja-JP
Coreano (Corea)	ko-KR
Portoghese (Brasile)	pt-BR

Supporto e limitazioni delle funzionalità

Chirp 3 supporta le seguenti funzionalità:

Funzionalità	Descrizione	Fase di avvio
Punteggiatura automatica	Vengono generati automaticamente dal modello e possono essere disattivati facoltativamente.	GA
Maiuscole automatiche	Vengono generati automaticamente dal modello e possono essere disattivati facoltativamente.	GA
Timestamp a livello di enunciato	Generato automaticamente dal modello.	GA
Speaker Diarization	Identifica automaticamente i diversi interlocutori in un campione audio a un solo canale. Disponibile solo in `BatchRecognize`	GA
Adattamento vocale (Biasing)	Fornisce suggerimenti al modello sotto forma di frasi o parole per migliorare l'accuratezza del riconoscimento di termini specifici o nomi propri.	GA
Trascrizione audio indipendente dalla lingua	Deduce e trascrive automaticamente nella lingua più diffusa.	GA

Chirp 3 non supporta le seguenti funzionalità:

Funzionalità	Descrizione
Timestamp a livello di parola	Generati automaticamente dal modello e possono essere abilitati facoltativamente, con un certo degrado della trascrizione previsto.
Punteggi di confidenza a livello di parola	L'API restituisce un valore, ma non si tratta di un vero e proprio punteggio di confidenza.

Trascrivere usando Chirp 3

Scopri come utilizzare Chirp 3 per le attività di trascrizione.

Esecuzione del riconoscimento vocale di audio in 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

Esecuzione del riconoscimento vocale sincrono

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

Eseguire il riconoscimento vocale batch

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

Utilizzare le funzionalità di Chirp 3

Scopri come utilizzare le ultime funzionalità con esempi di codice:

Eseguire una trascrizione indipendente dalla lingua

Chirp 3 è in grado di identificare e trascrivere automaticamente la lingua dominante parlata nell'audio, il che è essenziale per le applicazioni multilingue. Per ottenere questo risultato, imposta language_codes=["auto"] come indicato nell'esempio di codice:

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

Eseguire una trascrizione con limitazioni linguistiche

Chirp 3 può identificare e trascrivere automaticamente la lingua dominante in un file audio. Puoi anche impostare una condizione per le impostazioni internazionali specifiche che ti aspetti, ad esempio: ["en-US", "fr-FR"], che concentrerebbe le risorse del modello sulle lingue più probabili per risultati più affidabili, come mostrato nell'esempio di codice:

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

Eseguire la trascrizione e la diarizzazione dello speaker

Utilizza Chirp 3 per le attività di trascrizione e diarizzazione.

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

Migliorare l'accuratezza con l'adattamento del modello

Chirp 3 può migliorare l'accuratezza della trascrizione per il tuo audio specifico utilizzando l'adattamento del modello. In questo modo puoi fornire un elenco di parole e frasi specifiche, aumentando la probabilità che il modello le riconosca. È particolarmente utile per termini specifici del dominio, nomi propri o vocabolario unico.

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

Abilitare il riduttore del rumore e il filtro SNR

Chirp 3 può migliorare la qualità audio riducendo il rumore di fondo e filtrando i suoni indesiderati prima della trascrizione. Puoi migliorare i risultati in ambienti rumorosi attivando il denoiser integrato e il filtro del rapporto segnale-rumore (SNR).

L'impostazione denoiser_audio=true può aiutarti a ridurre la musica di sottofondo o i rumori come la pioggia e il traffico stradale.

Puoi impostare snr_threshold=X per controllare il volume minimo del parlato richiesto per la trascrizione. In questo modo, vengono filtrati l'audio non vocale o il rumore di fondo, impedendo la visualizzazione di testo indesiderato nei risultati. Un valore di snr_threshold più alto significa che l'utente deve parlare più forte affinché il modello possa trascrivere le espressioni.

Il filtro SNR può essere utilizzato nei casi d'uso di streaming in tempo reale per evitare di inviare suoni non necessari a un modello per la trascrizione. Un valore più alto per questa impostazione significa che il volume della voce deve essere più alto rispetto al rumore di fondo per essere inviato al modello di trascrizione.

La configurazione di snr_threshold interagirà con denoise_audio, che sarà true o false. Quando denoise_audio=true, il rumore di fondo viene rimosso e il parlato diventa relativamente più chiaro. L'SNR complessivo dell'audio aumenta.

Se il tuo caso d'uso riguarda solo la voce dell'utente senza che altri parlino, imposta denoise_audio=true per aumentare la sensibilità del filtro SNR, che può filtrare il rumore non vocale. Se il tuo caso d'uso prevede persone che parlano in sottofondo e vuoi evitare di trascrivere i discorsi in sottofondo, valuta la possibilità di impostare denoise_audio=false e abbassare la soglia del rapporto segnale/rumore.

Di seguito sono riportati i valori di soglia SNR consigliati. È possibile impostare un valore snr_threshold ragionevole compreso tra 0 e 1000. Un valore di 0 indica di non filtrare nulla, mentre 1000 indica di filtrare tutto. Perfezionare il valore se l'impostazione consigliata non funziona per te.

Riduci il rumore dell'audio	Soglia SNR	Sensibilità vocale
true	10,0	high
true	20,0	media
true	40,0	basso
true	100,0	molto bassa
falso	0,5	high
falso	1.0	media
falso	2.0	basso
falso	5,0	molto bassa

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

Utilizzare Chirp 3 nella console Google Cloud

Registrati per creare un account Google Cloud e crea un progetto.
Vai a Speech nella console Google Cloud .
Se l'API non è abilitata, abilitala.
Assicurati di avere una console STT Workspace. Se non hai uno spazio di lavoro, devi crearne uno.
1. Vai alla pagina delle trascrizioni e fai clic su Nuova trascrizione.
2. Apri il menu a discesa Workspace e fai clic su New Workspace (Nuovo spazio di lavoro) per creare uno spazio di lavoro per la trascrizione.
3. Nella barra laterale di navigazione Crea un nuovo spazio 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 dello spazio di lavoro per la console dell'API Speech-to-Text V2.
Esegui una trascrizione sull'audio effettivo.

Nella pagina Nuova trascrizione, seleziona il file audio tramite caricamento (Caricamento locale) o specificando un file Cloud Storage esistente (Cloud Storage).
Fai clic su Continua per passare alle Opzioni di trascrizione.
1. Seleziona la Lingua parlata che prevedi di utilizzare per il riconoscimento con Chirp dal riconoscitore creato in precedenza.
2. Nel menu a discesa del modello, seleziona chirp_3.
3. Nel menu a discesa Riconoscitore, seleziona il riconoscitore appena creato.
4. Fai clic su Invia per eseguire la prima richiesta di riconoscimento utilizzando chirp_3.
Visualizza il risultato della trascrizione di Chirp 3.
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.

Passaggi successivi

Scopri come trascrivere file audio corti.
Scopri come trascrivere l'audio in streaming.
Scopri come trascrivere file audio lunghi.
Per ottenere prestazioni e precisione ottimali e altri suggerimenti, consulta la documentazione sulle best practice.

Trascrizione di Chirp 3: maggiore accuratezza multilingue Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Dettagli modello

Identificatori modello

Metodi API

Disponibilità a livello di regione

Lingue disponibili per la trascrizione

Lingue disponibili per la diarizzazione

Supporto e limitazioni delle funzionalità

Trascrivere usando Chirp 3

Esecuzione del riconoscimento vocale di audio in streaming

Python

Esecuzione del riconoscimento vocale sincrono

Python

Eseguire il riconoscimento vocale batch

Python

Utilizzare le funzionalità di Chirp 3

Eseguire una trascrizione indipendente dalla lingua

Python

Eseguire una trascrizione con limitazioni linguistiche

Python

Eseguire la trascrizione e la diarizzazione dello speaker

Python

Migliorare l'accuratezza con l'adattamento del modello

Python

Abilitare il riduttore del rumore e il filtro SNR

Python

Utilizzare Chirp 3 nella console Google Cloud

Passaggi successivi

Trascrizione di Chirp 3: maggiore accuratezza multilingue