Importare modelli in Gemini Enterprise Agent Platform

Questa guida descrive come importare i modelli in Model Registry di Gemini Enterprise Agent Platform. Dopo aver importato il modello, questo sarà visibile in Model Registry. Da Model Registry, puoi eseguire il deployment del modello importato su un endpoint ed eseguire inferenze.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per importare i modelli, chiedi all'amministratore di concederti il ruolo IAM Utente di Agent Platform (roles/aiplatform.user) nel progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Potresti anche riuscire a ottenere le autorizzazioni richieste tramite i ruoli personalizzati o altri ruoli predefiniti.

Container predefiniti o personalizzati

Quando importi un modello, lo associ a un container per consentire ad Agent Platform di eseguire le richieste di inferenza. Puoi utilizzare i container predefiniti forniti da Agent Platform o i tuoi container personalizzati che crei ed esegui il push in Artifact Registry.

Puoi utilizzare un container predefinito se il modello soddisfa i seguenti requisiti:

Se stai importando un modello AutoML tabulare che hai esportato in precedenza, devi utilizzare un container personalizzato specifico fornito da Agent Platform.

In caso contrario, crea un nuovo container personalizzato o utilizza un container personalizzato esistente in Artifact Registry.

Caricare gli artefatti del modello in Cloud Storage

Devi archiviare gli artefatti del modello in un bucket Cloud Storage, dove la regione del bucket corrisponde all'endpoint regionale che stai utilizzando.

Se il bucket Cloud Storage si trova in un progetto diverso Google Cloud, devi concedere ad Agent Platform l'accesso in lettura agli artefatti del modello.

Se utilizzi un container predefinito, assicurati che i nomi dei file degli artefatti del modello corrispondano esattamente ai seguenti esempi:

  • SavedModel TensorFlow: saved_model.pb
  • PyTorch: model.mar
  • scikit-learn: model.joblib
  • XGBoost: model.bst o model.joblib

Scopri di più su esportazione degli artefatti del modello per l'inferenza.

Importare un modello utilizzando la console Google Cloud

Per importare un modello utilizzando la Google Cloud console:

  1. Nella Google Cloud console, vai alla pagina Modelli di Agent Platform.

    Vai alla pagina Modelli

  2. Fai clic su Importa.

  3. Seleziona Importa come nuovo modello per importare un nuovo modello.

  4. Seleziona Importa come nuova versione per importare un modello come versione di un modello esistente. Per saperne di più sul controllo delle versioni dei modelli, consulta Controllo delle versioni dei modelli.

  5. Nome e regione: inserisci un nome per il modello. Seleziona la regione che corrisponde sia alla regione del bucket sia all'endpoint regionale di Agent Platform che stai utilizzando. Fai clic su Continua.

  6. Se espandi Opzioni avanzate, puoi facoltativamente decidere di aggiungere una chiave di crittografia gestita dal cliente.

A seconda del tipo di container che utilizzi, seleziona la scheda appropriata di seguito.

Container predefinito

  1. Seleziona Importa gli artefatti del modello in un nuovo container predefinito.

  2. Seleziona il framework del modello e la versione del framework del modello che hai utilizzato per addestrare il modello.

  3. Se vuoi utilizzare le GPU per la gestione delle inferenze, imposta il Tipo di acceleratore su GPU.

    Selezionerai il tipo di GPU in un secondo momento, quando esegui il deployment del modello su un endpoint.

  4. Specifica il percorso di Cloud Storage della directory che contiene gli artefatti del modello.

    Ad esempio, gs://BUCKET_NAME/models/.

  5. Lascia vuoto il campo Schemi di previsione.

  6. Per importare il modello senza le impostazioni di Vertex Explainable AI, fai clic su Importa.

    Al termine dell'importazione, il modello viene visualizzato nella pagina Modelli.

    In caso contrario, continua a configurare il modello inserendo le impostazioni di spiegabilità nella scheda Spiegabilità. Scopri di più sulle impostazioni di spiegabilità.

Container personalizzato

  1. Seleziona Importa un container personalizzato esistente.

  2. Imposta l'URI dell'immagine container.

  3. Se vuoi fornire gli artefatti del modello oltre a un'immagine container, specifica il percorso di Cloud Storage della directory che contiene gli artefatti del modello.

    Ad esempio, gs://BUCKET_NAME/models/.

  4. Specifica i valori per gli altri campi.

    Scopri di più su questi campi facoltativi.

  5. Per importare il modello senza le impostazioni di Vertex Explainable AI, fai clic su Importa.

    Al termine dell'importazione, il modello viene visualizzato nella pagina Modelli.

    In caso contrario, continua a configurare il modello inserendo le impostazioni di spiegabilità nella scheda Spiegabilità. Scopri di più sulle impostazioni di spiegabilità.

Container tabulare AutoML

  1. Seleziona Importa un container personalizzato esistente.

  2. Nel campo Immagine container, inserisci MULTI_REGION-docker.pkg.dev/vertex-ai/automl-tabular/prediction-server-v1:latest.

    Sostituisci MULTI_REGION con us, europe, o asia per selezionare il repository Docker da cui vuoi eseguire il pull dell'immagine Docker da. Ogni repository fornisce la stessa immagine Docker, ma la scelta della regione multipla di Artifact Registry più vicina alla macchina su cui esegui Docker potrebbe ridurre la latenza.

  3. Nel campo Percorso del pacchetto, specifica il percorso di Cloud Storage della directory che contiene gli artefatti del modello.

    Il percorso è simile all'esempio seguente:

    gs://BUCKET_NAME/models-MODEL_ID/tf-saved-model/TIMESTAMP/

  4. Lascia vuoti tutti gli altri campi.

  5. Fai clic su Importa.

    Al termine dell'importazione, il modello viene visualizzato nella pagina Modelli. Puoi utilizzare questo modello come gli altri modelli tabulari AutoML, tranne per il fatto che i modelli tabulari AutoML importati non supportano Vertex Explainable AI.

Importare un modello in modo programmatico

Gli esempi seguenti mostrano come importare un modello utilizzando vari strumenti:

gcloud

L'esempio seguente utilizza il gcloud ai models upload comando:

gcloud ai models upload \
  --region=LOCATION \
  --display-name=MODEL_NAME \
  --container-image-uri=IMAGE_URI \
  --artifact-uri=PATH_TO_MODEL_ARTIFACT_DIRECTORY

Sostituisci quanto segue:

  • LOCATION_ID: la regione in cui utilizzi Agent Platform.
  • MODEL_NAME: un nome visualizzato per Model.
  • IMAGE_URI: l'URI dell'immagine container da utilizzare per la gestione delle inferenze. Ad esempio, us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest. Utilizza un container predefinito o un container personalizzato.
  • PATH_TO_MODEL_ARTIFACT_DIRECTORY: l'URI Cloud Storage (che inizia con gs://) di una directory in Cloud Storage che contiene gli artefatti del modello.

L'esempio precedente mostra tutti i flag necessari per importare la maggior parte dei modelli. Se non utilizzi un container predefinito per l'inferenza, probabilmente devi specificare alcuni flag facoltativi aggiuntivi in modo che Agent Platform possa utilizzare l'immagine container. Questi flag, che iniziano con --container-, corrispondono ai campi di Model's containerSpec.

REST

Utilizza l'esempio di codice seguente per caricare un modello utilizzando il upload metodo della model risorsa.

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

  • LOCATION_ID: la regione in cui utilizzi Agent Platform.
  • PROJECT_ID: il tuo [ID progetto](/resource-manager/docs/creating-managing-projects#identifiers). .
  • MODEL_NAME: un nome visualizzato per Model.
  • MODEL_DESCRIPTION: (facoltativo) Una descrizione per il modello.
  • IMAGE_URI: l'URI dell'immagine container da utilizzare per la gestione delle inferenze. Ad esempio, us-docker.pkg.dev/vertex-ai/prediction/tf2-cpu.2-1:latest. Utilizza un container predefinito o un container personalizzato.
  • PATH_TO_MODEL_ARTIFACT_DIRECTORY: l'URI Cloud Storage (che inizia con gs://) di una directory in Cloud Storage che contiene gli artefatti del modello. Questa variabile e il artifactUri campo sono facoltativi se utilizzi un container personalizzato.
  • labels: (facoltativo) Un insieme di coppie chiave-valore per organizzare i modelli. Ad esempio:
    • "env": "prod"
    • "tier": "backend"
  • Specifica LABEL_NAME e LABEL_VALUE per le etichette che vuoi applicare a questa pipeline di addestramento.

Metodo HTTP e URL: 

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

Corpo JSON della richiesta: 

{
  "model": {
    "displayName": "MODEL_NAME",
    "predictSchemata": {},
    "containerSpec": {
      "imageUri": "IMAGE_URI"
    },
    "artifactUri": "PATH_TO_MODEL_ARTIFACT_DIRECTORY",
    "labels": {
      "LABEL_NAME_1": "LABEL_VALUE_1",
      "LABEL_NAME_2": "LABEL_VALUE_2"
    }
  }
}

Per inviare la richiesta, scegli una di queste opzioni:

curl

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/models:upload"

PowerShell

Salva il corpo della richiesta in un file denominato request.json, e 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/models:upload" | Select-Object -Expand Content

Java

Prima di provare questo esempio, segui le istruzioni di configurazione Java nella guida rapida di Agent Platform per l'utilizzo delle librerie client.

Per eseguire l'autenticazione in Agent Platform, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 


import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.LocationName;
import com.google.cloud.aiplatform.v1.Model;
import com.google.cloud.aiplatform.v1.ModelContainerSpec;
import com.google.cloud.aiplatform.v1.ModelServiceClient;
import com.google.cloud.aiplatform.v1.ModelServiceSettings;
import com.google.cloud.aiplatform.v1.UploadModelOperationMetadata;
import com.google.cloud.aiplatform.v1.UploadModelResponse;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class UploadModelSample {
  public static void main(String[] args)
      throws InterruptedException, ExecutionException, TimeoutException, IOException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String modelDisplayName = "YOUR_MODEL_DISPLAY_NAME";
    String metadataSchemaUri =
        "gs://google-cloud-aiplatform/schema/trainingjob/definition/custom_task_1.0.0.yaml";
    String imageUri = "YOUR_IMAGE_URI";
    String artifactUri = "gs://your-gcs-bucket/artifact_path";
    uploadModel(project, modelDisplayName, metadataSchemaUri, imageUri, artifactUri);
  }

  static void uploadModel(
      String project,
      String modelDisplayName,
      String metadataSchemaUri,
      String imageUri,
      String artifactUri)
      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";
      LocationName locationName = LocationName.of(project, location);

      ModelContainerSpec modelContainerSpec =
          ModelContainerSpec.newBuilder().setImageUri(imageUri).build();

      Model model =
          Model.newBuilder()
              .setDisplayName(modelDisplayName)
              .setMetadataSchemaUri(metadataSchemaUri)
              .setArtifactUri(artifactUri)
              .setContainerSpec(modelContainerSpec)
              .build();

      OperationFuture<UploadModelResponse, UploadModelOperationMetadata> uploadModelResponseFuture =
          modelServiceClient.uploadModelAsync(locationName, model);
      System.out.format(
          "Operation name: %s\n", uploadModelResponseFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      UploadModelResponse uploadModelResponse = uploadModelResponseFuture.get(5, TimeUnit.MINUTES);

      System.out.println("Upload Model Response");
      System.out.format("Model: %s\n", uploadModelResponse.getModel());
    }
  }
}

Node.js

Prima di provare questo esempio, segui le istruzioni di configurazione di Node.js nella guida rapida di Agent Platform per l'utilizzo delle librerie client.

Per eseguire l'autenticazione in Agent Platform, configura le Credenziali predefinite dell'applicazione. Per saperne di più, consulta Configura l'autenticazione per un ambiente di sviluppo locale. 

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 */

// const modelDisplayName = 'YOUR_MODEL_DISPLAY_NAME';
// const metadataSchemaUri = 'YOUR_METADATA_SCHEMA_URI';
// const imageUri = 'YOUR_IMAGE_URI';
// const artifactUri = 'YOUR_ARTIFACT_URI';
// 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 uploadModel() {
  // Configure the parent resources
  const parent = `projects/${project}/locations/${location}`;
  // Configure the model resources
  const model = {
    displayName: modelDisplayName,
    metadataSchemaUri: '',
    artifactUri: artifactUri,
    containerSpec: {
      imageUri: imageUri,
      command: [],
      args: [],
      env: [],
      ports: [],
      predictRoute: '',
      healthRoute: '',
    },
  };
  const request = {
    parent,
    model,
  };

  console.log('PARENT AND MODEL');
  console.log(parent, model);
  // Upload Model request
  const [response] = await modelServiceClient.uploadModel(request);
  console.log(`Long running operation : ${response.name}`);

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

  console.log('Upload model response ');
  console.log(`\tModel : ${result.model}`);
}
uploadModel();

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 typing import Dict, Optional, Sequence

from google.cloud import aiplatform
from google.cloud.aiplatform import explain


def upload_model_sample(
    project: str,
    location: str,
    display_name: str,
    serving_container_image_uri: str,
    artifact_uri: Optional[str] = None,
    serving_container_predict_route: Optional[str] = None,
    serving_container_health_route: Optional[str] = None,
    description: Optional[str] = None,
    serving_container_command: Optional[Sequence[str]] = None,
    serving_container_args: Optional[Sequence[str]] = None,
    serving_container_environment_variables: Optional[Dict[str, str]] = None,
    serving_container_ports: Optional[Sequence[int]] = None,
    instance_schema_uri: Optional[str] = None,
    parameters_schema_uri: Optional[str] = None,
    prediction_schema_uri: Optional[str] = None,
    explanation_metadata: Optional[explain.ExplanationMetadata] = None,
    explanation_parameters: Optional[explain.ExplanationParameters] = None,
    sync: bool = True,
):

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

    model = aiplatform.Model.upload(
        display_name=display_name,
        artifact_uri=artifact_uri,
        serving_container_image_uri=serving_container_image_uri,
        serving_container_predict_route=serving_container_predict_route,
        serving_container_health_route=serving_container_health_route,
        instance_schema_uri=instance_schema_uri,
        parameters_schema_uri=parameters_schema_uri,
        prediction_schema_uri=prediction_schema_uri,
        description=description,
        serving_container_command=serving_container_command,
        serving_container_args=serving_container_args,
        serving_container_environment_variables=serving_container_environment_variables,
        serving_container_ports=serving_container_ports,
        explanation_metadata=explanation_metadata,
        explanation_parameters=explanation_parameters,
        sync=sync,
    )

    model.wait()

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

Per importare un modello con le impostazioni di Vertex Explainable AI abilitate, consulta gli esempi di importazione di modelli di Vertex Explainable AI.

Ottenere 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 visualizzare lo stato dell'operazione o annullarla. Agent Platform fornisce metodi di assistenza per effettuare chiamate a operazioni a lunga esecuzione. Per saperne di più, consulta Utilizzare le operazioni a lunga esecuzione.

Limitazioni

  • La dimensione massima del modello supportata da Model Registry è di 1 TB.

Passaggi successivi