Desplegar un modelo con la CLI de gcloud o la API de Vertex AI

Para desplegar un modelo en un endpoint público con la CLI de gcloud o la API de Vertex AI, debes obtener el ID de un endpoint y, a continuación, desplegar el modelo en él.

Obtener el ID del endpoint

Necesitas el ID del endpoint para desplegar el modelo.

gcloud

En el siguiente ejemplo se usa el comando gcloud ai endpoints list:

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

Haz los cambios siguientes:

  • LOCATION_ID: la región en la que usas Vertex AI.
  • ENDPOINT_NAME: el nombre visible del endpoint.

Fíjate en el número que aparece en la columna ENDPOINT_ID. Úsalo en el paso siguiente.

REST

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

  • LOCATION_ID: la región en la que usas Vertex AI.
  • PROJECT_ID: tu ID de proyecto.
  • ENDPOINT_NAME: el nombre visible del endpoint.

Método HTTP y URL: 

GET https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME

Para enviar tu solicitud, despliega una de estas opciones:

Deberías recibir una respuesta JSON similar a la siguiente:

{
  "endpoints": [
    {
      "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID",
      "displayName": "ENDPOINT_NAME",
      "etag": "AMEw9yPz5pf4PwBHbRWOGh0PcAxUdjbdX2Jm3QO_amguy3DbZGP5Oi_YUKRywIE-BtLx",
      "createTime": "2020-04-17T18:31:11.585169Z",
      "updateTime": "2020-04-17T18:35:08.568959Z"
    }
  ]
}
Ten en cuenta la ENDPOINT_ID.

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.

Haz los cambios siguientes:

  • PROJECT_ID: tu ID de proyecto.
  • LOCATION_ID: la región en la que usas Vertex AI.
  • ENDPOINT_NAME: el nombre visible del endpoint. 
from google.cloud import aiplatform

PROJECT_ID = "PROJECT_ID"
LOCATION = "LOCATION_ID"
ENDPOINT_NAME = "ENDPOINT_NAME"

aiplatform.init(
    project=PROJECT_ID,
    location=LOCATION,
)

endpoint = aiplatform.Endpoint.list( filter='display_name=ENDPOINT_NAME', )
endpoint_id = endpoint.name.split("/")[-1]

Desplegar el modelo

Selecciona la pestaña correspondiente a tu idioma o entorno:

gcloud

En los siguientes ejemplos se usa el comando gcloud ai endpoints deploy-model.

En el siguiente ejemplo se implementa un Model en un Endpoint sin usar GPUs para acelerar el servicio de predicciones y sin dividir el tráfico entre varios recursos DeployedModel:

Antes de usar los datos de los comandos que se indican a continuación, haz los siguientes cambios:

  • ENDPOINT_ID: ID del endpoint.
  • LOCATION_ID: la región en la que usas Vertex AI.
  • MODEL_ID: ID del modelo que se va a implementar.
  • DEPLOYED_MODEL_NAME: nombre del DeployedModel. También puedes usar el nombre visible de la Model para la DeployedModel.
  • MIN_REPLICA_COUNT: número mínimo de nodos de esta implementación. El número de nodos se puede aumentar o reducir según lo requiera la carga de inferencia, hasta el número máximo de nodos y nunca por debajo de este número.
  • MAX_REPLICA_COUNT: número máximo de nodos de este despliegue. El número de nodos se puede aumentar o reducir según lo requiera la carga de inferencia, hasta este número de nodos y nunca por debajo del número mínimo de nodos. Si omite la marca --max-replica-count, el número máximo de nodos se define como el valor de --min-replica-count.

Ejecuta el comando gcloud ai endpoints deploy-model:

Linux, macOS o Cloud Shell

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=100

Windows (PowerShell)

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME `
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=100

Windows (cmd.exe)

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME ^
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=100
  

Dividir el tráfico

La marca --traffic-split=0=100 de los ejemplos anteriores envía el 100% del tráfico de predicción que recibe Endpoint al nuevo DeployedModel, que se representa con el ID temporal 0. Si tu Endpoint ya tiene otros DeployedModel recursos, puedes dividir el tráfico entre los nuevos DeployedModel y los antiguos. Por ejemplo, para enviar el 20% del tráfico a la nueva DeployedModel y el 80% a una anterior, ejecuta el siguiente comando.

Antes de usar los datos de los comandos que se indican a continuación, haz los siguientes cambios:

  • OLD_DEPLOYED_MODEL_ID: el ID del DeployedModel.

Ejecuta el comando gcloud ai endpoints deploy-model:

Linux, macOS o Cloud Shell

gcloud ai endpoints deploy-model ENDPOINT_ID\
  --region=LOCATION_ID \
  --model=MODEL_ID \
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT \
  --max-replica-count=MAX_REPLICA_COUNT \
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (PowerShell)

gcloud ai endpoints deploy-model ENDPOINT_ID`
  --region=LOCATION_ID `
  --model=MODEL_ID `
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT `
  --max-replica-count=MAX_REPLICA_COUNT `
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80

Windows (cmd.exe)

gcloud ai endpoints deploy-model ENDPOINT_ID^
  --region=LOCATION_ID ^
  --model=MODEL_ID ^
  --display-name=DEPLOYED_MODEL_NAME \ 
  --min-replica-count=MIN_REPLICA_COUNT ^
  --max-replica-count=MAX_REPLICA_COUNT ^
  --traffic-split=0=20,OLD_DEPLOYED_MODEL_ID=80
  

REST

Despliega el modelo.

Antes de usar los datos de la solicitud, haz las siguientes sustituciones:

  • LOCATION_ID: la región en la que usas Vertex AI.
  • PROJECT_ID: tu ID de proyecto.
  • ENDPOINT_ID: ID del endpoint.
  • MODEL_ID: ID del modelo que se va a implementar.
  • DEPLOYED_MODEL_NAME: nombre del DeployedModel. También puedes usar el nombre visible de la Model para la DeployedModel.
  • MACHINE_TYPE: opcional. Los recursos de la máquina que se usan en cada nodo de esta implementación. Su ajuste predeterminado es n1-standard-2. Más información sobre los tipos de máquinas
  • ACCELERATOR_TYPE: tipo de acelerador que se va a asociar a la máquina. Opcional si ACCELERATOR_COUNT no se especifica o es cero. No se recomienda para modelos de AutoML ni modelos entrenados personalizados que usen imágenes que no sean de GPU. Más información
  • ACCELERATOR_COUNT: número de aceleradores que debe usar cada réplica. Opcional. Debe ser cero o no especificarse en los modelos de AutoML o en los modelos entrenados personalizados que usen imágenes que no sean de GPU.
  • MIN_REPLICA_COUNT: número mínimo de nodos de esta implementación. El número de nodos se puede aumentar o reducir según lo requiera la carga de inferencia, hasta el número máximo de nodos y nunca por debajo de este número. Este valor debe ser superior o igual a 1.
  • MAX_REPLICA_COUNT: número máximo de nodos de este despliegue. El número de nodos se puede aumentar o reducir según lo requiera la carga de inferencia, hasta este número de nodos y nunca por debajo del número mínimo de nodos.
  • REQUIRED_REPLICA_COUNT: opcional. Número de nodos necesarios para que esta implementación se marque como correcta. Debe ser igual o superior a 1 e igual o inferior al número mínimo de nodos. Si no se especifica, el valor predeterminado es el número mínimo de nodos.
  • TRAFFIC_SPLIT_THIS_MODEL: porcentaje del tráfico de predicción de este punto final que se va a dirigir al modelo que se está desplegando con esta operación. El valor predeterminado es 100. Todos los porcentajes de tráfico deben sumar 100. Más información sobre las divisiones de tráfico
  • DEPLOYED_MODEL_ID_N: opcional. Si se implementan otros modelos en este endpoint, debes actualizar los porcentajes de división del tráfico para que todos los porcentajes sumen 100.
  • TRAFFIC_SPLIT_MODEL_N: valor del porcentaje de división del tráfico de la clave del ID del modelo implementado.
  • PROJECT_NUMBER: el número de proyecto generado automáticamente de tu proyecto

Método HTTP y URL: 

POST https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel

Cuerpo JSON de la solicitud: 

{
  "deployedModel": {
    "model": "projects/PROJECT/locations/us-central1/models/MODEL_ID",
    "displayName": "DEPLOYED_MODEL_NAME",
    "dedicatedResources": {
       "machineSpec": {
         "machineType": "MACHINE_TYPE",
         "acceleratorType": "ACCELERATOR_TYPE",
         "acceleratorCount": "ACCELERATOR_COUNT"
       },
       "minReplicaCount": MIN_REPLICA_COUNT,
       "maxReplicaCount": MAX_REPLICA_COUNT,
       "requiredReplicaCount": REQUIRED_REPLICA_COUNT
     },
  },
  "trafficSplit": {
    "0": TRAFFIC_SPLIT_THIS_MODEL,
    "DEPLOYED_MODEL_ID_1": TRAFFIC_SPLIT_MODEL_1,
    "DEPLOYED_MODEL_ID_2": TRAFFIC_SPLIT_MODEL_2
  },
}

Para enviar tu solicitud, despliega una de estas opciones:

Deberías recibir una respuesta JSON similar a la siguiente:

{
  "name": "projects/PROJECT_ID/locations/LOCATION/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.DeployModelOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-10-19T17:53:16.502088Z",
      "updateTime": "2020-10-19T17:53:16.502088Z"
    }
  }
}

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.

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. 

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.DedicatedResources;
import com.google.cloud.aiplatform.v1.DeployModelOperationMetadata;
import com.google.cloud.aiplatform.v1.DeployModelResponse;
import com.google.cloud.aiplatform.v1.DeployedModel;
import com.google.cloud.aiplatform.v1.EndpointName;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.MachineSpec;
import com.google.cloud.aiplatform.v1.ModelName;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;

public class DeployModelCustomTrainedModelSample {

  public static void main(String[] args)
      throws IOException, ExecutionException, InterruptedException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "PROJECT";
    String endpointId = "ENDPOINT_ID";
    String modelName = "MODEL_NAME";
    String deployedModelDisplayName = "DEPLOYED_MODEL_DISPLAY_NAME";
    deployModelCustomTrainedModelSample(project, endpointId, modelName, deployedModelDisplayName);
  }

  static void deployModelCustomTrainedModelSample(
      String project, String endpointId, String model, String deployedModelDisplayName)
      throws IOException, ExecutionException, InterruptedException {
    EndpointServiceSettings settings =
        EndpointServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();
    String location = "us-central1";

    // Initialize client that will be used to send requests. This client only needs to be created
    // once, and can be reused for multiple requests. After completing all of your requests, call
    // the "close" method on the client to safely clean up any remaining background resources.
    try (EndpointServiceClient client = EndpointServiceClient.create(settings)) {
      MachineSpec machineSpec = MachineSpec.newBuilder().setMachineType("n1-standard-2").build();
      DedicatedResources dedicatedResources =
          DedicatedResources.newBuilder().setMinReplicaCount(1).setMachineSpec(machineSpec).build();

      String modelName = ModelName.of(project, location, model).toString();
      DeployedModel deployedModel =
          DeployedModel.newBuilder()
              .setModel(modelName)
              .setDisplayName(deployedModelDisplayName)
              // `dedicated_resources` must be used for non-AutoML models
              .setDedicatedResources(dedicatedResources)
              .build();
      // key '0' assigns traffic for the newly deployed model
      // Traffic percentage values must add up to 100
      // Leave dictionary empty if endpoint should not accept any traffic
      Map<String, Integer> trafficSplit = new HashMap<>();
      trafficSplit.put("0", 100);
      EndpointName endpoint = EndpointName.of(project, location, endpointId);
      OperationFuture<DeployModelResponse, DeployModelOperationMetadata> response =
          client.deployModelAsync(endpoint, deployedModel, trafficSplit);

      // You can use OperationFuture.getInitialFuture to get a future representing the initial
      // response to the request, which contains information while the operation is in progress.
      System.out.format("Operation name: %s\n", response.getInitialFuture().get().getName());

      // OperationFuture.get() will block until the operation is finished.
      DeployModelResponse deployModelResponse = response.get();
      System.out.format("deployModelResponse: %s\n", deployModelResponse);
    }
  }
}

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. 

def deploy_model_with_dedicated_resources_sample(
    project,
    location,
    model_name: str,
    machine_type: str,
    endpoint: Optional[aiplatform.Endpoint] = None,
    deployed_model_display_name: Optional[str] = None,
    traffic_percentage: Optional[int] = 0,
    traffic_split: Optional[Dict[str, int]] = None,
    min_replica_count: int = 1,
    max_replica_count: int = 1,
    accelerator_type: Optional[str] = None,
    accelerator_count: Optional[int] = None,
    explanation_metadata: Optional[explain.ExplanationMetadata] = None,
    explanation_parameters: Optional[explain.ExplanationParameters] = None,
    metadata: Optional[Sequence[Tuple[str, str]]] = (),
    sync: bool = True,
):
    """
    model_name: A fully-qualified model resource name or model ID.
          Example: "projects/123/locations/us-central1/models/456" or
          "456" when project and location are initialized or passed.
    """

    aiplatform.init(project=project, location=location)

    model = aiplatform.Model(model_name=model_name)

    # The explanation_metadata and explanation_parameters should only be
    # provided for a custom trained model and not an AutoML model.
    model.deploy(
        endpoint=endpoint,
        deployed_model_display_name=deployed_model_display_name,
        traffic_percentage=traffic_percentage,
        traffic_split=traffic_split,
        machine_type=machine_type,
        min_replica_count=min_replica_count,
        max_replica_count=max_replica_count,
        accelerator_type=accelerator_type,
        accelerator_count=accelerator_count,
        explanation_metadata=explanation_metadata,
        explanation_parameters=explanation_parameters,
        metadata=metadata,
        sync=sync,
    )

    model.wait()

    print(model.display_name)
    print(model.resource_name)
    return model

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. 

const automl = require('@google-cloud/automl');
const client = new automl.v1beta1.AutoMlClient();

/**
 * Demonstrates using the AutoML client to create a model.
 * TODO(developer): Uncomment the following lines before running the sample.
 */
// const projectId = '[PROJECT_ID]' e.g., "my-gcloud-project";
// const computeRegion = '[REGION_NAME]' e.g., "us-central1";
// const datasetId = '[DATASET_ID]' e.g., "TBL2246891593778855936";
// const tableId = '[TABLE_ID]' e.g., "1991013247762825216";
// const columnId = '[COLUMN_ID]' e.g., "773141392279994368";
// const modelName = '[MODEL_NAME]' e.g., "testModel";
// const trainBudget = '[TRAIN_BUDGET]' e.g., "1000",
// `Train budget in milli node hours`;

// A resource that represents Google Cloud Platform location.
const projectLocation = client.locationPath(projectId, computeRegion);

// Get the full path of the column.
const columnSpecId = client.columnSpecPath(
  projectId,
  computeRegion,
  datasetId,
  tableId,
  columnId
);

// Set target column to train the model.
const targetColumnSpec = {name: columnSpecId};

// Set tables model metadata.
const tablesModelMetadata = {
  targetColumnSpec: targetColumnSpec,
  trainBudgetMilliNodeHours: trainBudget,
};

// Set datasetId, model name and model metadata for the dataset.
const myModel = {
  datasetId: datasetId,
  displayName: modelName,
  tablesModelMetadata: tablesModelMetadata,
};

// Create a model with the model metadata in the region.
client
  .createModel({parent: projectLocation, model: myModel})
  .then(responses => {
    const initialApiResponse = responses[1];
    console.log(`Training operation name: ${initialApiResponse.name}`);
    console.log('Training started...');
  })
  .catch(err => {
    console.error(err);
  });

Consulta cómo cambiar la configuración predeterminada del registro de inferencias.

Obtener el estado de la operación

Algunas solicitudes inician operaciones de larga duración que requieren tiempo para completarse. Estas solicitudes devuelven un nombre de operación que puedes usar para ver el estado de la operación o cancelarla. Vertex AI proporciona métodos auxiliares para hacer llamadas a operaciones de larga duración. Para obtener más información, consulta Trabajar con operaciones de larga duración.

Siguientes pasos