Importazione di modelli in Vertex AI

Questa guida descrive come importare i modelli nel registro dei modelli. Una volta importato, il modello sarà visibile nella registro dei modelli. Da Model Registry, puoi eseguire il deployment il modello importato in un endpoint ed eseguire previsioni.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per importare i modelli, chiedi all'amministratore di concederti Ruolo IAM Utente Vertex AI (roles/aiplatform.user) per il progetto. Per saperne di più sulla concessione dei ruoli, consulta Gestire l'accesso.

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

Container predefiniti o personalizzati

Quando importi un modello, lo associ a un container per Vertex AI per eseguire richieste di previsione. Puoi utilizzare container predefiniti forniti da Vertex AI, oppure usa i tuoi container personalizzati che crei ed esegui il push su Artifact Registry.

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

Se importi un modello AutoML tabulare che hai precedentemente esportato, devi utilizzare un container personalizzato specifico forniti da Vertex AI.

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

Carica gli artefatti del modello in Cloud Storage

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

Se il bucket Cloud Storage si trova in un ambiente Google Cloud diverso progetto, devi creare concedere l'accesso a Vertex AI per leggere gli artefatti del modello.

Se utilizzi un container predefinito, assicurati che gli artefatti del modello abbiano corrispondenti esattamente ai seguenti esempi:

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

Scopri di più su esportazione degli artefatti del modello per la previsione.

Importa un modello utilizzando la console Google Cloud

Per importare un modello utilizzando la console Google Cloud:

  1. Nella console Google Cloud, vai ai modelli di Vertex AI .

    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 scoprire di più sul controllo delle versioni del modello, consulta Controllo delle versioni del modello.

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

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

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

Container predefinito

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

  2. Seleziona il Framework modello e la Versione framework modello che hai utilizzato per addestrare il modello.

  3. Se vuoi utilizzare GPU per fornire previsioni, imposta l'opzione Acceleratore da a GPU.

    Selezioni il tipo di GPU in un secondo momento, quando eseguire il deployment del modello in un endpoint.

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

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

  5. Lascia vuoto il campo Prevedi schema.

  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 il tuo Impostazioni di spiegabilità nella scheda Spiegabilità. Impara scopri di più sul Impostazioni di spiegabilità.

Container personalizzato

  1. Seleziona Importa un container personalizzato esistente.

  2. Imposta l'URI dell'immagine container.

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

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

  4. Specifica i valori per gli altri campi.

    Scopri di più su questi argomenti 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 il tuo Impostazioni di spiegabilità nella scheda Spiegabilità. Impara scopri di più sul 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 di cui vuoi eseguire il pull dell'immagine Docker da cui proviene. Ogni repository fornisce la stessa immagine Docker, ma scegliendo il Artifact Registry (più regioni) più vicino alla macchina su cui esegui Docker potrebbe ridurre una latenza di pochi millisecondi.

  3. Nel campo Posizione pacchetto, specifica il percorso Cloud Storage della directory gli artefatti del tuo modello.

    Il percorso è simile al seguente esempio:

    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 scheda Modelli . Puoi utilizzare questo modello come qualsiasi altro modello AutoML Modelli tabulari, esclusi i modelli tabulari AutoML importati non supportano Vertex Explainable AI.

Importa un modello in modo programmatico

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

gcloud

L'esempio seguente utilizza la classe 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 stai utilizzando Vertex AI.
  • MODEL_NAME: un nome visualizzato per Model.
  • IMAGE_URI: l'URI dell'immagine container da utilizzare per fornire le previsioni. 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 artefatto del modello.

L'esempio precedente mostra tutti i flag necessari per importare la maggior parte di grandi dimensioni. Se non utilizzi un container predefinito per la previsione, occorre specificare alcune facoltativi in modo che Vertex AI può utilizzare la tua immagine container. Questi flag, che iniziano con --container-, corrispondono ai campi del tuo Model containerSpec.

REST

Usa il seguente esempio di codice per caricare un modello mediante Metodo upload della risorsa model.

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

  • LOCATION_ID: la regione in cui stai utilizzando Vertex AI.
  • PROJECT_ID: il tuo ID progetto.
  • MODEL_NAME: un nome visualizzato per Model.
  • MODEL_DESCRIPTION: facoltativo. Una descrizione del modello.
  • IMAGE_URI: l'URI dell'immagine container da utilizzare per fornire le previsioni. 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 artefatto del modello. Questa variabile e I campi artifactUri sono facoltativi se utilizzi un container personalizzato.
  • labels: facoltativo. Qualsiasi insieme di coppie chiave-valore per organizzare di grandi dimensioni. Ad esempio:
    • "env": "prod"
    • "tier": "backend"
  • Specifica LABEL_NAME e LABEL_VALUE per tutte le etichette che vuoi si applicano 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 delle seguenti 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_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. 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_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 per la configurazione di Java nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Java Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 per la configurazione di Node.js nel Guida rapida di Vertex AI con librerie client. Per ulteriori informazioni, consulta API Node.js Vertex AI documentazione di riferimento.

Per eseguire l'autenticazione su Vertex AI, configura Credenziali predefinite dell'applicazione. Per ulteriori informazioni, vedi 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 per Python, vedi Installare l'SDK Vertex AI per Python. Per ulteriori informazioni, consulta documentazione di riferimento dell'API Python. 

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 le Esempi di importazione di modelli Vertex Explainable AI.

Ottieni stato dell'operazione

Alcune richieste avviano operazioni a lunga esecuzione il cui completamento richiede tempo. Questi restituiscono il nome di un'operazione, che puoi utilizzare per visualizzare o annullare l'operazione. Vertex AI offre metodi helper per effettuare chiamate a operazioni a lunga esecuzione. Per ulteriori informazioni, consulta la sezione Utilizzo di modelli operations.

Limitazioni

  • La dimensione massima supportata del modello è 10 GiB.

Passaggi successivi