As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

In-process recuperação e treinamento inútil

HyperPod o treinamento sem ponto de verificação usa redundância de modelo para permitir o treinamento tolerante a falhas. O princípio básico é que os estados do modelo e do otimizador sejam totalmente replicados em vários grupos de nós, com atualizações de peso e mudanças de estado do otimizador replicadas de forma síncrona em cada grupo. Quando ocorre uma falha, as réplicas íntegras concluem as etapas do otimizador e transmitem os model/optimizer estados atualizados às réplicas em recuperação.

Essa abordagem baseada em redundância de modelos permite vários mecanismos de tratamento de falhas:

Configurações sem necessidade de verificação

Aqui está o trecho principal do treinamento sem controle.

from hyperpod_checkpointless_training.inprocess.train_utils import wait_rank
    wait_rank()
      
def main():
    @HPWrapper(
        health_check=CudaHealthCheck(),
        hp_api_factory=HPAgentK8sAPIFactory(),
        abort_timeout=60.0,
        checkpoint_manager=PEFTCheckpointManager(enable_offload=True),
        abort=CheckpointlessAbortManager.get_default_checkpointless_abort(),
        finalize=CheckpointlessFinalizeCleanup(),
    )
    def run_main(cfg, caller: Optional[HPCallWrapper] = None):
        ...
        trainer = Trainer(
            strategy=CheckpointlessMegatronStrategy(...,
                num_distributed_optimizer_instances=2),
            callbacks=[..., CheckpointlessCallback(...)],
            )
        trainer.fresume = resume
        trainer._checkpoint_connector = CheckpointlessCompatibleConnector(trainer)
        trainer.wrapper = caller

Veja o exemplo para adicionar recursos de treinamento inúteis aos códigos.

Conceitos

Esta seção apresenta conceitos de treinamento inúteis. O treinamento da Checkpointless na Amazon SageMaker HyperPod oferece suporte à recuperação em processo. Essa interface de API segue um formato semelhante às APIs do NVRx.

Conceito - Re-Executable Bloco de código (RCB)

Quando ocorre uma falha, os processos íntegros permanecem ativos, mas uma parte do código deve ser reexecutada para recuperar os estados de treinamento e as pilhas do Python. Um bloco Re-executable de código (RCB) é um segmento de código específico que é executado novamente durante a recuperação de falhas. No exemplo a seguir, o RCB abrange todo o script de treinamento (ou seja, tudo em main ()), o que significa que cada recuperação de falha reinicia o script de treinamento enquanto preserva o modelo na memória e os estados do otimizador.

Conceito - Controle de falhas

Um módulo controlador de falhas recebe notificações quando ocorrem falhas durante o treinamento sem necessidade de verificação. Esse controlador de falhas inclui os seguintes componentes:

Conceito - Redundância do modelo

O treinamento de modelos grandes geralmente requer um tamanho paralelo de dados grande o suficiente para treinar modelos com eficiência. No paralelismo de dados tradicional, como PyTorch DDP e Horovod, o modelo é totalmente replicado. Técnicas mais avançadas de paralelismo de dados fragmentados, como o otimizador DeepSpeed Zero e o FSDP, também oferecem suporte ao modo de fragmentação híbrida, que permite fragmentar os model/optimizer estados dentro do grupo de fragmentação e replicar totalmente entre grupos de replicação. NeMo também tem esse recurso de fragmentação híbrida por meio de um argumento num_distributed_optimizer_instances, que permite redundância.

No entanto, adicionar redundância indica que o modelo não será totalmente fragmentado em todo o cluster, resultando em maior uso da memória do dispositivo. A quantidade de memória redundante variará dependendo das técnicas específicas de fragmentação do modelo implementadas pelo usuário. Os pesos, gradientes e memória de ativação do modelo de baixa precisão não serão afetados, pois são fragmentados por meio do paralelismo do modelo. O modelo mestre de alta precisão weights/gradients e os estados do otimizador serão afetados. Adicionar uma réplica de modelo redundante aumenta o uso da memória do dispositivo em aproximadamente o equivalente ao tamanho de um ponto de verificação DCP.

A fragmentação híbrida divide os coletivos de todos os grupos de DP em coletivos relativamente menores. Anteriormente, havia uma dispersão reduzida e uma coleta total em todo o grupo de DP. Depois da fragmentação híbrida, a redução da dispersão é executada somente dentro de cada réplica do modelo, e haverá uma redução total entre os grupos de réplicas do modelo. O all-gather também está sendo executado dentro de cada réplica do modelo. Como resultado, todo o volume de comunicação permanece praticamente inalterado, mas os coletivos funcionam com grupos menores, então esperamos uma melhor latência.

Conceito - Tipos de falha e reinicialização

A tabela a seguir registra diferentes tipos de falhas e mecanismos de recuperação associados. O treinamento da Checkpointless tenta primeiro a recuperação de falhas por meio de uma recuperação em andamento, seguida por uma reinicialização no nível do processo. Ele volta para uma reinicialização no nível do trabalho somente no caso de uma falha catastrófica (por exemplo, vários nós falham ao mesmo tempo).

Conceito - Proteção de bloqueio atômico para etapa otimizadora

A execução do modelo é dividida em três fases: propagação direta, propagação reversa e etapa otimizadora. O comportamento de recuperação varia de acordo com o tempo de falha:

Essa estratégia garante que as atualizações concluídas do otimizador nunca sejam descartadas, ajudando a reduzir o tempo de recuperação de falhas.

Diagrama de fluxo de treinamento Checkpointless

As etapas a seguir descrevem a detecção de falhas e o processo de recuperação sem necessidade de verificação:

Referência de API

wait_rank

hyperpod_checkpointless_training.inprocess.train_utils.wait_rank()

Aguarda e recupera as informações de classificação e, em seguida HyperPod, atualiza o ambiente de processo atual com variáveis de treinamento distribuídas.

Essa função obtém a atribuição de classificação correta e as variáveis de ambiente para treinamento distribuído. Ele garante que cada processo receba a configuração apropriada para sua função no trabalho de treinamento distribuído.

Parâmetros

Nenhum

Devoluções

Nenhum

Comportamento

Variáveis de ambiente

A função lê as seguintes variáveis de ambiente:

Aumenta

Exemplo

from hyperpod_checkpointless_training.inprocess.train_utils import wait_rank  

# Call before initializing distributed training  
wait_rank()  

# Now environment variables are properly set for this rank  
import torch.distributed as dist  
dist.init_process_group(backend='nccl')

Observações

Embalagem HP

class hyperpod_checkpointless_training.inprocess.wrap.HPWrapper(  
    *,  
    abort=Compose(HPAbortTorchDistributed()),  
    finalize=None,  
    health_check=None,  
    hp_api_factory=None,  
    abort_timeout=None,  
    enabled=True,  
    trace_file_path=None,  
    async_raise_before_abort=True,  
    early_abort_communicator=False,  
    checkpoint_manager=None,  
    check_memory_status=True)

Encapsulador de funções Python que permite recursos de reinicialização para um bloco de Re-executable código (RCB) em treinamento sem pontos de verificação. HyperPod

Esse invólucro fornece tolerância a falhas e recursos de recuperação automática monitorando a execução do treinamento e coordenando reinicializações em processos distribuídos quando ocorrem falhas. Ele usa uma abordagem de gerenciamento de contexto em vez de um decorador para manter os recursos globais durante todo o ciclo de vida do treinamento.

Parâmetros

Métodos

def __call__(self, fn)

Envolve uma função para ativar os recursos de reinicialização.

Parâmetros:

Devoluções:

Exemplo

from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import CheckpointManager  
from hyperpod_checkpointless_training.nemo_plugins.patches import patch_megatron_optimizer  
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_connector import CheckpointlessCompatibleConnector  
from hyperpod_checkpointless_training.inprocess.train_utils import HPAgentK8sAPIFactory  
from hyperpod_checkpointless_training.inprocess.abort import CheckpointlessFinalizeCleanup, CheckpointlessAbortManager   
      
@HPWrapper(  
    health_check=CudaHealthCheck(),  
    hp_api_factory=HPAgentK8sAPIFactory(),  
    abort_timeout=60.0,  
    checkpoint_manager=CheckpointManager(enable_offload=False),  
    abort=CheckpointlessAbortManager.get_default_checkpointless_abort(),  
    finalize=CheckpointlessFinalizeCleanup(),  
)def training_function():  
    # Your training code here  
    pass

Observações

HPCallWrapper

class hyperpod_checkpointless_training.inprocess.wrap.HPCallWrapper(wrapper)

Monitora e gerencia o estado de um bloco de código de reinicialização (RCB) durante a execução.

Essa classe lida com o ciclo de vida da execução do RCB, incluindo detecção de falhas, coordenação com outras categorias para reinicializações e operações de limpeza. Ele gerencia a sincronização distribuída e garante uma recuperação consistente em todos os processos de treinamento.

Parâmetros

Atributos.

Métodos

def initialize_barrier()

Aguarde a sincronização da HyperPod barreira depois de encontrar uma exceção do RCB.

def start_hp_fault_handling_thread()

Inicie a linha de tratamento de falhas para monitorar e coordenar falhas.

def handle_fn_exception(call_ex)

Processe exceções da função de execução ou RCB.

Parâmetros:

def restart(term_ex)

Execute o manipulador de reinicialização, incluindo finalização, coleta de lixo e verificações de integridade.

Parâmetros:

def launch(fn, *a, **kw)

Execute o RCB com o tratamento adequado de exceções.

Parâmetros:

def run(fn, a, kw)

Loop de execução principal que lida com reinicializações e sincronização de barreiras.

Parâmetros:

def shutdown()

Desligue o tratamento de falhas e os segmentos de monitoramento.

Observações

CudaHealthCheck

class hyperpod_checkpointless_training.inprocess.health_check.CudaHealthCheck(timeout=datetime.timedelta(seconds=30))

Garante que o contexto CUDA para o processo atual esteja em um estado saudável durante a recuperação inútil do treinamento.

Essa verificação de integridade é sincronizada com a GPU para verificar se o contexto CUDA não está corrompido após uma falha no treinamento. Ele executa operações de sincronização de GPU para detectar quaisquer problemas que possam impedir a retomada bem-sucedida do treinamento. A verificação de integridade é executada depois que os grupos distribuídos são destruídos e a finalização é concluída.

Parâmetros

Métodos

__call__(state, train_ex=None)

Execute a verificação de integridade do CUDA para verificar a integridade do contexto da GPU.

Parâmetros:

Devoluções:

Aumenta:

Preservação do estado: retorna o estado original e a exceção inalterados se todas as verificações forem aprovadas

Exemplo

import datetime  
from hyperpod_checkpointless_training.inprocess.health_check import CudaHealthCheck  
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
  
# Create CUDA health check with custom timeout  
cuda_health_check = CudaHealthCheck(  
    timeout=datetime.timedelta(seconds=60)  
)  
  
# Use with HPWrapper for fault-tolerant training  
@HPWrapper(  
    health_check=cuda_health_check,  
    enabled=True  
)  
def training_function():  
    # Your training code here  
    pass

Observações

HPAgentK8sAPIFactory

class hyperpod_checkpointless_training.inprocess.train_utils.HPAgentK8sAPIFactory()

Classe de fábrica para criar instâncias HPAgentk8SAPI que se comunicam com HyperPod a infraestrutura para coordenação de treinamento distribuído.

Essa fábrica fornece uma maneira padronizada de criar e configurar objetos HPAgentk8SAPI que lidam com a comunicação entre os processos de treinamento e o plano de controle. HyperPod Ele encapsula a criação do cliente de soquete subjacente e da instância da API, garantindo uma configuração consistente em diferentes partes do sistema de treinamento.

Métodos

__call__()

Crie e retorne uma instância HPAgentk8SAPI configurada para comunicação. HyperPod

Devoluções:

Exemplo

from hyperpod_checkpointless_training.inprocess.train_utils import HPAgentK8sAPIFactory  
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
from hyperpod_checkpointless_training.inprocess.health_check import CudaHealthCheck  
  
# Create the factory  
hp_api_factory = HPAgentK8sAPIFactory()  
  
# Use with HPWrapper for fault-tolerant training  
hp_wrapper = HPWrapper(  
    hp_api_factory=hp_api_factory,  
    health_check=CudaHealthCheck(),  
    abort_timeout=60.0,  
    enabled=True  
)  
  
@hp_wrapper  
def training_function():  
    # Your distributed training code here  
    pass

Observações

CheckpointManager

class hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager.CheckpointManager(  
    enable_checksum=False,  
    enable_offload=False)

Gerencia pontos de verificação na memória e recuperação ponto a ponto para tolerância a falhas sem pontos de verificação em treinamento distribuído.

Essa classe fornece a funcionalidade principal para o treinamento HyperPod sem pontos de verificação, gerenciando pontos de verificação do NeMo modelo na memória, validando a viabilidade da recuperação e orquestrando a transferência de pontos de verificação ponto a ponto de verificação ponto a ponto entre classificações saudáveis e fracassadas. Ele elimina a necessidade de disco I/O durante a recuperação, reduzindo significativamente o tempo médio de recuperação (MTTR).

Parâmetros

Atributos.

Métodos

save_checkpoint(trainer)

Salve o ponto de verificação do NeMo modelo na memória para uma possível recuperação sem sentido de verificação.

Parâmetros:

Observações:

delete_checkpoint()

Exclua o ponto de verificação na memória e execute operações de limpeza.

Observações:

try_checkpointless_load(trainer)

Tente uma recuperação sem sentido carregando o estado das classificações de pares.

Parâmetros:

Devoluções:

Observações:

checkpointless_recovery_feasible(trainer, include_checksum_verification=True)

Determine se a recuperação sem necessidade de verificação é possível para o cenário de falha atual.

Parâmetros:

Devoluções:

Critérios de validação:

store_rng_states()

Armazene todos os estados do gerador de números aleatórios para recuperação determinística.

Observações:

load_rng_states()

Restaure todos os estados de RNG para uma continuação determinística da recuperação.

Observações:

maybe_offload_checkpoint()

Descarregue o ponto de verificação da GPU para a memória da CPU se o descarregamento estiver ativado.

Observações:

Exemplo

from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import CheckpointManager  
# Use with HPWrapper for complete fault tolerance  
@HPWrapper(  
    checkpoint_manager=CheckpointManager(),  
    enabled=True  
)  
def training_function():  
    # Training code with automatic checkpointless recovery  
    pass

Validação: verifica a integridade do ponto de verificação usando somas de verificação (se habilitado)

Observações

PEFTCheckpointManager

class hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager.PEFTCheckpointManager(  
    *args,  
    **kwargs)

Gerencia pontos de verificação para PEFT (Parameter-Efficient Fine-Tuning) com base separada e manuseio do adaptador para uma recuperação otimizada sem pontos de verificação.

Esse gerenciador de pontos de verificação especializado se estende CheckpointManager para otimizar os fluxos de trabalho do PEFT, separando os pesos do modelo básico dos parâmetros do adaptador.

Parâmetros

Herda todos os parâmetros de CheckpointManager:

Atributos adicionais

Métodos

maybe_save_base_model(trainer)

Salve os pesos do modelo básico uma vez, filtrando os parâmetros do adaptador.

Parâmetros:

Observações:

save_checkpoint(trainer)

Salve o ponto de verificação do modelo do adaptador NeMo PEFT na memória para uma possível recuperação sem sentido de verificação.

Parâmetros:

Observações:

try_base_model_checkpointless_load(trainer)

Experimente a recuperação sem sentido dos pesos do modelo básico PEFT carregando o estado a partir de classificações de pares.

Parâmetros:

Devoluções:

Observações:

try_checkpointless_load(trainer)

Experimente a recuperação inútil dos pesos do adaptador PEFT carregando o estado a partir de classificações de pares.

Parâmetros:

Devoluções:

Observações:

is_adapter_key(key)

Verifique se a chave state dict pertence aos parâmetros do adaptador.

Parâmetros:

Devoluções:

Lógica de detecção:

maybe_offload_checkpoint()

Descarregue os pesos do modelo básico da GPU para a memória da CPU.

Observações:

Observações

Exemplo

from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import PEFTCheckpointManager  
# Use with HPWrapper for complete fault tolerance  
@HPWrapper(  
    checkpoint_manager=PEFTCheckpointManager(),  
    enabled=True  
)  
def training_function():  
    # Training code with automatic checkpointless recovery  
    pass

CheckpointlessAbortManager

class hyperpod_checkpointless_training.inprocess.abort.CheckpointlessAbortManager()

Classe de fábrica para criar e gerenciar composições de componentes abortados para verificar a tolerância a falhas sem sentido.

Essa classe de utilitário fornece métodos estáticos para criar, personalizar e gerenciar composições de componentes abortados usadas durante o tratamento de falhas em treinamentos inúteis HyperPod . Ele simplifica a configuração de sequências de interrupção que lidam com a limpeza de componentes de treinamento distribuídos, carregadores de dados e recursos específicos da estrutura durante a recuperação de falhas.

Parâmetros

Nenhum (todos os métodos são estáticos)

Métodos estáticos

get_default_checkpointless_abort()

Obtenha a instância de composição de aborto padrão contendo todos os componentes de cancelamento padrão.

Devoluções:

Componentes padrão:

create_custom_abort(abort_instances)

Crie uma composição de aborto personalizada com somente as instâncias de aborto especificadas.

Parâmetros:

Devoluções:

Aumenta:

override_abort(abort_compose, abort_type, new_abort)

Substitua um componente de cancelamento específico em uma instância do Compose por um novo componente.

Parâmetros:

Devoluções:

Aumenta:

Exemplo

from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
from hyperpod_checkpointless_training.nemo_plugins.callbacks import CheckpointlessCallback  
from hyperpod_checkpointless_training.inprocess.abort import CheckpointlessFinalizeCleanup, CheckpointlessAbortManager  
  
# The strategy automatically integrates with HPWrapper  
@HPWrapper(  
    abort=CheckpointlessAbortManager.get_default_checkpointless_abort(),  
    health_check=CudaHealthCheck(),  
    finalize=CheckpointlessFinalizeCleanup(),  
    enabled=True  
)  
def training_function():  
    trainer.fit(...)

Observações

CheckpointlessFinalizeCleanup

class hyperpod_checkpointless_training.inprocess.abort.CheckpointlessFinalizeCleanup()

Executa uma limpeza abrangente após a detecção de falhas para se preparar para a recuperação em processo durante o treinamento sem necessidade de verificação.

Esse manipulador de finalização executa operações de limpeza específicas da estrutura, incluindo Megatron/TransformerEngine aborto, limpeza de DDP, recarregamento de módulo e limpeza de memória, destruindo referências de componentes de treinamento. Ele garante que o ambiente de treinamento seja redefinido adequadamente para uma recuperação bem-sucedida durante o processo, sem exigir o encerramento total do processo.

Parâmetros

Nenhum

Atributos.

Métodos

__call__(*a, **kw)

Execute operações de limpeza abrangentes para a preparação da recuperação em andamento.

Parâmetros:

Operações de limpeza:

register_attributes(trainer)

Registre a instância do treinador para uso durante as operações de limpeza.

Parâmetros:

Integração com CheckpointlessCallback

from hyperpod_checkpointless_training.nemo_plugins.callbacks import CheckpointlessCallback  
from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
  
# The strategy automatically integrates with HPWrapper  
@HPWrapper(  
    ...  
    finalize=CheckpointlessFinalizeCleanup(),   
)  
def training_function():  
    trainer.fit(...)

Observações

CheckpointlessMegatronStrategy

class hyperpod_checkpointless_training.nemo_plugins.megatron_strategy.CheckpointlessMegatronStrategy(*args, **kwargs)

NeMo Estratégia Megatron com recursos integrados de recuperação sem pontos de verificação para treinamento distribuído tolerante a falhas.

Observe que o treinamento inútil requer pelo menos 2 num_distributed_optimizer_instances para que haja replicação otimizada. A estratégia também cuida do registro de atributos essenciais e da inicialização do grupo de processos.

Parâmetros

Herda todos os parâmetros de MegatronStrategy:

Atributos.

Métodos

setup(trainer)

Inicialize a estratégia e registre os componentes de tolerância a falhas com o treinador.

Parâmetros:

Operações de configuração:

setup_distributed()

Inicialize o grupo de processos usando TCPstore com prefixo ou conexão sem raiz.

load_model_state_dict(checkpoint, strict=True)

Carregue o ditado de estado do modelo com compatibilidade de recuperação inútil.

Parâmetros:

get_wrapper()

Obtenha a HPCallWrapper instância para coordenação de tolerância a falhas.

Devoluções:

is_peft()

Verifique se o PEFT (Parameter-Efficient Fine-Tuning) está ativado na configuração de treinamento verificando os retornos de chamada do PEFT

Devoluções:

teardown()

Substitua a desmontagem nativa PyTorch do Lightning para delegar a limpeza aos manipuladores de abortos.

Exemplo

from hyperpod_checkpointless_training.inprocess.wrap import HPWrapper  
  
# The strategy automatically integrates with HPWrapper  
@HPWrapper(  
    checkpoint_manager=checkpoint_manager,  
    enabled=True  
)  
def training_function():  
    trainer = pl.Trainer(strategy=CheckpointlessMegatronStrategy())  
    trainer.fit(model, datamodule)

CheckpointlessCallback

class hyperpod_checkpointless_training.nemo_plugins.callbacks.CheckpointlessCallback(  
    enable_inprocess=False,  
    enable_checkpointless=False,  
    enable_checksum=False,  
    clean_tensor_hook=False,  
    clean_lightning_module=False)

Retorno de chamada Lightning que integra o NeMo treinamento ao sistema de tolerância a falhas do treinamento sem pontos de verificação.

Esse retorno de chamada gerencia o rastreamento de etapas, o salvamento de pontos de verificação e a coordenação da atualização de parâmetros para recursos de recuperação em andamento. Ele serve como o principal ponto de integração entre os ciclos de treinamento do PyTorch Lightning e os mecanismos de treinamento HyperPod inúteis, coordenando as operações de tolerância a falhas em todo o ciclo de vida do treinamento.

Parâmetros

Atributos.

Métodos

get_wrapper_from_trainer(trainer)

Obtenha a HPCallWrapper instância do treinador para coordenar a tolerância a falhas.

Parâmetros:

Devoluções:

on_train_batch_start(trainer, pl_module, batch, batch_idx, *args, **kwargs)

Chamado no início de cada lote de treinamento para gerenciar o rastreamento e a recuperação de etapas.

Parâmetros:

on_train_batch_end(trainer, pl_module, outputs, batch, batch_idx)

Libere o bloqueio de atualização de parâmetros no final de cada lote de treinamento.

Parâmetros:

Observações:

get_peft_callback(trainer)

Recupere o retorno de chamada PEFT da lista de retorno de chamada do treinador.

Parâmetros:

Devoluções:

_try_adapter_checkpointless_restore(trainer, params_to_save)

Tente uma restauração inútil dos parâmetros do adaptador PEFT.

Parâmetros:

Observações:

Exemplo

from hyperpod_checkpointless_training.nemo_plugins.callbacks import CheckpointlessCallback  
from hyperpod_checkpointless_training.nemo_plugins.checkpoint_manager import CheckpointManager  
import pytorch_lightning as pl  
  
# Create checkpoint manager  
checkpoint_manager = CheckpointManager(  
    enable_checksum=True,  
    enable_offload=True  
)  
  
# Create checkpointless callback with full fault tolerance  
checkpointless_callback = CheckpointlessCallback(  
    enable_inprocess=True,  
    enable_checkpointless=True,  
    enable_checksum=True,  
    clean_tensor_hook=True,  
    clean_lightning_module=True  
)  
  
# Use with PyTorch Lightning trainer  
trainer = pl.Trainer(  
    callbacks=[checkpointless_callback],  
    strategy=CheckpointlessMegatronStrategy()  
)  
  
# Training with fault tolerance  
trainer.fit(model, datamodule=data_module)

Gerenciamento de memória

CheckpointlessCompatibleConnector

class hyperpod_checkpointless_training.nemo_plugins.checkpoint_connector.CheckpointlessCompatibleConnector()

PyTorch Conector de ponto de verificação Lightning que integra a recuperação sem ponto de verificação com o carregamento tradicional de pontos de verificação baseado em disco.

Esse conector amplia o PyTorch Lightning _CheckpointConnector para fornecer uma integração perfeita entre a recuperação sem ponto de verificação e a restauração padrão do ponto de verificação. Ele tenta primeiro a recuperação sem ponto de verificação e, em seguida, volta ao carregamento do ponto de verificação baseado em disco se a recuperação sem ponto de verificação não for viável ou falhar.

Parâmetros

Herda todos os parâmetros de _ CheckpointConnector

Métodos

resume_start(checkpoint_path=None)

Tente pré-carregar o ponto de verificação com prioridade de recuperação sem ponto de verificação.

Parâmetros:

resume_end()

Conclua o processo de carregamento do ponto de verificação e execute as operações pós-carregamento.

Observações

CheckpointlessAutoResume

class hyperpod_checkpointless_training.nemo_plugins.resume.CheckpointlessAutoResume()

Estende NeMo AutoResume com configuração atrasada para permitir a validação de recuperação sem pontos de verificação antes da resolução do caminho do ponto de verificação.

Essa classe implementa uma estratégia de inicialização em duas fases que permite que a validação de recuperação sem ponto de verificação ocorra antes de voltar ao carregamento tradicional de pontos de verificação baseado em disco. Ele atrasa condicionalmente a AutoResume configuração para evitar a resolução prematura do caminho do ponto de verificação, permitindo primeiro validar se a recuperação ponto CheckpointManager a ponto sem ponto de verificação é viável.

Parâmetros

Herda todos os parâmetros de AutoResume

Métodos

setup(trainer, model=None, force_setup=False)

Atrasar condicionalmente a AutoResume configuração para permitir a validação de recuperação sem necessidade de verificação.

Parâmetros:

Exemplo

from hyperpod_checkpointless_training.nemo_plugins.resume import CheckpointlessAutoResume  
from hyperpod_checkpointless_training.nemo_plugins.megatron_strategy import CheckpointlessMegatronStrategy  
import pytorch_lightning as pl  
  
# Create trainer with checkpointless auto-resume  
trainer = pl.Trainer(  
    strategy=CheckpointlessMegatronStrategy(),  
    resume=CheckpointlessAutoResume()  
)

Observações