DeepEP: Uma ferramenta de código aberto para otimizar a eficiência da comunicação especificamente para modelos MoE (DeepSeek Open Source Week Day 2)

Introdução geral

O DeepEP é uma biblioteca de comunicação de código aberto desenvolvida pela equipe deepseek-ai, com foco no aprimoramento da eficiência de treinamento e raciocínio dos modelos Mixture-of-Experts (MoE) e Expert Parallelism (EP). O DeepEP é compatível com as tecnologias NVLink e RDMA, é compatível com operações de baixa precisão, como FP8, e foi projetado com kernels de alta eficiência para cenários de treinamento e inferência, respectivamente. A biblioteca foi comprovada em batalha no ambiente de produção da equipe DeepSeek, especialmente para modelos MoE que exigem colaboração entre nós, o que pode melhorar significativamente o desempenho geral do sistema e é um assistente poderoso para pesquisadores e desenvolvedores de IA na criação de modelos eficientes de aprendizagem profunda. Atualmente, o DeepEP é de código aberto no GitHub, e a comunidade é bem-vinda para participar de seu aprimoramento.

Lista de funções

• Comunicações eficientes de todos para todosOtimização da comunicação total entre GPUs e suporte a NVLink intra-nó e RDMA inter-nó para garantir uma troca de dados rápida e estável.
• Suporte ao treinamento de alto rendimentoKernels: fornece kernels projetados para treinamento e pré-população de inferência que podem lidar com transferências de dados em grande escala e melhorar a eficiência do treinamento de modelos.
• Kernel de inferência de baixa latênciaPara a fase de inferência e decodificação, a tecnologia RDMA pura é usada para reduzir a latência, o que é adequado para cenários de aplicativos em tempo real.
• Aritmética de baixa precisão FP8Suporte nativo para distribuição FP8: reduz os custos de computação e mantém o desempenho para ambientes sensíveis a recursos.
• Controle flexível de recursosSuporte ao ajuste de contagem de multiprocessador (SM) de streaming, permitindo que os desenvolvedores otimizem a configuração de acordo com as condições de hardware.
• Sobreposição entre comunicações e computaçãoComunicação e computação contínuas por meio do mecanismo de gancho para melhorar a utilização da GPU.
• Otimização da largura de banda entre domíniosSuporte de encaminhamento de dados eficiente do NVLink para RDMA para o algoritmo Packet Limit Domain do DeepSeek-V3.

Usando a Ajuda

Processo de instalação

O DeepEP é um projeto de código aberto baseado no GitHub que requer download manual e configuração do ambiente a ser usado. Aqui estão as etapas detalhadas de instalação:

1. condições prévias

• sistema operacionalLinux (por exemplo, Ubuntu 20.04 ou posterior) é recomendado para compatibilidade com GPU e hardware de rede.
• Requisitos de hardwareEquipado com GPUs habilitadas para NVLink ou RDMA (por exemplo, NVIDIA H800) e conectado a redes de alta velocidade (por exemplo, InfiniBand 400Gb/s).
• dependência de software::
  • Kit de ferramentas CUDA (versão recomendada compatível com o hardware, como CUDA 11.x ou 12.x).
  • NCCL (Biblioteca de Comunicação Coletiva da NVIDIA).
  • Versão modificada do NVSHMEM (o DeepEP depende de seus recursos de comunicação e precisa ser instalado separadamente).
  • Python 3.8+ (para testes e execução de scripts).

2 - Faça o download do código-fonte do DeepEP

Abra um terminal e execute o seguinte comando para clonar o repositório:

git clone https://github.com/deepseek-ai/DeepEP.git
cd DeepEP

3. instalação do NVSHMEM

O DeepEP se baseia em uma versão modificada do NVSHMEM, consulte o documento oficialmente fornecidoGuia de instalação do NVSHMEM. As etapas resumidas são as seguintes:

• Faça o download do código-fonte do NVSHMEM e aplique o patch fornecido pelo DeepEP (localizado no diretóriothird-party/nvshmem.patch).
• Compilar e instalar:

  cd nvshmem
  patch -p1 < ... /third-party/nvshmem.patch
  make -j && sudo make install
  

4. compilação do DeepEP

Vá para o diretório DeepEP e compile a biblioteca de comunicação:

fazer

Após a compilação, são gerados arquivos de kernel que podem ser chamados no projeto.

5. configuração de variáveis de ambiente

Para garantir que o DeepEP funcione corretamente, os parâmetros relacionados ao NVSHMEM, como atribuições de canais virtuais, precisam ser definidos:

export NVSHMEM_IB_SL=0 # Configuração de canais virtuais para evitar conflitos de tráfego

Configurações adicionais estão disponíveis se você precisar ativar o roteamento adaptativo (somente kernels de baixa latência):

export NVSHMEM_ENABLE_ADAPTIVE_ROUTING=1

6. teste de instalação

Execute o script de teste fornecido para verificar a funcionalidade do DeepEP:

python tests/test_low_latency.py

Se a saída mostrar uma comunicação bem-sucedida, a instalação estará concluída.

Uso

O DeepEP é usado principalmente por meio de fluxos de trabalho integrados ao modelo MoE, e o que se segue é um guia detalhado de como usar os principais recursos:

Função 1: Executar treinamento de alto rendimento

O kernel de alto rendimento do DeepEP é adequado para o treinamento distribuído de modelos MoE. Supondo que você tenha um modelo baseado no DeepSeek-V3, você pode seguir as etapas abaixo:

1. Preparação de modelos e dadosVerifique se o seu modelo MoE está configurado com lógica paralela especializada e pronto para receber conjuntos de dados de treinamento.
2. Chamando o kernel do DeepEPInterface de comunicação completa do DeepEP: Introduzir a interface de comunicação completa do DeepEP no script de treinamento. Exemplo:

   #include "deep_ep.h"
   void moe_train(float* input, float* output, int size) {
   deep_ep_all_to_all(input, output, size, FP8);
   }
   

3. Hardware de configuraçãoEspecifique o dispositivo de GPU a ser usado, por exemplo:

   CUDA_VISIBLE_DEVICES=0,1,2,3 . /train_script
   

4. treinamento de corridaApós iniciar o treinamento, o DeepEP otimiza automaticamente a comunicação entre o NVLink e o RDMA.

Recurso 2: raciocínio de baixa latência

Os kernels de baixa latência são adequados para tarefas de raciocínio em tempo real, como sistemas de diálogo on-line:

1. Modelos de carregamentoCarregamento do modelo MoE pré-treinado na memória.
2. Chamando o núcleo de inferênciaRDMA: Use uma interface de comunicação RDMA pura. Exemplo:

   #include "deep_ep.h"
   void moe_infer(float* query, float* result, int batch_size) {
   deep_ep_low_latency_all_to_all(query, result, batch_size);
   }
   

3. Teste de velocidade de raciocínioExecute o seguinte comando para medir o atraso:

   python tests/test_inference.py --batch_size 128 --hidden_size 7168
   

   A saída mostrará o tempo de inferência para cada lote, garantindo que os requisitos em tempo real sejam atendidos.

Função 3: Otimização de computação do FP8

O DeepEP suporta a distribuição FP8 para reduzir os custos computacionais:

1. Ativar o modo FP8Especifique o tipo de dados como FP8 ao chamar a interface de comunicação.
2. Precisão da verificaçãoExecute o script de teste para comparar as diferenças de desempenho e precisão entre o FP8 e o BF16:

   python tests/test_fp8.py
   

3. Aplicação à produçãoIntegração de configurações do FP8 em processos de treinamento ou inferência existentes.

Função 4: Controle e otimização de recursos

Ajuste o número de SMs de acordo com o hardware:

1. Exibir o número de SMs de hardware: Usonvidia-smiVerifique o número de processadores de fluxo na GPU.
2. Definição de limites de SMEspecificado no script:

   deep_ep_set_sm_limit(32); // limite para 32 SMs
   

3. Desempenho do testeExecute benchmarks após ajustar o número de SMs para encontrar a melhor configuração.

advertência

• Configuração de redeO DeepEP é testado de forma ideal em redes InfiniBand, mas o RoCE exige uma verificação adicional de compatibilidade.
• Roteamento adaptativoApenas kernels de baixa latência suportam esse recurso; habilitá-lo para kernels normais pode resultar em deadlocks.
• Ajuste de clusterRecomenda-se executar todos os scripts de teste (por exemplotestes/), ajuste automaticamente a configuração para se adequar ao seu cluster.

Com essas etapas, você pode começar a usar o DeepEP rapidamente e aproveitar ao máximo seus recursos de otimização de comunicação no modelo MoE.