Chirp 2: maior acurácia em vários idiomas

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 em feedback e experiência. Ele melhora a acurácia e a velocidade do modelo Chirp original, além de oferecer novos recursos importantes, como marcas de tempo no nível da palavra, adaptação do modelo e tradução simultânea.

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. Para isso, especifique o identificador de modelo adequado 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 é compatível com os seguintes métodos de reconhecimento:

Modelo	Identificador de modelo	Suporte a idiomas
V2	Speech.StreamingRecognize (ideal 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 (ideal para áudios longos de 1 minuto a 8 horas)	No mesmo nível do Chirp

*Você sempre 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 está disponível nas seguintes regiões:

Zona doGoogle Cloud	Prontidão para o lançamento
us-central1	GA
europe-west4	GA
asia-southeast1	GA

Você sempre pode encontrar a lista mais recente de regiões, idiomas e recursos do Google Cloud compatíveis 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 de idiomas varia de acordo com o método usado. Especificamente, o BatchRecognize oferece o suporte a idiomas mais abrangente. O StreamingRecognize está disponível nos 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
Inglês (Estados Unidos)	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
Coreano (Coreia do Sul)	ko-KR
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 disponíveis para tradução simultânea. Observe que o suporte a idiomas do Chirp 2 para tradução não é simétrico. Isso significa que, embora seja possível 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 pares de idiomas a seguir são compatíveis com a tradução simultânea.

Para tradução para o inglês:

Idioma de origem -> Idioma-alvo	Origem -> Código do idioma-alvo
Á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 (Países Baixos) -> 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	cmn-Hans-CN -> en-US

Para tradução do inglês:

Idioma de origem -> Idioma-alvo	Origem -> Código do idioma-alvo
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 -> cmn-Hans-CN

Suporte e limitações dos recursos

O Chirp 2 é compatível com os seguintes recursos:

Recurso	Descrição
Pontuação automática	Gerada automaticamente pelo modelo e pode ser desativada.
Letras maiúsculas automáticas	Gerada automaticamente pelo modelo e pode ser desativada.
Adaptação da fala (polarização)	Forneça dicas ao modelo na forma de palavras ou frases simples para melhorar a acurácia do reconhecimento de termos específicos ou substantivos próprios. Não há suporte para tokens de classe ou classes personalizadas.
Marcações de tempo de palavra (carimbos de data/hora)	Geradas automaticamente pelo modelo e podem ser ativadas opcionalmente. É possível que a qualidade e a velocidade da transcrição diminuam um pouco.
Filtro de linguagem obscena	Detecte palavras obscenas e retorne apenas a primeira letra seguida por asteriscos na transcrição (por exemplo, f***).
Transcrição de áudio independente de idioma	O modelo infere automaticamente o idioma falado no arquivo de áudio e faz a transcrição no idioma mais usado.
Tradução específica de um idioma	O modelo traduz automaticamente do idioma falado para o idioma-alvo.
Normalização forçada	Se isso for 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 nível de confiança por palavra	A API retorna um valor, mas não é uma pontuação de confiança. No caso da tradução, as pontuações de confiança não são retornadas.
Cancelador de ruído e filtragem de SNR	Remova o ruído do áudio antes de enviá-lo para o modelo. Filtre segmentos de áudio se a SNR for menor que o limite especificado.

O Chirp 2 não é compatível com os seguintes recursos:

Recurso	Descrição
Diarização	Sem suporte
Detecção de idiomas	Sem suporte

Transcrição usando o Chirp 2

Descubra como usar o Chirp 2 para suas necessidades de transcrição e tradução.

Realizar o 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

Realizar 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

Realizar o 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 recursos do Chirp 2

Confira como usar os recursos mais recentes com exemplos de código:

Realizar uma transcrição independente de 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 uma tradução simultânea

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 por palavra

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 acurácia com a adaptação de 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

Detalhes sobre o cancelador de ruído e a filtragem de SNR

denoiser_audio=true pode ajudar a reduzir a música de fundo ou ruídos, como chuva e trânsito. Observe que um cancelador de ruído não pode remover vozes humanas em segundo plano.

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

Ativar o cancelador de ruído e a filtragem de SNR

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",
        denoiser_config={
            denoise_audio: True,
            # Medium snr threshold
            snr_threshold: 20.0,
        }
    )

    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

1. Verifique se você se inscreveu em uma conta do Google Cloud e criou um projeto.
2. Acesse Speech no console do Google Cloud .
3. Ative a API, se ainda não tiver feito isso.

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

   1. Acesse a página de transcrições e clique em Nova Transcrição.

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

   3. Na barra lateral de navegação Criar um novo espaço de trabalho, clique em Procurar.

   4. Clique para criar um novo bucket.

   5. Digite um nome para o bucket e clique em Continuar.

   6. Clique em Criar para criar um bucket do Cloud Storage.

   7. Depois que o bucket for criado, clique em Selecionar para selecionar o bucket a ser usado.

   8. Clique em Criar para concluir a criação do espaço de trabalho para o console da API Speech-to-Text V2.

5. Faça uma transcrição no áudio real.

   

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

6. Clique em Continuar para acessar as Opções de transcrição.

   

   1. Selecione o Idioma falado que você pretende usar para reconhecimento com o Chirp a partir do seu reconhecedor criado anteriormente.

   2. No menu suspenso do modelo, selecione Chirp - Modelo de Fala Universal.

   3. No menu suspenso Reconhecedor, selecione o reconhecedor recém-criado.

   4. Clique em Enviar para executar sua primeira solicitação de reconhecimento usando o Chirp.

7. Veja o resultado da transcrição do Chirp 2.

   1. Na página Transcrições, clique no nome da transcrição para ver o resultado.

   2. Na página Detalhes da transcrição, veja o resultado da transcrição e, se quiser, reproduza o áudio no navegador.

Limpeza

Para evitar cobranças na conta do Google Cloud pelos recursos usados nesta página, siga as etapas abaixo.

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

Cuidado: a exclusão de um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos nele.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um ID do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja explorar várias arquiteturas, tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda limites da cota.

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

Cuidado: a exclusão de um projeto tem os seguintes efeitos:

• Tudo no projeto é excluído. Se você tiver usado um projeto atual para as tarefas neste documento, a exclusão dele incluirá a exclusão de quaisquer outros trabalhos feitos nele.
• Os IDs do projeto personalizados são perdidos. Ao criar o projeto, você pode ter criado um ID do projeto personalizado para ser usado no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, exclua recursos específicos do projeto, em vez de excluir o projeto inteiro.

Se você planeja explorar várias arquiteturas, tutoriais e guias de início rápido, a reutilização de projetos pode evitar que você exceda limites da cota.

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.

A seguir

• Pratique a transcrição de arquivos de áudio curtos.
• Aprenda a transcrever um áudio de streaming.
• Aprenda a transcrever arquivos de áudio longos.
• Para o melhor desempenho e acurácia e outras dicas, consulte a documentação sobre práticas recomendadas.