Introdução geral

O DeepGEMM é um sistema de DeepSeek A biblioteca de código aberto FP8 GEMM (Generalised Matrix Multiplication) desenvolvida pela equipe tem como foco oferecer suporte eficiente a operações de matriz. Ela foi projetada especificamente para o Tensor Core da arquitetura NVIDIA Hopper e oferece suporte a operações de matriz comuns e operações GEMM agrupadas para modelos especializados mistos (MoE). Escrita em CUDA, a biblioteca é compilada no kernel em tempo de execução usando a compilação leve Just-In-Time (JIT), eliminando a necessidade de pré-compilação no momento da instalação e simplificando muito o processo de implantação. A DeepGEMM oferece desempenho excepcional, mantendo um código limpo, alcançando mais de 1.350 TFLOPS de potência de computação FP8 nas GPUs Hopper. Além de ser adequado para treinamento de modelos de aprendizado de máquina e aceleração de inferência, ele também é um excelente recurso para aprender a otimização de matrizes FP8 devido à sua natureza de código aberto e acessibilidade.

Lista de funções

-Oferece suporte a operações de matriz FP8GEMM (Generalised Matrix Multiplication) FP8 eficiente para cenários de computação de alto desempenho.
-Otimização do modelo MoESuporte para GEMM agrupado para modelos de especialistas híbridos, agrupados apenas para o eixo M, com especialistas em adaptação que compartilham a mesma forma da cena.
-Compilação Just-In-Time (JIT)Compilação do kernel em tempo de execução para se adaptar a diferentes ambientes de hardware sem pré-compilação.
-computação de alto desempenho (HPC)Obteve um rendimento de computação FP8 de mais de 1350 TFLOPS em GPUs NVIDIA Hopper.
-Design de código simplesCerca de 300 linhas de código principal, fácil de aprender e desenvolvimento secundário.
-alta compatibilidadeEle suporta GEMM normal e GEMM de pacote com máscara, o que é adequado para vários cenários de inferência.
-Código aberto e gratuitoPublicado sob o protocolo do MIT para pesquisa e uso comercial.

Usando a Ajuda

O DeepGEMM é uma biblioteca de aritmética de matriz de código aberto projetada para desenvolvedores, principalmente para usuários com algum conhecimento básico de programação CUDA e aprendizado de máquina. A seguir, um guia detalhado para ajudá-lo a começar rapidamente e integrá-lo ao seu projeto.

Processo de instalação

O DeepGEMM não requer um processo de pré-compilação complexo e pode ser instalado e o ambiente de tempo de execução configurado em apenas algumas etapas:
1.Preparação ambiental::

• Requisitos do sistema: GPUs compatíveis com a arquitetura NVIDIA Hopper (por exemplo, H100).
• Dependências de software: Instale o CUDA Toolkit (versão recomendada 11.8 ou superior) e Python (3.8+).
• Suporte de hardware: certifique-se de que seu dispositivo esteja equipado com uma GPU NVIDIA com pelo menos 40 GB de memória de vídeo.
  2.armazém de clones::
  Faça o download do repositório DeepGEMM localmente executando o seguinte comando em um terminal:

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

3. Instale a dependência:
   Use as ferramentas de gerenciamento de pacotes do Python para instalar as dependências necessárias:

pip install torch numpy

O DeepGEMM em si não requer compilação adicional, pois depende de técnicas de compilação on-the-fly e todos os kernels são gerados automaticamente em tempo de execução.
4. verifique a instalação:
Execute os scripts de teste fornecidos para garantir que o ambiente esteja configurado corretamente:

python test/deep_gemm_test.py

Se a saída mostrar resultados aritméticos normais da matriz, a instalação foi bem-sucedida.

Funções principais

1. execução de operações básicas do FP8 GEMM

O DeepGEMM oferece uma interface fácil de usar para realizar a multiplicação de matrizes FP8 não agrupadas:

• Procedimento operacional:
  • Importar bibliotecas e funções:

import torch
from deep_gemm import gemm_fp8_fp8_bf16_nt

• Prepare os dados de entrada (as matrizes A e B devem estar no formato FP8):

A = torch.randn(1024, 512, dtype=torch.float8_e4m3fn).cuda()
B = torch.randn(512, 1024, dtype=torch.float8_e4m3fn).cuda()

• Chame a função para realizar a multiplicação de matrizes:

C = gemm_fp8_fp8_bf16_nt(A, B)
print(C)

• Advertências:
  • A matriz de entrada precisa estar localizada na GPU e no formato FP8 (E4M3 ou E5M2).
  • A saída está no formato BF16, adequado para cálculos ou armazenamento subsequentes.

2. agrupamento da GEMM em apoio ao modelo MoE

Para usuários que precisam trabalhar com modelos MoE, o DeepGEMM oferece suporte a GEMM agrupado:

• Procedimento operacional:
  • Importar funções GEMM de agrupamento:

from deep_gemm import m_grouped_gemm_fp8_fp8_bf16_nt_contiguous

• Preparar dados de entrada para o layout contínuo:

A = torch.randn(4096, 512, dtype=torch.float8_e4m3fn).cuda() # Emenda de entrada para vários especialistas
B = torch.randn(512, 1024, dtype=torch.float8_e4m3fn).cuda()
group_sizes = [1024, 1024, 1024, 1024, 1024] # Cada especialista token frequentemente

• Executar o grupo GEMM:

C = m_grouped_gemm_fp8_fp8_bf16_nt_contiguous(A, B, group_sizes)
print(C)

• Advertências:
  • Os eixos M da matriz de entrada A precisam ser agrupados por especialistas e o tamanho de cada grupo precisa ser alinhado ao tamanho do bloco M do GEMM (disponível). get_m_alignment_for_contiguous_layout() (Acesso).
  • Os eixos N e K da matriz B precisam ser fixados.

3. agrupamento de máscaras no estágio de inferência GEMM

Na fase de decodificação de inferência, o DeepGEMM suporta GEMM agrupado usando máscaras para alocação dinâmica de tokens:

• Procedimento operacional:
  • Importe a função de agrupamento de máscaras:

from deep_gemm import m_grouped_gemm_fp8_fp8_bf16_nt_masked

• Prepare os dados de entrada e a máscara:

A = torch.randn(4096, 512, dtype=torch.float8_e4m3fn).cuda()
B = torch.randn(512, 1024, dtype=torch.float8_e4m3fn).cuda()
mask = torch.ones(4096, dtype=torch.bool).cuda() A máscara # indica um token válido

• Execute o agrupamento de máscaras GEMM:

C = m_grouped_gemm_fp8_fp8_bf16_nt_masked(A, B, mask)
print(C)

• Advertências:
  • As máscaras são usadas para especificar quais tokens precisam ser computados e são adequadas para raciocínio dinâmico quando os gráficos CUDA estão habilitados.

Funções em destaque Procedimento de operação

Otimização e depuração de alto desempenho

O ponto forte do DeepGEMM é sua eficiência e simplicidade, que os desenvolvedores podem otimizar e depurar ainda mais seguindo as etapas abaixo:

• Visualizar dados de desempenho:
  Adicione saída de registro para monitorar TFLOPS ao executar scripts de teste:

  importar logging
  logging.basicConfig(level=logging.INFO)
  C = gemm_fp8_fp8_bf16_nt(A, B)
  

Parâmetros de ajuste*:
Ajuste o tamanho do bloco (parâmetro TMA) de acordo com o hardware específico para otimizar a movimentação de dados e a sobreposição computacional; consulte o exemplo na pasta test/ da documentação.
Aprendizado e expansão*:
O código principal está localizado em deep_gemm/gemm_kernel.cu, com cerca de 300 linhas, e os desenvolvedores podem lê-lo diretamente e modificá-lo para atender aos requisitos personalizados.
Recomendações de uso
Requisitos de hardware*Atualmente, é compatível apenas com GPUs de arquitetura NVIDIA Hopper; outras arquiteturas ainda não estão adaptadas.
referência de documentação*: Descrições detalhadas das funções e exemplos de código podem ser encontrados nas pastas README.md e test/ dos repositórios do GitHub.
Suporte à comunidade*: Se encontrar problemas, envie comentários na página de problemas do GitHub e a equipe do DeepSeek responderá positivamente.
Com essas etapas, você pode integrar facilmente o DeepGEMM em seus projetos de aprendizado de máquina e aproveitar seu eficiente poder de computação de matriz FP8.