Détection des tâches bloquées

Ajoutez la variable d'environnement IP de l'hôte à votre RayCluster manifeste

Ajoutez la variable d'environnement suivante à la fois headGroupSpec et workerGroupSpecs dans votre RayCluster YAML. Cela permet à la bibliothèque Python exécutée dans le conteneur de formation de communiquer avec le service de surveillance des tâches sur l'hôte.

spec:
  headGroupSpec:
    template:
      spec:
        containers:
        - name: ray-head
          env:
          - name: HYPERPOD_JMA_HOST
            valueFrom:
              fieldRef:
                fieldPath: status.hostIP
  workerGroupSpecs:
  - template:
      spec:
        containers:
        - name: ray-worker
          env:
          - name: HYPERPOD_JMA_HOST
            valueFrom:
              fieldRef:
                fieldPath: status.hostIP

Installez la bibliothèque de boîtes à outils dans l'image de votre conteneur de formation

Ajoutez le package toolkit-for-ray-on-sagemaker-ai du site Web PyPI à l'image de votre conteneur de formation. La bibliothèque est préinstallée dans SageMaker Distribution images.

pip install toolkit-for-ray-on-sagemaker-ai

Ajoutez la surveillance à votre fonction d'entraînement

Faites appel SageMakerLogMonitoring.start() à votre service de formation avant de faire un travail significatif. Cela garantit que la surveillance est active dès le début de l'entraînement et peut détecter les blocages qui se produisent lors du chargement du modèle ou lors de la première passe.

from toolkit_for_ray_on_sagemaker_ai.log_monitoring import (
    SageMakerLogMonitoring,
    LogMonitorConfig,
)
from ray.train import RunConfig, FailureConfig, ScalingConfig
from ray.train.torch import TorchTrainer

def train_func():
    # Start monitoring BEFORE any meaningful work
    SageMakerLogMonitoring(config=LogMonitorConfig(
        enabled=True,
        rules=[
            {
                "name": "training_progress",
                "type": "log_pattern",
                "enabled": True,
                "log_pattern": "(Epoch|Step|Iteration) \\d+",
                "timeout_minutes": 10,
                "start_timeout_minutes": 30,
                "stop_pattern": "Training complete",
                "fault_on_match": False,
            },
            {
                "name": "oom_detection",
                "type": "log_pattern",
                "enabled": True,
                "log_pattern": "CUDA out of memory|OutOfMemoryError|OOM",
                "fault_on_match": True,
            },
        ],
        action="cancel",
    )).start()

    # ... your training loop
    for epoch in range(num_epochs):
        print(f"Epoch {epoch}")  # This output is what the rule monitors
        train_one_epoch(model, dataloader)

    print("Training complete")  # Matches stop_pattern, deactivates the rule

# Configure FailureConfig so Ray Train automatically restarts all workers
# when the cancel action terminates a hung worker.
trainer = TorchTrainer(
    train_func,
    scaling_config=ScalingConfig(num_workers=4, use_gpu=True),
    run_config=RunConfig(
        failure_config=FailureConfig(max_failures=3),
    ),
)

Lorsque l'cancelaction met fin à un travailleur bloqué, la documentation Ray Train FailureConfig in the Ray détecte la défaillance du travailleur et redémarre tous les travailleurs depuis le dernier point de contrôle. Définissez max_failures le nombre de tentatives de restauration automatique que vous souhaitez avant que la tâche n'échoue définitivement. Dans le cas FailureConfig contraire, le licenciement d'un seul travailleur fait échouer l'ensemble du travail.

Comme Ray Train effectue une restauration à partir du dernier point de contrôle enregistré au redémarrage, aucun progrès d'entraînement n'est perdu au-delà du travail effectué depuis le dernier point de contrôle. Si votre code d'entraînement enregistre régulièrement des points de contrôle (par exemple, à chaque limite d'époque), la tâche reprend automatiquement à partir du dernier état enregistré.