Entrena modelos exportables de Edge

Para crear un modelo personalizado, debes entrenarlo con un conjunto de datos preparado. La API de AutoML usa los elementos del conjunto de datos para entrenar el modelo, probarlo y evaluar su rendimiento. Puedes revisar los resultados, ajustar el conjunto de datos de entrenamiento según sea necesario y entrenar un modelo nuevo con el conjunto de datos mejorado.

El entrenamiento de un modelo puede tomar varias horas en completarse. La API de AutoML te permite verificar el estado de la capacitación.

Debido a que AutoML Vision crea un modelo nuevo cada vez que comienzas el entrenamiento, tu proyecto puede incluir varios modelos. Puedes obtener una lista de los modelos de tu proyecto que pueden borrar los modelos que ya no necesitas. Como alternativa, puedes usar la IU de Cloud AutoML Vision para enumerar y borrar los modelos creados mediante la API de AutoML que ya no necesitas.

Nota:

  • A menos que se indique lo contrario en la documentación o las Condiciones del Servicio correspondientes, no se pueden exportar los modelos personalizados creados en los productos de Cloud AutoML.
  • La duración máxima de un modelo personalizado es de 18 meses después del lanzamiento de la disponibilidad general. Debes crear y entrenar un modelo nuevo para continuar la clasificación de contenido después de ese período.
  • Los modelos de Edge están optimizados para la inferencia en un dispositivo de Edge. Por consiguiente, la exactitud del modelo de Edge será diferente de la exactitud del modelo de Cloud.

Los modelos se basan en investigaciones de última generación en Google. Tu modelo estará disponible como un paquete de TF Lite. Si deseas obtener más información sobre cómo integrar un modelo de TensorFlow Lite mediante el SDK de TensorFlow Lite, consulta los siguientes vínculos para iOS y Android.

Entrena modelos de Edge

Cuando tienes un conjunto de datos con un conjunto sólido de elementos de entrenamiento etiquetados, ya puedes crear y entrenar tu modelo de Edge personalizado.

Modelos de TF Lite y TensorFlow Serving

Durante el entrenamiento, puedes elegir el tipo de modelo de Edge que desees, según tu caso práctico específico:

  • Latencia baja (mobile-low-latency-1)
  • Uso general (mobile-versatile-1)
  • Mayor calidad de predicción (mobile-high-accuracy-1)

IU web

  1. Abre el Vision Dashboard.

    La página Conjuntos de datos (Datasets) muestra los conjuntos de datos disponibles para el proyecto actual.

    Enumera la página de un conjunto de datos
  2. Selecciona el conjunto de datos que deseas usar para entrenar el modelo personalizado.
  3. Cuando el conjunto de datos esté listo, selecciona la pestaña Entrenar y el botón Entrenar modelo nuevo.

    Se abrirá una ventana lateral “Entrenar nuevo modelo” (Train new model) con opciones de entrenamiento.

  4. En la sección de entrenamiento Define tu modelo (Define your model), cambia el nombre del modelo (o usa el valor predeterminado) y selecciona Edge como tipo de modelo. Después de seleccionar la opción para entrenar un modelo de Edge, selecciona Continuar (Continue). Imagen del botón de selección para entrenar el modelo de Edge
  5. En la sección Optimizar el modelo para a continuación, selecciona el criterio de optimización que desees: Mayor exactitud (Higher accuracy), Mejor compensación (Best tradeoff) o Predicción más rápida (Faster prediction). Después de seleccionar la especificación de optimización, selecciona Continuar (Continue).

    Imagen del botón de selección de mejor compensación
  6. En la siguiente sección Establecer un presupuesto de hora de procesamiento de nodo, usa el presupuesto recomendado o especifica un valor diferente.

    De forma predeterminada, 24 horas de procesamiento de nodo deberían ser suficientes para la mayoría de los conjuntos de datos. Este valor recomendado es una estimación para hacer que el modelo sea totalmente convergente. Sin embargo, puede elegir otro importe. La cantidad mínima de horas de procesamiento de nodo para la clasificación de imágenes es de 8. Para la detección de objetos, el importe mínimo es de 20.

    Sección de configuración del presupuesto de nodo
  7. Selecciona Comenzar entrenamiento (Start training) para empezar el entrenamiento de modelos.

El entrenamiento de un modelo puede tomar varias horas en completarse. Una vez que el modelo se entrene con éxito, recibirás un mensaje en la dirección de correo electrónico que usaste para tu proyecto de Google Cloud Platform.

LÍNEA DE CMD Y REST

Cuando entrenas modelos de Edge, puedes especificar tres valores distintos en el campo modelType según las necesidades del modelo:

  • mobile-low-latency-1 para una latencia baja
  • mobile-versatile-1 para uso general
  • mobile-high-accuracy-1 para una mayor calidad de predicción

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

  • project-id: Es el ID de tu proyecto de GCP.
  • display-name: Es el nombre visible de la string que elijas.
  • dataset-id: Es el ID de tu conjunto de datos. El ID es el último elemento del nombre del conjunto de datos. Por ejemplo:
    • Nombre del conjunto de datos: projects/project-id/locations/location-id/datasets/3104518874390609379
    • ID del conjunto de datos: 3104518874390609379

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

{
  "displayName": "display-name",
  "datasetId": "dataset-id",
  "imageClassificationModelMetadata": {
    "trainBudget": "1",
    "modelType": "mobile-low-latency-1"
  }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models" | Select-Object -Expand Content

Deberías ver un resultado similar al siguiente. Puedes usar el ID de operación (ICN2106290444865378475, en este caso) para obtener el estado de la tarea. Para ver un ejemplo, consulta Trabaja con operaciones de larga duración.

{
  "name": "projects/project-id/locations/us-central1/operations/ICN2106290444865378475",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2019-10-30T20:06:08.253243Z",
    "updateTime": "2019-10-30T20:06:08.253243Z",
    "createModelDetails": {}
  }
}

C#

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

/// <summary>
/// Demonstrates using the AutoML client to create a model.
/// </summary>
/// <param name="projectId">GCP Project ID.</param>
/// <param name="datasetId">the Id of the dataset.</param>
/// <param name="displayName">The name of the dataset to be created.</param>
public static object VisionClassificationCreateModel(string projectId = "YOUR-PROJECT-ID",
    string datasetId = "YOUR_DATASET_ID",
    string displayName = "YOUR_DATASET_NAME")
{
    // Initialize the client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    AutoMlClient client = AutoMlClient.Create();

    // A resource that represents Google Cloud Platform location.
    string projectLocation = LocationName.Format(projectId, "us-central1");
    // Set model metadata.
    ImageClassificationModelMetadata metadata = new ImageClassificationModelMetadata
    {
        TrainBudgetMilliNodeHours = 24000
    };
    Model model = new Model
    {
        DisplayName = displayName,
        DatasetId = datasetId,
        ImageClassificationModelMetadata = metadata
    };

    // Create a model with the model metadata in the region.
    Operation<Model, OperationMetadata> response =
        client.CreateModel(projectLocation, model);
    // Don't wait for model creation to finish, as this can take several hours.
    // However, you can use the `name` of the operation to check the status of your model.

    Console.WriteLine($"Training operation name: {response.Name}");
    Console.WriteLine("Training started...");
    return 0;
}

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

import (
	"context"
	"fmt"
	"io"

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

// visionClassificationCreateModel creates a model for image classification.
func visionClassificationCreateModel(w io.Writer, projectID string, location string, datasetID string, modelName string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// datasetID := "ICN123456789..."
	// modelName := "model_display_name"

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

	req := &automlpb.CreateModelRequest{
		Parent: fmt.Sprintf("projects/%s/locations/%s", projectID, location),
		Model: &automlpb.Model{
			DisplayName: modelName,
			DatasetId:   datasetID,
			ModelMetadata: &automlpb.Model_ImageClassificationModelMetadata{
				ImageClassificationModelMetadata: &automlpb.ImageClassificationModelMetadata{
					TrainBudgetMilliNodeHours: 1000, // 1000 milli-node hours are 1 hour
				},
			},
		},
	}

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

	return nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

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

class VisionClassificationCreateModel {

  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");
      // Set model metadata.
      ImageClassificationModelMetadata metadata =
          ImageClassificationModelMetadata.newBuilder().setTrainBudgetMilliNodeHours(24000).build();
      Model model =
          Model.newBuilder()
              .setDisplayName(displayName)
              .setDatasetId(datasetId)
              .setImageClassificationModelMetadata(metadata)
              .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

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

/**
 * 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,
      imageClassificationModelMetadata: {
        trainBudgetMilliNodeHours: 24000,
      },
    },
  };

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

createModel();

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

use Google\Cloud\AutoMl\V1\AutoMlClient;
use Google\Cloud\AutoMl\V1\Model;
use Google\Cloud\AutoMl\V1\ImageClassificationModelMetadata;

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

$client = new AutoMlClient();

try {
    // resource that represents Google Cloud Platform location
    $formattedParent = $client->locationName(
        $projectId,
        $location
    );

    // leave model unset to use the default base model provided by Google
    $metadata = new ImageClassificationModelMetadata();
    $model = (new Model())
        ->setDisplayName($displayName)
        ->setDatasetId($datasetId)
        ->setImageClassificationModelMetadata($metadata);

    // create model with above location and metadata
    $operationResponse = $client->createModel($formattedParent, $model);
    $operation = $operationResponse->getOperation();
    printf('Training operation name: %s' . PHP_EOL, $operation->getName());
    print('Training started...' . PHP_EOL);
} finally {
    $client->close();
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

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_models_display_name"

client = automl.AutoMlClient()

# A resource that represents Google Cloud Platform location.
project_location = client.location_path(project_id, "us-central1")
# Leave model unset to use the default base model provided by Google
# train_budget_milli_node_hours: The actual train_cost will be equal or
# less than this value.
# https://cloud.google.com/automl/docs/reference/rpc/google.cloud.automl.v1#imageclassificationmodelmetadata
metadata = automl.types.ImageClassificationModelMetadata(
    train_budget_milli_node_hours=24000
)
model = automl.types.Model(
    display_name=display_name,
    dataset_id=dataset_id,
    image_classification_model_metadata=metadata,
)

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

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

Ruby

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

require "google/cloud/automl"

project_id = "YOUR_PROJECT_ID"
dataset_id = "YOUR_DATASET_ID"
display_name = "YOUR_MODEL_NAME"

client = Google::Cloud::AutoML::AutoML.new

# A resource that represents Google Cloud Platform location.
project_location = client.location_path project_id, "us-central1"
# Leave model unset to use the default base model provided by Google
metadata = automl.types.ImageClassificationModelMetadata()
model = automl.types.Model(
  display_name = display_name,
  dataset_id = dataset_id,
  image_classification_model_metadata = metadata
)

# Create a model with the model metadata in the region.
operation = client.create_model project_location, model

puts "Training started..."

# Wait until the long running operation is done
operation.wait_until_done!

puts "Training complete."

Enumera estados de operaciones

Usa las siguientes muestras de código para enumerar las operaciones de tu proyecto y filtrar los resultados.

LÍNEA DE CMD Y REST

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

  • project-id: Es el ID de tu proyecto de GCP.

Método HTTP y URL:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el siguiente comando:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations

PowerShell

Ejecuta el siguiente comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations" | Select-Object -Expand Content

El resultado que verás variará según las operaciones que hayas solicitado.

También puedes filtrar las operaciones que se muestran con los parámetros de consulta seleccionados (operationId, done y worksOn). Por ejemplo, para mostrar una lista de las operaciones que finalizaron la ejecución, modifica la URL:

GET https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations?filter="done=true"

C#

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

/// <summary>
/// Demonstrates using the AutoML client to list operations.
/// </summary>
/// <param name="projectId">GCP Project ID.</param>
public static object ListOperationStatus(string projectId = "YOUR-PROJECT-ID")
{
    // Initialize the client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    AutoMlClient client = AutoMlClient.Create();

    // A resource that represents Google Cloud Platform location.
    string projectLocation = LocationName.Format(projectId, "us-central1");

    // Create list operations request.
    ListOperationsRequest listrequest = new ListOperationsRequest
    {
        Name = projectLocation
    };

    // List all the operations names available in the region by applying filter.
    foreach (Operation operation in
      client.CreateModelOperationsClient.ListOperations(listrequest))
    {
        Console.WriteLine($"Operation details:");
        Console.WriteLine($"\tName: {operation.Name}");
        Console.WriteLine($"\tMetadata Type Url: { operation.Metadata.TypeUrl}");
        Console.WriteLine($"\tDone: {operation.Done}");
        if (operation.Response != null)
        {
            Console.WriteLine($"\tResponse Type Url: {operation.Response.TypeUrl}");
        }
        if (operation.Error != null)
        {
            Console.WriteLine("\tResponse:");
            Console.WriteLine($"\t\tError code: {operation.Error.Code}");
            Console.WriteLine($"\t\tError message: {operation.Error.Message}");
        }
    }

    return 0;
}

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

import (
	"context"
	"fmt"
	"io"

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

// listOperationStatus lists existing operations' status.
func listOperationStatus(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 := &longrunning.ListOperationsRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s", projectID, location),
	}

	it := client.LROClient.ListOperations(ctx, req)

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

		fmt.Fprintf(w, "Name: %v\n", op.GetName())
		fmt.Fprintf(w, "Operation details:\n")
		fmt.Fprintf(w, "%v", op)
	}

	return nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.LocationName;
import com.google.longrunning.ListOperationsRequest;
import com.google.longrunning.Operation;
import java.io.IOException;

class ListOperationStatus {

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

  // Get the status of an operation
  static void listOperationStatus(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");

      // Create list operations request.
      ListOperationsRequest listrequest =
          ListOperationsRequest.newBuilder().setName(projectLocation.toString()).build();

      // List all the operations names available in the region by applying filter.
      for (Operation operation :
          client.getOperationsClient().listOperations(listrequest).iterateAll()) {
        System.out.println("Operation details:");
        System.out.format("\tName: %s\n", operation.getName());
        System.out.format("\tMetadata Type Url: %s\n", operation.getMetadata().getTypeUrl());
        System.out.format("\tDone: %s\n", operation.getDone());
        if (operation.hasResponse()) {
          System.out.format("\tResponse Type Url: %s\n", operation.getResponse().getTypeUrl());
        }
        if (operation.hasError()) {
          System.out.println("\tResponse:");
          System.out.format("\t\tError code: %s\n", operation.getError().getCode());
          System.out.format("\t\tError message: %s\n\n", operation.getError().getMessage());
        }
      }
    }
  }
}

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

/**
 * 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 listOperationStatus() {
  // Construct request
  const request = {
    name: client.locationPath(projectId, location),
    filter: '',
  };

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

  console.log('List of operation status:');
  for (const operation of response) {
    console.log(`Name: ${operation.name}`);
    console.log('Operation details:');
    console.log(`${operation}`);
  }
}

listOperationStatus();

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

use Google\ApiCore\LongRunning\OperationsClient;

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

$client = new OperationsClient();

try {
    // resource that represents Google Cloud Platform location
    $formattedName = $client->locationName(
        $projectId,
        $location
    );

    // list all operations
    $filter = '';
    $pagedResponse = $client->listOperations($formattedName, '');

    print('List of models' . PHP_EOL);
    foreach ($pagedResponse->iteratePages() as $page) {
        foreach ($page as $operation) {
            // display operation information
            printf('Operation name: %s' . PHP_EOL, $operation->getName());
            print('Operation details: ');
            print($operation);
        }
    }
} finally {
    if (isset($client)) {
        $client->close();
    }
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

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 = client.location_path(project_id, "us-central1")
# List all the operations names available in the region.
response = client.transport._operations_client.list_operations(
    project_location, ""
)

print("List of operations:")
for operation in response:
    print("Name: {}".format(operation.name))
    print("Operation details:")
    print(operation)

Trabaja con operaciones de larga duración

LÍNEA DE CMD Y REST

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

  • project-id: Es el ID de tu proyecto de GCP.
  • operation-id: Es el ID de la operación. El ID es el último elemento del nombre de tu operación. Por ejemplo:
    • Nombre de la operación: projects/project-id/locations/location-id/operations/IOD5281059901324392598
    • ID de la operación: IOD5281059901324392598

Método HTTP y URL:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el siguiente comando:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations/operation-id

PowerShell

Ejecuta el siguiente comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations/operation-id" | Select-Object -Expand Content
Deberías ver un resultado similar al siguiente para una operación de importación completada:
{
  "name": "projects/project-id/locations/us-central1/operations/operation-id",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2018-10-29T15:56:29.176485Z",
    "updateTime": "2018-10-29T16:10:41.326614Z",
    "importDataDetails": {}
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.protobuf.Empty"
  }
}

Deberías ver un resultado similar al siguiente para una operación de creación de modelo completada:

{
  "name": "projects/project-id/locations/us-central1/operations/operation-id",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2019-07-22T18:35:06.881193Z",
    "updateTime": "2019-07-22T19:58:44.972235Z",
    "createModelDetails": {}
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.Model",
    "name": "projects/project-id/locations/us-central1/models/model-id"
  }
}

C#

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

/// <summary>
/// Demonstrates using the AutoML client to get operation status.
/// </summary>
/// <param name="operationFullId">the complete name of a operation. For example, the name of your
/// operation is projects/[projectId]/locations/us-central1/operations/[operationId].</param>
public static object GetOperationStatus(string operationFullId
    = "projects/[projectId]/locations/us-central1/operations/[operationId]")
{
    // Initialize the client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    AutoMlClient client = AutoMlClient.Create();

    // Get the latest state of a long-running operation.
    Operation operation = client.CreateModelOperationsClient.GetOperation(operationFullId);

    // Display operation details.
    Console.WriteLine("Operation details:");
    Console.WriteLine($"\tName: {operation.Name}");
    Console.WriteLine($"\tMetadata Type Url: {operation.Metadata.TypeUrl}");
    Console.WriteLine($"\tDone: {operation.Done}");
    if (operation.Response != null)
    {
        Console.WriteLine($"\tResponse Type Url: {operation.Response.TypeUrl}");
    }
    if (operation.Error != null)
    {
        Console.WriteLine("\tResponse:");
        Console.WriteLine($"\t\tError code: {operation.Error.Code}");
        Console.WriteLine($"\t\tError message: {operation.Error.Message}");
    }

    return 0;
}

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

import (
	"context"
	"fmt"
	"io"

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

// getOperationStatus gets an operation's status.
func getOperationStatus(w io.Writer, projectID string, location string, operationID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// operationID := "TRL123456789..."

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

	req := &longrunning.GetOperationRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/operations/%s", projectID, location, operationID),
	}

	op, err := client.LROClient.GetOperation(ctx, req)
	if err != nil {
		return fmt.Errorf("GetOperation: %v", err)
	}

	fmt.Fprintf(w, "Name: %v\n", op.GetName())
	fmt.Fprintf(w, "Operation details:\n")
	fmt.Fprintf(w, "%v", op)

	return nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

import com.google.cloud.automl.v1.AutoMlClient;
import com.google.longrunning.Operation;
import java.io.IOException;

class GetOperationStatus {

  static void getOperationStatus() throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String operationFullId = "projects/[projectId]/locations/us-central1/operations/[operationId]";
    getOperationStatus(operationFullId);
  }

  // Get the status of an operation
  static void getOperationStatus(String operationFullId) 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 latest state of a long-running operation.
      Operation operation = client.getOperationsClient().getOperation(operationFullId);

      // Display operation details.
      System.out.println("Operation details:");
      System.out.format("\tName: %s\n", operation.getName());
      System.out.format("\tMetadata Type Url: %s\n", operation.getMetadata().getTypeUrl());
      System.out.format("\tDone: %s\n", operation.getDone());
      if (operation.hasResponse()) {
        System.out.format("\tResponse Type Url: %s\n", operation.getResponse().getTypeUrl());
      }
      if (operation.hasError()) {
        System.out.println("\tResponse:");
        System.out.format("\t\tError code: %s\n", operation.getError().getCode());
        System.out.format("\t\tError message: %s\n", operation.getError().getMessage());
      }
    }
  }
}

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

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

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

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

async function getOperationStatus() {
  // Construct request
  const request = {
    name: `projects/${projectId}/locations/${location}/operations/${operationId}`,
  };

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

  console.log(`Name: ${response.name}`);
  console.log('Operation details:');
  console.log(`${response}`);
}

getOperationStatus();

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

use Google\ApiCore\LongRunning\OperationsClient;

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

$client = new OperationsClient();

try {
    // full name of operation
    $formattedName = 'projects/' . $projectId . '/locations/us-central1/operations/' . $operationId;

    // get latest state of long running operation
    $operation = $client->getOperation($name);
    printf('Operation name: %s' . PHP_EOL, $operation->getName());
    print('Operation details: ');
    print($operation);
} finally {
    if (isset($client)) {
        $client->close();
    }
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página API y referencia > Bibliotecas cliente.

from google.cloud import automl

# TODO(developer): Uncomment and set the following variables
# operation_full_id = \
#     "projects/[projectId]/locations/us-central1/operations/[operationId]"

client = automl.AutoMlClient()
# Get the latest state of a long-running operation.
response = client.transport._operations_client.get_operation(
    operation_full_id
)

print("Name: {}".format(response.name))
print("Operation details:")
print(response)

Cancela una operación

Puedes cancelar una tarea de importación o de entrenamiento con el ID de la operación.

LÍNEA DE CMD Y REST

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

  • project-id: Es el ID de tu proyecto de GCP.
  • operation-id: Es el ID de la operación. El ID es el último elemento del nombre de tu operación. Por ejemplo:
    • Nombre de la operación: projects/project-id/locations/location-id/operations/IOD5281059901324392598
    • ID de la operación: IOD5281059901324392598

Método HTTP y URL:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el siguiente comando:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d "" \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations/operation-id:cancel

PowerShell

Ejecuta el siguiente comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/operations/operation-id:cancel" | Select-Object -Expand Content
Verás un objeto JSON vacío que se muestra en una solicitud correcta:
{}

Obtén información sobre un modelo

Cuando se completa el entrenamiento, puedes obtener información sobre el modelo recién creado.

LÍNEA DE CMD Y REST

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

  • project-id: Es el ID de tu proyecto de GCP.
  • model-id: Es el ID de tu modelo, a partir de la respuesta que recibiste cuando lo creaste. El ID es el último elemento del nombre de tu modelo. Por ejemplo:
    • Nombre del modelo: projects/project-id/locations/location-id/models/IOD4412217016962778756
    • ID del modelo: IOD4412217016962778756

Método HTTP y URL:

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

Para enviar tu solicitud, elige una de estas opciones:

curl

Ejecuta el siguiente comando:

curl -X GET \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id

PowerShell

Ejecuta el siguiente comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method GET `
-Headers $headers `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models/model-id" | Select-Object -Expand Content

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



    {
  "name": "projects/project-id/locations/us-central1/models/model-id",
  "displayName": "display-name",
  "datasetId": "dataset-id",
  "createTime": "2019-10-30T20:06:08.253243Z",
  "deploymentState": "UNDEPLOYED",
  "updateTime": "2019-10-30T20:54:50.472328Z",
  "imageClassificationModelMetadata": {
    "trainBudget": "1",
    "modelType": "mobile-low-latency-1",
    "nodeQps": 3.2
  }
}

C#

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

/// <summary>
/// Demonstrates using the AutoML client to get a model by ID.
/// </summary>
/// <param name="projectId">GCP Project ID.</param>
/// <param name="modelId">the Id of the model.</param>
public static object GetModel(string projectId = "YOUR-PROJECT-ID",
    string modelId = "YOUR-MODEL-ID")
{
    // Initialize the client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests.
    AutoMlClient client = AutoMlClient.Create();

    // Get the full path of the model.
    string modelFullId = ModelName.Format(projectId, "us-central1", modelId);
    Model model = client.GetModel(modelFullId);

    // Display the model information.
    Console.WriteLine($"Model name: {model.Name}");
    Console.WriteLine($"Model id: {model.ModelName.ModelId}");
    Console.WriteLine($"Model display name: {model.DisplayName}");
    Console.WriteLine($"Model create time:");
    Console.WriteLine($"\tseconds: { model.CreateTime.Seconds}");
    Console.WriteLine($"\tnanos: {model.CreateTime.Nanos}");
    Console.WriteLine($"Model deployment state: { model.DeploymentState}");

    return 0;
}

Go

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

import (
	"context"
	"fmt"
	"io"

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

// getModel gets a model.
func getModel(w io.Writer, projectID string, location string, modelID string) error {
	// projectID := "my-project-id"
	// location := "us-central1"
	// modelID := "TRL123456789..."

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

	req := &automlpb.GetModelRequest{
		Name: fmt.Sprintf("projects/%s/locations/%s/models/%s", projectID, location, modelID),
	}

	model, err := client.GetModel(ctx, req)
	if err != nil {
		return fmt.Errorf("GetModel: %v", err)
	}

	// Retrieve deployment state.
	deploymentState := "undeployed"
	if model.GetDeploymentState() == automlpb.Model_DEPLOYED {
		deploymentState = "deployed"
	}

	// Display the model information.
	fmt.Fprintf(w, "Model name: %v\n", model.GetName())
	fmt.Fprintf(w, "Model display name: %v\n", model.GetDisplayName())
	fmt.Fprintf(w, "Model create time:\n")
	fmt.Fprintf(w, "\tseconds: %v\n", model.GetCreateTime().GetSeconds())
	fmt.Fprintf(w, "\tnanos: %v\n", model.GetCreateTime().GetNanos())
	fmt.Fprintf(w, "Model deployment state: %v\n", deploymentState)

	return nil
}

Java

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

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

class GetModel {

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

  // Get a model
  static void getModel(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);
      Model model = client.getModel(modelFullId);

      // Display the model information.
      System.out.format("Model name: %s\n", model.getName());
      // To get the model id, you have to parse it out of the `name` field. As models Ids are
      // required for other methods.
      // Name Format: `projects/{project_id}/locations/{location_id}/models/{model_id}`
      String[] names = model.getName().split("/");
      String retrievedModelId = names[names.length - 1];
      System.out.format("Model id: %s\n", retrievedModelId);
      System.out.format("Model display name: %s\n", model.getDisplayName());
      System.out.println("Model create time:");
      System.out.format("\tseconds: %s\n", model.getCreateTime().getSeconds());
      System.out.format("\tnanos: %s\n", model.getCreateTime().getNanos());
      System.out.format("Model deployment state: %s\n", model.getDeploymentState());
    }
  }
}

Node.js

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

/**
 * 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 getModel() {
  // Construct request
  const request = {
    name: client.modelPath(projectId, location, modelId),
  };

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

  console.log(`Model name: ${response.name}`);
  console.log(
    `Model id: ${
      response.name.split('/')[response.name.split('/').length - 1]
    }`
  );
  console.log(`Model display name: ${response.displayName}`);
  console.log('Model create time');
  console.log(`\tseconds ${response.createTime.seconds}`);
  console.log(`\tnanos ${response.createTime.nanos / 1e9}`);
  console.log(`Model deployment state: ${response.deploymentState}`);
}

getModel();

PHP

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

use Google\Cloud\AutoMl\V1\AutoMlClient;
use Google\Cloud\AutoMl\V1\Model\DeploymentState;

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

$client = new AutoMlClient();

try {
    // get full path of model
    $formattedName = $client->modelName(
        $projectId,
        $location,
        $modelId
    );

    $model = $client->getModel($formattedName);

    // retrieve deployment state
    if ($model->getDeploymentState() == DeploymentState::DEPLOYED) {
        $deployment_state = 'deployed';
    } else {
        $deployment_state = 'undeployed';
    }

    // display model information
    $splitName = explode('/', $model->getName());
    printf('Model name: %s' . PHP_EOL, $model->getName());
    printf('Model id: %s' . PHP_EOL, end($splitName));
    printf('Model display name: %s' . PHP_EOL, $model->getDisplayName());
    printf('Model create time' . PHP_EOL);
    printf('seconds: %d' . PHP_EOL, $model->getCreateTime()->getSeconds());
    printf('nanos : %d' . PHP_EOL, $model->getCreateTime()->getNanos());
    printf('Model deployment state: %s' . PHP_EOL, $deployment_state);
} finally {
    $client->close();
}

Python

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

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)
model = client.get_model(model_full_id)

# Retrieve deployment state.
if model.deployment_state == automl.enums.Model.DeploymentState.DEPLOYED:
    deployment_state = "deployed"
else:
    deployment_state = "undeployed"

# Display the model information.
print("Model name: {}".format(model.name))
print("Model id: {}".format(model.name.split("/")[-1]))
print("Model display name: {}".format(model.display_name))
print("Model create time:")
print("\tseconds: {}".format(model.create_time.seconds))
print("\tnanos: {}".format(model.create_time.nanos))
print("Model deployment state: {}".format(deployment_state))

Ruby

Antes de probar esta muestra, sigue las instrucciones de configuración para este lenguaje en la página Bibliotecas cliente.

require "google/cloud/automl"

project_id = "YOUR_PROJECT_ID"
model_id = "YOUR_MODEL_ID"

client = Google::Cloud::AutoML::AutoML.new

# Get the full path of the model.
model_full_id = client.class.model_path project_id, "us-central1", model_id

model = client.get_model model_full_id

# Retrieve deployment state.
deployment_state = if model.deployment_state == :DEPLOYED
                     "deployed"
                   else
                     "undeployed"
                   end

# Display the model information.
puts "Model name: #{model.name}"
puts "Model id: #{model.name.split('/').last}"
puts "Model display name: #{model.display_name}"
puts "Model create time: #{model.create_time.to_time}"
puts "Model deployment state: #{deployment_state}"

Entrenamiento reanudable

Ahora puedes pausar y reanudar tu entrenamiento de modelo personalizado para grandes conjuntos de datos (con más de mil imágenes).

IU web

  1. Abre la AutoML Vision UI.

    En la página Conjuntos de datos (Datasets), se muestran los conjuntos de datos disponibles para el proyecto actual.

    Página de la lista de conjuntos de datos
  2. Selecciona el conjunto de datos que deseas usar para entrenar el modelo personalizado.

    El nombre visible del conjunto de datos seleccionado aparece en la barra de título, y se muestran los elementos individuales del conjunto junto con las etiquetas de cada uno.

    Página de elementos de imagen
  3. Cuando hayas terminado de revisar el conjunto de datos, selecciona la pestaña Train (Entrenar) justo debajo de la barra de título.

    Si ya entrenaste modelos, aparecerán en una lista en esta pestaña.

    Lista de modelos entrenados
  4. Si el entrenamiento reanudable está disponible para un modelo, aparecerá como opción cerca de la opción See full evaluation (Ver evaluación completa).

    Selecciona Resume training (Reanudar el entrenamiento) para reanudarlo en un modelo aplicable.

    Opción de reanudar entrenamiento
  5. Al igual que cuando se entrena el modelo original, si seleccionas Resume training (Reanudar el entrenamiento), se abrirá una ventana lateral de “Entrenar un modelo nuevo”. En la sección Define your model (Define tu modelo), puedes cambiar el nombre del modelo nuevo. También verás el nombre del modelo base que se usa para entrenar este modelo.

    Ventana lateral para definir tu modelo

    Después de definir el modelo, selecciona Continue (Continuar) para pasar a la siguiente sección.

  6. En la siguiente sección Set a node hour budget (Configura un presupuesto por hora de procesamiento de nodo), especifica un presupuesto por hora de procesamiento de nodo. Este presupuesto está sujeto a una estructura de precios y restricciones de cuota similares al entrenamiento del modelo inicial.

    Después de especificar un presupuesto de entrenamiento, selecciona Start training (Comenzar el entrenamiento). Recibirás un correo electrónico cuando finalice el entrenamiento reanudable.

LÍNEA DE CMD Y REST

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

  • base-model-id: Es el ID del modelo base (existente). El modelo nuevo se crea según este modelo base. Las siguientes especificaciones del modelo nuevo deben coincidir con el modelo base:

    * Se marcará modelType nuevo y del modelo base, incluso si este campo se omite en la nueva solicitud de modelo.

  • project-id: Es el ID de tu proyecto de GCP.
  • display-name: Es el nombre visible de la string que elijas.
  • dataset-id: Es el ID de tu conjunto de datos. El ID es el último elemento del nombre del conjunto de datos. Por ejemplo:
    • Nombre del conjunto de datos: projects/project-id/locations/location-id/datasets/3104518874390609379
    • ID del conjunto de datos: 3104518874390609379

Método HTTP y URL:

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

Cuerpo JSON de la solicitud:

{
  "baseModelId": base-model-id,
  "displayName": "display-name",
  "datasetId": "dataset-id",
  "imageClassificationModelMetadata": {
    "trainBudget": "1",
    "modelType": "mobile-low-latency-1"
  }
}

Para enviar tu solicitud, elige una de estas opciones:

curl

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

curl -X POST \
-H "Authorization: Bearer "$(gcloud auth application-default print-access-token) \
-H "Content-Type: application/json; charset=utf-8" \
-d @request.json \
https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models

PowerShell

Guarda el cuerpo de la solicitud en un archivo llamado request.json y ejecuta el siguiente comando:

$cred = gcloud auth application-default print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
-Method POST `
-Headers $headers `
-ContentType: "application/json; charset=utf-8" `
-InFile request.json `
-Uri "https://automl.googleapis.com/v1/projects/project-id/locations/us-central1/models" | Select-Object -Expand Content

Deberías ver un resultado similar al siguiente. Puedes usar el ID de operación (ICN2106290444865378475, en este caso) para obtener el estado de la tarea. Para ver un ejemplo, consulta Trabaja con operaciones de larga duración.

{
  "name": "projects/project-id/locations/us-central1/operations/ICN2106290444865378475",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2019-10-30T20:06:08.253243Z",
    "updateTime": "2019-10-30T20:06:08.253243Z",
    "createModelDetails": {}
  }
}