GPU sem servidor compute

info

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-2 ou us-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:

• Ambiente GPU 4
• Ambiente GPU 3

nota

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:

1. No seletor compute do Notebook, selecione GPU sem servidor .
2. Clique em para abrir o painel lateral Ambiente .
3. Selecione A10 ou H100 no campo Acelerador .
4. Selecione a versão do ambiente .
5. Clique em Apply e, em seguida, confirme que deseja aplicar a GPU serverless compute ao ambiente do Notebook.

nota

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.

nota

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:

1. Selecione o botão programar no canto superior direito.
2. Selecione Adicionar programar .
3. Preencha o formulário Novo programar com o nomeJob , programar e compute .
4. 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

nota

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.

O senhor pode iniciar o treinamento distribuído em várias GPUs em um único nó ou em vários nós usando a GPU sem servidor Python API . Ele tem uma interface simples e unificada para executar trabalhos com uma ou várias GPUs, lidando automaticamente com o provisionamento da GPU, a configuração do ambiente e a distribuição da carga de trabalho nos bastidores. Se você estiver trabalhando com GPUs locais ou expandindo para todos os nós com GPUs remotas, serverless_gpu simplifica a execução distribuída, exigindo apenas alterações mínimas no código.

Por exemplo, o código abaixo usa serverless_gpu para distribuir a função hello_world para execução em 8 GPUs A10 remotas.

Python

# 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(s: str) -> None:
  print('hello_world ', s)

# Trigger the distributed execution of the hello_world function
hello_world.distributed(s='abc')

Depois de executar o código acima, os resultados e logs aparecem na seção Experiment (Experimento ) do seu site workspace.

Comece importando o Notebook inicial para começar a trabalhar com o API e, em seguida, explore os exemplos do Notebook para ver como ele é usado em cenários reais de treinamento distribuído.

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.

• Tarefa agendada em GPU sem servidor compute:

  • Suportado apenas para uma única tarefa.
  • O comportamento de recuperação automática para versões incompatíveis do pacote associadas ao seu Notebook não é suportado.

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:

Python

# 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 a GPU sem servidor compute para diferentes cenários.

Tarefa	Descrição
Grandes modelos de linguagem (LLMs)	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.
computador vision	Exemplos de tarefas de visão computacional, incluindo detecção de objetos e classificação de imagens.
Sistemas de recomendação baseados em aprendizagem profunda	Exemplos para criar sistemas de recomendação usando abordagens modernas de aprendizagem profunda, como modelos de duas torres.
ML clássico	Exemplos de machine learning tarefa tradicional, incluindo XGBoost treinamento de modelos e previsão de séries temporais.
Treinamento distribuído com várias GPUs e vários nós	Exemplos de escalonamento de treinamento em várias GPUs e nós usando a API de GPU sem servidor, incluindo ajuste fino distribuído.