Ottenere le previsioni da un modello di classificazione delle immagini

Questa pagina mostra come ottenere previsioni online (in tempo reale) e previsioni batch dai tuoi modelli di classificazione delle immagini utilizzando la console Google Cloud o l'API Vertex AI.

Differenza tra le previsioni online e batch

Le previsioni online sono richieste sincrone effettuate a un endpoint del modello. Utilizza le predizioni online quando effettui richieste in risposta all'input dell'applicazione o in situazioni che richiedono un'inferenza tempestiva.

Le previsioni batch sono richieste asincrone. Le previsioni batch vanno richieste direttamente dalla risorsa del modello senza dover eseguire il deployment del modello in un endpoint. Per i dati delle immagini, utilizza le previsioni batch quando non hai bisogno di una risposta immediata e vuoi elaborare i dati accumulati utilizzando una singola richiesta.

Ricevere previsioni online

Eseguire il deployment di un modello in un endpoint

Devi eseguire il deployment di un modello in un endpoint prima di poterlo usare per fornire predizioni online. Il deployment di un modello associa risorse fisiche al modello in modo che possa fornire previsioni online con bassa latenza.

Puoi eseguire il deployment di più modelli in un endpoint e puoi eseguire il deployment di un modello in più di un endpoint. Per ulteriori informazioni sulle opzioni e sui casi d'uso per il deployment dei modelli, consulta Informazioni sul deployment dei modelli.

Per eseguire il deployment di un modello, utilizza uno dei seguenti metodi:

Console Google Cloud

1. Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Modelli.

   Vai alla pagina Modelli

2. Fai clic sul nome del modello di cui vuoi eseguire il deployment per aprire la pagina Descrizione modello.

3. Nella colonna ID versione, fai clic sull'ID della versione del modello che vuoi implementare.

4. Fai clic su Deployment e test.

   Se il modello è già stato implementato in uno o più endpoint, questi sono elencati nella sezione Esegui il deployment del modello.

5. Fai clic su Esegui il deployment nell'endpoint.

6. Per eseguire il deployment del modello in un nuovo endpoint, fai clic su Crea nuovo endpoint e inserisci un nome per il nuovo endpoint. Per eseguire il deployment del modello in un endpoint esistente, fai clic su Aggiungi a endpoint esistente e seleziona l'endpoint Nome endpoint.

   Puoi aggiungere più di un modello a un endpoint e un modello a più endpoint. Scopri di più.

   Se esegui il deployment in un nuovo endpoint, scegli la modalità di accesso all'endpoint:

   • Fai clic su Standard per rendere l'endpoint disponibile per la previsione tramite un'API REST.

   • Fai clic su Privato affinché l'endpoint utilizzi una connessione privata.

   Se esegui il deployment in un endpoint esistente in cui sono stati dipiazzati uno o più modelli, aggiorna la percentuale di Suddivisione del traffico per il modello di cui stai eseguendo il deployment e per i modelli già dipiazzati in modo che le relative percentuali sommino al 100%.

7. Seleziona AutoML Image e configura come segue:

   1. Se esegui il deployment del modello in un nuovo endpoint, accetta 100 per la Suddivisione del traffico. In caso contrario, modifica i valori di suddivisione del traffico per tutti i modelli nell'endpoint in modo che la somma sia pari a 100.

   2. Inserisci il numero di nodi di calcolo che vuoi fornire per il tuo modello.

      Si tratta del numero di nodi disponibili per questo modello in qualsiasi momento. Ti vengono addebitati i costi per i nodi, anche senza traffico di previsione. Consulta la pagina dei prezzi.

   3. Scopri come modificare le impostazioni predefinite per la registrazione delle previsioni.

   4. Solo modelli di classificazione (facoltativo): nella sezione Opzioni di spiegabilità, seleziona Attiva l'attribuzione delle caratteristiche per questo modello per attivare Vertex Explainable AI. Accetta le impostazioni di visualizzazione esistenti o scegli nuovi valori e fai clic su Fine.

      Il deployment di modelli di classificazione delle immagini AutoML con Vertex Explainable AI configurato ed esecuzione di previsioni con spiegazioni è facoltativo. L'attivazione di Vertex Explainable AI al momento del deployment comporta costi aggiuntivi in base al numero di nodi di cui è stato eseguito il deployment e al momento del deployment. Per ulteriori informazioni, consulta la sezione Prezzi.

   5. Fai clic su Fine per il modello e, quando tutte le percentuali di Suddivisione traffico sono corrette, fai clic su Continua.

      Viene visualizzata la regione in cui viene eseguito il deployment del modello. Deve essere la regione in cui hai creato il modello.

   6. Fai clic su Esegui il deployment per eseguire il deployment del modello nell'endpoint.

API

Quando esegui il deployment di un modello utilizzando l'API Vertex AI, completa i seguenti passaggi:

1. Crea un endpoint, se necessario.
2. Recupera l'ID endpoint.
3. Esegui il deployment del modello nell'endpoint.

Creazione di un endpoint

Se stai eseguendo il deployment di un modello in un endpoint esistente, puoi saltare questo passaggio.

gcloud

Nell'esempio seguente viene utilizzato il comando gcloud ai endpoints create:

gcloud ai endpoints create \
  --region=LOCATION \
  --display-name=ENDPOINT_NAME

Sostituisci quanto segue:

• LOCATION_ID: la regione in cui utilizzi Vertex AI.
• ENDPOINT_NAME: il nome visualizzato dell'endpoint.

Lo strumento Google Cloud CLI potrebbe richiedere alcuni secondi per creare l'endpoint.

REST

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

• LOCATION_ID: la tua regione.
• PROJECT_ID: il tuo ID progetto.
• ENDPOINT_NAME: il nome visualizzato dell'endpoint.

Metodo HTTP e URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints

Corpo JSON della richiesta:

{
  "display_name": "ENDPOINT_NAME"
}

Per inviare la richiesta, espandi una di queste opzioni:

curl (Linux, macOS o Cloud Shell)

Nota: il seguente comando 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 gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints"

PowerShell (Windows)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso alla CLI gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

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

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.CreateEndpointOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-11-05T17:45:42.812656Z",
      "updateTime": "2020-11-05T17:45:42.812656Z"
    }
  }
}

Puoi eseguire il polling per lo stato dell'operazione finché la risposta non include "done": true.

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di Vertex AI.

Per autenticarti in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.CreateEndpointOperationMetadata;
import com.google.cloud.aiplatform.v1.Endpoint;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateEndpointSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String endpointDisplayName = "YOUR_ENDPOINT_DISPLAY_NAME";
    createEndpointSample(project, endpointDisplayName);
  }

  static void createEndpointSample(String project, String endpointDisplayName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    EndpointServiceSettings endpointServiceSettings =
        EndpointServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // 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 (EndpointServiceClient endpointServiceClient =
        EndpointServiceClient.create(endpointServiceSettings)) {
      String location = "us-central1";
      LocationName locationName = LocationName.of(project, location);
      Endpoint endpoint = Endpoint.newBuilder().setDisplayName(endpointDisplayName).build();

      OperationFuture<Endpoint, CreateEndpointOperationMetadata> endpointFuture =
          endpointServiceClient.createEndpointAsync(locationName, endpoint);
      System.out.format("Operation name: %s\n", endpointFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      Endpoint endpointResponse = endpointFuture.get(300, TimeUnit.SECONDS);

      System.out.println("Create Endpoint Response");
      System.out.format("Name: %s\n", endpointResponse.getName());
      System.out.format("Display Name: %s\n", endpointResponse.getDisplayName());
      System.out.format("Description: %s\n", endpointResponse.getDescription());
      System.out.format("Labels: %s\n", endpointResponse.getLabelsMap());
      System.out.format("Create Time: %s\n", endpointResponse.getCreateTime());
      System.out.format("Update Time: %s\n", endpointResponse.getUpdateTime());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js di Vertex AI.

Per autenticarti in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const endpointDisplayName = 'YOUR_ENDPOINT_DISPLAY_NAME';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Endpoint Service Client library
const {EndpointServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const endpointServiceClient = new EndpointServiceClient(clientOptions);

async function createEndpoint() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const endpoint = {
    displayName: endpointDisplayName,
  };
  const request = {
    parent,
    endpoint,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] = await endpointServiceClient.createEndpoint(request);
  console.log(`Long running operation : ${response.name}`);

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

  console.log('Create endpoint response');
  console.log(`\tName : ${result.name}`);
  console.log(`\tDisplay name : ${result.displayName}`);
  console.log(`\tDescription : ${result.description}`);
  console.log(`\tLabels : ${JSON.stringify(result.labels)}`);
  console.log(`\tCreate time : ${JSON.stringify(result.createTime)}`);
  console.log(`\tUpdate time : ${JSON.stringify(result.updateTime)}`);
}
createEndpoint();

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

def create_endpoint_sample(
    project: str,
    display_name: str,
    location: str,
):
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint.create(
        display_name=display_name,
        project=project,
        location=location,
    )

    print(endpoint.display_name)
    print(endpoint.resource_name)
    return endpoint

Recupera l'ID endpoint

Per eseguire il deployment del modello, devi disporre dell'ID endpoint.

gcloud

Nell'esempio seguente viene utilizzato il comando gcloud ai endpoints list:

gcloud ai endpoints list \
  --region=LOCATION \
  --filter=display_name=ENDPOINT_NAME

Sostituisci quanto segue:

• LOCATION_ID: la regione in cui utilizzi Vertex AI.
• ENDPOINT_NAME: il nome visualizzato dell'endpoint.

Prendi nota del numero visualizzato nella colonna ENDPOINT_ID. Utilizza questo ID nel passaggio successivo.

REST

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

• LOCATION_ID: la regione in cui utilizzi Vertex AI.
• PROJECT_ID: il tuo ID progetto.
• ENDPOINT_NAME: il nome visualizzato dell'endpoint.

Metodo HTTP e URL:

GET https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME

Per inviare la richiesta, espandi una di queste opzioni:

curl (Linux, macOS o Cloud Shell)

Nota: il seguente comando 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 gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Esegui questo comando:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME"

PowerShell (Windows)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso alla CLI gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Esegui questo comando:

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

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "endpoints": [
    {
      "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID",
      "displayName": "ENDPOINT_NAME",
      "etag": "AMEw9yPz5pf4PwBHbRWOGh0PcAxUdjbdX2Jm3QO_amguy3DbZGP5Oi_YUKRywIE-BtLx",
      "createTime": "2020-04-17T18:31:11.585169Z",
      "updateTime": "2020-04-17T18:35:08.568959Z"
    }
  ]
}

Fai attenzione alla ENDPOINT_ID.

Esegui il deployment del modello

Seleziona la scheda di seguito per la tua lingua o il tuo ambiente:

gcloud

I seguenti esempi utilizzano il comando gcloud ai endpoints deploy-model.

L'esempio seguente esegue il deployment di un Model in un Endpoint senza suddividere il traffico tra più risorse DeployedModel:

Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:

• ENDPOINT_ID: l'ID dell'endpoint.
• LOCATION_ID: la regione in cui utilizzi Vertex AI.
• MODEL_ID: l'ID del modello da implementare.
• DEPLOYED_MODEL_NAME: un nome per il DeployedModel. Puoi utilizzare il nome visualizzato del Model anche per DeployedModel.
• MIN_REPLICA_COUNT: il numero minimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base al carico della previsione, fino al numero massimo di nodi e mai meno di questo numero.
• MAX_REPLICA_COUNT: il numero massimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base al carico della previsione, fino a questo numero di nodi e mai inferiore al numero minimo di nodi. Se il flag --max-replica-count viene omesso, il numero massimo di nodi viene impostato sul valore di --min-replica-count.

Esegui il comando gcloud ai endpoints deploy-model:

Linux, macOS o Cloud Shell

Nota: assicurati di aver inizializzato Google Cloud CLI con l'autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=100

Windows (PowerShell)

Nota: assicurati di aver inizializzato Google Cloud CLI con l'autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME `
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=100

Windows (cmd.exe)

Nota: assicurati di aver inizializzato Google Cloud CLI con l'autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME ^
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=100

 

Suddivisione del traffico

Il flag --traffic-split=0=100 negli esempi precedenti invia il 100% del traffico di previsione ricevuto da Endpoint al nuovo DeployedModel, rappresentato dall'ID temporaneo 0. Se il tuo Endpoint ha già altre risorseDeployedModel, puoi suddividere il traffico tra il nuovoDeployedModel e quello precedente. Ad esempio, per inviare il 20% del traffico al nuovo DeployedModel e l'80% a uno precedente, esegui il seguente comando.

Prima di utilizzare i dati dei comandi riportati di seguito, effettua le seguenti sostituzioni:

• OLD_DEPLOYED_MODEL_ID: l'ID del DeployedModel esistente.

Esegui il comando gcloud ai endpoints deploy-model:

Linux, macOS o Cloud Shell

Nota: assicurati di aver inizializzato Google Cloud CLI con l'autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (PowerShell)

Nota: assicurati di aver inizializzato Google Cloud CLI con l'autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (cmd.exe)

Nota: assicurati di aver inizializzato Google Cloud CLI con l'autenticazione e un progetto eseguendo gcloud init; oppure gcloud auth login e gcloud config set project.

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

 

REST

Esegui il deployment del modello.

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

• LOCATION_ID: la regione in cui utilizzi Vertex AI.
• PROJECT_ID: il tuo ID progetto.
• ENDPOINT_ID: l'ID dell'endpoint.
• MODEL_ID: l'ID del modello da implementare.
• DEPLOYED_MODEL_NAME: un nome per il DeployedModel. Puoi utilizzare il nome visualizzato del Model anche per DeployedModel.
• MIN_REPLICA_COUNT: il numero minimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base al carico della previsione, fino al numero massimo di nodi e mai meno di questo numero.
• MAX_REPLICA_COUNT: il numero massimo di nodi per questo deployment. Il numero di nodi può essere aumentato o diminuito in base al carico della previsione, fino a questo numero di nodi e mai inferiore al numero minimo di nodi.
• TRAFFIC_SPLIT_THIS_MODEL: la percentuale del traffico di previsione per questo endpoint da inoltrare al modello di cui viene eseguito il deployment con questa operazione. Il valore predefinito è 100. La somma di tutte le percentuali di traffico deve essere pari al 100%. Scopri di più sulle suddivisioni del traffico.
• DEPLOYED_MODEL_ID_N: facoltativo. Se in questo endpoint sono di cui è stato eseguito il deployment di altri modelli, devi aggiornare le relative percentuali di suddivisione del traffico in modo che tutte le percentuali sommate diano 100.
• TRAFFIC_SPLIT_MODEL_N: il valore percentuale della suddivisione del traffico per la chiave ID modello di cui è stato eseguito il deployment.
• PROJECT_NUMBER: il numero di progetto generato automaticamente del progetto

Metodo HTTP e URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel

Corpo JSON della richiesta:

{
  "deployedModel": {
    "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_NAME",
    "automaticResources": {
       "minReplicaCount": MIN_REPLICA_COUNT,
       "maxReplicaCount": MAX_REPLICA_COUNT
     }
  },
  "trafficSplit": {
    "0": TRAFFIC_SPLIT_THIS_MODEL,
    "DEPLOYED_MODEL_ID_1": TRAFFIC_SPLIT_MODEL_1,
    "DEPLOYED_MODEL_ID_2": TRAFFIC_SPLIT_MODEL_2
  },
}

Per inviare la richiesta, espandi una di queste opzioni:

curl (Linux, macOS o Cloud Shell)

Nota: il seguente comando 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 gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel"

PowerShell (Windows)

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso alla CLI gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

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

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-19T17:53:16.502088Z",
      "updateTime": "2020-10-19T17:53:16.502088Z"
    }
  }
}

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Java di Vertex AI.

Per autenticarti in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

import com.google.api.gax.longrunning.OperationFuture;
import com.google.api.gax.longrunning.OperationTimedPollAlgorithm;
import com.google.api.gax.retrying.RetrySettings;
import com.google.cloud.aiplatform.v1.AutomaticResources;
import com.google.cloud.aiplatform.v1.DedicatedResources;
import com.google.cloud.aiplatform.v1.DeployModelOperationMetadata;
import com.google.cloud.aiplatform.v1.DeployModelResponse;
import com.google.cloud.aiplatform.v1.DeployedModel;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.cloud.aiplatform.v1.stub.EndpointServiceStubSettings;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.threeten.bp.Duration;

public class DeployModelSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String deployedModelDisplayName = "YOUR_DEPLOYED_MODEL_DISPLAY_NAME";
    String endpointId = "YOUR_ENDPOINT_NAME";
    String modelId = "YOUR_MODEL_ID";
    int timeout = 900;
    deployModelSample(project, deployedModelDisplayName, endpointId, modelId, timeout);
  }

  static void deployModelSample(
      String project,
      String deployedModelDisplayName,
      String endpointId,
      String modelId,
      int timeout)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {

    // Set long-running operations (LROs) timeout
    final OperationTimedPollAlgorithm operationTimedPollAlgorithm =
        OperationTimedPollAlgorithm.create(
            RetrySettings.newBuilder()
                .setInitialRetryDelay(Duration.ofMillis(5000L))
                .setRetryDelayMultiplier(1.5)
                .setMaxRetryDelay(Duration.ofMillis(45000L))
                .setInitialRpcTimeout(Duration.ZERO)
                .setRpcTimeoutMultiplier(1.0)
                .setMaxRpcTimeout(Duration.ZERO)
                .setTotalTimeout(Duration.ofSeconds(timeout))
                .build());

    EndpointServiceStubSettings.Builder endpointServiceStubSettingsBuilder =
        EndpointServiceStubSettings.newBuilder();
    endpointServiceStubSettingsBuilder
        .deployModelOperationSettings()
        .setPollingAlgorithm(operationTimedPollAlgorithm);
    EndpointServiceStubSettings endpointStubSettings = endpointServiceStubSettingsBuilder.build();
    EndpointServiceSettings endpointServiceSettings =
        EndpointServiceSettings.create(endpointStubSettings);
    endpointServiceSettings =
        endpointServiceSettings.toBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // 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 (EndpointServiceClient endpointServiceClient =
        EndpointServiceClient.create(endpointServiceSettings)) {
      String location = "us-central1";
      EndpointName endpointName = EndpointName.of(project, location, endpointId);
      // key '0' assigns traffic for the newly deployed model
      // Traffic percentage values must add up to 100
      // Leave dictionary empty if endpoint should not accept any traffic
      Map<String, Integer> trafficSplit = new HashMap<>();
      trafficSplit.put("0", 100);
      ModelName modelName = ModelName.of(project, location, modelId);
      AutomaticResources automaticResourcesInput =
          AutomaticResources.newBuilder().setMinReplicaCount(1).setMaxReplicaCount(1).build();
      DeployedModel deployedModelInput =
          DeployedModel.newBuilder()
              .setModel(modelName.toString())
              .setDisplayName(deployedModelDisplayName)
              .setAutomaticResources(automaticResourcesInput)
              .build();

      OperationFuture<DeployModelResponse, DeployModelOperationMetadata> deployModelResponseFuture =
          endpointServiceClient.deployModelAsync(endpointName, deployedModelInput, trafficSplit);
      System.out.format(
          "Operation name: %s\n", deployModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      DeployModelResponse deployModelResponse = deployModelResponseFuture.get(20, TimeUnit.MINUTES);

      System.out.println("Deploy Model Response");
      DeployedModel deployedModel = deployModelResponse.getDeployedModel();
      System.out.println("\tDeployed Model");
      System.out.format("\t\tid: %s\n", deployedModel.getId());
      System.out.format("\t\tmodel: %s\n", deployedModel.getModel());
      System.out.format("\t\tDisplay Name: %s\n", deployedModel.getDisplayName());
      System.out.format("\t\tCreate Time: %s\n", deployedModel.getCreateTime());

      DedicatedResources dedicatedResources = deployedModel.getDedicatedResources();
      System.out.println("\t\tDedicated Resources");
      System.out.format("\t\t\tMin Replica Count: %s\n", dedicatedResources.getMinReplicaCount());

      MachineSpec machineSpec = dedicatedResources.getMachineSpec();
      System.out.println("\t\t\tMachine Spec");
      System.out.format("\t\t\t\tMachine Type: %s\n", machineSpec.getMachineType());
      System.out.format("\t\t\t\tAccelerator Type: %s\n", machineSpec.getAcceleratorType());
      System.out.format("\t\t\t\tAccelerator Count: %s\n", machineSpec.getAcceleratorCount());

      AutomaticResources automaticResources = deployedModel.getAutomaticResources();
      System.out.println("\t\tAutomatic Resources");
      System.out.format("\t\t\tMin Replica Count: %s\n", automaticResources.getMinReplicaCount());
      System.out.format("\t\t\tMax Replica Count: %s\n", automaticResources.getMaxReplicaCount());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione Node.js riportate nella guida rapida all'utilizzo delle librerie client di Vertex AI. Per ulteriori informazioni, consulta la documentazione di riferimento dell'API Node.js di Vertex AI.

Per autenticarti in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale.

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const modelId = "YOUR_MODEL_ID";
// const endpointId = 'YOUR_ENDPOINT_ID';
// const deployedModelDisplayName = 'YOUR_DEPLOYED_MODEL_DISPLAY_NAME';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

const modelName = `projects/${project}/locations/${location}/models/${modelId}`;
const endpoint = `projects/${project}/locations/${location}/endpoints/${endpointId}`;
// Imports the Google Cloud Endpoint Service Client library
const {EndpointServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint:
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const endpointServiceClient = new EndpointServiceClient(clientOptions);

async function deployModel() {
  // Configure the parent resource
  // key '0' assigns traffic for the newly deployed model
  // Traffic percentage values must add up to 100
  // Leave dictionary empty if endpoint should not accept any traffic
  const trafficSplit = {0: 100};
  const deployedModel = {
    // format: 'projects/{project}/locations/{location}/models/{model}'
    model: modelName,
    displayName: deployedModelDisplayName,
    automaticResources: {minReplicaCount: 1, maxReplicaCount: 1},
  };
  const request = {
    endpoint,
    deployedModel,
    trafficSplit,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] = await endpointServiceClient.deployModel(request);
  console.log(`Long running operation : ${response.name}`);

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

  console.log('Deploy model response');
  const modelDeployed = result.deployedModel;
  console.log('\tDeployed model');
  if (!modelDeployed) {
    console.log('\t\tId : {}');
    console.log('\t\tModel : {}');
    console.log('\t\tDisplay name : {}');
    console.log('\t\tCreate time : {}');

    console.log('\t\tDedicated resources');
    console.log('\t\t\tMin replica count : {}');
    console.log('\t\t\tMachine spec {}');
    console.log('\t\t\t\tMachine type : {}');
    console.log('\t\t\t\tAccelerator type : {}');
    console.log('\t\t\t\tAccelerator count : {}');

    console.log('\t\tAutomatic resources');
    console.log('\t\t\tMin replica count : {}');
    console.log('\t\t\tMax replica count : {}');
  } else {
    console.log(`\t\tId : ${modelDeployed.id}`);
    console.log(`\t\tModel : ${modelDeployed.model}`);
    console.log(`\t\tDisplay name : ${modelDeployed.displayName}`);
    console.log(`\t\tCreate time : ${modelDeployed.createTime}`);

    const dedicatedResources = modelDeployed.dedicatedResources;
    console.log('\t\tDedicated resources');
    if (!dedicatedResources) {
      console.log('\t\t\tMin replica count : {}');
      console.log('\t\t\tMachine spec {}');
      console.log('\t\t\t\tMachine type : {}');
      console.log('\t\t\t\tAccelerator type : {}');
      console.log('\t\t\t\tAccelerator count : {}');
    } else {
      console.log(
        `\t\t\tMin replica count : \
          ${dedicatedResources.minReplicaCount}`
      );
      const machineSpec = dedicatedResources.machineSpec;
      console.log('\t\t\tMachine spec');
      console.log(`\t\t\t\tMachine type : ${machineSpec.machineType}`);
      console.log(
        `\t\t\t\tAccelerator type : ${machineSpec.acceleratorType}`
      );
      console.log(
        `\t\t\t\tAccelerator count : ${machineSpec.acceleratorCount}`
      );
    }

    const automaticResources = modelDeployed.automaticResources;
    console.log('\t\tAutomatic resources');
    if (!automaticResources) {
      console.log('\t\t\tMin replica count : {}');
      console.log('\t\t\tMax replica count : {}');
    } else {
      console.log(
        `\t\t\tMin replica count : \
          ${automaticResources.minReplicaCount}`
      );
      console.log(
        `\t\t\tMax replica count : \
          ${automaticResources.maxReplicaCount}`
      );
    }
  }
}
deployModel();

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

def deploy_model_with_automatic_resources_sample(
    project,
    location,
    model_name: str,
    endpoint: Optional[aiplatform.Endpoint] = None,
    deployed_model_display_name: Optional[str] = None,
    traffic_percentage: Optional[int] = 0,
    traffic_split: Optional[Dict[str, int]] = None,
    min_replica_count: int = 1,
    max_replica_count: int = 1,
    metadata: Optional[Sequence[Tuple[str, str]]] = (),
    sync: bool = True,
):
    """
    model_name: A fully-qualified model resource name or model ID.
          Example: "projects/123/locations/us-central1/models/456" or
          "456" when project and location are initialized or passed.
    """

    aiplatform.init(project=project, location=location)

    model = aiplatform.Model(model_name=model_name)

    model.deploy(
        endpoint=endpoint,
        deployed_model_display_name=deployed_model_display_name,
        traffic_percentage=traffic_percentage,
        traffic_split=traffic_split,
        min_replica_count=min_replica_count,
        max_replica_count=max_replica_count,
        metadata=metadata,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    return model

Scopri come modificare le impostazioni predefinite per la registrazione delle previsioni.

Recupera lo stato dell'operazione

Alcune richieste avviano operazioni a lunga esecuzione che richiedono tempo per essere completate. Queste richieste restituiscono un nome dell'operazione, che puoi utilizzare per visualizzarne lo stato o annullarla. Vertex AI fornisce metodi di assistenza per effettuare chiamate a operazioni di lunga durata. Per ulteriori informazioni, consulta Utilizzo delle operazioni di lunga durata.

Fai una previsione online utilizzando il modello di cui è stato eseguito il deployment

Per fare una previsione online, invia uno o più elementi di test a un modello per analizzarli e il modello restituisce risultati in base al suo scopo. Per saperne di più sui risultati di previsione, consulta la pagina Interpreta i risultati.

Console

Utilizza la console Google Cloud per richiedere una previsione online. Il modello deve essere eseguito in un endpoint.

1. Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Modelli.

   Vai alla pagina Modelli

2. Nell'elenco dei modelli, fai clic sul nome del modello da cui richiedere le previsioni.

3. Seleziona la scheda Deployment e test.

4. Nella sezione Testa il tuo modello, aggiungi elementi di test per richiedere una previsione.

   I modelli AutoML per gli scopi relativi alle immagini richiedono di caricare un'immagine per richiedere una previsione.

   Per informazioni sull'importanza delle funzionalità locali, consulta Ricevere spiegazioni.

   Al termine della previsione, Vertex AI restituisce i risultati nella console.

API

Utilizza l'API Vertex AI per richiedere una previsione online. Il modello deve essere eseguito in un endpoint.

Generazione di previsioni batch

Per effettuare una richiesta di previsione batch, specifica un'origine di input e un formato di output in cui Vertex AI memorizza i risultati delle predizioni. Le previsioni batch per il tipo di modello di immagine AutoML richiedono un file JSON Lines di input e il nome di un bucket Cloud Storage in cui archiviare l'output.

Nota: devi selezionare le posizioni di input e output che si trovano nella stessa regione del tuo modello. Se utilizzi l'API per creare previsioni collettive, invia le richieste a un endpoint di servizio (ad esempio https://us-central1-aiplatform.googleapis.com) che si trovi nella stessa regione delle posizioni di input e output.

Requisiti dei dati di input

L'input per le richieste batch specifica gli elementi da inviare al modello per la previsione. Per i modelli di classificazione delle immagini, puoi utilizzare un file JSON Lines per specificare un elenco di immagini su cui fare previsioni e poi archiviare il file JSON Lines in un bucket Cloud Storage. L'esempio seguente mostra una singola riga in un file JSON Lines di input:

{"content": "gs://sourcebucket/datasets/images/source_image.jpg", "mimeType": "image/jpeg"}

Richiedere una previsione batch

Per le richieste di previsione batch, puoi utilizzare la console Google Cloud o l'API Vertex AI. A seconda del numero di elementi di input inviati, il completamento di un'attività di previsione batch può richiedere del tempo.

Console Google Cloud

Utilizza la console Google Cloud per richiedere una previsione batch.

1. Nella console Google Cloud, nella sezione Vertex AI, vai alla pagina Predizioni batch.

   Vai alla pagina Previsioni batch

2. Fai clic su Crea per aprire la finestra Nuova previsione batch e completa i seguenti passaggi:

   1. Inserisci un nome per la previsione batch.
   2. In Nome modello, seleziona il nome del modello da utilizzare per questa previsione batch.
   3. Per Percorso origine, specifica la posizione di Cloud Storage in cui si trova il file di input JSON Lines.
   4. Per Percorso di destinazione, specifica una posizione Cloud Storage dove vengono archiviati i risultati della previsione batch. Il formato Output è determinato dall'obiettivo del modello. I modelli AutoML per scopi di immagine generano file JSON Lines.

API

Utilizza l'API Vertex AI per inviare richieste di previsione in batch.

REST

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

• LOCATION_ID: regione in cui è archiviato il modello e viene eseguito il job di previsione batch. Ad esempio, us-central1.
• PROJECT_ID: il tuo ID progetto
• BATCH_JOB_NAME: nome visualizzato per il job batch
• MODEL_ID: l'ID del modello da utilizzare per fare le predizioni
• THRESHOLD_VALUE (facoltativo): Vertex AI restituisce solo le predizioni con punteggi di confidenza di almeno questo valore. Il valore predefinito è 0.0.
• MAX_PREDICTIONS (facoltativo): Vertex AI restituisce fino a questo numero di previsioni, a partire da quelle con i punteggi di affidabilità più elevati. Il valore predefinito è 10.
• URI: l'URI Cloud Storage in cui si trova il file JSON Lines di input.
• BUCKET: il tuo bucket Cloud Storage
• PROJECT_NUMBER: il numero di progetto generato automaticamente del progetto

Metodo HTTP e URL:

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs

Corpo JSON della richiesta:

{
    "displayName": "BATCH_JOB_NAME",
    "model": "projects/PROJECT/locations/LOCATION/models/MODEL_ID",
    "modelParameters": {
      "confidenceThreshold": THRESHOLD_VALUE,
      "maxPredictions": MAX_PREDICTIONS
    },
    "inputConfig": {
        "instancesFormat": "jsonl",
        "gcsSource": {
            "uris": ["URI"],
        },
    },
    "outputConfig": {
        "predictionsFormat": "jsonl",
        "gcsDestination": {
            "outputUriPrefix": "OUTPUT_BUCKET",
        },
    },
}

Per inviare la richiesta, scegli una delle seguenti opzioni:

curl

Nota: il seguente comando 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 gcloud. Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs"

PowerShell

Nota: il comando seguente presuppone che tu abbia eseguito l'accesso alla CLI gcloud con il tuo account utente eseguendo gcloud init o gcloud auth login . Puoi controllare l'account attualmente attivo eseguendo gcloud auth list.

Salva il corpo della richiesta in un file denominato request.json, quindi esegui il comando seguente:

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

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/batchPredictionJobs" | Select-Object -Expand Content

Dovresti ricevere una risposta JSON simile alla seguente:

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/batchPredictionJobs/BATCH_JOB_ID",
  "displayName": "BATCH_JOB_NAME",
  "model": "projects/PROJECT_ID/locations/LOCATION_ID/models/MODEL_ID",
  "inputConfig": {
    "instancesFormat": "jsonl",
    "gcsSource": {
      "uris": [
        "CONTENT"
      ]
    }
  },
  "outputConfig": {
    "predictionsFormat": "jsonl",
    "gcsDestination": {
      "outputUriPrefix": "BUCKET"
    }
  },
  "state": "JOB_STATE_PENDING",
  "createTime": "2020-05-30T02:58:44.341643Z",
  "updateTime": "2020-05-30T02:58:44.341643Z",
  "modelDisplayName": "MODEL_NAME",
  "modelObjective": "MODEL_OBJECTIVE"
}

Puoi eseguire il polling dello stato del job batch utilizzando BATCH_JOB_ID finché il job state non è JOB_STATE_SUCCEEDED.

Python

Per scoprire come installare o aggiornare l'SDK Vertex AI per Python, consulta Installare l'SDK Vertex AI per Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.

def create_batch_prediction_job_sample(
    project: str,
    location: str,
    model_resource_name: str,
    job_display_name: str,
    gcs_source: Union[str, Sequence[str]],
    gcs_destination: str,
    sync: bool = True,
):
    aiplatform.init(project=project, location=location)

    my_model = aiplatform.Model(model_resource_name)

    batch_prediction_job = my_model.batch_predict(
        job_display_name=job_display_name,
        gcs_source=gcs_source,
        gcs_destination_prefix=gcs_destination,
        sync=sync,
    )

    batch_prediction_job.wait()

    print(batch_prediction_job.display_name)
    print(batch_prediction_job.resource_name)
    print(batch_prediction_job.state)
    return batch_prediction_job

Recuperare i risultati delle previsioni batch

Vertex AI invia il risultato della previsione batch alla destinazione specificata.

Al termine di un'attività di previsione batch, l'output della previsione viene memorizzato nel bucket Cloud Storage specificato nella richiesta.

Esempi di risultati di previsione batch

Di seguito è riportato un esempio di risultati di previsione batch di un modello di classificazione delle immagini.

{
  "instance": {"content": "gs://bucket/image.jpg", "mimeType": "image/jpeg"},
  "prediction": {
    "ids": [1, 2],
    "displayNames": ["cat", "dog"],
    "confidences": [0.7, 0.5]
  }
}