La Agent Platform asigna nodos para controlar las inferencias en línea y por lotes. Cuando implementas un modelo entrenado personalizado o un modelo de AutoML en un recurso Endpoint para entregar inferencias en línea o cuando solicitas inferencias por lotes, puedes personalizar el tipo de máquina virtual que usa el servicio de inferencia para estos nodos. De manera opcional, puedes configurar los nodos de inferencia para que usen GPUs.
Los tipos de máquinas se diferencian de varias maneras:
- Cantidad de CPU virtual por nodo
- Cantidad de memoria por nodo
- Precios
Cuando seleccionas un tipo de máquina con más recursos de procesamiento, puedes entregar inferencias con menor latencia o manejar más solicitudes de inferencia al mismo tiempo.
Administra el costo y la disponibilidad
Para ayudar a administrar los costos o garantizar la disponibilidad de los recursos de VM, Agent Platform proporciona lo siguiente:
Para asegurarte de pagar solo por los recursos de procesamiento que necesitas, puedes usar el ajuste de escala automático de Vertex AI Inference. Para obtener más información, consulta Cómo escalar nodos de inferencia para Vertex AI Inference.
Para asegurarte de que los recursos de VM estén disponibles cuando tus trabajos de inferencia los necesiten, puedes usar las reservas de Compute Engine. Las reservas proporcionan un nivel de seguridad alto a fin de obtener capacidad para los recursos zonales de Compute Engine. Para obtener más información, consulta Usa reservas con inferencia.
Para reducir el costo de ejecutar tus trabajos de inferencia, puedes usar las VMs Spot. Las VMs Spot son instancias de máquina virtual (VM) que son un excedente de capacidad de Compute Engine. Las VMs Spot tienen descuentos significativos, pero Compute Engine podría detener o borrar las VMs Spot de forma preventiva para recuperar la capacidad en cualquier momento. Para obtener más información, consulta Usa VMs Spot con inferencia.
Dónde especificar recursos de procesamiento
Inferencia en línea
Si deseas usar un modelo entrenado personalizado o un modelo tabular de AutoML para entregar inferencias en línea, debes especificar un tipo de máquina cuando implementes el recurso Model como un DeployedModel en un Endpoint. Para otros tipos de modelos de AutoML, Agent Platform configura los tipos de máquinas de forma automática.
Especifica el tipo de máquina (y, de manera opcional, la configuración de GPU) en el campo dedicatedResources.machineSpec de tu DeployedModel.
Aprende a implementar cada tipo de modelo:
- Implementa un modelo tabular de AutoML en la Google Cloud consola
- Implementa un modelo con entrenamiento personalizado en la consola de Google Cloud
- Implementa un modelo con entrenamiento personalizado con bibliotecas cliente
Inferencia por lotes
Si deseas obtener inferencias por lotes de un modelo entrenado personalizado o un modelo tabular de AutoML, debes especificar un tipo de máquina cuando crees un recurso BatchPredictionJob. Especifica el tipo de máquina (y, de manera opcional, la configuración de GPU) en el campo dedicatedResources.machineSpec de tu BatchPredictionJob.
Tipos de máquina
En las siguientes tablas, se comparan los tipos de máquinas disponibles para entregar inferencias de modelos personalizados de entrenamiento y modelos tabulares de AutoML.
Para obtener información sobre los tipos de aceleradores de TPU, consulta Implementa un modelo en VMs de Cloud TPU.
Tipos de máquinas: CPU
Serie E2
| Nombre | CPU virtuales | Memoria (GB) |
|---|---|---|
e2-standard-2 |
2 | 8 |
e2-standard-4 |
4 | 16 |
e2-standard-8 |
8 | 32 |
e2-standard-16 |
16 | 64 |
e2-standard-32 |
32 | 128 |
e2-highmem-2 |
2 | 16 |
e2-highmem-4 |
4 | 32 |
e2-highmem-8 |
8 | 64 |
e2-highmem-16 |
16 | 128 |
e2-highcpu-2 |
2 | 2 |
e2-highcpu-4 |
4 | 4 |
e2-highcpu-8 |
8 | 8 |
e2-highcpu-16 |
16 | 16 |
e2-highcpu-32 |
32 | 32 |
Serie N1
| Nombre | CPU virtuales | Memoria (GB) |
|---|---|---|
n1-standard-2 |
2 | 7.5 |
n1-standard-4 |
4 | 15 |
n1-standard-8 |
8 | 30 |
n1-standard-16 |
16 | 60 |
n1-standard-32 |
32 | 120 |
n1-highmem-2 |
2 | 13 |
n1-highmem-4 |
4 | 26 |
n1-highmem-8 |
8 | 52 |
n1-highmem-16 |
16 | 104 |
n1-highmem-32 |
32 | 208 |
n1-highcpu-4 |
4 | 3.6 |
n1-highcpu-8 |
8 | 7.2 |
n1-highcpu-16 |
16 | 14.4 |
n1-highcpu-32 |
32 | 28.8 |
Serie N2
| Nombre | CPU virtuales | Memoria (GB) |
|---|---|---|
n2-standard-2 |
2 | 8 |
n2-standard-4 |
4 | 16 |
n2-standard-8 |
8 | 32 |
n2-standard-16 |
16 | 64 |
n2-standard-32 |
32 | 128 |
n2-standard-48 |
48 | 192 |
n2-standard-64 |
64 | 256 |
n2-standard-80 |
80 | 320 |
n2-standard-96 |
96 | 384 |
n2-standard-128 |
128 | 512 |
n2-highmem-2 |
2 | 16 |
n2-highmem-4 |
4 | 32 |
n2-highmem-8 |
8 | 64 |
n2-highmem-16 |
16 | 128 |
n2-highmem-32 |
32 | 256 |
n2-highmem-48 |
48 | 384 |
n2-highmem-64 |
64 | 512 |
n2-highmem-80 |
80 | 640 |
n2-highmem-96 |
96 | 768 |
n2-highmem-128 |
128 | 864 |
n2-highcpu-2 |
2 | 2 |
n2-highcpu-4 |
4 | 4 |
n2-highcpu-8 |
8 | 8 |
n2-highcpu-16 |
16 | 16 |
n2-highcpu-32 |
32 | 32 |
n2-highcpu-48 |
48 | 48 |
n2-highcpu-64 |
64 | 64 |
n2-highcpu-80 |
80 | 80 |
n2-highcpu-96 |
96 | 96 |
Serie N2D
| Nombre | CPU virtuales | Memoria (GB) |
|---|---|---|
n2d-standard-2 |
2 | 8 |
n2d-standard-4 |
4 | 16 |
n2d-standard-8 |
8 | 32 |
n2d-standard-16 |
16 | 64 |
n2d-standard-32 |
32 | 128 |
n2d-standard-48 |
48 | 192 |
n2d-standard-64 |
64 | 256 |
n2d-standard-80 |
80 | 320 |
n2d-standard-96 |
96 | 384 |
n2d-standard-128 |
128 | 512 |
n2d-standard-224 |
224 | 896 |
n2d-highmem-2 |
2 | 16 |
n2d-highmem-4 |
4 | 32 |
n2d-highmem-8 |
8 | 64 |
n2d-highmem-16 |
16 | 128 |
n2d-highmem-32 |
32 | 256 |
n2d-highmem-48 |
48 | 384 |
n2d-highmem-64 |
64 | 512 |
n2d-highmem-80 |
80 | 640 |
n2d-highmem-96 |
96 | 768 |
n2d-highcpu-2 |
2 | 2 |
n2d-highcpu-4 |
4 | 4 |
n2d-highcpu-8 |
8 | 8 |
n2d-highcpu-16 |
16 | 16 |
n2d-highcpu-32 |
32 | 32 |
n2d-highcpu-48 |
48 | 48 |
n2d-highcpu-64 |
64 | 64 |
n2d-highcpu-80 |
80 | 80 |
n2d-highcpu-96 |
96 | 96 |
n2d-highcpu-128 |
128 | 128 |
n2d-highcpu-224 |
224 | 224 |
Serie C2
| Nombre | CPU virtuales | Memoria (GB) |
|---|---|---|
c2-standard-4 |
4 | 16 |
c2-standard-8 |
8 | 32 |
c2-standard-16 |
16 | 64 |
c2-standard-30 |
30 | 120 |
c2-standard-60 |
60 | 240 |
Serie C2D
| Nombre | CPU virtuales | Memoria (GB) |
|---|---|---|
c2d-standard-2 |
2 | 8 |
c2d-standard-4 |
4 | 16 |
c2d-standard-8 |
8 | 32 |
c2d-standard-16 |
16 | 64 |
c2d-standard-32 |
32 | 128 |
c2d-standard-56 |
56 | 224 |
c2d-standard-112 |
112 | 448 |
c2d-highcpu-2 |
2 | 4 |
c2d-highcpu-4 |
4 | 8 |
c2d-highcpu-8 |
8 | 16 |
c2d-highcpu-16 |
16 | 32 |
c2d-highcpu-32 |
32 | 64 |
c2d-highcpu-56 |
56 | 112 |
c2d-highcpu-112 |
112 | 224 |
c2d-highmem-2 |
2 | 16 |
c2d-highmem-4 |
4 | 32 |
c2d-highmem-8 |
8 | 64 |
c2d-highmem-16 |
16 | 128 |
c2d-highmem-32 |
32 | 256 |
c2d-highmem-56 |
56 | 448 |
c2d-highmem-112 |
112 | 896 |
Serie C3
| Nombre | CPU virtuales | Memoria (GB) |
|---|---|---|
c3-highcpu-4 |
4 | 8 |
c3-highcpu-8 |
8 | 16 |
c3-highcpu-22 |
22 | 44 |
c3-highcpu-44 |
44 | 88 |
c3-highcpu-88 |
88 | 176 |
c3-highcpu-176 |
176 | 352 |
Tipos de máquinas: GPU
Serie A2
| Nombre | CPU virtuales | Memoria (GB) | GPU (NVIDIA A100) |
|---|---|---|---|
a2-highgpu-1g |
12 | 85 | 1 (A100 40GB) |
a2-highgpu-2g |
24 | 170 | 2 (A100 40GB) |
a2-highgpu-4g |
48 | 340 | 4 (A100 40GB) |
a2-highgpu-8g |
96 | 680 | 8 (A100 40GB) |
a2-megagpu-16g |
96 | 1,360 | 16 (A100 40GB) |
a2-ultragpu-1g |
12 | 170 | 1 (A100 80GB) |
a2-ultragpu-2g |
24 | 340 | 2 (A100 80GB) |
a2-ultragpu-4g |
48 | 680 | 4 (A100 80GB) |
a2-ultragpu-8g |
96 | 1,360 | 8 (A100 80GB) |
Serie A3
| Nombre | CPU virtuales | Memoria (GB) | GPUs (NVIDIA H100 o H200) |
|---|---|---|---|
a3-highgpu-1g |
26 | 234 | 1 (H100 80GB) |
a3-highgpu-2g |
52 | 468 | 2 (H100 80GB) |
a3-highgpu-4g |
104 | 936 | 4 (H100 80GB) |
a3-highgpu-8g |
208 | 1872 | 8 (H100 80GB) |
a3-edgegpu-8g |
208 | 1872 | 8 (H100 80GB) |
a3-ultragpu-8g |
224 | 2952 | 8 (H200 141GB) |
Serie A4
| Nombre | CPU virtuales | Memoria (GB) | GPUs (NVIDIA B200) |
|---|---|---|---|
a4-highgpu-8g |
224 | 3,968 | 8 |
Serie A4X
| Nombre | CPU virtuales | Memoria (GB) | GPUs (NVIDIA GB200) |
|---|---|---|---|
a4x-highgpu-4g |
140 | 884 | 4 |
Serie G2
| Nombre | CPU virtuales | Memoria (GB) | PUs (NVIDIA L4) |
|---|---|---|---|
g2-standard-4 |
4 | 16 | 1 |
g2-standard-8 |
8 | 32 | 1 |
g2-standard-12 |
12 | 48 | 1 |
g2-standard-16 |
16 | 64 | 1 |
g2-standard-24 |
24 | 96 | 2 |
g2-standard-32 |
32 | 128 | 1 |
g2-standard-48 |
48 | 192 | 4 |
g2-standard-96 |
96 | 384 | 8 |
Serie G4
| Nombre | CPU virtuales | Memoria (GB) | GPUs (NVIDIA RTX PRO 6000) |
|---|---|---|---|
g4-standard-48 |
48 | 180 | 1 |
g4-standard-96 |
96 | 360 | 2 |
g4-standard-192 |
192 | 720 | 4 |
g4-standard-384 |
384 | 1440 | 8 |
Obtén información sobre los precios para cada tipo de máquina. Consulta la documentación de Compute Engine sobre los tipos de máquinas para obtener más información sobre las especificaciones detalladas de estos tipos de máquinas.
Encuentra el tipo de máquina ideal
Inferencia en línea
Para encontrar el tipo de máquina ideal para tu caso de uso, te recomendamos cargar tu modelo en varios tipos de máquinas y medir características como la latencia, el costo, la simultaneidad y la capacidad de procesamiento.
Una forma de hacerlo es ejecutar este notebook en varios tipos de máquinas y comparar los resultados para encontrar el que te resulte más conveniente.
La plataforma de agentes de Gemini Enterprise reserva aproximadamente 1 CPU virtual en cada réplica para ejecutar procesos del sistema, lo que significa que ejecutar el notebook en un solo tipo de máquina de núcleo sería comparable a usar un tipo de máquina de 2 núcleos para entregar inferencias.
Cuando consideres los costos de inferencia, recuerda que, aunque las máquinas más grandes cuestan más, pueden reducir el costo general porque se necesitan menos réplicas para entregar la misma carga de trabajo. Esto es particularmente evidente para las GPU, que suelen costar más por hora, pero ambas pueden proporcionar una latencia más baja y un costo menor en general.
Inferencia por lotes
Para obtener más información, consulta Elige el tipo de máquina y el recuento de réplicas.
Aceleradores de GPU opcionales
Algunas configuraciones, como la serie A2 y la serie G2, tienen una cantidad fija de GPU integradas.
La serie A4X (a4x-highgpu-4g) requiere una cantidad mínima de réplicas de 18. Esta máquina se compra por rack y tiene un mínimo de 18 VMs.
Otras configuraciones, como la serie N1, te permiten agregar GPU de manera opcional para acelerar cada nodo de inferencia.
Si quieres agregar aceleradores de GPU opcionales, debes tener en cuenta varios requisitos:
- Solo puedes usar las GPU cuando tu recurso
Modelse basa en un modelo guardado de TensorFlow o cuando usas un contenedor personalizado que se diseñó para aprovechar las GPU. No puedes usar las GPU para los modelos XGBoost o scikit-learn. - La disponibilidad de cada tipo de GPU varía según la región que uses para el modelo. Obtén más información sobre qué tipos de GPU están disponibles en qué regiones.
- Solo puedes usar un tipo de GPU para el recurso
DeployedModelo paraBatchPredictionJob, y existen limitaciones en la cantidad de GPU que puedes agregar según el tipo de máquina que uses. En la siguiente tabla, se describen estas limitaciones.
En la siguiente tabla, se muestran las GPU opcionales que están disponibles para la inferencia en línea y cuántas GPU de cada tipo puedes usar con cada tipo de máquina de Compute Engine:
| Números válidos de GPU para cada tipo de máquina | |||||
|---|---|---|---|---|---|
| Tipo de máquina | NVIDIA Tesla P100 | NVIDIA Tesla V100 | NVIDIA Tesla P4 | NVIDIA Tesla T4 | |
n1-standard-2 |
1, 2, 4 | 1, 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-standard-4 |
1, 2, 4 | 1, 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-standard-8 |
1, 2, 4 | 1, 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-standard-16 |
1, 2, 4 | 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-standard-32 |
2, 4 | 4, 8 | 2, 4 | 2, 4 | |
n1-highmem-2 |
1, 2, 4 | 1, 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-highmem-4 |
1, 2, 4 | 1, 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-highmem-8 |
1, 2, 4 | 1, 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-highmem-16 |
1, 2, 4 | 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-highmem-32 |
2, 4 | 4, 8 | 2, 4 | 2, 4 | |
n1-highcpu-2 |
1, 2, 4 | 1, 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-highcpu-4 |
1, 2, 4 | 1, 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-highcpu-8 |
1, 2, 4 | 1, 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-highcpu-16 |
1, 2, 4 | 2, 4, 8 | 1, 2, 4 | 1, 2, 4 | |
n1-highcpu-32 |
2, 4 | 4, 8 | 2, 4 | 2, 4 | |
Las GPU opcionales generan costos adicionales.
Cómo programar varias réplicas en una sola VM
Para optimizar el costo de tu implementación, puedes implementar varias réplicas del mismo modelo en una sola VM equipada con varios aceleradores de hardware de GPU, como la VM a3-highgpu-8g, que tiene ocho GPUs NVIDIA H100. Cada réplica del modelo se puede asignar a una o más GPUs.
Para cargas de trabajo más pequeñas, también puedes particionar una sola GPU en varias instancias más pequeñas con las GPU de instancias múltiples (MIG) de NVIDIA. Esto te permite asignar recursos a nivel de sub-GPU, lo que maximiza el uso de cada acelerador. Para obtener más información sobre las GPU de instancias múltiples, consulta la guía del usuario de GPU de instancias múltiples de NVIDIA.
Ambas capacidades están diseñadas para proporcionar un uso más eficiente de los recursos y una mayor rentabilidad para tus cargas de trabajo de entrega.
Limitaciones
Esta función está sujeta a las siguientes limitaciones:
- Todas las réplicas del modelo programadas de forma conjunta deben ser de la misma versión del modelo.
- No se admite el uso de grupos de recursos de implementación para compartir recursos entre implementaciones.
Tipos de máquina admitidos
Se admiten los siguientes tipos de máquinas. Ten en cuenta que, para los tipos de máquinas que solo tienen una GPU, no se necesita la programación conjunta.
| Tipo de máquina | CoSchedule | Coschedule + MIG |
|---|---|---|
| a2-highgpu-1g | N/A | Sí |
| a2-highgpu-2g | Sí | Sí |
| a2-highgpu-4g | Sí | Sí |
| a2-highgpu-8g | Sí | Sí |
| a2-highgpu-16g | Sí | Sí |
| a2-ultragpu-1g | N/A | Sí |
| a2-ultragpu-2g | Sí | Sí |
| a2-ultragpu-4g | Sí | Sí |
| a2-ultragpu-8g | Sí | Sí |
| a3-edgegpu-8g | Sí | Sí |
| a3-highgpu-1g | N/A | Sí |
| a3-highgpu-2g | Sí | Sí |
| a3-highgpu-4g | Sí | Sí |
| a3-highgpu-8g | Sí | Sí |
| a3-megagpu-8g | Sí | Sí |
| a3-ultragpu-8g | Sí | Sí |
| a4-highgpu-8g | Sí | Sí |
| a4x-highgpu-8g | Sí | Sí |
| g4-standard-48 | N/A | Sí |
| g4-standard-96 | Sí | Sí |
| g4-standard-192 | Sí | Sí |
| g4-standard-384 | Sí | Sí |
Requisitos previos
Antes de usar esta función, lee Implementa un modelo con la gcloud CLI o la API de Agent Platform.
Implementa las réplicas del modelo
En los siguientes ejemplos, se muestra cómo implementar réplicas de modelos programadas de forma conjunta.
gcloud
Usa el siguiente comando gcloud para implementar réplicas del modelo programadas de forma conjunta en una VM:
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 \
--machine-type=MACHINE_TYPE \
--accelerator=type=ACC_TYPE,count=ACC_COUNT \
--traffic-split=0=100
Reemplaza lo siguiente:
- ENDPOINT_ID: Es el ID del extremo.
- LOCATION_ID: Es la región en la que usas Agent Platform.
- MODEL_ID: Es el ID del modelo que se implementará.
-
DEPLOYED_MODEL_NAME: Un nombre para
DeployedModelTambién puedes usar el nombre comercial deModelparaDeployedModel. - MIN_REPLICA_COUNT: La cantidad mínima de nodos para esta implementación. El recuento de nodos se puede aumentar o disminuir según lo requiera la carga de inferencia, hasta la cantidad máxima de nodos y nunca menos que esta cantidad.
- MAX_REPLICA_COUNT: La cantidad máxima de nodos para esta implementación. El recuento de nodos se puede aumentar o disminuir según lo requiera la carga de inferencia, hasta esta cantidad de nodos y nunca menos que la cantidad mínima de nodos. . Se requiere una VM por cada 2 réplicas que se implementen.
- MACHINE_TYPE: Es el tipo de VM que se usará para esta implementación. Debe ser de la familia con optimización de acelerador.
- ACC_TYPE: Es el tipo de acelerador de GPU. Debe corresponder al MACHINE_TYPE. Para
a3-highgpu-8g, usanvidia-h100-80gb. - ACC_COUNT: Es la cantidad de GPUs que puede usar cada réplica. Debe ser, al menos, 1 y no más que la cantidad total de GPUs en la máquina.
REST
Antes de usar cualquiera de los datos de solicitud a continuación, realiza los siguientes reemplazos:
- PROJECT_NUMBER: Es el número del proyecto.
- LOCATION_ID: Es la región en la que usas Agent Platform.
- MODEL_ID: El ID del modelo que se implementará.
-
DEPLOYED_MODEL_NAME: Un nombre para
DeployedModelTambién puedes usar el nombre comercial deModelparaDeployedModel. -
MACHINE_TYPE: Opcional Los recursos de máquina que se usan para cada nodo de esta implementación. Su configuración predeterminada es
n1-standard-2. Obtén más información sobre los tipos de máquinas. - ACC_TYPE: Es el tipo de acelerador de GPU. Debe corresponder a `GPU_PARTITION_SIZE`.
- GPU_PARTITION_SIZE: Es el tamaño de la partición de GPU. Por ejemplo, "1g.10gb".
- ACC_COUNT: Es la cantidad de GPUs que puede usar cada réplica. Debe ser, al menos, 1 y no más que la cantidad total de GPUs en la máquina.
- MIN_REPLICA_COUNT: La cantidad mínima de nodos para esta implementación. El recuento de nodos se puede aumentar o disminuir según lo requiera la carga de inferencia, hasta la cantidad máxima de nodos y nunca menos que esta cantidad.
- MAX_REPLICA_COUNT: La cantidad máxima de nodos para esta implementación. El recuento de nodos se puede aumentar o disminuir según lo requiera la carga de inferencia, hasta esta cantidad de nodos y nunca menos que la cantidad mínima de nodos.
Método HTTP y URL:
POST https://LOCATION_ID-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel
Cuerpo JSON de la solicitud:
{
"deployedModel": {
"model": "projects/PROJECT_NUMBER/locations/LOCATION_ID/models/MODEL_ID",
"displayName": "DEPLOYED_MODEL_NAME",
"dedicatedResources": {
"machineSpec": {
"machineType": "MACHINE_TYPE",
"acceleratorType": "ACC_TYPE",
"gpuPartitionSize": "GPU_PARTITION_SIZE",
"acceleratorCount": "ACC_COUNT""
},
"minReplicaCount": MIN_REPLICA_COUNT,
"maxReplicaCount": MAX_REPLICA_COUNT,
"autoscalingMetricSpecs": [
{
"metricName": "aiplatform.googleapis.com/prediction/online/accelerator/duty_cycle",
"target": 70
}
]
}
}
}
Para enviar tu solicitud, expande una de estas opciones:
Deberías recibir un código de estado exitoso (2xx) y una respuesta vacía.
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. Para obtener más información, consulta la documentación de referencia de la API de Python.
Usa el siguiente comando de Python para implementar réplicas del modelo programadas de forma conjunta en una VM.
endpoint.deploy(
model=<var>MODEL</var>,
machine_type=MACHINE_TYPE,
min_replica_count=MIN_REPLICA_COUNT,
max_replica_count=MAX_REPLICA_COUNT,
accelerator_type=ACC_TYPE,
gpu_partition_size=GPU_PARTITION_SIZE,
accelerator_count=ACC_COUNT
)
Reemplaza lo siguiente:
MODEL: Es el objeto del modelo que devuelve la siguiente llamada a la API:
model = aiplatform.Model(model_name=model_name)MACHINE_TYPE: Es el tipo de VM que se usará para esta implementación. Debe ser de la familia con optimización de acelerador. En la vista previa, solo se admite
a3-highgpu-8g.MIN_REPLICA_COUNT: La cantidad mínima de nodos para esta implementación. El recuento de nodos se puede aumentar o disminuir según lo requiera la carga de inferencia, hasta la cantidad máxima de nodos y nunca menos que esta cantidad.
MAX_REPLICA_COUNT: La cantidad máxima de nodos para esta implementación. El recuento de nodos se puede aumentar o disminuir según lo requiera la carga de inferencia, hasta esta cantidad de nodos y nunca menos que la cantidad mínima de nodos.
ACC_TYPE: Es el tipo de acelerador de GPU. Debe corresponder al GPU_PARTITION_SIZE.
GPU_PARTITION_SIZE: Es el tamaño de la partición de GPU. Por ejemplo,
"1g.10gb". Para obtener una lista completa de los tamaños de partición admitidos para cada tipo de GPU, consulta Particiones de GPU de instancias múltiples.ACC_COUNT: Es la cantidad de GPUs que puede usar cada réplica. Debe ser, al menos, 1 y no más que la cantidad total de GPUs en la máquina. Para
a3-highgpu-8g, especifica un valor entre 1 y 8.
Supervisa el uso de la VM
Sigue estas instrucciones para supervisar el recuento real de máquinas de las réplicas implementadas en el Explorador de métricas.
En la consola de Google Cloud , ve a la página Explorador de métricas.
Selecciona el proyecto para el que deseas ver las métricas.
En el menú desplegable Métrica, haz clic en Seleccionar una métrica.
En la barra de búsqueda Filtrar por nombre de recurso o métrica, ingresa
Gemini Enterprise Agent Platform Endpoint.Selecciona la categoría de métricas Agent Platform Endpoint > Prediction. En Active metrics, selecciona Machine count.
Haz clic en Aplicar.
Facturación
La facturación se basa en la cantidad de VMs que se usan, no en la cantidad de GPUs. Puedes supervisar el uso de tu VM con el Explorador de métricas.
Alta disponibilidad
Dado que se programa más de una réplica en la misma VM, Vertex AI Inference no puede distribuir tu implementación en varias VMs y, por lo tanto, en varias zonas hasta que el recuento de réplicas supere el nodo de una sola VM. Para fines de alta disponibilidad, Google recomienda realizar la implementación en al menos dos nodos (VMs).
¿Qué sigue?
- Implementa un modelo tabular de AutoML en la Google Cloud consola
- Implementa un modelo con entrenamiento personalizado en la consola de Google Cloud
- Implementa un modelo con entrenamiento personalizado con bibliotecas cliente
- Obtén inferencias por lotes