Implementar un modelo en un extremo

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.

Para que se pueda implementar, el modelo debe ser visible en Vertex AI Model Registry. Para obtener información acerca de Model Registry, incluido cómo importar artefactos del modelo o crearlos directamente en Model Registry, consulta Introducción a Vertex AI Model Registry.

Puedes implementar varios modelos en un extremo o puedes implementar el mismo modelo en varios extremos. Si deseas obtener más información acerca de las opciones y los casos de uso para implementar modelos, consulta Motivos para implementar más de un modelo en el mismo extremo.

Implementar un modelo en un extremo

Usa uno de los siguientes métodos para implementar un modelo:

gcloud ai endpoints create \
  --region=LOCATION_ID \
  --display-name=ENDPOINT_NAME

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

{
  "display_name": "ENDPOINT_NAME"
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints" | Select-Object -Expand Content

{
  "name": "projects/PROJECT_NUMBER/locations/LOCATION_ID/endpoints/ENDPOINT_ID/operations/OPERATION_ID",
  "metadata": {
    "@type": "type.googleapis.com/google.cloud.aiplatform.v1.CreateEndpointOperationMetadata",
    "genericMetadata": {
      "createTime": "2020-11-05T17:45:42.812656Z",
      "updateTime": "2020-11-05T17:45:42.812656Z"
    }
  }
}

# Endpoint name must be unique for the project
resource "random_id" "endpoint_id" {
  byte_length = 4
}

resource "google_vertex_ai_endpoint" "default" {
  name         = substr(random_id.endpoint_id.dec, 0, 10)
  display_name = "sample-endpoint"
  description  = "A sample Vertex AI endpoint"
  location     = "us-central1"
  labels = {
    label-one = "value-one"
  }
}

import com.google.api.gax.longrunning.OperationFuture;
import com.google.cloud.aiplatform.v1.CreateEndpointOperationMetadata;
import com.google.cloud.aiplatform.v1.Endpoint;
import com.google.cloud.aiplatform.v1.EndpointServiceClient;
import com.google.cloud.aiplatform.v1.EndpointServiceSettings;
import com.google.cloud.aiplatform.v1.LocationName;
import java.io.IOException;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;

public class CreateEndpointSample {

  public static void main(String[] args)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    // TODO(developer): Replace these variables before running the sample.
    String project = "YOUR_PROJECT_ID";
    String endpointDisplayName = "YOUR_ENDPOINT_DISPLAY_NAME";
    createEndpointSample(project, endpointDisplayName);
  }

  static void createEndpointSample(String project, String endpointDisplayName)
      throws IOException, InterruptedException, ExecutionException, TimeoutException {
    EndpointServiceSettings endpointServiceSettings =
        EndpointServiceSettings.newBuilder()
            .setEndpoint("us-central1-aiplatform.googleapis.com:443")
            .build();

    // 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 endpointServiceClient =
        EndpointServiceClient.create(endpointServiceSettings)) {
      String location = "us-central1";
      LocationName locationName = LocationName.of(project, location);
      Endpoint endpoint = Endpoint.newBuilder().setDisplayName(endpointDisplayName).build();

      OperationFuture<Endpoint, CreateEndpointOperationMetadata> endpointFuture =
          endpointServiceClient.createEndpointAsync(locationName, endpoint);
      System.out.format("Operation name: %s\n", endpointFuture.getInitialFuture().get().getName());
      System.out.println("Waiting for operation to finish...");
      Endpoint endpointResponse = endpointFuture.get(300, TimeUnit.SECONDS);

      System.out.println("Create Endpoint Response");
      System.out.format("Name: %s\n", endpointResponse.getName());
      System.out.format("Display Name: %s\n", endpointResponse.getDisplayName());
      System.out.format("Description: %s\n", endpointResponse.getDescription());
      System.out.format("Labels: %s\n", endpointResponse.getLabelsMap());
      System.out.format("Create Time: %s\n", endpointResponse.getCreateTime());
      System.out.format("Update Time: %s\n", endpointResponse.getUpdateTime());
    }
  }
}

/**
 * TODO(developer): Uncomment these variables before running the sample.\
 * (Not necessary if passing values as arguments)
 */

// const endpointDisplayName = 'YOUR_ENDPOINT_DISPLAY_NAME';
// const project = 'YOUR_PROJECT_ID';
// const location = 'YOUR_PROJECT_LOCATION';

// Imports the Google Cloud Endpoint Service Client library
const {EndpointServiceClient} = require('@google-cloud/aiplatform');

// Specifies the location of the api endpoint
const clientOptions = {
  apiEndpoint: 'us-central1-aiplatform.googleapis.com',
};

// Instantiates a client
const endpointServiceClient = new EndpointServiceClient(clientOptions);

async function createEndpoint() {
  // Configure the parent resource
  const parent = `projects/${project}/locations/${location}`;
  const endpoint = {
    displayName: endpointDisplayName,
  };
  const request = {
    parent,
    endpoint,
  };

  // Get and print out a list of all the endpoints for this resource
  const [response] = await endpointServiceClient.createEndpoint(request);
  console.log(`Long running operation : ${response.name}`);

  // Wait for operation to complete
  await response.promise();
  const result = response.result;

  console.log('Create endpoint response');
  console.log(`\tName : ${result.name}`);
  console.log(`\tDisplay name : ${result.displayName}`);
  console.log(`\tDescription : ${result.description}`);
  console.log(`\tLabels : ${JSON.stringify(result.labels)}`);
  console.log(`\tCreate time : ${JSON.stringify(result.createTime)}`);
  console.log(`\tUpdate time : ${JSON.stringify(result.updateTime)}`);
}
createEndpoint();

def create_endpoint_sample(
    project: str,
    display_name: str,
    location: str,
):
    aiplatform.init(project=project, location=location)

    endpoint = aiplatform.Endpoint.create(
        display_name=display_name,
        project=project,
        location=location,
    )

    print(endpoint.display_name)
    print(endpoint.resource_name)
    return endpoint

curl -X POST \
-H "Authorization: Bearer $(gcloud auth print-access-token)" \
-H "Content-Type: application/json" \
-d '{"display_name": "ENDPOINT_NAME", "dedicatedEndpointEnabled": true}' \
https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints

endpoint = aiplatform.Endpoint.create(
  display_name="ENDPOINT_NAME",
  dedicated_endpoint_enabled=True,
)

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

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

curl -X GET \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method GET `
    -Headers $headers `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints?filter=display_name=ENDPOINT_NAME" | Select-Object -Expand Content

{
  "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"
    }
  ]
}

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

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

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

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

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

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

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

{
  "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
     },
  },
  "trafficSplit": {
    "0": TRAFFIC_SPLIT_THIS_MODEL,
    "DEPLOYED_MODEL_ID_1": TRAFFIC_SPLIT_MODEL_1,
    "DEPLOYED_MODEL_ID_2": TRAFFIC_SPLIT_MODEL_2
  },
}

curl -X POST \
     -H "Authorization: Bearer $(gcloud auth print-access-token)" \
     -H "Content-Type: application/json; charset=utf-8" \
     -d @request.json \
     "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel"

$cred = gcloud auth print-access-token
$headers = @{ "Authorization" = "Bearer $cred" }

Invoke-WebRequest `
    -Method POST `
    -Headers $headers `
    -ContentType: "application/json; charset=utf-8" `
    -InFile request.json `
    -Uri "https://LOCATION_ID-aiplatform.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel" | Select-Object -Expand Content

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

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);
    }
  }
}

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

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);
  });

Limitaciones

• Si tienes habilitados los Controles del servicio de VPC, el contenedor de tu modelo implementado no tendrá acceso a Internet.

Configura la implementación del modelo

Durante la implementación del modelo, toma las siguientes decisiones importantes sobre cómo ejecutar la predicción en línea:

No puedes actualizar esta configuración que se muestra después de la creación inicial del modelo o extremo, y no puedes anularlos en la solicitud de predicción en línea. Si necesitas cambiar esta configuración, debes volver a implementar tu modelo.

Qué sucede cuando implementas un modelo

Cuando implementas un modelo en un extremo, asocias recursos físicos (máquinas) con ese modelo para que pueda entregar predicciones en línea. Las predicciones en línea tienen requisitos de baja latencia. Proporcionar recursos al modelo con anticipación reduce la latencia.

El tipo de capacitación del modelo (AutoML o personalizado) y el tipo de datos (AutoML) determinan los tipos de recursos físicos disponibles para el modelo. Después de implementar el modelo, puedes mutate algunos de esos recursos sin crear una implementación nueva.

El recurso de extremo proporciona el extremo del servicio (URL) que usas para solicitar la predicción. Por ejemplo:

https://us-central1-aiplatform.googleapis.com/v1/projects/{project}/locations/{location}/endpoints/{endpoint}:predict

Razones para implementar más de un modelo en el mismo extremo

Implementar dos modelos en el mismo extremo te permite reemplazar de forma gradual un modelo por el otro. Por ejemplo, supongamos que usas un modelo y encuentras una manera de aumentar la exactitud de ese modelo con datos de capacitación nuevos. Sin embargo, no quieres actualizar tu aplicación para que apunte a una URL de extremo nueva y tampoco deseas crear cambios repentinos en la aplicación. Puedes agregar el modelo nuevo al mismo extremo, que entrega un pequeño porcentaje de tráfico, y aumentar de forma gradual la división del tráfico del modelo nuevo hasta que entregue el 100% del tráfico.

Debido a que los recursos están asociados con el modelo en lugar del extremo, puedes implementar modelos de diferentes tipos en el mismo extremo. Sin embargo, la práctica recomendada es implementar modelos de un tipo específico (por ejemplo, tabular de AutoML, entrenado de forma personalizada) en un extremo. Esta configuración es más fácil de administrar.

Motivos para implementar un modelo en más de un extremo

Es posible que desees implementar tus modelos con diferentes recursos para diferentes entornos de aplicaciones, como pruebas y producción. Es posible que también quieras admitir diferentes SLO para tus solicitudes de predicción. Quizás una de tus aplicaciones necesite un rendimiento mucho más alto que las otras. En este caso, puedes implementar ese modelo en un extremo de mayor rendimiento con más recursos de máquina. Para optimizar los costos, también puedes implementar el modelo en un extremo de menor rendimiento con menos recursos de máquina.

Comportamiento del escalamiento

Cuando implementas un modelo para la predicción en línea como DeployedModel, puedes configurar nodos de predicción para que se escalen automáticamente. Para ello, configura dedicatedResources.maxReplicaCount con un valor mayor que dedicatedResources.minReplicaCount.

Cuando configuras un DeployedModel, debes configurar dedicatedResources.minReplicaCount en, como mínimo, 1. En otras palabras, no puedes configurar DeployedModel para escalar a 0 nodos de predicción cuando no se usa.

Uso y configuración de destino

De forma predeterminada, si implementas un modelo sin recursos de GPU dedicados, Vertex AI aumentará o disminuirá la escala de la cantidad de réplicas de forma automática para que el uso de CPU coincida con el valor objetivo predeterminado del 60%.

De forma predeterminada, si implementas un modelo con recursos de GPU dedicados (si machineSpec.accelerator_count es superior a 0), Vertex AI escalará vertical y horizontalmente la cantidad de réplicas automáticamente para que el uso de CPU o GPU, el que sea más alto, coincida con el valor objetivo predeterminado del 60%. Por lo tanto, si la capacidad de procesamiento de tu predicción causa un uso elevado de GPU, pero no un uso elevado de CPU, Vertex AI escalará de forma vertical y el uso de CPU será muy bajo, lo que será visible en la supervisión. Por el contrario, si tu contenedor personalizado tiene poco uso de la GPU, pero tiene un proceso no relacionado que aumenta el uso de CPU por encima del 60%, Vertex AI escalará verticalmente, incluso si esto no fue necesario para lograr los objetivos de QPS y latencia.

Puedes anular la métrica y el objetivo de límite predeterminados si especificas autoscalingMetricSpecs. Ten en cuenta que, si tu implementación está configurada para escalar solo según el uso de CPU, no se escalará de forma vertical, incluso si el uso de GPU es alto.

Administra el uso de recursos

Puedes supervisar tu extremo para hacer un seguimiento de las métricas, como el uso de CPU y acelerador, la cantidad de solicitudes, la latencia y la cantidad actual y objetivo de réplicas. Esta información puede ayudarte a comprender el uso de los recursos de tu extremo y el comportamiento del escalamiento.

Ten en cuenta que cada réplica ejecuta solo un contenedor. Esto significa que si un contenedor de predicción no puede usar por completo el recurso de procesamiento elegido, como un solo código de subproceso para una máquina de varios núcleos o un modelo personalizado que llame a otro servicio como parte de la predicción, es posible que tus nodos no se escalen de forma vertical.

Por ejemplo, si usas FastAPI o cualquier servidor de modelos que tenga una cantidad configurable de trabajadores o subprocesos, existen muchos casos en los que tener más de un trabajador puede aumentar el uso de recursos, lo que mejora la capacidad del servicio para escalar de forma automática la cantidad de réplicas.

Por lo general, recomendamos empezar con un trabajador o subproceso por núcleo. Si notas que el uso de CPU es bajo, en especial con una carga alta o tu modelo no escala de forma vertical porque el uso de CPU es bajo, aumenta la cantidad de trabajadores. Por otro lado, si notas que el uso es demasiado alto y las latencias aumentan más de lo esperado con la carga, intenta usar menos trabajadores. Si ya usas un solo trabajador, intenta usar un tipo de máquina más pequeño.

Comportamiento y retraso del escalamiento

Vertex AI ajusta la cantidad de réplicas cada 15 segundos mediante los datos de la ventana de 5 minutos anteriores. Para cada ciclo de 15 segundos, el sistema mide el uso del servidor y genera una cantidad objetivo de réplicas según la siguiente fórmula:

target # of replicas = Ceil(current # of replicas * (current utilization / target utilization))

Por ejemplo, si tienes dos réplicas que se usan al 100%, el objetivo es 4:

4 = Ceil(3.33) = Ceil(2 * (100% / 60%))

Otro ejemplo, si tienes 10 réplicas y el uso disminuye al 1%, el objetivo es 1:

1 = Ceil(.167) = Ceil(10 * (1% / 60%))

Al final de cada ciclo de 15 segundos, el sistema ajusta la cantidad de réplicas para que coincida con el valor objetivo más alto de la ventana anterior de 5 minutos. Ten en cuenta que, como se elige el valor objetivo más alto, tu extremo no reducirá la escala verticalmente si hay un aumento en el uso durante ese período de 5 minutos, incluso si el uso general es muy bajo. Por otro lado, si el sistema necesita escalar de forma vertical, lo hará en un plazo de 15 segundos, ya que se elige el valor objetivo más alto en lugar del promedio.

Ten en cuenta que, incluso después de que Vertex AI ajuste la cantidad de réplicas, el inicio o el apagado de las réplicas lleva tiempo. Por lo tanto, hay un retraso adicional antes de que el extremo pueda ajustarse al tráfico. Los factores principales que contribuyen a este momento incluyen los siguientes:

• el tiempo para aprovisionar y, luego, iniciar las VMs de Compute Engine
• el tiempo para descargar el contenedor desde el registro
• el tiempo para cargar el modelo desde el almacenamiento

La mejor manera de comprender el comportamiento de escalamiento del modelo real es ejecutar una prueba de carga y optimizar las características importantes para el modelo y tu caso de uso. Si el escalador automático no escala de forma vertical lo suficientemente rápido para la aplicación, aprovisiona min_replicas suficientes para controlar el tráfico del modelo de referencia esperado.

Actualiza la configuración de escalamiento

Si especificaste DedicatedResources o AutomaticResources cuando implementaste el modelo, puedes actualizar la configuración de escalamiento sin volver a implementar el modelo mediante una llamada a mutateDeployedModel.

Por ejemplo, la siguiente solicitud actualiza max_replica y autoscaling_metric_specs y luego, inhabilita el registro de contenedores.

{
  "deployedModel": {
    "id": "2464520679043629056",
    "dedicatedResources": {
      "maxReplicaCount": 9,
      "autoscalingMetricSpecs": [
        {
          "metricName": "aiplatform.googleapis.com/prediction/online/cpu/utilization",
          "target": 50
        }
      ]
    },
    "disableContainerLogging": true
  },
  "update_mask": {
    "paths": [
      "dedicated_resources.max_replica_count",
      "dedicated_resources.autoscaling_metric_specs",
      "disable_container_logging"
    ]
  }
}

Notas de uso:

• No puedes cambiar el tipo de máquina ni cambiar de DedicatedResources a AutomaticResources o viceversa. Los únicos campos de configuración de escalamiento que puedes cambiar son min_replica, max_replica y AutoscalingMetricSpec (solo DedicatedResources).
• Debes enumerar todos los campos que necesites actualizar en updateMask. Los campos no enumerados se ignoran.
• El DeployedModel debe tener un estado DEPLOYED. Puede haber, como máximo, una operación de mutación activa por modelo implementado.
• mutateDeployedModel también te permite habilitar o inhabilitar el registro de contenedores. Para obtener más información, consulta Registro de predicciones en línea.

Anula la implementación de un modelo y borra el extremo

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

¿Qué sigue?

• Obtén más información para obtener una predicción en línea.
• Obtén más información sobre los extremos privados.