Vertex AI alloca nodi per gestire le inferenze online e in batch.
Quando esegui il deployment di un modello con addestramento personalizzato o di un modello AutoML su una risorsa Endpoint
per pubblicare inferenze online o quando
richiedi inferenze batch, puoi
personalizzare il tipo di macchina virtuale utilizzato dal servizio di inferenza per
questi nodi. Se vuoi, puoi configurare i nodi di inferenza in modo che utilizzino le GPU.
I tipi di macchine differiscono per alcuni aspetti:
- Numero di CPU virtuali (vCPU) per nodo
- Quantità di memoria per nodo
- Prezzi
Se selezioni un tipo di macchina con più risorse di calcolo, puoi pubblicare inferenze con una latenza inferiore o gestire più richieste di inferenza contemporaneamente.
Gestire costi e disponibilità
Per aiutarti a gestire i costi o garantire la disponibilità delle risorse VM, Vertex AI fornisce quanto segue:
Per assicurarti che le risorse VM siano disponibili quando i job di inferenza ne hanno bisogno, puoi utilizzare le prenotazioni di Compute Engine. Le prenotazioni offrono un alto livello di garanzia per l'ottenimento di capacità per le risorse Compute Engine. Per saperne di più, vedi Utilizza le prenotazioni con l'inferenza.
Per ridurre il costo di esecuzione dei job di inferenza, puoi utilizzare le VM spot. Le VM spot sono istanze di macchine virtuali (VM) che rappresentano la capacità di Compute Engine in eccesso. Le VM spot beneficiano di sconti significativi, ma Compute Engine potrebbe arrestarle o eliminarle preventivamente per recuperare capacità in qualsiasi momento. Per saperne di più, consulta Utilizzare le VM spot con l'inferenza.
Dove specificare le risorse di calcolo
Inferenza online
Se vuoi utilizzare un modello con addestramento personalizzato o un modello tabulare AutoML per pubblicare inferenze online, devi specificare un tipo di macchina quando esegui il deployment della risorsa Model
come DeployedModel
in un Endpoint
. Per altri tipi di modelli AutoML, Vertex AI configura automaticamente i tipi di macchina.
Specifica il tipo di macchina (e, facoltativamente, la configurazione GPU) nel campo
dedicatedResources.machineSpec
del tuo
DeployedModel
.
Scopri come eseguire il deployment di ogni tipo di modello:
- Esegui il deployment di un modello tabulare AutoML nella console Google Cloud
- Esegui il deployment di un modello con addestramento personalizzato nella Google Cloud console
- Esegui il deployment di un modello con addestramento personalizzato utilizzando le librerie client
Inferenza batch
Se vuoi ottenere inferenze batch da un modello con addestramento personalizzato o da un modello tabellare AutoML, devi specificare un tipo di macchina quando crei una risorsa
BatchPredictionJob
. Specifica il tipo di macchina (e, facoltativamente, la configurazione della GPU) nel campo dedicatedResources.machineSpec
del tuo BatchPredictionJob
.
Tipi di macchine
La seguente tabella confronta i tipi di macchine disponibili per la pubblicazione di inferenze da modelli con addestramento personalizzato e modelli tabulari AutoML:
Serie E2
Nome | vCPU | 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
Nome | vCPU | 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
Nome | vCPU | 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
Nome | vCPU | 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
Nome | vCPU | 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
Nome | vCPU | 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
Nome | vCPU | 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 |
Serie A2
Nome | vCPU | Memoria (GB) | GPU (NVIDIA A100) |
---|---|---|---|
a2-highgpu-1g |
12 | 85 | 1 (A100 da 40 GB) |
a2-highgpu-2g |
24 | 170 | 2 (A100 da 40 GB) |
a2-highgpu-4g |
48 | 340 | 4 (A100 da 40 GB) |
a2-highgpu-8g |
96 | 680 | 8 (A100 da 40 GB) |
a2-megagpu-16g |
96 | 1360 | 16 (A100 da 40 GB) |
a2-ultragpu-1g |
12 | 170 | 1 (A100 da 80 GB) |
a2-ultragpu-2g |
24 | 340 | 2 (A100 da 80 GB) |
a2-ultragpu-4g |
48 | 680 | 4 (A100 da 80 GB) |
a2-ultragpu-8g |
96 | 1360 | 8 (A100 da 80 GB) |
Serie A3
Nome | vCPU | Memoria (GB) | GPU (NVIDIA H100 o H200) |
---|---|---|---|
a3-highgpu-1g |
26 | 234 | 1 (H100 da 80 GB) |
a3-highgpu-2g |
52 | 468 | 2 (H100 da 80 GB) |
a3-highgpu-4g |
104 | 936 | 4 (H100 da 80 GB) |
a3-highgpu-8g |
208 | 1872 | 8 (H100 da 80 GB) |
a3-edgegpu-8g |
208 | 1872 | 8 (H100 da 80 GB) |
a3-ultragpu-8g |
224 | 2952 | 8 (H200 da 141 GB) |
Serie A4X
Nome | vCPU | Memoria (GB) | GPU (NVIDIA GB200) |
---|---|---|---|
a4x-highgpu-4g |
140 | 884 | 4 |
Serie G2
Nome | vCPU | Memoria (GB) | GPU (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 |
Scopri di più sui prezzi per ogni tipo di macchina. Scopri di più sulle specifiche dettagliate di questi tipi di macchine nella documentazione di Compute Engine sui tipi di macchine.
Trovare il tipo di macchina ideale
Inferenza online
Per trovare il tipo di macchina ideale per il tuo caso d'uso, ti consigliamo di caricare il modello su più tipi di macchine e misurare caratteristiche come latenza, costo, concorrenza e velocità effettiva.
Un modo per farlo è eseguire questo blocco note su più tipi di macchine e confrontare i risultati per trovare quello più adatto alle tue esigenze.
Vertex AI riserva circa 1 vCPU su ogni replica per l'esecuzione dei processi di sistema. Ciò significa che l'esecuzione del notebook su un tipo di macchina con un singolo core sarebbe paragonabile all'utilizzo di un tipo di macchina con 2 core per la pubblicazione delle inferenze.
Quando valuti i costi di inferenza, ricorda che, sebbene le macchine più grandi costino di più, possono ridurre il costo complessivo perché sono necessarie meno repliche per gestire lo stesso carico di lavoro. Ciò è particolarmente evidente per le GPU, che tendono a costare di più all'ora, ma possono fornire una latenza inferiore e costare meno in totale.
Inferenza batch
Per saperne di più, consulta Scegliere il tipo di macchina e il numero di repliche.
Acceleratori GPU opzionali
Alcune configurazioni, come le serie A2 e G2, hanno un numero fisso di GPU integrate.
La serie A4X (a4x-highgpu-4g
)
richiede un numero minimo di repliche pari a 18. Questa macchina viene acquistata per
rack e ha un minimo di 18 VM.
Altre configurazioni, come la serie N1, consentono di aggiungere facoltativamente GPU per accelerare ogni nodo di inferenza.
Per aggiungere acceleratori GPU facoltativi, devi tenere conto di diversi requisiti:
- Puoi utilizzare le GPU solo se la risorsa
Model
si basa su un SavedModel di TensorFlow o se utilizzi un container personalizzato progettato per sfruttare le GPU. Non puoi utilizzare le GPU per i modelli scikit-learn o XGBoost. - La disponibilità di ogni tipo di GPU varia a seconda della regione che utilizzi per il modello. Scopri quali tipi di GPU sono disponibili in quali regioni.
- Puoi utilizzare un solo tipo di GPU per la risorsa
DeployedModel
oBatchPredictionJob
e ci sono limitazioni al numero di GPU che puoi aggiungere a seconda del tipo di macchina che utilizzi. La tabella seguente descrive queste limitazioni.
La seguente tabella mostra le GPU opzionali disponibili per l'inferenza online e il numero di GPU di ogni tipo che puoi utilizzare con ogni tipo di macchina Compute Engine:
Numeri validi di GPU per ogni tipo di macchina | |||||
---|---|---|---|---|---|
Tipo di macchina | 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 |
Le GPU facoltative comportano costi aggiuntivi.
Pianificare più repliche su una singola VM
Per ottimizzare il costo del deployment, puoi eseguire il deployment di più repliche dello stesso modello su una singola VM dotata di più acceleratori hardware GPU, come la VM a3-highgpu-8g
, che dispone di otto GPU NVIDIA H100. Ogni replica del modello può essere assegnata a una o più GPU.
Per i workload più piccoli, puoi anche partizionare una singola GPU in più istanze più piccole utilizzando le GPU multi-istanza (MIG) NVIDIA. In questo modo puoi assegnare risorse a livello di sub-GPU, massimizzando l'utilizzo di ogni acceleratore. Per ulteriori informazioni sulle GPU multi-istanza, consulta la Guida dell'utente per le GPU multi-istanza NVIDIA.
Entrambe queste funzionalità sono progettate per fornire un utilizzo più efficiente delle risorse e una maggiore convenienza per i carichi di lavoro di pubblicazione.
Limitazioni
Questa funzionalità è soggetta alle seguenti limitazioni:
- Tutte le repliche del modello pianificate in contemporanea devono essere della stessa versione del modello.
- L'utilizzo dei pool di risorse di deployment per condividere le risorse tra i deployment non è supportato.
Tipi di macchine supportati
Sono supportati i seguenti tipi di macchine. Tieni presente che, per i tipi di macchina con una sola GPU, non è necessaria alcuna pianificazione coordinata.
Tipo di macchina | CoSchedule | Coschedule + MIG |
---|---|---|
a2-highgpu-1g | N/D | 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/D | 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/D | 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ì | No |
Prerequisiti
Prima di utilizzare questa funzionalità, leggi Esegui il deployment di un modello utilizzando gcloud CLI o l'API Vertex AI.
Deployment delle repliche del modello
Gli esempi riportati di seguito mostrano come eseguire il deployment di repliche del modello pianificate insieme.
gcloud
Utilizza il seguente comando gcloud
per eseguire il deployment di repliche del modello pianificate congiuntamente su 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
Sostituisci quanto segue:
- ENDPOINT_ID: l'ID dell'endpoint.
- LOCATION_ID: la regione in cui utilizzi Vertex AI.
- MODEL_ID: L'ID modello del modello da implementare.
-
DEPLOYED_MODEL_NAME: un nome per
DeployedModel
. Puoi utilizzare il nome visualizzato diModel
anche perDeployedModel
. - MIN_REPLICA_COUNT: il numero minimo di nodi per questo deployment. Il conteggio di nodi può essere aumentato o diminuito in base al carico di inferenza, fino al numero massimo di nodi e mai al di sotto di questo numero di nodi.
- MAX_REPLICA_COUNT: il numero massimo di nodi per questo deployment. Il conteggio di nodi può essere aumentato o diminuito in base al carico di inferenza, fino a questo numero di nodi e mai al di sotto del numero minimo di nodi. . È necessaria una VM per ogni due repliche da implementare.
- MACHINE_TYPE: il tipo di VM da utilizzare per questo deployment. Deve appartenere alla famiglia ottimizzata per l'acceleratore.
- ACC_TYPE: Il tipo di acceleratore GPU. Deve corrispondere a
MACHINE_TYPE. Per
a3-highgpu-8g
, utilizzanvidia-h100-80gb
. - ACC_COUNT: il numero di GPU che ogni replica può utilizzare. Deve essere almeno 1 e non superiore al numero totale di GPU nella macchina.
REST
Prima di utilizzare i dati della richiesta, apporta le seguenti sostituzioni:
- PROJECT_NUMBER: il numero di progetto.
- LOCATION_ID: la regione in cui utilizzi Vertex AI.
- MODEL_ID: l'ID del modello da implementare.
-
DEPLOYED_MODEL_NAME: un nome per
DeployedModel
. Puoi utilizzare il nome visualizzato diModel
anche perDeployedModel
. -
MACHINE_TYPE: (Facoltativo) Le risorse macchina utilizzate per ogni nodo di questo
deployment. L'impostazione predefinita è
n1-standard-2
. Scopri di più sui tipi di macchina. - ACC_TYPE: Il tipo di acceleratore GPU. Deve corrispondere a `GPU_PARTITION_SIZE`.
- GPU_PARTITION_SIZE: la dimensione della partizione della GPU. Ad esempio, "1g.10gb".
- ACC_COUNT: il numero di GPU che ogni replica può utilizzare. Deve essere almeno 1 e non superiore al numero totale di GPU nella macchina.
- MIN_REPLICA_COUNT: il numero minimo di nodi per questo deployment. Il conteggio di nodi può essere aumentato o diminuito in base al carico di inferenza, fino al numero massimo di nodi e mai al di sotto di questo numero di nodi.
- MAX_REPLICA_COUNT: il numero massimo di nodi per questo deployment. Il conteggio di nodi può essere aumentato o diminuito in base al carico di inferenza, fino a questo numero di nodi e mai al di sotto del numero minimo di nodi.
Metodo HTTP e URL:
POST https://LOCATION_ID-aiplatform.googleapis.com/v1beta1/projects/PROJECT_ID/locations/LOCATION_ID/endpoints/ENDPOINT_ID:deployModel
Corpo JSON della richiesta:
{ "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 } ] } } }
Per inviare la richiesta, espandi una di queste opzioni:
Dovresti ricevere un codice di stato riuscito (2xx) e una risposta vuota.
Python
Per scoprire come installare o aggiornare l'SDK Vertex AI Python, consulta Installare l'SDK Vertex AI Python. Per saperne di più, consulta la documentazione di riferimento dell'API Python.
Utilizza il seguente comando Python per eseguire il deployment di repliche del modello pianificate congiuntamente su 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
)
Sostituisci quanto segue:
MODEL: l'oggetto modello restituito dalla seguente chiamata API:
model = aiplatform.Model(model_name=model_name)
MACHINE_TYPE: il tipo di VM da utilizzare per questo deployment. Deve appartenere alla famiglia ottimizzata per l'acceleratore. Nell'anteprima è supportato solo
a3-highgpu-8g
.MIN_REPLICA_COUNT: il numero minimo di nodi per questo deployment. Il conteggio di nodi può essere aumentato o diminuito in base al carico di inferenza, fino al numero massimo di nodi e mai al di sotto di questo numero di nodi.
MAX_REPLICA_COUNT: il numero massimo di nodi per questo deployment. Il conteggio di nodi può essere aumentato o diminuito in base al carico di inferenza, fino a questo numero di nodi e mai al di sotto del numero minimo di nodi.
ACC_TYPE: Il tipo di acceleratore GPU. Deve corrispondere a GPU_PARTITION_SIZE.
GPU_PARTITION_SIZE: la dimensione della partizione della GPU. Ad esempio,
"1g.10gb"
. Per un elenco completo delle dimensioni delle partizioni supportate per ogni tipo di GPU, vedi Partizioni GPU multi-istanza.ACC_COUNT: il numero di GPU che ogni replica può utilizzare. Deve essere almeno 1 e non superiore al numero totale di GPU nella macchina. Per
a3-highgpu-8g
, specifica un valore compreso tra 1 e 8.
Monitora l'utilizzo delle VM
Utilizza le seguenti istruzioni per monitorare il conteggio effettivo delle macchine per le repliche di cui è stato eseguito il deployment in Metrics Explorer.
Nella console Google Cloud , vai alla pagina Esplora metriche.
Seleziona il progetto per cui vuoi visualizzare le metriche.
Nel menu a discesa Metrica, fai clic su Seleziona una metrica.
Nella barra di ricerca Filtra in base al nome della risorsa o della metrica, inserisci
Vertex AI Endpoint
.Seleziona la categoria di metriche Endpoint Vertex AI > Previsione. In Metriche attive, seleziona Conteggio macchine.
Fai clic su Applica.
Fatturazione
La fatturazione si basa sul numero di VM utilizzate, non sul numero di GPU. Puoi monitorare l'utilizzo della VM utilizzando Metrics Explorer.
Alta disponibilità
Poiché più di una replica viene pianificata contemporaneamente sulla stessa VM, Vertex AI Inference non può distribuire il deployment su più VM e quindi su più zone finché il numero di repliche non supera il nodo VM singolo. Per scopi di alta affidabilità, Google consiglia il deployment su almeno due nodi (VM).
Passaggi successivi
- Esegui il deployment di un modello tabulare AutoML nella console Google Cloud
- Esegui il deployment di un modello con addestramento personalizzato nella Google Cloud console
- Esegui il deployment di un modello con addestramento personalizzato utilizzando le librerie client
- Ottenere inferenze batch