Questa pagina è stata tradotta dall'API Cloud Translation.

Esportare i modelli AutoML Edge

Questa pagina descrive come utilizzare Vertex AI per esportare i modelli AutoML Edge per immagini in Cloud Storage.

Per informazioni sull'esportazione dei modelli tabulari, vedi Esportazione di un modello tabulare AutoML.

Introduzione

Dopo aver addestrato un modello AutoML Edge, in alcuni casi puoi esportarlo in formati diversi, a seconda di come vuoi utilizzarlo. I file del modello esportato vengono salvati in un bucket Cloud Storage e possono essere utilizzati per la previsione nell'ambiente che preferisci.

Non puoi utilizzare un modello Edge in Vertex AI per pubblicare previsioni; devi eseguire il deployment del modello Edge su un dispositivo esterno per ottenere le previsioni.

Esportazione di un modello

Utilizza i seguenti esempi di codice per identificare un modello AutoML Edge, specificare una posizione di archiviazione dei file di output e quindi inviare la richiesta di esportazione del modello.

Immagine

Seleziona la scheda di seguito relativa al tuo obiettivo:

Classificazione

I modelli di classificazione delle immagini AutoML Edge addestrati possono essere esportati nei seguenti formati:

TF Lite: esporta il modello come pacchetto TF Lite per eseguirlo su dispositivi edge o mobili.
TF Lite Edge TPU: esporta il modello come pacchetto TF Lite per eseguirlo su dispositivi Edge TPU.
Container: esporta il modello come modello salvato TF per eseguirlo su un container Docker.
Core ML: esporta un file .mlmodel per eseguire il modello su dispositivi iOS e macOS.
Tensorflow.js: esporta il modello come pacchetto TensorFlow.js per eseguirlo nel browser e in Node.js.

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

Console

Nella console Google Cloud , nella sezione Vertex AI, vai alla pagina Modelli.
Vai alla pagina Modelli
Fai clic sul numero di versione del modello AutoML Edge che vuoi esportare per aprire la relativa pagina dei dettagli.
Fai clic su Esporta.
Nella finestra laterale Esporta modello, specifica la posizione in Cloud Storage in cui archiviare l'output dell'esportazione del modello Edge.
Fai clic su Esporta.
Fai clic su Fine per chiudere la finestra laterale Esporta modello.

REST

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

LOCATION: la posizione del progetto.
PROJECT: il tuo ID progetto
MODEL_ID: il numero ID del modello AutoML Edge addestrato che stai esportando.
EXPORT_FORMAT: Il tipo di modello Edge che stai esportando. Per questo obiettivo, le opzioni sono:
- tflite (TF Lite) - Esporta il modello come pacchetto TF Lite per eseguirlo su dispositivi edge o mobili.
- edgetpu-tflite (Edge TPU TF Lite) - Esporta il modello come pacchetto TF Lite per eseguirlo su dispositivi Edge TPU.
- tf-saved-model (Container) - Esporta il modello come modello salvato TF per eseguirlo su un container Docker.
- core-ml (Core ML) - Esporta un file .mlmodel per eseguire il modello su dispositivi iOS e macOS.
- tf-js (Tensorflow.js) - Esporta il modello come pacchetto TensorFlow.js per eseguirlo nel browser e in Node.js.
OUTPUT_BUCKET: il percorso della directory del bucket Cloud Storage in cui vuoi archiviare i file del modello Edge.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export

Corpo JSON della richiesta:

{
  "outputConfig": {
    "exportFormatId": "EXPORT_FORMAT",
    "artifactDestination": {
      "outputUriPrefix": "gs://OUTPUT_BUCKET/"
    }
  }
}

Per inviare la richiesta, scegli una di queste 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 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, ed esegui questo comando:

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

PowerShell

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 . 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:

$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-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export" | Select-Object -Expand Content

La risposta contiene informazioni sulle specifiche e sul OPERATION_ID.

Risposta

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.ExportModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-07-16T20:06:33.679353Z",
      "updateTime": "2020-07-16T20:06:33.679353Z"
    },
    "outputInfo": {
      "artifactOutputUri": "gs://OUTPUT_BUCKET/model-MODEL_ID/EXPORT_FORMAT/YYYY-MM-DDThh:mm:ss.sssZ"
    }
  }
}

Puoi ottenere lo stato dell'operazione di esportazione per vedere quando termina.

Java

Prima di provare questo esempio, segui le istruzioni di configurazione di Java nella guida rapida di Vertex AI per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Vertex AI Java.

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


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.ExportModelOperationMetadata;
import com.google.cloud.aiplatform.v1.ExportModelRequest;
import com.google.cloud.aiplatform.v1.ExportModelResponse;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ExportModelSample {

  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 modelId = "YOUR_MODEL_ID";
    String gcsDestinationOutputUriPrefix = "gs://YOUR_GCS_SOURCE_BUCKET/path_to_your_destination/";
    String exportFormat = "YOUR_EXPORT_FORMAT";
    exportModelSample(project, modelId, gcsDestinationOutputUriPrefix, exportFormat);
  }

  static void exportModelSample(
      String project, String modelId, String gcsDestinationOutputUriPrefix, String exportFormat)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.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 (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      GcsDestination.Builder gcsDestination = GcsDestination.newBuilder();
      gcsDestination.setOutputUriPrefix(gcsDestinationOutputUriPrefix);

      ModelName modelName = ModelName.of(project, location, modelId);
      ExportModelRequest.OutputConfig outputConfig =
          ExportModelRequest.OutputConfig.newBuilder()
              .setExportFormatId(exportFormat)
              .setArtifactDestination(gcsDestination)
              .build();

      OperationFuture<ExportModelResponse, ExportModelOperationMetadata> exportModelResponseFuture =
          modelServiceClient.exportModelAsync(modelName, outputConfig);
      System.out.format(
          "Operation name: %s\n", exportModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      ExportModelResponse exportModelResponse =
          exportModelResponseFuture.get(300, TimeUnit.SECONDS);

      System.out.format("Export Model Response: %s\n", exportModelResponse);
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Vertex AI per l'utilizzo delle librerie client. Per saperne di più, consulta la documentazione di riferimento dell'API Vertex AI Node.js.

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura 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 gcsDestinationOutputUriPrefix ='YOUR_GCS_DEST_OUTPUT_URI_PREFIX';
//    eg. "gs://<your-gcs-bucket>/destination_path"
// const exportFormat = 'YOUR_EXPORT_FORMAT';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

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

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

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function exportModel() {
  // Configure the name resources
  const name = `projects/${project}/locations/${location}/models/${modelId}`;
  // Configure the outputConfig resources
  const outputConfig = {
    exportFormatId: exportFormat,
    gcsDestination: {
      outputUriPrefix: gcsDestinationOutputUriPrefix,
    },
  };
  const request = {
    name,
    outputConfig,
  };

  // Export Model request
  const [response] = await modelServiceClient.exportModel(request);
  console.log(`Long running operation : ${response.name}`);

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

  console.log(`Export model response : ${JSON.stringify(result)}`);
}
exportModel();

Python

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

from google.cloud import aiplatform


def export_model_sample(
    project: str,
    model_id: str,
    gcs_destination_output_uri_prefix: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
    timeout: int = 300,
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.ModelServiceClient(client_options=client_options)
    output_config = {
        "artifact_destination": {
            "output_uri_prefix": gcs_destination_output_uri_prefix
        },
        # For information about export formats: https://cloud.google.com/ai-platform-unified/docs/export/export-edge-model#aiplatform_export_model_sample-drest
        "export_format_id": "tf-saved-model",
    }
    name = client.model_path(project=project, location=location, model=model_id)
    response = client.export_model(name=name, output_config=output_config)
    print("Long running operation:", response.operation.name)
    print("output_info:", response.metadata.output_info)
    export_model_response = response.result(timeout=timeout)
    print("export_model_response:", export_model_response)

Classificazione

I modelli di classificazione delle immagini AutoML Edge addestrati possono essere esportati nei seguenti formati:

TF Lite: esporta il modello come pacchetto TF Lite per eseguirlo su dispositivi edge o mobili.
TF Lite Edge TPU: esporta il modello come pacchetto TF Lite per eseguirlo su dispositivi Edge TPU.
Container: esporta il modello come modello salvato TF per eseguirlo su un container Docker.
Core ML: esporta un file .mlmodel per eseguire il modello su dispositivi iOS e macOS.
Tensorflow.js: esporta il modello come pacchetto TensorFlow.js per eseguirlo nel browser e in Node.js.

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

Console

Nella console Google Cloud , nella sezione Vertex AI, vai alla pagina Modelli.
Vai alla pagina Modelli
Fai clic sul numero di versione del modello AutoML Edge che vuoi esportare per aprire la relativa pagina dei dettagli.
Fai clic su Esporta.
Nella finestra laterale Esporta modello, specifica la posizione in Cloud Storage in cui archiviare l'output dell'esportazione del modello Edge.
Fai clic su Esporta.
Fai clic su Fine per chiudere la finestra laterale Esporta modello.

REST

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

LOCATION: la posizione del progetto.
PROJECT: il tuo ID progetto
MODEL_ID: il numero ID del modello AutoML Edge addestrato che stai esportando.
EXPORT_FORMAT: Il tipo di modello Edge che stai esportando. Per questo obiettivo, le opzioni sono:
- tflite (TF Lite) - Esporta il modello come pacchetto TF Lite per eseguirlo su dispositivi edge o mobili.
- edgetpu-tflite (Edge TPU TF Lite) - Esporta il modello come pacchetto TF Lite per eseguirlo su dispositivi Edge TPU.
- tf-saved-model (Container) - Esporta il modello come modello salvato TF per eseguirlo su un container Docker.
- core-ml (Core ML) - Esporta un file .mlmodel per eseguire il modello su dispositivi iOS e macOS.
- tf-js (Tensorflow.js) - Esporta il modello come pacchetto TensorFlow.js per eseguirlo nel browser e in Node.js.
OUTPUT_BUCKET: il percorso della directory del bucket Cloud Storage in cui vuoi archiviare i file del modello Edge.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export

Corpo JSON della richiesta:

{
  "outputConfig": {
    "exportFormatId": "EXPORT_FORMAT",
    "artifactDestination": {
      "outputUriPrefix": "gs://OUTPUT_BUCKET/"
    }
  }
}

Per inviare la richiesta, scegli una di queste opzioni:

curl

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 "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export"

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

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

La risposta contiene informazioni sulle specifiche e sul OPERATION_ID.

Risposta

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.ExportModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-07-16T20:06:33.679353Z",
      "updateTime": "2020-07-16T20:06:33.679353Z"
    },
    "outputInfo": {
      "artifactOutputUri": "gs://OUTPUT_BUCKET/model-MODEL_ID/EXPORT_FORMAT/YYYY-MM-DDThh:mm:ss.sssZ"
    }
  }
}

Puoi ottenere lo stato dell'operazione di esportazione per vedere quando termina.

Java

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


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.ExportModelOperationMetadata;
import com.google.cloud.aiplatform.v1.ExportModelRequest;
import com.google.cloud.aiplatform.v1.ExportModelResponse;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ExportModelSample {

  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 modelId = "YOUR_MODEL_ID";
    String gcsDestinationOutputUriPrefix = "gs://YOUR_GCS_SOURCE_BUCKET/path_to_your_destination/";
    String exportFormat = "YOUR_EXPORT_FORMAT";
    exportModelSample(project, modelId, gcsDestinationOutputUriPrefix, exportFormat);
  }

  static void exportModelSample(
      String project, String modelId, String gcsDestinationOutputUriPrefix, String exportFormat)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.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 (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      GcsDestination.Builder gcsDestination = GcsDestination.newBuilder();
      gcsDestination.setOutputUriPrefix(gcsDestinationOutputUriPrefix);

      ModelName modelName = ModelName.of(project, location, modelId);
      ExportModelRequest.OutputConfig outputConfig =
          ExportModelRequest.OutputConfig.newBuilder()
              .setExportFormatId(exportFormat)
              .setArtifactDestination(gcsDestination)
              .build();

      OperationFuture<ExportModelResponse, ExportModelOperationMetadata> exportModelResponseFuture =
          modelServiceClient.exportModelAsync(modelName, outputConfig);
      System.out.format(
          "Operation name: %s\n", exportModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      ExportModelResponse exportModelResponse =
          exportModelResponseFuture.get(300, TimeUnit.SECONDS);

      System.out.format("Export Model Response: %s\n", exportModelResponse);
    }
  }
}

Node.js

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura 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 gcsDestinationOutputUriPrefix ='YOUR_GCS_DEST_OUTPUT_URI_PREFIX';
//    eg. "gs://<your-gcs-bucket>/destination_path"
// const exportFormat = 'YOUR_EXPORT_FORMAT';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

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

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

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function exportModel() {
  // Configure the name resources
  const name = `projects/${project}/locations/${location}/models/${modelId}`;
  // Configure the outputConfig resources
  const outputConfig = {
    exportFormatId: exportFormat,
    gcsDestination: {
      outputUriPrefix: gcsDestinationOutputUriPrefix,
    },
  };
  const request = {
    name,
    outputConfig,
  };

  // Export Model request
  const [response] = await modelServiceClient.exportModel(request);
  console.log(`Long running operation : ${response.name}`);

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

  console.log(`Export model response : ${JSON.stringify(result)}`);
}
exportModel();

Python

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

from google.cloud import aiplatform


def export_model_sample(
    project: str,
    model_id: str,
    gcs_destination_output_uri_prefix: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
    timeout: int = 300,
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.ModelServiceClient(client_options=client_options)
    output_config = {
        "artifact_destination": {
            "output_uri_prefix": gcs_destination_output_uri_prefix
        },
        # For information about export formats: https://cloud.google.com/ai-platform-unified/docs/export/export-edge-model#aiplatform_export_model_sample-drest
        "export_format_id": "tf-saved-model",
    }
    name = client.model_path(project=project, location=location, model=model_id)
    response = client.export_model(name=name, output_config=output_config)
    print("Long running operation:", response.operation.name)
    print("output_info:", response.metadata.output_info)
    export_model_response = response.result(timeout=timeout)
    print("export_model_response:", export_model_response)

Rilevamento di oggetti

I modelli di rilevamento degli oggetti nelle immagini AutoML Edge addestrati possono essere esportati nei seguenti formati:

TF Lite: esporta il modello come pacchetto TF Lite per eseguirlo su dispositivi edge o mobili.
Container: esporta il modello come modello salvato TF per eseguirlo su un container Docker.
Tensorflow.js: esporta il modello come pacchetto TensorFlow.js per eseguirlo nel browser e in Node.js.

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

Console

Nella console Google Cloud , nella sezione Vertex AI, vai alla pagina Modelli.
Vai alla pagina Modelli
Fai clic sul numero di versione del modello AutoML Edge che vuoi esportare per aprire la relativa pagina dei dettagli.
Seleziona la scheda Deployment e test per visualizzare i formati di esportazione disponibili.
Seleziona il formato del modello di esportazione che preferisci dalla sezione Utilizza il modello ottimizzato per l'edge.
Nella finestra laterale Esporta modello, specifica la posizione in Cloud Storage in cui archiviare l'output dell'esportazione del modello Edge.
Fai clic su Esporta.
Fai clic su Fine per chiudere la finestra laterale Esporta modello.

REST

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

LOCATION: la posizione del progetto.
PROJECT: .
MODEL_ID: il numero ID del modello AutoML Edge addestrato che stai esportando.
EXPORT_FORMAT: Il tipo di modello Edge che stai esportando. Per questo obiettivo, le opzioni sono:
- tflite (TF Lite) - Esporta il modello come pacchetto TF Lite per eseguirlo su dispositivi edge o mobili.
- tf-saved-model (Container) - Esporta il modello come modello salvato TF per eseguirlo su un container Docker.
- tf-js (Tensorflow.js) - Esporta il modello come pacchetto TensorFlow.js per eseguirlo nel browser e in Node.js.
OUTPUT_BUCKET: il percorso della directory del bucket Cloud Storage in cui vuoi archiviare i file del modello Edge.

Metodo HTTP e URL:

POST https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export

Corpo JSON della richiesta:

{
  "outputConfig": {
    "exportFormatId": "EXPORT_FORMAT",
    "artifactDestination": {
      "outputUriPrefix": "gs://OUTPUT_BUCKET/"
    }
  }
}

Per inviare la richiesta, scegli una di queste opzioni:

curl

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 "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/models/MODEL_ID:export"

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

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

La risposta contiene informazioni sulle specifiche e sul OPERATION_ID.

Risposta

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.ExportModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-07-16T20:06:33.679353Z",
      "updateTime": "2020-07-16T20:06:33.679353Z"
    },
    "outputInfo": {
      "artifactOutputUri": "gs://OUTPUT_BUCKET/model-MODEL_ID/EXPORT_FORMAT/YYYY-MM-DDThh:mm:ss.sssZ"
    }
  }
}

Puoi ottenere lo stato dell'operazione di esportazione per vedere quando termina.

Java

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


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.ExportModelOperationMetadata;
import com.google.cloud.aiplatform.v1.ExportModelRequest;
import com.google.cloud.aiplatform.v1.ExportModelResponse;
import com.google.cloud.aiplatform.v1.GcsDestination;
import com.google.cloud.aiplatform.v1.ModelName;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class ExportModelSample {

  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 modelId = "YOUR_MODEL_ID";
    String gcsDestinationOutputUriPrefix = "gs://YOUR_GCS_SOURCE_BUCKET/path_to_your_destination/";
    String exportFormat = "YOUR_EXPORT_FORMAT";
    exportModelSample(project, modelId, gcsDestinationOutputUriPrefix, exportFormat);
  }

  static void exportModelSample(
      String project, String modelId, String gcsDestinationOutputUriPrefix, String exportFormat)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    ModelServiceSettings modelServiceSettings =
        ModelServiceSettings.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 (ModelServiceClient modelServiceClient = ModelServiceClient.create(modelServiceSettings)) {
      String location = "us-central1";
      GcsDestination.Builder gcsDestination = GcsDestination.newBuilder();
      gcsDestination.setOutputUriPrefix(gcsDestinationOutputUriPrefix);

      ModelName modelName = ModelName.of(project, location, modelId);
      ExportModelRequest.OutputConfig outputConfig =
          ExportModelRequest.OutputConfig.newBuilder()
              .setExportFormatId(exportFormat)
              .setArtifactDestination(gcsDestination)
              .build();

      OperationFuture<ExportModelResponse, ExportModelOperationMetadata> exportModelResponseFuture =
          modelServiceClient.exportModelAsync(modelName, outputConfig);
      System.out.format(
          "Operation name: %s\n", exportModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      ExportModelResponse exportModelResponse =
          exportModelResponseFuture.get(300, TimeUnit.SECONDS);

      System.out.format("Export Model Response: %s\n", exportModelResponse);
    }
  }
}

Node.js

Per eseguire l'autenticazione in Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configura 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 gcsDestinationOutputUriPrefix ='YOUR_GCS_DEST_OUTPUT_URI_PREFIX';
//    eg. "gs://<your-gcs-bucket>/destination_path"
// const exportFormat = 'YOUR_EXPORT_FORMAT';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

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

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

// Instantiates a client
const modelServiceClient = new ModelServiceClient(clientOptions);

async function exportModel() {
  // Configure the name resources
  const name = `projects/${project}/locations/${location}/models/${modelId}`;
  // Configure the outputConfig resources
  const outputConfig = {
    exportFormatId: exportFormat,
    gcsDestination: {
      outputUriPrefix: gcsDestinationOutputUriPrefix,
    },
  };
  const request = {
    name,
    outputConfig,
  };

  // Export Model request
  const [response] = await modelServiceClient.exportModel(request);
  console.log(`Long running operation : ${response.name}`);

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

  console.log(`Export model response : ${JSON.stringify(result)}`);
}
exportModel();

Python

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

from google.cloud import aiplatform


def export_model_sample(
    project: str,
    model_id: str,
    gcs_destination_output_uri_prefix: str,
    location: str = "us-central1",
    api_endpoint: str = "us-central1-aiplatform.googleapis.com",
    timeout: int = 300,
):
    # The AI Platform services require regional API endpoints.
    client_options = {"api_endpoint": api_endpoint}
    # Initialize client that will be used to create and send requests.
    # This client only needs to be created once, and can be reused for multiple requests.
    client = aiplatform.gapic.ModelServiceClient(client_options=client_options)
    output_config = {
        "artifact_destination": {
            "output_uri_prefix": gcs_destination_output_uri_prefix
        },
        # For information about export formats: https://cloud.google.com/ai-platform-unified/docs/export/export-edge-model#aiplatform_export_model_sample-drest
        "export_format_id": "tf-saved-model",
    }
    name = client.model_path(project=project, location=location, model=model_id)
    response = client.export_model(name=name, output_config=output_config)
    print("Long running operation:", response.operation.name)
    print("output_info:", response.metadata.output_info)
    export_model_response = response.result(timeout=timeout)
    print("export_model_response:", export_model_response)

Recupera lo stato dell'operazione

Immagine

Utilizza il seguente codice per ottenere lo stato dell'operazione di esportazione. Questo codice è lo stesso per tutti gli obiettivi:

REST

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

LOCATION: la posizione del progetto.
PROJECT: .
OPERATION_ID:l'ID dell'operazione di destinazione. Questo ID è in genere contenuto nella risposta alla richiesta originale.

Metodo HTTP e URL:

GET https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/operations/OPERATION_ID

Per inviare la richiesta, scegli una di queste opzioni:

curl

Esegui questo comando:

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/operations/OPERATION_ID"

PowerShell

Esegui questo comando:

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

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION-aiplatform.googleapis.com/v1/projects/PROJECT/locations/LOCATION/operations/OPERATION_ID" | Select-Object -Expand Content

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

{
  "name": "projects/PROJECT/locations/LOCATION/models/MODEL_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.ExportModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-12T20:53:40.130785Z",
      "updateTime": "2020-10-12T20:53:40.793983Z"
    },
    "outputInfo": {
      "artifactOutputUri": "gs://OUTPUT_BUCKET/model-MODEL_ID/EXPORT_FORMAT/YYYY-MM-DDThh:mm:ss.sssZ"
    }
  },
  "done": true,
  "response": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.ExportModelResponse"
  }
}

File di output

Immagine

Seleziona la scheda sottostante per il formato del modello:

TF Lite

Il OUTPUT_BUCKET specificato nella richiesta determina dove vengono archiviati i file di output. Il formato della directory in cui sono archiviati i file di output è il seguente:

gs://OUTPUT_BUCKET/model-MODEL_ID/tflite/YYYY-MM-DDThh:mm:ss.sssZ/

File:

model.tflite: un file contenente una versione del modello pronta per essere utilizzata con TensorFlow Lite.

Punto chiave: a differenza del comportamento di esportazione precedente in AutoML Vision, l'esportazione di questo formato in Vertex AI non produce un file di etichette (dict.txt) come uno dei file di output. Queste informazioni sono ora incluse nel file .tflite stesso. Per informazioni sull'estrazione di queste informazioni, consulta la seguente documentazione di TensorFlow:

Edge TPU

Il OUTPUT_BUCKET specificato nella richiesta determina dove vengono archiviati i file di output. Il formato della directory in cui sono archiviati i file di output è il seguente:

gs://OUTPUT_BUCKET/model-MODEL_ID/edgetpu-tflite/YYYY-MM-DDThh:mm:ss.sssZ/

File:

edgetpu_model.tflite: Un file contenente una versione del modello per TensorFlow Lite, passato attraverso il compilatore Edge TPU per essere compatibile con Edge TPU.

Container

Il OUTPUT_BUCKET specificato nella richiesta determina dove vengono archiviati i file di output. Il formato della directory in cui sono archiviati i file di output è il seguente:

gs://OUTPUT_BUCKET/model-MODEL_ID/tf-saved-model/YYYY-MM-DDThh:mm:ss.sssZ/

File:

saved_model.pb: un file buffer di protocollo contenente la definizione del grafico e i pesi del modello.

Core ML

Il OUTPUT_BUCKET specificato nella richiesta determina dove vengono archiviati i file di output. Il formato della directory in cui sono archiviati i file di output è il seguente:

gs://OUTPUT_BUCKET/model-MODEL_ID/core-ml/YYYY-MM-DDThh:mm:ss.sssZ/

File:

dict.txt: un file di etichette. Ogni riga del file di etichette dict.txt rappresenta un'etichetta delle previsioni restituite dal modello, nello stesso ordine in cui sono state richieste.
Esempio dict.txt
```
roses
daisy
tulips
dandelion
sunflowers
```
model.mlmodel: un file che specifica un modello Core ML.

Tensorflow.js

Il OUTPUT_BUCKET specificato nella richiesta determina dove vengono archiviati i file di output. Il formato della directory in cui sono archiviati i file di output è il seguente:

gs://OUTPUT_BUCKET/model-MODEL_ID/tf-js/YYYY-MM-DDThh:mm:ss.sssZ/

File:

dict.txt: un file di etichette. Ogni riga del file di etichette dict.txt rappresenta un'etichetta delle previsioni restituite dal modello, nello stesso ordine in cui sono state richieste.
Esempio dict.txt
```
roses
daisy
tulips
dandelion
sunflowers
```
group1-shard1of3.bin: Un file binario.
group1-shard2of3.bin: Un file binario.
group1-shard3of3.bin: Un file binario.

model.json: una rappresentazione JSON di un modello.

Esempio model.json (abbreviato per chiarezza)

{
  "format": "graph-model",
  "generatedBy": "2.4.0",
  "convertedBy": "TensorFlow.js Converter v1.7.0",
  "userDefinedMetadata": {
    "signature": {
      "inputs": {
        "image:0": {
          "name": "image:0",
          "dtype": "DT_FLOAT",
          "tensorShape": {
            "dim": [
              {
                "size": "1"
              },
              {
                "size": "224"
              },
              {
                "size": "224"
              },
              {
                "size": "3"
              }
            ]
          }
        }
      },
      "outputs": {
        "scores:0": {
          "name": "scores:0",
          "dtype": "DT_FLOAT",
          "tensorShape": {
            "dim": [
              {
                "size": "1"
              },
              {
                "size": "5"
              }
            ]
          }
        }
      }
    }
  },
  "modelTopology": {
    "node": [
      {
        "name": "image",
        "op": "Placeholder",
        "attr": {
          "dtype": {
            "type": "DT_FLOAT"
          },
          "shape": {
            "shape": {
              "dim": [
                {
                  "size": "1"
                },
                {
                  "size": "224"
                },
                {
                  "size": "224"
                },
                {
                  "size": "3"
                }
              ]
            }
          }
        }
      },
      {
        "name": "mnas_v4_a_1/feature_network/feature_extractor/Mean/reduction_indices",
        "op": "Const",
        "attr": {
          "value": {
            "tensor": {
              "dtype": "DT_INT32",
              "tensorShape": {
                "dim": [
                  {
                    "size": "2"
                  }
                ]
              }
            }
          },
          "dtype": {
            "type": "DT_INT32"
          }
        }
      },
      ...
      {
        "name": "scores",
        "op": "Identity",
        "input": [
          "Softmax"
        ],
        "attr": {
          "T": {
            "type": "DT_FLOAT"
          }
        }
      }
    ],
    "library": {},
    "versions": {}
  },
  "weightsManifest": [
    {
      "paths": [
        "group1-shard1of3.bin",
        "group1-shard2of3.bin",
        "group1-shard3of3.bin"
      ],
      "weights": [
        {
          "name": "mnas_v4_a_1/feature_network/feature_extractor/Mean/reduction_indices",
          "shape": [
            2
          ],
          "dtype": "int32"
        },
        {
          "name": "mnas_v4_a/output/fc/tf_layer/kernel",
          "shape": [
            1280,
            5
          ],
          "dtype": "float32"
        },
        ...
        {
          "name": "mnas_v4_a_1/feature_network/lead_cell_17/op_0/conv2d_0/Conv2D_weights",
          "shape": [
            1,
            1,
            320,
            1280
          ],
          "dtype": "float32"
        },
        {
          "name": "mnas_v4_a_1/feature_network/cell_14/op_0/expand_0/Conv2D_bn_offset",
          "shape": [
            1152
          ],
          "dtype": "float32"
        }
      ]
    }
  ]
}

Esportare i modelli AutoML Edge Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Introduzione

Esportazione di un modello

Immagine

Classificazione

Console

REST

curl

PowerShell

Risposta

Java

Node.js

Python

Classificazione

Console

REST

curl

PowerShell

Risposta

Java

Node.js

Python

Rilevamento di oggetti

Console

REST

curl

PowerShell

Risposta

Java

Node.js

Python

Recupera lo stato dell'operazione

Immagine

REST

curl

PowerShell

File di output

Immagine

TF Lite

Edge TPU

Container

Core ML

Tensorflow.js

Esportare i modelli AutoML Edge