Traduire des documents

Cloud Translation Advanced fournit l'API Document Translation pour traduire directement des documents dans des formats tels que PDF et DOCX. Par rapport aux traductions de texte brut, la traduction de documents conserve la mise en forme et la mise en page d'origine dans vos documents traduits, ce qui vous permet de conserver une grande partie du contexte d'origine, comme les sauts de paragraphe.

Les sections suivantes décrivent comment traduire des documents et utiliser Document Translation avec d'autres fonctionnalités de Cloud Translation Advanced, telles que des glossaires et des modèles AutoML Translation. Document Translation est compatible avec les requêtes de traduction en ligne et par lots.

Pour les traductions en texte brut et HTML, consultez Traduire du texte.

Formats de fichiers acceptés

Document Translation accepte les types de fichiers d'entrée et les types de fichiers de sortie associés suivants.

Entrées Type MIME du document Sortie
DOC* application/msword DOC, DOCX
DOCX* application/vnd.openxmlformats-officedocument.wordprocessingml.document DOCX
PDF† application/pdf PDF, DOCX
PPT application/vnd.ms-powerpoint PPT, PPTX
PPTX application/vnd.openxmlformats-officedocument.presentationml.presentation PPTX
XLS application/vnd.ms-excel XLS, XLSX
XLSX application/vnd.openxmlformats-officedocument.spreadsheetml.sheet XLSX

* Le contenu des zones de texte n'est pas traduit et reste dans la langue source.

* Document Translation accepte les documents PDF natifs et scannés, à quelques différences près. Pour une gestion optimale du format, utilisez si possible des fichiers PDF natifs. La traduction des fichiers PDF scannés entraîne une perte de mise en forme. Les mises en page PDF complexes peuvent également entraîner une perte de mise en forme, qui peut inclure des tables de données, des mises en page à plusieurs colonnes, et des graphiques avec des libellés ou des légendes.

Si vous avez du contenu PDF au format DOCX ou PPTX, nous vous recommandons de le traduire en utilisant ces formats avant de les convertir en PDF. En général, Document Translation conserve mieux la mise en page et le style des fichiers DOCX et PPTX que des fichiers PDF. Après la traduction d'un document, vous pouvez convertir les résultats en fichiers PDF.

Traduction de documents PDF natifs et scannés

Document Translation est compatible avec les fichiers PDF natifs et scannés, y compris les traductions vers ou depuis les langues s'écrivant de droite à gauche. L'assistance pour les conversions PDF en DOCX n'est disponible que pour les traductions de documents par lots sur des fichiers PDF natifs. En outre, Document Translation ne conserve les liens hypertexte, la taille et la couleur de police que sur des fichiers PDF natifs (pour les traductions synchrones et par lots).

Avant de commencer

Pour pouvoir utiliser l'API Cloud Translation, vous devez disposer d'un projet pour lequel cette API est activée, ainsi que des identifiants appropriés. Vous pouvez également installer des bibliothèques clientes pour les langages de programmation courants afin de faciliter les appels à l'API. Pour en savoir plus, consultez la page Configuration.

Autorisations requises

Pour les requêtes nécessitant un accès à Cloud Storage, telles que la traduction de documents par lots, vous pouvez avoir besoin des autorisations Cloud Storage pour lire les fichiers d'entrée ou envoyer des fichiers de sortie à un bucket. Par exemple, pour lire des fichiers d'entrée à partir d'un bucket, vous devez disposer au minimum des autorisations de lecture des objets (fournies par le rôle roles/storage.objectViewer) sur le bucket. Pour en savoir plus sur les rôles Cloud Storage, consultez la documentation associée.

Traduire des documents (en ligne)

La traduction en ligne permet de traiter en temps réel (traitement synchrone) un fichier unique.

Pour les PDF, la taille maximale du fichier est de 20 Mo et de 300 pages pour les PDF natifs (la valeur du champ isTranslateNativePdfOnly doit être true). Si vous activez le champ enableShadowRemovalNativePdf, la limite est de 20 pages. Pour les PDF scannés, la limite est de 20 pages.

Pour les autres types de documents, la taille du fichier peut atteindre 20 Mo sans limite de page.

Traduire un document à partir de Cloud Storage

L'exemple suivant traduit un fichier à partir d'un bucket Cloud Storage et génère le résultat dans un bucket Cloud Storage. La réponse renvoie également un flux d'octets. Vous pouvez spécifier le type MIME. Si vous ne le faites pas, Document Translation le détermine à l'aide de l'extension du fichier d'entrée.

Si vous ne spécifiez pas de code de langue source, Document Translation détecte la langue pour vous. La langue détectée est incluse dans la sortie dans le champ detectedLanguageCode.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_NUMBER_OR_ID : ID numérique ou alphanumérique de votre projet Google Cloud.
  • LOCATION : région dans laquelle vous souhaitez exécuter cette opération. Exemple : us-central1.
  • SOURCE_LANGUAGE (facultatif) : code de langue du document d'entrée. Si vous le connaissez, définissez l'un des codes de langue répertoriés dans la page Langues acceptées.
  • TARGET_LANGUAGE : langue cible dans laquelle traduire le document d'entrée. Définissez l'un des codes de langue répertoriés dans la page Langues acceptées.
  • INPUT_FILE_PATH : emplacement Cloud Storage et nom de fichier du document d'entrée.
  • OUTPUT_FILE_PREFIX : emplacement Cloud Storage où le document de sortie sera stocké.
  • IS_NATIVE (facultatif) : pour les documents PDF natifs, une valeur booléenne indique si votre requête utilise la limite de pages PDF natives ou analysées. Si la valeur est "true", la limite de pages est augmentée à 300 pour les documents PDF natifs uniquement. Si la valeur est "false" ou non spécifiée, la limite de pages PDF analysées est utilisée (20 pages).

Méthode HTTP et URL : 

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION:translateDocument

Corps JSON de la requête :

{
  "source_language_code": "SOURCE_LANGUAGE",
  "target_language_code": "TARGET_LANGUAGE",
  "document_input_config": {
    "gcsSource": {
      "inputUri": "gs://INPUT_FILE_PATH"
    }
  },
  "document_output_config": {
    "gcsDestination": {
      "outputUriPrefix": "gs://OUTPUT_FILE_PREFIX"
    }
  },
  "isTranslateNativePdfOnly": IS_NATIVE
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "documentTranslation": {
    "byteStreamOutputs": ["BYTE_STREAM"],
    "mimeType": "MIME_TYPE"
  },
  "model": "projects/PROJECT_NUMBER/locations/LOCATION/models/general/nmt"
}

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.

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. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'global';
// const inputUri = 'path_to_your_file';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate').v3beta1;

// Instantiates a client
const translationClient = new TranslationServiceClient();

const documentInputConfig = {
  gcsSource: {
    inputUri: inputUri,
  },
};

async function translateDocument() {
  // Construct request
  const request = {
    parent: translationClient.locationPath(projectId, location),
    documentInputConfig: documentInputConfig,
    sourceLanguageCode: 'en-US',
    targetLanguageCode: 'sr-Latn',
  };

  // Run request
  const [response] = await translationClient.translateDocument(request);

  console.log(
    `Response: Mime Type - ${response.documentTranslation.mimeType}`
  );
}

translateDocument();

Traduire un document intégré

L'exemple suivant envoie un document intégré au sein de la requête. Vous devez inclure le type MIME pour les traductions de documents intégrés.

Si vous ne spécifiez pas de code de langue source, Document Translation détecte la langue pour vous. La langue détectée est incluse dans la sortie dans le champ detectedLanguageCode.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_NUMBER_OR_ID : ID numérique ou alphanumérique de votre projet Google Cloud.
  • LOCATION : région dans laquelle vous souhaitez exécuter cette opération. Exemple : us-central1.
  • SOURCE_LANGUAGE (facultatif) : code de langue du document d'entrée. Si vous le connaissez, définissez l'un des codes de langue répertoriés dans la page Langues acceptées.
  • TARGET_LANGUAGE : langue cible dans laquelle traduire le document d'entrée. Définissez l'un des codes de langue répertoriés dans la page Langues acceptées.
  • MIME_TYPE : format du document source, tel que application/pdf.
  • INPUT_BYTE_STREAM : contenu du document d'entrée représenté sous forme de flux d'octets.
  • OUTPUT_FILE_PREFIX : emplacement Cloud Storage où le document de sortie sera stocké.
  • IS_NATIVE (facultatif) : pour les documents PDF natifs, une valeur booléenne indique si votre requête utilise la limite de pages PDF natives ou analysées. Si la valeur est "true", la limite de pages est augmentée à 300 pour les documents PDF natifs uniquement. Si la valeur est "false" ou non spécifiée, la limite de pages PDF analysées est utilisée (20 pages).

Méthode HTTP et URL : 

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION:translateDocument

Corps JSON de la requête :

{
  "source_language_code": "SOURCE_LANGUAGE",
  "target_language_code": "TARGET_LANGUAGE",
  "document_input_config": {
    "mimeType": "MIME_TYPE",
    "content": "INPUT_BYTE_STREAM"
  },
  "document_output_config": {
    "gcsDestination": {
      "outputUriPrefix": "gs://OUTPUT_FILE_PREFIX"
    }
  },
  "isTranslateNativePdfOnly": IS_NATIVE
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "documentTranslation": {
    "byteStreamOutputs": ["BYTE_STREAM"],
    "mimeType": "MIME_TYPE"
  },
  "model": "projects/PROJECT_NUMBER/locations/LOCATION/models/general/nmt"
}

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. 

from google.cloud import translate_v3beta1 as translate

def translate_document(
    project_id: str,
    file_path: str,
) -> translate.TranslationServiceClient:
    """Translates a document.

    Args:
        project_id: The GCP project ID.
        file_path: The path to the file to be translated.

    Returns:
        The translated document.
    """

    client = translate.TranslationServiceClient()
    location = "us-central1"
    parent = f"projects/{project_id}/locations/{location}"

    # Supported file types: https://cloud.google.com/translate/docs/supported-formats
    with open(file_path, "rb") as document:
        document_content = document.read()

    document_input_config = {
        "content": document_content,
        "mime_type": "application/pdf",
    }

    response = client.translate_document(
        request={
            "parent": parent,
            "target_language_code": "fr-FR",
            "document_input_config": document_input_config,
        }
    )

    # To output the translated document, uncomment the code below.
    # f = open('/tmp/output', 'wb')
    # f.write(response.document_translation.byte_stream_outputs[0])
    # f.close()

    # If not provided in the TranslationRequest, the translated file will only be returned through a byte-stream
    # and its output mime type will be the same as the input file's mime type
    print(
        f"Response: Detected Language Code - {response.document_translation.detected_language_code}"
    )

    return response

Utiliser un modèle AutoML ou un glossaire

Au lieu du modèle géré par Google, vous pouvez utiliser vos propres modèles AutoML Translation pour traduire des documents. En plus de spécifier un modèle, vous pouvez également inclure un glossaire afin de gérer la terminologie spécifique à un domaine. Si vous spécifiez un modèle ou un glossaire, vous devez spécifier la langue source. L'exemple suivant utilise un modèle AutoML et un glossaire. Si le modèle ou le glossaire se trouve dans un projet différent, vous devez disposer de l'autorisation IAM correspondante pour accéder à ces ressources.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_NUMBER_OR_ID : ID numérique ou alphanumérique de votre projet Google Cloud.
  • LOCATION : région dans laquelle vous souhaitez exécuter cette opération, par exemple us-central1. L'emplacement doit correspondre à la région dans laquelle se trouve le modèle, le glossaire ou les deux.
  • SOURCE_LANGUAGE : code de langue du document d'entrée. Définissez l'un des codes de langue répertoriés dans la page Langues acceptées.
  • TARGET_LANGUAGE : langue cible dans laquelle traduire le document d'entrée. Définissez l'un des codes de langue répertoriés dans la page Langues acceptées.
  • INPUT_FILE_PATH : emplacement Cloud Storage et nom de fichier du document d'entrée.
  • OUTPUT_FILE_PREFIX : emplacement Cloud Storage où le document de sortie sera stocké.
  • MODEL_PROJECT_ID : ID du projet dans lequel se trouve le modèle.
  • MODEL_LOCATION : région où se trouve le modèle.
  • MODEL_ID : ID du modèle à utiliser.
  • GLOSSARY_PROJECT_ID : ID du projet dans lequel se trouve le glossaire.
  • GLOSSARY_LOCATION : région où se trouve le glossaire.
  • GLOSSARY_ID : ID du glossaire à utiliser.

Méthode HTTP et URL :

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION:translateDocument

Corps JSON de la requête :

{
  "source_language_code": "SOURCE_LANGUAGE",
  "target_language_code": "TARGET_LANGUAGE",
  "document_input_config": {
    "gcsSource": {
      "inputUri": "gs://INPUT_FILE_PATH"
    }
  },
  "document_output_config": {
    "gcsDestination": {
      "outputUriPrefix": "gs://OUTPUT_FILE_PREFIX"
    }
  },
  "model": "projects/MODEL_PROJECT_ID/locations/MODEL_LOCATION/models/MODEL_ID",
  "glossary_config": {
    "glossary": "projects/GLOSSARY_PROJECT_ID/locations/MODEL_LOCATION/glossaries/GLOSSARY_ID"
  }
}

Pour envoyer votre requête, développez l'une des options suivantes :

Vous devriez recevoir une réponse JSON de ce type :

{
  "documentTranslation": {
    "byteStreamOutputs": ["BYTE_STREAM"],
    "mimeType": "MIME_TYPE"
  },
  "glossary_document_translation": {
    "byteStreamOutputs": ["BYTE_STREAM_USING_GLOSSARY"],
    "mimeType": "MIME_TYPE"
  },
  "model": "projects/MODEL_PROJECT_ID/locations/MODEL_LOCATION/models/MODEL_ID",
  "glossaryConfig": {
    "glossary": "projects/GLOSSARY_PROJECT_ID/locations/MODEL_LOCATION/glossaries/GLOSSARY_ID"
  }
}

Traduire des documents (par lots)

La traduction par lots vous permet de traduire plusieurs fichiers dans plusieurs langues en une seule requête. Pour chaque requête, vous pouvez envoyer jusqu'à 100 fichiers dont la taille totale de contenu peut atteindre 1 Go ou 100 millions de points de code Unicode, selon la limite atteinte en premier. Vous pouvez spécifier un modèle de traduction particulier pour chaque langue.

Traduire plusieurs documents

L'exemple suivant inclut plusieurs configurations d'entrée. Chaque configuration d'entrée est un pointeur vers un fichier dans un bucket Cloud Storage.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_NUMBER_OR_ID : ID numérique ou alphanumérique de votre projet Google Cloud.
  • LOCATION : région dans laquelle vous souhaitez exécuter cette opération. Exemple : us-central1.
  • SOURCE_LANGUAGE : code de langue des documents d'entrée. Définissez l'un des codes de langue répertoriés dans la page Langues acceptées.
  • TARGET_LANGUAGE : langue ou langues cibles dans lesquelles traduire les documents d'entrée. Utilisez les codes de langue répertoriés dans la page Langues acceptées.
  • INPUT_FILE_PATH : emplacement Cloud Storage et nom de fichier d'un ou de plusieurs documents d'entrée.
  • OUTPUT_FILE_PREFIX : emplacement Cloud Storage où seront stockés tous les documents de sortie.

Méthode HTTP et URL :

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION:batchTranslateDocument

Corps JSON de la requête :

{
  "source_language_code": "SOURCE_LANGUAGE",
  "target_language_codes": ["TARGET_LANGUAGE", ...],
  "input_configs": [
    {
      "gcsSource": {
        "inputUri": "gs://INPUT_FILE_PATH_1"
      }
    },
    {
      "gcsSource": {
        "inputUri": "gs://INPUT_FILE_PATH_2"
      }
    },
    ...
  ],
  "output_config": {
    "gcsDestination": {
      "outputUriPrefix": "gs://OUTPUT_FILE_PREFIX"
    }
  }
}

Pour envoyer votre requête, développez l'une des options suivantes :

La réponse contient l'ID d'une opération de longue durée. 
{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.translation.v3.BatchTranslateDocumentMetadata",
    "state": "RUNNING"
  }
}

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.

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. 

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const inputUri = 'path_to_your_files';
// const outputUri = 'path_to_your_output_bucket';

// Imports the Google Cloud Translation library
const {TranslationServiceClient} = require('@google-cloud/translate').v3beta1;

// Instantiates a client
const translationClient = new TranslationServiceClient();

const documentInputConfig = {
  gcsSource: {
    inputUri: inputUri,
  },
};

async function batchTranslateDocument() {
  // Construct request
  const request = {
    parent: translationClient.locationPath(projectId, location),
    documentInputConfig: documentInputConfig,
    sourceLanguageCode: 'en-US',
    targetLanguageCodes: ['sr-Latn'],
    inputConfigs: [
      {
        gcsSource: {
          inputUri: inputUri,
        },
      },
    ],
    outputConfig: {
      gcsDestination: {
        outputUriPrefix: outputUri,
      },
    },
  };

  // Batch translate documents using a long-running operation.
  // You can wait for now, or get results later.
  const [operation] = await translationClient.batchTranslateDocument(request);

  // Wait for operation to complete.
  const [response] = await operation.promise();

  console.log(`Total Pages: ${response.totalPages}`);
}

batchTranslateDocument();

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. 


from google.cloud import translate_v3beta1 as translate

def batch_translate_document(
    input_uri: str,
    output_uri: str,
    project_id: str,
    timeout: int = 180,
) -> translate.BatchTranslateDocumentResponse:
    """Batch translate documents.

    Args:
        input_uri: Google Cloud Storage location of the input document.
        output_uri: Google Cloud Storage location of the output document.
        project_id: The GCP project ID.
        timeout: The timeout for this request.

    Returns:
        Translated document response
    """
    client = translate.TranslationServiceClient()

    # The ``global`` location is not supported for batch translation
    location = "us-central1"

    # Google Cloud Storage location for the source input. This can be a single file
    # (for example, ``gs://translation-test/input.docx``) or a wildcard
    # (for example, ``gs://translation-test/*``).
    # Supported file types: https://cloud.google.com/translate/docs/supported-formats
    gcs_source = {"input_uri": input_uri}

    batch_document_input_configs = {
        "gcs_source": gcs_source,
    }
    gcs_destination = {"output_uri_prefix": output_uri}
    batch_document_output_config = {"gcs_destination": gcs_destination}
    parent = f"projects/{project_id}/locations/{location}"

    # Supported language codes: https://cloud.google.com/translate/docs/language
    operation = client.batch_translate_document(
        request={
            "parent": parent,
            "source_language_code": "en-US",
            "target_language_codes": ["fr-FR"],
            "input_configs": [batch_document_input_configs],
            "output_config": batch_document_output_config,
        }
    )

    print("Waiting for operation to complete...")
    response = operation.result(timeout)

    print(f"Total Pages: {response.total_pages}")

    return response

Traduire et convertir un fichier PDF natif

L'exemple suivant traduit et convertit un fichier PDF natif en fichier DOCX. Vous pouvez spécifier plusieurs entrées de différents types de fichiers. Il n'est pas nécessaire que ces fichiers soient des fichiers PDF natifs. Toutefois, les fichiers PDF scannés ne peuvent pas être inclus lors d'une conversion. La requête est rejetée et aucune traduction n'est effectuée. Seuls les fichiers PDF natifs sont traduits et convertis en fichiers DOCX. Par exemple, si vous incluez des fichiers PPTX, ils sont traduits et renvoyés en fichiers PPTX.

Si vous traduisez régulièrement des fichiers PDF scannés et natifs, nous vous recommandons de les organiser en buckets Cloud Storage distincts. De cette façon, lorsque vous demandez une traduction par lot et une conversion, vous pouvez facilement exclure le bucket qui contient les fichiers PDF scannés au lieu d'avoir à exclure des fichiers individuels.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_NUMBER_OR_ID : ID numérique ou alphanumérique de votre projet Google Cloud.
  • LOCATION : région dans laquelle vous souhaitez exécuter cette opération. Exemple : us-central1.
  • SOURCE_LANGUAGE : code de langue des documents d'entrée. Définissez l'un des codes de langue répertoriés dans la page Langues acceptées.
  • TARGET_LANGUAGE : langue ou langues cibles dans lesquelles traduire les documents d'entrée. Utilisez les codes de langue répertoriés dans la page Langues acceptées.
  • INPUT_FILE_PATH : emplacement Cloud Storage, et nom d'un ou de plusieurs fichiers PDF natifs.
  • OUTPUT_FILE_PREFIX : emplacement Cloud Storage où seront stockés tous les documents de sortie.

Méthode HTTP et URL :

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION:batchTranslateDocument

Corps JSON de la requête :

{
  "source_language_code": "SOURCE_LANGUAGE",
  "target_language_codes": ["TARGET_LANGUAGE", ...],
  "input_configs": [
    {
      "gcsSource": {
        "inputUri": "gs://INPUT_FILE_PATH_1"
      }
    },
    {
      "gcsSource": {
        "inputUri": "gs://INPUT_FILE_PATH_2"
      }
    },
    ...
  ],
  "output_config": {
    "gcsDestination": {
      "outputUriPrefix": "gs://OUTPUT_FILE_PREFIX"
    }
  },
  "format_conversions": {
    "application/pdf": "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
  }
}

Pour envoyer votre requête, développez l'une des options suivantes :

La réponse contient l'ID d'une opération de longue durée. 
{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.translation.v3.BatchTranslateDocumentMetadata",
    "state": "RUNNING"
  }
}

Utiliser un modèle AutoML ou un glossaire

Au lieu du modèle géré par Google, vous pouvez utiliser vos propres modèles AutoML Translation pour traduire des documents. En plus de spécifier un modèle, vous pouvez également inclure un glossaire afin de gérer la terminologie spécifique à un domaine. Si vous spécifiez un modèle ou un glossaire, vous devez spécifier la langue source. L'exemple suivant utilise un modèle AutoML et un glossaire. Vous pouvez spécifier jusqu'à 10 langues cibles avec leur propre modèle et glossaire.

Si vous spécifiez un modèle pour certaines langues cibles et pas pour d'autres, Document Translation utilise le modèle géré par Google pour les langues non spécifiées. De même, si vous spécifiez un glossaire pour certaines langues cibles, Document Translation n'utilise aucun glossaire pour les langues non spécifiées.

REST

Avant d'utiliser les données de requête ci-dessous, effectuez les remplacements suivants :

  • PROJECT_NUMBER_OR_ID : ID numérique ou alphanumérique de votre projet Google Cloud.
  • LOCATION : région dans laquelle vous souhaitez exécuter cette opération, par exemple us-central1. L'emplacement doit correspondre à la région dans laquelle se trouve le modèle, le glossaire ou les deux.
  • SOURCE_LANGUAGE : code de langue des documents d'entrée. Définissez l'un des codes de langue répertoriés dans la page Langues acceptées.
  • TARGET_LANGUAGE : langue ou langues cibles dans lesquelles traduire les documents d'entrée. Utilisez les codes de langue répertoriés dans la page Langues acceptées.
  • INPUT_FILE_PATH : emplacement Cloud Storage et nom de fichier d'un ou de plusieurs documents d'entrée.
  • OUTPUT_FILE_PREFIX : emplacement Cloud Storage où seront stockés tous les documents de sortie.
  • MODEL_PROJECT_ID : ID du projet dans lequel se trouve le modèle.
  • MODEL_LOCATION : région où se trouve le modèle.
  • MODEL_ID : ID du modèle à utiliser.
  • GLOSSARY_PROJECT_ID : ID du projet dans lequel se trouve le glossaire.
  • GLOSSARY_LOCATION : région où se trouve le glossaire.
  • GLOSSARY_ID : ID du glossaire à utiliser.

Méthode HTTP et URL :

POST https://translation.googleapis.com/v3/projects/PROJECT_NUMBER_OR_ID/locations/LOCATION:translateDocument

Corps JSON de la requête :

{
  "source_language_code": "SOURCE_LANGUAGE",
  "target_language_codes": "[TARGET_LANGUAGE, ...]",
  "input_configs": [
    {
      "gcsSource": {
        "inputUri": "gs://INPUT_FILE_PATH"
      }
    }
  ],
  "output_config": {
    "gcsDestination": {
      "outputUriPrefix": "gs://OUTPUT_FILE_PREFIX"
    }
  },
  "models": {
    "TARGET_LANGUAGE": "projects/MODEL_PROJECT_ID/locations/MODEL_LOCATION/models/MODEL_ID",
    ...
  },
  "glossaries": {
    "TARGET_LANGUAGE": {
      "glossary": "projects/GLOSSARY_PROJECT_ID/locations/MODEL_LOCATION/glossaries/GLOSSARY_ID"
    },
    ...
  }
}

Pour envoyer votre requête, développez l'une des options suivantes :

La réponse contient l'ID d'une opération de longue durée. 
{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.translation.v3.BatchTranslateDocumentMetadata",
    "state": "RUNNING"
  }
}

Superposition de textes

Dans certains cas, les traductions de PDF natifs peuvent inclure du texte traduit superposé au texte source. Ce problème est appelé "texte fantôme" (shadow text).

Dans certains cas, vous pouvez supprimer ce texte fantôme en activant l'option enableShadowRemovalNativePdf. Si vous activez cette option, la latence de réponse augmente et, pour les traductions de documents en ligne, la limite de pages est réduite à 20. Vous ne pouvez savoir si votre document nécessite la suppression de texte fantôme qu'après sa traduction.

Dans d'autres cas, si l'option enableShadowRemovalNativePdf ne fonctionne pas, convertissez le PDF en image, puis traduisez-le. Ces cas correspondent généralement à des documents comprenant des couches de texte superposées, par exemple du texte sélectionnable qui se trouverait au-dessus d'une image de fond contenant également du texte. La conversion du fichier PDF en image permet à Cloud Translation de traiter le document en tant que fichier PDF scanné. Pour effectuer la conversion, vous pouvez utiliser Chrome (en imprimant le fichier en tant qu'image) ou d'autres outils tiers.

Orientation du texte

Pour les traductions de PDF scannés, le texte source doit être orienté horizontalement. Si, par exemple, un document scanné comprend du texte qui est incliné vers le haut ou vers le bas, Cloud Translation risque de ne pas analyser correctement tout le texte, ce qui entraîne des traductions incorrectes ou incomplètes.

Si vos documents ne sont pas orientés de manière cohérente, vous pouvez demander à Cloud Translation de les orienter à votre place. Dans votre requête de traduction, activez l'option enableRotationCorrection afin que le texte soit correctement orienté avant la traduction.

Étapes suivantes

  • Document Translation est facturé par page. Pour en savoir plus, reportez-vous à la section Tarification.