O Chirp 3 é a geração mais recente dos modelos generativos multilíngues de reconhecimento de fala automático (ASR, na sigla em inglês) do Google e foi projetado para atender às necessidades dos usuários com base em feedback e experiência. Ele oferece mais precisão e velocidade do que os modelos anteriores do Chirp, além de diarização e detecção automática de idioma.
Detalhes do modelo
O Chirp 3: Transcription está disponível exclusivamente na API Speech-to-Text V2.
Identificadores de modelo
É possível usar o Chirp 3: Transcription como qualquer outro modelo. Para isso, especifique o identificador de modelo adequado na solicitação de reconhecimento ao usar a API ou o nome do modelo no console Google Cloud . Especifique o identificador adequado no seu reconhecimento.
| Modelo | Identificador de modelo |
|---|---|
| Chirp 3 | chirp_3 |
Métodos da API
Nem todos os métodos de reconhecimento são compatíveis com os mesmos conjuntos de disponibilidade de idiomas. Como o Chirp 3 está disponível na API Speech-to-Text V2, ele é compatível com os seguintes métodos de reconhecimento:
| Versão da API | Método de API | Suporte |
|---|---|---|
| V2 | Speech.StreamingRecognize (ideal para streaming e áudios em tempo real) | Sim |
| V2 | Speech.Recognize (ideal para áudios com menos de um minuto) | Sim |
| V2 | Speech.BatchRecognize (ideal para áudios longos de um minuto a uma hora) | Sim |
Disponibilidade regional
Embora haja planos de expansão para outras regiões, o Chirp 3 está disponível atualmente nas regiões do Google Cloud abaixo:
| ZonaGoogle Cloud | Prontidão para o lançamento |
|---|---|
us (multi-region) |
GA |
eu (multi-region) |
GA |
asia-northeast1 |
GA |
asia-southeast1 |
GA |
asia-south1 |
Pré-lançamento |
europe-west2 |
Pré-lançamento |
europe-west3 |
Pré-lançamento |
northamerica-northeast1 |
Pré-lançamento |
Conforme explicado aqui, você pode usar a API Location para encontrar a lista mais recente de regiões, localidades e idiomas aceitos do Google Cloud , além de recursos para cada modelo de transcrição.
Disponibilidade de idiomas para transcrição
O Chirp 3 oferece suporte à transcrição em StreamingRecognize, Recognize e BatchRecognize nos seguintes idiomas:
| Idioma | BCP-47 Code |
Prontidão para o lançamento |
| Catalão (Espanha) | ca-ES | GA |
| Chinês (simplificado, China) | cmn-Hans-CN | GA |
| Croata (Croácia) | hr-HR | GA |
| Dinamarquês (Dinamarca) | da-DK | GA |
| Holandês (Países Baixos) | nl-NL | GA |
| Inglês (Austrália) | en-AU | GA |
| Inglês (Reino Unido) | en-GB | GA |
| Inglês (Índia) | en-IN | GA |
| Inglês (Estados Unidos) | en-US | GA |
| Finlandês (Finlândia) | fi-FI | GA |
| Francês (Canadá) | fr-CA | GA |
| Francês (França) | fr-FR | GA |
| Alemão (Alemanha) | de-DE | GA |
| Grego (Grécia) | el-GR | GA |
| Hindi (Índia) | hi-IN | GA |
| Italiano (Itália) | it-IT | GA |
| Japonês (Japão) | ja-JP | GA |
| Coreano (Coreia) | ko-KR | GA |
| Polonês (Polônia) | pl-PL | GA |
| Português (Brasil) | pt-BR | GA |
| Português (Portugal) | pt-PT | GA |
| Romeno (Romênia) | ro-RO | GA |
| Russo (Rússia) | ru-RU | GA |
| Espanhol (Espanha) | es-ES | GA |
| Espanhol (Estados Unidos) | es-US | GA |
| Sueco (Suécia) | sv-SE | GA |
| Turco (Turquia) | tr-TR | GA |
| Ucraniano (Ucrânia) | uk-UA | GA |
| Vietnamita (Vietnã) | vi-VN | GA |
| Árabe | ar-XA | Pré-lançamento |
| Árabe (Argélia) | ar-DZ | Pré-lançamento |
| Árabe (Bahrein) | ar-BH | Pré-lançamento |
| Árabe (Egito) | ar-EG | Pré-lançamento |
| Árabe (Israel) | ar-IL | Pré-lançamento |
| Árabe (Jordânia) | ar-JO | Pré-lançamento |
| Árabe (Kuwait) | ar-KW | Pré-lançamento |
| Árabe (Líbano) | ar-LB | Pré-lançamento |
| Árabe (Mauritânia) | ar-MR | Pré-lançamento |
| Árabe (Marrocos) | ar-MA | Pré-lançamento |
| Árabe (Omã) | ar-OM | Pré-lançamento |
| Árabe (Catar) | ar-QA | Pré-lançamento |
| Árabe (Arábia Saudita) | ar-SA | Pré-lançamento |
| Árabe (Estado da Palestina) | ar-PS | Pré-lançamento |
| Árabe (Síria) | ar-SY | Pré-lançamento |
| Árabe (Tunísia) | ar-TN | Pré-lançamento |
| Árabe (Emirados Árabes Unidos) | ar-AE | Pré-lançamento |
| Árabe (Iêmen) | ar-YE | Pré-lançamento |
| Armênio (Armênia) | hy-AM | Pré-lançamento |
| Bengali (Bangladesh) | bn-BD | Pré-lançamento |
| Bengali (Índia) | bn-IN | Pré-lançamento |
| Búlgaro (Bulgária) | bg-BG | Pré-lançamento |
| Birmanês (Mianmar) | my-MM | Pré-lançamento |
| Curdo central (Iraque) | ar-IQ | Pré-lançamento |
| Chinês, cantonês (Tradicional, Hong Kong) | yue-Hant-HK | Pré-lançamento |
| Chinês, Mandarim (Tradicional, Taiwan) | cmn-Hant-TW | Pré-lançamento |
| Tcheco (República Tcheca) | cs-CZ | Pré-lançamento |
| Inglês (Filipinas) | en-PH | Pré-lançamento |
| Estoniano (Estônia) | et-EE | Pré-lançamento |
| Filipino (Filipinas) | fil-PH | Pré-lançamento |
| Gujarati (Índia) | gu-IN | Pré-lançamento |
| Hebraico (Israel) | iw-IL | Pré-lançamento |
| Húngaro (Hungria) | hu-HU | Pré-lançamento |
| Indonésio (Indonésia) | id-ID | Pré-lançamento |
| Canarês (Índia) | kn-IN | Pré-lançamento |
| Khmer (Camboja) | km-KH | Pré-lançamento |
| Lao (Laos) | lo-LA | Pré-lançamento |
| Letão (Letônia) | lv-LV | Pré-lançamento |
| Lituano (Lituânia) | lt-LT | Pré-lançamento |
| Malaio (Malásia) | ms-MY | Pré-lançamento |
| Malaiala (Índia) | ml-IN | Pré-lançamento |
| Marathi (Índia) | mr-IN | Pré-lançamento |
| Nepalês (Nepal) | ne-NP | Pré-lançamento |
| Norueguês (Noruega) | no-NO | Pré-lançamento |
| Persa (Irã) | fa-IR | Pré-lançamento |
| Sérvio (Sérvia) | sr-RS | Pré-lançamento |
| Eslovaco (Eslováquia) | sk-SK | Pré-lançamento |
| Esloveno (Eslovênia) | sl-SI | Pré-lançamento |
| Espanhol (México) | es-MX | Pré-lançamento |
| Suaíli | sw | Pré-lançamento |
| Tamil (Índia) | ta-IN | Pré-lançamento |
| Telugu (Índia) | te-IN | Pré-lançamento |
| Tailandês (Tailândia) | th-TH | Pré-lançamento |
| Uzbeque (Uzbequistão) | uz-UZ | Pré-lançamento |
Disponibilidade de idiomas para diarização
O Chirp 3 oferece suporte à transcrição e diarização apenas em BatchRecognize e Recognize nos seguintes idiomas:
| Idioma | Código BCP-47 |
| Chinês (simplificado, China) | cmn-Hans-CN |
| Alemão (Alemanha) | de-DE |
| Inglês (Reino Unido) | en-GB |
| Inglês (Índia) | en-IN |
| Inglês (Estados Unidos) | en-US |
| Espanhol (Espanha) | es-ES |
| Espanhol (Estados Unidos) | es-US |
| Francês (Canadá) | fr-CA |
| Francês (França) | fr-FR |
| Hindi (Índia) | hi-IN |
| Italiano (Itália) | it-IT |
| Japonês (Japão) | ja-JP |
| Coreano (Coreia) | ko-KR |
| Português (Brasil) | pt-BR |
Suporte e limitações dos recursos
O Chirp 3 aceita os seguintes recursos:
| Recurso | Descrição | Etapa do lançamento |
|---|---|---|
| Pontuação automática | Gerada automaticamente pelo modelo e pode ser desativada. | GA |
| Letras maiúsculas automáticas | Gerada automaticamente pelo modelo e pode ser desativada. | GA |
| Carimbos de data/hora no nível da expressão | Gerados automaticamente pelo modelo. | GA |
| Diarização de locutor | Identifica automaticamente os diferentes locutores em um trecho de áudio de canal único. Disponível apenas no BatchRecognize |
GA |
| Adaptação da fala (polarização) | Fornece frases ou palavras ao modelo como dicas para melhorar a acurácia do reconhecimento de termos específicos ou substantivos próprios. | GA |
| Transcrição de áudio independente de idioma | Infere e transcreve automaticamente no idioma mais usado. | GA |
O Chirp 3 não aceita os seguintes recursos:
| Recurso | Descrição |
| Carimbos de data/hora no nível da palavra | Gerados automaticamente pelo modelo e podem ser ativados, o que causa alguma degradação na transcrição. |
| Pontuações de nível de confiança por palavra | A API retorna um valor, mas não é uma pontuação de confiança. |
Transcrição usando o Chirp 3
Saiba como usar o Chirp 3 para tarefas de transcrição.
Realizar o reconhecimento de fala em 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
Realizar o reconhecimento de fala síncrono
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
Realizar o reconhecimento de fala em lote
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
Usar recursos do Chirp 3
Confira como usar os recursos mais recentes com exemplos de código:
Realizar uma transcrição independente de idioma
O Chirp 3 pode identificar e transcrever automaticamente no idioma dominante falado no áudio, o que é essencial para aplicativos multilíngues. Para isso, defina language_codes=["auto"] conforme indicado no exemplo de código:
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/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
Realizar transcrição para um idioma específico
O Chirp 3 pode identificar e transcrever automaticamente o idioma dominante em um arquivo de áudio. Você também pode condicionar a resposta a localidades específicas, por exemplo, ["en-US", "fr-FR"]. Isso direciona os recursos do modelo para os idiomas mais prováveis a fim de gerar resultados mais confiáveis, conforme mostrado no exemplo de código:
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/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
Realizar transcrição e diarização de locutor
Use o Chirp 3 para tarefas de transcrição e diarização.
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
Melhorar a acurácia com a adaptação de modelo
O Chirp 3 pode melhorar a acurácia da transcrição do seu áudio específico usando a adaptação de modelo. Isso permite gerar uma lista de palavras e frases específicas, aumentando a probabilidade de o modelo reconhecê-las. Isso é especialmente útil para termos específicos do domínio, substantivos próprios ou vocabulário exclusivo.
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
Ativar o cancelador de ruído e a filtragem de SNR
O Chirp 3 pode melhorar a qualidade do áudio reduzindo o ruído de fundo e filtrando sons indesejados antes da transcrição. Para melhorar os resultados em ambientes ruidosos, ative o cancelador de ruído integrado e a filtragem da relação sinal-ruído (SNR, na sigla em inglês).
Definir denoiser_audio=true pode ajudar a reduzir música ou ruídos de fundo, como chuva e trânsito.
Você pode definir snr_threshold=X para controlar o volume mínimo da fala necessário para transcrição. Isso ajuda a filtrar um áudio sem fala ou o ruído de
fundo, evitando texto indesejado nos resultados. Um valor snr_threshold mais alto significa
que o usuário precisa falar mais alto para que o modelo transcreva os enunciados.
A filtragem de SNR pode ser usada em casos de uso de streaming em tempo real para evitar o envio de sons desnecessários a um modelo para transcrição. Um valor mais alto para essa configuração significa que o volume da sua fala precisa ser mais alto em relação ao ruído de fundo para ser enviado ao modelo de transcrição.
A configuração de snr_threshold vai interagir
com o fato de denoise_audio ser true ou false. Quando denoise_audio=true,
o ruído de fundo é removido, e a fala fica relativamente mais clara. A SNR geral
do áudio aumenta.
Se o caso de uso envolver apenas a voz do usuário sem outras pessoas falando, defina denoise_audio=true para aumentar a sensibilidade da filtragem de SNR, que pode
filtrar ruídos que não são de fala. Se o caso de uso envolver pessoas
falando ao fundo e você quiser evitar a transcrição da fala em segundo plano,
considere a possibilidade de definir denoise_audio=false e reduzir o limite de SNR.
Confira a seguir os valores recomendados de limite de SNR. Um valor snr_threshold
razoável pode ser definido de 0 a 1000. Um valor igual a 0 significa não filtrar nada, e 1000
significa filtrar tudo. Ajuste o valor se a configuração recomendada não funcionar para
você.
| Remover ruído do áudio | Limite de SNR | Sensibilidade à fala |
|---|---|---|
| verdadeiro | 10,0 | alta |
| verdadeiro | 20,0 | média |
| verdadeiro | 40,0 | baixa |
| verdadeiro | 100,0 | muito baixa |
| falso | 0,5 | alta |
| falso | 1,0 | média |
| falso | 2,0 | baixa |
| falso | 5,0 | muito baixa |
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
Usar o Chirp 3 no console Google Cloud
- Inscreva-se em uma conta Google Cloud e crie um projeto.
- Clique em Fala no console Google Cloud .
- Se a API não estiver ativada, faça isso.
Verifique se você tem um espaço de trabalho do console da STT. Se não tiver, então crie 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 selecionar o bucket a ser usado.
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 real.
A página de criação da transcrição da Speech-to-Text, mostrando a seleção ou o upload de arquivos. Na página Nova Transcrição, selecione seu arquivo de áudio para 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 reconhecedor que criou anteriormente.
No menu suspenso do modelo, selecione chirp_3.
No menu suspenso Reconhecedor, selecione o reconhecedor recém-criado.
Clique em Enviar para executar sua primeira solicitação de reconhecimento usando o
chirp_3.
Veja o resultado da transcrição do Chirp 3.
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.