Distributed Training Deepspeed

# Skill DeepSpeed

Orientação especializada e abrangente para treinamento distribuído com DeepSpeed - estágios de otimização ZeRO, paralelismo de pipeline, FP16/BF16/FP8, 1-bit Adam, atenção esparsa

## Quando Usar Esta Skill

Esta skill deve ser acionada quando:
- Trabalhar com deepspeed
- Fazer perguntas sobre recursos ou APIs do deepspeed
- Implementar soluções com deepspeed
- Debugar código deepspeed
- Aprender boas práticas do deepspeed

## Referência Rápida

### Padrões Comuns

**Padrão 1:** Conteúdo DeepNVMe - Requisitos de Criação de Identificadores DeepNVMe - Uso de Identificadores DeepNVMe - Escrita de Arquivo Bloqueante - Escrita de Arquivo Não-Bloqueante - Escrita de Arquivo Paralela - Tensores Fixados em Memória - Juntando Tudo - Agradecimentos - Apêndice - Criação de Identificador Avançada - Ajuste de Desempenho - APIs DeepNVMe - APIs de E/S Gerais - APIs Específicas do GDS - APIs de Configuração de Identificador Este tutorial mostrará como usar DeepNVMe para transferências de dados entre armazenamento persistente e tensores residentes na memória do host ou do dispositivo. DeepNVMe melhora o desempenho e a eficiência de operações de E/S em aplicações de Deep Learning por meio de otimizações poderosas construídas sobre NVMe (Non-Volatile Memory Express) SSDs (Solid State Drives), E/S Assíncrona do Linux (libaio) e Storage Direto do GPU NVIDIA Magnum IO™ (GDS). Requisitos Certifique-se de que seu ambiente está adequadamente configurado para usar DeepNVMe. Primeiro, você precisa instalar a versão DeepSpeed >= 0.15.0. Em seguida, certifique-se de que os operadores DeepNVMe estão disponíveis na instalação do DeepSpeed. O operador async_io é necessário para qualquer funcionalidade DeepNVMe, enquanto o operador gds é necessário apenas para funcionalidade GDS. Você pode confirmar a disponibilidade de cada operador inspecionando a saída de ds_report para verificar que o status compatível é [OKAY]. Abaixo há um trecho da saída de ds_report confirmando a disponibilidade de ambos os operadores async_io e gds. Se o operador async_io não estiver disponível, você precisará instalar os binários apropriados da biblioteca libaio para sua distribuição Linux. Por exemplo, usuários do Ubuntu precisarão executar apt install libaio-dev. Em geral, você deve inspecionar cuidadosamente a saída de ds_report para dicas úteis, como as seguintes: [WARNING] async_io requer o objeto .so de desenvolvimento libaio e cabeçalhos, mas esses não foram encontrados. [WARNING] async_io: por favor instale o pacote libaio-dev com apt [WARNING] Se libaio já está instalado (talvez a partir da fonte), tente configurar as variáveis de ambiente CFLAGS e LDFLAGS para onde ele pode ser encontrado. Para ativar o operador gds, você precisará instalar o NVIDIA GDS consultando o guia apropriado para sistemas bare-metal ou VMs do Azure (em breve). Criando Identificadores DeepNVMe A funcionalidade DeepNVMe pode ser acessada através de duas abstrações: aio_handle e gds_handle. O aio_handle é utilizável tanto em tensores de host quanto de dispositivo, enquanto gds_handle funciona apenas em tensores CUDA, mas é mais eficiente. O primeiro passo para usar DeepNVMe é criar um identificador desejado. aio_handle requer operador async_io, enquanto gds_handle requer ambos operadores async_io e gds. Os seguintes trechos ilustram a criação de aio_handle e gds_handle respectivamente. ### Criar aio_handle

```python
from deepspeed.ops.op_builder import AsyncIOBuilder
aio_handle = AsyncIOBuilder().load().aio_handle()
```

### Criar gds_handle

```python
from deepspeed.ops.op_builder import GDSBuilder
gds_handle = GDSBuilder().load().gds_handle()
```

Para simplificar, os exemplos acima ilustram a criação de identificador com parâmetros padrão. Esperamos que identificadores criados com parâmetros padrão forneçam bom desempenho na maioria dos ambientes. No entanto, você pode ver abaixo para criação avançada de identificador. Usando Identificadores DeepNVMe aio_handle e gds_handle fornecem APIs idênticas para armazenar tensores em arquivos ou carregar tensores de arquivos. Uma característica comum dessas APIs é que elas pegam um tensor e um caminho de arquivo como argumentos para a operação de E/S desejada. Para melhor desempenho, tensores de dispositivo ou host fixados em memória devem ser usados para operações de E/S (veja aqui para detalhes). Para brevidade, este tutorial usará aio_handle para ilustração, mas tenha em mente que gds_handle funciona de forma similar. Você pode ver as APIs disponíveis em um shell Python via conclusão de aba em um objeto aio_handle. Isto é ilustrado usando conclusão de aba de h.. >python Python 3.10.12 (main, Jul 29 2024, 16:56:48) [GCC 11.4.0] on linux Digite "help", "copyright", "credits" or "license" para mais informações. >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle() >>> h. h.async_pread( h.free_cpu_locked_tensor( h.get_overlap_events( h.get_single_submit( h.new_cpu_locked_tensor( h.pwrite( h.sync_pread( h.wait( h.async_pwrite( h.get_block_size( h.get_queue_depth( h.get_intra_op_parallelism( h.pread( h.read( h.sync_pwrite( h.write( As APIs de interesse para executar operações de E/S são aquelas nomeadas com substrings pread e pwrite. Para brevidade, vamos focar nas APIs de escrita de arquivo, nomeadamente sync_pwrite, async_pwrite e pwrite. Discutiremos apenas sync_pwrite e async_pwrite abaixo porque são especializações de pwrite. Escrita de Arquivo Bloqueante sync_pwrite fornece a semântica bloqueante padrão da escrita de arquivo Python. O exemplo abaixo ilustra o uso de sync_pwrite para armazenar um tensor CUDA de 1GB em um arquivo NVMe local. >>> import os >>> os.path.isfile('/local_nvme/test_1GB.pt') False >>> import torch >>> t=torch.empty(1024**3, dtype=torch.uint8).cuda() >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle() >>> h.sync_pwrite(t,'/local_nvme/test_1GB.pt') >>> os.path.isfile('/local_nvme/test_1GB.pt') True >>> os.path.getsize('/local_nvme/test_1GB.pt') 1073741824 Escrita de Arquivo Não-Bloqueante Uma otimização importante de DeepNVMe é a semântica de E/S não-bloqueante que permite que threads Python sobreponham computações com operações de E/S. async_pwrite fornece a semântica não-bloqueante para escritas de arquivo. A thread Python pode depois usar wait() para sincronizar com a operação de E/S. async_write também pode ser usado para submeter múltiplas operações de E/S não-bloqueantes consecutivas, nas quais podem ser depois bloqueadas usando um único wait(). O exemplo abaixo ilustra o uso de async_pwrite para armazenar um tensor CUDA de 1GB em um arquivo NVMe local. >>> import os >>> os.path.isfile('/local_nvme/test_1GB.pt') False >>> import torch >>> t=torch.empty(1024**3, dtype=torch.uint8).cuda() >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle() >>> h.async_pwrite(t,'/local_nvme/test_1GB.pt') >>> h.wait() 1 >>> os.path.isfile('/local_nvme/test_1GB.pt') True >>> os.path.getsize('/local_nvme/test_1GB.pt') 1073741824 Aviso para operações de E/S não-bloqueante: Para evitar corridas de dados e corrupções, .wait() deve ser cuidadosamente usado para serializar a escrita de tensores de origem e a leitura de tensores de destino. Por exemplo, a seguinte atualização de t durante uma escrita de arquivo não-bloqueante é insegura e pode corromper /local_nvme/test_1GB.pt. >>> t=torch.empty(1024**3, dtype=torch.uint8).cuda() >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle() >>> h.async_pwrite(t,'/local_nvme/test_1GB.pt') >>> t += 1 # <--- Corrida de dados; evite precedendo com `h.wait()` Problemas de segurança similares se aplicam à leitura do tensor de destino de uma leitura de arquivo não-bloqueante sem sincronização .wait(). Escrita de Arquivo Paralela Uma otimização importante de DeepNVMe é a capacidade de paralelizar operações de E/S individuais. Esta otimização é habilitada especificando o grau de paralelismo desejado ao construir um identificador DeepNVMe. Operações de E/S subsequentes com esse identificador são automaticamente paralelizadas sobre o número solicitado de threads de host ou dispositivo, conforme apropriado. O paralelismo de E/S é composável com qualquer API de E/S bloqueante ou não-bloqueante. O exemplo abaixo ilustra paralelismo de 4 vias de uma escrita de arquivo usando async_pwrite. Note o uso do argumento intra_op_parallelism para especificar o grau de paralelismo desejado na criação do identificador. >>> import os >>> os.path.isfile('/local_nvme/test_1GB.pt') False >>> import torch >>> t=torch.empty(1024**3, dtype=torch.uint8).cuda() >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle(intra_op_parallelism=4) >>> h.async_pwrite(t,'/local_nvme/test_1GB.pt') >>> h.wait() 1 >>> os.path.isfile('/local_nvme/test_1GB.pt') True >>> os.path.getsize('/local_nvme/test_1GB.pt') 1073741824 Tensores Fixados em Memória Uma parte chave das otimizações DeepNVMe é usar acesso direto à memória (DMA) para operações de E/S, que requer que o tensor de host ou dispositivo seja fixado em memória. Para fixar tensores de host, você pode usar mecanismos fornecidos pelo PyTorch ou DeepSpeed Accelerators. O exemplo a seguir ilustra escrever um tensor CPU fixado em memória em um arquivo NVMe local. >>> import os >>> os.path.isfile('/local_nvme/test_1GB.pt') False >>> import torch >>> t=torch.empty(1024**3, dtype=torch.uint8).pin_memory() >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle() >>> h.async_pwrite(t,'/local_nvme/test_1GB.pt') >>> h.wait() 1 >>> os.path.isfile('/local_nvme/test_1GB.pt') True >>> os.path.getsize('/local_nvme/test_1GB.pt') 1073741824 Por outro lado, gds_handle fornece funções new_pinned_device_tensor() e pin_device_tensor() para fixar tensores CUDA. O exemplo a seguir ilustra escrever um tensor CUDA fixado em memória em um arquivo NVMe local. >>> import os >>> os.path.isfile('/local_nvme/test_1GB.pt') False >>> import torch >>> t=torch.empty(1024**3, dtype=torch.uint8).cuda() >>> from deepspeed.ops.op_builder import GDSBuilder >>> h = GDSBuilder().load().gds_handle() >>> h.pin_device_tensor(t) >>> h.async_pwrite(t,'/local_nvme/test_1GB.pt') >>> h.wait() 1 >>> os.path.isfile('/local_nvme/test_1GB.pt') True >>> os.path.getsize('/local_nvme/test_1GB.pt') 1073741824 >>> h.unpin_device_tensor(t) Juntando Tudo Esperamos que o material acima ajude você a começar com DeepNVMe. Você também pode usar os links a seguir para ver o uso de DeepNVMe em aplicações reais de Deep Learning. Permutador de parâmetros em ZeRO-Inference e ZeRO-Infinity. Permutador de otimizador em ZeRO-Infinity. Permutador de gradiente em ZeRO-Infinity. Operações simples de leitura e escrita de arquivo. Agradecimentos Este tutorial foi significativamente melhorado por feedback de Guanhua Wang, Masahiro Tanaka e Stas Bekman. Apêndice Criação de Identificador Avançada Atingir desempenho de E/S de pico com DeepNVMe requer configuração cuidadosa da criação de identificador. Em particular, os parâmetros dos construtores aio_handle e gds_handle são críticos para o desempenho porque determinam como o DeepNVMe interage eficientemente com o subsistema de armazenamento subjacente (ou seja, libaio, GDS, PCIe e SSD). Para conveniência, tornamos possível criar identificadores usando valores de parâmetro padrão que fornecerão desempenho decente na maioria dos cenários. No entanto, extrair todo desempenho disponível em seu ambiente provavelmente exigirá ajuste dos parâmetros do construtor, nomeadamente block_size, queue_depth, single_submit, overlap_events e intra_op_parallelism. Os parâmetros do construtor aio_handle e valores padrão são ilustrados abaixo: >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> help(AsyncIOBuilder().load().aio_handle()) Ajuda em aio_handle no módulo async_io object: class aio_handle(pybind11_builtins.pybind11_object) | Ordem de resolução de método: | aio_handle | pybind11_builtins.pybind11_object | builtins.object | | Métodos definidos aqui: | | __init__(...) | __init__(self: async_io.aio_handle, block_size: int = 1048576, queue_depth: int = 128, single_submit: bool = False, overlap_events: bool = False, intra_op_parallelism: int = 1) -> None | | Construtor aio_handle Ajuste de Desempenho Como discutido anteriormente, alcançar desempenho de pico do DeepNVMe para uma carga de trabalho ou ambiente alvo requer usar identificadores aio_handle ou gds_handle otimamente configurados. Para conveniência de configuração, fornecemos um utilitário chamado ds_nvme_tune para automatizar a descoberta de configurações DeepNVMe ótimas. ds_nvme_tune explora automaticamente um espaço de configuração especificado pelo usuário ou padrão e recomenda a opção que fornece melhor desempenho de leitura e escrita. Abaixo há um exemplo de uso de ds_nvme_tune para ajustar transferências de dados aio_handle entre memória GPU e um SSD NVMe local montado em /local_nvme. Este exemplo usou o espaço de configuração padrão de ds_nvme_tune para ajuste. $ ds_nvme_tune --nvme_dir /local_nvme --gpu Executando ajuste de desempenho DeepNVMe em ['/local_nvme/'] Melhor desempenho (GB/sec): leitura = 3.69, escrita = 3.18 { "aio": { "single_submit": "false", "overlap_events": "true", "intra_op_parallelism": 8, "queue_depth": 32, "block_size": 1048576 } } O ajuste acima foi executado em uma estação Lambda equipada com duas GPUs NVIDIA A6000-48GB, 252GB de DRAM e um SSD NVMe CS3040 2TB com velocidades de leitura e escrita de pico de 5,6 GB/s e 4,3 GB/s respectivamente. O ajuste levou aproximadamente quatro minutos e meio. Com base nos resultados, é possível esperar alcançar velocidades de transferência de leitura e escrita de 3,69 GB/seg e 3,18 GB/seg respectivamente usando um aio_handle configurado conforme abaixo. >>> from deepspeed.ops.op_builder import AsyncIOBuilder >>> h = AsyncIOBuilder().load().aio_handle(block_size=1048576, queue_depth=32, single_submit=False, overlap_events=True, intra_op_parallelism=8) As opções de linha de comando completas de ds_nvme_tune podem ser obtidas via -h ou --help. uso: ds_nvme_tune [-h] --nvme_dir NVME_DIR [NVME_DIR ...] [--sweep_config SWEEP_CONFIG] [--no_read] [--no_write] [--io_size IO_SIZE] [--gpu] [--gds] [--flush_page_cache] [--log_dir LOG_DIR] [--loops LOOPS] [--verbose] opções: -h, --help mostrar esta mensagem de ajuda e sair --nvme_dir NVME_DIR [NVME_DIR ...] Diretório em que realizar testes de E/S. Um diretório gravável em um dispositivo NVMe. --sweep_config SWEEP_CONFIG Arquivo de configuração json de varredura de desempenho. --no_read Desativar medições de desempenho de leitura. --no_write Desativar medições de desempenho de escrita. --io_size IO_SIZE Número de bytes de E/S para ler/escrever para medições de desempenho. --gpu Tensor de teste transferências entre GPU dispositivo e dispositivo NVME. --gds Executar a varredura sobre o operador NVIDIA GPUDirectStorage --flush_page_cache Cache de página não será limpo e velocidades de leitura relatadas podem ser maiores que reais ***Requer acesso sudo***. --log_dir LOG_DIR Diretório de saída para arquivos de log de desempenho. O padrão é ./_aio_bench_logs --loops LOOPS Contagem de repetições de operação --verbose Imprimir informações de depuração. APIs DeepNVMe Para conveniência, fornecemos listagem e breves descrições das APIs DeepNVMe. APIs de E/S Gerais As seguintes funções são usadas para operações de E/S com ambos aio_handle e gds_handle. Função Descrição async_pread Leitura de arquivo não-bloqueante em tensor sync_pread Leitura de arquivo bloqueante em tensor pread Leitura de arquivo com opções bloqueante e não-bloqueante async_pwrite Escrita de arquivo não-bloqueante a partir de tensor sync_pwrite Escrita de arquivo bloqueante a partir de tensor pwrite Escrita de arquivo com opções bloqueante e não-bloqueante wait Aguardar conclusão de operações de E/S não-bloqueante APIs Específicas do GDS As seguintes funções estão disponíveis apenas para gds_handle Função Descrição new_pinned_device_tensor Alocar e fixar um tensor de dispositivo free_pinned_device_tensor Desafixar e liberar um tensor de dispositivo pin_device_tensor Fixar um tensor de dispositivo unpin_device_tensor desafixar um tensor de dispositivo APIs de Configuração de Identificador As seguintes APIs podem ser usadas para investigar a configuração de identificador. Função Descrição get_queue_depth Retornar configuração de profundidade de fila get_single_submit Retornar se single_submit está habilitado get_intra_op_parallelism Retornar grau de paralelismo de E/S get_block_size Retornar configuração de tamanho de bloco de E/S get_overlap_events Retornar se overlap_event está habilitado Atualizado: 5 de novembro de 2025 Anterior Próximo

**Padrão 2:** Mixture of Experts para modelos NLG - Conteúdo 1. Instalação 2. Treinamento de modelos NLG+MoE 2.1. Alterações no modelo 2.2. Pré-treinamento do modelo MoE padrão 2.3. Pré-treinamento do modelo PR-MoE 2.4. Treinamento de MoS com tamanho de modelo reduzido Neste tutorial, introduzimos como aplicar DeepSpeed Mixture of Experts (MoE) a modelos NLG, que reduz o custo de treinamento em 5 vezes e reduz o tamanho do modelo MoE em 3 vezes (detalhes em nosso Blog). Usamos modelos do tipo GPT-3 no framework Megatron-LM como exemplo. Antes de ler este tutorial, recomendamos ler primeiro os tutoriais sobre Mixture of Experts e pré-treinamento Megatron-LM GPT. 1. Instalação Você precisaria instalar a versão DeepSpeed v0.6.0 ou superior para usar o recurso MoE. Os exemplos MoE para modelos NLG estão no repositório Megatron-DeepSpeed sob a pasta MoE. 2. Treinamento de modelos NLG+MoE 2.1. Alterações no modelo Para aplicar MoE ao modelo estilo GPT, fizemos várias alterações no framework Megatron, principalmente em megatron/model/ onde adicionamos as camadas MoE ao modelo. 2.2. Pré-treinamento do modelo MoE padrão Fornecemos scripts de treinamento de exemplo em examples_deepspeed/MoE que usamos para executar os experimentos em nosso Blog. Existem poucos novos hiperparâmetros para o modelo MoE padrão: --num-experts: o número de especialistas por camada MoE. Em nossos experimentos definimos para 128. Um número maior de especialistas tende a fornecer melhor convergência, mas há retornos decrescentes. --moe-expert-parallel-size: grau do paralelismo de especialistas MoE. Em outras palavras, haverá num-experts/moe-expert-parallel-size especialistas em cada GPU. Portanto, --moe-expert-parallel-size não deve ser maior que ambos número de GPUs e --num-experts. --moe-loss-coeff: coeficiente de escala para adicionar perda MoE à perda do modelo. Em nossos experimentos achamos que 0.01 é uma boa configuração. --moe-train-capacity-factor, --moe-eval-capacity-factor, --moe-min-capacity: essas configurações determinam quantos tokens um único especialista pode lidar. Números maiores poderiam levar a melhor convergência, mas também levariam a treinamento mais lento já que a carga seria mais desequilibrada em diferentes especialistas. --disable-moe-token-dropping: isto removerá completamente a limitação de quantos tokens um único especialista pode lidar. Pela mesma razão acima, recomendamos usar isto apenas durante inferência/avaliação. 2.3. Pré-treinamento do modelo PR-MoE PR-MoE é um modelo MoE de novo design, significando Pyramid-Residual-MoE, que melhora a eficiência de parâmetros até 3 vezes em comparação com MoE padrão. Por favor, veja nosso Blog para mais detalhes. Fornecemos scripts de treinamento de exemplo em examples_deepspeed/MoE. Existem poucos hiperparâmetros diferentes para o modelo PR-MoE comparado com MoE padrão: --num-experts: Em vez de fornecer um único número, para habilitar Pyramid-MoE, você precisa fornecer uma lista, cuja extensão é a mesma que o número de camadas MoE. Sugerimos usar mais especialistas no último estágio (próximo à saída) do modelo. --mlp-type: escolhido de [standard, residual]. Quando é residual, Residual-MoE é habilitado. Além dos novos hiperparâmetros acima para MoE padrão e PR-MoE, para modelos NLG+MoE achamos útil abaixar a taxa de aprendizado e aumentar a duração do decaimento de taxa de aprendizado comparado com o modelo denso base. Detalhes do nosso ajuste podem ser encontrados nos scripts de treinamento de exemplo. Quanto aos dados de treinamento, não somos capazes de liberar nossos dados internos, mas qualquer dado público para pré-treinamento Megatron-LM pode ser diretamente usado para treinar modelos MoE (com a ressalva de que pode não fornecer exatamente a mesma qualidade de modelo que em nossos experimentos). Por exemplo, avaliamos o dataset The Pile (pile.eleuther.ai, github.com/EleutherAI/the-pile) para ambos modelos denso e MoE. A Tabela 1 abaixo mostra que este dado público fornece resultados de avaliação similares ao nosso dado interno. Tamanho do modelo LAMBADA: predição de conclusão PIQA: raciocínio senso comum BoolQ: compreensão de leitura RACE-h: compreensão de leitura TriviaQA: resposta de perguntas WebQs: resposta de perguntas NLG Denso: 350M, dado interno 0.5203 0.6931 0.5364 0.3177 0.0321 0.0157 350M, Pile público 0.5106 0.6589 0.5933 0.3196 0.0257 0.0064 MoE Padrão NLG: 350M+MoE-128, dado interno 0.6270 0.7459 0.6046 0.3560 0.1658 0.0517 350M+MoE-128, Pile público 0.6128 0.7323 0.6040 0.3349 0.1111 0.0335 PR-MoE NLG: 350M+MoE-128, dado interno 0.6365 0.7399 0.5988 0.3569 0.1630 0.0473 PR-MoE + MoS NLG: 350M+MoE-128, dado interno 0.6346 0.7334 0.5807 0.3483 0.1369 0.0522 Tabela 1: Resultados de avaliação zero-shot (últimas seis colunas) para diferentes modelos NLG denso e MoE. Todos os resultados de avaliação zero-shot usam a métrica de acurácia. 2.4. Treinamento de MoS com tamanho de modelo reduzido MoS, significando Mixture-of-Students, é uma técnica baseada em destilação em estágio para comprimir modelos MoE grandes. MoS reduz ainda mais o tamanho do modelo em 12.5%, levando até redução de tamanho de modelo 3.7 vezes quando combinado com PR-MoE em relação ao MoE padrão. O tamanho do modelo reduzido ajuda a reduzir a latência e o custo durante inferência. Para treinar um modelo MoS, é preciso especificar alguns parâmetros adicionais. Usaremos PR-MoE como um exemplo: --mos: Isto habilitaria Mixture-of-Students via destilação de conhecimento. --load-teacher: Isto especifica o caminho para o checkpoint do modelo professor. Este é um argumento obrigatório para usar MoS e o checkpoint do modelo professor pode ser obtido treinando tanto um MoE padrão ou um PR-MoE. num-layers-teacher, --hidden-size-teacher, --hidden-size-teacher, --num-experts-teacher: Além do caminho do checkpoint do modelo professor, também precisamos especificar a arquitetura do modelo professor tal como seu número de camadas, tamanho de dimensão oculta e número de especialistas por camada MoE. No caso de PR-MoE, também precisamos fornecer uma lista de especialistas para o modelo professor, onde removemos poucas camadas de especialistas do modelo professor. Além dos novos parâmetros acima, observamos que usar o PR-MoE professor durante o processo de treinamento inteiro pode impactar adversamente a acurácia final do modelo aluno. Em nossos experimentos, usamos um método de destilação em estágio parando a destilação cedo no processo de treinamento (por ex., após 400K passos) e executar otimização apenas contra a perda de modelagem de linguagem padrão para o restante do treinamento. Fornecemos scripts de treinamento de exemplo em examples_deepspeed/MoE. Detalhes das nossas configurações de parâmetros podem ser encontrados nos scripts de treinamento de exemplo. Os resultados de desempenho de MoS podem ser vistos a partir de nosso blog post e nosso paper. Atualizado: 5 de novembro de 2025 Anterior Próximo

**Padrão 3:** MoS, significando Mixture-of-Students, é uma técnica baseada em destilação em estágio para comprimir modelos MoE grandes. MoS reduz ainda mais o tamanho do modelo em 12.5%, levando até redução de tamanho de modelo 3.7 vezes quando combinado com PR-MoE em relação ao MoE padrão. O tamanho do modelo reduzido ajuda a reduzir a latência e o custo durante inferência. Para treinar um modelo MoS, é preciso especificar alguns parâmetros adicionais. Usaremos PR-MoE como um exemplo:

```
--mos
```

**Padrão 4:** Teste de Intervalo de Taxa de Aprendizado -