Tutoriel sur l'API AutoML Translation

Ce tutoriel explique comment créer un modèle de traduction personnalisé à l'aide d'AutoML Translation. L'application entraîne un modèle personnalisé à l'aide d'un ensemble de données en anglais et en espagnol, constitué de paires de phrases axées sur la technologie et issues de la localisation de logiciels.

Ce tutoriel traite de l'entraînement du modèle personnalisé, de l'évaluation de ses performances et de la traduction de nouveaux contenus.

Conditions préalables

Configurer l'environnement de projet

Connectez-vous à votre compte Google Cloud. Si vous débutez sur Google Cloud, créez un compte pour évaluer les performances de nos produits en conditions réelles. Les nouveaux clients bénéficient également de 300 $ de crédits gratuits pour exécuter, tester et déployer des charges de travail.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Accéder au sélecteur de projet

Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

Activer les API AutoML Translation.

Activer les API

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Accéder au sélecteur de projet

Vérifiez que la facturation est activée pour votre projet Google Cloud. Découvrez comment vérifier si la facturation est activée sur un projet.

Activer les API AutoML Translation.

Activer les API

Installez Google Cloud CLI.
Suivez les instructions pour créer un compte de service et télécharger un fichier de clé.
Indiquez le chemin d'accès au fichier de clé du compte de service, que vous avez téléchargé lors de la création de ce dernier, comme variable d'environnement GOOGLE_APPLICATION_CREDENTIALS. Exemple :
```
export GOOGLE_APPLICATION_CREDENTIALS=key-file
```
Ajoutez votre nouveau compte de service au rôle IAM de l'éditeur AutoML à l'aide des commandes ci-dessous. Remplacez project-id par le nom de votre projet Google Cloud Project et service-account-name par le nom de votre nouveau compte de service, par exemple service-account1@myproject.iam.gserviceaccount.com.
```
gcloud auth login
gcloud config set project project-id
gcloud projects add-iam-policy-binding project-id \
  --member=serviceAccount:service-account-name \
  --role='roles/automl.editor'
```

Autorisez les comptes de service AutoML Translation à accéder aux ressources de votre projet Google Cloud :

gcloud projects add-iam-policy-binding project-id \
  --member="serviceAccount:service-project-number@gcp-sa-automl.iam.gserviceaccount.com" \
  --role="roles/automl.serviceAgent"

Installez la bibliothèque cliente.
Définissez les variables d'environnement PROJECT_ID et REGION_NAME.

Remplacez project-id par l'ID de votre projet Google Cloud Project. AutoML Translation nécessite actuellement l'emplacement us-central1.
```
export PROJECT_ID="project-id"
export REGION_NAME="us-central1"
```
Créez un bucket Google Cloud Storage afin de stocker les documents nécessaires pour entraîner votre modèle personnalisé.

Le nom du bucket doit respecter le format suivant : $PROJECT_ID-vcm. La commande ci-dessous permet de créer un bucket de stockage dans la région us-central1, nommé $PROJECT_ID-vcm.
```
gsutil mb -p $PROJECT_ID -c regional -l $REGION_NAME gs://$PROJECT_ID-vcm/
```
Téléchargez le fichier d'archive contenant les exemples de données pour l'entraînement du modèle, extrayez son contenu, puis importez les fichiers dans votre bucket Google Cloud Storage.

Pour en savoir plus sur les formats, consultez la page Préparer les données d'entraînement.
L'exemple de code de ce tutoriel utilise un ensemble de données anglais-espagnol. Des ensembles de données ayant pour langue cible l'allemand, le chinois, le français et le russe sont également disponibles. Si vous utilisez l'un d'entre eux, remplacez le code de langue es des exemples par le code de langue approprié.
Dans le fichier en-es.csv de l'étape précédente, remplacez {project_id} par l'ID de votre projet.

Emplacements des fichiers de code source

Vous pouvez télécharger le code source depuis l'emplacement indiqué ci-dessous. Une fois le téléchargement terminé, vous pouvez copier le code source dans le dossier de votre projet Google Cloud.

Python

Le tutoriel contient ces fichiers Python :

translate_create_dataset.py : inclut une fonctionnalité permettant de créer un ensemble de données
import_dataset.py : inclut une fonctionnalité permettant d'importer un ensemble de données
translate_create_model.py : inclut une fonctionnalité permettant de créer un modèle
list_model_evaluations.py : inclut une fonctionnalité permettant de répertorier les évaluations de modèles
translate_predict.py : inclut une fonctionnalité liée à la prédiction
delete_model.py : inclut une fonctionnalité permettant de supprimer un modèle

Java

Le tutoriel contient ces fichiers Java :

TranslateCreateDataset.java : inclut une fonctionnalité permettant de créer un ensemble de données
ImportDataset.java : inclut une fonctionnalité permettant d'importer un ensemble de données
TranslateCreateModel.java : inclut une fonctionnalité permettant de créer un modèle
ListModelEvaluations.java : inclut une fonctionnalité permettant de répertorier les évaluations de modèles
TranslatePredict.java : inclut une fonctionnalité liée à la prédiction
DeleteModel.java : inclut une fonctionnalité permettant de supprimer un modèle

Node.js

Le tutoriel comprend les programmes Node.js suivants :

translate_create_dataset.js : inclut une fonctionnalité permettant de créer un ensemble de données
import_dataset.js : inclut une fonctionnalité permettant d'importer un ensemble de données
translate_create_model.js : inclut une fonctionnalité permettant de créer un modèle
list_model_evaluations.js : inclut une fonctionnalité permettant de répertorier les évaluations de modèles
translate_predict.js : inclut une fonctionnalité liée à la prédiction
delete_model.js : inclut une fonctionnalité permettant de supprimer un modèle

Exécuter l'application

Étape 1 : Créez un ensemble de données

La première étape de l'élaboration d'un modèle personnalisé consiste à créer un ensemble de données vide, qui contiendra à terme les données d'entraînement du modèle. Lorsque vous créez un ensemble de données, vous devez indiquer les langues source et cible de la traduction.

Copier le code

Python

Ouvrir dans l'éditeur Afficher sur GitHub

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# display_name = "YOUR_DATASET_NAME"

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = f"projects/{project_id}/locations/us-central1"
# For a list of supported languages, see:
# https://cloud.google.com/translate/automl/docs/languages
dataset_metadata = automl.TranslationDatasetMetadata(
    source_language_code="en", target_language_code="ja"
)
dataset = automl.Dataset(
    display_name=display_name,
    translation_dataset_metadata=dataset_metadata,
)

# Create a dataset with the dataset metadata in the region.
response = client.create_dataset(parent=project_location, dataset=dataset)

created_dataset = response.result()

# Display the dataset information
print("Dataset name: {}".format(created_dataset.name))
print("Dataset id: {}".format(created_dataset.name.split("/")[-1]))

Java

Ouvrir dans l'éditeur Afficher sur GitHub

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.Dataset;
import com.google.cloud.automl.v1.LocationName;
import com.google.cloud.automl.v1.OperationMetadata;
import com.google.cloud.automl.v1.TranslationDatasetMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class TranslateCreateDataset {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String displayName = "YOUR_DATASET_NAME";
    createDataset(projectId, displayName);
  }

  // Create a dataset
  static void createDataset(String projectId, String displayName)
      throws IOException, ExecutionException, InterruptedException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");

      // Specify the source and target language.
      TranslationDatasetMetadata translationDatasetMetadata =
          TranslationDatasetMetadata.newBuilder()
              .setSourceLanguageCode("en")
              .setTargetLanguageCode("ja")
              .build();
      Dataset dataset =
          Dataset.newBuilder()
              .setDisplayName(displayName)
              .setTranslationDatasetMetadata(translationDatasetMetadata)
              .build();
      OperationFuture<Dataset, OperationMetadata> future =
          client.createDatasetAsync(projectLocation, dataset);

      Dataset createdDataset = future.get();

      // Display the dataset information.
      System.out.format("Dataset name: %s\n", createdDataset.getName());
      // To get the dataset id, you have to parse it out of the `name` field. As dataset Ids are
      // required for other methods.
      // Name Form: `projects/{project_id}/locations/{location_id}/datasets/{dataset_id}`
      String[] names = createdDataset.getName().split("/");
      String datasetId = names[names.length - 1];
      System.out.format("Dataset id: %s\n", datasetId);
    }
  }
}

Node.js

Ouvrir dans l'éditeur Afficher sur GitHub

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

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function createDataset() {
  // Construct request
  const request = {
    parent: client.locationPath(projectId, location),
    dataset: {
      displayName: displayName,
      translationDatasetMetadata: {
        sourceLanguageCode: 'en',
        targetLanguageCode: 'ja',
      },
    },
  };

  // Create dataset
  const [operation] = await client.createDataset(request);

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

  console.log(`Dataset name: ${response.name}`);
  console.log(`
    Dataset id: ${
      response.name
        .split('/')
        [response.name.split('/').length - 1].split('\n')[0]
    }`);
}

createDataset();

Requête

Exécutez la fonction create_dataset pour créer un ensemble de données vide. Vous devez modifier les lignes de code suivantes :

Définissez le champ project_id sur votre valeur PROJECT_ID.
Définissez le champ display_name pour l'ensemble de données (en_es_dataset).
Remplacez la valeur ja du champ target_language_code par es.

Python

python translate_create_dataset.py

Java

mvn compile exec:java -Dexec.mainClass="com.example.automl.TranslateCreateDataset"

Node.js

node translate_create_dataset.js

Réponse

La réponse inclut les détails de l'ensemble de données créé, y compris son ID qui permet de le référencer dans des requêtes ultérieures. Nous vous recommandons d'indiquer la valeur de l'ID d'ensemble de données renvoyé sur la ligne d'une variable d'environnement DATASET_ID.

Dataset name: projects/216065747626/locations/us-central1/datasets/TRL7372141011130533778
Dataset id: TRL7372141011130533778
Dataset display name: en_es_dataset
Translation dataset Metadata:
        source_language_code: en
        target_language_code: es
Dataset example count: 0
Dataset create time:
       seconds: 1530251987
       nanos: 216586000

Étape 2 : Importez les paires de phrases de l'entraînement dans l'ensemble de données

L'étape suivante consiste à insérer une liste de paires de phrases de l'entraînement dans l'ensemble de données.

L'interface de la fonction import_dataset utilise un fichier .csv qui répertorie les emplacements de tous les documents d'entraînement et le libellé approprié pour chacun de ces documents. (Consultez la page Préparer vos données pour en savoir plus sur le format requis.) Pour les besoins de ce tutoriel, nous allons utiliser en-es.csv, que vous avez précédemment importé dans Google Cloud Storage.

Copier le code

Python

Ouvrir dans l'éditeur Afficher sur GitHub

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# dataset_id = "YOUR_DATASET_ID"
# path = "gs://YOUR_BUCKET_ID/path/to/data.csv"

client = automl.AutoMlClient()
# Get the full path of the dataset.
dataset_full_id = client.dataset_path(project_id, "us-central1", dataset_id)
# Get the multiple Google Cloud Storage URIs
input_uris = path.split(",")
gcs_source = automl.GcsSource(input_uris=input_uris)
input_config = automl.InputConfig(gcs_source=gcs_source)
# Import data from the input URI
response = client.import_data(name=dataset_full_id, input_config=input_config)

print("Processing import...")
print("Data imported. {}".format(response.result()))

Java

Ouvrir dans l'éditeur Afficher sur GitHub

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.DatasetName;
import com.google.cloud.automl.v1.GcsSource;
import com.google.cloud.automl.v1.InputConfig;
import com.google.cloud.automl.v1.OperationMetadata;
import com.google.protobuf.Empty;
import java.io.IOException;
import java.util.Arrays;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

class ImportDataset {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String datasetId = "YOUR_DATASET_ID";
    String path = "gs://BUCKET_ID/path_to_training_data.csv";
    importDataset(projectId, datasetId, path);
  }

  // Import a dataset
  static void importDataset(String projectId, String datasetId, String path)
      throws IOException, ExecutionException, InterruptedException, TimeoutException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // Get the complete path of the dataset.
      DatasetName datasetFullId = DatasetName.of(projectId, "us-central1", datasetId);

      // Get multiple Google Cloud Storage URIs to import data from
      GcsSource gcsSource =
          GcsSource.newBuilder().addAllInputUris(Arrays.asList(path.split(","))).build();

      // Import data from the input URI
      InputConfig inputConfig = InputConfig.newBuilder().setGcsSource(gcsSource).build();
      System.out.println("Processing import...");

      // Start the import job
      OperationFuture<Empty, OperationMetadata> operation =
          client.importDataAsync(datasetFullId, inputConfig);

      System.out.format("Operation name: %s%n", operation.getName());

      // If you want to wait for the operation to finish, adjust the timeout appropriately. The
      // operation will still run if you choose not to wait for it to complete. You can check the
      // status of your operation using the operation's name.
      Empty response = operation.get(45, TimeUnit.MINUTES);
      System.out.format("Dataset imported. %s%n", response);
    } catch (TimeoutException e) {
      System.out.println("The operation's polling period was not long enough.");
      System.out.println("You can use the Operation's name to get the current status.");
      System.out.println("The import job is still running and will complete as expected.");
      throw e;
    }
  }
}

Node.js

Ouvrir dans l'éditeur Afficher sur GitHub

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const datasetId = 'YOUR_DISPLAY_ID';
// const path = 'gs://BUCKET_ID/path_to_training_data.csv';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function importDataset() {
  // Construct request
  const request = {
    name: client.datasetPath(projectId, location, datasetId),
    inputConfig: {
      gcsSource: {
        inputUris: path.split(','),
      },
    },
  };

  // Import dataset
  console.log('Proccessing import');
  const [operation] = await client.importData(request);

  // Wait for operation to complete.
  const [response] = await operation.promise();
  console.log(`Dataset imported: ${response}`);
}

importDataset();

Requête

Exécutez la fonction import_data pour importer le contenu de l'entraînement. Vous devez modifier les lignes de code suivantes :

Définissez le champ project_id sur votre valeur PROJECT_ID.
Définissez le champ dataset_id pour l'ensemble de données (à partir de la sortie de l'étape précédente).
Définissez le champ path qui correspond à l'URI du fichier (gs://YOUR_PROJECT_ID-vcm/en-es.csv).

Python

python import_dataset.py

Java

mvn compile exec:java -Dexec.mainClass="com.example.automl.ImportDataset"

Node.js

node import_dataset.js

Réponse

Processing import...
Dataset imported.

Étape 3 : Créez (entraînez) le modèle

Maintenant que vous disposez d'un ensemble de données de documents d'entraînement étiquetés, vous pouvez entraîner un nouveau modèle.

Copier le code

Python

Ouvrir dans l'éditeur Afficher sur GitHub

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# dataset_id = "YOUR_DATASET_ID"
# display_name = "YOUR_MODEL_NAME"

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = f"projects/{project_id}/locations/us-central1"
translation_model_metadata = automl.TranslationModelMetadata()
model = automl.Model(
    display_name=display_name,
    dataset_id=dataset_id,
    translation_model_metadata=translation_model_metadata,
)

# Create a model with the model metadata in the region.
response = client.create_model(parent=project_location, model=model)

print("Training operation name: {}".format(response.operation.name))
print("Training started...")

Java

Ouvrir dans l'éditeur Afficher sur GitHub

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.LocationName;
import com.google.cloud.automl.v1.Model;
import com.google.cloud.automl.v1.OperationMetadata;
import com.google.cloud.automl.v1.TranslationModelMetadata;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class TranslateCreateModel {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String datasetId = "YOUR_DATASET_ID";
    String displayName = "YOUR_DATASET_NAME";
    createModel(projectId, datasetId, displayName);
  }

  // Create a model
  static void createModel(String projectId, String datasetId, String displayName)
      throws IOException, ExecutionException, InterruptedException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");
      TranslationModelMetadata translationModelMetadata =
          TranslationModelMetadata.newBuilder().build();
      Model model =
          Model.newBuilder()
              .setDisplayName(displayName)
              .setDatasetId(datasetId)
              .setTranslationModelMetadata(translationModelMetadata)
              .build();

      // Create a model with the model metadata in the region.
      OperationFuture<Model, OperationMetadata> future =
          client.createModelAsync(projectLocation, model);
      // OperationFuture.get() will block until the model is created, which may take several hours.
      // You can use OperationFuture.getInitialFuture to get a future representing the initial
      // response to the request, which contains information while the operation is in progress.
      System.out.format("Training operation name: %s\n", future.getInitialFuture().get().getName());
      System.out.println("Training started...");
    }
  }
}

Node.js

Ouvrir dans l'éditeur Afficher sur GitHub

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const dataset_id = 'YOUR_DATASET_ID';
// const displayName = 'YOUR_DISPLAY_NAME';

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function createModel() {
  // Construct request
  const request = {
    parent: client.locationPath(projectId, location),
    model: {
      displayName: displayName,
      datasetId: datasetId,
      translationModelMetadata: {},
    },
  };

  // Don't wait for the LRO
  const [operation] = await client.createModel(request);
  console.log('Training started...');
  console.log(`Training operation name: ${operation.name}`);
}

createModel();

Requête

Pour exécuter create_model, vous devez modifier les lignes de code suivantes :

Définissez le champ project_id sur votre valeur PROJECT_ID.
Définissez le champ dataset_id pour l'ensemble de données (à partir de la sortie de l'étape précédente).
Définissez le champ display_name pour le nouveau modèle (en_es_test_model).

Python

python translate_create_model.py

Java

mvn compile exec:java -Dexec.mainClass="com.example.automl.TranlateCreateModel"

Node.js

node translate_create_model.js

Réponse

La fonction create_model déclenche une opération d'entraînement et imprime le nom de l'opération. L'entraînement se déroule de manière asynchrone et peut prendre un certain temps. Vous pouvez donc consulter l'état de l'entraînement à l'aide de l'ID d'opération. Une fois l'entraînement terminé, create_model renvoie l'ID du modèle. Comme pour l'ID de l'ensemble de données, vous pouvez définir une variable d'environnement MODEL_ID sur la valeur de l'ID de modèle renvoyé.

Training operation name: projects/216065747626/locations/us-central1/operations/TRL3007727620979824033
Training started...
Model name: projects/216065747626/locations/us-central1/models/TRL3007727620979824033
Model id: TRL3007727620979824033
Model display name: en_es_test_model
Model create time:
        seconds: 1529649600
        nanos: 966000000
Model deployment state: deployed

Étape 4 : Évaluer le modèle

Après l'entraînement, vous pouvez évaluer l'état de préparation de votre modèle en examinant son score BLEU.

La fonction list_model_evaluations utilise l'ID du modèle comme paramètre.

Copier le code

Python

Ouvrir dans l'éditeur Afficher sur GitHub

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"

client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, "us-central1", model_id)

print("List of model evaluations:")
for evaluation in client.list_model_evaluations(parent=model_full_id, filter=""):
    print("Model evaluation name: {}".format(evaluation.name))
    print("Model annotation spec id: {}".format(evaluation.annotation_spec_id))
    print("Create Time: {}".format(evaluation.create_time))
    print("Evaluation example count: {}".format(evaluation.evaluated_example_count))
    print(
        "Translation model evaluation metrics: {}".format(
            evaluation.translation_evaluation_metrics
        )
    )

Java

Ouvrir dans l'éditeur Afficher sur GitHub


import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ListModelEvaluationsRequest;
import com.google.cloud.automl.v1.ModelEvaluation;
import com.google.cloud.automl.v1.ModelName;
import java.io.IOException;

class ListModelEvaluations {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    listModelEvaluations(projectId, modelId);
  }

  // List model evaluations
  static void listModelEvaluations(String projectId, String modelId) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // Get the full path of the model.
      ModelName modelFullId = ModelName.of(projectId, "us-central1", modelId);
      ListModelEvaluationsRequest modelEvaluationsrequest =
          ListModelEvaluationsRequest.newBuilder().setParent(modelFullId.toString()).build();

      // List all the model evaluations in the model by applying filter.
      System.out.println("List of model evaluations:");
      for (ModelEvaluation modelEvaluation :
          client.listModelEvaluations(modelEvaluationsrequest).iterateAll()) {

        System.out.format("Model Evaluation Name: %s\n", modelEvaluation.getName());
        System.out.format("Model Annotation Spec Id: %s", modelEvaluation.getAnnotationSpecId());
        System.out.println("Create Time:");
        System.out.format("\tseconds: %s\n", modelEvaluation.getCreateTime().getSeconds());
        System.out.format("\tnanos: %s", modelEvaluation.getCreateTime().getNanos() / 1e9);
        System.out.format(
            "Evalution Example Count: %d\n", modelEvaluation.getEvaluatedExampleCount());
        System.out.format(
            "Translate Model Evaluation Metrics: %s\n",
            modelEvaluation.getTranslationEvaluationMetrics());
      }
    }
  }
}

Node.js

Ouvrir dans l'éditeur Afficher sur GitHub

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

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function listModelEvaluations() {
  // Construct request
  const request = {
    parent: client.modelPath(projectId, location, modelId),
    filter: '',
  };

  const [response] = await client.listModelEvaluations(request);

  console.log('List of model evaluations:');
  for (const evaluation of response) {
    console.log(`Model evaluation name: ${evaluation.name}`);
    console.log(`Model annotation spec id: ${evaluation.annotationSpecId}`);
    console.log(`Model display name: ${evaluation.displayName}`);
    console.log('Model create time');
    console.log(`\tseconds ${evaluation.createTime.seconds}`);
    console.log(`\tnanos ${evaluation.createTime.nanos / 1e9}`);
    console.log(
      `Evaluation example count: ${evaluation.evaluatedExampleCount}`
    );
    console.log(
      `Translation model evaluation metrics: ${evaluation.translationEvaluationMetrics}`
    );
  }
}

listModelEvaluations();

Requête

Pour afficher les performances d'évaluation globales du modèle, exécutez la requête suivante. Vous devez modifier les lignes de code suivantes :

Définissez le champ project_id sur votre valeur PROJECT_ID.
Définissez le champ model_id sur l'ID de votre modèle.

Python

python list_model_evaluations.py

Java

mvn compile exec:java -Dexec.mainClass="com.example.automl.ListModelEvaluations"

Node.js

node list_model_evaluations.js

Réponse

Si le score BLEU est trop faible, vous pouvez renforcer l'ensemble de données de l'entraînement et entraîner à nouveau votre modèle. Pour plus d'informations, consultez la page Évaluer les modèles.

List of model evaluations:
name: "projects/216065747626/locations/us-central1/models/5419131644870929143/modelEvaluations/TRL7683346839371803263"
create_time {
  seconds: 1530196488
  nanos: 509247000
}
evaluated_example_count: 3
translation_evaluation_metrics {
  bleu_score: 19.23076957464218
  base_bleu_score: 11.428571492433548
}

Étape 5 : Réalisez une prédiction à l'aide d'un modèle

Une fois que votre modèle personnalisé répond à vos attentes en matière de qualité, vous pouvez vous en servir pour traduire un nouveau contenu.

Copier le code

Python

Ouvrir dans l'éditeur Afficher sur GitHub

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"
# file_path = "path_to_local_file.txt"

prediction_client = automl.PredictionServiceClient()

# Get the full path of the model.
model_full_id = automl.AutoMlClient.model_path(project_id, "us-central1", model_id)

# Read the file content for translation.
with open(file_path, "rb") as content_file:
    content = content_file.read()
content.decode("utf-8")

text_snippet = automl.TextSnippet(content=content)
payload = automl.ExamplePayload(text_snippet=text_snippet)

response = prediction_client.predict(name=model_full_id, payload=payload)
translated_content = response.payload[0].translation.translated_content

print(u"Translated content: {}".format(translated_content.content))

Java

Ouvrir dans l'éditeur Afficher sur GitHub

import com.google.cloud.automl.v1.ExamplePayload;
import com.google.cloud.automl.v1.ModelName;
import com.google.cloud.automl.v1.PredictRequest;
import com.google.cloud.automl.v1.PredictResponse;
import com.google.cloud.automl.v1.PredictionServiceClient;
import com.google.cloud.automl.v1.TextSnippet;
import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Paths;

class TranslatePredict {

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    String filePath = "path_to_local_file.txt";
    predict(projectId, modelId, filePath);
  }

  static void predict(String projectId, String modelId, String filePath) throws IOException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (PredictionServiceClient client = PredictionServiceClient.create()) {
      // Get the full path of the model.
      ModelName name = ModelName.of(projectId, "us-central1", modelId);

      String content = new String(Files.readAllBytes(Paths.get(filePath)));

      TextSnippet textSnippet = TextSnippet.newBuilder().setContent(content).build();
      ExamplePayload payload = ExamplePayload.newBuilder().setTextSnippet(textSnippet).build();
      PredictRequest predictRequest =
          PredictRequest.newBuilder().setName(name.toString()).setPayload(payload).build();

      PredictResponse response = client.predict(predictRequest);
      TextSnippet translatedContent =
          response.getPayload(0).getTranslation().getTranslatedContent();
      System.out.format("Translated Content: %s\n", translatedContent.getContent());
    }
  }
}

Node.js

Ouvrir dans l'éditeur Afficher sur GitHub

/**
 * TODO(developer): Uncomment these variables before running the sample.
 */
// const projectId = 'YOUR_PROJECT_ID';
// const location = 'us-central1';
// const modelId = 'YOUR_MODEL_ID';
// const filePath = 'path_to_local_file.txt';

// Imports the Google Cloud AutoML library
const {PredictionServiceClient} = require('@google-cloud/automl').v1;
const fs = require('fs');

// Instantiates a client
const client = new PredictionServiceClient();

// Read the file content for translation.
const content = fs.readFileSync(filePath, 'utf8');

async function predict() {
  // Construct request
  const request = {
    name: client.modelPath(projectId, location, modelId),
    payload: {
      textSnippet: {
        content: content,
      },
    },
  };

  const [response] = await client.predict(request);

  console.log(
    'Translated content: ',
    response.payload[0].translation.translatedContent.content
  );
}

predict();

Requête

Pour la fonction predict, vous devez modifier les lignes de code suivantes :

Définissez le champ project_id sur votre valeur PROJECT_ID.
Définissez le champ model_id sur l'ID de votre modèle.
Définissez le champ file_path sur le fichier téléchargé ("resources/input.txt").

Python

python tranlsate_predict.py

Java

mvn compile exec:java -Dexec.mainClass="com.example.automl.TranslatePredict"

Node.js

node translate_predict.js predict

Réponse

La fonction renvoie le contenu traduit.

Translated content: Ver y administrar tus cuentas de Google Tag Manager.

Le contenu ci-dessus correspond à la traduction en espagnol de la phrase anglaise "View and manage your Google Tag Manager accounts". Comparez cette traduction personnalisée à la traduction du modèle Google de base :

Ver y administrar sus cuentas de Administrador de etiquetas de Google

Étape 6 : Supprimez un modèle

Lorsque vous avez fini d'utiliser cet exemple de modèle, vous pouvez le supprimer définitivement. Vous ne pourrez plus vous servir du modèle pour la prédiction.

Copier le code

Python

Ouvrir dans l'éditeur Afficher sur GitHub

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# project_id = "YOUR_PROJECT_ID"
# model_id = "YOUR_MODEL_ID"

client = automl.AutoMlClient()
# Get the full path of the model.
model_full_id = client.model_path(project_id, "us-central1", model_id)
response = client.delete_model(name=model_full_id)

print("Model deleted. {}".format(response.result()))

Java

Ouvrir dans l'éditeur Afficher sur GitHub

import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ModelName;
import com.google.protobuf.Empty;
import java.io.IOException;
import java.util.concurrent.ExecutionException;

class DeleteModel {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String modelId = "YOUR_MODEL_ID";
    deleteModel(projectId, modelId);
  }

  // Delete a model
  static void deleteModel(String projectId, String modelId)
      throws IOException, ExecutionException, InterruptedException {
    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (AutoMlClient client = AutoMlClient.create()) {
      // Get the full path of the model.
      ModelName modelFullId = ModelName.of(projectId, "us-central1", modelId);

      // Delete a model.
      Empty response = client.deleteModelAsync(modelFullId).get();

      System.out.println("Model deletion started...");
      System.out.println(String.format("Model deleted. %s", response));
    }
  }
}

Node.js

Ouvrir dans l'éditeur Afficher sur GitHub

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

// Imports the Google Cloud AutoML library
const {AutoMlClient} = require('@google-cloud/automl').v1;

// Instantiates a client
const client = new AutoMlClient();

async function deleteModel() {
  // Construct request
  const request = {
    name: client.modelPath(projectId, location, modelId),
  };

  const [response] = await client.deleteModel(request);
  console.log(`Model deleted: ${response}`);
}

deleteModel();

Requête

Effectuez une requête avec le type d'opération delete_model pour supprimer un modèle que vous avez créé. Vous devez modifier les lignes de code suivantes :

Définissez le champ project_id sur votre valeur PROJECT_ID.
Définissez le champ model_id sur l'ID de votre modèle.

Python

python delete_model.py

Java

mvn compile exec:java -Dexec.mainClass="com.example.automl.DeleteModel"

Node.js

node delete_model.js

Réponse

Model deleted.