Questa versione legacy di AutoML Vision è ritirata e non sarà più disponibile su Google Cloud dopo il 31 marzo 2024. Tutte le funzionalità della versione precedente di AutoML Vision e le nuove funzionalità sono disponibili sulla piattaforma Vertex AI. Consulta Eseguire la migrazione a Vertex AI per scoprire come eseguire la migrazione delle risorse.

Addestramento dei modelli esportabili Edge

Puoi creare un modello personalizzato addestrandolo utilizzando un set di dati preparato. L'API AutoML utilizza gli elementi del set di dati per addestrare il modello, testarlo e evaluate le prestazioni. Puoi esaminare i risultati, modificare il set di dati di addestramento in base alle esigenze e addestrare un nuovo modello utilizzando il set di dati migliorato.

L'addestramento di un modello può richiedere diverse ore. L'API AutoML consente di controllare lo stato dell'addestramento.

Poiché AutoML Vision crea un nuovo modello a ogni avvio dell'addestramento, il progetto può includere numerosi modelli. Puoi ottenere un elenco dei modelli presenti nel tuo progetto ed eliminare i modelli che non ti servono più. In alternativa, puoi utilizzare l'interfaccia utente di Cloud AutoML Vision per elencare ed eliminare i modelli creati tramite l'API AutoML che non ti servono più.

I modelli si basano sulla ricerca sullo stato dell'arte di Google. Il modello sarà disponibile come pacchetto TF Lite. Per ulteriori informazioni su come integrare un modello TensorFlow Lite utilizzando l'SDK TensorFlow Lite, consulta i seguenti link per iOS e Android.

Addestramento dei modelli Edge

Quando hai un set di dati con un solido insieme di elementi di addestramento etichettati, puoi creare e addestrare il tuo modello Edge personalizzato.

TensorFlow Service e TF Lite

Durante l'addestramento di modelli Edge, puoi specificare tre valori distinti nel campo modelType a seconda delle esigenze del modello:

mobile-low-latency-1 per una bassa latenza,
mobile-versatile-1 per uso generico oppure
mobile-high-accuracy-1 per una maggiore qualità della previsione.

Il tipo di modello verrà visualizzato anche nella risposta alla richiesta API.

UI web

Apri l'AutoML Vision Object Detection UI.

La pagina Set di dati mostra i set di dati disponibili per il progetto corrente.
Seleziona il set di dati da utilizzare per addestrare il modello personalizzato.
Quando il set di dati è pronto, seleziona la scheda Addestra e il pulsante Addestra nuovo modello.

Si aprirà una finestra laterale "Addestra nuovo modello" con le opzioni di addestramento.
Nella sezione di addestramento Definisci il modello, modifica il nome del modello (o utilizza il valore predefinito) e seleziona Perimetro come tipo di modello. Dopo aver scelto di addestrare un modello Edge, seleziona Continua.
Nella sezione Ottimizza modello per seguente, seleziona il criterio di ottimizzazione desiderato: Maggiore precisione, Miglior compromesso o Previsione più rapida. Dopo aver selezionato la specifica di ottimizzazione, seleziona Continua.
Nella sezione Imposta un budget per l'ora nodo riportata di seguito, utilizza il budget consigliato per l'ora nodo oppure specifica un valore diverso.

Per impostazione predefinita, 24 ore nodo dovrebbero essere sufficienti per la maggior parte dei set di dati per l'addestramento del modello. Questo valore consigliato è una stima per rendere il modello completamente convergente. Tuttavia, puoi sceglierne un altro. Il numero minimo di ore nodo per la classificazione delle immagini è 8. Per il rilevamento di oggetti, questo importo minimo è 20.
Budget per ora nodo: il tempo di addestramento consigliato viene calcolato in base a:
- delle curve di apprendimento del modello
- dimensione del set di dati di addestramento
Se l'addestramento del modello converge prima della selezione del tempo consigliato o personalizzato, il sistema consente un arresto anticipato; ciò significa che ti viene addebitato solo il tempo necessario per l'addestramento del modello. Ti invitiamo a utilizzare la quantità consigliata di ore per evitare di utilizzare più risorse del necessario e ridurre i costi di fatturazione.
Seleziona Inizia addestramento per iniziare l'addestramento del modello.

L'addestramento di un modello può richiedere diverse ore. Al termine dell'addestramento del modello, riceverai un messaggio all'indirizzo email che hai utilizzato per il progetto Google Cloud Platform.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

project-id: l'ID del tuo progetto Google Cloud.
dataset-id: l'ID del set di dati. L'ID è l'ultimo elemento del nome del set di dati. Ecco alcuni esempi:
- nome set di dati: projects/project-id/locations/location-id/datasets/3104518874390609379
- ID set di dati: 3104518874390609379

display-name: un nome visualizzato della stringa a tua scelta.

caratteri validi: A-Z,a-z,0-9 (ASCII), _ (trattino basso); lunghezza: <= 32 caratteri.

my_new_dataset_20191101085615	invalid-name-with-dashes
edge_model_10_october_2019	_invalid_name_that_does_not_start_with_a_letter
mulitlabel_cloud_model_10DEC2019 (<=32 caratteri)	invalid_name_that_is_greater_than_32_characters

Considerazioni specifiche sui campi:

imageObjectDetectionModelMetadata.trainBudgetMilliNodeHours - Il budget dell'addestramento per la creazione del modello, espresso in milliore nodo (1000 valore in questo campo indica 1 ora nodo). Il valore trainCostMilliNodeHours effettivo sarà uguale o inferiore a questo valore. Se l'addestramento ulteriore del modello smette di fornire miglioramenti, verrà interrotto senza utilizzare l'intero budget e il valore stopReason sarà MODEL_CONVERGED.
Nota: node_hour = actual_hour * number_of_nodes_involved).

Per il tipo di modello mobile-low-latency-1, mobile-versatile-1 o mobile-high-accuracy-1, il budget dell'addestramento deve essere compreso tra 1000 e 100.000 mln di ore nodo inclusi. Il valore predefinito è 24.000,che rappresenta un giorno nelltempo totale di esecuzione.

Metodo HTTP e URL:

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

Corpo JSON della richiesta:

{
  "displayName": "DISPLAY_NAME",
  "datasetId": "DATASET_ID",
  "imageObjectDetectionModelMetadata": {
    "modelType": "mobile-low-latency-1",
    "trainBudgetMilliNodeHours": "24000"
  }
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso all'interfaccia a riga di comando gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login oppure utilizzando Cloud Shell, che ti consente di accedere automaticamente all'interfaccia a riga di comando di gcloud. . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

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

PowerShell

Salva il corpo della richiesta in un file denominato request.json ed esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

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

Dovresti vedere un output simile al seguente. Puoi utilizzare l'ID operazione (IOD2106290444865378475, in questo caso) per ottenere lo stato dell'attività. Per un esempio, vedi Operazioni con operazioni a lunga esecuzione.

{
  "name": "projects/PROJECT_ID/locations/us-central1/operations/IOD2106290444865378475",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.automl.v1.OperationMetadata",
    "createTime": "2019-07-29T17:16:34.476787Z",
    "updateTime": "2019-07-29T17:16:34.476787Z",
    "createModelDetails": {}
  }
}

Go

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	"cloud.google.com/go/automl/apiv1/automlpb"
)

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

	ctx := context.Background()
	client, err := automl.NewClient(ctx)
	if err != nil {
		return fmt.Errorf("NewClient: %w", 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_ImageObjectDetectionModelMetadata{
				ImageObjectDetectionModelMetadata: &automlpb.ImageObjectDetectionModelMetadata{},
			},
		},
	}

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

	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.automl.v1.AutoMlClient;
import com.google.cloud.automl.v1.ImageObjectDetectionModelMetadata;
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 VisionObjectDetectionCreateModel {

  static void createModel() 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.
      ImageObjectDetectionModelMetadata metadata =
          ImageObjectDetectionModelMetadata.newBuilder().build();
      Model model =
          Model.newBuilder()
              .setDisplayName(displayName)
              .setDatasetId(datasetId)
              .setImageObjectDetectionModelMetadata(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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

/**
 * 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,
      imageObjectDetectionModelMetadata: {},
    },
  };

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

Python

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

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 = f"projects/{project_id}/locations/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#imageobjectdetectionmodelmetadata
metadata = automl.ImageObjectDetectionModelMetadata(
    train_budget_milli_node_hours=24000
)
model = automl.Model(
    display_name=display_name,
    dataset_id=dataset_id,
    image_object_detection_model_metadata=metadata,
)

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

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

Stato delle operazioni dell'elenco

Utilizza i seguenti esempi di codice per elencare le operazioni del progetto e filtrare i risultati.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

project-id: l'ID del tuo progetto Google Cloud.

Metodo HTTP e URL:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Esegui questo comando:

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

PowerShell

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

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

L'output visualizzato varia a seconda delle operazioni richieste.

Puoi anche filtrare le operazioni restituite utilizzando parametri di ricerca di selezione (operationId, done e worksOn). Ad esempio, per restituire un elenco di operazioni la cui esecuzione è terminata, modifica l'URL:

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

Go

Prima di provare questo esempio, segui le istruzioni di configurazione per questo linguaggio nella pagina API e riferimenti > Librerie client.

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	longrunning "cloud.google.com/go/longrunning/autogen/longrunningpb"
	"google.golang.org/api/iterator"
)

// 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: %w", 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: %w", err)
		}

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

	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione per questo linguaggio nella pagina API e riferimenti > Librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questo linguaggio nella pagina API e riferimenti > Librerie client.

/**
 * 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: `worksOn=projects/${projectId}/locations/${location}/models/*`,
  };

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

Python

Prima di provare questo esempio, segui le istruzioni di configurazione per questo linguaggio nella pagina API e riferimenti > Librerie client.

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 operations names available in the region.
response = client._transport.operations_client.list_operations(
    name=project_location, filter_="", timeout=5
)

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

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e poi consulta la documentazione di riferimento di AutoML Vision Object Detection per .NET.

PHP: segui le istruzioni per la configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di AutoML Vision Object Detection per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di AutoML Vision Object Detection per Ruby.

Ottenere lo stato di un'operazione

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

project-id: l'ID del tuo progetto Google Cloud.
operation-id: l'ID dell'operazione. L'ID è l'ultimo elemento del nome dell'operazione. Ad esempio:
- nome operazione: projects/project-id/locations/location-id/operations/IOD5281059901324392598
- ID operazione: IOD5281059901324392598

Metodo HTTP e URL:

GET https://automl.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/operations/OPERATION_ID

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Esegui questo comando:

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

PowerShell

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

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

Dovresti vedere un output simile al seguente per un'operazione di importazione completata:

{
  "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"
  }
}

Dovresti vedere un output simile al seguente per un'operazione di creazione del modello completata:

{
  "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"
  }
}

Go

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	"cloud.google.com/go/automl/apiv1/automlpb"
)

// getOperationStatus gets an operation's status.
func getOperationStatus(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: %w", 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 err
	}
	fmt.Fprintf(w, "Name: %v\n", op.Name())

	// Wait for the longrunning operation complete.
	resp, err := op.Wait(ctx)
	if err != nil && !op.Done() {
		fmt.Println("failed to fetch operation status", err)
		return err
	}
	if err != nil && op.Done() {
		fmt.Println("operation completed with error", err)
		return err
	}
	fmt.Fprintf(w, "Response: %v\n", resp)

	return nil
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

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

Python

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

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(f"Name: {response.name}")
print("Operation details:")
print(response)

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e poi consulta la documentazione di riferimento di AutoML Vision Object Detection per .NET.

PHP: segui le istruzioni per la configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di AutoML Vision Object Detection per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di AutoML Vision Object Detection per Ruby.

Annullamento di un'operazione

Puoi annullare un'attività di importazione o addestramento utilizzando l'ID operazione.

REST

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

project-id: l'ID del tuo progetto Google Cloud.
operation-id: l'ID dell'operazione. L'ID è l'ultimo elemento del nome dell'operazione. Ad esempio:
- nome operazione: projects/project-id/locations/location-id/operations/IOD5281059901324392598
- ID operazione: IOD5281059901324392598

Metodo HTTP e URL:

POST https://automl.googleapis.com/v1/projects/PROJECT_ID/locations/us-central1/operations/OPERATION_ID:cancel

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Esegui questo comando:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "x-goog-user-project: project-id" \
     -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

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

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

Verrà visualizzato un oggetto JSON vuoto restituito da una richiesta riuscita:

{}

Recupero di informazioni su un modello

Utilizza i seguenti esempi di codice per ottenere informazioni su un modello addestrato specifico. Puoi utilizzare le informazioni restituite da questa richiesta per modificare la modalità o inviare una richiesta di previsione.

REST

Prima di utilizzare i dati della richiesta, effettua le seguenti sostituzioni:

project-id: l'ID del tuo progetto Google Cloud.
model-id: l'ID del modello, dalla risposta al momento della creazione del modello. L'ID è l'ultimo elemento del nome del modello. Ad esempio:
- nome del modello: projects/project-id/locations/location-id/models/IOD4412217016962778756
- ID modello: IOD4412217016962778756

Metodo HTTP e URL:

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

Per inviare la richiesta, scegli una delle seguenti opzioni:

arricciatura

Esegui questo comando:

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

PowerShell

Esegui questo comando:

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred"; "x-goog-user-project" = "project-id" }

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

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_ID/locations/us-central1/models/MODEL_ID",
  "displayName": "DISPLAY_NAME",
  "datasetId": "DATASET_ID",
  "createTime": "2019-07-29T17:16:34.476787Z",
  "deploymentState": "UNDEPLOYED",
  "updateTime": "2019-07-29T18:30:13.601461Z",
  "imageObjectDetectionModelMetadata": {
    "modelType": "mobile-low-latency-1",
    "nodeQps": -1,
    "stopReason": "MODEL_CONVERGED",
    "trainBudgetMilliNodeHours": "24000",
    "trainCostMilliNodeHours": "861"
    }
   }

Go

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

import (
	"context"
	"fmt"
	"io"

	automl "cloud.google.com/go/automl/apiv1"
	"cloud.google.com/go/automl/apiv1/automlpb"
)

// 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: %w", 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: %w", 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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

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

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

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

Python

Prima di provare questo esempio, segui le istruzioni di configurazione per questa lingua nella pagina Librerie client.

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(name=model_full_id)

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

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

Linguaggi aggiuntivi

C#: segui le istruzioni di configurazione di C# nella pagina delle librerie client e poi consulta la documentazione di riferimento di AutoML Vision Object Detection per .NET.

PHP: segui le istruzioni per la configurazione dei file PHP nella pagina delle librerie client e consulta la documentazione di riferimento di AutoML Vision Object Detection per PHP.

Ruby: segui le istruzioni di configurazione di Ruby nella pagina delle librerie client e poi visita la documentazione di riferimento di AutoML Vision Object Detection per Ruby.