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.
# Adaptation de votre propre conteneur d’entraînement
Pour exécuter votre propre modèle de formation, créez un conteneur Docker à l'aide de l'[Amazon SageMaker Training Toolkit](https://github.com/aws/sagemaker-training-toolkit) via une instance de SageMaker bloc-notes Amazon.
## Étape 1 : créer une instance de SageMaker bloc-notes
1. Ouvrez la console Amazon SageMaker AI à l'adresse [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/).
1. Dans le panneau de navigation gauche, choisissez **Notebook (Bloc-notes)**, choisissez **Notebook instances (Instances de bloc-notes)**, puis choisissez **Create notebook instance (Créer une instance de bloc-notes)**.
1. Sur la page Créer une instance de bloc-notes, fournissez les informations suivantes :****
1. Pour **Nom de l’instance de bloc-notes**, entrez **RunScriptNotebookInstance**.
1. Pour **Type d’instance de bloc-notes**, choisissez **ml.t2.medium**.
1. Dans la section **Permissions and encryption (Autorisations et chiffrement)** procédez de la façon suivante :
1. Pour Rôle IAM, choisissez Créer un rôle.******** Une nouvelle fenêtre s’ouvre.
1. Sur la page **Create an IAM role (Créer un rôle IAM)**, choisissez **Specific S3 buckets (Compartiments S3 spécifiques)**, spécifiez un compartiment Amazon S3 appelé **sagemaker-run-script**, puis choisissez **Create role (Créer un rôle)**.
SageMaker L'IA crée un rôle IAM nommé`AmazonSageMaker-ExecutionRole-YYYYMMDDTHHmmSS`. Par exemple, `AmazonSageMaker-ExecutionRole-20190429T110788`. Notez que la convention de dénomination des rôles d’exécution utilise la date et l’heure de création du rôle, séparées par un `T`.
1. Sous **Root Access (Accès racine)**, choisissez **Enable (Activer)**.
1. Choisissez **Create notebook instance (Créer une instance de bloc-notes)**.
1. Sur la page **Notebook instances (Instances de bloc-notes)** le **Status (Statut)** est **Pending (En attente)**. Amazon SageMaker AI peut mettre quelques minutes à lancer une instance de calcul d'apprentissage automatique (dans ce cas, il lance une instance de bloc-notes) et à y associer un volume de stockage ML. L’instance de bloc-notes possède un serveur de blocs-notes Jupyter préconfiguré et un ensemble de bibliothèques Anaconda. Pour plus d'informations, voir [ CreateNotebookInstance](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateNotebookInstance.html).
1. Cliquez sur le **nom** du bloc-notes que vous venez de créer. Une nouvelle page s’ouvre.
1. Dans la section **Autorisations et chiffrement**, copiez **le numéro d’ARN du rôle IAM**, et collez-le dans un fichier bloc-notes pour l’enregistrer temporairement. Vous utiliserez ce numéro d’ARN de rôle IAM ultérieurement pour configurer un estimateur d’entraînement local dans l’instance de bloc-notes. **Le numéro d’ARN du rôle IAM** ressemble à ceci : `'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'`
1. Une fois que le statut de l'instance du bloc-notes est **InService**passé à, choisissez **Ouvrir JupyterLab**.
## Étape 2 : créer et télécharger le fichier Dockerfile et les scripts d’entraînement Python
1. Après JupyterLab ouverture, créez un nouveau dossier dans le répertoire personnel de votre JupyterLab. Dans le coin supérieur gauche, choisissez l’icône **Nouveau dossier**, puis saisissez le nom du dossier `docker_test_folder`.
1. Dans le répertoire `docker_test_folder`, créez un fichier texte `Dockerfile`.
1. Choisissez l’icône **Nouveau lanceur** (\$1) dans le coin supérieur gauche.
1. Dans le panneau de droite, dans la section **Other (Autre)**, choisissez **Text File (Fichier texte)**.
1. Collez l’exemple de code `Dockerfile` suivant dans votre fichier texte.
```
#Download an open source TensorFlow Docker image
FROM tensorflow/tensorflow:latest-gpu-jupyter
# Install sagemaker-training toolkit that contains the common functionality necessary to create a container compatible with SageMaker AI and the Python SDK.
RUN pip3 install sagemaker-training
# Copies the training code inside the container
COPY train.py /opt/ml/code/train.py
# Defines train.py as script entrypoint
ENV SAGEMAKER_PROGRAM train.py
```
Le script Dockerfile effectue les tâches suivantes :
+ `FROM tensorflow/tensorflow:latest-gpu-jupyter`— Télécharge la dernière image de base de TensorFlow Docker. Vous pouvez la remplacer par n'importe quelle image de base Docker que vous souhaitez utiliser pour créer des conteneurs, ainsi que par des images de base de AWS conteneurs prédéfinies.
+ `RUN pip install sagemaker-training`— Installe le [kit de formation SageMaker AI](https://github.com/aws/sagemaker-training-toolkit) qui contient les fonctionnalités communes nécessaires pour créer un conteneur compatible avec l' SageMaker IA.
+ `COPY train.py /opt/ml/code/train.py`— Copie le script à l'emplacement prévu par l' SageMaker IA à l'intérieur du conteneur. Le script doit être situé dans ce dossier.
+ `ENV SAGEMAKER_PROGRAM train.py` : prend votre script d’entraînement `train.py` comme le script de point d’entrée copié dans le dossier `/opt/ml/code` du conteneur. Il s’agit de la seule variable d’environnement que vous devez spécifier lorsque vous créez votre propre conteneur.
1. Dans le panneau de navigation du répertoire gauche, le nom du fichier texte peut être automatiquement défini sur `untitled.txt`. Pour renommer le fichier, faites un clic droit sur le fichier, choisissez **Renommer**, renommez le fichier en tant que `Dockerfile` sans l’extension `.txt`, puis appuyez sur `Ctrl+s` ou `Command+s` pour enregistrer le fichier.
1. Chargez un script d’entraînement `train.py` dans `docker_test_folder`. Vous pouvez utiliser l’exemple de script suivant pour créer un modèle qui lit les chiffres manuscrits entraînés sur le [jeu de données MNIST](https://en.wikipedia.org/wiki/MNIST_database) pour cet exercice.
```
import tensorflow as tf
import os
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
model = tf.keras.models.Sequential([
tf.keras.layers.Flatten(input_shape=(28, 28)),
tf.keras.layers.Dense(128, activation='relu'),
tf.keras.layers.Dropout(0.2),
tf.keras.layers.Dense(10, activation='softmax')
])
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(x_train, y_train, epochs=1)
model_save_dir = f"{os.environ.get('SM_MODEL_DIR')}/1"
model.evaluate(x_test, y_test)
tf.saved_model.save(model, model_save_dir)
```
## Étape 3 : créer le conteneur
1. Dans le JupyterLab répertoire de base, ouvrez un bloc-notes Jupyter. Pour ouvrir un nouveau bloc-notes, choisissez l’icône **Nouveau lancement**, puis choisissez la version la plus récente de **conda\$1tensorflow2** dans la section **Bloc-notes**.
1. Exécutez la commande suivante dans la première cellule de bloc-notes pour changer au répertoire `docker_test_folder` :
```
cd ~/SageMaker/docker_test_folder
```
Cela renvoie votre répertoire actuel de la façon suivante :
```
! pwd
```
`output: /home/ec2-user/SageMaker/docker_test_folder`
1. Pour créer le conteneur Docker, exécutez la commande de création Docker suivante, en incluant l’espace suivie d’un point final :
```
! docker build -t tf-custom-container-test .
```
La commande de création Docker doit être exécutée à partir du répertoire Docker que vous avez créé (en l’occurrence `docker_test_folder`).
**Note**
Si vous obtenez le message d’erreur suivant indiquant que Docker ne peut pas trouver le Dockerfile, assurez-vous que le Dockerfile a été nommé correctement et qu’il est enregistré dans le répertoire.
```
unable to prepare context: unable to evaluate symlinks in Dockerfile path:
lstat /home/ec2-user/SageMaker/docker/Dockerfile: no such file or directory
```
N’oubliez pas que `docker` recherche un fichier appelé spécifiquement `Dockerfile`, sans extension, dans le répertoire actuel. Si vous avez nommé le fichier différemment, vous pouvez transmettre le nom de fichier manuellement avec l’indicateur `-f`. Par exemple, si vous avez nommé votre Dockerfile `Dockerfile-text.txt`, exécutez la commande suivante :
```
! docker build -t tf-custom-container-test -f Dockerfile-text.txt .
```
## Étape 4 : tester le conteneur
1. Pour tester le conteneur localement dans l’instance de bloc-notes, ouvrez un bloc-notes Jupyter. Choisissez **Nouveau lanceur**, puis choisissez la version la plus récente de **conda\$1tensorflow2** dans la section **Bloc-notes**.
1. Collez l'exemple de script suivant dans la cellule de code du bloc-notes pour configurer un estimateur SageMaker AI.
```
import sagemaker
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri='tf-custom-container-test',
role=sagemaker.get_execution_role(),
instance_count=1,
instance_type='local')
estimator.fit()
```
Dans l'exemple de code précédent, l'`role`argument `sagemaker.get_execution_role()` est spécifié pour récupérer automatiquement le rôle configuré pour la session SageMaker AI. Vous pouvez également le remplacer par la valeur de chaîne du **numéro d’ARN du rôle IAM** que vous avez utilisé lors de la configuration de l’instance de bloc-notes. L’ARN doit ressembler à l’exemple suivant : `'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'`.
1. Exécutez la cellule de code. Ce test génère la configuration de l’environnement d’entraînement, les valeurs utilisées pour les variables d’environnement, la source des données, ainsi que la perte et la précision obtenues au cours de l’entraînement.
## Étape 5 : pousser le conteneur vers Amazon Elastic Container Registry (Amazon ECR)
1. Après avoir exécuté avec succès ce test en mode local, vous pouvez pousser le conteneur Docker vers [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) et l’utiliser pour exécuter des tâches d’entraînement. Si vous souhaitez utiliser un registre Docker privé au lieu d’Amazon ECR, consultez [Transfert de votre conteneur d’entraînement vers un registre privé](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry.html).
Vous pouvez exécuter les lignes de commande suivantes dans une cellule de bloc-notes.
```
%%sh
# Specify an algorithm name
algorithm_name=tf-custom-container-test
account=$(aws sts get-caller-identity --query Account --output text)
# Get the region defined in the current configuration (default to us-west-2 if none defined)
region=$(aws configure get region)
region=${region:-us-west-2}
fullname="${account}.dkr.ecr.${region}.amazonaws.com/${algorithm_name}:latest"
# If the repository doesn't exist in ECR, create it.
aws ecr describe-repositories --repository-names "${algorithm_name}" > /dev/null 2>&1
if [ $? -ne 0 ]
then
aws ecr create-repository --repository-name "${algorithm_name}" > /dev/null
fi
# Get the login command from ECR and execute it directly
aws ecr get-login-password --region ${region}|docker login --username AWS --password-stdin ${fullname}
# Build the docker image locally with the image name and then push it to ECR
# with the full name.
docker build -t ${algorithm_name} .
docker tag ${algorithm_name} ${fullname}
docker push ${fullname}
```
**Note**
Ce script shell bash peut soulever un problème d’autorisation semblable au message d’erreur suivant :
```
"denied: User: [ARN] is not authorized to perform: ecr:InitiateLayerUpload on resource:
arn:aws:ecr:us-east-1:[id]:repository/tf-custom-container-test"
```
Si cette erreur se produit, vous devez associer la EC2 ContainerRegistryFullAccess politique **Amazon** à votre rôle IAM. Accédez à la [console IAM](https://console.aws.amazon.com/iam/home), choisissez **Rôles dans** le volet de navigation de gauche, recherchez le nom IAMrole que vous avez utilisé pour l'instance Notebook. Dans l'onglet **Autorisation**, cliquez sur le bouton **Joindre des politiques** et recherchez la EC2 ContainerRegistryFullAccess politique **Amazon**. Cochez la case correspondant à la politique et choisissez **Ajouter des autorisations** pour finir.
1. Exécutez le code suivant dans une cellule de bloc-notes Studio pour appeler l’image Amazon ECR de votre conteneur d’entraînement.
```
import boto3
account_id = boto3.client('sts').get_caller_identity().get('Account')
ecr_repository = 'tf-custom-container-test'
tag = ':latest'
region = boto3.session.Session().region_name
uri_suffix = 'amazonaws.com'
if region in ['cn-north-1', 'cn-northwest-1']:
uri_suffix = 'amazonaws.com.cn'
byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(account_id, region, uri_suffix, ecr_repository + tag)
byoc_image_uri
# This should return something like
# 111122223333.dkr.ecr.us-east-2.amazonaws.com/sagemaker-byoc-test:latest
```
1. Utilisez le résultat `ecr_image` obtenu à l'étape précédente pour configurer un objet estimateur SageMaker AI. L'exemple de code suivant configure un estimateur d' SageMaker IA avec `byoc_image_uri` et lance une tâche de formation sur une instance Amazon EC2.
------
#### [ SageMaker Python SDK v1 ]
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri=byoc_image_uri,
role=get_execution_role(),
base_job_name='tf-custom-container-test-job',
instance_count=1,
instance_type='ml.g4dn.xlarge')
#train your model
estimator.fit()
```
------
#### [ SageMaker Python SDK v2 ]
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator = Estimator(image_uri=byoc_image_uri,
role=get_execution_role(),
base_job_name='tf-custom-container-test-job',
instance_count=1,
instance_type='ml.g4dn.xlarge')
#train your model
estimator.fit()
```
------
1. Si vous souhaitez déployer votre modèle à l’aide de votre propre conteneur, reportez-vous à [Adaptation de votre propre conteneur d’inférence](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-inference-container.html). Vous pouvez également utiliser un conteneur de AWS structure capable de déployer un TensorFlow modèle. Pour déployer le modèle d'exemple afin de lire des chiffres manuscrits, entrez l'exemple de script suivant dans le même bloc-notes que celui que vous avez utilisé pour entraîner votre modèle à la sous-étape précédente afin d'obtenir l'image URIs (identifiants de ressource universels) nécessaire au déploiement, puis déployez le modèle.
```
import boto3
import sagemaker
#obtain image uris
from sagemaker import image_uris
container = image_uris.retrieve(framework='tensorflow',region='us-west-2',version='2.11.0',
image_scope='inference',instance_type='ml.g4dn.xlarge')
#create the model entity, endpoint configuration and endpoint
predictor = estimator.deploy(1,instance_type='ml.g4dn.xlarge',image_uri=container)
```
Testez votre modèle à l’aide d’un exemple de chiffre manuscrit issu du jeu de données MNIST à l’aide de l’exemple de code suivant.
```
#Retrieve an example test dataset to test
import numpy as np
import matplotlib.pyplot as plt
from keras.datasets import mnist
# Load the MNIST dataset and split it into training and testing sets
(x_train, y_train), (x_test, y_test) = mnist.load_data()
# Select a random example from the training set
example_index = np.random.randint(0, x_train.shape[0])
example_image = x_train[example_index]
example_label = y_train[example_index]
# Print the label and show the image
print(f"Label: {example_label}")
plt.imshow(example_image, cmap='gray')
plt.show()
```
Convertissez le chiffre manuscrit du test en une forme qui TensorFlow peut être ingérée et faire une prédiction de test.
```
from sagemaker.serializers import JSONSerializer
data = {"instances": example_image.tolist()}
predictor.serializer=JSONSerializer() #update the predictor to use the JSONSerializer
predictor.predict(data) #make the prediction
```
Pour un exemple complet montrant comment tester un conteneur personnalisé localement et le transférer vers une image Amazon ECR, consultez le carnet d'exemples [Building Your Own TensorFlow Container](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/tensorflow_bring_your_own/tensorflow_bring_your_own.html).
**Astuce**
Pour profiler et déboguer les tâches de formation afin de surveiller les problèmes d'utilisation du système (tels que les goulots d'étranglement du processeur et la sous-utilisation du GPU) et d'identifier les problèmes d'entraînement (tels que le surajustement, le surentraînement, l'explosion des tenseurs et la disparition des dégradés), utilisez Amazon Debugger. SageMaker Pour de plus amples informations, veuillez consulter [Utilisation de Debugger avec des conteneurs d’entraînement personnalisés](debugger-bring-your-own-container.md).
## Étape 6 : nettoyer les ressources
**Pour nettoyer les ressources lorsque vous avez terminé avec l’exemple de démarrage**
1. Ouvrez la [console SageMaker AI](https://console.aws.amazon.com/sagemaker/), choisissez l'instance du bloc-notes **RunScriptNotebookInstance**, sélectionnez **Actions**, puis **Stop**. L’arrêt de l’instance peut prendre quelques minutes.
1. Une fois que le **Statut** de l’instance affiche **Arrêtée**, sélectionnez **Actions**, puis **Supprimer**, et enfin **Supprimer** dans la boîte de dialogue. La suppression de l’instance peut prendre quelques minutes. Une fois supprimée, l’instance de bloc-notes disparaît du tableau.
1. Ouvrez la [Console Amazon S3](https://console.aws.amazon.com/s3/) et supprimez le compartiment que vous avez créé pour stocker les artefacts de modèle et le jeu de données d’entraînement.
1. Ouvrez la [Console IAM](https://console.aws.amazon.com/iam/) et supprimez le rôle IAM. Si vous avez créé des politiques d’autorisation, vous pouvez également les supprimer.
**Note**
Le conteneur Docker s’arrête automatiquement après s’être exécuté. Vous n’avez pas besoin de le supprimer.
## Blogs et études de cas
Les blogs suivants présentent des études de cas sur l'utilisation de conteneurs de formation personnalisés dans Amazon SageMaker AI.
+ [Pourquoi apporter votre propre conteneur à Amazon SageMaker AI et comment le faire correctement](https://medium.com/@pandey.vikesh/why-bring-your-own-container-to-amazon-sagemaker-and-how-to-do-it-right-bc158fe41ed1), *Medium* (20 janvier 2023)