Implementa y realiza inferencias de Gemma con Model Garden y extremos compatibles con GPU de Vertex AI

En este instructivo, usarás Model Garden para implementar el modelo abierto Gemma 2B en un extremo de Vertex AI respaldado por GPU. Debes implementar un modelo en un extremo antes de que se pueda usar para entregar predicciones en línea. La implementación de un modelo asocia recursos físicos con el modelo para que pueda entregar predicciones en línea con baja latencia.

Después de implementar el modelo Gemma 2B, infieres el modelo entrenado con PredictionServiceClient para obtener predicciones en línea. Las predicciones en línea son solicitudes síncronas realizadas en un modelo que se implementa en un extremo.

Objetivos

En este instructivo, se muestra cómo completar las siguientes tareas:

  • Usa Model Garden para implementar el modelo abierto Gemma 2B en un extremo con copia de seguridad de GPU
  • Usa PredictionServiceClient para obtener predicciones en línea

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

Para realizar este instructivo, debes hacer lo siguiente:

  • Configura un proyecto de Google Cloud y habilita la API de Vertex AI
  • En tu máquina local, haz lo siguiente:
    • Instala, inicializa y autentica con Google Cloud CLI
    • Instala el SDK para tu idioma

Configura un proyecto de Google Cloud

Configura tu proyecto de Google Cloud y habilita la API de 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.

Configura la CLI de Google Cloud

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

  1. Instala y, luego, inicializa Google Cloud CLI.

  2. Si ya instalaste gcloud CLI, ejecuta este comando para asegurarte de que los componentes de gcloud estén actualizados.

    gcloud components update

  3. Para autenticarte con gcloud CLI, ejecuta este comando para generar un archivo local de credenciales predeterminadas de la aplicación (ADC). El flujo web que inicia el comando se usa para proporcionar tus credenciales de usuario.

    gcloud auth application-default login

    Para obtener más información, consulta Configuración de autenticación de gcloud CLI y configuración de ADC.

Configura el SDK para tu lenguaje de programación

Para configurar el entorno que se usa en este instructivo, debes instalar el SDK de Vertex AI para tu lenguaje y la biblioteca de Protocol Buffers. Las muestras de código usan funciones de la biblioteca de 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 para tu lenguaje de programación.

  • Ejecuta este comando para instalar y actualizar el SDK de Vertex AI para Python.

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

  • Ejecuta este comando para instalar la biblioteca de Protocol Buffers para Python.

    pip3 install --upgrade "profobuf>=5.28"

Node.js

Ejecuta el siguiente comando para instalar o actualizar el SDK de aiplatform para Node.js:

npm install @google-cloud/aiplatform

Java

Para agregar google-cloud-aiplatform como dependencia, agrega el código apropiado para tu entorno.

Maven con BOM

Agrega 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

Agrega 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

Agrega lo siguiente a tu build.gradle:

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

Go

Ejecuta los siguientes comandos para instalar estos paquetes de Go.

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

Implementa Gemma con Model Garden

Implementas el modelo Gemma 2B en un tipo de máquina optimizado para aceleradores de Compute Engine g2-standard-12. Esta máquina tiene un acelerador de GPU NVIDIA L4 conectado.

En este instructivo, implementarás el modelo abierto Gemma 2B ajustado por instrucciones con la tarjeta de modelo en Model Garden. La versión específica del modelo es gemma2-2b-it. -it significa ajuste de instrucciones.

El modelo Gemma 2B tiene un tamaño de parámetro más bajo, lo que significa que tiene requisitos de recursos más bajos y más flexibilidad de implementación.

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

    Ir a Model Garden

  2. Haz clic en la tarjeta de modelo Gemma 2.

    Ir a Gemma 2

  3. Haz clic en Implementar para abrir el panel Implementar modelo.

  4. En el panel Deploy model, especifica estos detalles.

    1. En Entorno de implementación, haz clic en Vertex AI.

    2. En la sección Implementar modelo, haz lo siguiente:

      1. En ID del recurso, elige gemma-2b-it.

      2. Para Nombre del modelo y Nombre del extremo, acepta los valores predeterminados. Por ejemplo:

        • Nombre del modelo: gemma2-2b-it-1234567891234
        • Nombre del extremo: gemma2-2b-it-mg-one-click-deploy

        Toma nota del nombre del extremo. La necesitarás para encontrar el ID de extremo que se usa en las muestras de código.

    3. En la sección Configuración de la implementación, haz lo siguiente:

      1. Acepta la opción predeterminada para la configuración Básica.

      2. En Región, acepta el valor predeterminado o elige una región de la lista. Anota la región. La necesitarás para los ejemplos de código.

      3. En Especificaciones de la máquina, elige la instancia con copia de seguridad de GPU: 1 NVIDIA_L4 g2-standard-12.

  5. Haz clic en Implementar. Cuando finalice la implementación, recibirás un correo electrónico con detalles sobre tu nuevo extremo. También puedes ver los detalles del extremo haciendo clic en Predicción en línea > Extremos y seleccionando tu región.

    Ir a Endpoints

Inferencia de Gemma 2B con PredictionServiceClient

Después de implementar Gemma 2B, usa PredictionServiceClient para obtener predicciones en línea para la instrucción: "¿Por qué el cielo es azul?".

Parámetros de código

Las muestras de código de PredictionServiceClient requieren que actualices lo siguiente.

  • PROJECT_ID: Para encontrar el ID de tu proyecto, sigue estos pasos.

    1. Ve a la página Bienvenida en la consola de Google Cloud.

      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 Te damos la bienvenida.

  • ENDPOINT_REGION: Es la región en la que implementaste el extremo.

  • ENDPOINT_ID: Para encontrar el ID de tu extremo, búscalo en la consola o ejecuta el comando gcloud ai endpoints list. Necesitarás el nombre y la región del extremo del panel Implementar modelo.

    Console

    Para ver los detalles del extremo, haz clic en Predicción en línea > extremos y selecciona tu región. Toma nota del número que aparece en la columna ID.

    Ir a Endpoints

    gcloud

    Para ver los detalles del extremo, ejecuta el comando gcloud ai endpoints list.

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

    El resultado se verá de la siguiente manera.

    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 muestra de tu idioma, actualiza PROJECT_ID, ENDPOINT_REGION y ENDPOINT_ID. Luego, ejecuta tu código.

Python

Si deseas obtener información para instalar o actualizar el SDK de Vertex AI para Python, consulta Instala el SDK de Vertex AI para Python. Si deseas obtener más información, consulta la documentación de referencia de la API de Python. 

"""
Sample to run inference on a Gemma2 model deployed to a Vertex AI endpoint with GPU 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 GPUs
# Example format: [{'inputs': 'Why is the sky blue?', 'parameters': {'temperature': 0.9}}]
input = {"inputs": prompt, "parameters": 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 instrucciones de configuración para Node.js incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Node.js.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

async function gemma2PredictGpu(predictionServiceClient) {
  // 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';

  // Default configuration
  const config = {maxOutputTokens: 1024, temperature: 0.9, topP: 1.0, topK: 1};
  // Prompt used in the prediction
  const prompt = 'Why is the sky blue?';

  // Encapsulate the prompt in a correct format for GPUs
  // Example format: [{inputs: 'Why is the sky blue?', parameters: {temperature: 0.9}}]
  const input = {
    inputs: prompt,
    parameters: config,
  };

  // 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);
  return text;
}

module.exports = gemma2PredictGpu;

// TODO(developer): Uncomment below lines before running the sample.
// gemma2PredictGpu(...process.argv.slice(2)).catch(err => {
//   console.error(err.message);
//   process.exitCode = 1;
// });

Java

Antes de probar este ejemplo, sigue las instrucciones de configuración para Java incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Java.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo 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 Gemma2PredictGpu {

  private final PredictionServiceClient predictionServiceClient;

  // Constructor to inject the PredictionServiceClient
  public Gemma2PredictGpu(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-east4";
    String endpointId = "YOUR_ENDPOINT_ID";

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

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

  // Demonstrates how to run inference on a Gemma2 model
  // deployed to a Vertex AI endpoint with GPU accelerators.
  public String gemma2PredictGpu(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 = "{ \"inputs\": \"Why is the sky blue?\"}";
    Value.Builder instanceValue = Value.newBuilder();
    JsonFormat.parser().merge(instance, instanceValue);
    // Encapsulate the prompt in a correct format for GPUs
    // Example format: [{'inputs': 'Why is the sky blue?', 'parameters': {'temperature': 0.8}}]
    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 probar este ejemplo, sigue las instrucciones de configuración para Go incluidas en la guía de inicio rápido de Vertex AI sobre cómo usar bibliotecas cliente. Para obtener más información, consulta la documentación de referencia de la API de Vertex AI Go.

Para autenticarte en Vertex AI, configura las credenciales predeterminadas de la aplicación. Si deseas obtener más información, consulta Configura la autenticación para un entorno de desarrollo local. 

import (
	"context"
	"fmt"
	"io"

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

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

// predictGPU demonstrates how to run interference on a Gemma2 model deployed to a Vertex AI endpoint with GPU accelerators.
func predictGPU(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.
	// Pay attention that prompt should be set in "inputs" field.
	// Example format: [{'inputs': 'Why is the sky blue?', 'parameters': {'temperature': 0.9}}]
	promptValue, err := structpb.NewValue(map[string]interface{}{
		"inputs":     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
}

Realiza una limpieza

Para evitar que se apliquen cargos a tu cuenta de Google Cloud por los recursos usados en este instructivo, borra el proyecto que contiene los recursos o conserva el proyecto y borra los recursos individuales.

Borra el proyecto

  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.

Borra los recursos individuales

Si conservas tu proyecto, borra los recursos que se usaron en este instructivo:

  • Anula la implementación del modelo y borra el extremo
  • Borra el modelo de Model Registry

Anula la implementación del modelo y borra el extremo

Usa uno de los siguientes métodos para anular la implementación de un modelo y borrar el extremo.

Console

  1. En la consola de Google Cloud, haz clic en Predicción en línea y, luego, haz clic en Extremos.

    Ir a la página Estremos

  2. En la lista desplegable Región, elige la región en la que implementaste tu extremo.

  3. Haz clic en el nombre del extremo para abrir la página de detalles. Por ejemplo: gemma2-2b-it-mg-one-click-deploy

  4. En la fila del modelo Gemma 2 (Version 1), haz clic en Acciones y, luego, en Anular la implementación del modelo en el extremo.

  5. En el cuadro de diálogo Anular la implementación del modelo desde el extremo, haz clic en Anular la implementación.

  6. Haz clic en el botón Atrás para volver a la página Extremos.

    Ir a la página Estremos

  7. Al final de la fila gemma2-2b-it-mg-one-click-deploy, haz clic en Acciones y, luego, selecciona Borrar extremo.

  8. En el mensaje de confirmación, haz clic en Confirmar.

gcloud

Para anular la implementación del modelo y borrar el extremo con Google Cloud CLI, sigue estos pasos.

En estos comandos, reemplaza lo siguiente:

  • PROJECT_ID por el nombre del proyecto
  • LOCATION_ID por la región en la que implementaste el modelo y el extremo
  • ENDPOINT_ID por el ID del extremo
  • DEPLOYED_MODEL_NAME con el nombre visible del modelo
  • DEPLOYED_MODEL_ID por el ID del modelo

  1. Ejecuta el comando gcloud ai endpoints list para obtener el ID del extremo. Este comando enumera los IDs de los extremos de todos los extremos de tu proyecto. Anota el ID del extremo que se usa en este instructivo.

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

    El resultado se verá de la siguiente manera. 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

  2. Para obtener el ID del modelo, ejecuta el comando gcloud ai models describe. Anota el ID del modelo que implementaste en este instructivo.

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

    El resultado abreviado se ve de la siguiente manera. 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
...

  3. Anula la implementación del modelo desde el extremo. Necesitarás el ID del extremo y el ID del 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 produce resultados.

  4. Ejecuta el comando gcloud ai endpoints delete para borrar el extremo.

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

    Cuando se te solicite, escribe y para confirmar. Este comando no produce resultados.

Borra el modelo

Console

  1. Ve a la página Model Registry desde la sección Vertex AI en la consola de Google Cloud.

    Ir a la página Model Registry

  2. En la lista desplegable Región, elige la región en la que implementaste tu modelo.

  3. Al final de la fila gemma2-2b-it-1234567891234, haz clic en Acciones.

  4. Selecciona Borrar modelo.

    Cuando borras el modelo, todas las versiones y evaluaciones de modelo asociadas se borran de tu proyecto de Google Cloud.

  5. En el mensaje de confirmación, haz clic en Borrar.

gcloud

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

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

Reemplaza DEPLOYED_MODEL_NAME por el nombre visible del modelo. Reemplaza PROJECT_ID por el nombre de tu proyecto. Reemplaza LOCATION_ID por la región en la que implementaste el modelo.

¿Qué sigue?