Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Préparez et gérez un travail de formation avec SageMaker Profiler
<a name="profiler-prepare"></a>

**Note**  
Avis de fin de support : le 30 juin 2027, le support d'Amazon SageMaker Profiler AWS prendra fin. Après le 30 juin 2027, vous ne pourrez plus accéder à la console Profiler ni aux ressources du Profiler. Pour de plus amples informations, veuillez consulter [Modification de la disponibilité du profileur](profiler-availability-change.md).

La configuration pour exécuter une tâche de formation avec le SageMaker Profiler comprend deux étapes : adapter le script de formation et configurer le lanceur de tâches de SageMaker formation.

**Topics**
+ [Étape 1 : Adaptez votre script d'entraînement à l'aide des modules Python de SageMaker Profiler](#profiler-prepare-training-script)
+ [Étape 2 : Créez une SageMaker IA ModelTrainer et activez SageMaker Profiler](#profiler-profilerconfig)
+ [(Facultatif) Installez le package Python SageMaker Profiler](#profiler-install-python-package)

## Étape 1 : Adaptez votre script d'entraînement à l'aide des modules Python de SageMaker Profiler
<a name="profiler-prepare-training-script"></a>

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 de SageMaker Profiler. 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éez une SageMaker IA ModelTrainer et activez SageMaker Profiler](#profiler-profilerconfig).

**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](profiler-release-notes.md#profiler-release-notes-20231214) implique une modification radicale. Le nom du package Python de SageMaker Profiler est remplacé par`smppy`. `smprof` Cela est effectif dans les conteneurs [ SageMaker AI Framework ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) pour la TensorFlow version 2.12 et les versions ultérieures.  
Si vous utilisez l'une des versions précédentes des conteneurs [ SageMaker AI Framework, ](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only) telle que la TensorFlow version 2.11.0, le package SageMaker Profiler Python est toujours disponible en tant que. `smppy` Si vous ne savez pas quelle version ou quel nom de package utiliser, remplacez l'instruction d'importation du package SageMaker Profiler 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 pour le soumettre à l'aide d'un lanceur de tâches de SageMaker formation à l'étape 2 suivante. L’exemple de lanceur suppose que le script d’entraînement est nommé `train_with_profiler_demo.py`.

## Étape 2 : Créez une SageMaker IA ModelTrainer et activez SageMaker Profiler
<a name="profiler-profilerconfig"></a>

La procédure suivante montre comment préparer une SageMaker IA à l'entraînement ModelTrainer à l'aide du SDK SageMaker Python.

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 SageMaker Profiler avec le job de formation.
     +  `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. 

1. Créez une SageMaker IA ModelTrainer avec l'`profiler_config`objet créé à l'étape précédente. Le code suivant montre un exemple de création d'un PyTorch ModelTrainer. Si vous souhaitez créer un TensorFlow ModelTrainer, importez-le `sagemaker.tensorflow.TensorFlow` plutôt et spécifiez l'une des [ TensorFlow versions ](profiler-support.md#profiler-support-frameworks-tensorflow) prises en charge par SageMaker Profiler. Pour plus d’informations sur les cadres et les types d’instance pris en charge, consultez [SageMaker Images du framework AI préinstallées avec Profiler SageMaker](profiler-support.md#profiler-support-frameworks).

   ```
   from sagemaker.train import ModelTrainer
   from sagemaker.train.configs import SourceCode
   from sagemaker.core.helper.session_helper import get_execution_role
   from sagemaker.core import image_uris
   
   training_image = image_uris.retrieve(
       framework="pytorch", region=region, version="{{2.0.0}}",
       image_scope="training", instance_type={{ml.p4d.24xlarge}}
   )
   
   model_trainer = ModelTrainer(
       training_image=training_image,
       role=get_execution_role(),
       source_code=SourceCode(entry_script="{{train_with_profiler_demo.py}}", source_dir={{source_dir}}), # your training job entry point
       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}}
   )
   ```

1. Démarrez la tâche d’entraînement en exécutant la méthode `train`. 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.

   ```
   model_trainer.train(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 [Ouvrez l'application SageMaker Profiler UI](profiler-access-smprofiler-ui.md) 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(model_trainer):
    config_name = None
    for processing in model_trainer.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(
        model_trainer.output_path, 
        model_trainer.latest_training_job.name, 
        "rule-output",
        config_name,
    )

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

## (Facultatif) Installez le package Python SageMaker Profiler
<a name="profiler-install-python-package"></a>

Pour utiliser SageMaker Profiler sur PyTorch des images de TensorFlow framework non répertoriées dans [SageMaker Images du framework AI préinstallées avec Profiler SageMaker](profiler-support.md#profiler-support-frameworks) ou sur votre propre conteneur Docker personnalisé à des fins de formation, vous pouvez installer SageMaker Profiler à l'aide de l'un des. [SageMaker Fichiers binaires du package Python Profiler](profiler-support.md#profiler-python-package)

**Option 1 : installer le package SageMaker Profiler lors du lancement d'une tâche de formation **

Si vous souhaitez utiliser SageMaker Profiler pour des tâches de formation utilisant PyTorch TensorFlow des images qui ne figurent pas dans la liste[SageMaker Images du framework AI préinstallées avec Profiler SageMaker](profiler-support.md#profiler-support-frameworks), créez un `requirements.txt` fichier et localisez-le sous le chemin que vous avez indiqué pour le `source_dir` paramètre de l' SageMaker IA ModelTrainer à l'[étape 2](#profiler-profilerconfig). Pour plus d'informations sur la configuration d'un `requirements.txt` fichier en général, consultez la section [ Utilisation de bibliothèques tierces ](https://sagemaker.readthedocs.io/en/stable/api/sagemaker_train.html) dans la documentation * du SDK * SageMaker Python. Dans le fichier `requirements.txt`, ajoutez l’un des chemins de compartiment S3 pour le [SageMaker Fichiers binaires du package Python Profiler](profiler-support.md#profiler-python-package).

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

**Option 2 : installez le package SageMaker Profiler dans vos conteneurs Docker personnalisés **

Si vous utilisez un conteneur Docker personnalisé pour l’entraînement, ajoutez un des [SageMaker Fichiers binaires du package Python Profiler](profiler-support.md#profiler-python-package) à 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'utilisation d'un conteneur Docker personnalisé pour la formation sur l' SageMaker IA en général, consultez [ Adaptation de votre propre conteneur de formation](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html).