Crea y administra conjuntos de datos

Un conjunto de datos contiene muestras representativas del tipo de contenido que deseas traducir, como pares de oraciones equivalentes en los idiomas de origen y objetivo. El conjunto de datos sirve como entrada para entrenar un modelo.

Los pasos principales para compilar un conjunto de datos son:

  1. Crear un conjunto de datos y luego identificar los idiomas fuente y objetivo.
  2. Importar pares de oraciones al conjunto de datos.

Un proyecto puede tener varios conjuntos de datos, y cada uno se usa para entrenar un modelo diferente. Puedes obtener una lista de los conjuntos de datos disponibles y, también, borrar los conjuntos de datos que ya no necesites.

Crea un conjunto de datos

El primer paso cuando se crea un modelo personalizado es crear un conjunto de datos vacío que finalmente tendrá los datos de entrenamiento para el modelo. Cuando creas un conjunto de datos, identificas los idiomas fuente y objetivo para el modelo. Para obtener más información sobre los idiomas y las variantes admitidos, consulta Idiomas admitidos para modelos personalizados.

IU web

La IU de AutoML Translation te permite crear un conjunto de datos nuevo e importar elementos desde la misma página.

  1. Visita la IU de AutoML Translation.

  2. Selecciona el proyecto para el que habilitaste AutoML Translation de la lista desplegable en la parte superior derecha de la barra de título.

  3. En la pestaña Conjuntos de datos (Datasets), haz clic en Crear conjunto de datos (Create Dataset).

    Página de conjuntos de datos con un conjunto de datos

  4. En el diálogo Crear conjunto de datos, haz lo siguiente:

    • Ingresa un nombre para el conjunto de datos.

    • Selecciona el idioma de origen y el idioma objetivo en las listas desplegables. Cuando seleccionas un idioma en Traducir del, aparecen los idiomas disponibles en Traducir al.

    • Haz clic en Crear. Se abrirá la pestaña Importar.

LÍNEA DE REST Y CMD

Envía la solicitud de creación de conjunto de datos

A continuación, se muestra cómo enviar una solicitud POST al método project.locations.datasets/create. En el ejemplo, se usa el token de acceso de una cuenta de servicio que se configuró para el proyecto con el SDK de Cloud.

Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

  • project-id: el ID de tu proyecto de Google Cloud Platform
  • dataset-name: el nombre de tu conjunto de datos nuevo
  • source-language-code: el idioma desde el que deseas traducir, como un código ISO 639-1, como “en”
  • target-language-code: el idioma al que deseas traducir, como un código ISO 639-1, como "es"

Método HTTP y URL:

POST https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/datasets

Cuerpo JSON de la solicitud:

{
    "displayName": "dataset-name",
    "translationDatasetMetadata": {
       "sourceLanguageCode": "source-language-code",
       "targetLanguageCode": "target-language-code"
     }
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/project-number/locations/us-central1/operations/operation-id",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2019-10-01T22:13:48.155710Z",
    "updateTime": "2019-10-01T22:13:48.155710Z",
    "createDatasetDetails": {}
  }
}

Obtén los resultados

Para obtener los resultados de tu solicitud, debes enviar una solicitud GET al recurso operations. A continuación, se muestra cómo enviar una solicitud de este tipo.

Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

  • operation-name: el nombre de la operación como se muestra en la respuesta a la llamada original a la API

Método HTTP y URL:

GET https://automl.googleapis.com/v1/operation-name

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2019-10-01T22:13:48.155710Z",
    "updateTime": "2019-10-01T22:13:52.321072Z",
    ...
  },
  "done": true,
  "response": {
    "@type": "resource-type",
    "name": "resource-name"
  }
}

Go

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	automlpb "google.golang.org/genproto/googleapis/cloud/automl/v1"
)

// translateCreateDataset creates a dataset for translate.
func translateCreateDataset(w io.Writer, projectID string, location string, datasetName string, sourceLanguageCode string, targetLanguageCode string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// datasetName := "dataset_display_name"

	// Supported languages:
	//   https://cloud.google.com/translate/automl/docs/languages
	// sourceLanguageCode := "en"
	// targetLanguageCode := "ja"

	ctx := context.Background()
	client, err := automl.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %v", err)
	}
	defer client.Close()

	req := &automlpb.CreateDatasetRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, location),
		Dataset: &automlpb.Dataset{
			DisplayName: datasetName,
			DatasetMetadata: &automlpb.Dataset_TranslationDatasetMetadata{
				TranslationDatasetMetadata: &automlpb.TranslationDatasetMetadata{
					SourceLanguageCode: sourceLanguageCode,
					TargetLanguageCode: targetLanguageCode,
				},
			},
		},
	}

	op, err := client.CreateDataset(ctx, req)
	if err != nil {
		return fmt.Errorf("CreateDataset: %v", err)
	}
	fmt.Fprintf(w, "Processing operation name: %q\n", op.Name())

	dataset, err := op.Wait(ctx)
	if err != nil {
		return fmt.Errorf("Wait: %v", err)
	}

	fmt.Fprintf(w, "Dataset name: %v\n", dataset.GetName())

	return nil
}

Java

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

/**
 * 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();

Python

Antes de que puedas ejecutar este ejemplo de código, debes instalar las Bibliotecas cliente de Python.

Guarda el nombre completo de tu conjunto de datos nuevo para usarlo con otras operaciones, como la importación de elementos a tu conjunto de datos. 

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

Idiomas adicionales

C#: Sigue las instrucciones de configuración de C# en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para .NET.

PHP: Sigue las instrucciones de configuración de PHP que se muestran en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para PHP.

Ruby: sigue las instrucciones de configuración de Ruby en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para Ruby.

Importar elementos a un conjunto de datos

Luego de que hayas creado un conjunto de datos, puedes importar pares de oraciones de entrenamiento. Para obtener detalles sobre cómo preparar datos de entrenamiento, consulta Cómo preparar los datos de entrenamiento.

IU web

La IU de AutoML Translation te permite crear un conjunto de datos nuevo y, también, importar elementos a él desde la misma página (consulta Crea un conjunto de datos). Los pasos siguientes sirven para importar elementos a un conjunto de datos existente.

Después de crear la carpeta del conjunto de datos, debes subir tus datos.

  1. Sube los pares de oraciones que se usarán para entrenar el modelo.

    En la pestaña Importar (Import), puedes subir archivos TSV o TMX desde tu computadora local o desde Cloud Storage. Para los archivos importados de forma local, después de seleccionar el archivo, haz clic en Examinar (Browse). Aparecerá una lista de carpetas. Selecciona la carpeta en la que deseas que se suba el archivo. Se requiere este directorio alojado en Cloud Storage para garantizar la residencia de los datos.

    Selecciona la casilla de verificación de Usar archivos distintos para el entrenamiento, la validación y las pruebas (avanzado) (Use separate files for training, validation, and testing [advanced]), si deseas subir archivos distintos que contengan los pares de oraciones. Esta opción se recomienda si tu conjunto de datos tiene más de 100,000 pares de oraciones. Debes asignar 10,000 pares de oraciones como máximo para los conjuntos de validación y de prueba. De lo contrario, AutoML Translation muestra un error.

    Pestaña Importar (Import)

  2. Haz clic en Continuar (Continue).

    Volverás a la página Conjuntos de datos. El conjunto de datos muestra una animación en curso mientras se importan tus documentos. Cuando tu conjunto de datos se suba con éxito, recibirás un mensaje en la dirección de correo electrónico que usaste para registrarte en el programa.

  3. Revisa el conjunto de datos.

    Una vez que los datos se hayan importado con éxito, selecciona el conjunto de datos de la pestaña Conjuntos de datos para ver los detalles del conjunto de datos. La pestaña Oración está habilitada y muestra el nombre del conjunto de datos. Se crea una lista de los pares de oraciones. A cada par se le asigna “entrenamiento”, “validación” o “prueba”, a fin de indicar en qué etapa del procesamiento se usará.

LÍNEA DE REST Y CMD

Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

  • dataset-name: es el nombre de tu conjunto de datos, como lo mostró la API cuando creaste el conjunto de datos.
  • bucket-name: el depósito de Cloud Storage que contiene el archivo CSV de entrada que describe el conjunto de datos
  • csv-file-name: el nombre del archivo CSV de entrada que describe el conjunto de datos

Método HTTP y URL:

POST https://automl.googleapis.com/v1/dataset-name:import

Cuerpo JSON de la solicitud:

{
  "inputUris": "gs://bucket-name/csv-file-name"
}

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/project-number/locations/us-central1/operations/operation-id",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1beta1.OperationMetadata",
    "createTime": "2018-04-27T01:28:36.128120Z",
    "updateTime": "2018-04-27T01:28:36.128150Z",
    "cancellable": true
  }
}

Go

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	automlpb "google.golang.org/genproto/googleapis/cloud/automl/v1"
)

// importDataIntoDataset imports data into a dataset.
func importDataIntoDataset(w io.Writer, projectID string, location string, datasetID string, inputURI string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// datasetID := "TRL123456789..."
	// inputURI := "gs://BUCKET_ID/path_to_training_data.csv"

	ctx := context.Background()
	client, err := automl.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %v", err)
	}
	defer client.Close()

	req := &automlpb.ImportDataRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/datasets/%s", projectID, location, datasetID),
		InputConfig: &automlpb.InputConfig{
			Source: &automlpb.InputConfig_GcsSource{
				GcsSource: &automlpb.GcsSource{
					InputUris: []string{inputURI},
				},
			},
		},
	}

	op, err := client.ImportData(ctx, req)
	if err != nil {
		return fmt.Errorf("ImportData: %v", err)
	}
	fmt.Fprintf(w, "Processing operation name: %q\n", op.Name())

	if err := op.Wait(ctx); err != nil {
		return fmt.Errorf("Wait: %v", err)
	}

	fmt.Fprintf(w, "Data imported.\n")

	return nil
}

Java

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

/**
 * 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();

Python

Antes de que puedas ejecutar este ejemplo de código, debes instalar las bibliotecas cliente de Python. La API de AutoML solo admite la importación de datos mediante un archivo .csv de tu bucket de Google Cloud Storage.

  • dataset_full_id es el nombre completo del conjunto de datos, con el siguiente formato: projects/{project-id}/locations/us-central1/datasets/{dataset-id}

  • El valor de input_uris debe ser la ruta del archivo CSV en el depósito de Google Cloud Storage asociado a este proyecto. El formato es el siguiente: gs://{project-id}-lcm/{document-name}.csv

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

Idiomas adicionales

C#: Sigue las instrucciones de configuración de C# en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para .NET.

PHP: Sigue las instrucciones de configuración de PHP que se muestran en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para PHP.

Ruby: sigue las instrucciones de configuración de Ruby en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para Ruby.

Una vez que hayas creado y propagado el conjunto de datos, estarás listo para entrenar el modelo (consulta: Administrar modelos).

Administra conjuntos de datos

Enumera conjuntos de datos

Un proyecto puede incluir numerosos conjuntos de datos. En esta sección, se describe cómo recuperar una lista de los conjuntos de datos disponibles para un proyecto.

IU web

Para ver una lista de los conjuntos de datos disponibles que usan la IU de AutoML Translation, haz clic en el vínculo Conjuntos de datos (Datasets) en la parte superior del menú de navegación de la izquierda.

Página de conjuntos de datos con un conjunto de datos

Para ver los conjuntos de datos de otro proyecto, selecciona el proyecto de la lista desplegable en la parte superior derecha de la barra de título.

LÍNEA DE REST Y CMD

Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

  • project-id: el ID de tu proyecto de Google Cloud Platform

Método HTTP y URL:

GET https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/datasets

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "datasets": [
    {
      "name": "projects/project-number/locations/us-central1/datasets/dataset-id",
      "displayName": "dataset-display-name",
      "createTime": "2019-10-01T22:47:38.347689Z",
      "etag": "AB3BwFpPWn6klFqJ867nz98aXr_JHcfYFQBMYTf7rcO-JMi8Ez4iDSNrRW4Vv501i488",
      "translationDatasetMetadata": {
        "sourceLanguageCode": "source-language",
        "targetLanguageCode": "target-language"
      }
    },
    ...
  ]
}

Go

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	"google.golang.org/api/iterator"
	automlpb "google.golang.org/genproto/googleapis/cloud/automl/v1"
)

// listDatasets lists existing datasets.
func listDatasets(w io.Writer, projectID string, location string) error {
	// projectID := "my-project-id"
	// location := "us-central1"

	ctx := context.Background()
	client, err := automl.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %v", err)
	}
	defer client.Close()

	req := &automlpb.ListDatasetsRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, location),
	}

	it := client.ListDatasets(ctx, req)

	// Iterate over all results
	for {
		dataset, err := it.Next()
		if err == iterator.Done {
			break
		}
		if err != nil {
			return fmt.Errorf("ListGlossaries.Next: %v", err)
		}

		fmt.Fprintf(w, "Dataset name: %v\n", dataset.GetName())
		fmt.Fprintf(w, "Dataset display name: %v\n", dataset.GetDisplayName())
		fmt.Fprintf(w, "Dataset create time:\n")
		fmt.Fprintf(w, "\tseconds: %v\n", dataset.GetCreateTime().GetSeconds())
		fmt.Fprintf(w, "\tnanos: %v\n", dataset.GetCreateTime().GetNanos())

		// Translate
		if metadata := dataset.GetTranslationDatasetMetadata(); metadata != nil {
			fmt.Fprintf(w, "Translation dataset metadata:\n")
			fmt.Fprintf(w, "\tsource_language_code: %v\n", metadata.GetSourceLanguageCode())
			fmt.Fprintf(w, "\ttarget_language_code: %v\n", metadata.GetTargetLanguageCode())
		}

	}

	return nil
}

Java

import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.Dataset;
import com.google.cloud.automl.v1.ListDatasetsRequest;
import com.google.cloud.automl.v1.LocationName;
import java.io.IOException;

class ListDatasets {

  static void listDatasets() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    listDatasets(projectId);
  }

  // List the datasets
  static void listDatasets(String projectId) 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()) {
      // A resource that represents Google Cloud Platform location.
      LocationName projectLocation = LocationName.of(projectId, "us-central1");
      ListDatasetsRequest request =
          ListDatasetsRequest.newBuilder().setParent(projectLocation.toString()).build();

      // List all the datasets available in the region by applying filter.
      System.out.println("List of datasets:");
      for (Dataset dataset : client.listDatasets(request).iterateAll()) {
        // Display the dataset information
        System.out.format("\nDataset name: %s\n", dataset.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 = dataset.getName().split("/");
        String retrievedDatasetId = names[names.length - 1];
        System.out.format("Dataset id: %s\n", retrievedDatasetId);
        System.out.format("Dataset display name: %s\n", dataset.getDisplayName());
        System.out.println("Dataset create time:");
        System.out.format("\tseconds: %s\n", dataset.getCreateTime().getSeconds());
        System.out.format("\tnanos: %s\n", dataset.getCreateTime().getNanos());
        System.out.println("Translation dataset metadata:");
        System.out.format(
            "\tSource language code: %s\n",
            dataset.getTranslationDatasetMetadata().getSourceLanguageCode());
        System.out.format(
            "\tTarget language code: %s\n",
            dataset.getTranslationDatasetMetadata().getTargetLanguageCode());
      }
    }
  }
}

Node.js

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

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

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

async function listDatasets() {
  // Construct request
  const request = {
    parent: client.locationPath(projectId, location),
    filter: 'translation_dataset_metadata:*',
  };

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

  console.log('List of datasets:');
  for (const dataset of response) {
    console.log(`Dataset name: ${dataset.name}`);
    console.log(
      `Dataset id: ${
        dataset.name.split('/')[dataset.name.split('/').length - 1]
      }`
    );
    console.log(`Dataset display name: ${dataset.displayName}`);
    console.log('Dataset create time');
    console.log(`\tseconds ${dataset.createTime.seconds}`);
    console.log(`\tnanos ${dataset.createTime.nanos / 1e9}`);
    if (dataset.translationDatasetMetadata !== undefined) {
      console.log('Translation dataset metadata:');
      console.log(
        `\tSource language code: ${dataset.translationDatasetMetadata.sourceLanguageCode}`
      );
      console.log(
        `\tTarget language code: ${dataset.translationDatasetMetadata.targetLanguageCode}`
      );
    }
  }
}

listDatasets();

Python

Antes de que puedas ejecutar este ejemplo de código, debes instalar las bibliotecas cliente de Python. 
from google.cloud import automl

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

client = automl.AutoMlClient()
# A resource that represents Google Cloud Platform location.
project_location = f"projects/{project_id}/locations/us-central1"

# List all the datasets available in the region.
request = automl.ListDatasetsRequest(parent=project_location, filter="")
response = client.list_datasets(request=request)

print("List of datasets:")
for dataset in response:
    print("Dataset name: {}".format(dataset.name))
    print("Dataset id: {}".format(dataset.name.split("/")[-1]))
    print("Dataset display name: {}".format(dataset.display_name))
    print("Dataset create time: {}".format(dataset.create_time))
    print("Translation dataset metadata:")
    print(
        "\tsource_language_code: {}".format(
            dataset.translation_dataset_metadata.source_language_code
        )
    )
    print(
        "\ttarget_language_code: {}".format(
            dataset.translation_dataset_metadata.target_language_code
        )
    )

Idiomas adicionales

C#: Sigue las instrucciones de configuración de C# en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para .NET.

PHP: Sigue las instrucciones de configuración de PHP que se muestran en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para PHP.

Ruby: sigue las instrucciones de configuración de Ruby en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para Ruby.

Borrar un conjunto de datos

IU web

  1. En la IU de AutoML Translation, haz clic en el vínculo Conjuntos de datos (Datasets) situado en la parte superior del menú de navegación de la izquierda para ver la lista de conjuntos de datos disponibles.

    Página de conjuntos de datos con un conjunto de datos

  2. Haz clic en el menú de tres puntos en el extremo derecho de la fila que deseas borrar y selecciona Borrar.

  3. Haz clic en Confirmar en el cuadro de diálogo de confirmación.

LÍNEA DE REST Y CMD

  • Reemplaza dataset-name con el nombre completo del conjunto de datos, de la respuesta cuando lo creaste. El nombre completo tiene el siguiente formato: projects/{project-id}/locations/us-central1/datasets/{dataset-id}

Antes de usar cualquiera de los siguientes datos de solicitud, realiza estos reemplazos:

  • dataset-name: el nombre del conjunto de datos que deseas borrar, en el formato project/project-id/locations/us-central1/datasets/dataset-id

Método HTTP y URL:

DELETE https://automl.googleapis.com/v1/dataset-name

Para enviar tu solicitud, expande una de estas opciones:

Deberías recibir una respuesta JSON similar a la que se muestra a continuación:

{
  "name": "projects/project-number/locations/us-central1/operations/operation-id",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2019-10-02T16:43:03.923442Z",
    "updateTime": "2019-10-02T16:43:03.923442Z",
    "deleteDetails": {}
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.protobuf.Empty"
  }
}

Go

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	automlpb "google.golang.org/genproto/googleapis/cloud/automl/v1"
)

// deleteDataset deletes a dataset.
func deleteDataset(w io.Writer, projectID string, location string, datasetID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// datasetID := "TRL123456789..."

	ctx := context.Background()
	client, err := automl.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %v", err)
	}
	defer client.Close()

	req := &automlpb.DeleteDatasetRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/datasets/%s", projectID, location, datasetID),
	}

	op, err := client.DeleteDataset(ctx, req)
	if err != nil {
		return fmt.Errorf("DeleteDataset: %v", err)
	}
	fmt.Fprintf(w, "Processing operation name: %q\n", op.Name())

	if err := op.Wait(ctx); err != nil {
		return fmt.Errorf("Wait: %v", err)
	}

	fmt.Fprintf(w, "Dataset deleted.\n")

	return nil
}

Java

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

class DeleteDataset {

  static void deleteDataset() throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String datasetId = "YOUR_DATASET_ID";
    deleteDataset(projectId, datasetId);
  }

  // Delete a dataset
  static void deleteDataset(String projectId, String datasetId)
      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 dataset.
      DatasetName datasetFullId = DatasetName.of(projectId, "us-central1", datasetId);
      Empty response = client.deleteDatasetAsync(datasetFullId).get();
      System.out.format("Dataset deleted. %s\n", response);
    }
  }
}

Node.js

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

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

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

async function deleteDataset() {
  // Construct request
  const request = {
    name: client.datasetPath(projectId, location, datasetId),
  };

  const [operation] = await client.deleteDataset(request);

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

deleteDataset();

PHP

use Google\Cloud\AutoMl\V1\AutoMlClient;

/** Uncomment and populate these variables in your code */
// $projectId = '[Google Cloud Project ID]';
// $location = 'us-central1';
// $datasetId = 'my_dataset_id_123';

$client = new AutoMlClient();

try {
    // get full path of dataset
    $formattedName = $client->datasetName(
        $projectId,
        $location,
        $datasetId
    );

    $operationResponse = $client->deleteDataset($formattedName);
    $operationResponse->pollUntilComplete();
    if ($operationResponse->operationSucceeded()) {
        $result = $operationResponse->getResult();
        printf('Dataset deleted.' . PHP_EOL);
    } else {
        $error = $operationResponse->getError();
        // handleError($error)
    }
} finally {
    $client->close();
}

Python

Antes de que puedas ejecutar este ejemplo de código, debes instalar las bibliotecas cliente de Python.

  • dataset_id es el nombre completo del conjunto de datos, con el siguiente formato: projects/{project-id}/locations/us-central1/datasets/{dataset-id}
from google.cloud import automl

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

client = automl.AutoMlClient()
# Get the full path of the dataset
dataset_full_id = client.dataset_path(project_id, "us-central1", dataset_id)
response = client.delete_dataset(name=dataset_full_id)

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

Idiomas adicionales

C#: Sigue las instrucciones de configuración de C# en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para .NET.

PHP: Sigue las instrucciones de configuración de PHP que se muestran en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para PHP.

Ruby: sigue las instrucciones de configuración de Ruby en la página de bibliotecas cliente y, luego, visita el 101} Documentación de referencia de AutoML Translation para Ruby.

Problemas de importación

Cuando creas un conjunto de datos, AutoML Translation puede descartar pares de oraciones si son demasiado largos o si los pares son exactamente los mismos en los idiomas de origen y destino.

En el caso de los pares de oraciones demasiado largos, te recomendamos que dividas las oraciones de aproximadamente 200 palabras o menos y, luego, vuelvas a crear el conjunto de datos para incluir los pares descartados. Mientras se procesan tus datos, AutoML Translation usa un proceso interno para asignar tokens a los datos de entrada, lo que puede aumentar el tamaño de las oraciones. Estos datos con tokens asignados son los que AutoML Translation usa para medir el tamaño de los datos. Por lo tanto, el límite de 200 palabras es una estimación para la longitud máxima.

En el caso de los pares de oraciones que son iguales en los idiomas de origen y objetivo, puedes quitarlos de tu conjunto de datos. Si quieres mantener estas oraciones sin traducir, usa un recurso de glosario para crear un diccionario personalizado que defina cómo AutoML Translation maneja términos específicos.