Condividi tramite

Calcolo di GPU senza server

Importante

Questa funzionalità è in versione beta.

Questo articolo descrive il calcolo GPU serverless in Databricks e fornisce casi d'uso consigliati, indicazioni su come configurare risorse di calcolo GPU e limitazioni delle funzionalità.

Che cos'è il calcolo GPU serverless?

Il calcolo serverless con GPU è parte dell'offerta di calcolo serverless. Il calcolo GPU serverless è specializzato per carichi di lavoro di Deep Learning a nodo singolo e multinodo personalizzati. È possibile usare il calcolo GPU serverless per eseguire il training e ottimizzare i modelli personalizzati usando i framework preferiti e ottenere efficienza, prestazioni e qualità all'avanguardia.

L'elaborazione GPU senza server include:

  • Un'esperienza integrata tra notebook, catalogo Unity e MLflow: È possibile sviluppare il codice in modo interattivo usando notebook.
  • Acceleratori GPU A10: LE GPU A10 sono progettate per accelerare carichi di lavoro di Machine Learning di piccole e medie dimensioni e deep learning, inclusi i modelli di Machine Learning classici e l'ottimizzazione dei modelli linguistici più piccoli. A10s sono ideali per le attività con requisiti di calcolo moderati.
  • Supporto multi-GPU e multinodo: È possibile eseguire carichi di lavoro di training distribuiti più GPU e più nodi usando l'API Python gpu serverless. Vedere Training distribuito.

I pacchetti preinstallati nel calcolo GPU serverless non sono una sostituzione di Databricks Runtime ML. Anche se sono presenti pacchetti comuni, non tutte le dipendenze e le librerie di Machine Learning di Databricks Runtime si riflettono nell'ambiente di calcolo GPU serverless.

Ambienti Python nel calcolo GPU serverless

Databricks offre due ambienti gestiti per gestire casi d'uso diversi.

Annotazioni

Gli ambienti di base personalizzati non sono supportati per il calcolo GPU serverless. Usare invece l'ambiente predefinito o di intelligenza artificiale e specificare dipendenze aggiuntive direttamente nel pannello laterale Ambienti o pip install in esse.

Ambiente di base predefinito

In questo modo è disponibile un ambiente minimo con UN'API client stabile per garantire la compatibilità delle applicazioni. Vengono installati solo i pacchetti Python necessari. Questo consente a Databricks di aggiornare il server in modo indipendente, migliorando le prestazioni, potenziando la sicurezza e correggendo errori, senza richiedere modifiche al codice dei carichi di lavoro. Si tratta dell'ambiente predefinito quando si sceglie il calcolo GPU serverless. Scegliere questo ambiente se si vuole personalizzare completamente l'ambiente per il training.

Per ulteriori dettagli sulle versioni dei pacchetti installate nelle diverse versioni, consultare le note sulla versione:

Ambiente di intelligenza artificiale

L'ambiente di intelligenza artificiale di Databricks è disponibile nell'ambiente GPU serverless 4. L'ambiente di intelligenza artificiale si basa sull'ambiente di base predefinito con pacchetti comuni di runtime e pacchetti specifici per il machine learning sulle GPU. Contiene librerie di Machine Learning più diffuse, tra cui PyTorch, LangChain, Transformers, Ray e XGBoost per il training e l'inferenza del modello. Scegliere questo ambiente per l'esecuzione di carichi di lavoro di training.

Per ulteriori dettagli sulle versioni dei pacchetti installate nelle diverse versioni, consultare le note sulle versioni:

Databricks consiglia il calcolo GPU serverless per qualsiasi caso d'uso di addestramento del modello che richiede personalizzazioni e GPU per l'addestramento.

Per esempio:

  • Ottimizzazione LLM
  • Visione artificiale
  • sistemi di raccomandazione
  • Apprendimento per rinforzo
  • Previsione di serie temporali basate su Deep Learning

Requisiti

  • Un'area di lavoro in una delle aree supportate da Azure seguenti:
    • eastus
    • eastus2
    • centralus
    • northcentralus
    • westcentralus
    • westus

Configurare il calcolo GPU serverless

Per connettere il notebook al calcolo GPU serverless e configurare l'ambiente:

  1. In un notebook fare clic sul menu a discesa Connetti nella parte superiore e selezionare GPU serverless.
  2. Fare clic sull'icona Ambiente per aprire il pannello laterale Ambiente .
  3. Selezionare A10 nel campo Acceleratore .
  4. Selezionare Nessuno per l'ambiente predefinito o IA v4 per l'ambiente di intelligenza artificiale nel campo Ambiente di base.
  5. Se si sceglie Nessuno nel campo Ambiente di base , selezionare la versione ambiente.
  6. Fare clic su Applica e quindi confermare di voler applicare il calcolo GPU serverless all'ambiente notebook.

Annotazioni

La connessione al calcolo termina automaticamente dopo 60 minuti di inattività.

Aggiungere librerie all'ambiente

È possibile installare librerie aggiuntive nell'ambiente di calcolo GPU serverless. Vedere Aggiungere dipendenze al notebook.

Annotazioni

L'aggiunta di dipendenze tramite il pannello Ambienti come illustrato in Aggiungere dipendenze al notebook non è supportata per i processi pianificati di calcolo GPU serverless.

Creare e pianificare un processo

I passaggi seguenti illustrano come creare e pianificare processi per i carichi di lavoro di calcolo GPU serverless. Per altri dettagli, vedere Creare e gestire processi di notebook pianificati .

Dopo aver aperto il notebook da usare:

  1. Selezionare il pulsante Pianifica in alto a destra.
  2. Selezionare Aggiungi pianificazione.
  3. Popolare il modulo Nuova pianificazione con il nome dell'attività, la pianificazione e le risorse di calcolo.
  4. Fare clic su Crea.

È anche possibile creare e pianificare processi dall'interfaccia utente processi e pipeline . Per istruzioni dettagliate, vedere Creare un nuovo processo .

Training distribuito

È possibile avviare il training distribuito tra più GPU, all'interno di un singolo nodo o tra più nodi, usando l'API Python gpu serverless. L'API fornisce un'interfaccia semplice e unificata che astrae i dettagli del provisioning gpu, della configurazione dell'ambiente e della distribuzione del carico di lavoro. Con modifiche minime al codice, è possibile passare facilmente dal training a GPU singola all'esecuzione distribuita tra GPU remote dallo stesso notebook.

Il decoratore @distributed funziona in modo simile all'avvio dell'addestramento multinodo con torchrun, ma interamente in Python. Ad esempio, il frammento seguente distribuisce la hello_world funzione tra 8 GPU remote A10:

# Import the distributed decorator
from serverless_gpu import distributed

# Decorate the function with @distributed and specify the number of GPUs, the GPU type, and whether
# or not the GPUs are remote
@distributed(gpus=8, gpu_type='A10', remote=True)
def hello_world(name: str) -> None:
  print('hello', name)

# Trigger the distributed execution of the hello_world function
hello_world.distributed('world')

Quando eseguiti, i log e gli output di tutti i lavoratori vengono raccolti e visualizzati nella sezione Esperimento dell'area di lavoro.

L'API supporta librerie di training parallele comuni, ad esempio Distributed Data Parallel (DDP), Fully Sharded Data Parallel (FSDP), DeepSpeed e Ray.

Per iniziare, importare il notebook iniziale per iniziare a usare l'API, quindi esplorare gli esempi di notebook per vedere come viene usato in scenari di training distribuiti reali usando le varie librerie.

Per informazioni dettagliate, vedere la documentazione dell'API Python per GPU serverless .

Eseguire Ray Code con @ray\_launch

Usare @ray_launch per avviare il codice Ray. ray_launch è un altro elemento decorator dell'API SGC che viene sovrapposto a @distributed. Ogni ray_launch attività esegue prima il bootstrap di un rendezvous distribuito di Torch per determinare il nodo head worker di Ray e aggregare gli indirizzi IP. Rank-zero inizia ray start --head (con l'esportazione delle metriche se abilitata), imposta RAY_ADDRESS e esegue la funzione decorata come driver Ray. Altri nodi si uniscono tramite ray start --address e attendono che il driver scriva un marcatore di completamento.

  • La raccolta di metriche del sistema Ray può essere abilitata per ogni nodo tramite RayMetricsMonitor quando remote=True.

  • Configurare i dettagli del runtime di Ray (attori, set di dati, gruppi di posizionamento, opzioni di pianificazione) all'interno della funzione decorata usando le normali API di Ray.

  • I controlli a livello di cluster (numero/tipo di GPU, remote e locali, comportamento asincrono e pool di Databricks env vars) rimangono all'esterno negli argomenti decorator o nell'env del notebook.

Dettagli di configurazione aggiuntivi:

  • Per abilitare la raccolta delle metriche di sistema Ray in ogni nodo, usare RayMetricsMonitor con remote=True.
  • Definire le opzioni di runtime Ray (attori, set di dati, gruppi di posizionamento e pianificazione) all'interno della funzione decorata usando le API Ray standard.
  • Gestire i controlli a livello di cluster (numero di GPU e tipo, modalità remota e locale, comportamento asincrono e variabili di ambiente del pool di Databricks) all'esterno della funzione negli argomenti del decoratore o nell'ambiente del notebook.

L'esempio seguente illustra come usare @ray_launch:

from serverless_gpu.ray import ray_launch
@ray_launch(gpus=16, remote=True, gpu_type='h100')
def foo():
    import os
    import ray
    print(ray.state.available_resources_per_node())
    return 1
foo.distributed()

Limitazioni

  • Il calcolo GPU serverless supporta solo acceleratori A10.
  • Collegamento privato non è supportato. I repository di archiviazione o pip dietro Private Link non sono supportati.
  • Le risorse di calcolo GPU serverless non sono supportate per le aree di lavoro conformi ai profili di sicurezza (ad esempio HIPAA o PCI). L'elaborazione dei dati regolamentati non è attualmente supportata.
  • Per i processi pianificati su GPU serverless, il comportamento di ripristino automatico per le versioni dei pacchetti incompatibili associate al notebook non è supportato.
  • Il runtime massimo per un carico di lavoro è di sette giorni. Per i processi di training del modello che superano questo limite, implementare il checkpoint e riavviare il processo una volta raggiunto il runtime massimo.

Procedure consigliate

Vedere Procedure consigliate per il calcolo GPU Serverless.

Risolvere i problemi relativi all'ambiente di calcolo GPU serverless

Se si verificano problemi durante l'esecuzione di carichi di lavoro nel calcolo GPU serverless, vedere la guida alla risoluzione dei problemi per problemi comuni, soluzioni alternative e risorse di supporto.

Esempi di notebook

Di seguito sono riportati vari esempi di notebook che illustrano come usare il calcolo GPU serverless per diverse attività.

Task Description
Modelli linguistici di grandi dimensioni Esempi di ottimizzazione di modelli linguistici di grandi dimensioni, inclusi metodi efficienti per i parametri, ad esempio Low-Rank Adaptation (LoRA) e approcci di ottimizzazione con supervisione.
Visione artificiale Esempi di attività di visione artificiale, tra cui il rilevamento degli oggetti e la classificazione delle immagini.
Sistemi di raccomandazione basati su Deep Learning Esempi per la creazione di sistemi di raccomandazione che usano approcci di Deep Learning moderni, ad esempio modelli a due torre.
Ml classico Esempi di attività tradizionali di Machine Learning, tra cui il training del modello XGBoost e la previsione delle serie temporali.
Formazione distribuita multi-GPU e multi-nodo Esempi per il ridimensionamento del training tra più GPU e nodi utilizzando l'API GPU serverless, includendo il fine-tuning distribuito.

Esempi di training su più GPU

Consultare Training distribuito su più GPU e nodi multipli per notebook che illustrano come usare varie librerie di training distribuito per il training su più GPU.

  • Last updated on