Como traduzir o texto de uma foto e gerar a leitura automática dele com glossários (Advanced)


Nesta página, você aprende a detectar texto em uma imagem, personalizar traduções e gerar falas sintéticas a partir de um texto. Neste tutorial, o Cloud Vision é usado para detectar textos em um arquivo de imagem. Em seguida, você verá como usar o Cloud Translation para traduzir o texto detectado de maneira personalizada. Por fim, o Text-to-Speech será usado para fornecer o ditado automatizado do texto traduzido.

Objetivos

  1. Transmitir o texto reconhecido pela API Cloud Vision para a API Cloud Translation.

  2. Criar e usar glossários do Cloud Translation para personalizar as traduções da API Cloud Translation.

  3. Criar uma representação de áudio do texto traduzido usando a API Text-to-Speech.

Custos

Cada API do Google Cloud tem uma estrutura de preços diferente.

Para detalhes sobre preços, consulte os respectivos guias do Cloud Vision, do Cloud Translation e do Text-to-Speech.

Antes de começar

Você precisa ter o seguinte:

Como fazer o download dos códigos de amostra

Neste tutorial, o código é usado no diretório samples/snippets/hybrid_glossaries das bibliotecas de cliente do Cloud para Python.

Para fazer o download do código deste tutorial e navegar até ele, execute os comandos a seguir no terminal.

git clone https://github.com/googleapis/python-translate.git
cd samples/snippets/hybrid_glossaries/

Como configurar bibliotecas de cliente

Neste tutorial, as bibliotecas de cliente do Vision, Translation e Text-to-Speech são usadas.

Para instalar as bibliotecas de cliente necessárias, execute os comandos a seguir no terminal.

pip install --upgrade google-cloud-vision
pip install --upgrade google-cloud-translate
pip install --upgrade google-cloud-texttospeech

Como definir permissões para criar o glossário

Para criar glossários do Translation, é preciso usar uma chave de conta de serviço que tenha as permissões de editor da API Cloud Translation.

Para configurar uma chave de conta de serviço com as permissões do editor da API Cloud Translation, faça o seguinte:

  1. Crie uma conta de serviço:

    1. No Console do Google Cloud, acesse a página Contas de serviço.

      Acesse Contas de serviço

    2. Selecione o projeto.

    3. Clique em Criar conta de serviço.

    4. No campo Nome da conta de serviço, insira um nome. O console do Google Cloud preenche o campo ID da conta de serviço com base nesse nome.

    5. Opcional: preencha o campo Descrição da conta de serviço.

    6. Clique em Criar e continuar.

    7. Clique no campo Selecionar papel e selecione Cloud Translation > Editor da API Cloud Translation.

    8. Clique em Concluído para terminar a criação da conta de serviço.

      Não feche a janela do navegador. Você vai usá-la na próxima etapa.

  2. Faça o download de uma chave JSON para a conta de serviço que você acabou de criar:

    1. No console do Google Cloud, clique no endereço de e-mail da conta de serviço que você criou.
    2. Clique em Chaves.
    3. Clique em Adicionar chave e em Criar nova chave.
    4. Clique em Criar. O download de um arquivo de chave JSON é feito no seu computador.

      Armazene o arquivo de chave com segurança, porque ele pode ser usado para autenticar como sua conta de serviço. Mova e renomeie esse arquivo como quiser.

    5. Clique em Fechar.

  3. Na pasta hybrid_glossaries no terminal, use o comando a seguir para definir a variável GOOGLE_APPLICATION_CREDENTIALS. Substitua path_to_key pelo caminho para o arquivo JSON transferido por download que contém a nova chave de conta de serviço.

    Linux ou macOS

    export GOOGLE_APPLICATION_CREDENTIALS=path_to_key

    Windows

    set GOOGLE_APPLICATION_CREDENTIALS=path_to_key

Como importar bibliotecas

Neste tutorial, as importações de sistema e de biblioteca de cliente a seguir são usadas.

import html
import os

# Imports the Google Cloud client libraries
from google.api_core.exceptions import AlreadyExists
from google.cloud import texttospeech
from google.cloud import translate_v3beta1 as translate
from google.cloud import vision

Como definir o ID do projeto

É preciso associar um projeto do Google Cloud a cada solicitação feita a uma API do Google Cloud. Para escolher o projeto do Google Cloud, defina a variável de ambiente GOOGLE_CLOUD_PROJECT no terminal.

Substitua o PROJECT_NUMBER_OR_ID pelo código do projeto do Google Cloud. Execute o comando a seguir no terminal.

Linux ou macOS

export GOOGLE_CLOUD_PROJECT=PROJECT_NUMBER_OR_ID

Windows

set GOOGLE_CLOUD_PROJECT=PROJECT_NUMBER_OR_ID

Neste tutorial, a variável de ID do projeto global a seguir é usada.

# extract GCP project id
PROJECT_ID = os.environ["GOOGLE_CLOUD_PROJECT"]

Como usar o Vision para detectar o texto de uma imagem

Use a API Vision para detectar e extrair o texto de uma imagem. A API Vision usa o Reconhecimento ótico de caracteres (OCR, na sigla em inglês) para fornecer dois recursos de detecção de texto: detecção de textos densos ou DOCUMENT_TEXT_DETECTION e a detecção de textos esparsos ou TEXT_DETECTION.

Veja no código a seguir como usar o recurso DOCUMENT_TEXT_DETECTION da API Vision para detectar o texto em uma foto com texto denso.

def pic_to_text(infile: str) -> str:
    """Detects text in an image file

    Args:
    infile: path to image file

    Returns:
    String of text detected in image
    """

    # Instantiates a client
    client = vision.ImageAnnotatorClient()

    # Opens the input image file
    with open(infile, "rb") as image_file:
        content = image_file.read()

    image = vision.Image(content=content)

    # For dense text, use document_text_detection
    # For less dense text, use text_detection
    response = client.document_text_detection(image=image)
    text = response.full_text_annotation.text
    print(f"Detected text: {text}")

    return text

Como usar o Translation com glossários

Após extrair o texto de uma imagem, use glossários do Translation para personalizar a tradução dele. Os glossários fornecem traduções predefinidas que modificam as traduções de certos termos da API Cloud Translation.

Os casos de uso do glossário incluem o seguinte:

  • Nomes de produtos: por exemplo, Google Home precisa ser mantido como "Google Home".

  • Palavras ambíguas: por exemplo, a palavra "bat" pode significar um equipamento esportivo ou um animal. Se você souber que está traduzindo palavras sobre esporte, usará um glossário para alimentar a API Cloud Translation com a tradução esportiva de "bat", não com a de animal.

  • Palavras emprestadas: do francês para o inglês, "bouillabaisse" é traduzido como "bouillabaisse". A língua inglesa pegou emprestada a palavra "bouillabaisse" do francês. Um falante de inglês sem o contexto cultural francês pode não saber que "bouillabaisse" é um prato típico de ensopado de peixe. Com os glossários, é possível substituir uma tradução para que "bouillabaisse", em francês, seja traduzido como "fish stew" (ensopado de peixe).

Como criar um arquivo de glossário

A API Cloud Translation aceita arquivos de glossário TSV, CSV ou TMX. Neste tutorial, um arquivo CSV enviado ao Cloud Storage é usado para definir conjuntos de termos equivalentes.

Para criar um arquivo CSV do glossário:

  1. Defina o idioma de uma coluna usando os códigos ISO-639-1 ou BCP-47 na primeira linha do arquivo CSV.

    fr,en,

  2. Liste pares de termos equivalentes em cada linha do arquivo CSV. Separe os termos com vírgulas. No exemplo a seguir, a tradução em inglês de várias palavras francesas sobre culinária é definida.

    fr,en,
    chèvre,goat cheese,
    crème brulée,crème brulée,
    bouillabaisse,fish stew,
    steak frites,steak with french fries,
    

  3. Defina variantes de uma palavra. A API Cloud Translation diferencia maiúsculas e minúsculas, além de caracteres especiais, como palavras acentuadas. Defina explicitamente várias grafias de uma palavra para garantir que o glossário processe as variações dela.

    fr,en,
    chevre,goat cheese,
    Chevre,Goat cheese,
    chèvre,goat cheese,
    Chèvre,Goat cheese,
    crème brulée,crème brulée,
    Crème brulée,Crème brulée,
    Crème Brulée,Crème Brulée,
    bouillabaisse,fish stew,
    Bouillabaisse,Fish stew,
    steak frites,steak with french fries,
    Steak frites,Steak with french fries,
    Steak Frites,Steak with French Fries,
    

  4. Faça upload do glossário para um bucket do Cloud Storage. Neste tutorial, você não precisa fazer upload de um arquivo de glossário para um bucket do Cloud Storage nem criar esse bucket. Em vez disso, use o arquivo de glossário disponível publicamente. Ele foi criado para que não sejam gerados custos do Cloud Storage. Envie o URI de um arquivo de glossário no Cloud Storage para a API Cloud Translation para criar um recurso de glossário. O URI do arquivo de glossário disponível publicamente neste tutorial é gs://cloud-samples-data/translation/bistro_glossary.csv. Para fazer o download do glossário, clique no link do URI acima, mas não o abra em uma nova guia.

Como criar um recurso de glossário

Para usar um glossário, é preciso criar um recurso correspondente com a API Cloud Translation. Para criar um recurso de glossário, envie o URI de um arquivo de glossário no Cloud Storage para a API Cloud Translation.

Verifique se você está usando uma conta de serviço com as permissões de editor da API Cloud Translation e se definiu o ID do projeto no terminal.

Com a função a seguir, você cria um recurso de glossário. Com ele, será possível personalizar a solicitação de tradução na próxima etapa deste tutorial.

def create_glossary(
    languages: list,
    project_id: str,
    glossary_name: str,
    glossary_uri: str,
) -> str:
    """Creates a GCP glossary resource
    Assumes you've already manually uploaded a glossary to Cloud Storage

    Args:
    languages: list of languages in the glossary
    project_id: GCP project id
    glossary_name: name you want to give this glossary resource
    glossary_uri: the uri of the glossary you uploaded to Cloud Storage

    Returns:
    name of the created or existing glossary
    """

    # Instantiates a client
    client = translate.TranslationServiceClient()

    # Designates the data center location that you want to use
    location = "us-central1"

    # Set glossary resource name
    name = client.glossary_path(project_id, location, glossary_name)

    # Set language codes
    language_codes_set = translate.Glossary.LanguageCodesSet(language_codes=languages)

    gcs_source = translate.GcsSource(input_uri=glossary_uri)

    input_config = translate.GlossaryInputConfig(gcs_source=gcs_source)

    # Set glossary resource information
    glossary = translate.Glossary(
        name=name, language_codes_set=language_codes_set, input_config=input_config
    )

    parent = f"projects/{project_id}/locations/{location}"

    # Create glossary resource
    # Handle exception for case in which a glossary
    #  with glossary_name already exists
    try:
        operation = client.create_glossary(parent=parent, glossary=glossary)
        operation.result(timeout=90)
        print("Created glossary " + glossary_name + ".")
    except AlreadyExists:
        print(
            "The glossary "
            + glossary_name
            + " already exists. No new glossary was created."
        )

    return glossary_name

Como traduzir com glossários

Depois de criar um recurso de glossário, é possível usá-lo para personalizar traduções de textos enviados para a API Cloud Translation.

A função a seguir usa o recurso de glossário já criado para personalizar a tradução do texto.

def translate_text(
    text: str,
    source_language_code: str,
    target_language_code: str,
    project_id: str,
    glossary_name: str,
) -> str:
    """Translates text to a given language using a glossary

    Args:
    text: String of text to translate
    source_language_code: language of input text
    target_language_code: language of output text
    project_id: GCP project id
    glossary_name: name you gave your project's glossary
        resource when you created it

    Return:
    String of translated text
    """

    # Instantiates a client
    client = translate.TranslationServiceClient()

    # Designates the data center location that you want to use
    location = "us-central1"

    glossary = client.glossary_path(project_id, location, glossary_name)

    glossary_config = translate.TranslateTextGlossaryConfig(glossary=glossary)

    parent = f"projects/{project_id}/locations/{location}"

    result = client.translate_text(
        request={
            "parent": parent,
            "contents": [text],
            "mime_type": "text/plain",  # mime types: text/plain, text/html
            "source_language_code": source_language_code,
            "target_language_code": target_language_code,
            "glossary_config": glossary_config,
        }
    )

    # Extract translated text from API response
    return result.glossary_translations[0].translated_text

Como usar o Text-to-Speech com a linguagem de marcação de síntese de fala

Agora que você personalizou uma tradução de texto detectado por imagem, use a API Text-to-Speech. Com ela, é possível criar áudios sintéticos do texto traduzido.

A API Text-to-Speech gera um áudio sintético a partir de uma string de texto simples ou marcada com a linguagem de marcação de síntese de fala (SSML, na sigla em inglês). A SSML é compatível com a anotação de texto com tags correspondentes. Use essas tags para determinar como a API Text-to-Speech formata a criação de fala sintética.

A função a seguir converte uma string de SSML em um arquivo MP3 de fala sintética.

def text_to_speech(text: str, outfile: str) -> str:
    """Converts plaintext to SSML and
    generates synthetic audio from SSML

    Args:

    text: text to synthesize
    outfile: filename to use to store synthetic audio

    Returns:
    String of synthesized audio
    """

    # Replace special characters with HTML Ampersand Character Codes
    # These Codes prevent the API from confusing text with
    # SSML commands
    # For example, '<' --> '&lt;' and '&' --> '&amp;'
    escaped_lines = html.escape(text)

    # Convert plaintext to SSML in order to wait two seconds
    #   between each line in synthetic speech
    ssml = "<speak>{}</speak>".format(
        escaped_lines.replace("\n", '\n<break time="2s"/>')
    )

    # Instantiates a client
    client = texttospeech.TextToSpeechClient()

    # Sets the text input to be synthesized
    synthesis_input = texttospeech.SynthesisInput(ssml=ssml)

    # Builds the voice request, selects the language code ("en-US") and
    # the SSML voice gender ("MALE")
    voice = texttospeech.VoiceSelectionParams(
        language_code="en-US", ssml_gender=texttospeech.SsmlVoiceGender.MALE
    )

    # Selects the type of audio file to return
    audio_config = texttospeech.AudioConfig(
        audio_encoding=texttospeech.AudioEncoding.MP3
    )

    # Performs the text-to-speech request on the text input with the selected
    # voice parameters and audio file type

    request = texttospeech.SynthesizeSpeechRequest(
        input=synthesis_input, voice=voice, audio_config=audio_config
    )

    response = client.synthesize_speech(request=request)

    # Writes the synthetic audio to the output file.
    with open(outfile, "wb") as out:
        out.write(response.audio_content)
        print("Audio content written to file " + outfile)

Como tudo funciona em conjunto

Nas etapas anteriores, você definiu funções em hybrid_glossaries.py que usam o Vision, o Translation e o Text-to-Speech. Agora, utilize-as para gerar a fala sintética do texto traduzido da foto a seguir.

O código a seguir chama funções definidas em hybrid_glossaries.py para:

  • criar um recurso de glossário da API Cloud Translation;

  • usar a API Vision para detectar o texto na imagem acima;

  • realizar uma tradução do glossário da API Cloud Translation do texto detectado;

  • gerar a fala sintética do Text-to-Speech do texto traduzido.

def main() -> None:
    """This method is called when the tutorial is run in the Google Cloud
    Translation API. It creates a glossary, translates text to
    French, and speaks the translated text.

    Args:
    None

    Returns:
    None
    """
    # Photo from which to extract text
    infile = "resources/example.png"
    # Name of file that will hold synthetic speech
    outfile = "resources/example.mp3"

    # Defines the languages in the glossary
    # This list must match the languages in the glossary
    #   Here, the glossary includes French and English
    glossary_langs = ["fr", "en"]
    # Name that will be assigned to your project's glossary resource
    glossary_name = "bistro-glossary"
    # uri of .csv file uploaded to Cloud Storage
    glossary_uri = "gs://cloud-samples-data/translation/bistro_glossary.csv"

    created_glossary_name = create_glossary(
        glossary_langs, PROJECT_ID, glossary_name, glossary_uri
    )

    # photo -> detected text
    text_to_translate = pic_to_text(infile)
    # detected text -> translated text
    text_to_speak = translate_text(
        text_to_translate, "fr", "en", PROJECT_ID, created_glossary_name
    )
    # translated text -> synthetic audio
    text_to_speech(text_to_speak, outfile)

Como executar o código

Para executar o código, insira o comando a seguir no diretório clonado hybrid_glossaries no terminal:

python hybrid_tutorial.py

A seguinte resposta é exibida:

Created glossary bistro-glossary.
Audio content written to file resources/example.mp3

Após executar hybrid_glossaries.py, navegue até o diretório resources a partir do diretório hybrid_glossaries. Verifique o diretório de recursos de um arquivo example.mp3.

Ouça o áudio a seguir para verificar se o arquivo example.mp3 é igual.


Como solucionar mensagens de erro

Como fazer a limpeza

Se você não precisar do projeto, use o Console do Google Cloud para excluí-lo. A exclusão do projeto evita outros custos da conta de faturamento do Cloud pelos recursos usados neste tutorial.

Como excluir o projeto

  1. No console do Google Cloud, abra a página "Projetos".
  2. Na lista de projetos, selecione um e clique em Excluir.
  3. Na caixa de diálogo, insira o ID do projeto e clique em Encerrar para excluí-lo.

A seguir

Parabéns! Você acabou de usar o OCR da Vision para detectar texto em uma imagem. Depois, você criou um glossário do Translation e gerou uma tradução com ele. E então, usou o Text-to-Speech para gerar um áudio sintético do texto traduzido.

Para ampliar seus conhecimentos sobre o Vision, o Cloud Translation e o ext-to-Speech, faça o seguinte: