Esta página se ha traducido con Cloud Translation API.

Desplegar y usar Gemma para inferencias con Model Garden y endpoints respaldados por TPU de Vertex AI

En este tutorial, usarás Model Garden para desplegar el modelo abierto Gemma 2B en un endpoint de Vertex AI con TPU. Debes desplegar un modelo en un endpoint para poder usarlo y ofrecer predicciones online. Al desplegar un modelo, se asocian recursos físicos a este para que pueda ofrecer predicciones online con baja latencia.

Una vez que hayas desplegado el modelo Gemma 2B, podrás inferir el modelo entrenado mediante PredictionServiceClient para obtener predicciones online. Las predicciones online son solicitudes síncronas que se envían a un modelo desplegado en un endpoint.

Objetivos

En este tutorial se explica cómo realizar las siguientes tareas:

Desplegar el modelo abierto Gemma 2B en un endpoint con TPU mediante Model Garden
Usar PredictionServiceClient para obtener predicciones online

Costes

En este documento, se utilizan los siguientes componentes facturables de Google Cloud:

A ct5lp-hightpu-1t machine type with one TPU_V5 accelerator
Vertex AI prediction and explanation

Para generar una estimación de costes basada en el uso previsto, utiliza la calculadora de precios.

Los usuarios nuevos Google Cloud pueden disfrutar de una prueba gratuita.

Cuando termines las tareas que se describen en este documento, puedes evitar que se te siga facturando eliminando los recursos que has creado. Para obtener más información, consulta la sección Limpiar.

Antes de empezar

Para hacer este tutorial, debes:

Configurar un Google Cloud proyecto y habilitar la API de Vertex AI
En tu equipo local:
- Instalar, inicializar y autenticar con la CLI de Google Cloud
- Instalar el SDK de tu idioma

Configurar un Google Cloud proyecto

Configura tu Google Cloud proyecto y habilita la API Vertex AI.

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.

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

Verify that billing is enabled for your Google Cloud project.

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

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

Verify that billing is enabled for your Google Cloud project.

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

Configurar Google Cloud CLI

En tu máquina local, configura Google Cloud CLI.

Instala e inicializa la CLI de Google Cloud.
Si ya has instalado la CLI de gcloud, asegúrate de que tus componentes de gcloud estén actualizados ejecutando este comando.
```
gcloud components update
```
Para autenticarte con la CLI de gcloud, genera un archivo local de credenciales predeterminadas de la aplicación (ADC) ejecutando este comando. El flujo web que inicia el comando se usa para proporcionar las credenciales de usuario.
```
gcloud auth application-default login
```
Para obtener más información, consulta Configuración de autenticación de la CLI de gcloud y configuración de ADC.

Configurar el SDK para tu lenguaje de programación

Para configurar el entorno que se usa en este tutorial, instala el SDK de Vertex AI para tu idioma y la biblioteca Protocol Buffers. Los ejemplos de código usan funciones de la biblioteca Protocol Buffers para convertir el diccionario de entrada al formato JSON que espera la API.

En tu máquina local, haz clic en una de las siguientes pestañas para instalar el SDK de tu lenguaje de programación.

Python

En tu máquina local, haz clic en una de las siguientes pestañas para instalar el SDK de tu lenguaje de programación.

Instala y actualiza el SDK de Vertex AI para Python ejecutando este comando.
```
pip3 install --upgrade "google-cloud-aiplatform>=1.64"
```
Instala la biblioteca Protocol Buffers para Python ejecutando este comando.
```
pip3 install --upgrade "protobuf>=5.28"
```

Node.js

Instala o actualiza el SDK de aiplatform para Node.js ejecutando el siguiente comando.

npm install @google-cloud/aiplatform

Java

Para añadir google-cloud-aiplatform como dependencia, añade el código adecuado para tu entorno.

Maven con BOM

Añade el siguiente código HTML a tu 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 sin BOM

Añade lo siguiente a tu 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 sin BOM

Añade lo siguiente a tu build.gradle:

implementation 'com.google.cloud:google-cloud-aiplatf1.1.0orm:'

Go

Instala estos paquetes de Go ejecutando los siguientes comandos.

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

Desplegar Gemma con Model Garden

Implementa el modelo Gemma 2B en un ct5lp-hightpu-1t tipo de máquina de Compute Engine optimizado para el entrenamiento a pequeña y mediana escala. Esta máquina tiene un acelerador TPU v5e. Para obtener más información sobre cómo entrenar modelos con TPUs, consulta el artículo sobre el entrenamiento con la versión 5e de TPU de Cloud.

En este tutorial, desplegarás el modelo abierto Gemma 2B ajustado para seguir instrucciones mediante la tarjeta de modelo de Model Garden. La versión específica del modelo es gemma2-2b-it. -it significa ajustado para instrucciones.

El modelo Gemma 2B tiene un tamaño de parámetro más pequeño, lo que significa que requiere menos recursos y ofrece más flexibilidad de implementación.

En la Google Cloud consola, ve a la página Model Garden.

Ir a Model Garden
Haz clic en la tarjeta del modelo Gemma 2.

Ir a Gemma 2
Haga clic en Implementar para abrir el panel Implementar modelo.
En el panel Implementar modelo, especifica estos detalles.
1. En Entorno de implementación, haz clic en Vertex AI.
2. En la sección Desplegar modelo:
  1. En ID de recurso, elige gemma-2b-it.
  2. En Nombre del modelo y Nombre del endpoint, acepta los valores predeterminados. Por ejemplo:
    - Nombre del modelo: gemma2-2b-it-1234567891234
    - Nombre del endpoint: gemma2-2b-it-mg-one-click-deploy
    Anota el nombre del endpoint. Lo necesitará para encontrar el ID de endpoint que se usa en los ejemplos de código.
3. En la sección Ajustes del despliegue:
  1. Acepta la opción predeterminada de Básico.
  2. En Región, acepta el valor predeterminado o elige una región de la lista. Anota la región. Lo necesitarás para los ejemplos de código.
  3. En Especificación de la máquina, elige la instancia con TPU: ct5lp-hightpu-1t (1 TPU_V5_LITEPOD; ct5lp-hightpu-1t).
Haz clic en Desplegar. Cuando finalice la implementación, recibirás un correo con los detalles de tu nuevo endpoint. También puede ver los detalles del endpoint haciendo clic en Predicción online > Endpoints y seleccionando su región.

Ir a Endpoints

Inferir Gemma 2B con PredictionServiceClient

Después de desplegar Gemma 2B, usas la PredictionServiceClient para obtener predicciones online de la petición "¿Por qué el cielo es azul?".

Parámetros de código

En los ejemplos de código de PredictionServiceClient, debes actualizar lo siguiente.

PROJECT_ID: Para encontrar el ID de tu proyecto, sigue estos pasos.
1. Ve a la página Bienvenida de la Google Cloud consola.
  Ir a Bienvenida
2. En el selector de proyectos de la parte superior de la página, selecciona tu proyecto.
  
  El nombre, el número y el ID del proyecto aparecen después del encabezado Bienvenido.
ENDPOINT_REGION: es la región en la que has implementado el endpoint.
ENDPOINT_ID: Para encontrar tu ID de endpoint, consúltalo en la consola o ejecuta el comando gcloud ai endpoints list. Necesitarás el nombre y la región del endpoint del panel Implementar modelo.
Consola
Para ver los detalles del endpoint, haga clic en Predicción online > Endpoints y seleccione su región. Fíjate en el número que aparece en la columna ID.

Ir a Endpoints
gcloud
Para ver los detalles del endpoint, ejecuta el comando gcloud ai endpoints list.
```
gcloud ai endpoints list \
  --region=ENDPOINT_REGION \
  --filter=display_name=ENDPOINT_NAME
```
La salida tiene este aspecto.
```
Using endpoint [https://us-central1-aiplatform.googleapis.com/]
ENDPOINT_ID: 1234567891234567891
DISPLAY_NAME: gemma2-2b-it-mg-one-click-deploy
```

Código de muestra

En el código de ejemplo de tu idioma, actualiza PROJECT_ID, ENDPOINT_REGION y ENDPOINT_ID. A continuación, ejecuta el código.

Python

Para saber cómo instalar o actualizar el SDK de Vertex AI para Python, consulta Instalar el SDK de Vertex AI para Python. Para obtener más información, consulta la documentación de referencia de la 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 Val&ue

# 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 probar este ejemplo, sigue las Node.js instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Node.js de Vertex AI.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Para obtener más información, consulta el artículo Configurar la autenticación en un entorno de desarrollo local.

// Imports the Google Cloud Prediction Service Client library
const {
  // TODO(developer): Uncomment PredictionServiceClient before running the sample.
  // PredictionServiceClient,
  helpers,
} = require(&#39;@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 probar este ejemplo, sigue las Java instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Java de Vertex AI.


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) th>rows IOException {
    M<>apString, 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 = &quot;{ \"prompt\": \"Why is the sky blue?\"}";
    Value.Builder instanceValue = Value.newBuilder();
    JsonFormat.parser().merge(instance, instanceValue);
    // Encapsulate the prompt in a co<rrect> format for TPUs
    // Ex<>ample format: [{'prompt': 'Why is the sky blue?';, 'temperature': 0.9}]
    ListValue 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.getPred<ictions(0).get>StringValue();
    System.out.println(textResponse);
    return textResponse;
  }

  private static Value mapToValue(MapString, 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 probar este ejemplo, sigue las Go instrucciones de configuración de la guía de inicio rápido de Vertex AI con bibliotecas de cliente. Para obtener más información, consulta la documentación de referencia de la API Go de Vertex AI.

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
}

Limpieza

Para evitar que los recursos utilizados en este tutorial se cobren en tu cuenta de Google Cloud, elimina el proyecto que contiene los recursos o conserva el proyecto y elimina los recursos.

Eliminar el proyecto

Precaución: Eliminar un proyecto tiene los siguientes efectos:

Se elimina todo el contenido del proyecto. Si has usado un proyecto que ya existía para las tareas de este documento, cuando lo elimines, también se eliminará cualquier otro trabajo que hayas realizado en él.
Se pierden los IDs de proyecto personalizados. Cuando creaste este proyecto, es posible que hayas creado un ID de proyecto personalizado que quieras usar en el futuro. Para conservar las URLs que usan el ID del proyecto, como una URL appspot.com, elimina los recursos seleccionados dentro del proyecto en lugar de eliminar todo el proyecto.

Si tienes previsto consultar varias arquitecturas, tutoriales o guías de inicio rápido, reutilizar los proyectos puede ayudarte a no superar los límites de cuota de proyectos.

In the Google Cloud console, go to the Manage resources page.
Go to Manage resources
In the project list, select the project that you want to delete, and then click Delete.
In the dialog, type the project ID, and then click Shut down to delete the project.

Eliminar recursos concretos

Si vas a conservar el proyecto, elimina los recursos que has usado en este tutorial:

Anular el despliegue del modelo y eliminar el endpoint
Eliminar el modelo del registro de modelos

Anular el despliegue del modelo y eliminar el endpoint

Utilice uno de los siguientes métodos para retirar un modelo y eliminar el endpoint.

Consola

En la Google Cloud consola, haz clic en Predicción online y, a continuación, en Endpoints.

Ir a la página Endpoints
En la lista desplegable Región, elige la región en la que has implementado tu endpoint.
Haz clic en el nombre del endpoint para abrir la página de detalles. Por ejemplo: gemma2-2b-it-mg-one-click-deploy.
En la fila del modelo Gemma 2 (Version 1), haga clic en Acciones y, a continuación, en Retirar modelo del endpoint.
En el cuadro de diálogo Anular despliegue de modelo de punto final, haz clic en Anular despliegue.
Haz clic en el botón Atrás para volver a la página Endpoints (Endpoints)

Ir a la página Endpoints
Al final de la fila gemma2-2b-it-mg-one-click-deploy, haga clic en Acciones y, a continuación, seleccione Eliminar endpoint.
En la ventana de confirmación, haz clic en Confirmar.

gcloud

Para retirar el modelo y eliminar el endpoint con la CLI de Google Cloud, sigue estos pasos.

En estos comandos, sustituye lo siguiente:

PROJECT_ID con el nombre de tu proyecto
LOCATION_ID por la región en la que has desplegado el modelo y el endpoint
ENDPOINT_ID con el ID del endpoint
DEPLOYED_MODEL_NAME con el nombre visible del modelo
DEPLOYED_MODEL_ID con el ID del modelo

Obtén el ID del endpoint ejecutando el comando gcloud ai endpoints list. Este comando muestra los IDs de endpoint de todos los endpoints de tu proyecto. Anota el ID del endpoint que se ha usado en este tutorial.
```
gcloud ai endpoints list \
    --project=PROJECT_ID \
    --region=LOCATION_ID
```
La salida tiene este aspecto. En el resultado, el ID se llama ENDPOINT_ID.
```
Using endpoint [https://us-central1-aiplatform.googleapis.com/]
ENDPOINT_ID: 1234567891234567891
DISPLAY_NAME: gemma2-2b-it-mg-one-click-deploy
```

Obtén el ID del modelo ejecutando el comando gcloud ai models describe. Anota el ID del modelo que has implementado en este tutorial.

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

La salida abreviada tiene este aspecto. En el resultado, el ID se llama 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
...

Anula el despliegue del modelo en el endpoint. Necesitarás el ID de endpoint y el ID de modelo de los comandos anteriores.

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

Este comando no genera ninguna salida.

Ejecuta el comando gcloud ai endpoints delete para eliminar el endpoint.
```
gcloud ai endpoints delete ENDPOINT_ID \
    --project=PROJECT_ID \
    --region=LOCATION_ID
```
Cuando se te solicite, escribe y para confirmar la acción. Este comando no genera ninguna salida.

Eliminar el modelo

Consola

Ve a la página Registro de modelos de la sección Vertex AI de la consola de Google Cloud .

Ve a la página Registro de modelos.
En la lista desplegable Región, elige la región en la que has implementado el modelo.
Al final de la fila gemma2-2b-it-1234567891234, haz clic en Acciones.
Selecciona Eliminar modelo.

Cuando eliminas el modelo, todas las versiones y evaluaciones asociadas se eliminan de tu Google Cloud proyecto.
En la ventana de confirmación, haz clic en Eliminar.

gcloud

Para eliminar el modelo con Google Cloud CLI, proporciona el nombre visible y la región del modelo al comando gcloud ai models delete.

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

Sustituye DEPLOYED_MODEL_NAME por el nombre visible del modelo. Sustituye PROJECT_ID por el nombre de tu proyecto. Sustituye LOCATION_ID por la región en la que has desplegado el modelo.

Siguientes pasos

Más información sobre los modelos abiertos de Gemma
Lee los Términos de Uso de Gemma.
Más información sobre los modelos abiertos
Consulta cómo desplegar un modelo ajustado.
Consulta cómo desplegar Gemma 2 en Google Kubernetes Engine con Hugging Face Textgen Inference (TGI).
Consulta más información sobre PredictionServiceClient en el idioma que prefieras: Python, Node.js, Java o Go.

Desplegar y usar Gemma para inferencias con Model Garden y endpoints respaldados por TPU de Vertex AI Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.

Objetivos

Costes

Antes de empezar

Configurar un Google Cloud proyecto

Configurar Google Cloud CLI

Configurar el SDK para tu lenguaje de programación

Python

Node.js

Java

Maven con BOM

Maven sin BOM

Gradle sin BOM

Go

Desplegar Gemma con Model Garden

Inferir Gemma 2B con PredictionServiceClient

Parámetros de código

Consola

gcloud

Código de muestra

Python

Node.js

Java

Go

Limpieza

Eliminar el proyecto

Eliminar recursos concretos

Anular el despliegue del modelo y eliminar el endpoint

Consola

gcloud

Eliminar el modelo

Consola

gcloud

Siguientes pasos

Desplegar y usar Gemma para inferencias con Model Garden y endpoints respaldados por TPU de Vertex AI