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á.
# HyperPod recursos de treinamento sem pontos de verificação
Consulte as páginas a seguir para saber mais sobre os recursos de treinamento no treinamento sem pontos de verificação.
**Topics**
+ [Repositórios de treinamento SageMaker HyperPod sem pontos de verificação da Amazon](#sagemaker-eks-checkpointless-repositories)
+ [Melhorias na inicialização da comunicação coletiva](sagemaker-eks-checkpointless-features-communication.md)
+ [Carregador de dados mapeado na memória](sagemaker-eks-checkpointless-features-mmap.md)
+ [Recuperação em processo e treinamento sem pontos de verificação](sagemaker-eks-checkpointless-in-process-recovery.md)
## Repositórios de treinamento SageMaker HyperPod sem pontos de verificação da Amazon
HyperPod o [treinamento sem ponto de verificação](https://github.com/aws/sagemaker-hyperpod-checkpointless-training#) acelera a recuperação de falhas de cluster em ambientes de treinamento distribuídos em grande escala por meio de otimizações em nível de estrutura. Essas otimizações são fornecidas por meio de uma imagem básica de contêiner que inclui melhorias aprimoradas na inicialização da NCCL, otimizações no carregamento de dados e componentes de recuperação em processo e sem pontos de verificação. O pacote de treinamento HyperPod checkpointless é construído sobre essa base.
O treinamento Checkpointless é habilitado por meio de três faixas de otimização que funcionam em conjunto:
+ **Melhorias na inicialização da comunicação (NCCL e Gloo)** - Elimine os gargalos de comunicação descentralizando as informações de classificação por pares e anéis (caixa vermelha abaixo).
+ **Otimizações de carregamento de dados** - Reduza o tempo necessário para fornecer o primeiro lote de dados durante as operações de reinicialização (caixas laranja abaixo).
+ **Redução da sobrecarga de reinicialização do programa** - Minimize os custos de reinicialização e possibilite o reabastecimento ininterrupto por meio da recuperação do processo em nós íntegros (caixas azuis e verdes abaixo).
![\[alt text not found\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-optimization-tracks.png)
# Melhorias na inicialização da comunicação coletiva
A NCCL e a Gloo são bibliotecas de comunicação fundamentais que permitem operações coletivas (como redução total e transmissão) em processos de treinamento distribuídos. No entanto, a inicialização tradicional do NCCL e do Gloo pode criar gargalos durante a recuperação de falhas.
O processo de recuperação padrão exige que todos os processos se conectem a um processo centralizado TCPStore e coordenado por meio de um processo raiz, introduzindo uma sobrecarga cara que se torna particularmente problemática durante as reinicializações. Esse design centralizado cria três problemas críticos: sobrecarga de coordenação decorrente de TCPStore conexões obrigatórias, atrasos na recuperação, pois cada reinicialização deve repetir a sequência de inicialização completa e um único ponto de falha no próprio processo raiz. Isso impõe etapas de coordenação caras e centralizadas toda vez que o treinamento é inicializado ou reiniciado.
HyperPod o treinamento sem ponto de verificação elimina esses gargalos de coordenação, permitindo uma recuperação mais rápida de falhas, tornando a inicialização “sem raiz” e “.” TCPStoreless
## Configurações sem raiz
Para habilitar o Rootless, basta expor as seguintes variáveis de ambiente.
```
export HPCT_USE_ROOTLESS=1 && \
sysctl -w net.ipv4.ip_local_port_range="20000 65535" && \
```
HPCT\$1USE\$1ROOTLESS: 0 ou 1. Use para ligar e desligar sem raiz
sysctl -w net.ipv4.ip\$1local\$1port\$1range="20000 65535": Defina o intervalo de portas do sistema
Veja [o exemplo](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/llama3/launch/pretrain_llama3_70b_checkpointless_p5.yaml#L111-L113) para habilitar o Rootless.
## Sem raízes
HyperPod O treinamento checkpointless oferece novos métodos de inicialização, Rootless e, para grupos de processos NCCL e TCPStoreless Gloo.
A implementação dessas otimizações envolve a modificação de NCCL, Gloo e: PyTorch
+ Estendendo APIs a biblioteca de terceiros para permitir otimizações NCCL e Gloo sem raiz e sem armazenamento, mantendo a compatibilidade com versões anteriores
+ Atualização de back-ends de grupos de processos para usar condicionalmente caminhos otimizados e lidar com problemas de recuperação em processo
+ Ignorando a TCPStore criação cara na camada PyTorch distribuída e mantendo padrões de endereço simétricos por meio de contadores de grupos globais
O gráfico a seguir mostra a arquitetura das bibliotecas de treinamento distribuídas e as mudanças feitas no treinamento sem pontos de verificação.
![\[O gráfico a seguir mostra a arquitetura das bibliotecas de treinamento distribuídas e as mudanças feitas no treinamento sem pontos de verificação.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-training-libraries.png)
### NCCL e Gloo
Esses são pacotes independentes que executam a funcionalidade principal das comunicações coletivas. Eles fornecem a chave APIs, como ncclCommInit Rank, para inicializar redes de comunicação, gerenciar os recursos subjacentes e realizar comunicações coletivas. Depois de fazer alterações personalizadas no NCCL e no Gloo, o Rootless e o Storeless otimizam (por exemplo, pulam a conexão com a) inicialização da rede de comunicação. TCPStore Você pode alternar entre usar os caminhos de código originais ou os caminhos de código otimizados de forma flexível.
### PyTorch backend do grupo de processos
Os back-ends do grupo de processos, especificamente ProcessGroup NCCL e ProcessGroupGloo, implementam o ProcessGroup APIs invocando suas bibliotecas subjacentes APIs correspondentes. Como ampliamos as bibliotecas de terceiros APIs, precisamos invocá-las adequadamente e fazer trocas de caminho de código com base nas configurações dos clientes.
Além dos caminhos do código de otimização, também alteramos o back-end do grupo de processos para oferecer suporte à recuperação em processo.
# Carregador de dados mapeado na memória
Outra sobrecarga de reinicialização decorre do carregamento de dados: o cluster de treinamento permanece ocioso enquanto o carregador de dados inicializa, baixa dados de sistemas de arquivos remotos e os processa em lotes.
Para resolver isso, apresentamos o carregador de dados mapeado em memória DataLoader (MMAP), que armazena em cache os lotes pré-buscados na memória persistente, garantindo que eles permaneçam disponíveis mesmo após uma reinicialização induzida por falhas. Essa abordagem elimina o tempo de configuração do carregador de dados e permite que o treinamento seja retomado imediatamente usando lotes em cache, enquanto o carregador de dados reinicializa e busca simultaneamente os dados subsequentes em segundo plano. O cache de dados reside em cada classificação que requer dados de treinamento e mantém dois tipos de lotes: lotes consumidos recentemente que foram usados para treinamento e lotes pré-buscados prontos para uso imediato.
![\[Esta imagem ilustra o carregador de dados MMAP, os caches e os lotes consumidos.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-mmap-dataloader.png)
O dataloader MMAP oferece dois recursos a seguir:
+ **Pré-busca de dados - busca** e armazena em cache proativamente os dados gerados pelo dataloader
+ **Cache persistente** - armazena lotes consumidos e pré-buscados em um sistema de arquivos temporário que sobrevive à reinicialização do processo
Usando o cache, o trabalho de treinamento se beneficiará de:
+ Espaço de **memória reduzido** - aproveita a memória mapeada I/O para manter uma única cópia compartilhada dos dados na memória da CPU do host, eliminando cópias redundantes nos processos da GPU (por exemplo, reduz de 8 cópias para 1 em uma instância p5 com 8) GPUs
+ **Recuperação mais rápida** - reduz o tempo médio de reinicialização (MTTR) ao permitir que o treinamento seja retomado imediatamente a partir dos lotes armazenados em cache, eliminando a espera pela reinicialização do carregador de dados e pela geração do primeiro lote
## Configurações do MMAP
Para usar o MMAP, basta passar o módulo de dados original para `MMAPDataModule`
```
data_module=MMAPDataModule(
data_module=MY_DATA_MODULE(...),
mmap_config=CacheResumeMMAPConfig(
cache_dir=self.cfg.mmap.cache_dir,
checkpoint_frequency=self.cfg.mmap.checkpoint_frequency),
)
```
`CacheResumeMMAPConfig`: os parâmetros do MMAP Dataloader controlam a localização do diretório de cache, os limites de tamanho e a delegação de busca de dados. Por padrão, somente a classificação TP 0 por nó busca dados da fonte, enquanto outras classificações no mesmo grupo de replicação de dados leem do cache compartilhado, eliminando transferências redundantes.
`MMAPDataModule`: Ele envolve o módulo de dados original e retorna o carregador de dados mmap para treinamento e validação.
Veja [o exemplo](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/gpt_oss/gpt_oss_120b_full_finetune_checkpointless.py#L101-L109) para habilitar o MMAP.
## Referência de API
### CacheResumeMMAPConfig
```
class hyperpod_checkpointless_training.dataloader.config.CacheResumeMMAPConfig(
cache_dir='/dev/shm/pdl_cache',
prefetch_length=10,
val_prefetch_length=10,
lookback_length=2,
checkpoint_frequency=None,
model_parallel_group=None,
enable_batch_encryption=False)
```
Classe de configuração para a funcionalidade do carregador de dados mapeado na memória (MMAP) em treinamento sem ponto de verificação. HyperPod
Essa configuração permite o carregamento eficiente de dados com recursos de armazenamento em cache e pré-busca, permitindo que o treinamento seja retomado rapidamente após falhas, mantendo lotes de dados em cache em arquivos mapeados na memória.
**Parâmetros**
+ **cache\$1dir** (str, opcional) — Caminho do diretório para armazenar lotes de dados em cache. Padrão: “/dev/shm/pdl\$1cache”
+ **prefetch\$1length** (int, opcional) — Número de lotes a serem pré-buscados com antecedência durante o treinamento. Padrão: 10
+ **val\$1prefetch\$1length** (int, opcional) — Número de lotes a serem pré-buscados com antecedência durante a validação. Padrão: 10
+ **lookback\$1length** (int, opcional) — Número de lotes usados anteriormente para manter em cache para possível reutilização. Padrão: 2
+ **checkpoint\$1frequency** (int, opcional) — Frequência das etapas de checkpoint do modelo. Usado para otimização do desempenho do cache. Padrão: nenhum
+ **model\$1parallel\$1group (object, optional) — Grupo** de processos para paralelismo de modelos. Se Nenhum, será criado automaticamente. Padrão: nenhum
+ **enable\$1batch\$1encryption** (bool, optional) — Se a criptografia deve ser ativada para dados em lote em cache. Padrão: False
**Métodos**
```
create(dataloader_init_callable,
parallel_state_util,
step,
is_data_loading_rank,
create_model_parallel_group_callable,
name='Train',
is_val=False,
cached_len=0)
```
Cria e retorna uma instância configurada do dataloader MMAP.
**Parâmetros**
+ **dataloader\$1init\$1callable (Callable**) — Função para inicializar o carregador de dados subjacente
+ **parallel\$1state\$1util (object) — Utilitário** para gerenciar o estado paralelo entre processos
+ **step** (int) — A etapa de dados a partir da qual continuar durante o treinamento
+ **is\$1data\$1loading\$1rank** (Callable) — Função que retorna True se a classificação atual deve carregar dados
+ **create\$1model\$1parallel\$1group\$1callable (Callable) — Função para criar um grupo** de processos paralelos do modelo
+ **name** (str, opcional) — Identificador de nome para o carregador de dados. Padrão: “Train”
+ **is\$1val** (bool, optional) — Se este é um carregador de dados de validação. Padrão: False
+ **cached\$1len** (int, opcional) — Tamanho dos dados em cache se forem retomados do cache existente. Padrão: 0
Retorna `CacheResumePrefetchedDataLoader` ou `CacheResumeReadDataLoader` — Instância configurada do carregador de dados MMAP
Aumenta `ValueError` se o parâmetro da etapa for`None`.
**Exemplo**
```
from hyperpod_checkpointless_training.dataloader.config import CacheResumeMMAPConfig
# Create configuration
config = CacheResumeMMAPConfig(
cache_dir="/tmp/training_cache",
prefetch_length=20,
checkpoint_frequency=100,
enable_batch_encryption=False
)
# Create dataloader
dataloader = config.create(
dataloader_init_callable=my_dataloader_init,
parallel_state_util=parallel_util,
step=current_step,
is_data_loading_rank=lambda: rank == 0,
create_model_parallel_group_callable=create_mp_group,
name="TrainingData"
)
```
**Observações**
+ O diretório de cache deve ter espaço suficiente e I/O desempenho rápido (por exemplo, /dev/shm para armazenamento na memória).
+ `checkpoint_frequency`A configuração melhora o desempenho do cache ao alinhar o gerenciamento do cache com o ponto de verificação do modelo
+ Para validação dataloaders (`is_val=True`), a etapa é redefinida para 0 e a inicialização a frio é forçada
+ Diferentes implementações de carregadores de dados são usadas com base no fato de a classificação atual ser responsável pelo carregamento de dados
### MMAPDataMódulo
```
class hyperpod_checkpointless_training.dataloader.mmap_data_module.MMAPDataModule(
data_module,
mmap_config,
parallel_state_util=MegatronParallelStateUtil(),
is_data_loading_rank=None)
```
Um DataModule wrapper PyTorch Lightning que aplica recursos de carregamento de dados mapeados em memória (MMAP) aos treinamentos existentes para fins de verificação sem necessidade de verificação. DataModules
Essa classe agrupa um PyTorch Lightning existente DataModule e o aprimora com a funcionalidade MMAP, permitindo um armazenamento eficiente de dados em cache e uma recuperação rápida durante falhas de treinamento. Ele mantém a compatibilidade com a DataModule interface original enquanto adiciona recursos de treinamento sem pontos de verificação.
Parâmetros
módulo de dados (pl. LightningDataModule)
O subjacente DataModule ao encapsulamento (por exemplo, LLMData Módulo)
mmap\$1config () MMAPConfig
O objeto de configuração MMAP que define o comportamento e os parâmetros de armazenamento em cache
`parallel_state_util`(MegatronParallelStateUtil, opcional)
Utilitário para gerenciar estados paralelos em processos distribuídos. Padrão: MegatronParallelStateUtil ()
`is_data_loading_rank`(Pode ser chamado, opcional)
Função que retorna True se a classificação atual precisar carregar dados. Se Nenhum, o padrão é parallel\$1state\$1util.is\$1tp\$10. Padrão: nenhum
**Atributos.**
`global_step` (int)
Etapa de treinamento global atual, usada para retomar a partir dos postos de controle
`cached_train_dl_len` (int)
Tamanho em cache do carregador de dados de treinamento
`cached_val_dl_len` (int)
Tamanho em cache do carregador de dados de validação
**Métodos**
```
setup(stage=None)
```
Configure o módulo de dados subjacente para o estágio de treinamento especificado.
`stage`(str, opcional)
Estágio do treinamento ('ajuste', 'validação', 'teste' ou 'previsão'). Padrão: nenhum
```
train_dataloader()
```
Crie o treinamento DataLoader com a embalagem MMAP.
*Retorna:* DataLoader — Treinamento empacotado em MMAP DataLoader com recursos de cache e pré-busca
```
val_dataloader()
```
Crie a validação DataLoader com o empacotamento MMAP.
*Retorna:* DataLoader — Validação DataLoader empacotada em MMAP com recursos de cache
```
test_dataloader()
```
Crie o teste DataLoader se o módulo de dados subjacente o suportar.
*Retorna:* DataLoader ou Nenhum — Teste DataLoader do módulo de dados subjacente, ou Nenhum se não for suportado
```
predict_dataloader()
```
Crie a previsão DataLoader se o módulo de dados subjacente a suportar.
*Retorna:* DataLoader ou Nenhum — Preveja a DataLoader partir do módulo de dados subjacente, ou Nenhum se não for suportado
```
load_checkpoint(checkpoint)
```
Carregue as informações do ponto de verificação para retomar o treinamento a partir de uma etapa específica.
ponto de verificação (ditado)
Dicionário de pontos de verificação contendo a chave 'global\$1step'
```
get_underlying_data_module()
```
Obtenha o módulo de dados empacotado subjacente.
*Devoluções:* pl. LightningDataModule — O módulo de dados original que foi empacotado
```
state_dict()
```
Obtenha o dicionário estadual do MMAP DataModule para pontos de verificação.
*Retorna:* dict — Dicionário contendo comprimentos de carregadores de dados em cache
```
load_state_dict(state_dict)
```
Carregue o dicionário de estado para restaurar o DataModule estado do MMAP.
`state_dict`(ditado)
Dicionário de estado a ser carregado
**Properties**
```
data_sampler
```
Exponha o amostrador de dados do módulo de dados subjacente à estrutura. NeMo
*Retorna:* objeto ou Nenhum — O amostrador de dados do módulo de dados subjacente
**Exemplo**
```
from hyperpod_checkpointless_training.dataloader.mmap_data_module import MMAPDataModule
from hyperpod_checkpointless_training.dataloader.config import CacheResumeMMAPConfig
from my_project import MyLLMDataModule
# Create MMAP configuration
mmap_config = CacheResumeMMAPConfig(
cache_dir="/tmp/training_cache",
prefetch_length=20,
checkpoint_frequency=100
)
# Create original data module
original_data_module = MyLLMDataModule(
data_path="/path/to/data",
batch_size=32
)
# Wrap with MMAP capabilities
mmap_data_module = MMAPDataModule(
data_module=original_data_module,
mmap_config=mmap_config
)
# Use in PyTorch Lightning Trainer
trainer = pl.Trainer()
trainer.fit(model, data=mmap_data_module)
# Resume from checkpoint
checkpoint = {"global_step": 1000}
mmap_data_module.load_checkpoint(checkpoint)
```
**Observações**
+ O wrapper delega a maioria dos atributos de acesso ao módulo de dados subjacente usando \$1\$1getattr\$1\$1
+ Somente as classificações de carregamento de dados realmente inicializam e usam o módulo de dados subjacente; outras classificações usam carregadores de dados falsos
+ Os comprimentos do carregador de dados em cache são mantidos para otimizar o desempenho durante a retomada do treinamento
# 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:
+ **Recuperação em processo:** os processos permanecem ativos apesar das falhas, mantendo todos os estados do modelo e do otimizador na memória da GPU com os valores mais recentes
+ **Tratamento eficiente de abortos: abortos** controlados e limpeza de recursos para as operações afetadas
+ **Reexecução do bloco de código:** reexecutando somente os segmentos de código afetados em um Bloco de Código Reexecutável (RCB)
+ **Recuperação sem pontos de verificação sem perda do progresso do treinamento:** como os processos persistem e os estados permanecem na memória, nenhum progresso do treinamento é perdido; quando ocorre uma falha, o treinamento é retomado a partir da etapa anterior, em vez de ser retomado a partir do último ponto de verificação salvo
**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
```
+ `wait_rank`: Todas as classificações aguardarão as informações de classificação da HyperpodTrainingOperator infraestrutura.
+ `HPWrapper`: invólucro de função Python que permite recursos de reinicialização para um Bloco de Código Reexecutável (RCB). A implementação usa um gerenciador de contexto em vez de um decorador Python porque os decoradores não podem determinar o número de monitores a RCBs serem monitorados em tempo de execução.
+ `CudaHealthCheck`: garante que o contexto CUDA do processo atual esteja em um estado íntegro por meio da sincronização com a GPU. Usa o dispositivo especificado pela variável de ambiente LOCAL\$1RANK ou usa como padrão o dispositivo CUDA do thread principal se LOCAL\$1RANK não estiver definido.
+ `HPAgentK8sAPIFactory`: essa API permite que o treinamento sem pontos de verificação consulte o status de treinamento de outros pods no cluster de treinamento do Kubernetes. Ele também fornece uma barreira em nível de infraestrutura que garante que todas as fileiras concluam com êxito as operações de abortamento e reinicialização antes de continuar.
+ `CheckpointManager`: gerencia pontos de verificação e peer-to-peer recuperação na memória para tolerância a falhas sem pontos de verificação. Ela tem as seguintes responsabilidades principais:
+ **Gerenciamento de pontos de verificação na memória**: salva e gerencia os pontos de verificação NeMo do modelo na memória para uma recuperação rápida sem disco I/O durante cenários de recuperação sem pontos de verificação.
+ **Validação da viabilidade de recuperação**: determina se a recuperação sem pontos de verificação é possível validando a consistência global das etapas, a integridade da classificação e a integridade do estado do modelo.
+ **Peer-to-Peer Orquestração de recuperação**: coordena a transferência de pontos de verificação entre classificações saudáveis e falhadas usando comunicação distribuída para recuperação rápida.
+ **Gerenciamento de estado RNG**: preserva e restaura estados geradores de números aleatórios em Python, NumPy PyTorch, e Megatron para recuperação determinística.
+ **[Opcional] Descarga do ponto de verificação: descarregue** no ponto de verificação da memória para a CPU se a GPU não tiver capacidade de memória suficiente.
+ `PEFTCheckpointManager`: Ele se estende `CheckpointManager` mantendo os pesos do modelo básico para o ajuste fino do PEFT.
+ `CheckpointlessAbortManager`: gerencia as operações de aborto em um thread em segundo plano quando um erro é encontrado. Por padrão, ele aborta TransformerEngine, Checkpointing TorchDistributed, e. DataLoader Os usuários podem registrar manipuladores de aborto personalizados conforme necessário. Após a conclusão do aborto, toda a comunicação deve ser interrompida e todos os processos e threads devem ser encerrados para evitar vazamentos de recursos.
+ `CheckpointlessFinalizeCleanup`: manipula as operações finais de limpeza no encadeamento principal para componentes que não podem ser abortados ou limpos com segurança no encadeamento em segundo plano.
+ `CheckpointlessMegatronStrategy`: Isso é herdado do `MegatronStrategy` de Nemo. 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, por exemplo, sem root.
+ `CheckpointlessCallback`: Retorno de chamada relâmpago que integra o NeMo treinamento ao sistema de tolerância a falhas do checkpointless training. Ela tem as seguintes responsabilidades principais:
+ **Gerenciamento do ciclo de vida da etapa de treinamento**: monitora o progresso do treinamento e ParameterUpdateLock coordena a recuperação enable/disable sem pontos de verificação com base no estado do treinamento (primeira etapa versus etapas subsequentes).
+ **Coordenação do estado do ponto de verificação**: gerencia o salvamento/restauração do ponto de verificação do modelo base PEFT na memória.
+ `CheckpointlessCompatibleConnector`: uma PTL `CheckpointConnector` que tenta pré-carregar o arquivo do ponto de verificação na memória, com o caminho de origem determinado nesta prioridade:
+ experimente a recuperação sem pontos de verificação
+ se o checkpointless retornar None, volte para parent.resume\$1start ()
Veja [o exemplo](https://github.com/aws/sagemaker-hyperpod-checkpointless-training/blob/main/examples/gpt_oss/gpt_oss_120b_full_finetune.py) 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:
+ **Módulo de detecção de falhas:** recebe notificações de falhas de infraestrutura
+ **Definição de RCB APIs:** permite que os usuários definam o bloco de código reexecutável (RCB) em seu código
+ **Módulo de reinicialização:** encerra o RCB, limpa os recursos e reinicia o RCB
![\[Esta imagem ilustra como um módulo controlador de falhas recebe notificações quando ocorre uma falha durante um treinamento sem ponto de verificação.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-fault-controller-module.png)
**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\$1distributed\$1optimizer\$1instances, 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 nos 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).
| Tipo de falha | Causa | Tipo de recuperação | Mecanismo de recuperação |
| --- | --- | --- | --- |
| Falha no processo | Erros em nível de código, exceções | Recuperação em processo (IPR) | Execute novamente o RCB dentro do processo existente; processos saudáveis permanecem ativos |
| Falha na reinicialização do processo | Contexto CUDA corrompido, processo encerrado | Reinício no nível do processo (PLR) | SageMaker HyperPod o operador de treinamento reinicia os processos; ignora a reinicialização do pod K8s |
| Falha na substituição do nó | Falha permanente node/GPU de hardware | Job Level Restart (JLR) | Substitua o nó com falha; reinicie todo o trabalho de treinamento |
**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:
+ **Propagação para frente/para trás:** reverta para o início da etapa de treinamento atual e transmita os estados do modelo para os nós de substituição
+ **Etapa do otimizador:** permitir que réplicas íntegras concluam a etapa de proteção bloqueada e, em seguida, transmita os estados atualizados do modelo para os nós de substituição
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.
![\[Esta imagem ilustra como a falha é tratada, dependendo se ela ocorre antes ou depois da falha.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-optimizer.png)
## Diagrama de fluxo de treinamento sem pontos de verificação
![\[Este diagrama ilustra o fluxo de treinamento sem pontos de verificação.\]](http://docs.aws.amazon.com/pt_br/sagemaker/latest/dg/images/hyperpod/hyperpod-checkpointless-training-flow.png)
As etapas a seguir descrevem a detecção de falhas e o processo de recuperação sem pontos de verificação:
1. Início do ciclo de treinamento
1. A falha ocorre
1. Avalie a viabilidade de um currículo sem pontos de verificação
1. Verifique se é possível fazer um currículo sem pontos de verificação
+ Se possível, tente retomar o checkpoint sem precisar
+ Se a retomada falhar, volte para o ponto de verificação de carregamento a partir do armazenamento
+ Se a retomada for bem-sucedida, o treinamento continuará a partir do estado recuperado
+ Se não for viável, volte para o ponto de verificação carregando do armazenamento
1. Limpe os recursos - aborte todos os grupos de processos e back-ends e libere recursos em preparação para a reinicialização.
1. Retomar o ciclo de treinamento - um novo ciclo de treinamento começa e o processo retorna à etapa 1.
## Referência de API
### wait\$1rank
```
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**
+ **Verificação do processo**: ignora a execução se for chamada a partir de um subprocesso (só é executado em) MainProcess
+ **Recuperação de ambiente**: obtém variáveis de ambiente atuais `RANK` e `WORLD_SIZE` a partir de
+ **HyperPod Comunicação**: chamadas `hyperpod_wait_rank_info()` para recuperar informações de classificação de HyperPod
+ **Atualização do ambiente: atualiza** o ambiente de processo atual com variáveis de ambiente específicas do trabalhador recebidas de HyperPod
**Variáveis de ambiente**
A função lê as seguintes variáveis de ambiente:
+ **RANK** (*int*) — Classificação atual do processo (padrão: -1 se não estiver definido)
+ **WORLD\$1SIZE** (*int*) — Número total de processos na tarefa distribuída (padrão: 0 se não estiver definido)
**Aumenta**
+ **AssertionError**— Se a resposta de não HyperPod estiver no formato esperado ou se faltarem campos obrigatórios
**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**
+ Só é executado no processo principal; as chamadas do subprocesso são automaticamente ignoradas
+ A função bloqueia até HyperPod fornecer as informações de classificação
### 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**
+ **abort** (Abortar, *opcional*) — *aborta* a execução de forma assíncrona quando falhas são detectadas. Padrão: `Compose(HPAbortTorchDistributed())`
+ **finalize (*Finalize***, *opcional*) — Manipulador de finalização local de classificação executado durante a reinicialização. Padrão: `None`
+ **health\$1check** (*HealthCheck*, *opcional*) — Verificação de integridade local de classificação executada durante a reinicialização. Padrão: `None`
+ **hp\$1api\$1factory** (*Callable*, *optional*) — Função de fábrica para criar uma API com a qual interagir. HyperPod HyperPod Padrão: `None`
+ **abort\$1timeout** (*float*, *optional*) — Tempo limite para abortar a chamada no thread de controle de falhas. Padrão: `None`
+ **ativado** (*bool*, *opcional*) — Ativa a funcionalidade do wrapper. Quando`False`, o invólucro se torna uma passagem. Padrão: `True`
+ **trace\$1file\$1path** (*str*, *opcional*) — Caminho para o arquivo de rastreamento para criação de perfil. VizTracer Padrão: `None`
+ **async\$1raise\$1before\$1abort (*bool*, *opcional*) — Ative o aumento antes do aborto** no thread de controle de falhas. Padrão: `True`
+ **early\$1abort\$1communicator (*bool*, *opcional*) — Aborta o comunicador** (NCCL/gloo) antes de abortar o carregador de dados. Padrão: `False`
+ **checkpoint\$1manager** (*Qualquer*, *opcional*) — Gerenciador para lidar com pontos de verificação durante a recuperação. Padrão: `None`
+ **check\$1memory\$1status** (*bool*, *opcional*) — Ative a verificação e o registro do status da memória. Padrão: `True`
**Métodos**
```
def __call__(self, fn)
```
*Envolve uma função para ativar os recursos de reinicialização.*
**Parâmetros:**
+ **fn** (*Callable*) — A função a ser concluída com recursos de reinicialização
**Devoluções:**
+ **Chamável** — Função embrulhada com recursos de reinicialização ou função original se desativada
**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**
+ O invólucro `torch.distributed` precisa estar disponível
+ Quando`enabled=False`, o invólucro se torna uma passagem e retorna a função original inalterada
+ O invólucro mantém recursos globais, como segmentos de monitoramento em todo o ciclo de vida do treinamento
+ Suporta a VizTracer criação de perfil quando `trace_file_path` é fornecido
+ Integra-se ao tratamento HyperPod coordenado de falhas em treinamentos distribuídos
### 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**
+ **wrapper** (*HPWrapper*) — O wrapper principal contendo configurações globais de recuperação em processo
**Atributos.**
+ **step\$1upon\$1restart** (*int*) — Contador que rastreia as etapas desde a última reinicialização, usado para determinar a estratégia de reinicialização
**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:**
+ **call\$1ex** (*Exception*) — Exceção da função de monitoramento
```
def restart(term_ex)
```
Execute o manipulador de reinicialização, incluindo finalização, coleta de lixo e verificações de saúde.
**Parâmetros:**
+ **term\$1ex** (*RankShouldRestart*) — Exceção de rescisão que aciona a reinicialização
```
def launch(fn, *a, **kw)
```
*Execute o RCB com o tratamento adequado de exceções.*
**Parâmetros:**
+ **fn** (*Callable*) — Função a ser executada
+ **a** — Argumentos da função
+ **kw** — Argumentos da palavra-chave da função
```
def run(fn, a, kw)
```
Loop de execução principal que lida com reinicializações e sincronização de barreiras.
**Parâmetros:**
+ **fn** (*Callable*) — Função a ser executada
+ **a** — Argumentos da função
+ **kw** — Argumentos da palavra-chave da função
```
def shutdown()
```
Desligue as roscas de monitoramento e tratamento de falhas.
**Observações**
+ Lida automaticamente com `RankShouldRestart` exceções para uma recuperação coordenada
+ Gerencia rastreamento de memória e abortos, coleta de lixo durante reinicializações
+ Suporta estratégias de recuperação em processo e PLR (reinicialização em nível de processo) com base no tempo de falha
### 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**
+ **timeout** (*datetime.timedelta*, *opcional*) — Duração do tempo limite para operações de sincronização da GPU. Padrão: `datetime.timedelta(seconds=30)`
**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:**
+ **state** (*HPState*) — HyperPod Estado atual contendo informações classificadas e distribuídas
+ **train\$1ex** (*Exceção*, *opcional*) — A exceção de treinamento original que acionou a reinicialização. Padrão: `None`
**Devoluções:**
+ **tuple** — Uma tupla contendo `(state, train_ex)` inalterado se a verificação de saúde for aprovada
**Aumenta:**
+ **TimeoutError**— Se a sincronização da GPU atingir o tempo limite, indicando um contexto CUDA potencialmente corrompido
**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**
+ Usa segmentação para implementar proteção de tempo limite para sincronização de GPU
+ Projetado para detectar contextos CUDA corrompidos que poderiam impedir a retomada bem-sucedida do treinamento
+ Deve ser usado como parte do pipeline de tolerância a falhas em cenários de treinamento distribuído
### 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:**
+ **HPAgentK8sapi** — Instância de API configurada para comunicação com a infraestrutura HyperPod
**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**
+ Projetado para funcionar perfeitamente com HyperPod a infraestrutura baseada em Kubernetes. É essencial para o tratamento e a recuperação coordenados de falhas em cenários de treinamento distribuído.
### 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**
+ **enable\$1checksum** (*bool*, *opcional*) — Ative a validação da soma de verificação do estado do modelo para verificações de integridade durante a recuperação. Padrão: `False`
+ **enable\$1offload** (*bool*, *opcional*) — Ative o descarregamento do ponto de verificação da GPU para a memória da CPU para reduzir o uso da memória da GPU. Padrão: `False`
**Atributos.**
+ **global\$1step** (*int* ou *None*) — Etapa de treinamento atual associada ao ponto de verificação salvo
+ **rng\$1states** (*list* ou *None*) — Estados geradores de números aleatórios armazenados para recuperação determinística
+ **checksum\$1manager (*MemoryChecksumManager*) — Gerenciador** para validação da soma de verificação do estado do modelo
+ **parameter\$1update\$1lock** (*ParameterUpdateLock*) — Bloqueio para coordenar atualizações de parâmetros durante a recuperação
**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:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
**Observações:**
+ Chamado por CheckpointlessCallback no final do lote ou durante o tratamento de exceções
+ Cria pontos de recuperação sem I/O sobrecarga de disco
+ Armazena estados completos do modelo, do otimizador e do agendador
```
delete_checkpoint()
```
Exclua o ponto de verificação na memória e execute as operações de limpeza.
**Observações:**
+ Limpa dados do ponto de verificação, estados RNG e tensores em cache
+ Executa a coleta de lixo e a limpeza do cache CUDA
+ Chamado após uma recuperação bem-sucedida ou quando o ponto de verificação não é mais necessário
```
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:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
**Devoluções:**
+ **dict** ou **None** — Ponto de verificação restaurado se for bem-sucedido, Nenhum se for necessário retornar ao disco
**Observações:**
+ Principal ponto de entrada para recuperação sem pontos de verificação
+ Valida a viabilidade da recuperação antes de tentar a transferência P2P
+ Sempre limpa os pontos de verificação na memória após a tentativa de recuperação
```
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:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
+ **include\$1checksum\$1verification** (*bool*, *opcional*) — Se a validação da soma de verificação deve ser incluída. Padrão: `True`
**Devoluções:**
+ **bool** — Verdadeiro se a recuperação sem ponto de verificação for viável, falso caso contrário
**Critérios de validação:**
+ Consistência global de etapas em níveis saudáveis
+ Réplicas saudáveis suficientes disponíveis para recuperação
+ Integridade da soma de verificação do estado do modelo (se ativada)
```
store_rng_states()
```
Armazene todos os estados do gerador de números aleatórios para recuperação determinística.
**Observações:**
+ Captura os estados Python NumPy, CPU/GPU PyTorch e Megatron RNG
+ Essencial para manter o determinismo do treinamento após a recuperação
```
load_rng_states()
```
Restaure todos os estados de RNG para a continuação da recuperação determinística.
**Observações:**
+ Restaura todos os estados RNG armazenados anteriormente
+ Garante que o treinamento continue com sequências aleatórias idênticas
```
maybe_offload_checkpoint()
```
Descarregue o ponto de verificação da GPU para a memória da CPU se o descarregamento estiver ativado.
**Observações:**
+ Reduz o uso da memória da GPU para modelos grandes
+ Só é executado se `enable_offload=True`
+ Mantém a acessibilidade do ponto de verificação para recuperação
**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**
+ Usa primitivas de comunicação distribuída para transferência P2P eficiente
+ Lida automaticamente com conversões de tensor dtype e posicionamento de dispositivos
+ **MemoryChecksumManager**— Lida com a validação da integridade do estado do modelo
### 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**:
+ **enable\$1checksum** (*bool*, *opcional*) — Habilita a validação da soma de verificação do estado do modelo. Padrão: `False`
+ **enable\$1offload** (*bool*, *opcional*) — Ativa o descarregamento do ponto de verificação para a memória da CPU. Padrão: `False`
**Atributos adicionais**
+ **params\$1to\$1save** (*set) — Conjunto* de nomes de parâmetros que devem ser salvos como parâmetros do adaptador
+ **base\$1model\$1weights** (*dict* ou *None*) — Pesos do modelo base em cache, salvos uma vez e reutilizados
+ **base\$1model\$1keys\$1to\$1extract (list ou *None*) — Chaves para extrair** *tensores* do modelo básico durante a transferência P2P
**Métodos**
```
maybe_save_base_model(trainer)
```
Salve os pesos do modelo básico uma vez, filtrando os parâmetros do adaptador.
**Parâmetros:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
**Observações:**
+ Salva apenas os pesos do modelo básico na primeira chamada; as chamadas subsequentes são autônomas
+ Filtra os parâmetros do adaptador para armazenar somente pesos congelados do modelo básico
+ Os pesos do modelo básico são preservados em várias sessões de treinamento
```
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:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
**Observações:**
+ Chama automaticamente `maybe_save_base_model()` se o modelo base ainda não foi salvo
+ Filtra o ponto de verificação para incluir somente os parâmetros do adaptador e o estado de treinamento
+ Reduz significativamente o tamanho do ponto de verificação em comparação com os pontos de verificação do modelo completo
```
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:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
**Devoluções:**
+ **dict** ou **None** — Ponto de verificação do modelo básico restaurado se for bem-sucedido, Nenhum se for necessário
**Observações:**
+ Usado durante a inicialização do modelo para recuperar os pesos básicos do modelo
+ Não limpa os pesos do modelo básico após a recuperação (preserva para reutilização)
+ Otimizado para cenários model-weights-only de recuperação
```
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:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
**Devoluções:**
+ **dict** ou **None** — Ponto de verificação do adaptador restaurado se for bem-sucedido, Nenhum se for necessário fazer um fallback
**Observações:**
+ Recupera somente parâmetros do adaptador, estados do otimizador e agendadores
+ Carrega automaticamente os estados do otimizador e do agendador após uma recuperação bem-sucedida
+ Limpa os pontos de verificação do adaptador após a tentativa de recuperação
```
is_adapter_key(key)
```
Verifique se a chave state dict pertence aos parâmetros do adaptador.
**Parâmetros:**
+ **key** (*str* ou *tuple*) — Chave de ditado de estado a ser verificada
**Devoluções:**
+ **bool** — Verdadeiro se a chave for o parâmetro do adaptador, Falso se o parâmetro do modelo base
**Lógica de detecção:**
+ Verifica se a chave está `params_to_save` definida
+ Identifica chaves contendo “.adapter”. substring
+ Identifica chaves que terminam com “.adapters”
+ Para chaves de tupla, verifica se o parâmetro requer gradientes
```
maybe_offload_checkpoint()
```
Transfira os pesos do modelo básico da GPU para a memória da CPU.
**Observações:**
+ Estende o método principal para lidar com a descarga de peso do modelo básico
+ Os pesos dos adaptadores geralmente são pequenos e não precisam ser descarregados
+ Define o sinalizador interno para rastrear o estado de descarga
**Observações**
+ Projetado especificamente para cenários de ajuste fino com eficiência de parâmetros (LoRa, adaptadores, etc.)
+ Lida automaticamente com a separação dos parâmetros do modelo básico e do adaptador
**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:**
+ **Compose** — Instância de aborto composta padrão com todos os componentes de aborto
**Componentes padrão:**
+ **AbortTransformerEngine()** — Limpa os recursos TransformerEngine
+ **HPCheckpointingAbort ()** — Lida com a limpeza do sistema de pontos de verificação
+ **HPAbortTorchDistributed()** — Aborta operações PyTorch distribuídas
+ **HPDataLoaderAbort()** — Pára e limpa os carregadores de dados
```
create_custom_abort(abort_instances)
```
*Crie uma composição de aborto personalizada somente com as instâncias de aborto especificadas.*
**Parâmetros:**
+ **abort\$1instances** (*Abort*) — Número variável de instâncias de aborto a serem incluídas na composição
**Devoluções:**
+ **Compose** — Nova instância de aborto composta contendo somente os componentes especificados
**Aumenta:**
+ **ValueError**— Se nenhuma instância de aborto for fornecida
```
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:**
+ **abort\$1compose (Compose**) — A instância original do *Compose* a ser modificada
+ **abort\$1type (*type***) — O tipo de componente de aborto a ser substituído (por exemplo,) `HPCheckpointingAbort`
+ **new\$1abort (Abort***) — A nova instância de aborto* a ser usada como substituta
**Devoluções:**
+ **Compose** — Nova instância do Compose com o componente especificado substituído
**Aumenta:**
+ **ValueError**— Se abort\$1compose não tiver o atributo 'instances'
**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**
+ As configurações personalizadas permitem um controle preciso sobre o comportamento de limpeza
+ As operações de aborto são essenciais para a limpeza adequada dos recursos durante a recuperação de falhas
### 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.**
+ **trainer** *(*pytorch\$1lightning.trainer ou None) — Referência à instância do Lightning trainer** PyTorch
**Métodos**
```
__call__(*a, **kw)
```
**Execute operações de limpeza abrangentes para a preparação da recuperação durante o processo.**
*Parâmetros:*
+ **a** — Argumentos posicionais variáveis (herdados da interface Finalize)
+ **kw** — Argumentos de palavras-chave variáveis (herdados da interface Finalize)
**Operações de limpeza:**
+ Limpeza do **Megatron Framework — Chamadas `abort_megatron()` para limpar** recursos específicos do Megatron
+ **TransformerEngine Limpeza** — Chamadas `abort_te()` para limpar recursos TransformerEngine
+ **RoPe Cleanup** — Solicita `cleanup_rope()` a limpeza dos recursos de incorporação da posição rotativa
+ **Limpeza de DDP** — Chamadas `cleanup_ddp()` para limpar recursos DistributedDataParallel
+ **Recarregamento de módulo** — Chamadas `reload_megatron_and_te()` para recarregar módulos da estrutura
+ **Limpeza do módulo Lightning — opcionalmente limpa o módulo Lightning para reduzir a memória da GPU**
+ **Limpeza de memória** — Destrói as referências dos componentes de treinamento para liberar memória
```
register_attributes(trainer)
```
*Registre a instância do treinador para uso durante as operações de limpeza.*
**Parâmetros:**
+ **trainer** (*Pytorch\$1lightning.trainer) — Instância do Lightning* trainer para registrar PyTorch
**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**
+ As operações de limpeza são executadas em uma ordem específica para evitar problemas de dependência
+ A limpeza da memória usa a introspecção da coleta de lixo para encontrar objetos alvo
+ Todas as operações de limpeza foram projetadas para serem idempotentes e seguras de serem repetidas.
### 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**:
+ Parâmetros de NeMo MegatronStrategy inicialização padrão
+ Opções de configuração de treinamento distribuído
+ Configurações de paralelismo do modelo
**Atributos.**
+ **base\$1store (torch.distributed***). TCPStore*ou *Nenhum*) — Loja distribuída para coordenação de grupos de processos
**Métodos**
```
setup(trainer)
```
Inicialize a estratégia e registre os componentes de tolerância a falhas com o treinador.
**Parâmetros:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
**Operações de configuração:**
+ **Configuração dos pais — MegatronStrategy Configuração** dos pais de chamadas
+ **Registro de injeção de falhas** — registra HPFault InjectionCallback ganchos, se presentes
+ **Finalizar o registro — Registra** o treinador com os responsáveis pela finalização da limpeza
+ **Registro de aborto** — registra o treinador com manipuladores de aborto que o apoiam
```
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:**
+ **checkpoint** (*Mapping [str, Any]*) — Dicionário de pontos de verificação contendo o estado do modelo
+ **strict** (*bool*, *opcional*) — Se a correspondência de chaves do ditado de estado deve ser rigorosamente aplicada. Padrão: `True`
```
get_wrapper()
```
Obtenha a instância HPCall Wrapper para coordenação de tolerância a falhas.
**Devoluções:**
+ **HPCallWrapper** — A instância do wrapper anexada ao treinador para tolerância a falhas
```
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:**
+ **bool** — Verdadeiro se o retorno de chamada PEFT estiver presente, Falso caso contrário
```
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**
+ **enable\$1inprocess** (*bool*, *opcional*) — Ative os recursos de recuperação em processo. Padrão: `False`
+ **enable\$1checkpointless** (*bool*, *opcional*) — Habilita a recuperação sem ponto de verificação (obrigatório). `enable_inprocess=True` Padrão: `False`
+ **enable\$1checksum** (*bool*, *opcional*) — Habilita a validação da soma de verificação do estado do modelo (obrigatório). `enable_checkpointless=True` Padrão: `False`
+ **clean\$1tensor\$1hook** (*bool*, *opcional*) — Limpe os ganchos tensores de todos os tensores da GPU durante a limpeza (operação cara). Padrão: `False`
+ **clean\$1lightning\$1module** (*bool*, *opcional*) — Ative a limpeza do módulo Lightning para liberar memória da GPU após cada reinicialização. Padrão: `False`
**Atributos.**
+ **tried\$1adapter\$1checkpointless** (*bool*) — Sinalize para rastrear se a restauração sem ponto de verificação do adaptador foi tentada
**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:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
**Devoluções:**
+ **HPCallWrapper** — A instância do wrapper para operações de tolerância a falhas
```
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:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
+ **pl\$1module (pytorch\$1lightning***). LightningModule*) — Módulo Lightning sendo treinado
+ **batch** — Dados atuais do lote de treinamento
+ **batch\$1idx** (*int*) — Índice do lote atual
+ **args — Argumentos** posicionais adicionais
+ **kwargs** — Argumentos adicionais de palavras-chave
```
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:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
+ **pl\$1module (pytorch\$1lightning***). LightningModule*) — Módulo Lightning sendo treinado
+ **saídas** (*STEP\$1OUTPUT) — Saídas da* etapa de treinamento
+ **lote** (*Qualquer*) — Dados atuais do lote de treinamento
+ **batch\$1idx** (*int*) — Índice do lote atual
**Observações:**
+ O tempo de liberação do bloqueio garante que a recuperação sem pontos de verificação possa prosseguir após a conclusão das atualizações dos parâmetros
+ Só é executado quando ambos `enable_inprocess` `enable_checkpointless` são verdadeiros
```
get_peft_callback(trainer)
```
*Recupere o retorno de chamada PEFT da lista de retorno de chamada do treinador.*
**Parâmetros:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
**Devoluções:**
+ **PEFT** ou **Nenhuma** — Instância de retorno de chamada PEFT se encontrada, Nenhuma caso contrário
```
_try_adapter_checkpointless_restore(trainer, params_to_save)
```
*Tente fazer uma restauração inútil dos parâmetros do adaptador PEFT.*
**Parâmetros:**
+ **trainer** (*Pytorch\$1lightning.trainer) — instância do Lightning* trainer PyTorch
+ **params\$1to\$1save** (*set) — Conjunto de* nomes de parâmetros para salvar como parâmetros do adaptador
**Observações:**
+ Só é executado uma vez por sessão de treinamento (controlado por `tried_adapter_checkpointless` bandeira)
+ Configura o gerenciador de pontos de verificação com informações de parâmetros do adaptador
**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**
+ **clean\$1tensor\$1hook**: remove os ganchos do tensor durante a limpeza (caro, mas completo)
+ **clean\$1lightning\$1module: libera a memória da GPU do módulo** Lightning durante as reinicializações
+ Ambas as opções ajudam a reduzir o consumo de memória durante a recuperação de falhas
+ Coordena com ParameterUpdateLock para rastreamento seguro de atualizações de parâmetros
### 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 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 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 \$1 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:**
+ **checkpoint\$1path** (*str* ou *None*, *opcional*) — Caminho para o ponto de verificação do disco para fallback. Padrão: `None`
```
resume_end()
```
Conclua o processo de carregamento do ponto de verificação e execute as operações de pós-carregamento.
**Observações**
+ Estende a `_CheckpointConnector` classe interna do PyTorch Lightning com suporte de recuperação sem pontos de verificação
+ Mantém total compatibilidade com os fluxos de trabalho padrão do PyTorch Lightning Checkpoint
### 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:**
+ **trainer** *(*pytorch\$1lightning.trainer ou lightning.fabric.fabric) — Lightning trainer* ou instância do Fabric* PyTorch
+ **model** (*opcional*) — Instância do modelo para configuração. Padrão: `None`
+ **force\$1setup** (*bool*, *opcional*) — Se verdadeiro, ignore o atraso e execute a configuração imediatamente. AutoResume Padrão: `False`
**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**
+ AutoResume Classe NeMo da Extends com mecanismo de atraso para permitir uma recuperação sem pontos de verificação
+ Funciona em conjunto com `CheckpointlessCompatibleConnector` para um fluxo de trabalho de recuperação completo