

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.

# Conteneurs avec algorithmes d’entraînement personnalisés
<a name="your-algorithms-training-algo"></a>

Cette section explique comment Amazon SageMaker AI interagit avec un conteneur Docker qui exécute votre algorithme d'entraînement personnalisé. Utilisez ces informations pour écrire le code d’entraînement et créer une image Docker pour vos algorithmes d’entraînement. 

**Topics**
+ [Comment Amazon SageMaker AI gère votre image de formation](your-algorithms-training-algo-dockerfile.md)
+ [Comment Amazon SageMaker AI fournit des informations de formation](your-algorithms-training-algo-running-container.md)
+ [Exécution d’un entraînement avec EFA](your-algorithms-training-efa.md)
+ [Comment Amazon SageMaker AI signale le succès et l'échec d'un algorithme](your-algorithms-training-signal-success-failure.md)
+ [Comment Amazon SageMaker AI traite les résultats de formation](your-algorithms-training-algo-output.md)

# Comment Amazon SageMaker AI gère votre image de formation
<a name="your-algorithms-training-algo-dockerfile"></a>

Vous pouvez utiliser un script de point d’entrée personnalisé pour automatiser l’infrastructure et réaliser l’entraînement dans un environnement de production. Si vous transmettez votre script de point d'entrée dans votre conteneur Docker, vous pouvez également l'exécuter en tant que script autonome sans avoir à reconstruire vos images. SageMaker L'IA traite votre image d'entraînement à l'aide d'un script de point d'entrée de conteneur Docker. 

Cette section vous montre comment utiliser un point d’entrée personnalisé sans utiliser la boîte à outils d’entraînement. Si vous souhaitez utiliser un point d'entrée personnalisé mais que vous ne savez pas comment configurer manuellement un conteneur Docker, nous vous recommandons d'utiliser plutôt la bibliothèque de boîtes à [outils de SageMaker formation](https://github.com/aws/sagemaker-training-toolkit). Pour plus d’informations sur comment utiliser la boîte à outils d’entraînement, consultez [Adaptation de votre propre conteneur d’entraînement](adapt-training-container.md). 

Par défaut, l' SageMaker IA recherche un script appelé `train` dans votre conteneur. Vous pouvez également fournir manuellement votre propre point d'entrée personnalisé en utilisant les `ContainerEntrypoint` paramètres `ContainerArguments` et de l'[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)API. 

Vous disposez des deux options suivantes pour configurer manuellement votre conteneur Docker afin d’exécuter votre image.
+ Utilisez l'[CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API et un conteneur Docker contenant une instruction de point d'entrée.
+ Utilisez l’API `CreateTrainingJob` et transmettez votre script d’entraînement depuis l’extérieur de votre conteneur Docker.

Si vous transmettez votre script d’entraînement depuis l’extérieur de votre conteneur Docker, vous n’avez pas besoin de reconstruire le conteneur Docker lorsque vous mettez à jour votre script. Vous pouvez également utiliser plusieurs scripts différents à exécuter dans le même conteneur.

Votre script de point d’entrée doit contenir le code d’entraînement pour votre image. Si vous utilisez le paramètre `source_dir` facultatif dans un [estimateur](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html), il doit faire référence au chemin Amazon S3 relatif vers le dossier contenant votre script de point d’entrée. Vous pouvez référencer plusieurs fichiers à l’aide du paramètre `source_dir`. Si vous n’utilisez pas `source_dir`, vous pouvez spécifier le point d’entrée à l’aide du paramètre `entry_point`. Pour un exemple de script de point d'entrée personnalisé contenant un estimateur, voir [Bring Your Own Model with SageMaker ](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-script-mode/sagemaker-script-mode.html) AI Script Mode.

SageMaker L'entraînement par modèle d'IA prend en charge les compartiments de répertoire S3 Express One Zone à hautes performances comme emplacement d'entrée de données pour le mode fichier, le mode fichier rapide et le mode tube. Vous pouvez également utiliser les compartiments de répertoire S3 Express One Zone pour stocker votre sortie d’entraînement. Pour utiliser S3 Express One Zone, fournissez l’URI d’un compartiment de répertoire S3 Express One Zone au lieu d’un compartiment Amazon S3 à usage général. Vous ne pouvez chiffrer vos données de sortie d' SageMaker IA que dans des compartiments de répertoire avec un chiffrement côté serveur avec des clés gérées par Amazon S3 (SSE-S3). Le chiffrement côté serveur à l'aide de AWS KMS clés (SSE-KMS) n'est actuellement pas pris en charge pour le stockage des données de sortie de l' SageMaker IA dans des compartiments d'annuaire. Pour plus d’informations, consultez [S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html).

## Exécuter une tâche d’entraînement à l’aide d’un script de point d’entrée intégré au conteneur Docker
<a name="your-algorithms-training-algo-dockerfile-api-ep-in"></a>

SageMaker L'IA peut exécuter un script de point d'entrée intégré à votre conteneur Docker. 
+ Par défaut, Amazon SageMaker AI exécute le conteneur suivant.

  ```
  docker run image train
  ```
+ SageMaker AI remplace toutes les instructions [CMD](https://docs.docker.com/engine/reference/builder/#cmd) par défaut d'un conteneur en spécifiant l'`train`argument après le nom de l'image. Dans votre conteneur Docker, utilisez la forme `exec` suivante de l’instruction `ENTRYPOINT`.

  ```
  ENTRYPOINT ["executable", "param1", "param2", ...]
  ```

  L’exemple suivant montre comment spécifier une instruction de point d’entrée Python appelée `k-means-algorithm.py`.

  ```
  ENTRYPOINT ["python", "k-means-algorithm.py"]
  ```

  Le formulaire `exec` de l’instruction `ENTRYPOINT` lance l’exécutable directement, et non en tant qu’enfant de `/bin/sh`. Cela lui permet de recevoir des signaux similaires `SIGTERM` et en `SIGKILL` provenance de SageMaker APIs. Les conditions suivantes s'appliquent lors de l'utilisation du SageMaker APIs. 
  + L'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API comporte une condition d'arrêt qui demande à l' SageMaker IA d'arrêter l'entraînement du modèle après un certain temps. 
  + L’exemple suivant montre l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html). L’API émet l’équivalent de la commande `docker stop`, avec 2 minutes de délai d’attente, pour arrêter correctement le conteneur spécifié.

    ```
    docker stop -t 120
    ```

    La commande tente d’arrêter le conteneur en cours d’exécution en envoyant un signal `SIGTERM`. Après le délai d’expiration de 2 minutes, l’API envoie `SIGKILL` et arrête de force les conteneurs. Si le conteneur gère `SIGTERM` normalement et s’arrête dans les 120 secondes suivant sa réception, aucun `SIGKILL` n’est envoyé. 

  Si vous souhaitez accéder aux artefacts du modèle intermédiaire une fois que l' SageMaker IA a arrêté l'entraînement, ajoutez du code pour gérer la sauvegarde des artefacts dans votre `SIGTERM` gestionnaire.
+ Si vous prévoyez d’utiliser des dispositifs GPU pour l’entraînement des modèles, assurez-vous que vos conteneurs sont compatibles avec `nvidia-docker`. N’incluez que la boîte à outils CUDA dans les conteneurs ; ne regroupez pas de pilote NVIDIA avec l’image. Pour plus d’informations sur `nvidia-docker`, consultez [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).
+ Vous ne pouvez pas utiliser l'`tini`initialiseur comme script de point d'entrée dans les conteneurs SageMaker AI, car il est confus par les arguments et. `train` `serve`
+ `/opt/ml`et tous les sous-répertoires sont réservés par SageMaker entraînement. Lors de la création de l’image Docker de votre algorithme, veillez à ne pas placer de données requises par votre algorithme dans ce répertoire. Dans le cas contraire, les données risquent de ne plus être visibles pendant l’entraînement.

Pour regrouper vos scripts shell ou Python dans votre image Docker, ou pour fournir le script dans un compartiment Amazon S3 ou à l'aide de la AWS Command Line Interface (CLI), passez à la section suivante.

### Regrouper votre script shell dans un conteneur Docker
<a name="your-algorithms-training-algo-dockerfile-script-sh"></a>

 Si vous souhaitez regrouper un script shell personnalisé dans votre image Docker, procédez comme suit. 

1. Copiez votre script shell depuis votre répertoire de travail vers votre conteneur Docker. L’extrait de code suivant copie un script de point d’entrée personnalisé `custom_entrypoint.sh` du répertoire de travail actuel vers un conteneur Docker situé dans `mydir`. L’exemple suivant suppose que Python est installé sur l’image Docker de base.

   ```
   FROM <base-docker-image>:<tag>
   
   # Copy custom entrypoint from current dir to /mydir on container
   COPY ./custom_entrypoint.sh /mydir/
   ```

1. Créez et envoyez un conteneur Docker vers l’Amazon Elastic Container Registry ([Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) en suivant les instructions de la section [Pousser une image Docker](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) dans le *Guide de l’utilisateur Amazon ECR*.

1. Lancez la tâche de formation en exécutant la AWS CLI commande suivante.

   ```
   aws --region <your-region> sagemaker create-training-job \
   --training-job-name <your-training-job-name> \
   --role-arn <your-execution-role-arn> \
   --algorithm-specification '{ \ 
       "TrainingInputMode": "File", \
       "TrainingImage": "<your-ecr-image>", \
       "ContainerEntrypoint": ["/bin/sh"], \
       "ContainerArguments": ["/mydir/custom_entrypoint.sh"]}' \
   --output-data-config '{"S3OutputPath": "s3://custom-entrypoint-output-bucket/"}' \
   --resource-config '{"VolumeSizeInGB":10,"InstanceCount":1,"InstanceType":"ml.m5.2xlarge"}' \
   --stopping-condition '{"MaxRuntimeInSeconds": 180}'
   ```

### Regrouper votre script Python dans un conteneur Docker
<a name="your-algorithms-training-algo-dockerfile-script-py"></a>

Pour regrouper un script Python personnalisé dans votre image Docker, procédez comme suit. 

1. Copiez votre script Python depuis votre répertoire de travail vers votre conteneur Docker. L’extrait de code suivant copie un script de point d’entrée personnalisé `custom_entrypoint.py` du répertoire de travail actuel vers un conteneur Docker situé dans `mydir`.

   ```
   FROM <base-docker-image>:<tag>
   # Copy custom entrypoint from current dir to /mydir on container
   COPY ./custom_entrypoint.py /mydir/
   ```

1. Lancez la tâche de formation en exécutant la AWS CLI commande suivante.

   ```
   --algorithm-specification '{ \ 
       "TrainingInputMode": "File", \
       "TrainingImage": "<your-ecr-image>", \
       "ContainerEntrypoint": ["python"], \
       "ContainerArguments": ["/mydir/custom_entrypoint.py"]}' \
   ```

## Exécuter une tâche d’entraînement à l’aide d’un script de point d’entrée en dehors du conteneur Docker
<a name="your-algorithms-training-algo-dockerfile-api-pass-ep"></a>

Vous pouvez utiliser votre propre conteneur Docker pour l’entraînement et transmettre un script de point d’entrée depuis l’extérieur du conteneur Docker. La structuration de votre script de point d’entrée en dehors du conteneur présente certains avantages. Si vous mettez à jour votre script de point d’entrée, vous n’avez pas besoin de reconstruire le conteneur Docker. Vous pouvez également utiliser plusieurs scripts différents à exécuter dans le même conteneur. 

Spécifiez l'emplacement de votre script d'entraînement à l'aide des `ContainerArguments` paramètres `ContainerEntrypoint` et de l'[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)API. Ces points d’entrée et arguments se comportent de la même manière que les points d’entrée et arguments Docker. Les valeurs de ces paramètres remplacent les valeurs correspondantes `ENTRYPOINT` ou `CMD` fournies dans le cadre du conteneur Docker. 

Lorsque vous transmettez votre script de point d’entrée personnalisé à votre conteneur d’entraînement Docker, les entrées que vous fournissez déterminent le comportement du conteneur.
+ Par exemple, si vous fournissez uniquement`ContainerEntrypoint`, la syntaxe de la demande à l'aide de l' CreateTrainingJob API est la suivante.

  ```
  {
      "AlgorithmSpecification": {
          "ContainerEntrypoint": ["string"],   
          ...     
          }       
  }
  ```

  Ensuite, le backend de SageMaker formation exécute votre point d'entrée personnalisé comme suit.

  ```
  docker run --entrypoint <ContainerEntrypoint> image
  ```
**Note**  
S'il `ContainerEntrypoint` est fourni, le backend d' SageMaker entraînement exécute l'image avec le point d'entrée donné et remplace la valeur par défaut `ENTRYPOINT` de l'image.
+ Si vous fournissez uniquement`ContainerArguments`, SageMaker AI suppose que le conteneur Docker contient un script de point d'entrée. La syntaxe des requêtes utilisant l’API `CreateTrainingJob` est la suivante.

  ```
  {
      "AlgorithmSpecification": {
          "ContainerArguments": ["arg1", "arg2"],
          ...
      }
  }
  ```

  Le backend de SageMaker formation gère votre point d'entrée personnalisé comme suit.

  ```
  docker run image <ContainerArguments>
  ```
+ Si vous fournissez à la fois le `ContainerEntrypoint` et le `ContainerArguments`, la syntaxe de la requête utilisant l’API `CreateTrainingJob` est la suivante.

  ```
  {
      "AlgorithmSpecification": {
          "ContainerEntrypoint": ["string"],
          "ContainerArguments": ["arg1", "arg2"],
          ...
      }
  }
  ```

   Le backend de SageMaker formation gère votre point d'entrée personnalisé comme suit.

  ```
  docker run --entrypoint <ContainerEntrypoint> image <ContainerArguments>
  ```

Vous pouvez utiliser n’importe quelle source `InputDataConfig` prise en charge dans l’API `CreateTrainingJob` pour fournir un script de point d’entrée permettant d’exécuter votre image d’entraînement. 

### Fournissez votre script de point d’entrée dans un compartiment Amazon S3
<a name="your-algorithms-training-algo-dockerfile-script-s3"></a>

 Pour fournir un script de point d'entrée personnalisé à l'aide d'un compartiment S3, utilisez le `S3DataSource` paramètre de l'[DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)API pour spécifier l'emplacement du script. Si vous utilisez le paramètre `S3DataSource`, les éléments suivants sont obligatoires.
+ [InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)Il doit être du type`File`.
+ Le [S3 DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource) doit l'être`FullyReplicated`.

Dans l’exemple suivant, un script appelé custom\$1entrypoint.sh est placé dans un chemin d’accès vers un compartiment S3 `s3://<bucket-name>/<bucket prefix>/custom_entrypoint.sh`.

```
#!/bin/bash
echo "Running custom_entrypoint.sh"
echo "Hello you have provided the following arguments: " "$@"
```

Ensuite, vous devez définir la configuration du canal de données d’entrée pour exécuter une tâche d’entraînement. Pour ce faire, utilisez AWS CLI directement ou un fichier JSON.

#### Configurer le canal de données d'entrée à l' AWS CLI aide d'un fichier JSON
<a name="your-algorithms-training-algo-dockerfile-script-s3-json"></a>

Pour configurer votre canal de données d'entrée avec un fichier JSON, AWS CLI utilisez-le comme indiqué dans la structure de code suivante. Assurez-vous que tous les champs suivants utilisent la syntaxe de demande définie dans l'[CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)API.

```
// run-my-training-job.json
{
 "[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-AlgorithmSpecification)": { 
        "ContainerEntrypoint": ["/bin/sh"],
        "ContainerArguments": ["/opt/ml/input/data/<your_channel_name>/custom_entrypoint.sh"],
         ...
   },
  "[InputDataConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-InputDataConfig)": [ 
    { 
        "[ChannelName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-ChannelName)": "<your_channel_name>",
        "[DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-DataSource)": { 
            "[S3DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)": { 
                "[S3DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataDistributionType)": "FullyReplicated",
                "[S3DataType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataType)": "S3Prefix",
                "[S3Uri](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3Uri)": "s3://<bucket-name>/<bucket_prefix>"
            }
        },
        "[InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)": "File",
    },
    ...]
}
```

Ensuite, exécutez la AWS CLI commande pour lancer la tâche de formation à partir du fichier JSON comme suit.

```
aws sagemaker create-training-job --cli-input-json file://run-my-training-job.json
```

#### Configurez le canal de données d'entrée en utilisant AWS CLI directement
<a name="your-algorithms-training-algo-dockerfile-script-s3-directly"></a>

Pour configurer votre canal de données d'entrée sans fichier JSON, utilisez la structure de AWS CLI code suivante.

```
aws --region <your-region> sagemaker create-training-job \
--training-job-name <your-training-job-name> \
--role-arn <your-execution-role-arn> \
--algorithm-specification '{ \
    "TrainingInputMode": "File", \
    "TrainingImage": "<your-ecr-image>", \
    "ContainerEntrypoint": ["/bin/sh"], \
    "ContainerArguments": ["/opt/ml/input/data/<your_channel_name>/custom_entrypoint.sh"]}' \
--input-data-config '[{ \
    "ChannelName":"<your_channel_name>", \
    "DataSource":{ \
        "S3DataSource":{ \
            "S3DataType":"S3Prefix", \
            "S3Uri":"s3://<bucket-name>/<bucket_prefix>", \
            "S3DataDistributionType":"FullyReplicated"}}}]' \
--output-data-config '{"S3OutputPath": "s3://custom-entrypoint-output-bucket/"}' \
--resource-config '{"VolumeSizeInGB":10,"InstanceCount":1,"InstanceType":"ml.m5.2xlarge"}' \
--stopping-condition '{"MaxRuntimeInSeconds": 180}'
```

# Comment Amazon SageMaker AI fournit des informations de formation
<a name="your-algorithms-training-algo-running-container"></a>

Cette section explique comment l' SageMaker IA met les informations d'entraînement, telles que les données d'entraînement, les hyperparamètres et autres informations de configuration, à la disposition de votre conteneur Docker. 

Lorsque vous envoyez une [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)demande à SageMaker AI pour démarrer l'entraînement du modèle, vous spécifiez le chemin Amazon Elastic Container Registry (Amazon ECR) de l'image Docker contenant l'algorithme d'entraînement. Vous spécifiez également l'emplacement Amazon Simple Storage Service (Amazon S3) où les données d'entraînement sont stockées, ainsi que les paramètres spécifiques à l'algorithme. SageMaker L'IA met ces informations à la disposition du conteneur Docker afin que votre algorithme d'entraînement puisse les utiliser. Cette section explique comment ces informations sont rendues disponibles pour votre conteneur Docker. Pour plus d’informations sur la création d’une tâche d’entraînement, consultez `CreateTrainingJob`. Pour plus d'informations sur la manière dont les conteneurs SageMaker AI organisent les informations, consultez[SageMaker Boîtes à outils de formation et d'inférence](amazon-sagemaker-toolkits.md).

**Topics**
+ [Hyperparamètres](#your-algorithms-training-algo-running-container-hyperparameters)
+ [Variables d’environnement](#your-algorithms-training-algo-running-container-environment-variables)
+ [Configuration des données d’entrée](#your-algorithms-training-algo-running-container-inputdataconfig)
+ [Données d’entraînement](#your-algorithms-training-algo-running-container-trainingdata)
+ [Configuration d’entraînement distribué](#your-algorithms-training-algo-running-container-dist-training)

## Hyperparamètres
<a name="your-algorithms-training-algo-running-container-hyperparameters"></a>

 SageMaker L'IA rend les hyperparamètres d'une `CreateTrainingJob` requête disponibles dans le conteneur Docker du `/opt/ml/input/config/hyperparameters.json` fichier.

Voici un exemple de configuration d'hyperparamètres permettant de spécifier `hyperparameters.json` les `eta` hyperparamètres `num_round` et dans l'`CreateTrainingJob`opération pour. [XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) 

```
{
    "num_round": "128",
    "eta": "0.001"
}
```

Pour une liste complète des hyperparamètres pouvant être utilisés pour l' XGBoost algorithme intégré de l' SageMaker IA, voir [XGBoostHyperparamètres](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost_hyperparameters.html).

Les hyperparamètres que vous pouvez régler dépendent de l’algorithme que vous entraînez. Pour obtenir la liste des hyperparamètres disponibles pour un algorithme intégré à l' SageMaker IA, retrouvez-les dans **Hyperparamètres** sous le lien de l'algorithme dans Utiliser les [algorithmes intégrés ou les modèles pré-entraînés d'Amazon SageMaker AI](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html).

## Variables d’environnement
<a name="your-algorithms-training-algo-running-container-environment-variables"></a>

SageMaker L'IA définit les variables d'environnement suivantes dans votre conteneur :
+ TRAINING\$1JOB\$1NAME : spécifiée dans le paramètre `TrainingJobName` de la requête `CreateTrainingJob`.
+ TRAINING\$1JOB\$1ARN : Amazon Resource Name (ARN) de la tâche d’entraînement renvoyée en tant que `TrainingJobArn` dans la réponse `CreateTrainingJob`.
+ Toutes les variables d’environnement spécifiées dans le paramètre [Environnement](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-Environment) de la demande `CreateTrainingJob`.

## Configuration des données d’entrée
<a name="your-algorithms-training-algo-running-container-inputdataconfig"></a>

SageMaker L'IA met les informations du canal de données contenues dans le `InputDataConfig` paramètre de votre `CreateTrainingJob` demande à disposition dans le `/opt/ml/input/config/inputdataconfig.json` fichier de votre conteneur Docker.

Supposons, par exemple, que vous spécifiez trois canaux de données (`train``evaluation`, et`validation`) dans votre demande. SageMaker AI fournit le JSON suivant :

```
{
  "train" : {"ContentType":  "trainingContentType",
             "TrainingInputMode": "File",
             "S3DistributionType": "FullyReplicated",
             "RecordWrapperType": "None"},
  "evaluation" : {"ContentType":  "evalContentType",
                  "TrainingInputMode": "File",
                  "S3DistributionType": "FullyReplicated",
                  "RecordWrapperType": "None"},
  "validation" : {"TrainingInputMode": "File",
                  "S3DistributionType": "FullyReplicated",
                  "RecordWrapperType": "None"}
}
```

**Note**  
SageMaker L'IA fournit uniquement des informations pertinentes sur chaque canal de données (par exemple, le nom du canal et le type de contenu) au conteneur, comme indiqué dans l'exemple précédent. `S3DistributionType`sera défini comme `FullyReplicated` si vous spécifiiez EFS ou FSx Lustre comme sources de données d'entrée.

## Données d’entraînement
<a name="your-algorithms-training-algo-running-container-trainingdata"></a>

Le paramètre `TrainingInputMode` dans `AlgorithmSpecification` de la demande [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) spécifie comment le jeu de données d’entraînement est mis à la disposition de votre conteneur. Les modes d’entrée suivants sont disponibles.
+ **Mode `File`**

  Si vous utilisez `File` le mode comme `TrainingInputMode` valeur, l' SageMaker IA définit les paramètres suivants dans votre conteneur.
  + Votre paramètre `TrainingInputMode` est écrit dans `inputdataconfig.json` sous la forme « File ».
  + Votre répertoire de canaux de données est écrit dans `/opt/ml/input/data/channel_name`.

  Si vous utilisez `File` le mode, SageMaker l'IA crée un répertoire pour chaque canal. Par exemple, si vous avez trois canaux nommés `training` `validation``testing`, et que SageMaker AI crée les trois répertoires suivants dans votre conteneur Docker : 
  + `/opt/ml/input/data/training`
  + `/opt/ml/input/data/validation`
  + `/opt/ml/input/data/testing`

  Le mode `File` prend également en charge les sources de données suivantes.
  + Amazon Simple Storage Service (Amazon S3)
  + Amazon Elastic File System (Amazon EFS)
  + Amazon FSx pour Lustre
**Note**  
Les canaux qui utilisent des sources de données de systèmes de fichiers telles qu'Amazon EFS et Amazon FSx doivent utiliser `File` le mode. Dans ce cas, le chemin de répertoire fourni dans le canal est monté à l’emplacement `/opt/ml/input/data/channel_name`.
+ **Mode `FastFile`**

  Si vous utilisez `FastFile` le mode comme votre`TrainingInputNodeParameter`, l' SageMaker IA définit les paramètres suivants dans votre conteneur.
  + Comme en mode `File`, en mode `FastFile`, votre paramètre `TrainingInputMode` est écrit dans `inputdataconfig.json` sous la forme « File ».
  + Votre répertoire de canaux de données est écrit dans `/opt/ml/input/data/channel_name`.

  Le mode `FastFile` prend en charge les sources de données suivantes.
  + Amazon S3

  Si vous utilisez le mode `FastFile`, le répertoire des canaux est monté avec une autorisation en lecture seule.

  Historiquement, le mode `File` a précédé le mode `FastFile`. Pour garantir la rétrocompatibilité, les algorithmes qui prennent en charge le mode `File` peuvent également fonctionner sans problème avec le mode `FastFile` tant que le paramètre `TrainingInputMode` est défini sur `File` dans `inputdataconfig.json.`.
**Note**  
Les canaux qui utilisent le mode `FastFile` doivent utiliser un `S3DataType` « S3Prefix ».  
Le mode `FastFile` présente une vue de dossier qui utilise la barre oblique (`/`) comme délimiteur pour regrouper les objets Amazon S3 dans des dossiers. Les préfixes `S3Uri` ne doivent pas correspondre à un nom de dossier partiel. Par exemple, si un jeu de données Amazon S3 contient `s3://amzn-s3-demo-bucket/train-01/data.csv`, ni `s3://amzn-s3-demo-bucket/train` ni `s3://amzn-s3-demo-bucket/train-01` ne sont autorisés comme préfixes `S3Uri`.  
Une barre oblique finale est recommandée pour définir un canal correspondant à un dossier. Par exemple, le canal `s3://amzn-s3-demo-bucket/train-01/` du dossier `train-01`. Sans la barre oblique finale, le canal serait ambigu s’il existait un autre dossier `s3://amzn-s3-demo-bucket/train-011/` ou fichier `s3://amzn-s3-demo-bucket/train-01.txt/`.
+ **Mode `Pipe`**
  + Paramètre `TrainingInputMode` écrit dans `inputdataconfig.json` : « Pipe »
  + Répertoire du canal de données dans le conteneur Docker : `/opt/ml/input/data/channel_name_epoch_number`
  + Sources de données prises en charge : Amazon S3

  Vous devez lire à partir d’un tube séparé pour chaque canal. Par exemple, si vous disposez de trois canaux nommés `training`, `validation` et `testing`, vous devez lire à partir des tubes suivants :
  + `/opt/ml/input/data/training_0, /opt/ml/input/data/training_1, ...`
  + `/opt/ml/input/data/validation_0, /opt/ml/input/data/validation_1, ...`
  + `/opt/ml/input/data/testing_0, /opt/ml/input/data/testing_1, ...`

  Lisez les tubes de manière séquentielle. Par exemple, si vous avez un canal appelé `training`, lisez les tubes selon cette séquence : 

  1. Ouvrez `/opt/ml/input/data/training_0` en mode lecture et lisez-le sur end-of-file (EOF) ou, si vous en avez terminé avec la première époque, fermez le fichier pipe plus tôt. 

  1. Après avoir fermé le premier fichier tube, recherchez `/opt/ml/input/data/training_1` et lisez-le jusqu’à ce que vous ayez terminé la deuxième époque, etc.

  Si le fichier correspondant à une époque donnée n’existe pas encore, votre code devra peut-être réessayer jusqu’à ce que le tube soit créé. Il n’y a aucune restriction de séquençage parmi les types de canal. Par exemple, vous pouvez lire plusieurs époques pour le canal `training` et commencer à lire le canal `validation` lorsque vous êtes prêt. Vous pouvez également les lire simultanément si votre algorithme le nécessite.

  Pour un exemple de bloc-notes Jupyter qui montre comment utiliser le mode Pipe lorsque vous apportez votre propre conteneur, consultez l'article [Apporter votre propre algorithme en mode tuyau à Amazon AI](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/pipe_bring_your_own/pipe_bring_your_own.ipynb). SageMaker 

  

SageMaker L'entraînement par modèle d'IA prend en charge les compartiments de répertoire S3 Express One Zone à hautes performances comme emplacement d'entrée de données pour le mode fichier, le mode fichier rapide et le mode tube. Pour utiliser S3 Express One Zone, entrez l’emplacement du compartiment de répertoire S3 Express One Zone au lieu d’un compartiment Amazon S3 à usage général. Fournissez l’ARN du rôle IAM avec la politique de contrôle d’accès et d’autorisation requise. Pour plus d'informations, consultez [AmazonSageMakerFullAccesspolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerFullAccess.html). Vous ne pouvez chiffrer vos données de sortie d' SageMaker IA que dans des compartiments de répertoire avec un chiffrement côté serveur avec des clés gérées par Amazon S3 (SSE-S3). Le chiffrement côté serveur à l'aide de AWS KMS clés (SSE-KMS) n'est actuellement pas pris en charge pour le stockage des données de sortie de l' SageMaker IA dans des compartiments d'annuaire. Pour plus d’informations, consultez [S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html).

## Configuration d’entraînement distribué
<a name="your-algorithms-training-algo-running-container-dist-training"></a>

Si vous effectuez une formation distribuée avec plusieurs conteneurs, l' SageMaker IA rend les informations relatives à tous les conteneurs disponibles dans le `/opt/ml/input/config/resourceconfig.json` fichier.

Pour permettre la communication entre conteneurs, ce fichier JSON contient des informations pour tous les conteneurs. SageMaker L'IA rend ce fichier disponible pour les algorithmes à la fois `File` et pour les algorithmes de `Pipe` mode. Le fichier fournit les informations suivantes :
+ `current_host` : nom du conteneur actuel sur le réseau de conteneurs. Par exemple, `algo-1`. Les valeurs d’hôte peuvent changer à tout moment. N’écrivez pas de code contenant des valeurs spécifiques pour cette variable.
+ `hosts` : liste des noms de tous les conteneurs sur le réseau de conteneurs, triée de manière lexicographique. Par exemple, `["algo-1", "algo-2", "algo-3"]` pour un cluster à trois nœuds. Les conteneurs peuvent utiliser ces noms pour traiter d’autres conteneurs sur le réseau de conteneurs. Les valeurs d’hôte peuvent changer à tout moment. N’écrivez pas de code contenant des valeurs spécifiques pour ces variables.
+ `network_interface_name` : nom de l’interface réseau qui est exposée à votre conteneur. Par exemple, les conteneurs utilisant l’interface Message Passing Interface (MPI) peuvent utiliser ces informations pour définir le nom de l’interface réseau.
+ N’utilisez pas les informations de `/etc/hostname` ou `/etc/hosts`, car elles peuvent être inexactes.
+ Les informations sur les noms d’hôte peuvent ne pas être immédiatement disponibles pour le conteneur de l’algorithme. Nous vous recommandons d’ajouter une politique de nouvelle tentative aux opérations de résolution de nom d’hôte quand les nœuds deviennent disponibles dans le cluster.

Voici un exemple de fichier sur le nœud 1 d’un cluster à trois nœuds :

```
{
    "current_host": "algo-1",
    "hosts": ["algo-1","algo-2","algo-3"],
    "network_interface_name":"eth1"
}
```

# Exécution d’un entraînement avec EFA
<a name="your-algorithms-training-efa"></a>

 SageMaker L'IA permet l'intégration aux appareils [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) pour accélérer les applications de calcul haute performance (HPC) et d'apprentissage automatique. Cette intégration vous permet de tirer parti d’un périphérique EFA lors de l’exécution de vos tâches d’entraînement distribué. Vous pouvez ajouter l'intégration EFA à un conteneur Docker existant que vous apportez à SageMaker AI. Les informations suivantes expliquent comment configurer votre propre conteneur pour qu’il utilise un périphérique EFA pour vos tâches d’entraînement distribué. 

## Conditions préalables
<a name="your-algorithms-training-efa-prereq"></a>

 Votre conteneur doit satisfaire aux [spécifications du conteneur d'SageMaker entraînement](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-dockerfile.html).  

## Installation d’EFA et des packages requis
<a name="your-algorithms-training-efa-install"></a>

Votre conteneur doit télécharger et installer le [logiciel EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html). Cela permet à votre conteneur de reconnaître le périphérique EFA, et fournit des versions compatibles de Libfabric et Open MPI. 

Tous les outils tels que MPI et NCCL doivent être installés et gérés à l’intérieur du conteneur pour être utilisés dans le cadre de votre tâche d’entraînement compatible EFA. Pour obtenir la liste de toutes les versions d’EFA disponibles, voir [Vérification du programme d’installation EFA à l’aide d’un total de contrôle](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-verify.html). L’exemple suivant montre comment modifier le fichier Dockerfile de votre conteneur compatible EFA pour installer EFA, MPI, OFI, NCCL et NCCL-TEST.

**Note**  
Lorsque vous utilisez PyTorch EFA sur votre conteneur, la version NCCL de votre conteneur doit correspondre à la version NCCL de votre installation. PyTorch Pour vérifier la version PyTorch NCCL, utilisez la commande suivante :  

```
torch.cuda.nccl.version()
```

```
ARG OPEN_MPI_PATH=/opt/amazon/openmpi/
ENV NCCL_VERSION=2.7.8
ENV EFA_VERSION=1.30.0
ENV BRANCH_OFI=1.1.1

#################################################
## EFA and MPI SETUP
RUN cd $HOME \
  && curl -O https://s3-us-west-2.amazonaws.com/aws-efa-installer/aws-efa-installer-${EFA_VERSION}.tar.gz \
  && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \
  && cd aws-efa-installer \
  && ./efa_installer.sh -y --skip-kmod -g \

ENV PATH="$OPEN_MPI_PATH/bin:$PATH"
ENV LD_LIBRARY_PATH="$OPEN_MPI_PATH/lib/:$LD_LIBRARY_PATH"

#################################################
## NCCL, OFI, NCCL-TEST SETUP
RUN cd $HOME \
  && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
  && cd nccl \
  && make -j64 src.build BUILDDIR=/usr/local

RUN apt-get update && apt-get install -y autoconf
RUN cd $HOME \
  && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \
  && cd aws-ofi-nccl \
  && ./autogen.sh \
  && ./configure --with-libfabric=/opt/amazon/efa \
       --with-mpi=/opt/amazon/openmpi \
       --with-cuda=/usr/local/cuda \
       --with-nccl=/usr/local --prefix=/usr/local \
  && make && make install
  
RUN cd $HOME \
  && git clone https://github.com/NVIDIA/nccl-tests \
  && cd nccl-tests \
  && make MPI=1 MPI_HOME=/opt/amazon/openmpi CUDA_HOME=/usr/local/cuda NCCL_HOME=/usr/local
```

## Considérations lors de la création de votre conteneur
<a name="your-algorithms-training-efa-considerations"></a>

Le périphérique EFA est monté sur le conteneur en tant que `/dev/infiniband/uverbs0` dans la liste des périphériques accessibles au conteneur. Sur les instances P4d, le conteneur a accès à 4 périphériques EFA. Les périphériques EFA peuvent être trouvés dans la liste des périphériques accessibles au conteneur de la façon suivante : 
+  `/dev/infiniband/uverbs0` 
+  `/dev/infiniband/uverbs1` 
+  `/dev/infiniband/uverbs2` 
+  `/dev/infiniband/uverbs3` 

 Pour obtenir des informations sur le nom d’hôte, les noms d’hôte homologues et l’interface réseau (pour MPI) à partir du fichier `resourceconfig.json` fourni à chaque instance de conteneur, consultez [Configuration d’entraînement distribué](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-dist-training). Votre conteneur gère le trafic TCP régulier entre homologues via les interfaces réseau Elastic (ENI) par défaut, tout en gérant le trafic OFI (contournement du noyau) via le périphérique EFA. 

## Vérifier que votre périphérique EFA est reconnu
<a name="your-algorithms-training-efa-verify"></a>

  Pour vérifier que le périphérique EFA est reconnu, exécutez la commande suivante à partir de votre conteneur. 

```
/opt/amazon/efa/bin/fi_info -p efa
```

Votre sortie doit ressembler à ce qui suit :

```
provider: efa
    fabric: EFA-fe80::e5:56ff:fe34:56a8
    domain: efa_0-rdm
    version: 2.0
    type: FI_EP_RDM
    protocol: FI_PROTO_EFA
provider: efa
    fabric: EFA-fe80::e5:56ff:fe34:56a8
    domain: efa_0-dgrm
    version: 2.0
    type: FI_EP_DGRAM
    protocol: FI_PROTO_EFA
provider: efa;ofi_rxd
    fabric: EFA-fe80::e5:56ff:fe34:56a8
    domain: efa_0-dgrm
    version: 1.0
    type: FI_EP_RDM
    protocol: FI_PROTO_RXD
```

## Exécution d’une tâche d’entraînement avec EFA
<a name="your-algorithms-training-efa-run"></a>

 Une fois que vous avez créé un conteneur compatible EFA, vous pouvez exécuter une tâche de formation avec EFA à l'aide d'un estimateur SageMaker AI de la même manière que vous le feriez avec n'importe quelle autre image Docker. Pour plus d’informations sur l’enregistrement de votre conteneur et son utilisation pour l’entraînement, consultez [Adaptation de votre propre conteneur d’entraînement](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step5).

# Comment Amazon SageMaker AI signale le succès et l'échec d'un algorithme
<a name="your-algorithms-training-signal-success-failure"></a>

Un algorithme d’entraînement indique s’il a réussi ou échoué à l’aide du code de sortie de son processus. 

L’exécution de la réussite d’un entraînement réussi doit se terminer avec un code de sortie 0. L’exécution de l’échec d’un entraînement doit se terminer avec un code de sortie différent de zéro. Ces valeurs seront converties en `Completed` et `Failed` dans le `TrainingJobStatus` renvoyé par `DescribeTrainingJob`. Les conventions liées à ce code de sortie sont standard et facilement mises en œuvre dans toutes les langues. Par exemple, dans Python, vous pouvez utiliser `sys.exit(1)` pour signaler une sortie d’échec, l’exécution jusqu’à la fin de la routine principale causera une sortie de Python avec un code 0.

En cas d’échec, l’algorithme peut écrire une description de l’échec dans le fichier des défaillances. Pour plus de détails, consultez la section suivante.

# Comment Amazon SageMaker AI traite les résultats de formation
<a name="your-algorithms-training-algo-output"></a>

À mesure que votre algorithme s’exécute dans un conteneur, il génère une sortie incluant le statut de la tâche et du modèle d’entraînement, ainsi que des artefacts de sortie. Votre algorithme doit écrire ces informations dans les fichiers suivants, placés dans le répertoire `/output` du conteneur. Amazon SageMaker AI traite les informations contenues dans ce répertoire comme suit :
+ `/opt/ml/model`— Votre algorithme doit écrire tous les artefacts du modèle final dans ce répertoire. SageMaker AI copie ces données sous forme d'objet unique au format tar compressé vers l'emplacement S3 que vous avez spécifié dans la `CreateTrainingJob` demande. Si plusieurs conteneurs dans le cadre d'une même tâche de formation écrivent dans ce répertoire, ils doivent s'assurer qu'aucun `file/directory` nom n'est en conflit. SageMaker L'IA agrège le résultat dans un fichier TAR et le télécharge sur S3 à la fin de la tâche de formation. 
+ `/opt/ml/output/data`— Votre algorithme doit écrire les artefacts que vous souhaitez stocker autres que le modèle final dans ce répertoire. SageMaker AI copie ces données sous forme d'objet unique au format tar compressé vers l'emplacement S3 que vous avez spécifié dans la `CreateTrainingJob` demande. Si plusieurs conteneurs dans le cadre d'une même tâche de formation écrivent dans ce répertoire, ils doivent s'assurer qu'aucun `file/directory` nom n'est en conflit. SageMaker L'IA agrège le résultat dans un fichier TAR et le télécharge sur S3 à la fin de la tâche de formation.
+ `/opt/ml/output/failure` : si l’entraînement échoue, une fois que toutes les sorties de l’algorithme (par exemple, la journalisation) sont terminées, votre algorithme doit écrire la description de la défaillance dans ce fichier. Dans une `DescribeTrainingJob` réponse, SageMaker AI renvoie les 1024 premiers caractères de ce fichier sous la forme`FailureReason`. 

Vous pouvez spécifier un compartiment S3 à usage général ou un compartiment de répertoire S3 pour stocker votre sortie d’entraînement. Les compartiments de répertoire utilisent uniquement la classe de stockage Amazon S3 Express One Zone, conçue pour les charges de travail ou les applications critiques en termes de performances qui nécessitent une latence constante inférieure à dix millisecondes. Choisissez le type de compartiment qui correspond le mieux à votre application et à vos exigences de performances. Pour plus d’informations sur les compartiments de répertoire S3, consultez [Compartiments de répertoire](https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html) dans le *Guide de l’utilisateur Amazon Simple Storage Service*. 

**Note**  
Vous pouvez uniquement chiffrer vos données de sortie d' SageMaker IA dans des compartiments de répertoire S3 avec un chiffrement côté serveur avec des clés gérées par Amazon S3 (SSE-S3). Le chiffrement côté serveur à l'aide de AWS KMS clés (SSE-KMS) n'est actuellement pas pris en charge pour le stockage des données de sortie de l' SageMaker IA dans des compartiments d'annuaire.