Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Recuperación durante el proceso y formación sin puntos de control

HyperPod La formación sin puntos de control utiliza la redundancia de modelos para permitir una formación tolerante a fallos. El principio fundamental es que los estados del modelo y del optimizador se replican completamente en varios grupos de nodos, y las actualizaciones de peso y los cambios de estado del optimizador se replican de forma sincrónica dentro de cada grupo. Cuando se produce un error, las réplicas en buen estado completan sus pasos de optimización y transmiten los estados actualizados a las réplicas en recuperación. model/optimizer

Este modelo de enfoque basado en la redundancia permite varios mecanismos de gestión de errores:

Configuraciones sin puntos de control

Este es el fragmento principal del entrenamiento sin puntos de control.

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

Consulta el ejemplo para añadir funciones de entrenamiento sin puntos de control a los códigos.

Conceptos

En esta sección se presentan los conceptos de entrenamiento sin puntos de control. La formación de Checkpointless en Amazon SageMaker HyperPod apoya la recuperación durante el proceso. Esta interfaz API sigue un formato similar al. NVRx APIs

Concepto: bloque de código reejecutable (RCB)

Cuando se produce un error, los procesos en buen estado permanecen activos, pero se debe volver a ejecutar una parte del código para recuperar los estados de entrenamiento y las pilas de Python. Un bloque de código reejecutable (RCB) es un segmento de código específico que se vuelve a ejecutar durante la recuperación de un error. En el siguiente ejemplo, el RCB abarca todo el guion de entrenamiento (es decir, todo lo que aparece debajo de main ()), lo que significa que cada recuperación ante un fallo reinicia el guion de entrenamiento y, al mismo tiempo, conserva el modelo en memoria y los estados del optimizador.

Concepto: control de fallos

Un módulo controlador de fallas recibe notificaciones cuando se producen fallas durante un entrenamiento sin puntos de control. Este controlador de fallas incluye los siguientes componentes:

Concepto: modelo de redundancia

El entrenamiento de modelos grandes generalmente requiere un tamaño paralelo de datos lo suficientemente grande como para entrenar modelos de manera eficiente. En el paralelismo de datos tradicional, como el PyTorch DDP y el Horovod, el modelo se replica completamente. Las técnicas de paralelismo de datos fragmentados más avanzadas, como el optimizador ZeRO y el FSDP DeepSpeed , también admiten el modo de fragmentación híbrida, que permite fragmentar los estados del grupo de fragmentación y replicarlos completamente entre los grupos de replicación. model/optimizer NeMo también tiene esta función de fragmentación híbrida mediante un argumento num_distributed_optimizer_instances, que permite la redundancia.

Sin embargo, añadir redundancia indica que el modelo no estará completamente fragmentado en todo el clúster, lo que se traducirá en un mayor uso de la memoria del dispositivo. La cantidad de memoria redundante variará en función de las técnicas específicas de fragmentación del modelo implementadas por el usuario. Los pesos, los gradientes y la memoria de activación del modelo de baja precisión no se verán afectados, ya que se fragmentan mediante el paralelismo del modelo. Los estados del optimizador y del modelo weights/gradients maestro de alta precisión se verán afectados. La adición de una réplica de modelo redundante aumenta el uso de memoria del dispositivo aproximadamente el equivalente al tamaño de un punto de control de DCP.

La fragmentación híbrida divide los colectivos de todos los grupos de DP en colectivos relativamente más pequeños. Anteriormente, había una dispersión reducida y una dispersión total en todo el grupo de DP. Tras la fragmentación híbrida, la dispersión reducida solo se ejecutará dentro de cada réplica del modelo y habrá una reducción total en todos los grupos de réplicas del modelo. La función «all-gather» también se ejecuta dentro de cada réplica del modelo. Como resultado, todo el volumen de comunicación permanece prácticamente sin cambios, pero los colectivos funcionan con grupos más pequeños, por lo que esperamos una mejor latencia.

Concepto: tipos de errores y reinicios

La siguiente tabla registra los diferentes tipos de errores y los mecanismos de recuperación asociados. El entrenamiento sin control intenta primero la recuperación de los errores mediante una recuperación en proceso, seguida de un reinicio a nivel del proceso. Solo se recurre a un reinicio a nivel de trabajo en caso de una falla catastrófica (por ejemplo, si varios nodos fallan al mismo tiempo).

Concepto: protección de bloqueo atómico para optimizar el paso

La ejecución del modelo se divide en tres fases: propagación hacia adelante, propagación hacia atrás y paso de optimización. El comportamiento de recuperación varía en función del momento de la falla:

Esta estrategia garantiza que las actualizaciones completadas del optimizador nunca se descarten, lo que ayuda a reducir el tiempo de recuperación ante fallos.

Diagrama de flujo de entrenamiento sin puntos de control

Los siguientes pasos describen el proceso de detección de fallas y recuperación sin puntos de control:

Referencia de la API

wait_rank

hyperpod_checkpointless_training.inprocess.train_utils.wait_rank()

Espera y recupera la información de clasificación y, a continuación HyperPod, actualiza el entorno de proceso actual con variables de entrenamiento distribuidas.

Esta función obtiene la asignación de rangos y las variables de entorno correctas para el entrenamiento distribuido. Garantiza que cada proceso tenga la configuración adecuada para su función en el trabajo de formación distribuido.

Parámetros

Ninguno

Devuelve

Ninguna

Comportamiento

Variables de entorno

La función lee las siguientes variables de entorno:

Aumenta

Ejemplo

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')

Notas

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)

Contenedor de funciones de Python que permite reiniciar un bloque de código reejecutable (RCB) en HyperPod un entrenamiento sin puntos de control.

Este contenedor proporciona capacidades de tolerancia a errores y recuperación automática al monitorear la ejecución del entrenamiento y coordinar los reinicios en todos los procesos distribuidos cuando se producen fallas. Utiliza un enfoque de administrador de contexto en lugar de un decorador para mantener los recursos globales durante todo el ciclo de vida de la formación.

Parámetros

Métodos

def __call__(self, fn)

Incluye una función para habilitar las capacidades de reinicio.

Parámetros:

Devoluciones:

Ejemplo

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

Notas

HPCallEnvoltorio

class hyperpod_checkpointless_training.inprocess.wrap.HPCallWrapper(wrapper)

Supervisa y administra el estado de un bloque de código de reinicio (RCB) durante la ejecución.

Esta clase se ocupa del ciclo de vida de la ejecución del RCB, incluida la detección de errores, la coordinación con otros niveles para los reinicios y las operaciones de limpieza. Gestiona la sincronización distribuida y garantiza una recuperación uniforme en todos los procesos de formación.

Parámetros

Atributos

Métodos

def initialize_barrier()

Espere a que se sincronice HyperPod la barrera después de encontrar una excepción del RCB.

def start_hp_fault_handling_thread()

Inicie el hilo de gestión de fallos para supervisar y coordinar los fallos.

def handle_fn_exception(call_ex)

Procese las excepciones de la función de ejecución o del RCB.

Parámetros:

def restart(term_ex)

Ejecute el controlador de reinicios, incluida la finalización, la recolección de elementos no utilizados y las comprobaciones de estado.

Parámetros:

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

Ejecute el RCB con el manejo adecuado de las excepciones.

Parámetros:

def run(fn, a, kw)

Bucle de ejecución principal que gestiona los reinicios y la sincronización de barreras.

Parámetros:

def shutdown()

Cierre los subprocesos de gestión y supervisión de errores.

Notas

CudaHealthCheck

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

Garantiza que el contexto CUDA del proceso actual se encuentre en buen estado durante la recuperación del entrenamiento sin puntos de control.

Esta comprobación de estado se sincroniza con la GPU para comprobar que el contexto CUDA no está dañado tras un error de entrenamiento. Realiza operaciones de sincronización de la GPU para detectar cualquier problema que pueda impedir que el entrenamiento se reanude correctamente. La comprobación de estado se ejecuta una vez que se destruyen los grupos distribuidos y se ha completado la finalización.

Parámetros

Métodos

__call__(state, train_ex=None)

Ejecute la comprobación de estado de CUDA para comprobar la integridad del contexto de la GPU.

Parámetros:

Devuelve:

Aumenta:

Preservación del estado: devuelve el estado original y la excepción sin cambios si se aprueban todas las comprobaciones

Ejemplo

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

Notas

HPAgentK8 APIFactory

class hyperpod_checkpointless_training.inprocess.train_utils.HPAgentK8sAPIFactory()

Clase de fábrica para crear instancias de HPAgent K8sAPI que se comunican con la HyperPod infraestructura para la coordinación distribuida de la formación.

Esta fábrica proporciona una forma estandarizada de crear y configurar objetos HPAgent K8SAPI que gestionan la comunicación entre los procesos de entrenamiento y el plano de control. HyperPod Encapsula la creación del cliente de socket y la instancia de API subyacentes, lo que garantiza una configuración uniforme en las diferentes partes del sistema de entrenamiento.

Métodos

__call__()

Crea y devuelve una instancia de HPAgent K8sAPI configurada para la comunicación. HyperPod

Devoluciones:

Ejemplo

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

Notas

CheckpointManager

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

Gestiona los puntos de control y la peer-to-peer recuperación en memoria para lograr una tolerancia a los fallos sin puntos de control en la formación distribuida.

Esta clase proporciona la funcionalidad básica para el entrenamiento HyperPod sin puntos de control, ya que permite gestionar los puntos de control de los NeMo modelos en la memoria, validar la viabilidad de la recuperación y organizar la transferencia de puntos de control entre los rangos en buen estado peer-to-peer y los que han fallado. Elimina la necesidad de disponer de disco I/O durante la recuperación, lo que reduce considerablemente el tiempo medio de recuperación (MTTR).

Parámetros

Atributos

Métodos

save_checkpoint(trainer)

Guarda el punto de control NeMo del modelo en la memoria para una posible recuperación sin puntos de control.

Parámetros:

Notas:

delete_checkpoint()

Elimine el punto de control en la memoria y realice las operaciones de limpieza.

Notas:

try_checkpointless_load(trainer)

Intenta recuperarte sin puntos de control cargando el estado de los rangos de tus compañeros.

Parámetros:

Devoluciones:

Notas:

checkpointless_recovery_feasible(trainer, include_checksum_verification=True)

Determine si es posible realizar una recuperación sin puntos de control en el escenario de fallo actual.

Parámetros:

Devoluciones:

Criterios de validación:

store_rng_states()

Guarde todos los estados del generador de números aleatorios para una recuperación determinista.

Notas:

load_rng_states()

Restaure todos los estados del RNG para continuar con la recuperación determinista.

Notas:

maybe_offload_checkpoint()

Si la descarga está habilitada, descargue el punto de control de la GPU a la memoria de la CPU.

Notas:

Ejemplo

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

Validación: verifica la integridad de los puntos de control mediante sumas de control (si están habilitadas)

Notas

PEFTCheckpointGerente

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

Gestiona los puntos de control para el PEFT (ajuste preciso con eficiencia de parámetros) con un manejo independiente de la base y el adaptador para una recuperación optimizada sin puntos de control.

Este gestor de puntos de control especializado se amplía CheckpointManager para optimizar los flujos de trabajo del PEFT al separar los pesos del modelo base de los parámetros del adaptador.

Parámetros

Hereda todos los parámetros de: CheckpointManager

Atributos adicionales

Métodos

maybe_save_base_model(trainer)

Guarda los pesos del modelo base una vez y filtra los parámetros del adaptador.

Parámetros:

Notas:

save_checkpoint(trainer)

Guarde el punto de control del modelo del adaptador NeMo PEFT en la memoria para una posible recuperación sin puntos de control.

Parámetros:

Notas:

try_base_model_checkpointless_load(trainer)

El modelo base Tempt PEFT pondera la recuperación sin puntos de control cargando el estado de las filas homólogas.

Parámetros:

Devoluciones:

Notas:

try_checkpointless_load(trainer)

Un intento de adaptación PEFT pondera la recuperación sin puntos de control cargando el estado de las filas homólogas.

Parámetros:

Devoluciones:

Notas:

is_adapter_key(key)

Compruebe si la clave de dictado de estado pertenece a los parámetros del adaptador.

Parámetros:

Devoluciones:

Lógica de detección:

maybe_offload_checkpoint()

Descarga los pesos del modelo base de la GPU a la memoria de la CPU.

Notas:

Notas

Ejemplo

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()

Clase de fábrica para crear y gestionar las composiciones de los componentes abortados para lograr una tolerancia a los fallos sin puntos de control.

Esta clase de utilidad proporciona métodos estáticos para crear, personalizar y gestionar las composiciones de los componentes abortados que se utilizan durante la gestión de fallos en una formación sin puntos de control. HyperPod Simplifica la configuración de las secuencias de cancelación que se encargan de limpiar los componentes de entrenamiento distribuidos, los cargadores de datos y los recursos específicos del marco durante la recuperación de errores.

Parámetros

Ninguno (todos los métodos son estáticos)

Métodos estáticos

get_default_checkpointless_abort()

Obtenga la instancia de composición de abortación predeterminada que contiene todos los componentes de cancelación estándar.

Devoluciones:

Componentes por defecto:

create_custom_abort(abort_instances)

Cree una composición de cancelación personalizada con solo las instancias de cancelación especificadas.

Parámetros:

Devuelve:

Aumenta:

override_abort(abort_compose, abort_type, new_abort)

Sustituye un componente de cancelación específico en una instancia de Compose por un componente nuevo.

Parámetros:

Devuelve:

Aumenta:

Ejemplo

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(...)

Notas

CheckpointlessFinalizeCleanup

class hyperpod_checkpointless_training.inprocess.abort.CheckpointlessFinalizeCleanup()

Realiza una limpieza exhaustiva tras la detección de un fallo para preparar la recuperación durante el proceso durante una formación sin puntos de control.

Este controlador de finalización ejecuta operaciones de limpieza específicas del marco, como la anulación, la limpieza del DDP, la recarga de módulos y la limpieza de Megatron/TransformerEngine memoria, destruyendo las referencias de los componentes de entrenamiento. Garantiza que el entorno de formación se restablezca correctamente para que la recuperación del proceso se realice correctamente sin necesidad de finalizar por completo el proceso.

Parámetros

Ninguno

Atributos

Métodos

__call__(*a, **kw)

Ejecute operaciones de limpieza exhaustivas para preparar la recuperación durante el proceso.

Parámetros:

Operaciones de limpieza:

register_attributes(trainer)

Registre la instancia del entrenador para utilizarla durante las operaciones de limpieza.

Parámetros:

Integración con 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(...)

Notas

CheckpointlessMegatronStrategy

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

NeMo Estrategia Megatron con capacidades integradas de recuperación sin puntos de control para una formación distribuida y tolerante a fallos.

Tenga en cuenta que la capacitación sin puntos de control debe ser de al menos 2 num_distributed_optimizer_instances para que la replicación sea optimizada. La estrategia también se ocupa del registro de los atributos esenciales y de la inicialización de los grupos de procesos.

Parámetros

Hereda todos los parámetros de: MegatronStrategy

Atributos

Métodos

setup(trainer)

Inicie la estrategia y registre los componentes de tolerancia a fallos con el formador.

Parámetros:

Operaciones de configuración:

setup_distributed()

Inicialice el grupo de procesos mediante una conexión TCPStore con prefijo o sin raíz.

load_model_state_dict(checkpoint, strict=True)

Cargue el dictado de estado del modelo con una compatibilidad de recuperación sin puntos de control.

Parámetros:

get_wrapper()

Obtenga la instancia de HPCall Wrapper para coordinar la tolerancia a errores.

Devoluciones:

is_peft()

Compruebe si el PEFT (ajuste preciso con eficiencia de parámetros) está habilitado en la configuración de entrenamiento comprobando si hay devoluciones de llamadas del PEFT

Devoluciones:

teardown()

Anule el desmontaje nativo de PyTorch Lightning para delegar la limpieza y anular los controladores.

Ejemplo

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)

Lightning Callback, que integra la NeMo formación con el sistema de tolerancia a fallos de Checkpointless Training.

Esta devolución de llamadas gestiona el seguimiento de los pasos, el almacenamiento de los puntos de control y la coordinación de la actualización de los parámetros para lograr funciones de recuperación durante el proceso. Sirve como el principal punto de integración entre los ciclos de entrenamiento de PyTorch Lightning y los mecanismos de entrenamiento HyperPod sin puntos de control, ya que coordina las operaciones de tolerancia a los fallos a lo largo del ciclo de vida del entrenamiento.

Parámetros

Atributos

Métodos

get_wrapper_from_trainer(trainer)

Obtenga la instancia de Wrapper del entrenador para coordinar la tolerancia a fallas. HPCall

Parámetros:

Devoluciones:

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

Se utiliza al principio de cada lote de formación para gestionar el seguimiento y la recuperación de los pasos.

Parámetros:

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

Libera el bloqueo de actualización de parámetros al final de cada lote de entrenamiento.

Parámetros:

Notas:

get_peft_callback(trainer)

Recupera la llamada PEFT de la lista de devoluciones de llamadas del entrenador.

Parámetros:

Devoluciones:

_try_adapter_checkpointless_restore(trainer, params_to_save)

Intente restaurar sin puntos de control los parámetros del adaptador PEFT.

Parámetros:

Notas:

Ejemplo

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)

Administración de la memoria

CheckpointlessCompatibleConnector

class hyperpod_checkpointless_training.nemo_plugins.checkpoint_connector.CheckpointlessCompatibleConnector()

PyTorch Conector Lightning Checkpoint que integra la recuperación sin puntos de control con la carga tradicional de puntos de control basada en disco.

Este conector amplía el de PyTorch Lightning _CheckpointConnector para ofrecer una integración perfecta entre la recuperación sin puntos de control y la restauración de puntos de control estándar. En primer lugar, intenta realizar una recuperación sin puntos de control y, a continuación, recurre a la carga mediante puntos de control basados en disco si la recuperación sin puntos de control no es factible o se produce un error.

Parámetros

Hereda todos los parámetros de _ CheckpointConnector

Métodos

resume_start(checkpoint_path=None)

Intente precargar el punto de control con una prioridad de recuperación sin puntos de control.

Parámetros:

resume_end()

Complete el proceso de carga del punto de control y realice las operaciones posteriores a la carga.

Notas

CheckpointlessAutoResume

class hyperpod_checkpointless_training.nemo_plugins.resume.CheckpointlessAutoResume()

Se amplía AutoResume con NeMo una configuración diferida para permitir la validación de la recuperación sin puntos de control antes de resolver la ruta del punto de control.

Esta clase implementa una estrategia de inicialización en dos fases que permite realizar la validación de la recuperación sin puntos de control antes de volver a la carga tradicional de puntos de control basada en disco. Retrasa la AutoResume configuración de forma condicional para evitar una resolución prematura de la ruta de los puntos de control, lo que permite validar primero si la recuperación sin puntos de control es factible CheckpointManager . peer-to-peer

Parámetros

Hereda todos los parámetros de AutoResume

Métodos

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

Retrasa la AutoResume configuración de forma condicional para permitir la validación de la recuperación sin puntos de control.

Parámetros:

Ejemplo

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()  
)

Notas