GPU sem servidor compute
Beta
Esse recurso está na versão beta.
Este artigo descreve a serverless GPU compute em Databricks e fornece casos de uso recomendados, orientação sobre como configurar a GPU compute recurso e limitações de recurso.
O que é serverless GPU compute?
GPU sem servidor compute faz parte da oferta sem servidor compute. A GPU sem servidor compute é especializada em cargas de trabalho personalizadas de aprendizagem profunda de um ou vários nós. O senhor pode usar a GPU serverless compute para treinar e ajustar modelos personalizados usando suas estruturas favoritas e obter eficiência, desempenho e qualidade de última geração.
GPU sem servidor compute inclui:
- Uma experiência integrada no Notebook, Unity Catalog e MLflow : O senhor pode desenvolver seu código de forma interativa usando o Notebook.
- Aceleradores de GPU A10s e H100s: Use as GPUs A10 para tarefas econômicas, de pequeno a médio machine learning e aprendizagem profunda, como os modelos clássicos ML ou o ajuste fino de modelos de idiomas menores. Escolha as GPUs H100 para cargas de trabalho de grande escala AI, incluindo treinamento ou ajuste fino de modelos maciços ou execução de tarefas avançadas de aprendizagem profunda.
- Suporte a várias GPUs e vários nós: O senhor pode executar cargas de trabalho de treinamento distribuído com várias GPUs (A10s e H100s) e vários nós (somente A10s) usando a GPU sem servidor Python API. Consulte Treinamento distribuído.
O pacote pré-instalado no serverless GPU compute não substitui o Databricks Runtime ML. Embora haja um pacote comum, nem todas as dependências e biblioteca do Databricks Runtime ML são refletidas no ambiente do serverless GPU compute.
Casos de uso recomendados
Databricks recomenda a serverless GPU compute para qualquer caso de uso de treinamento de modelo que exija personalizações de treinamento e GPUs.
Por exemplo:
- Ajuste fino do LLM
- computador vision
- Sistemas de recomendação
- Aprendizagem por reforço
- aprendizagem profunda baseada em previsão de séries temporais
Requisitos
- Um workspace em
us-west-2ouus-east-1.
O que está instalado
A GPU sem servidor compute para Notebook usa versões de ambiente, que fornecem um cliente estável API para garantir a compatibilidade do aplicativo. Isso permite que a Databricks atualize o servidor de forma independente, oferecendo melhorias de desempenho, aprimoramentos de segurança e correções de bugs sem exigir nenhuma alteração de código nas cargas de trabalho.
Para obter mais detalhes, consulte as notas sobre a versão:
Os ambientes básicos não são compatíveis com a GPU serverless compute. Para configurar o serverless GPU compute em seu ambiente, especifique as dependências diretamente no painel lateral Environments ou pip install.
Configurar serverless GPU compute
Para conectar seu notebook ao serverless GPU compute e configurar o ambiente:
- No seletor compute do Notebook, selecione GPU sem servidor .
- Clique em
para abrir o painel lateral Ambiente . - Selecione A10 ou H100 no campo Acelerador .
- Selecione a versão do ambiente .
- Clique em Apply e, em seguida, confirme que deseja aplicar a GPU serverless compute ao ambiente do Notebook.
A conexão com o site compute é encerrada automaticamente após 60 minutos de inatividade.
Adicionar biblioteca ao ambiente
O senhor pode instalar uma biblioteca adicional no ambiente serverless GPU compute. Consulte Adicionar dependências ao Notebook.
Adicionar dependências usando o painel Ambientes , conforme mostrado em Adicionar dependências ao Notebook, não é compatível com uma tarefa agendada do GPU compute do serverless.
Criar e programar uma tarefa
As etapas a seguir mostram como criar e programar um trabalho para suas cargas de trabalho do serverless GPU compute. Para obter mais detalhes, consulte Criar e gerenciar tarefas agendadas do Notebook.
Após abrir o Caderno que deseja utilizar:
- Selecione o botão programar no canto superior direito.
- Selecione Adicionar programar .
- Preencha o formulário Novo programar com o nomeJob , programar e compute .
- Selecione Criar .
Também é possível criar e programar tarefas a partir da interface do usuário de tarefas e pipeline . Consulte Criar uma nova tarefa para obter orientações passo a passo.
Treinamento distribuído
O treinamento distribuído com várias GPUs é compatível com os H100s e os A10s. O treinamento distribuído em vários nós só é compatível com as GPUs A10.
Você pode iniciar o treinamento distribuído em várias GPUs — em um único nó ou em vários nós — usando a API Python da GPU sem servidor. A API fornece uma interface simples e unificada que abstrai a detalhes de provisionamento de GPU, configuração de ambiente e distribuição de carga de trabalho. Com código mínimo mudanças, você pode passar facilmente do treinamento de GPU única para a execução distribuída em ambientes remotos GPUs do mesmo notebook.
O decorador @distributed funciona de forma muito semelhante ao lançamento de treinamento multi-nó com torchrun, mas em
Python puro. Por exemplo, o snippet abaixo distribui a função hello_world em 8 remotos
GPUs 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 executado, logs e saídas de todos os trabalhadores são coletados e exibidos no Experimento seção do seu workspace.
A API suporta bibliotecas populares de treinamento paralelo, como Distributed Data Parallel (DDP), Fully Sharded Data Parallel (FSDP), DeepSpeed e Raio.
comece importando o Notebook inicial para colocar a mão na massa com a API e, em seguida, explore os exemplos do Notebook para ver como ele é usado em cenários reais de treinamento distribuído usando as diversas bibliotecas.
Para obter detalhes completos, consulte a documentação da GPU sem servidor Python API .
Limitações
- GPU sem servidor compute suporta apenas aceleradores A10 e H100.
- Os aceleradores H100 suportam apenas fluxo de trabalho e Job de nó único. O fluxo de trabalho de vários nós em H100s ainda não é compatível.
- O PrivateLink não é suportado. Armazenamento ou repositórios pip por trás do PrivateLink não são suportados.
- A GPU sem servidor compute não é compatível com o espaço de trabalho do perfil de segurança compliance (como HIPAA ou PCT) . O processamento de dados regulamentados não é suportado no momento.
- A GPU sem servidor compute é compatível apenas com ambientes interativos.
- Para trabalhos agendados em compute de GPU sem servidor, o comportamento de recuperação automática para versões de pacotes incompatíveis associadas ao seu Notebook não é suportado.
- O tempo máximo de execução de uma carga de trabalho é de sete dias. Para trabalhos de treinamento de modelo que excedam esse limite, implemente o ponto de verificação e reinicie o trabalho quando o tempo máximo de execução for atingido.
Lista de verificação de melhores práticas
Antes de executar um notebook usando o serverless GPU compute, verifique o seguinte:
-
Ambiente: Certifique-se de que sua biblioteca e seu pacote sejam compatíveis com a versão do ambiente serverless selecionada.
-
Armazenamento de pontos de controle: Verifique se o senhor está salvando os pontos de verificação em DBFS ou deixe-o não especificado para permitir que MLflow default para DBFS.
-
Evite usar
/Workspace, que tem um limite de 500 MB por tamanho de arquivo. -
Verifique o checkpoint mais cedo. Por exemplo, após 50 os passos, em vez de 1 época.
-
Registro do MLFlow: Defina o parâmetro logger o passo para um número suficientemente grande de lotes para evitar o registro de cada lote (default) e exceder o limite de 1 milhão de métricas o passo.
-
Lançamento de vários nós: adicione novas tentativas ou um tempo limite maior para evitar problemas de tempo limite de barreira.
O código a seguir mostra como implementar essas melhores práticas:
# Settings for a quick run to verify logging and checkpointing
# If using transformers
from transformers import TrainingArguments
training_args = TrainingArguments(
# checkpoint to /Vol if no symlinks created
output_dir = "/Volumes/your_catalog/your_schema/your_vol/your_model",
logging_strategy = "steps",
logging_steps = 10, # avoid exceeding mlflow 1M metric step limit
# save checkpoints earlier after 100 steps to verify checkpointing
save_strategy = "steps",
save_steps = 100,
# terminate job earlier after 200 steps as a trial run to verify logging and checkpointing
max_steps = 200,
...
)
Notebook exemplos
abaixo estão vários exemplos de Notebook que demonstram como usar compute de GPU sem servidor para diferentes tarefa.
Tarefa | Descrição |
|---|---|
Exemplos de ajuste fino de modelos de grandes linguagens, incluindo métodos eficientes em parâmetros, como adaptação de baixa classificação (LoRa) e abordagens de ajuste fino supervisionado. | |
Exemplos de tarefas de visão computacional, incluindo detecção de objetos e classificação de imagens. | |
Exemplos para criar sistemas de recomendação usando abordagens modernas de aprendizagem profunda, como modelos de duas torres. | |
Exemplos de machine learning tarefa tradicional, incluindo XGBoost treinamento de modelos e previsão de séries temporais. | |
Exemplos de escalonamento de treinamento em várias GPUs e nós usando a API de GPU sem servidor, incluindo ajuste fino distribuído. |
Abaixo estão exemplos de Notebooks que demonstram como usar diversas bibliotecas de treinamento distribuídas em compute de GPU sem servidor para treinamento multi-GPU.
Biblioteca | Descrição |
|---|---|
Exemplos de modelos de treinamento usando paralelismo de dados distribuídos. | |
Exemplos de modelos de treinamento usando paralelismo de dados totalmente fragmentados. | |
Exemplos de modelos de treinamento usando otimizações da biblioteca DeepSpeed. | |
Exemplos de treinamento de modelos usando a biblioteca Ray. |