Obtenir une traduction et une synthèse vocale à partir d'une photo avec des glossaires (version Advanced)

Cette page explique comment détecter du texte dans une image, personnaliser des traductions et générer une voix synthétique à partir d'un texte. Ce tutoriel fait appel à Cloud Vision pour détecter du texte dans un fichier image. Il explique ensuite comment utiliser Cloud Translation pour fournir une traduction personnalisée du texte détecté. Enfin, il utilise Text-to-Speech pour fournir une dictée automatique du texte traduit.

Objectifs

  1. Transmettre le texte reconnu par l'API Cloud Vision à l'API Cloud Translation

  2. Créer et utiliser des glossaires Cloud Translation pour personnaliser les traductions générées par l'API Cloud Translation

  3. Créer une représentation audio du texte traduit à l'aide de l'API Text-to-Speech

Coûts

Chaque API Google Cloud utilise une grille tarifaire distincte.

Pour en savoir plus sur les tarifs, consultez le Guide de tarification Cloud Vision, le Guide de tarification Cloud Translation et le Guide de tarification Text-to-Speech.

Avant de commencer

Vous devez disposer des éléments suivants :

Télécharger les exemples de code

Ce tutoriel utilise du code figurant dans le répertoire samples/snippets/hybrid_glossaries des bibliothèques clientes Cloud pour Python.

Pour télécharger le code pour ce tutoriel et y accéder, exécutez les commandes suivantes depuis le terminal.

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

Configurer des bibliothèques clientes

Ce tutoriel utilise les bibliothèques clientes Vision, Translation et Text-to-Speech.

Pour installer les bibliothèques clientes appropriées, exécutez les commandes suivantes depuis le terminal.

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

Configurer des autorisations pour la création de glossaires

La création de glossaires Translation nécessite l'utilisation d'une clé de compte de service possédant les autorisations "Éditeur de l'API Cloud Translation".

Pour configurer une clé de compte de service possédant les autorisations de l'éditeur de l'API Cloud Translation, procédez comme suit :

  1. Créez un compte de service :

    1. Dans Google Cloud Console, accédez à la page Comptes de service.

      Accéder à la page "Comptes de service"

    2. Sélectionnez votre projet.

    3. Cliquez sur Créer un compte de service.

    4. Dans le champ Nom du compte de service, saisissez un nom. Google Cloud Console remplit le champ ID du compte de service en fonction de ce nom.

    5. Facultatif : dans le champ Description du compte de service, saisissez une description du compte de service.

    6. Cliquez sur Créer et continuer.

    7. Cliquez sur le champ Sélectionner un rôle, puis sélectionnez Cloud Translation > Éditeur de l'API Cloud Translation.

    8. Cliquez sur OK pour terminer la création du compte de service.

      Ne fermez pas la fenêtre de votre navigateur. Vous en aurez besoin lors de la tâche suivante.

  2. Téléchargez une clé JSON pour le compte de service que vous venez de créer :

    1. Dans Google Cloud Console, cliquez sur l'adresse e-mail du compte de service que vous avez créé.
    2. Cliquez sur Keys (Clés).
    3. Cliquez sur Add key (Ajouter une clé), puis sur Create new key (Créer une clé).

    4. Cliquez sur Créer. Un fichier de clé JSON est téléchargé sur votre ordinateur.

      Veillez à stocker le fichier de clé en toute sécurité, car il peut être utilisé pour s'authentifier en tant que compte de service. Vous pouvez déplacer et renommer ce fichier comme vous le souhaitez.

    5. Cliquez sur Fermer.

  3. À partir du dossier hybrid_glossaries dans le terminal, définissez la variable GOOGLE_APPLICATION_CREDENTIALS à l'aide de la commande ci-après. Remplacez path_to_key par le chemin d'accès au fichier JSON téléchargé contenant votre nouvelle clé de compte de service.

    Linux ou macOS

    export GOOGLE_APPLICATION_CREDENTIALS=path_to_key

    Windows

    set GOOGLE_APPLICATION_CREDENTIALS=path_to_key

Importer des bibliothèques

Ce tutoriel utilise les importations système et les importations de bibliothèques clientes ci-après.

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

Définir l'ID de votre projet

Vous devez associer un projet Google Cloud à chaque requête envoyée à une API Google Cloud. Spécifiez votre projet Google Cloud en définissant la variable d'environnement GOOGLE_CLOUD_PROJECT à partir du terminal.

Dans la commande suivante, remplacez PROJECT_NUMBER_OR_ID par le numéro ou l'ID de votre projet Google Cloud. Exécutez la commande ci-après à partir du terminal.

Linux ou macOS

export GOOGLE_CLOUD_PROJECT=PROJECT_NUMBER_OR_ID

Windows

set GOOGLE_CLOUD_PROJECT=PROJECT_NUMBER_OR_ID

Ce tutoriel utilise la variable d'ID de projet globale suivante.

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

Détecter le texte d'une image à l'aide de Vision

Utilisez l'API Vision pour détecter et extraire le texte d'une image. L'API Vision fait appel à la reconnaissance optique des caractères (OCR, Optical Character Recognition) pour prendre en charge deux fonctionnalités de détection de texte : la détection de texte dense, ou DOCUMENT_TEXT_DETECTION, et la détection de texte épars, ou TEXT_DETECTION.

Le code suivant montre comment utiliser la fonctionnalité DOCUMENT_TEXT_DETECTION de l'API Vision pour détecter du texte dans une photo comprenant du texte dense. 

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

Utiliser Translation avec des glossaires

Après avoir extrait du texte d'une image, utilisez les glossaires Translation pour personnaliser la traduction du texte extrait. Les glossaires fournissent des traductions prédéfinies qui remplacent les traductions de l'API Cloud Translation pour les termes désignés.

Voici des cas d'utilisation de glossaires :

  • Noms de produits : par exemple, Google Home doit être traduit par Google Home.

  • Mots ambigus : par exemple, le mot "avocat" peut désigner une profession ou un aliment. Si vous savez que vous traduisez un texte juridique, vous pouvez utiliser un glossaire pour indiquer à l'API Cloud Translation que la traduction juridique du mot "avocat" doit être employée, et non la traduction correspondant à l'aliment.

  • Emprunts : par exemple, le mot "bouillabaisse" en français est traduit par "bouillabaisse" en anglais. L'anglais a emprunté le mot "bouillabaisse" au français. Si un anglophone ne connaît pas le contexte culturel français, il ne sait peut-être pas que la bouillabaisse est un plat français à base de poisson. Un glossaire permet de remplacer une traduction de sorte que le mot "bouillabaisse" en français soit traduit par "fish stew" (ragoût de poisson) en anglais.

Créer un fichier de glossaire

L'API Cloud Translation accepte les fichiers de glossaire TSV, CSV ou TMX. Ce tutoriel utilise un fichier CSV importé dans Cloud Storage pour définir des ensembles de termes équivalents.

Pour créer un fichier de glossaire CSV :

  1. Spécifiez la langue d'une colonne à l'aide des codes de langue ISO-639 ou BCP-47 dans la première ligne du fichier CSV.

    fr,en,

  2. Répertoriez les paires de termes équivalents sur chaque ligne du fichier CSV. Séparez les termes par des virgules. L'exemple suivant définit la traduction en anglais de plusieurs termes culinaires français. 

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

  3. Définissez les variantes d'un mot. L'API Cloud Translation est sensible à la casse et aux caractères spéciaux tels que les accents. Assurez-vous que votre glossaire gère les variantes d'un mot en définissant explicitement ses différentes orthographes. 

    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. Importez le glossaire dans un bucket Cloud Storage. Dans le cadre de ce tutoriel, vous n'avez pas besoin d'importer un fichier de glossaire dans un bucket Cloud Storage ni de créer un bucket Cloud Storage. Utilisez plutôt le fichier de glossaire accessible au public créé pour ce tutoriel afin d'éviter que des frais liés à Cloud Storage ne vous soient facturés. Envoyez l'URI d'un fichier de glossaire dans Cloud Storage à l'API Cloud Translation pour créer une ressource de glossaire. L'URI du fichier de glossaire accessible au public pour ce tutoriel est gs://cloud-samples-data/translation/bistro_glossary.csv. Pour télécharger le glossaire, cliquez sur le lien URI ci-dessus, mais ne l'ouvrez pas dans un nouvel onglet.

Créer une ressource de glossaire

Pour utiliser un glossaire, vous devez créer une ressource de glossaire avec l'API Cloud Translation. Pour créer une ressource de glossaire, envoyez l'URI d'un fichier de glossaire dans Cloud Storage à l'API Cloud Translation.

Assurez-vous que vous utilisez une clé de compte de service possédant les autorisations "Éditeur de l'API Cloud Translation" et que vous avez défini l'ID du projet depuis le terminal.

La fonction suivante crée une ressource de glossaire. Grâce à cette ressource de glossaire, vous pouvez personnaliser la requête de traduction à l'étape suivante de ce tutoriel. 

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

Traduire avec des glossaires

Une fois que vous avez créé une ressource de glossaire, vous pouvez l'utiliser pour personnaliser les traductions du texte que vous envoyez à l'API Cloud Translation.

La fonction suivante utilise la ressource de glossaire créée précédemment pour personnaliser la traduction du texte. 

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

Utiliser Text-to-Speech avec le langage de balisage de synthèse vocale

Maintenant que vous avez personnalisé une traduction du texte détecté dans l'image, vous êtes prêt à utiliser l'API Text-to-Speech. Cette API peut créer un son synthétique du texte traduit.

L'API Text-to-Speech génère un son synthétique à partir d'une chaîne de texte brut ou d'une chaîne de texte balisée avec le langage de balisage de synthèse vocale (SSML, Speech Synthesis Markup Language). SSML est un langage de balisage qui accepte l'annotation de texte avec des balises SSML. Vous pouvez utiliser des balises SSML pour influencer la façon dont l'API Text-to-Speech formate la création de la voix synthétique.

La fonction suivante convertit une chaîne au format SSML en fichier MP3 de voix synthétique. 

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)

Synthèse

Au cours des étapes précédentes, vous avez défini des fonctions dans hybrid_glossaries.py qui utilisent Vision, Translation et Text-to-Speech. Vous êtes maintenant prêt à utiliser ces fonctions pour générer une voix synthétique du texte traduit à partir de la photo suivante.

Le code suivant appelle les fonctions définies dans hybrid_glossaries.py pour :

  • créer une ressource de glossaire de l'API Cloud Translation ;

  • utiliser l'API Vision pour détecter du texte dans l'image ci-dessus ;

  • effectuer une traduction du texte détecté à l'aide des glossaires de l'API Cloud Translation ;

  • générer la voix synthétique Text-to-Speech du texte traduit.

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)

Exécuter le code

Pour exécuter le code, saisissez la commande suivante dans le terminal de votre répertoire hybrid_glossaries cloné :

python hybrid_tutorial.py

Le résultat suivant s'affiche :

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

Après avoir exécuté hybrid_glossaries.py, accédez au répertoire resources à partir du répertoire hybrid_glossaries. Recherchez un fichier example.mp3 dans le répertoire "resources".

Écoutez le clip audio suivant pour vérifier que votre fichier example.mp3 est ressemblant.


Dépanner des messages d'erreur

Nettoyer

Utilisez la console Google Cloud pour supprimer votre projet, si vous n'en avez plus besoin. En supprimant votre projet, vous évitez que des frais supplémentaires ne soient facturés sur votre compte de facturation Cloud pour les ressources utilisées dans ce tutoriel.

Supprimer le projet

  1. Dans Google Cloud Console, accédez à la page Projets.
  2. Dans la liste des projets, sélectionnez celui que vous souhaitez supprimer, puis cliquez sur Supprimer.
  3. Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour le supprimer.

Étape suivante

Félicitations ! Vous venez d'utiliser la fonctionnalité OCR de Vision pour détecter du texte dans une image. Vous avez ensuite créé un glossaire Translation et effectué une traduction avec celui-ci. Puis, vous avez généré le son synthétique du texte traduit à l'aide de Text-to-Speech.

Pour développer vos connaissances concernant Vision, Cloud Translation et Text-to-Speech :