Text aus einem Foto übersetzen

Auf dieser Seite wird beschrieben, wie Sie Text in einem Bild erkennen, Übersetzungen personalisieren und synthetische Sprache aus Text generieren. In dieser Anleitung wird Cloud Vision verwendet, um Text in einer Bilddatei zu erkennen. Anschließend wird gezeigt, wie Sie mithilfe von Cloud Translation eine benutzerdefinierte Übersetzung des erkannten Textes bereitstellen. Schließlich wird mithilfe von Text-to-Speech ein maschinelles Diktat des übersetzten Textes bereitgestellt.

Ziele

Von der Cloud Vision API erkannten Text an die Cloud Translation API übergeben
Cloud Translation-Glossare erstellen und verwenden, um Cloud Translation API-Übersetzungen zu personalisieren
Mit der Text-to-Speech API eine Audiodarstellung für übersetzten Text erstellen

Kosten

Für jede Google Cloud API gilt eine eigene Preisstruktur.

Preisdetails finden Sie im Preisleitfaden zu Cloud Vision, im Preisleitfaden zu Cloud Translation und im Preisleitfaden zu Text-to-Speech.

Vorbereitung

Folgende Voraussetzungen müssen erfüllt sein:

Sie haben ein Projekt in der Google Cloud Console mit der Vision API, der Cloud Translation API und der Text-to-Speech API aktiviert.
Sie haben Grundkenntnisse bezüglich der Programmierung in Python oder NodeJS.

Clientbibliotheken einrichten

In dieser Anleitung werden Vision-, Translation- und Text-to-Speech-Clientbibliotheken verwendet.

Führen Sie die folgenden Befehle über das Terminal aus, um die relevanten Clientbibliotheken zu installieren.

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

Berechtigungen für die Glossarerstellung einrichten

Zum Erstellen von Translation-Glossaren ist ein Dienstkontoschlüssel mit den Cloud Translation API-Bearbeiter-Berechtigungen erforderlich.

So richten Sie einen Dienstkontoschlüssel mit den Cloud Translation API-Bearbeiterberechtigungen ein:

Erstellen Sie ein Dienstkonto:
1. Rufen Sie in der Google Cloud Console die Seite Dienstkonten auf.
  
  Zur Seite „Dienstkonten“
2. Wählen Sie Ihr Projekt aus.
3. Klicken Sie auf Dienstkonto erstellen.
4. Geben Sie im Feld Dienstkontoname einen Namen ein. Die Google Cloud Console füllt das Feld Dienstkonto-ID anhand dieses Namens aus.
5. Optional: Im Feld Beschreibung des Dienstkontos können Sie eine entsprechende Beschreibung eingeben.
6. Klicken Sie auf Erstellen und fortfahren.
7. Klicken Sie auf das Feld Rolle auswählen und wählen Sie Cloud Translation > Cloud Translation API-Bearbeiter aus.
8. Klicken Sie auf Fertig, um das Erstellen des Dienstkontos abzuschließen.
  
  Schließen Sie das Browserfenster nicht. Sie verwenden es in der nächsten Aufgabe.
Laden Sie einen JSON-Schlüssel für das gerade erstellte Dienstkonto herunter:
1. Klicken Sie in der Google Cloud Console auf die E-Mail-Adresse des von Ihnen erstellten Dienstkontos.
2. Klicken Sie auf Schlüssel.
3. Klicken Sie auf Schlüssel hinzufügen > Neuen Schlüssel erstellen.
4. Klicken Sie auf Erstellen. Daraufhin wird eine JSON-Schlüsseldatei auf Ihren Computer heruntergeladen.
  
  Bewahren Sie die Schlüsseldatei sicher auf, da sie zur Authentifizierung als Ihr Dienstkonto verwendet werden kann. Sie können diese Datei beliebig verschieben und umbenennen.
5. Klicken Sie auf Schließen.
Legen Sie im Terminal die Variable GOOGLE_APPLICATION_CREDENTIALS mit dem folgenden Befehl fest. Ersetzen Sie path_to_key durch den Pfad zur heruntergeladenen JSON-Datei, die den neuen Dienstkontoschlüssel enthält.
Linux oder macOS
```
export GOOGLE_APPLICATION_CREDENTIALS=path_to_key
```
Windows
```
set GOOGLE_APPLICATION_CREDENTIALS=path_to_key
```

Bibliotheken importieren

In dieser Anleitung werden die folgenden Systeme und Clientbibliotheken importiert.

Python

Folgen Sie der Einrichtungsanleitung für Python in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Python API.

Richten Sie die Standardanmeldedaten für Anwendungen ein, um sich bei Cloud Translation zu authentifizieren. Weitere Informationen finden Sie unter Authentifizierung für eine lokale Entwicklungsumgebung einrichten.

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

Folgen Sie der Einrichtungsanleitung für Node.js in der Cloud Translation-Kurzanleitung zur Verwendung von Clientbibliotheken, bevor Sie dieses Beispiel anwenden. Weitere Informationen finden Sie in der Referenzdokumentation zu Cloud Translation Node.js API.

// 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');

Projekt-ID festlegen

Sie müssen ein Google Cloud-Projekt für jede Anfrage mit einer Google Cloud API verknüpfen. Legen Sie im Terminal die Umgebungsvariable GCLOUD_PROJECT fest, um Ihr Google Cloud-Projekt zu bestimmen.

Ersetzen Sie im folgenden Befehl project-id durch die ID Ihres Google Cloud-Projekts. Führen Sie den folgenden Befehl über das Terminal aus.

Linux oder macOS

export GCLOUD_PROJECT=project-id

Windows

set GCLOUD_PROJECT=project-id

Vision zum Erkennen von Text in einem Bild verwenden

Verwenden Sie die Vision API, um Text in einem Bild zu erkennen und daraus zu extrahieren. Die Vision API verwendet Optische Zeichenerkennung (Optical Character Recognition, OCR) zur Unterstützung von zwei Features zur Texterkennung: Erkennung von dichtem Text oder DOCUMENT_TEXT_DETECTION und Erkennung von dünn besetztem Text oder TEXT_DETECTION.

Der folgende Code zeigt die Verwendung des Vision API-Features DOCUMENT_TEXT_DETECTION zur Erkennung von Text mit hoher Dichte in einem Foto.

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;
}

Translation mit Glossaren verwenden

Nachdem Sie Text aus einem Bild extrahiert haben, verwenden Sie Translation-Glossare, um die Übersetzung des extrahierten Textes zu personalisieren. Glossare enthalten vordefinierte Übersetzungen, die die Übersetzungen der festgelegten Begriffe in der Cloud Translation API überschreiben.

Anwendungsfälle für Glossare:

Produktnamen: "Google Home" muss beispielsweise mit "Google Home" übersetzt werden.
Mehrdeutige Wörter: Das Wort "Schnecke" kann beispielsweise eine Backware oder ein Tier sein. Wenn Sie wissen, dass Sie Wörter zum Thema Gebäck übersetzen, können Sie ein Glossar in der Cloud Translation API verwenden, damit die richtige Übersetzung für Backwaren und nicht die für das Tier verwendet wird.
Entlehnte Wörter: Beispielsweise wird das französische Wort "Bouillabaisse" im Deutschen mit "Bouillabaisse" übersetzt; es wurde aus dem Französischen entlehnt. Ein Deutscher, dem der kulturelle Kontext Frankreichs fehlt, weiß vielleicht nicht, dass Bouillabaisse ein Fischeintopf ist. Glossare können Übersetzungen überschreiben, sodass das französische Wort "Bouillabaisse" im Deutschen mit "Fischeintopf" übersetzt wird.

Glossardatei erstellen

Die Cloud Translation API akzeptiert Glossardateien der Formate TSV, CSV und TMX. In dieser Anleitung wird eine CSV-Datei verwendet, die in Cloud Storage hochgeladen wurde, um Sätze äquivalenter Begriffe zu definieren.

So erstellen Sie eine Glossardatei im CSV-Format:

Legen Sie die Sprache einer Spalte fest. Verwenden Sie dafür in der ersten Zeile der CSV-Datei den Sprachcode gemäß ISO-639 oder BCP-47.
```
fr,en,
```
Geben Sie Paare äquivalenter Begriffe in jeder Zeile der CSV-Datei an. Trennen Sie Begriffe durch Kommas. Im folgenden Beispiel wird die englische Übersetzung für mehrere kulinarische französische Wörter definiert.
```
fr,en,
chèvre,goat cheese,
crème brulée,crème brulée,
bouillabaisse,fish stew,
steak frites,steak with french fries,
```

Definieren Sie Varianten eines Worts. Bei der Cloud Translation API wird zwischen Groß- und Kleinschreibung unterschieden. Sonderzeichen wie akzentuierte Wörter werden berücksichtigt. Achten Sie darauf, dass Ihr Glossar Varianten eines Worts berücksichtigt. Dazu können Sie verschiedene Schreibweisen des Worts explizit definieren.

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,

Laden Sie das Glossar in einen Cloud Storage-Bucket hoch. Für die Zwecke dieser Anleitung ist es nicht erforderlich, eine Glossardatei in einen Cloud Storage-Bucket hochzuladen oder einen Cloud Storage-Bucket zu erstellen. Verwenden Sie stattdessen die öffentlich verfügbare Glossardatei, die für diese Anleitung erstellt wurde, um Cloud Storage-Kosten zu vermeiden. Senden Sie den URI einer Glossardatei in Cloud Storage an die Cloud Translation API, um eine Glossarressource zu erstellen. Der URI der öffentlich verfügbaren Glossardatei für diese Anleitung ist gs://cloud-samples-data/translation/bistro_glossary.csv. Klicken Sie zum Herunterladen des Glossars auf den obigen URI-Link, aber öffnen Sie ihn nicht in einem neuen Tab.

Glossarressource erstellen

Wenn Sie ein Glossar verwenden möchten, müssen Sie mit der Cloud Translation API eine Glossarressource erstellen. Wenn Sie eine Glossarressource erstellen möchten, senden Sie den URI einer Glossardatei in Cloud Storage an die Cloud Translation API.

Achten Sie darauf, einen Dienstkontoschlüssel mit den Cloud Translation API-Bearbeiter-Berechtigungen zu verwenden und Ihre Projekt-ID über das Terminal festzulegen.

Mit dem folgenden Feature wird eine Glossarressource erstellt. Mit dieser Glossarressource können Sie die Übersetzungsanfrage im nächsten Schritt dieser Anleitung personalisieren.

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.'
    );
  }
}

Mit Glossaren übersetzen

Nachdem Sie eine Glossarressource erstellt haben, können Sie diese Glossarressource verwenden, um Übersetzungen von Text zu personalisieren, den Sie an die Cloud Translation API senden.

Das folgende Feature verwendet die zuvor erstellte Glossarressource, um die Übersetzung von Text zu personalisieren.

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;
}

Text-to-Speech mit Speech Synthesis Markup Language (SSML) verwenden

Nachdem Sie nun eine Übersetzung von in einem Bild erkannten Text personalisiert haben, können Sie die Text-to-Speech API verwenden. Sie kann synthetische Audiodaten des übersetzten Textes erstellen.

Die Text-to-Speech API generiert synthetisches Audio entweder aus einem String aus Nur-Text-Dateien oder aus einem String mit Speech Synthesis Markup Language (SSML). SSML ist eine Auszeichnungssprache, die das Annotieren von Text mit SSML-Tags unterstützt. Mit SSML-Tags können Sie beeinflussen, wie die Text-to-Speech API synthetische Spracherstellung formatiert.

Mit dem folgenden Feature wird ein SSML-String in eine MP3-Datei mit synthetischer Sprache umgewandelt.

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);
}

Zusammenfassung

In den vorherigen Schritten haben Sie Features in hybrid_glossaries.py definiert, die Vision, Translation und Text-to-Speech verwenden. Nun können Sie sie verwenden, um synthetische Sprache des übersetzten Textes aus dem folgenden Foto zu generieren.

Mit dem folgenden Code werden die in hybrid_glossaries.py definierten Features aufgerufen, um folgende Aufgaben auszuführen:

Eine Glossarressource für die Cloud Translation API erstellen
Die Vision API verwenden, um Text im obigen Bild zu erkennen
Eine Übersetzung des erkannten Textes über das Cloud Translation API-Glossar ausführen
Synthetische Text-to-Speech-Sprache des übersetzten Textes erzeugen

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

Code ausführen

Geben Sie zum Ausführen des Codes im Verzeichnis, in dem sich der Code befindet folgenden Befehl ein:

Python

python hybrid_tutorial.py

Node.js

  node hybridGlossaries.js

Die Ausgabe sieht so aus:

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

Gehen Sie nach der Ausführung des Codes zum Verzeichnis resources aus dem Verzeichnis hybrid_glossaries. Suchen Sie im Verzeichnis "resources" nach der Datei example.mp3.

Hören Sie sich den folgenden Audioclip an, um zu überprüfen, ob die Datei example.mp3 gleich klingt.

Fehlermeldungen beheben

```
403 IAM permission 'cloudtranslate.glossaries.create' denied.
```
Mit einem Dienstkontoschlüssel ohne die "Cloud Translation API-Bearbeiter"-Berechtigungen wird diese Ausnahme ausgelöst.
```
KeyError: 'GCLOUD_PROJECT'
```
Wenn Sie die GCLOUD_PROJECT-Variable nicht festlegen, wird dieser Fehler generiert.
```
400 Invalid resource name project id
```
Verwenden Sie entweder einen Glossarnamen, der andere Zeichen als Kleinbuchstaben, Ziffern, Punkte, Doppelpunkte oder Bindestriche enthält, oder verwenden Sie einen Dienstkontoschlüssel ohne die "Cloud Translation API-Bearbeiter"-Berechtigungen.
```
File filename was not found.
```
Wenn Sie die Variable GOOGLE_APPLICATION_CREDENTIALS auf einen ungültigen Dateipfad festlegen, wird diese Ausnahme ausgelöst.

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

Wenn Sie die Variable GOOGLE_APPLICATION_CREDENTIALS nicht festlegen, wird diese Ausnahme ausgelöst.

```
Forbidden: 403 POST API has not been used or is disabled
```
Beim Aufrufen der Cloud Translation API, der Cloud Vision API oder der Text-to-Speech API ohne Aktivierung der zugehörigen APIs wird diese Warnung generiert.
```
AttributeError: 'module' object has no attribute 'escape'
```
Python 2.7.10 oder früher ist nicht mit HTML kompatibel. Verwenden Sie eine virtuelle Python-Umgebung, um diesen Fehler zu beheben. Für die virtuelle Umgebung wird die neueste Version von Python verwendet.
```
UnicodeEncodeError
```
Python 2.7.10 oder früher ist nicht mit HTML kompatibel. Verwenden Sie eine virtuelle Python-Umgebung, um diesen Fehler zu beheben. Für die virtuelle Umgebung wird die neueste Version von Python verwendet.

Bereinigen

Löschen Sie das Projekt mit der Google Cloud Console, wenn Sie es nicht benötigen. Dadurch werden zusätzliche Kosten für die in dieser Anleitung verwendeten Ressourcen für Ihr Cloud-Rechnungskonto vermieden.

Projekt löschen

Öffnen Sie in der Google Cloud Console die Seite "Projekte".
Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie auf Löschen.
Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Herunterfahren, um das Projekt zu löschen.

Nächste Schritte

Glückwunsch! Sie haben gerade Vision OCR verwendet, um Text in einem Bild zu erkennen. Dann haben Sie ein Translation-Glossar erstellt und eine Übersetzung mit diesem Glossar durchgeführt. Anschließend haben Sie Text-to-Speech verwendet, um synthetisches Audio des übersetzten Textes zu generieren.

So erweitern Sie Ihr Wissen über Vision, Translation und Text-to-Speech:

Erstellen Sie Ihr eigenes Glossar. Erstellen Sie einen Cloud Storage-Bucket und laden Sie die CSV-Datei des Glossars in den Bucket hoch.
Testen Sie andere Möglichkeiten zur Verwendung von Translation-Glossaren.
Erlernen Sie die Verwendung von Cloud Storage mit Cloud Vision OCR.
Erlernen Sie die Verwendung von SSML mit Text-to-Speech.
Erlernen Sie die Verwendung des Feldes imageContext der Vision API, um zusätzlichen Kontext zu einem Foto weiterzugeben, wenn Sie Vision OCR verwenden.
Lesen Sie die Community-Anleitungen.