Traduire du texte à partir d'une photo

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

Transmettre le texte reconnu par l'API Cloud Vision à l'API Cloud Translation
Créer et utiliser des glossaires Cloud Translation pour personnaliser les traductions générées par l'API Cloud Translation
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 :

Un projet dans Google Cloud Console, pour lequel les API Vision, Cloud Translation et Text-to-Speech sont activées
Des connaissances de base en programmation Python ou NodeJS

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.

Python

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

Node.js

  npm install --save @google-cloud/vision
  npm install --save @google-cloud/translate
  npm install --save @google-cloud/text-to-speech

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 :

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.
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 Create (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 Close (Fermer).
Dans votre terminal, définissez la variable GOOGLE_APPLICATION_CREDENTIALS à l'aide de la commande suivante. 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.

Python

Avant d'essayer cet exemple, suivez les instructions de configuration pour Python du guide de démarrage rapide de Cloud Translation : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Cloud Translation en langage Python.

Pour vous authentifier auprès de Cloud Translation, configurez le service Identifiants par défaut de l'application. Pour en savoir plus, consultez Configurer l'authentification pour un environnement de développement local.

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

Node.js

Avant d'essayer cet exemple, suivez les instructions de configuration pour Node.js du guide de démarrage rapide de Cloud Translation : Utiliser les bibliothèques clientes. Pour en savoir plus, consultez la documentation de référence de l'API Cloud Translation en langage Node.js.

// Imports the Google Cloud client library
const textToSpeech = require('@google-cloud/text-to-speech');
const translate = require('@google-cloud/translate').v3beta1;
const vision = require('@google-cloud/vision');

// Import other required libraries
const fs = require('fs');
//const escape = require('escape-html');
const util = require('util');

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 GCLOUD_PROJECT à partir du terminal.

Dans la commande suivante, remplacez project-id par votre ID de projet Google Cloud. Exécutez la commande ci-après à partir du terminal.

Linux ou macOS

export GCLOUD_PROJECT=project-id

Windows

set GCLOUD_PROJECT=project-id

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.

Python

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

Node.js

/**
 * Detects text in an image file
 *
 * ARGS
 * inputFile: path to image file
 * RETURNS
 * string of text detected in the input image
 **/
async function picToText(inputFile) {
  // Creates a client
  const client = new vision.ImageAnnotatorClient();

  // Performs text detection on the local file
  const [result] = await client.textDetection(inputFile);
  return result.fullTextAnnotation.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 :

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,
```
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,
```

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,

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.

Python

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

Node.js

/** Creates a GCP glossary resource
 * Assumes you've already manually uploaded a glossary to Cloud Storage
 *
 * ARGS
 * languages: list of languages in the glossary
 * projectId: GCP project id
 * glossaryName: name you want to give this glossary resource
 * glossaryUri: the uri of the glossary you uploaded to Cloud Storage
 * RETURNS
 * nothing
 **/
async function createGlossary(
  languages,
  projectId,
  glossaryName,
  glossaryUri
) {
  // Instantiates a client
  const translationClient = await new translate.TranslationServiceClient();

  // Construct glossary
  const glossary = {
    languageCodesSet: {
      languageCodes: languages,
    },
    inputConfig: {
      gcsSource: {
        inputUri: glossaryUri,
      },
    },
    name: translationClient.glossaryPath(
      projectId,
      'us-central1',
      glossaryName
    ),
  };

  // Construct request
  const request = {
    parent: translationClient.locationPath(projectId, 'us-central1'),
    glossary: glossary,
  };

  // Create glossary using a long-running operation.
  try {
    const [operation] = await translationClient.createGlossary(request);
    // Wait for operation to complete.
    await operation.promise();
    console.log('Created glossary ' + glossaryName + '.');
  } catch (AlreadyExists) {
    console.log(
      'The glossary ' +
        glossaryName +
        ' already exists. No new glossary was created.'
    );
  }
}

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.

Python

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

Node.js

/**
 * Translates text to a given language using a glossary
 *
 * ARGS
 * text: String of text to translate
 * sourceLanguageCode: language of input text
 * targetLanguageCode: language of output text
 * projectId: GCP project id
 * glossaryName: name you gave your project's glossary
 *     resource when you created it
 * RETURNS
 * String of translated text
 **/
async function translateText(
  text,
  sourceLanguageCode,
  targetLanguageCode,
  projectId,
  glossaryName
) {
  // Instantiates a client
  const translationClient = new translate.TranslationServiceClient();
  const glossary = translationClient.glossaryPath(
    projectId,
    'us-central1',
    glossaryName
  );
  const glossaryConfig = {
    glossary: glossary,
  };
  // Construct request
  const request = {
    parent: translationClient.locationPath(projectId, 'us-central1'),
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: sourceLanguageCode,
    targetLanguageCode: targetLanguageCode,
    glossaryConfig: glossaryConfig,
  };

  // Run request
  const [response] = await translationClient.translateText(request);
  // Extract the string of translated text
  return response.glossaryTranslations[0].translatedText;
}

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.

Python

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)

Node.js

/**
 * Generates synthetic audio from plaintext tagged with SSML.
 *
 * Given the name of a text file and an output file name, this function
 * tags the text in the text file with SSML. This function then
 * calls the Text-to-Speech API. The API returns a synthetic audio
 * version of the text, formatted according to the SSML commands. This
 * function saves the synthetic audio to the designated output file.
 *
 * ARGS
 * text: String of plaintext
 * outFile: String name of file under which to save audio output
 * RETURNS
 * nothing
 *
 */
async function syntheticAudio(text, outFile) {
  // Replace special characters with HTML Ampersand Character Codes
  // These codes prevent the API from confusing text with SSML tags
  // For example, '<' --> '&lt;' and '&' --> '&amp;'
  let escapedLines = text.replace(/&/g, '&amp;');
  escapedLines = escapedLines.replace(/"/g, '&quot;');
  escapedLines = escapedLines.replace(/</g, '&lt;');
  escapedLines = escapedLines.replace(/>/g, '&gt;');

  // Convert plaintext to SSML
  // Tag SSML so that there is a 2 second pause between each address
  const expandedNewline = escapedLines.replace(/\n/g, '\n<break time="2s"/>');
  const ssmlText = '<speak>' + expandedNewline + '</speak>';

  // Creates a client
  const client = new textToSpeech.TextToSpeechClient();

  // Constructs the request
  const request = {
    // Select the text to synthesize
    input: {ssml: ssmlText},
    // Select the language and SSML Voice Gender (optional)
    voice: {languageCode: 'en-US', ssmlGender: 'MALE'},
    // Select the type of audio encoding
    audioConfig: {audioEncoding: 'MP3'},
  };

  // Performs the Text-to-Speech request
  const [response] = await client.synthesizeSpeech(request);
  // Write the binary audio content to a local file
  const writeFile = util.promisify(fs.writeFile);
  await writeFile(outFile, response.audioContent, 'binary');
  console.log('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.

Python

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)

Node.js

await createGlossary(glossaryLangs, projectId, glossaryName, glossaryUri);
const text = await picToText(inFile);
const translatedText = await translateText(
  text,
  'fr',
  'en',
  projectId,
  glossaryName
);
syntheticAudio(translatedText, outFile);

Exécuter le code

Pour exécuter le code, saisissez la commande suivante dans le terminal du répertoire où se trouve votre code :

Python

python hybrid_tutorial.py

Node.js

  node hybridGlossaries.js

Le résultat suivant s'affiche :

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

Après avoir exécuté le code, 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

```
403 IAM permission 'cloudtranslate.glossaries.create' denied.
```
Cette exception est générée si vous utilisez une clé de compte de service sans les autorisations "Éditeur de l'API Cloud Translation".
```
KeyError: 'GCLOUD_PROJECT'
```
Cette erreur est générée si vous ne définissez pas votre variable GCLOUD_PROJECT.
```
400 Invalid resource name project id
```
Cette exception est générée si vous utilisez soit un nom de glossaire qui contient des caractères autres que des lettres minuscules, des chiffres, des points, des signes deux-points ou des traits d'union, soit une clé de compte de service sans les autorisations "Éditeur de l'API Cloud Translation".
```
File filename was not found.
```
Cette exception est générée si vous définissez la variable GOOGLE_APPLICATION_CREDENTIALS sur un chemin de fichier non valide.

Could not automatically determine credentials. Please set GOOGLE_APPLICATION_CREDENTIALS or explicitly create credentials and re-run the application

Cette exception est générée si vous omettez de définir la variable GOOGLE_APPLICATION_CREDENTIALS.

```
Forbidden: 403 POST API has not been used or is disabled
```
Cet avertissement est généré en cas d'appel de l'API Cloud Translation, de l'API Cloud Vision ou de l'API Text-to-Speech sans les activer.
```
AttributeError: 'module' object has no attribute 'escape'
```
Python 2.7.10 ou version antérieure n'est pas compatible avec HTML. Pour corriger cette erreur, utilisez un environnement virtuel Python. L'environnement virtuel utilise la dernière version de Python.
```
UnicodeEncodeError
```
Python 2.7.10 ou version antérieure n'est pas compatible avec HTML. Pour corriger cette erreur, utilisez un environnement virtuel Python. L'environnement virtuel utilise la dernière version de Python.

Nettoyer

Utilisez Google Cloud Console 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

Dans Google Cloud Console, accédez à la page Projets.
Dans la liste des projets, sélectionnez celui que vous souhaitez supprimer, puis cliquez sur Supprimer.
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, Translation et Text-to-Speech :

Créez votre propre glossaire. Découvrez comment créer un bucket Cloud Storage et importer votre fichier de glossaire CSV dans le bucket.
Essayez d'autres façons d'utiliser des glossaires Translation.
Découvrez comment utiliser Cloud Storage avec la fonctionnalité OCR de Cloud Vision.
Découvrez comment utiliser le langage SSML avec Text-to-Speech.
Apprenez à utiliser le champ imageContext de l'API Vision pour transmettre du contexte supplémentaire sur une photo lorsque vous utilisez la fonctionnalité OCR de Vision.
Consultez des tutoriels de la communauté.