Préparation et exécution d’une tâche d’entraînement à l’aide du profileur SageMaker - Amazon SageMaker AI
Étape 1 : Adapter votre script d’entraînement à l’aide des modules Python du profileur SageMakerÉtape 2 : créer un estimateur de cadre SageMaker AI et activer le profileur SageMaker(Facultatif) Installer le package Python du profileur SageMaker

Préparation et exécution d’une tâche d’entraînement à l’aide du profileur SageMaker

La configuration et l’exécution d’une tâche d’entraînement à l’aide du profileur SageMaker se font en deux étapes : l’adaptation du script d’entraînement et la configuration du lanceur de tâches d’entraînement SageMaker.

Étape 1 : Adapter votre script d’entraînement à l’aide des modules Python du profileur SageMaker

Pour commencer à capturer les exécutions du noyau sur les GPU pendant que la tâche d’entraînement est en cours d’exécution, modifiez votre script d’entraînement à l’aide des modules Python du profileur SageMaker. Importez la bibliothèque et ajoutez les méthodes start_profiling() et stop_profiling() pour définir le début et la fin du profilage. Vous pouvez également utiliser des annotations personnalisées facultatives pour ajouter des marqueurs dans le script d’entraînement afin de visualiser les activités du matériel lors d’opérations spécifiques, à chaque étape.

Notez que les annotateurs extraient les opérations des GPU. Pour les opérations de profilage dans les CPU, il n’est pas nécessaire d’ajouter d’annotations supplémentaires. Le profilage des CPU est également activé lorsque vous spécifiez la configuration du profilage, que vous observerez dans Étape 2 : créer un estimateur de cadre SageMaker AI et activer le profileur SageMaker.

Note

Le profilage d’une tâche d’entraînement complète n’est pas l’utilisation la plus efficace des ressources. Nous recommandons le profilage d’au plus 300 étapes d’une tâche d’entraînement.

Important

La mise à jour sur 14 décembre 2023 implique une modification radicale. Le nom du package Python du profileur SageMaker smppy est replacé par smprof. Cela prend effet dans les conteneurs SageMaker AI Framework pour TensorFlow v2.12 et versions ultérieures.

Si vous utilisez l’une des versions précédentes des conteneurs SageMaker AI Framework, telle que TensorFlow v2.11.0, le package Python du profileur SageMaker est toujours disponible en tant que smppy. Si vous n’êtes pas certain de la version ou du nom du package à utiliser, remplacez l’instruction d’importation du package du profileur SageMaker par l’extrait de code suivant.

try:
    import smprof 
except ImportError:
    # backward-compatability for TF 2.11 and PT 1.13.1 images
    import smppy as smprof

Approche 1. Utilisation du gestionnaire de contexte smprof.annotate pour annoter l’intégralité des fonctions

Vous pouvez encapsuler toutes les fonctions dans le gestionnaire de contexte smprof.annotate(). Cet encapsuleur est recommandé si vous souhaitez effectuer un profilage par fonctions plutôt que par lignes de code. L’exemple de script suivant montre comment implémenter le gestionnaire de contexte pour encapsuler la boucle d’entraînement et les fonctions complètes à chaque itération.

import smprof

SMProf = smprof.SMProfiler.instance()
config = smprof.Config()
config.profiler = {
    "EnableCuda": "1",
}
SMProf.configure(config)
SMProf.start_profiling()

for epoch in range(args.epochs):
    if world_size > 1:
        sampler.set_epoch(epoch)
    tstart = time.perf_counter()
    for i, data in enumerate(trainloader, 0):
        with smprof.annotate("step_"+str(i)):
            inputs, labels = data
            inputs = inputs.to("cuda", non_blocking=True)
            labels = labels.to("cuda", non_blocking=True)
    
            optimizer.zero_grad()
    
            with smprof.annotate("Forward"):
                outputs = net(inputs)
            with smprof.annotate("Loss"):
                loss = criterion(outputs, labels)
            with smprof.annotate("Backward"):
                loss.backward()
            with smprof.annotate("Optimizer"):
                optimizer.step()

SMProf.stop_profiling()

Approche 2. Utilisation de smprof.annotation_begin() et de smprof.annotation_end() pour annoter une ligne de code spécifique dans les fonctions

Vous pouvez également définir des annotations pour profiler des lignes de code spécifiques. Vous pouvez définir le point de départ et le point final exacts du profilage au niveau des lignes de code individuelles et non par fonctions. Par exemple, dans le script suivant, step_annotator est défini au début de chaque itération et se termine à la fin de l’itération. Pendant ce temps, d’autres annotateurs détaillés pour chaque opération sont définis et encapsulent les opérations cibles tout au long de chaque itération.

import smprof

SMProf = smprof.SMProfiler.instance()
config = smprof.Config()
config.profiler = {
    "EnableCuda": "1",
}
SMProf.configure(config)
SMProf.start_profiling()

for epoch in range(args.epochs):
    if world_size > 1:
        sampler.set_epoch(epoch)
    tstart = time.perf_counter()
    for i, data in enumerate(trainloader, 0):
        step_annotator = smprof.annotation_begin("step_" + str(i))

        inputs, labels = data
        inputs = inputs.to("cuda", non_blocking=True)
        labels = labels.to("cuda", non_blocking=True)
        optimizer.zero_grad()

        forward_annotator = smprof.annotation_begin("Forward")
        outputs = net(inputs)
        smprof.annotation_end(forward_annotator)

        loss_annotator = smprof.annotation_begin("Loss")
        loss = criterion(outputs, labels)
        smprof.annotation_end(loss_annotator)

        backward_annotator = smprof.annotation_begin("Backward")
        loss.backward()
        smprof.annotation_end(backward_annotator)

        optimizer_annotator = smprof.annotation_begin("Optimizer")
        optimizer.step()
        smprof.annotation_end(optimizer_annotator)

        smprof.annotation_end(step_annotator)

SMProf.stop_profiling()

Après avoir annoté et configuré les modules d’initiation du profileur, enregistrez le script à soumettre à l’aide d’un lanceur de tâches d’entraînement SageMaker à l’étape 2 ci-après. L’exemple de lanceur suppose que le script d’entraînement est nommé train_with_profiler_demo.py.

Étape 2 : créer un estimateur de cadre SageMaker AI et activer le profileur SageMaker

La procédure suivante montre comment préparer un estimateur de cadre SageMaker AI à l’entraînement à l’aide du kit SageMaker Python SDK.

  1. Configurez un objet profiler_config à l’aide des modules ProfilerConfig et Profiler comme suit.

    from sagemaker import ProfilerConfig, Profiler
profiler_config = ProfilerConfig(
    profile_params = Profiler(cpu_profiling_duration=3600)
)

    Voici la description du module Profiler et de son argument.

    • Profiler : module permettant d’activer le profileur SageMaker avec la tâche d’entraînement.

      • cpu_profiling_duration (int) : spécifiez la durée en secondes pour le profilage sur les CPU. La valeur par défaut est de 3 600 secondes.

  2. Créez un estimateur de cadre SageMaker AI à l’aide de l’objet profiler_config créé à l’étape précédente. Le code suivant montre un exemple de création d’un estimateur PyTorch. Si vous souhaitez créer un estimateur TensorFlow, importez plutôt sagemaker.tensorflow.TensorFlow et spécifiez l’une des versions de TensorFlow prises en charge par le profileur SageMaker. Pour plus d’informations sur les cadres et les types d’instance pris en charge, consultez Images de cadre SageMaker AI préinstallées avec le profileur SageMaker.

    import sagemaker
from sagemaker.pytorch import PyTorch

estimator = PyTorch(
    framework_version="2.0.0",
    role=sagemaker.get_execution_role(),
    entry_point="train_with_profiler_demo.py", # your training job entry point
    source_dir=source_dir, # source directory for your training script
    output_path=output_path,
    base_job_name="sagemaker-profiler-demo",
    hyperparameters=hyperparameters, # if any
    instance_count=1, # Recommended to test with < 8
    instance_type=ml.p4d.24xlarge,
    profiler_config=profiler_config
)

  3. Démarrez la tâche d’entraînement en exécutant la méthode fit. Avec wait=False, vous pouvez rendre silencieux les journaux des tâches d’entraînement et les laisser s’exécuter en arrière-plan.

    estimator.fit(wait=False)

Pendant l’exécution de la tâche d’entraînement ou une fois celle-ci terminée, vous pouvez passer à la rubrique suivante Ouverture de l’application de l’interface utilisateur du profileur SageMaker et commencer à explorer et à visualiser les profils enregistrés.

Si vous souhaitez accéder directement aux données de profil enregistrées dans le compartiment Amazon S3, utilisez le script suivant pour récupérer l’URI S3.

import os
# This is an ad-hoc function to get the S3 URI
# to where the profile output data is saved
def get_detailed_profiler_output_uri(estimator):
    config_name = None
    for processing in estimator.profiler_rule_configs:
        params = processing.get("RuleParameters", dict())
        rule = config_name = params.get("rule_to_invoke", "")
        if rule == "DetailedProfilerProcessing":
            config_name = processing.get("RuleConfigurationName")
            break
    return os.path.join(
        estimator.output_path, 
        estimator.latest_training_job.name, 
        "rule-output",
        config_name,
    )

print(
    f"Profiler output S3 bucket: ", 
    get_detailed_profiler_output_uri(estimator)
)

(Facultatif) Installer le package Python du profileur SageMaker

Pour utiliser le profileur SageMaker sur des images de cadre PyTorch ou TensorFlow non répertoriées dans Images de cadre SageMaker AI préinstallées avec le profileur SageMaker, ou sur votre propre conteneur Docker personnalisé à des fins d’entraînement, vous pouvez installer le profileur SageMaker à l’aide de l’un des Fichiers binaires du package Python du profileur SageMaker.

Option 1 : installer le package du profileur SageMaker lors du lancement d’une tâche d’entraînement

Si vous souhaitez utiliser le profileur SageMaker pour des tâches d’entraînement utilisant des images PyTorch ou TensorFlow non répertoriées dans Images de cadre SageMaker AI préinstallées avec le profileur SageMaker, créez un fichier requirements.txt et localisez-le sous le chemin que vous avez indiqué vers le paramètre source_dir de l’estimateur de cadre SageMaker AI à l’étape 2. Pour plus d’informations sur la configuration d’un fichier requirements.txt en général, consultez Utilisation des bibliothèques tierces dans la documentation sur le kit SageMaker Python SDK. Dans le fichier requirements.txt, ajoutez l’un des chemins de compartiment S3 pour le Fichiers binaires du package Python du profileur SageMaker.

# requirements.txt
https://smppy.s3.amazonaws.com/tensorflow/cu112/smprof-0.3.332-cp39-cp39-linux_x86_64.whl

Option 2 : installer le package du profileur SageMaker dans vos conteneurs Docker personnalisés

Si vous utilisez un conteneur Docker personnalisé pour l’entraînement, ajoutez un des Fichiers binaires du package Python du profileur SageMaker à votre Dockerfile.

# Install the smprof package version compatible with your CUDA version
RUN pip install https://smppy.s3.amazonaws.com/tensorflow/cu112/smprof-0.3.332-cp39-cp39-linux_x86_64.whl

Pour obtenir des conseils sur l’exécution d’un conteneur Docker personnalisé à des fins d’entraînement sur SageMaker AI en général, consultez Adaptation de votre propre conteneur d’entraînement.