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á.

Recuperação em processo e treinamento sem pontos de verificação

HyperPod o treinamento sem ponto de verificação usa redundância de modelo para permitir um treinamento tolerante a falhas. O princípio fundamental é que os estados do modelo e do otimizador sejam totalmente replicados em vários grupos de nós, com atualizações de peso e alterações de estado do otimizador replicadas de forma síncrona em cada grupo. Quando ocorre uma falha, as réplicas íntegras concluem suas etapas de otimização 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 pontos de verificação

Aqui está o trecho principal do treinamento sem pontos de verificação.

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 sem pontos de verificação aos códigos.

Conceitos

Esta seção apresenta conceitos de treinamento sem pontos de verificação. O treinamento Checkpointless na Amazon SageMaker HyperPod oferece suporte à recuperação em processo. Essa interface de API segue um formato semelhante ao NVRx APIs.

Conceito - Bloco de código reexecutável (RCB)

Quando ocorre uma falha, os processos íntegros permanecem ativos, mas uma parte do código deve ser executada novamente para recuperar os estados de treinamento e as pilhas de python. Um Bloco de Código Reexecutável (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 ponto 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 os 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 redução na dispersão e uma coleta total em todo o grupo de DP. Após a fragmentação híbrida, a redução de dispersão é executada somente dentro de cada réplica do modelo, e haverá uma redução total em todos 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 estão trabalhando com grupos menores, então esperamos uma latência melhor.

Conceito - Tipos de falha e reinicialização

A tabela a seguir registra diferentes tipos de falhas e mecanismos de recuperação associados. O treinamento Checkpointless tenta primeiro a recuperação de falhas por meio de uma recuperação em processo, seguida por uma reinicialização em nível de 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 para frente, propagação para trás e etapa do otimizador. O comportamento de recuperação varia com base no 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 sem pontos de verificação

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

Referência de API

wait_rank

hyperpod_checkpointless_training.inprocess.train_utils.wait_rank()

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

Essa função obtém a atribuição correta de classificação e as variáveis de ambiente para treinamento distribuído. Ele garante que cada processo obtenha 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

HPWrapper

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)

Invólucro de funções Python que permite os recursos de reinicialização de um Bloco de Código Reexecutável (RCB) em um 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 as reinicializações em processos distribuídos quando ocorrem falhas. Ele usa uma abordagem de gerenciador 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

HPCallEmbalagem

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 trata do ciclo de vida da execução do RCB, incluindo detecção de falhas, coordenação com outras classificações 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 após encontrar uma exceção do RCB.

def start_hp_fault_handling_thread()

Inicie a rosca 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 do RCB.

Parâmetros:

def restart(term_ex)

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

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 as linhas de tratamento e monitoramento de falhas.

Observações

CudaHealthCheck

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

Garante que o contexto CUDA do processo atual esteja em um estado saudável durante a recuperação do treinamento sem pontos de verificação.

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 da 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

HPAgentK8s APIFactory

class hyperpod_checkpointless_training.inprocess.train_utils.HPAgentK8sAPIFactory()

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

Essa fábrica fornece uma maneira padronizada de criar e configurar objetos HPAgent K8sAPI 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 HPAgent K8sapi 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 e peer-to-peer recuperação na memória para tolerância a falhas sem pontos de verificação em treinamentos distribuídos.

Essa classe fornece a funcionalidade principal para treinamento HyperPod sem pontos de verificação, gerenciando pontos de verificação de NeMo modelos na memória, validando a viabilidade de recuperação e orquestrando a transferência de pontos de peer-to-peer verificação 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 ponto de verificação.

Parâmetros:

Observações:

delete_checkpoint()

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

Observações:

try_checkpointless_load(trainer)

Tente uma recuperação sem pontos de verificação carregando o estado a partir de classificações de pares.

Parâmetros:

Devoluções:

Observações:

checkpointless_recovery_feasible(trainer, include_checksum_verification=True)

Determine se a recuperação sem ponto 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 a continuação da recuperação determinística.

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

PEFTCheckpointGerente

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 de adaptador para 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 de 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 ponto de verificação.

Parâmetros:

Observações:

try_base_model_checkpointless_load(trainer)

Tente a recuperação sem pontos de verificação de pesos do modelo base PEFT carregando o estado de classificações de pares.

Parâmetros:

Devoluções:

Observações:

try_checkpointless_load(trainer)

Tente a recuperação sem pontos de verificação dos pesos do adaptador PEFT carregando o estado das 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()

Transfira 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 de aborto para tolerância a falhas sem pontos de verificação.

Essa classe de utilitário fornece métodos estáticos para criar, personalizar e gerenciar composições de componentes de aborto usadas durante o tratamento de falhas em um treinamento sem pontos de HyperPod verificação. Ele simplifica a configuração de sequências de aborto 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 padrão de composição de aborto contendo todos os componentes de aborto padrão.

Devoluções:

Componentes padrão:

create_custom_abort(abort_instances)

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

Parâmetros:

Devoluções:

Aumenta:

override_abort(abort_compose, abort_type, new_abort)

Substitua um componente de aborto 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 pontos 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ódulos 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 do 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 durante o processo.

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 sem ponto de verificação requer pelo menos 2 num_distributed_optimizer_instances para que haja replicação do otimizador. 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 uma conexão TCPStore com prefixo ou sem raiz.

load_model_state_dict(checkpoint, strict=True)

Carregue o ditado de estado do modelo com compatibilidade de recuperação sem pontos de verificação.

Parâmetros:

get_wrapper()

Obtenha a instância do HPCall Wrapper para coordenação da tolerância a falhas.

Devoluções:

is_peft()

Verifique se o PEFT (Parameter-Efficient Fine-Tuning) está ativado na configuração do 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 abortamento.

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 relâmpago que integra o NeMo treinamento ao sistema de tolerância a falhas do checkpointless training.

Esse retorno de chamada gerencia o rastreamento de etapas, o salvamento de pontos de verificação e a coordenação de atualização de parâmetros para recursos de recuperação em processo. Ele serve como o principal ponto de integração entre os ciclos de treinamento do PyTorch Lightning e os mecanismos de treinamento HyperPod sem pontos de verificação, 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 instância do HPCall Wrapper do treinador para coordenação da 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 fazer 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 estende o PyTorch Lightning _CheckpointConnector para fornecer 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 para o 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 de pós-carregamento.

Observações

CheckpointlessAutoResume

class hyperpod_checkpointless_training.nemo_plugins.resume.CheckpointlessAutoResume()

Estende-se NeMo AutoResume com configuração atrasada para permitir a validação de recuperação sem ponto 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 da recuperação sem ponto de verificação ocorra antes de retornar ao carregamento tradicional do ponto 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 CheckpointManager a recuperação sem ponto de verificação peer-to-peer é viável.

Parâmetros

Herda todos os parâmetros de AutoResume

Métodos

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

Adie condicionalmente a AutoResume configuração para permitir a validação de recuperação sem pontos 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