O Chirp 2 é a geração mais recente dos modelos multilíngues específicos de ASR do Google, projetados para atender às necessidades dos usuários com base no feedback e na experiência. Ele melhora o modelo original do Chirp em precisão e velocidade, além de expandir para novos recursos importantes, como marcas de tempo no nível da palavra, adaptação de modelo e tradução de fala.
 Testar um notebook do Colab
|
 Acessar o notebook no GitHub
|
Detalhes do modelo
O Chirp 2 está disponível exclusivamente na API Speech-to-Text V2.
Identificadores de modelo
É possível usar o Chirp 2 como qualquer outro modelo especificando o identificador de modelo apropriado na solicitação de reconhecimento ao usar a API ou o nome do modelo no console do Google Cloud.
| Modelo | Identificador de modelo |
|---|---|
| Chirp 2 | chirp_2 |
Métodos da API
Como o Chirp 2 está disponível exclusivamente na API Speech-to-Text V2, ele oferece suporte aos seguintes métodos de reconhecimento:
| Modelo | Identificador de modelo | Suporte ao idioma |
|---|---|---|
V2 |
Speech.StreamingRecognize (bom para streaming e áudio em tempo real) |
Limitado* |
V2 |
Speech.Recognize (ideal para áudios curtos < 1 minuto) |
No mesmo nível do Chirp |
V2 |
Speech.BatchRecognize (bom para áudio de 1 minuto a 8 horas) |
No mesmo nível do Chirp |
*Você pode encontrar a lista mais recente de idiomas e recursos compatíveis para cada modelo de transcrição usando a API Locations.
Disponibilidade regional
O Chirp 2 tem suporte nas seguintes regiões:
| Zona do Google Cloud | Preparação para o lançamento |
|---|---|
us-central1 |
GA |
europe-west4 |
GA |
asia-southeast1 |
Prévia particular |
Você pode encontrar a lista mais recente de regiões, idiomas e recursos do Google Cloud com suporte para cada modelo de transcrição usando a API Locations, conforme explicado aqui.
Disponibilidade de idiomas para transcrição
O Chirp 2 oferece suporte à transcrição nos métodos de reconhecimento StreamingRecognize, Recognize e BatchRecognize. No entanto, a compatibilidade com idiomas varia de acordo com o método usado. Mais especificamente, BatchRecognize oferece o suporte a idiomas mais amplo. O StreamingRecognize é compatível com os seguintes idiomas:
| Idioma | Código BCP-47 |
|---|---|
| Chinês (Simplificado, China) | cmn-Hans-CN |
| Chinês tradicional (Taiwan) | cmn-hant-tw |
| Chinês, Cantonês (Tradicional, Hong Kong) | yue-Hant-HK |
| Inglês (Austrália) | en-AU |
| Inglês (Índia) | en-IN |
| Inglês (Reino Unido) | en-GB |
| English (United States) | en-US |
| Francês (Canadá) | fr-CA |
| Francês (França) | fr-FR |
| Alemão (Alemanha) | de-DE |
| Italiano (Itália) | it-IT |
| Japonês (Japão) | ja-JP |
| Português (Brasil) | pt-BR |
| Espanhol (Espanha) | es-ES |
| Espanhol (Estados Unidos) | es-US |
Disponibilidade de idiomas para tradução
Estes são os idiomas com suporte para a tradução de voz. O suporte de idioma do Chirp 2 para tradução não é simétrico. Isso significa que, embora possamos traduzir do idioma A para o idioma B, a tradução do idioma B para o idioma A pode não estar disponível. Os seguintes pares de idiomas são compatíveis com a tradução de voz.
Para tradução para o inglês:
| Origem -> Idioma de destino | Origem -> Código do idioma de destino |
|---|---|
| Árabe (Egito) -> Inglês | ar-EG -> en-US |
| Árabe (Golfo) -> Inglês | ar-x-gulf -> en-US |
| Árabe (Levante) -> Inglês | ar-x-levant -> en-US |
| Árabe (Magrebe) -> Inglês | ar-x-maghrebi -> en-US |
| Catalão (Espanha) -> Inglês | ca-ES -> en-US |
| Galês (Reino Unido) -> Inglês | cy-GB -> en-US |
| Alemão (Alemanha) -> Inglês | de-DE -> en-US |
| Espanhol (América Latina) -> Inglês | es-419 -> en-US |
| Espanhol (Espanha) -> Inglês | es-ES -> en-US |
| Espanhol (Estados Unidos) -> Inglês | es-US -> en-US |
| Estoniano (Estônia) -> Inglês | et-EE -> en-US |
| Francês (Canadá) -> Inglês | fr-CA -> en-US |
| Francês (França) -> Inglês | fr-FR -> en-US |
| Persa (Irã) -> Inglês | fa-IR -> en-US |
| Indonésio (Indonésia) -> Inglês | id-ID -> en-US |
| Italiano (Itália) -> Inglês | it-IT -> en-US |
| Japonês (Japão) -> Inglês | ja-JP -> en-US |
| Letão (Letônia) -> Inglês | lv-LV -> en-US |
| Mongol (Mongólia) -> Inglês | mn-MN -> en-US |
| Holandês (Holanda) -> Inglês | nl-NL -> en-US |
| Português (Brasil) -> Inglês | pt-BR -> en-US |
| Russo (Rússia) -> Inglês | ru-RU -> en-US |
| Esloveno (Eslovênia) -> Inglês | sl-SI -> en-US |
| Sueco (Suécia) -> Inglês | sv-SE -> en-US |
| Tâmil (Índia) -> Inglês | ta-IN -> en-US |
| Turco (Turquia) -> Inglês | tr-TR -> en-US |
| Chinês (simplificado, China) -> Inglês | zh-Hans-CN -> en-US |
Para tradução do inglês:
| Origem -> Idioma de destino | Origem -> Código do idioma de destino |
|---|---|
| Inglês -> Árabe (Egito) | en-US -> ar-EG |
| Inglês -> Árabe (Golfo) | en-US -> ar-x-gulf |
| Inglês -> Árabe (Levante) | en-US -> ar-x-levant |
| Inglês -> Árabe (Magrebe) | en-US -> ar-x-maghrebi |
| Inglês -> Catalão (Espanha) | en-US -> ca-ES |
| Inglês -> Galês (Reino Unido) | en-US -> cy-GB |
| Inglês -> Alemão (Alemanha) | en-US -> de-DE |
| Inglês -> Estoniano (Estônia) | en-US -> et-EE |
| Inglês -> Persa (Irã) | en-US -> fa-IR |
| Inglês -> Indonésio (Indonésia) | en-US -> id-ID |
| Inglês -> Japonês (Japão) | en-US -> ja-JP |
| Inglês -> Letão (Letônia) | en-US -> lv-LV |
| Inglês -> Mongol (Mongólia) | en-US -> mn-MN |
| Inglês -> Esloveno (Eslovênia) | en-US -> sl-SI |
| Inglês -> Sueco (Suécia) | en-US -> sv-SE |
| Inglês -> tâmil (Índia) | en-US -> ta-IN |
| Inglês -> Turco (Turquia) | en-US -> tr-TR |
| Inglês -> Chinês (simplificado, China) | en-US -> zh-Hans-CN |
Suporte e limitações dos recursos
O Chirp 2 oferece suporte aos seguintes recursos:
| Recurso | Descrição |
|---|---|
| Pontuação automática | Gerado automaticamente pelo modelo e pode ser desativado. |
| Maiúsculas automáticas | Gerado automaticamente pelo modelo e pode ser desativado. |
| Adaptação de fala (viés) | Forneça dicas ao modelo na forma de palavras ou frases simples para melhorar a precisão do reconhecimento de termos específicos ou substantivos próprios. Não há suporte para tokens de classe ou classes personalizadas. |
| Tempos de palavra (carimbos de data/hora) | Gerado automaticamente pelo modelo e pode ser ativado opcionalmente. É possível que a qualidade e a velocidade da transcrição sejam um pouco prejudicadas. |
| Transcrição de áudio independente do idioma | O modelo infere automaticamente o idioma falado no arquivo de áudio e faz a transcrição no idioma mais comum. |
| Tradução específica para cada idioma | O modelo traduz automaticamente do idioma falado para o idioma de destino. |
| Normalização forçada | Se definido no corpo da solicitação, a API vai realizar substituições de string em termos ou frases específicos, garantindo a consistência na transcrição. |
| Pontuações de confiança por palavra | A API retorna um valor, mas não é um índice de confiança. No caso da tradução, as pontuações de confiança não são retornadas. |
O Chirp 2 não é compatível com os seguintes recursos:
| Recurso | Descrição |
|---|---|
| Diarização | Sem suporte |
| Detecção de idiomas | Sem suporte |
| Filtro de linguagem obscena | Sem suporte |
Transcrever usando o Chirp 2
Descubra como usar o Chirp 2 para suas necessidades de transcrição e tradução.
Realizar reconhecimento de fala em 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
Executar o reconhecimento de fala síncrono
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
Fazer reconhecimento de fala em lote
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
Usar os recursos do Chirp 2
Confira como usar os recursos mais recentes com exemplos de código:
Realizar uma transcrição independente do idioma
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
Realizar tradução de fala
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
Ativar carimbos de data/hora de palavras
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
Melhorar a precisão com a adaptação do modelo
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
Usar o Chirp 2 no console do Google Cloud
- Verifique se você se inscreveu em uma conta do Google Cloud e criou um projeto.
- Acesse Speech no console do Google Cloud.
- Ative a API, se ainda não tiver feito isso.
Verifique se você tem um espaço de trabalho do console do STT. Crie um espaço de trabalho, caso ainda não tenha um.
Acesse a página de transcrições e clique em Nova transcrição.
Abra o menu suspenso Espaço de trabalho e clique em Novo espaço de trabalho para criar um espaço de trabalho para transcrição.
Na barra lateral de navegação Criar um novo espaço de trabalho, clique em Procurar.
Clique para criar um novo bucket.
Digite um nome para o bucket e clique em Continuar.
Clique em Criar para criar um bucket do Cloud Storage.
Depois que o bucket for criado, clique em Selecionar para usar o bucket.
Clique em Criar para concluir a criação do espaço de trabalho para o console da API Speech-to-Text V2.
Faça uma transcrição no áudio.
Na página Nova transcrição, selecione seu arquivo de áudio por meio de upload (Upload local) ou especificando um arquivo do Cloud Storage (Cloud Storage).
Clique em Continuar para acessar as Opções de transcrição.
Selecione o Idioma falado que você pretende usar para reconhecimento com o Chirp a partir do seu reconhecedor criado anteriormente.
No menu suspenso do modelo, selecione Chirp: modelo de fala universal.
No menu suspenso Reconhecedor, selecione o reconhecedor recém-criado.
Clique em Enviar para executar sua primeira solicitação de reconhecimento usando o Chirp.
Confira o resultado da transcrição do Chirp 2.
Na página Transcrições, clique no nome da transcrição para ver o resultado.
Na página Detalhes da transcrição, veja o resultado da transcrição e, se quiser, reproduza o áudio no navegador.
Limpar
Para evitar cobranças na conta do Google Cloud pelos recursos usados nesta página, siga estas etapas.
-
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
A seguir
- Pratique a transcrição de arquivos de áudio curtos.
- Saiba como transcrever streaming de áudio.
- Saiba como transcrever arquivos de áudio longos.
- Para dicas sobre como conseguir o melhor desempenho e precisão, entre outras, consulte a documentação sobre práticas recomendadas.