Traduire du texte

Cette page vous explique comment utiliser Vertex AI Studio pour traduire rapidement du texte d'une langue à une autre. Traduction dans Vertex AI Studio offre le choix entre Gemini et deux modèles de traduction spécialisés, qui incluent le modèle de traduction automatique neuronale (NMT, Neural Machine Translation) de Cloud Translation et un LLM affiné pour les traductions. Lorsque vous utilisez le LLM de traduction, vous pouvez adapter les réponses en fournissant des exemples de traductions qui correspondent mieux à votre style, votre ton et votre domaine d'activité. Le modèle utilise vos exemples en tant que contexte few-shot avant de traduire votre texte.

Vous ne pouvez pas transmettre d'exemples lorsque vous traduisez du texte avec Gemini ou le modèle NMT. Toutefois, pour les traductions directes sans exemples, vous pouvez utiliser Gemini ou un modèle de traduction spécialisé.

Langues disponibles

Les langues compatibles avec chaque modèle peuvent varier. Avant de demander des traductions, vérifiez que le modèle que vous utilisez est compatible avec vos langues source et cible.

LLM de traduction

Pour le LLM de traduction, vous pouvez traduire vers et depuis l'une des combinaisons linguistiques suivantes:

  • Chinois (simplifié) <-> Anglais
  • Français <-> Anglais
  • Allemand <-> Anglais
  • Italien <-> Anglais
  • Japonais <-> Anglais
  • Coréen <-> Anglais
  • Portugais <-> Anglais
  • Espagnol <-> Anglais

Gemini et NMT

Pour en savoir plus sur les langues compatibles avec Gemini et le modèle NMT, consultez la documentation suivante:

Traduire du texte

Utilisez le modèle LLM, Gemini ou NMT pour traduire du texte à l'aide de la console Google Cloud ou de l'API.

Console

  1. Dans la section Cloud Translation de la console Google Cloud, accédez à la page Traduction de Vertex AI Studio.

    Accéder à Vertex AI Studio

  2. Dans le volet Exécuter les paramètres, sélectionnez un modèle de traduction dans le champ Modèle.

  3. Pour modifier les paramètres du modèle, tels que la température, développez Avancé.

  4. Définissez les langues source et cible.

  5. Dans le champ de saisie, saisissez le texte à traduire.

  6. Cliquez sur Envoyer.

  7. Pour obtenir le code ou la commande curl qui montre comment demander des traductions, cliquez sur Obtenir le code.

API

Sélectionnez le modèle à utiliser pour vos traductions.

LLM de traduction

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 du texte d'entrée. Définissez l'un des codes de langue répertoriés dans la traduction adaptative.
  • TARGET_LANGUAGE : langue cible vers laquelle traduire le texte d'entrée. Définissez l'un des codes de langue répertoriés dans la traduction adaptative.
  • SOURCE_TEXT : texte dans la langue source à traduire.

Méthode HTTP et URL : 

POST https://translation.googleapis.com/v3/projects/PROJECT_ID/locations/LOCATION:adaptiveMtTranslate

Corps JSON de la requête :

{
  "sourceLanguageCode": "SOURCE_LANGUAGE_CODE",
  "targetLanguageCode": "TARGET_LANGUAGE_CODE",
  "content": ["INPUT_TEXT"],
  "model": "projects/PROJECT_ID/locations/LOCATION/model/general/translation-llm",
}

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

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

{
  "translations": [
    {
      "translatedText": "TRANSLATED_TEXT"
    }
  ],
  "languageCode": "TARGET_LANGUAGE"
}

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. 

const projectId = '<PROJECT_ID>';
const location = 'global';
const text = '<INPUT_TEXT>';

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

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

async function translateText() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: '<SOURCE_LANGUAGE_CODE>',
    targetLanguageCode: '<TARGET_LANGUAGE_CODE>',
    model: `projects/${projectId}/locations/${location}/model/general/translation-llm`
  };

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

  for (const translation of response.translations) {
    console.log(`Translation: ${translation.translatedText}`);
  }
}

translateText();

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. 

# Imports the Google Cloud Translation library
from google.cloud import translate

# Initialize Translation client
def translate_text(
    text: str = "YOUR_TEXT_TO_TRANSLATE", project_id: str = "YOUR_PROJECT_ID"
) -> translate.TranslationServiceClient:
    """Translating Text."""

    client = translate.TranslationServiceClient()

    location = "global"

    parent = f"projects/{project_id}/locations/{location}"
    model = f"{parent}/models/general/translation-llm"

    # Translate text from English to French
    # Detail on supported types can be found here:
    # https://cloud.google.com/translate/docs/supported-formats
    response = client.translate_text(
        request={
            "parent": parent,
            "contents": [text],
            "model": model
            "mime_type": "text/plain",  # mime types: text/plain, text/html
            "source_language_code": "<SOURCE_LANGUAGE_CODE>",
            "target_language_code": "<TARGET_LANGUAGE_CODE>",
        }
    )

    # Display the translation for each input text provided
    for translation in response.translations:
        print(f"Translated text: {translation.translated_text}")

    return response

translate_text(<INPUT_TEXT>, <PROJECT_ID>)

Gemini

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 traiter la requête. Les options disponibles sont les suivantes :

    Cliquer pour développer les régions disponibles

    • us-central1
    • us-west4
    • northamerica-northeast1
    • us-east4
    • us-west1
    • asia-northeast3
    • asia-southeast1
    • asia-northeast1
  • MODEL_ID : ID du modèle, tel que gemini-1.0-pro-002
  • SOURCE_LANGUAGE_CODE : langue du texte d'entrée.
  • TARGET_LANGUAGE_CODE : langue cible vers laquelle traduire le texte d'entrée.
  • SOURCE_TEXT : texte à traduire
  • TEMPERATURE : La température est utilisée pour l'échantillonnage pendant la génération des réponses, qui se produit lorsque topP et topK sont appliqués. La température permet de contrôler le degré de hasard dans la sélection des jetons. Les températures inférieures sont idéales pour les requêtes qui nécessitent une réponse moins ouverte ou créative, tandis que des températures plus élevées peuvent conduire à des résultats plus diversifiés ou créatifs. Une température de 0 signifie que les jetons de probabilité les plus élevés sont toujours sélectionnés. Dans ce cas, les réponses pour une requête donnée sont principalement déterministes, mais une petite quantité de variation est toujours possible.

    Si le modèle renvoie une réponse trop générique ou trop courte, ou s'il renvoie une réponse de remplacement, essayez d'augmenter la température.

  • TOP_P : Top-P modifie la façon dont le modèle sélectionne les jetons pour la sortie. Les jetons sont sélectionnés de la valeur la plus élevée (voir top-K) à la moins probable jusqu'à ce que la somme de leurs probabilités soit égale à la valeur top-P. Par exemple, si les jetons A, B et C ont une probabilité de 0,3, 0,2 et 0,1 et que la valeur de top-P est supérieure à 0.5, le modèle sélectionne A ou B comme jeton suivant en utilisant la température et exclut C comme candidat.

    Spécifiez une valeur inférieure pour les réponses moins aléatoires et une valeur plus élevée pour les réponses plus aléatoires.

  • TOP_K : Top-K modifie la façon dont le modèle sélectionne les jetons pour la sortie. Un top-K de 1 signifie que le prochain jeton sélectionné est le plus probable parmi tous les jetons du vocabulaire du modèle (également appelé décodage gourmand), tandis que le top-K de 3 signifie que le jeton suivant est sélectionné parmi les trois jetons les plus probables en utilisant la température.

    Pour chaque étape de sélection du jeton, les jetons top-K avec les probabilités les plus élevées sont échantillonnés. Les jetons sont ensuite filtrés en fonction du top-P avec le jeton final sélectionné à l'aide de l'échantillonnage de température.

    Spécifiez une valeur inférieure pour les réponses moins aléatoires et une valeur plus élevée pour les réponses plus aléatoires.

  • MAX_OUTPUT_TOKENS : nombre maximal de jetons pouvant être générés dans la réponse. Un jeton correspond environ à quatre caractères. 100 jetons correspondent à environ 60-80 mots.

    Spécifiez une valeur inférieure pour obtenir des réponses plus courtes et une valeur supérieure pour des réponses potentiellement plus longues.

  • SAFETY_CATEGORY : catégorie de sécurité pour laquelle configurer un seuil. Les valeurs acceptées incluent les suivantes :

    Cliquer pour développer les catégories de sécurité

    • HARM_CATEGORY_SEXUALLY_EXPLICIT
    • HARM_CATEGORY_HATE_SPEECH
    • HARM_CATEGORY_HARASSMENT
    • HARM_CATEGORY_DANGEROUS_CONTENT
  • THRESHOLD : seuil de blocage des réponses susceptibles d'appartenir à la catégorie de sécurité spécifiée en fonction de la probabilité. Les valeurs acceptées incluent les suivantes :

    Cliquer pour développer les seuils de blocage

    • BLOCK_NONE
    • BLOCK_ONLY_HIGH
    • BLOCK_MEDIUM_AND_ABOVE (par défaut)
    • BLOCK_LOW_AND_ABOVE
     BLOCK_LOW_AND_ABOVE bloque le plus, tandis que BLOCK_ONLY_HIGH bloque le moins.

Méthode HTTP et URL :

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/publishers/google/models/MODEL_ID:streamGenerateContent

Corps JSON de la requête :

{
  "contents": [
    {
      "role": "user",
      "parts": [
        {
        "text": "SOURCE_LANGUAGE_CODE: SOURCE_TEXT\nTARGET_LANGUAGE_CODE:"
        }
      ]
    }
  ],
  "generation_config": {
    "temperature": TEMPERATURE,
    "topP": TOP_P,
    "topK": TOP_K,
    "candidateCount": 1,
    "maxOutputTokens": MAX_OUTPUT_TOKENS
  }
  "safetySettings": [
    {
      "category": "SAFETY_CATEGORY",
      "threshold": "THRESHOLD"
    }
  ]
}

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

Vous devriez recevoir un code d'état indiquant le succès de l'opération (2xx), ainsi qu'une réponse vide.

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. 

const {VertexAI} = require('@google-cloud/vertexai');

// Initialize Vertex with your Cloud project and location
const vertex_ai = new VertexAI({project: '<PROJECT_ID>', location: '<LOCATION>'});
const model = 'gemini-1.0-pro';

// Instantiate the models
const generativeModel = vertex_ai.preview.getGenerativeModel({
  model: model,
  generationConfig: {
    'candidate_count': 1,
    'max_output_tokens': <MAX_OUTPUT_TOKENS>,
    'temperature': <TEMPERATURE>,
    'top_p': <TOP_P>,
    'top_k': <TOP_K>,
  },
  safetySettings: [
    {
        'category': 'HARM_CATEGORY_HATE_SPEECH',
        'threshold': 'BLOCK_MEDIUM_AND_ABOVE'
    },
    {
        'category': 'HARM_CATEGORY_DANGEROUS_CONTENT',
        'threshold': 'BLOCK_MEDIUM_AND_ABOVE'
    },
    {
        'category': 'HARM_CATEGORY_SEXUALLY_EXPLICIT',
        'threshold': 'BLOCK_MEDIUM_AND_ABOVE'
    },
    {
        'category': 'HARM_CATEGORY_HARASSMENT',
        'threshold': 'BLOCK_MEDIUM_AND_ABOVE'
    }
  ],
});

async function generateContent() {
  const req = {
    contents: [
      {role: 'user', parts: [{text: `<SOURCE_LANGUAGE_CODE>: <TEXT>
<TARGET_LANGUAGE_CODE>:`}]}
    ],
  };

  const streamingResp = await generativeModel.generateContentStream(req);

  for await (const item of streamingResp.stream) {
    process.stdout.write('stream chunk: ' + JSON.stringify(item) + '\n');
  }

  process.stdout.write('aggregated response: ' + JSON.stringify(await streamingResp.response));
}

generateContent();

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 base64
import vertexai
from vertexai.generative_models import GenerativeModel, Part, FinishReason
import vertexai.preview.generative_models as generative_models

def generate():
  vertexai.init(project="<PROJECT_ID>", location="<LOCATION>")
  model = GenerativeModel("gemini-1.0-pro")
  responses = model.generate_content(
      ["""<SOURCE_LANGUAGE_CODE>: <TEXT>
<TARGET_LANGUAGE_CODE>:"""],
      generation_config=generation_config,
      safety_settings=safety_settings,
  )

  print(responses)

generation_config = {
    "candidate_count": 1,
    "max_output_tokens": <MAX_OUTPUT_TOKENS>,
    "temperature": <TEMPERATURE>,
    "top_p": <TOP_P>,
    "top_k": <TOP_K>,
}

safety_settings = {
    generative_models.HarmCategory.HARM_CATEGORY_HATE_SPEECH: generative_models.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    generative_models.HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: generative_models.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    generative_models.HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: generative_models.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
    generative_models.HarmCategory.HARM_CATEGORY_HARASSMENT: generative_models.HarmBlockThreshold.BLOCK_MEDIUM_AND_ABOVE,
}

generate()

NMT

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.
  • SOURCE_LANGUAGE (facultatif) : code de langue du texte d'entrée. Pour connaître les codes de langue compatibles, consultez la page Langues acceptées.
  • TARGET_LANGUAGE : langue cible vers laquelle traduire le texte d'entrée. Définissez l'un des codes de langue acceptés.
  • SOURCE_TEXT : texte à traduire

Méthode HTTP et URL : 

POST https://translation.googleapis.com/v3/projects/PROJECT_ID:translateText

Corps JSON de la requête :

{
  "sourceLanguageCode": "SOURCE_LANGUAGE",
  "targetLanguageCode": "TARGET_LANGUAGE",
  "contents": ["SOURCE_TEXT1", "SOURCE_TEXT2"]
}

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

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

{
  "translations": [
    {
      "translatedText": "TRANSLATED_TEXT1"
    },
    {
      "translatedText": "TRANSLATED_TEXT2"
    }
  ]
}

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 text = 'text to translate';

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

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

async function translateText() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    contents: [text],
    mimeType: 'text/plain', // mime types: text/plain, text/html
    sourceLanguageCode: 'en',
    targetLanguageCode: 'sr-Latn',
  };

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

  for (const translation of response.translations) {
    console.log(`Translation: ${translation.translatedText}`);
  }
}

translateText();

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. 

# Imports the Google Cloud Translation library
from google.cloud import translate

# Initialize Translation client
def translate_text(
    text: str = "YOUR_TEXT_TO_TRANSLATE", project_id: str = "YOUR_PROJECT_ID"
) -> translate.TranslationServiceClient:
    """Translating Text."""

    client = translate.TranslationServiceClient()

    location = "global"

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

    # Translate text from English to French
    # Detail on supported types can be found here:
    # https://cloud.google.com/translate/docs/supported-formats
    response = client.translate_text(
        request={
            "parent": parent,
            "contents": [text],
            "mime_type": "text/plain",  # mime types: text/plain, text/html
            "source_language_code": "en-US",
            "target_language_code": "fr",
        }
    )

    # Display the translation for each input text provided
    for translation in response.translations:
        print(f"Translated text: {translation.translated_text}")

    return response

Traductions personnalisées

Personnalisez les réponses du LLM de traduction en fournissant vos propres exemples de traductions. Les traductions personnalisées ne fonctionnent qu'avec le LLM de traduction.

Exigences en matière de données

Les exemples de traductions doivent être écrits sous forme de paires de segments dans un fichier TMX ou TSV. Chaque paire comprend un segment de langue source et son équivalent traduit. Pour en savoir plus, consultez la page Préparer des exemples de traductions dans la documentation Cloud Translation.

Pour obtenir des résultats plus précis, incluez des exemples spécifiques issus d'une grande variété de scénarios. Vous devez inclure au moins cinq paires de phrases, mais pas plus de 10 000 paires. Une paire de segments ne peut pas dépasser 512 caractères.

Personnaliser les traductions

Console

  1. Dans la section Cloud Translation de la console Google Cloud, accédez à la page Traduction de Vertex AI Studio.

    Accéder à Vertex AI Studio

  2. Dans la fiche Traduire du texte, cliquez sur Traduire.

  3. Dans le volet Paramètre, configurez vos paramètres de traduction.

    1. Dans le champ Modèle, sélectionnez Traduction LLM.
    2. Pour modifier la température, développez Avancé.

  4. Cliquez sur Ajouter des exemples.

    1. Sélectionnez un fichier local ou un fichier dans Cloud Storage. Vertex AI Studio détermine les langues source et cible à partir de votre fichier.
    2. Sélectionnez le nombre d'exemples que le modèle doit utiliser avant de générer une réponse.

    Le nombre d'exemples que vous sélectionnez est comptabilisé dans le nombre maximal de caractères d'entrée par requête de 3 000.

  5. Dans le champ de saisie, saisissez le texte à traduire.

  6. Cliquez sur Envoyer.

    Le modèle tente d'identifier des schémas à partir de vos exemples et les applique lors de la génération d'une réponse. La limite de sortie par requête est de 3 000 caractères. Tout texte au-delà de cette limite est supprimé.

  7. Pour obtenir le code ou la commande curl montrant comment demander des traductions, cliquez sur Obtenir le code.

REST

Créer un ensemble de données

Créez un ensemble de données dans lequel vous importerez vos exemples de traductions. Les langues source et cible doivent correspondre aux langues que vous souhaitez utiliser dans les traductions.

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 où se trouve votre ensemble de données source, par exemple us-central1
  • DATASET_ID : identifiant unique de votre ensemble de données
  • DISPLAY_NAME : nom descriptif de l'ensemble de données
  • SOURCE_LANGUAGE : code de langue du texte d'entrée. Pour connaître les codes de langue acceptés, consultez la page Langues acceptées.
  • TARGET_LANGUAGE : langue cible vers laquelle traduire le texte d'entrée. Pour connaître les codes de langue acceptés, consultez la page Langues acceptées.

Méthode HTTP et URL : 

POST https://translation.googleapis.com/v3/projects/PROJECT_ID/locations/LOCATION/adaptiveMtDatasets

Corps JSON de la requête :

{
  "name": "projects/PROJECT_ID/locations/LOCATION/adaptiveMtDatasets/DATASET_ID,
  "display_name": "DISPLAY_NAME",
  "source_language_code": "SOURCE_LANGUAGE",
  "target_language_code": "TARGET_LANGUAGE"
}

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

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

{
  "name": "projects/PROJECT_ID/locations/LOCATION/adaptiveMtDatasets/DATASET_ID",
  "displayName": "DISPLAY_NAME",
  "sourceLanguageCode": "SOURCE_LANGUAGE",
  "targetLanguageCode": "TARGET_LANGUAGE"
}

Importer des données

Complétez votre ensemble de données avec des exemples de traductions provenant d'un fichier TSV ou TMX.

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 où se trouve votre ensemble de données, par exemple us-central1
  • DATASET_ID : identifiant unique de l'ensemble de données dans lequel les données doivent être importées
  • GCS_FILE_PATH : chemin d'accès au fichier de données source dans Cloud Storage, tel que gs://example/data.tsv

Méthode HTTP et URL : 

POST https://translation.googleapis.com/v3/projects/PROJECT_ID/locations/LOCATION/adaptiveMtDatasets/DATASET_ID:importAdaptiveMtFile

Corps JSON de la requête :

{
  "gcs_input_source": {
    "input_uri": "GCS_FILE_PATH"
  }
}

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

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

{
  "adaptiveMtFile": {
    "name": "DATASET_NAME",
    "displayName": "FILE_NAME",
    "entryCount": TOTAL_ENTRIES
  }
}

Traduire du texte

Fournissez le texte à traduire et l'ensemble de données à utiliser pour la traduction.

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 où se trouve votre ensemble de données source, par exemple us-central1
  • DATASET_NAME : nom de l'ensemble de données utilisé par Cloud Translation pour personnaliser vos traductions, au format projects/PROJECT_ID/locations/LOCATION/adaptiveMtDatasets/DATASET_ID. Vous pouvez obtenir les noms des ensembles de données en répertoriant tous les ensembles de données de votre projet.
  • SOURCE_TEXT : texte à traduire

Méthode HTTP et URL : 

POST https://translation.googleapis.com/v3/projects/PROJECT_ID/locations/LOCATION:adaptiveMtTranslate

Corps JSON de la requête :

{
  "dataset": "DATASET_NAME",
  "content": ["SOURCE_TEXT"]
}

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

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

{
  "translations": [
    {
      "translatedText": "TRANSLATED_TEXT"
    }
  ],
  "languageCode": "TARGET_LANGUAGE"
}

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. 

const projectId = '<PROJECT_ID>';
const location = 'us-central1';
const text = '<INPUT_TEXT>';

async function createAdaptiveMtDataset() {
  // Construct request
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    adaptiveMtDataset: {
      name: `projects/${projectId}/locations/${location}/adaptiveMtDatasets/${
          adaptiveMtDatasetName}`,
      displayName: 'DATASET_DISPLAY_NAME',
      sourceLanguageCode: <SOURCE_LANGUAGE_CODE>,
      targetLanguageCode: <TARGET_LANGUAGE_CODE>,
    }
  };

  // Run request
  const [response] = await translationClient.createAdaptiveMtDataset(request);
  console.log('Created')
  console.log(response)
}

async function importAdaptiveMtFile() {
  const request = {
    parent: `projects/${projectId}/locations/${location}/adaptiveMtDatasets/${
        adaptiveMtDatasetName}`,
    gcsInputSource: {inputUri: gcs_file_uri}
  } const [response] = await translationClient.importAdaptiveMtFile(request)
  console.log('Importing file')
  console.log(response)
}

async function translate() {
  const request = {
    parent: `projects/${projectId}/locations/${location}`,
    dataset: `projects/${projectId}/locations/${location}/adaptiveMtDatasets/${
        adaptiveMtDatasetName}`,
    content: [text]
  } const [response] = await translationClient.adaptiveMtTranslate(request)
  console.log('Translating')
  console.log(response)
}

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. 

# Imports the Google Cloud Translation library
from google.cloud import translate

def create_adaptive_mt_dataset():
  # Create a client
  client = translate.TranslationServiceClient()
  # Initialize request argument(s)
  adaptive_mt_dataset = translate.AdaptiveMtDataset()
  adaptive_mt_dataset.name = "projects/<PROJECT_ID>/locations/us-central1/adaptiveMtDatasets/DATASET_ID"
  adaptive_mt_dataset.display_name = "DATASET_DISPLAY_NAME"
  adaptive_mt_dataset.source_language_code = "<SOURCE_LANGUAGE_CODE>"
  adaptive_mt_dataset.target_language_code = "<TARGET_LANGUAGE_CODE>"
  request = translate.CreateAdaptiveMtDatasetRequest(
      parent="projects/<PROJECT_ID>/locations/us-central1",
      adaptive_mt_dataset=adaptive_mt_dataset,
  )
  # Make the request
  response = client.create_adaptive_mt_dataset(request=request)
  # Handle the response
  print(response)

def import_adaptive_mt_file():
  # Create a client
  client = translate.TranslationServiceClient()
  gcs_input_source = translate.GcsInputSource()
  gcs_input_source.input_uri = "gs://SOURCE_LOCATION/FILE.tsv"
  # Initialize the request
  request = translate.ImportAdaptiveMtFileRequest(
      parent="projects/<PROJECT_ID>/locations/us-central1/adaptiveMtDatasets/DATASET_ID",
      gcs_input_source=gcs_input_source
  )
  # Make the request
  response = client.import_adaptive_mt_file(request)
  # Handle the response
  print(response)

def adaptive_mt_translate():
  # Create a client
  client = translate.TranslationServiceClient()
  # Initialize the request
  request = translate.AdaptiveMtTranslateRequest(
      parent="projects/<PROJECT_ID>/locations/us-central1",
      dataset="projects/<PROJECT_ID>/locations/us-central1/adaptiveMtDatasets/DATASET_ID",
      content=["<INPUT_TEXT>"],

  )
  # Make the request
  response = client.adaptive_mt_translate(request)
  # Handle the response
  print(response)