Esegui il deployment e l'inferenza di Gemma utilizzando Model Garden e gli endpoint basati su TPU di Vertex AI

In questo tutorial utilizzerai Model Garden per eseguire il deployment del modello aperto Gemma 2B in un endpoint Vertex AI basato su TPU. Devi eseguire il deployment di un modello in un endpoint prima che il modello possa essere usato per fornire previsioni online. Il deployment di un modello associa risorse fisiche al modello in modo che possa fornire previsioni online con bassa latenza.

Dopo aver eseguito il deployment del modello Gemma 2B, esegui l'inferenza del modello addestrato utilizzando PredictionServiceClient per ottenere previsioni online. Le previsioni online sono richieste sincrone effettuate a un modello di cui è stato eseguito il deployment in un endpoint.

Obiettivi

Questo tutorial mostra come eseguire le seguenti attività:

  • Esegui il deployment del modello open Gemma 2B su un endpoint basato su TPU utilizzando Model Garden
  • Utilizza PredictionServiceClient per ottenere previsioni online

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi Google Cloud utenti potrebbero avere diritto a una prova gratuita.

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione Pulizia.

Prima di iniziare

Per questo tutorial devi:

  • Configura un Google Cloud progetto e abilita l'API Vertex AI
  • Sulla tua macchina locale:
    • Installa, inizializza e autenticati con Google Cloud CLI
    • Installa l'SDK per la tua lingua

Configura un Google Cloud progetto

Configura il Google Cloud progetto e abilita l'API Vertex AI.

  1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

  2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  3. Make sure that billing is enabled for your Google Cloud project.

  4. Enable the Vertex AI API.

    Enable the API

    5.

  5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  6. Make sure that billing is enabled for your Google Cloud project.

  7. Enable the Vertex AI API.

    Enable the API

    8.

Configurare Google Cloud CLI

Sulla tua macchina locale, configura Google Cloud CLI.

  1. Installa e inizializza Google Cloud CLI.

  2. Se hai già installato gcloud CLI, assicurati che i componenti di gcloud siano aggiornati eseguendo questo comando.

    gcloud components update

  3. Per autenticarti con gcloud CLI, genera un file Credenziali predefinite dell'applicazione (ADC) locale eseguendo questo comando. Il flusso web avviato dal comando viene utilizzato per fornire le credenziali utente.

    gcloud auth application-default login

    Per ulteriori informazioni, consulta la configurazione dell'autenticazione e della configurazione dell'ADC dell'interfaccia a riga di comando gcloud.

Configura l'SDK per il tuo linguaggio di programmazione

Per configurare l'ambiente utilizzato in questo tutorial, installa l'SDK Vertex AI per il tuo linguaggio e la libreria Protocol Buffers. Gli esempi di codice utilizzano le funzioni della libreria Protocol Buffers per convertire il dizionario di input nel formato JSON previsto dall'API.

Sulla tua macchina locale, fai clic su una delle seguenti schede per installare l'SDK per il tuo linguaggio di programmazione.

Python

Sulla tua macchina locale, fai clic su una delle seguenti schede per installare l'SDK per il tuo linguaggio di programmazione.

  • Installa e aggiorna l'SDK Vertex AI per Python eseguendo questo comando.

    pip3 install --upgrade "google-cloud-aiplatform>=1.64"

  • Installa la libreria Protocol Buffers per Python eseguendo questo comando.

    pip3 install --upgrade "protobuf>=5.28"

Node.js

Installa o aggiorna l'SDK aiplatform per Node.js eseguendo il seguente comando.

npm install @google-cloud/aiplatform

Java

Per aggiungere google-cloud-aiplatform come dipendenza, aggiungi il codice appropriato per il tuo ambiente.

Maven con BOM

Aggiungi il seguente codice HTML a pom.xml:

<dependencyManagement>
<dependencies>
  <dependency>
    <artifactId>libraries-bom</artifactId>
    <groupId>com.google.cloud</groupId>
    <scope>import</scope>
    <type>pom</type>
    <version>26.34.0</version>
  </dependency>
</dependencies>
</dependencyManagement>
<dependencies>
<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-aiplatform</artifactId>
</dependency>
<dependency>
  <groupId>com.google.protobuf</groupId>
  <artifactId>protobuf-java-util</artifactId>
</dependency>
<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
</dependency>
</dependencies>

Maven senza BOM

Aggiungi quanto segue al tuo pom.xml:

<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-aiplatform</artifactId>
  <version>1.1.0</version>
</dependency>
<dependency>
  <groupId>com.google.protobuf</groupId>
  <artifactId>protobuf-java-util</artifactId>
  <version>5.28</version>
</dependency>
<dependency>
  <groupId>com.google.code.gson</groupId>
  <artifactId>gson</artifactId>
  <version>2.11.0</version>
</dependency>

Gradle senza BOM

Aggiungi quanto segue a build.gradle:

implementation 'com.google.cloud:google-cloud-aiplatform:1.1.0'

Vai

Installa questi pacchetti Go eseguendo i seguenti comandi.

go get cloud.google.com/go/aiplatform
go get google.golang.org/protobuf
go get github.com/googleapis/gax-go/v2

Esegui il deployment di Gemma utilizzando Model Garden

Esegui il deployment del modello Gemma 2B in un tipo di macchina Compute Engine ct5lp-hightpu-1t ottimizzato per l'addestramento su piccola e media scala. Questa macchina ha un acceleratore TPU v5e. Per ulteriori informazioni sull'addestramento dei modelli con le TPU, consulta Addestramento per Cloud TPU v5e.

In questo tutorial esegui il deployment del modello open Gemma 2B ottimizzato in base alle istruzioni utilizzando la scheda del modello in Model Garden. La versione specifica del modello è gemma2-2b-it, dove -it indica ottimizzato in base alle istruzioni.

Il modello Gemma 2B ha una dimensione dei parametri inferiore, il che significa requisiti di risorse inferiori e maggiore flessibilità di implementazione.

  1. Nella console Google Cloud, vai alla pagina Model Garden.

    Vai a Model Garden

  2. Fai clic sulla scheda del modello Gemma 2.

    Passa a Gemma 2

  3. Fai clic su Esegui il deployment per aprire il riquadro Esegui il deployment del modello.

  4. Nel riquadro Esegui il deployment del modello, specifica questi dettagli.

    1. Per Ambiente di deployment, fai clic su Vertex AI.

    2. Nella sezione Esegui il deployment del modello:

      1. In ID risorsa, scegli gemma-2b-it.

      2. Per Nome modello e Nome endpoint, accetta i valori predefiniti. Ad esempio:

        • Nome del modello: gemma2-2b-it-1234567891234
        • Nome endpoint: gemma2-2b-it-mg-one-click-deploy

        Prendi nota del nome dell'endpoint. Ti servirà per trovare l'ID endpoint utilizzato negli esempi di codice.

    3. Nella sezione Impostazioni di deployment:

      1. Accetta l'opzione predefinita per le impostazioni Base.

      2. Per Regione, accetta il valore predefinito o scegli una regione dall'elenco. Prendi nota della regione. Ne avrai bisogno per i sample di codice.

      3. In Specifiche della macchina, scegli l'istanza basata su TPU: ct5lp-hightpu-1t (1 TPU_V5_LITEPOD; ct5lp-hightpu-1t).

  5. Fai clic su Esegui il deployment. Al termine del deployment, riceverai un'email con i dettagli del nuovo endpoint. Puoi anche visualizzare i dettagli dell'endpoint facendo clic su Predizione online > Endpoint e selezionando la tua regione.

    Vai a Endpoints

Eseguire l'inferenza di Gemma 2B con PredictionServiceClient

Dopo aver eseguito il deployment di Gemma 2B, utilizzi PredictionServiceClient per ottenere previsioni online per il prompt: "Perché il cielo è blu?"

Parametri di codice

Gli esempi di codice PredictionServiceClient richiedono di aggiornare quanto segue.

  • PROJECT_ID: per trovare l'ID progetto, segui questi passaggi.

    1. Vai alla pagina Ti diamo il benvenuto nella console Google Cloud.

      Vai a Benvenuto

    2. Seleziona il tuo progetto dal selettore dei progetti nella parte superiore della pagina.

      Il nome, il numero e l'ID progetto vengono visualizzati dopo l'intestazione Ti diamo il benvenuto.

  • ENDPOINT_REGION: si tratta della regione in cui hai implementato l'endpoint.

  • ENDPOINT_ID: per trovare l'ID endpoint, visualizzalo nella console o esegui il comando gcloud ai endpoints list. Devi avere il nome e la regione dell'endpoint nel riquadro Esegui il deployment del modello.

    Console

    Per visualizzare i dettagli dell'endpoint, fai clic su Predizione online > Endpoint e seleziona la tua regione. Prendi nota del numero visualizzato nella colonna ID.

    Vai a Endpoints

    gcloud

    Puoi visualizzare i dettagli dell'endpoint eseguendo il comando gcloud ai endpoints list.

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

    L'output ha il seguente aspetto.

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
ENDPOINT_ID: 1234567891234567891
DISPLAY_NAME: gemma2-2b-it-mg-one-click-deploy

Codice di esempio

Nel codice di esempio per la tua lingua, aggiorna PROJECT_ID, ENDPOINT_REGION e ENDPOINT_ID. Poi esegui il codice.

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. 

"""
Sample to run inference on a Gemma2 model deployed to a Vertex AI endpoint with TPU accellerators.
"""

from google.cloud import aiplatform
from google.protobuf import json_format
from google.protobuf.struct_pb2 import Value

# TODO(developer): Update & uncomment lines below
# PROJECT_ID = "your-project-id"
# ENDPOINT_REGION = "your-vertex-endpoint-region"
# ENDPOINT_ID = "your-vertex-endpoint-id"

# Default configuration
config = {"max_tokens": 1024, "temperature": 0.9, "top_p": 1.0, "top_k": 1}

# Prompt used in the prediction
prompt = "Why is the sky blue?"

# Encapsulate the prompt in a correct format for TPUs
# Example format: [{'prompt': 'Why is the sky blue?', 'temperature': 0.9}]
input = {"prompt": prompt}
input.update(config)

# Convert input message to a list of GAPIC instances for model input
instances = [json_format.ParseDict(input, Value())]

# Create a client
api_endpoint = f"{ENDPOINT_REGION}-aiplatform.googleapis.com"
client = aiplatform.gapic.PredictionServiceClient(
    client_options={"api_endpoint": api_endpoint}
)

# Call the Gemma2 endpoint
gemma2_end_point = (
    f"projects/{PROJECT_ID}/locations/{ENDPOINT_REGION}/endpoints/{ENDPOINT_ID}"
)
response = client.predict(
    endpoint=gemma2_end_point,
    instances=instances,
)
text_responses = response.predictions
print(text_responses[0])

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 a Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 

// Imports the Google Cloud Prediction Service Client library
const {
  // TODO(developer): Uncomment PredictionServiceClient before running the sample.
  // PredictionServiceClient,
  helpers,
} = require('@google-cloud/aiplatform');
/**
 * TODO(developer): Update these variables before running the sample.
 */
const projectId = 'your-project-id';
const endpointRegion = 'your-vertex-endpoint-region';
const endpointId = 'your-vertex-endpoint-id';

// Prompt used in the prediction
const prompt = 'Why is the sky blue?';

// Encapsulate the prompt in a correct format for TPUs
// Example format: [{prompt: 'Why is the sky blue?', temperature: 0.9}]
const input = {
  prompt,
  // Parameters for default configuration
  maxOutputTokens: 1024,
  temperature: 0.9,
  topP: 1.0,
  topK: 1,
};

// Convert input message to a list of GAPIC instances for model input
const instances = [helpers.toValue(input)];

// TODO(developer): Uncomment apiEndpoint and predictionServiceClient before running the sample.
// const apiEndpoint = `${endpointRegion}-aiplatform.googleapis.com`;

// Create a client
// predictionServiceClient = new PredictionServiceClient({apiEndpoint});

// Call the Gemma2 endpoint
const gemma2Endpoint = `projects/${projectId}/locations/${endpointRegion}/endpoints/${endpointId}`;

const [response] = await predictionServiceClient.predict({
  endpoint: gemma2Endpoint,
  instances,
});

const predictions = response.predictions;
const text = predictions[0].stringValue;

console.log('Predictions:', text);

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 a Vertex AI, configura le Credenziali predefinite dell'applicazione. Per ulteriori informazioni, consulta Configurare l'autenticazione per un ambiente di sviluppo locale. 


import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.PredictResponse;
import com.google.cloud.aiplatform.v1.PredictionServiceClient;
import com.google.cloud.aiplatform.v1.PredictionServiceSettings;
import com.google.gson.Gson;
import com.google.protobuf.InvalidProtocolBufferException;
import com.google.protobuf.Value;
import com.google.protobuf.util.JsonFormat;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Gemma2PredictTpu {
  private final PredictionServiceClient predictionServiceClient;

  // Constructor to inject the PredictionServiceClient
  public Gemma2PredictTpu(PredictionServiceClient predictionServiceClient) {
    this.predictionServiceClient = predictionServiceClient;
  }

  public static void main(String[] args) throws IOException {
    // TODO(developer): Replace these variables before running the sample.
    String projectId = "YOUR_PROJECT_ID";
    String endpointRegion = "us-west1";
    String endpointId = "YOUR_ENDPOINT_ID";

    PredictionServiceSettings predictionServiceSettings =
        PredictionServiceSettings.newBuilder()
            .setEndpoint(String.format("%s-aiplatform.googleapis.com:443", endpointRegion))
            .build();
    PredictionServiceClient predictionServiceClient =
        PredictionServiceClient.create(predictionServiceSettings);
    Gemma2PredictTpu creator = new Gemma2PredictTpu(predictionServiceClient);

    creator.gemma2PredictTpu(projectId, endpointRegion, endpointId);
  }

  // Demonstrates how to run inference on a Gemma2 model
  // deployed to a Vertex AI endpoint with TPU accelerators.
  public String gemma2PredictTpu(String projectId, String region,
           String endpointId) throws IOException {
    Map<String, Object> paramsMap = new HashMap<>();
    paramsMap.put("temperature", 0.9);
    paramsMap.put("maxOutputTokens", 1024);
    paramsMap.put("topP", 1.0);
    paramsMap.put("topK", 1);
    Value parameters = mapToValue(paramsMap);
    // Prompt used in the prediction
    String instance = "{ \"prompt\": \"Why is the sky blue?\"}";
    Value.Builder instanceValue = Value.newBuilder();
    JsonFormat.parser().merge(instance, instanceValue);
    // Encapsulate the prompt in a correct format for TPUs
    // Example format: [{'prompt': 'Why is the sky blue?', 'temperature': 0.9}]
    List<Value> instances = new ArrayList<>();
    instances.add(instanceValue.build());

    EndpointName endpointName = EndpointName.of(projectId, region, endpointId);

    PredictResponse predictResponse = this.predictionServiceClient
        .predict(endpointName, instances, parameters);
    String textResponse = predictResponse.getPredictions(0).getStringValue();
    System.out.println(textResponse);
    return textResponse;
  }

  private static Value mapToValue(Map<String, Object> map) throws InvalidProtocolBufferException {
    Gson gson = new Gson();
    String json = gson.toJson(map);
    Value.Builder builder = Value.newBuilder();
    JsonFormat.parser().merge(json, builder);
    return builder.build();
  }
}

Go

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

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

import (
	"context"
	"fmt"
	"io"

	"cloud.google.com/go/aiplatform/apiv1/aiplatformpb"

	"google.golang.org/protobuf/types/known/structpb"
)

// predictTPU demonstrates how to run interference on a Gemma2 model deployed to a Vertex AI endpoint with TPU accelerators.
func predictTPU(w io.Writer, client PredictionsClient, projectID, location, endpointID string) error {
	ctx := context.Background()

	// Note: client can be initialized in the following way:
	// apiEndpoint := fmt.Sprintf("%s-aiplatform.googleapis.com:443", location)
	// client, err := aiplatform.NewPredictionClient(ctx, option.WithEndpoint(apiEndpoint))
	// if err != nil {
	// 	return fmt.Errorf("unable to create prediction client: %v", err)
	// }
	// defer client.Close()

	gemma2Endpoint := fmt.Sprintf("projects/%s/locations/%s/endpoints/%s", projectID, location, endpointID)
	prompt := "Why is the sky blue?"
	parameters := map[string]interface{}{
		"temperature":     0.9,
		"maxOutputTokens": 1024,
		"topP":            1.0,
		"topK":            1,
	}

	// Encapsulate the prompt in a correct format for TPUs.
	// Example format: [{'prompt': 'Why is the sky blue?', 'temperature': 0.9}]
	promptValue, err := structpb.NewValue(map[string]interface{}{
		"prompt":     prompt,
		"parameters": parameters,
	})
	if err != nil {
		fmt.Fprintf(w, "unable to convert prompt to Value: %v", err)
		return err
	}

	req := &aiplatformpb.PredictRequest{
		Endpoint:  gemma2Endpoint,
		Instances: []*structpb.Value{promptValue},
	}

	resp, err := client.Predict(ctx, req)
	if err != nil {
		return err
	}

	prediction := resp.GetPredictions()
	value := prediction[0].GetStringValue()
	fmt.Fprintf(w, "%v", value)

	return nil
}

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che contiene le risorse oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Elimina singole risorse

Se mantieni il progetto, elimina le risorse utilizzate in questo tutorial:

  • Annullare il deployment del modello ed eliminare l'endpoint
  • Elimina il modello dal Registro dei modelli

Annullare il deployment del modello ed eliminare l'endpoint

Utilizza uno dei seguenti metodi per annullare il deployment di un modello ed eliminare l'endpoint.

Console

  1. Nella console Google Cloud, fai clic su Previsione online e poi su Endpoint.

    Vai alla pagina Endpoints

  2. Nell'elenco a discesa Regione, scegli la regione in cui hai eseguito il deployment dell'endpoint.

  3. Fai clic sul nome dell'endpoint per aprire la pagina dei dettagli. Ad esempio: gemma2-2b-it-mg-one-click-deploy.

  4. Nella riga del modello Gemma 2 (Version 1), fai clic su Azioni e poi su Annulla il deployment del modello nell'endpoint.

  5. Nella finestra di dialogo Annulla il deployment del modello nell'endpoint, fai clic su Annulla deployment.

  6. Fai clic sul pulsante Indietro per tornare alla pagina Endpoint.

    Vai alla pagina Endpoints

  7. Alla fine della riga gemma2-2b-it-mg-one-click-deploy, fai clic su Azioni e poi seleziona Elimina endpoint.

  8. Nella richiesta di conferma, fai clic su Conferma.

gcloud

Per annullare il deployment del modello ed eliminare l'endpoint utilizzando Google Cloud CLI, segui questi passaggi.

In questi comandi, sostituisci:

  • PROJECT_ID con il nome del progetto
  • LOCATION_ID con la regione in cui hai eseguito il deployment del modello e dell'endpoint
  • ENDPOINT_ID con l'ID endpoint
  • DEPLOYED_MODEL_NAME con il nome visualizzato del modello
  • DEPLOYED_MODEL_ID con l'ID modello

  1. Recupera l'ID endpoint eseguendo il comando gcloud ai endpoints list. Questo comando elenca gli ID di tutti gli endpoint del progetto. Prendi nota dell'ID dell'endpoint utilizzato in questo tutorial.

    gcloud ai endpoints list \
    --project=PROJECT_ID \
    --region=LOCATION_ID

    L'output ha il seguente aspetto. Nell'output, l'ID è chiamato ENDPOINT_ID.

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
ENDPOINT_ID: 1234567891234567891
DISPLAY_NAME: gemma2-2b-it-mg-one-click-deploy

  2. Recupera l'ID modello eseguendo il comando gcloud ai models describe. Prendi nota dell'ID del modello di cui hai eseguito il deployment in questo tutorial.

    gcloud ai models describe DEPLOYED_MODEL_NAME \
    --project=PROJECT_ID \
    --region=LOCATION_ID

    L'output abbreviato è simile al seguente. Nell'output, l'ID è chiamato deployedModelId.

    Using endpoint [https://us-central1-aiplatform.googleapis.com/]
artifactUri: [URI removed]
baseModelSource:
  modelGardenSource:
    publicModelName: publishers/google/models/gemma2
...
deployedModels:
- deployedModelId: '1234567891234567891'
  endpoint: projects/12345678912/locations/us-central1/endpoints/12345678912345
displayName: gemma2-2b-it-12345678912345
etag: [ETag removed]
modelSourceInfo:
  sourceType: MODEL_GARDEN
name: projects/123456789123/locations/us-central1/models/gemma2-2b-it-12345678912345
...

  3. Annullare il deployment del modello dall'endpoint. Ti serviranno l'ID endpoint e l'ID modello dei comandi precedenti.

    gcloud ai endpoints undeploy-model ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID \
    --deployed-model-id=DEPLOYED_MODEL_ID

    Questo comando non produce alcun output.

  4. Esegui il comando gcloud ai endpoints delete per eliminare l'endpoint.

    gcloud ai endpoints delete ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID

    Quando richiesto, digita y per confermare. Questo comando non produce alcun output.

Elimina il modello

Console

  1. Vai alla pagina Registro dei modelli dalla sezione Vertex AI nella console Google Cloud.

    Vai alla pagina Registro dei modelli

  2. Nell'elenco a discesa Regione, scegli la regione in cui hai eseguito il deployment del modello.

  3. Alla fine della riga gemma2-2b-it-1234567891234, fai clic su Azioni.

  4. Seleziona Elimina modello.

    Quando elimini il modello, tutte le versioni e le valutazioni associate vengono eliminate dal tuo Google Cloud progetto.

  5. Nel messaggio di conferma, fai clic su Elimina.

gcloud

Per eliminare il modello utilizzando Google Cloud CLI, fornisci il nome visualizzato e la regione del modello al comando gcloud ai models delete.

gcloud ai models delete DEPLOYED_MODEL_NAME \
    --project=PROJECT_ID \
    --region=LOCATION_ID

Sostituisci DEPLOYED_MODEL_NAME con il nome visualizzato del modello. Sostituisci PROJECT_ID con il nome del progetto. Sostituisci LOCATION_ID con la regione in cui hai eseguito il deployment del modello.

Passaggi successivi