Pular para o conteúdo principal
Última atualização em

Comece agora: compute GPU sem servidor com GPUs A10

Este Notebook demonstra como usar compute GPU serverless para executar cargas de trabalho de GPU em GPUs A10 diretamente do Databricks Notebook. Você aprenderá como usar a biblioteca Python serverless_gpu para executar funções em uma ou várias GPUs para treinamento distribuído.

compute GPU sem servidor fornece acesso sob demanda a recursos de GPU sem a necessidade de gerenciar clusters. A biblioteca serverless_gpu permite a execução perfeita de cargas de trabalho de GPU com provisionamento automático de recursos. Para saber mais, consulte a documentação API de GPU sem servidor.

Requisitos​

Antes de executar este Notebook, conecte-o à compute GPU sem servidor:

  1. No seletor compute , selecione GPU sem servidor .
  2. Na tab Ambiente , no lado direito, selecione A10 como Acelerador.

Verifique a conexão da GPU​

Execute o comando nvidia-smi para confirmar que seu notebook está conectado a uma GPU A10 e view as especificações da GPU.

Python
%sh nvidia-smi
Output
Wed Jan 14 19:31:33 2026
+-----------------------------------------------------------------------------------------+
| NVIDIA-SMI 550.144.03             Driver Version: 550.144.03     CUDA Version: 12.4     |
|-----------------------------------------+------------------------+----------------------+
| GPU  Name                 Persistence-M | Bus-Id          Disp.A | Volatile Uncorr. ECC |
| Fan  Temp   Perf          Pwr:Usage/Cap |           Memory-Usage | GPU-Util  Compute M. |
|                                         |                        |               MIG M. |
|=========================================+========================+======================|
|   0  NVIDIA A10G                    On  |   00000000:00:1E.0 Off |                    0 |
|  0%   22C    P8             23W /  300W |       1MiB /  23028MiB |      0%      Default |
|                                         |                        |                  N/A |
+-----------------------------------------+------------------------+----------------------+

+-----------------------------------------------------------------------------------------+
| Processes:                                                                              |
|  GPU   GI   CI        PID   Type   Process name                              GPU Memory |
|        ID   ID                                                               Usage      |
|=========================================================================================|
|  No running processes found                                                             |
+-----------------------------------------------------------------------------------------+

Importe a biblioteca de GPUs serverless .​

Importe a biblioteca serverless_gpu para acessar a API para executar funções em recursos de GPU.

Python
import serverless_gpu
Output
Warning: serverless_gpu is in Beta. The API is subject to change.

Criar uma função distribuída​

Use o decorador @distributed para criar um DistributedFunction que seja executado no recurso da GPU. Este decorador aceita os seguintes parâmetros:

  • gpus (int): Número de GPUs a serem usadas
  • gpu_type (Opcional[União[GPUType, str]]): O tipo de GPU a ser usado (obrigatório se remote=True). Tipos disponíveis: 'a10', 'h100'
  • remote (bool): Indica se a função deve ser executada em GPUs remotas (o padrão é False).
  • run_async (bool): Indica se a função deve ser executada de forma assíncrona (o padrão é False).
Python
from serverless_gpu import distributed

@distributed(gpus=1, gpu_type='a10', remote=True)
def foo(x):
  print('hello_world', x)
  return x


foo
Output
DistributedFunction(gpus=1, gpu_type=GPUType.A10, remote=True, run_async=False, func=foo)

execução da função distribuída​

Inicie o DistributedFunction usando o método .distributed() . Passe todos os argumentos necessários como parâmetros nomeados.

Python
foo.distributed(x=5)
Output
[5]

Treinamento distribuído com múltiplas GPUs​

Você pode executar várias GPUs A10 em paralelo para cargas de trabalho de treinamento distribuídas. O módulo serverless_gpu.runtime fornece funções auxiliares para gerenciar a execução distribuída:

  • get_local_rank()Obtenha a classificação local da GPU atual.
  • get_global_rank()Obtenha a classificação global em todas as GPUs.
  • get_world_size()Obtenha o número total de GPUs.

Observação: A execução em vários nós, até um máximo de 70 nós, pode demorar até 20 minutos para iniciar, sendo que cada nó subsequente demora mais tempo. Para execuções em larga escala, você poderá experimentar tempos de espera mais longos ou falhas ocasionais.

Python
# The runtime module includes helpers to be used during the GPU runtime (i.e. in the function body).
# These helpers include get_local_rank, get_global_rank, get_world_size
from serverless_gpu import runtime as rt

@distributed(gpus=3, gpu_type='a10', remote=True)
def multi_a10():
  return rt.get_global_rank(), rt.get_world_size()


multi_a10.distributed() # returns a list, one element per GPU

Output
[(0, 3), (1, 3), (2, 3)]

Próximos passos​

Saiba mais sobre compute GPU serverless :

Exemplo de caderno​

Comece agora: compute GPU sem servidor com GPUs A10

Abrir notebook em uma nova aba