Implemente e faça inferência do Gemma através do Model Garden e dos pontos finais suportados pela TPU do Vertex AI

Neste tutorial, vai usar o Model Garden para implementar o modelo aberto Gemma 2B num ponto final do Vertex AI com tecnologia de TPU. Tem de implementar um modelo num ponto final antes de poder usar esse modelo para publicar previsões online. A implementação de um modelo associa recursos físicos ao modelo para que possa publicar previsões online com baixa latência.

Depois de implementar o modelo Gemma 2B, infere o modelo preparado usando o PredictionServiceClient para obter previsões online. As previsões online são pedidos síncronos feitos a um modelo implementado num ponto final.

Objetivos

Este tutorial mostra como realizar as seguintes tarefas:

  • Implemente o modelo aberto Gemma 2B num ponto final suportado por TPU através do Model Garden
  • Use o PredictionServiceClient para receber previsões online

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

Antes de começar

Este tutorial requer que:

  • Configure um Google Cloud projeto e ative a API Vertex AI
  • Na sua máquina local:
    • Instale, inicialize e faça a autenticação com a CLI Google Cloud
    • Instale o SDK para o seu idioma

Configure um Google Cloud projeto

Configure o seu Google Cloud projeto e ative a 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.

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  3. Verify that billing is enabled for your Google Cloud project.

  4. Enable the Vertex AI API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

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

    Roles required to select or create a project

    • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
    • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

    Go to project selector

  6. Verify that billing is enabled for your Google Cloud project.

  7. Enable the Vertex AI API.

    Roles required to enable APIs

    To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

    Enable the API

    8.

    Configure a CLI Google Cloud

    Na sua máquina local, configure a CLI Google Cloud.

    1. Instale e inicialize a CLI Google Cloud.

    2. Se instalou anteriormente a CLI gcloud, certifique-se de que os componentes gcloud estão atualizados executando este comando.

      gcloud components update

    3. Para se autenticar com a CLI gcloud, execute este comando para gerar um ficheiro de Credenciais padrão da aplicação (ADC) local. O fluxo da Web iniciado pelo comando é usado para fornecer as suas credenciais de utilizador.

      gcloud auth application-default login

      Para mais informações, consulte a configuração de autenticação da CLI gcloud e a configuração do ADC.

    Configure o SDK para a sua linguagem de programação

    Para configurar o ambiente usado neste tutorial, instala o SDK do Vertex AI para o seu idioma e a biblioteca Protocol Buffers. Os exemplos de código usam funções da biblioteca de buffers de protocolo para converter o dicionário de entrada no formato JSON esperado pela API.

    Na sua máquina local, clique num dos seguintes separadores para instalar o SDK para o seu idioma de programação.

    Python

    Na sua máquina local, clique num dos seguintes separadores para instalar o SDK para a sua linguagem de programação.

    • Instale e atualize o SDK Vertex AI para Python executando este comando.

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

    • Instale a biblioteca Protocol Buffers para Python executando este comando.

      pip3 install --upgrade "protobuf>=5.28"

    Node.js

    Instale ou atualize o SDK aiplatform para Node.js executando o seguinte comando.

    npm install @google-cloud/aiplatform

    Java

    Para adicionar google-cloud-aiplatform como uma dependência, adicione o código adequado para o seu ambiente.

    Maven com BOM

    Adicione o seguinte HTML ao seu 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 sem BOM

    Adicione o seguinte ao seu 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 sem BOM

    Adicione o seguinte ao seu build.gradle:

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

    Ir

    Instale estes pacotes Go executando os seguintes comandos.

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

    Implemente o Gemma através do Model Garden

    Implementa o modelo Gemma 2B num tipo de máquina do Compute Engine ct5lp-hightpu-1t otimizado para o treino de pequena a média escala. Esta máquina tem um acelerador TPU v5e. Para mais informações sobre a preparação de modelos com TPUs, consulte o artigo Preparação de Cloud TPU v5e.

    Neste tutorial, implementa o modelo aberto Gemma 2B com ajuste fino de instruções usando o cartão do modelo no Model Garden. A versão específica do modelo é gemma2-2b-it. -it significa ajustado para instruções.

    O modelo Gemma 2B tem um tamanho de parâmetro inferior, o que significa requisitos de recursos mais baixos e maior flexibilidade de implementação.

    1. Na Google Cloud consola, aceda à página Model Garden.

      Aceda ao Model Garden

    2. Clique no cartão do modelo Gemma 2.

      Aceda ao Gemma 2

    3. Clique em Implementar para abrir o painel Implementar modelo.

    4. No painel Implementar modelo, especifique estes detalhes.

      1. Em Ambiente de implementação, clique em Vertex AI.

      2. Na secção Implementar modelo:

        1. Para ID do recurso, escolha gemma-2b-it.

        2. Para Nome do modelo e Nome do ponto final, aceite os valores predefinidos. Por exemplo:

          • Nome do modelo: gemma2-2b-it-1234567891234
          • Nome do ponto final: gemma2-2b-it-mg-one-click-deploy

          Tome nota do nome do ponto final. Precisa dele para encontrar o ID do ponto final usado nos exemplos de código.

      3. Na secção Definições de implementação:

        1. Aceite a opção predefinida para as definições Básicas.

        2. Para Região, aceite o valor predefinido ou escolha uma região na lista. Tome nota da região. Vai precisar dele para os exemplos de código.

        3. Para Especificações da máquina, escolha a instância suportada pela TPU: ct5lp-hightpu-1t (1 TPU_V5_LITEPOD; ct5lp-hightpu-1t).

    5. Clique em Implementar. Quando a implementação estiver concluída, recebe um email que contém detalhes sobre o seu novo ponto final. Também pode ver os detalhes do ponto final clicando em Previsão online > Pontos finais e selecionando a sua região.

      Aceda a Pontos finais

    Faça inferência do Gemma 2B com o PredictionServiceClient

    Depois de implementar o Gemma 2B, usa a PredictionServiceClient para obter previsões online para o comando: "Porque é que o céu é azul?"

    Parâmetros de código

    Os PredictionServiceClient exemplos de código requerem que atualize o seguinte.

    • PROJECT_ID: para encontrar o ID do projeto, siga estes passos.

      1. Aceda à página Boas-vindas na Google Cloud consola.

        Aceder a Boas-vindas

      2. No seletor de projetos na parte superior da página, selecione o seu projeto.

        O nome do projeto, o número do projeto e o ID do projeto aparecem após o cabeçalho Bem-vindo.

    • ENDPOINT_REGION: esta é a região onde implementou o ponto final.

    • ENDPOINT_ID: para encontrar o ID do ponto final, veja-o na consola ou execute o comando gcloud ai endpoints list. Precisa do nome do ponto final e da região do painel Implementar modelo.

      Consola

      Pode ver os detalhes do ponto final clicando em Previsão online > Pontos finais e selecionando a sua região. Tenha em atenção o número apresentado na coluna ID.

      Aceda a Pontos finais

      gcloud

      Pode ver os detalhes do ponto final executando o comando gcloud ai endpoints list.

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

      O resultado tem o seguinte aspeto.

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

    Exemplo de código

    No exemplo de código para o seu idioma, atualize os valores PROJECT_ID, ENDPOINT_REGION e ENDPOINT_ID. Em seguida, execute o código.

    Python

    Para saber como instalar ou atualizar o SDK Vertex AI para Python, consulte o artigo Instale o SDK Vertex AI para Python. Para mais informações, consulte a Python documentação de referência da API. 

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

    Antes de experimentar este exemplo, siga as Node.jsinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Node.js Vertex AI.

    Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

    // 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

    Antes de experimentar este exemplo, siga as Javainstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Java Vertex AI.

    Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

    
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

    Antes de experimentar este exemplo, siga as Goinstruções de configuração no início rápido do Vertex AI com bibliotecas de cliente. Para mais informações, consulte a documentação de referência da API Go Vertex AI.

    Para se autenticar no Vertex AI, configure as Credenciais padrão da aplicação. Para mais informações, consulte o artigo Configure a autenticação para um ambiente de desenvolvimento local. 

    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
}

    Limpar

    Para evitar incorrer em custos na sua conta do Google Cloud pelos recursos usados neste tutorial, elimine o projeto que contém os recursos ou mantenha o projeto e elimine os recursos individuais.

    Elimine o projeto

    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.

    Elimine recursos individuais

    Se vai manter o projeto, elimine os recursos usados neste tutorial:

    • Anule a implementação do modelo e elimine o ponto final
    • Elimine o modelo do registo de modelos

    Anule a implementação do modelo e elimine o ponto final

    Use um dos seguintes métodos para anular a implementação de um modelo e eliminar o ponto final.

    Consola

    1. Na Google Cloud consola, clique em Previsão online e, de seguida, clique em Pontos finais.

      Aceda à página Pontos finais

    2. Na lista pendente Região, escolha a região onde implementou o seu ponto final.

    3. Clique no nome do ponto final para abrir a página de detalhes. Por exemplo: gemma2-2b-it-mg-one-click-deploy.

    4. Na linha do modelo Gemma 2 (Version 1), clique em Ações e, de seguida, clique em Anular implementação do modelo a partir do ponto final.

    5. Na caixa de diálogo Anular implementação do modelo a partir do ponto final, clique em Anular implementação.

    6. Clique no botão Anterior para voltar à página Pontos finais.

      Aceda à página Pontos finais

    7. No final da linha gemma2-2b-it-mg-one-click-deploy, clique em Ações e, de seguida, selecione Eliminar ponto final.

    8. No comando de confirmação, clique em Confirmar.

    gcloud

    Para anular a implementação do modelo e eliminar o ponto final através da Google Cloud CLI, siga estes passos.

    Nestes comandos, substitua:

    • PROJECT_ID com o nome do seu projeto
    • LOCATION_ID com a região onde implementou o modelo e o ponto final
    • ENDPOINT_ID com o ID de ponto final
    • DEPLOYED_MODEL_NAME com o nome a apresentar do modelo
    • DEPLOYED_MODEL_ID com o ID do modelo

    1. Execute o comando gcloud ai endpoints list para obter o ID do ponto final. Este comando lista os IDs dos pontos finais de todos os pontos finais no seu projeto. Tome nota do ID do ponto final usado neste tutorial.

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

      O resultado tem o seguinte aspeto. Na saída, o ID é denominado ENDPOINT_ID.

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

    2. Execute o comando gcloud ai models describe para obter o ID do modelo. Tome nota do ID do modelo que implementou neste tutorial.

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

      O resultado abreviado tem o seguinte aspeto. Na saída, o ID é denominado 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. Anule a implementação do modelo no ponto final. Precisa do ID do ponto final e do ID do modelo dos comandos anteriores.

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

      Este comando não produz qualquer resultado.

    4. Execute o comando gcloud ai endpoints delete para eliminar o ponto final.

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

      Quando lhe for pedido, escreva y para confirmar. Este comando não produz qualquer resultado.

    Elimine o modelo

    Consola

    1. Aceda à página Registo de modelos na secção Vertex AI da Google Cloud consola.

      Aceda à página Registo de modelos

    2. Na lista pendente Região, escolha a região onde implementou o modelo.

    3. No final da linha gemma2-2b-it-1234567891234, clique em Ações.

    4. Selecione Eliminar modelo.

      Quando elimina o modelo, todas as versões e avaliações do modelo associadas são eliminadas do seu Google Cloud projeto.

    5. Na mensagem de confirmação, clique em Eliminar.

    gcloud

    Para eliminar o modelo através da CLI Google Cloud, indique o nome a apresentar e a região do modelo no comando gcloud ai models delete.

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

    Substitua DEPLOYED_MODEL_NAME pelo nome a apresentar do modelo. Substitua PROJECT_ID pelo nome do seu projeto. Substitua LOCATION_ID pela região onde implementou o modelo.

    O que se segue?