Étape 1 : créer une instance de bloc-notes Étape 2 : créer et télécharger des scripts d'entraînement Étape 3 : créer le conteneur Étape 4 : tester le conteneur Étape 5 : pousser le conteneur vers Amazon ECR Étape 6 : nettoyer les ressources Blogs et études de cas

Adaptation de votre propre conteneur d'entraînement

Pour exécuter votre propre modèle d'entraînement, créez un conteneur Docker à l'aide de la Boîte à outils d'entraînement Amazon SageMaker via une instance de bloc-notes Amazon SageMaker.

Étape 1 : créer une instance de bloc-notes SageMaker

Ouvrez la console Amazon SageMaker à l'adresse https://console.aws.amazon.com/sagemaker/.https://console.aws.amazon.com/sagemaker/
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).
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
2. Pour Type d'instance de bloc-notes, choisissez .ml.t2.medium
3. 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.
  2. 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 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.
4. Sous Root Access (Accès racine), choisissez Enable (Activer).
5. Choisissez Create notebook instance (Créer une instance de bloc-notes).
Sur la page Notebook instances (Instances de bloc-notes) le Status (Statut) est Pending (En attente). Amazon SageMaker peut prendre quelques minutes pour lancer une instance de calcul machine learning (dans ce cas, elle lance une instance de bloc-notes) et lui attache 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 de plus amples informations, veuillez consulter CreateNotebookInstance (Créer une instance de bloc-notes).
Cliquez sur le nom du bloc-notes que vous venez de créer. Une nouvelle page s'ouvre.
Dans la section Permissions and encryption (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'
Une fois que le statut de l'instance de bloc-notes passe à InService (En service), choisissez Open JupyterLab (Ouvrir JupyterLab).

Étape 2 : créer et télécharger le fichier Dockerfile et les scripts d'entraînement Python

Une fois JupyterLab ouvert, créez un nouveau dossier dans le répertoire d'accueil de votre JupyterLab. Dans le coin supérieur gauche, choisissez l'icône New Folder (Nouveau dossier), puis saisissez le nom du dossier docker_test_folder.
Dans le répertoire docker_test_folder, créez un fichier texte Dockerfile.
1. Choisissez l'icône New Launcher (Nouveau lanceur) (+) dans le coin supérieur gauche.
2. Dans le panneau de droite, dans la section Other (Autre), choisissez Text File (Fichier texte).
3. 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 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 l'image de base Docker TensorFlow la plus récente. Vous pouvez la remplacer par n'importe quelle image Docker de base que vous voulez importer pour créer des conteneurs, ou des images de base de conteneur préconçues AWS.
  - RUN pip install sagemaker-training – Installe la boîte à outils d'entraînement SageMaker qui contient les fonctionnalités courantes nécessaires pour créer un conteneur compatible avec SageMaker.
  - COPY train.py /opt/ml/code/train.py – Copie le script dans le conteneur, à l'emplacement prévu par SageMaker. 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.
4. 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 Rename (Renommer), renommez le fichier en tant que Dockerfile sans l'extension .txt, puis appuyez sur Ctrl+s ou Command+s pour enregistrer le fichier.

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 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

Dans le répertoire d'accueil JupyterLab, 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_tensorflow2 dans la section Bloc-notes.
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
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

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_tensorflow2 dans la section Bloc-notes.
Copiez et collez l'exemple de script suivant dans la cellule de code du bloc-notes pour configurer un évaluateur SageMaker.
```
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, sagemaker.get_execution_role() est spécifié pour l'argument role afin de récupérer automatiquement le rôle défini pour la session SageMaker. 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'
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)

Après avoir exécuté avec succès ce test en mode local, vous pouvez pousser le conteneur Docker vers Amazon ECR 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 Push your training container to a private registry (Transfert de votre conteneur d'entraînement vers un registre privé).

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 attacher la politique AmazonEC2ContainerRegistryFullAccess à votre rôle IAM. Accédez à la console IAM, choisissez Roles (Rôles) dans le panneau de navigation de gauche et recherchez le rôle IAM que vous avez utilisé pour l'instance de bloc-notes. Sous l'onglet Permission (Autorisation), choisissez le bouton Attach policies (Attacher des politiques), et recherchez la politique AmazonEC2ContainerRegistryFullAccess. Cochez la case correspondant à la politique et choisissez Ajouter des autorisations pour finir.

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

Utilisez l'ecr_image récupérée à l'étape précédente pour configurer un objet d'estimateur SageMaker. L'exemple de code suivant configure un estimateur SageMaker avec l'byoc_image_uri et initie une tâche d'entraînement sur une instance Amazon EC2.

Si vous souhaitez déployer votre modèle à l'aide de votre propre conteneur, reportez-vous à Adaptation de votre propre conteneur d'inférence. Vous pouvez également utiliser un conteneur de framework AWS capable de déployer un modèle TensorFlow. Pour déployer cet exemple de modèle 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 dans la sous-étape précédente afin d'obtenir les URI (Uniform Resource Identifier) d'images nécessaires 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 de test dans une forme que TensorFlow peut ingérer et effectuez 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 obtenir un exemple complet montrant comment tester localement un conteneur personnalisé et le pousser vers une image Amazon ECR, veuillez consulter l'exemple de bloc-notes Building Your Own TensorFlow Container (Création de votre propre conteneur TensorFlow).

Astuce

Pour profiler et déboguer les tâches d'entraînement afin de contrôler les problèmes d'utilisation du système (tels que les goulets d'étranglement du processeur et la sous-utilisation du GPU) et identifier les problèmes d'entraînement (tels que le surajustement, le surentraînement, les tenseurs qui explosent et les gradients qui disparaissent), utilisez Amazon SageMaker Debugger. Pour de plus amples informations, veuillez consulter Utiliser Debugger avec des conteneurs d'entraînement personnalisés.

Étape 6 : nettoyer les ressources

Pour nettoyer les ressources lorsque vous avez terminé avec l'exemple de cette rubrique

Ouvrez la console SageMaker, choisissez l'instance de bloc-notes RunScriptNotebookInstance, choisissez Actions, puis choisissez Stop (Arrêt). L'arrêt de l'instance peut prendre quelques minutes.
Une fois que le Status (Statut) de l'instance affiche Stopped (Arrêtée), sélectionnez Actions, puis Delete (Supprimer), et enfin Delete (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.
Ouvrez la Console Amazon 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.
Ouvrez la Console 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 traitent d'études de cas sur l'utilisation de conteneurs d'entraînement personnalisés dans Amazon SageMaker.

Why bring your own container to Amazon SageMaker and how to do it right, Medium (20 janvier 2023)

Avertissement JavaScript est désactivé ou n'est pas disponible dans votre navigateur.

Pour que vous puissiez utiliser la documentation AWS, Javascript doit être activé. Vous trouverez des instructions sur les pages d'aide de votre navigateur.

Conventions de rédaction

Boîtes à outils d'entraînement et d'inférence SageMaker

Adaptation de votre tâche d'entraînement pour accéder aux images dans un registre Docker privé