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.
# Extension d’un conteneur préconçu
Si un conteneur d' SageMaker IA prédéfini ne répond pas à toutes vos exigences, vous pouvez étendre l'image existante pour répondre à vos besoins. Même s’il existe une prise en charge directe de votre environnement ou de votre cadre, vous pouvez ajouter des fonctionnalités supplémentaires ou configurer votre environnement de conteneur différemment. En étendant une image préconçue, vous pouvez tirer parti des bibliothèques et des paramètres de deep learning inclus sans devoir créer une image à partir de zéro. Vous pouvez étendre le conteneur pour ajouter des bibliothèques, modifier des paramètres et installer des dépendances supplémentaires.
Le didacticiel suivant explique comment étendre une SageMaker image prédéfinie et la publier sur Amazon ECR.
**Topics**
+ [Exigences relatives à l’extension d’un conteneur préconçu](#prebuilt-containers-extend-required)
+ [Étendre les conteneurs SageMaker AI pour exécuter un script Python](#prebuilt-containers-extend-tutorial)
## Exigences relatives à l’extension d’un conteneur préconçu
Pour étendre une SageMaker image prédéfinie, vous devez définir les variables d'environnement suivantes dans votre Dockerfile. Pour plus d'informations sur les variables d'environnement associées aux conteneurs SageMaker AI, consultez le [ GitHub référentiel SageMaker Training Toolkit](https://github.com/aws/sagemaker-training-toolkit/blob/master/ENVIRONMENT_VARIABLES.md).
+ `SAGEMAKER_SUBMIT_DIRECTORY` : répertoire qui, dans le conteneur, contient le script Python pour l’entraînement.
+ `SAGEMAKER_PROGRAM` : script Python qui doit être appelé et utilisé comme point d’entrée pour l’entraînement.
Vous pouvez également installer des bibliothèques supplémentaires en incluant les éléments suivants dans votre Dockerfile :
```
RUN pip install
```
Le didacticiel suivant explique comment utiliser ces variables d’environnement.
## Étendre les conteneurs SageMaker AI pour exécuter un script Python
Dans ce didacticiel, vous apprendrez à étendre le PyTorch conteneur SageMaker AI avec un fichier Python qui utilise le jeu de données CIFAR-10. En étendant le PyTorch conteneur SageMaker AI, vous utilisez la solution de formation existante conçue pour fonctionner avec l' SageMaker IA. Ce didacticiel étend une image d’entraînement, mais la procédure est identique pour étendre une image d’inférence. Pour obtenir la liste complète des images disponibles, consultez [Images Deep Learning Containers disponibles](https://github.com/aws/deep-learning-containers/blob/master/available_images.md).
Pour exécuter votre propre modèle de formation à l'aide des conteneurs SageMaker AI, créez un conteneur Docker via une instance SageMaker Notebook.
### Étape 1 : créer une instance de SageMaker bloc-notes
1. Ouvrez la [console SageMaker AI](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.********
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`, tel que`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. 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.
```
# SageMaker PyTorch image
FROM 763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-training:1.5.1-cpu-py36-ubuntu16.04
ENV PATH="/opt/ml/code:${PATH}"
# this environment variable is used by the SageMaker PyTorch container to determine our user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code
# /opt/ml and all subdirectories are utilized by SageMaker, use the /code subdirectory to store your user code.
COPY cifar10.py /opt/ml/code/cifar10.py
# Defines cifar10.py as script entrypoint
ENV SAGEMAKER_PROGRAM cifar10.py
```
Le script Dockerfile effectue les tâches suivantes :
+ `FROM 763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-training:1.5.1-cpu-py36-ubuntu16.04`— Télécharge l'image de PyTorch base de l' SageMaker IA. Vous pouvez la remplacer par n'importe quelle image de base d' SageMaker IA que vous souhaitez utiliser pour créer des conteneurs.
+ `ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code` : définit `/opt/ml/code` comme répertoire de script d’entraînement.
+ `COPY cifar10.py /opt/ml/code/cifar10.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 cifar10.py` : définit votre script d’entraînement `cifar10.py` comme script de point d’entrée.
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. Création ou téléchargement d’un script d’entraînement `cifar10.py` dans le `docker_test_folder`. Vous pouvez utiliser l’exemple de script suivant pour cet exercice.
```
import ast
import argparse
import logging
import os
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.nn.parallel
import torch.optim
import torch.utils.data
import torch.utils.data.distributed
import torchvision
import torchvision.models
import torchvision.transforms as transforms
import torch.nn.functional as F
logger=logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
classes=('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')
# https://github.com/pytorch/tutorials/blob/master/beginner_source/blitz/cifar10_tutorial.py#L118
class Net(nn.Module):
def __init__(self):
super(Net, self).__init__()
self.conv1=nn.Conv2d(3, 6, 5)
self.pool=nn.MaxPool2d(2, 2)
self.conv2=nn.Conv2d(6, 16, 5)
self.fc1=nn.Linear(16 * 5 * 5, 120)
self.fc2=nn.Linear(120, 84)
self.fc3=nn.Linear(84, 10)
def forward(self, x):
x=self.pool(F.relu(self.conv1(x)))
x=self.pool(F.relu(self.conv2(x)))
x=x.view(-1, 16 * 5 * 5)
x=F.relu(self.fc1(x))
x=F.relu(self.fc2(x))
x=self.fc3(x)
return x
def _train(args):
is_distributed=len(args.hosts) > 1 and args.dist_backend is not None
logger.debug("Distributed training - {}".format(is_distributed))
if is_distributed:
# Initialize the distributed environment.
world_size=len(args.hosts)
os.environ['WORLD_SIZE']=str(world_size)
host_rank=args.hosts.index(args.current_host)
dist.init_process_group(backend=args.dist_backend, rank=host_rank, world_size=world_size)
logger.info(
'Initialized the distributed environment: \'{}\' backend on {} nodes. '.format(
args.dist_backend,
dist.get_world_size()) + 'Current host rank is {}. Using cuda: {}. Number of gpus: {}'.format(
dist.get_rank(), torch.cuda.is_available(), args.num_gpus))
device='cuda' if torch.cuda.is_available() else 'cpu'
logger.info("Device Type: {}".format(device))
logger.info("Loading Cifar10 dataset")
transform=transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
trainset=torchvision.datasets.CIFAR10(root=args.data_dir, train=True,
download=False, transform=transform)
train_loader=torch.utils.data.DataLoader(trainset, batch_size=args.batch_size,
shuffle=True, num_workers=args.workers)
testset=torchvision.datasets.CIFAR10(root=args.data_dir, train=False,
download=False, transform=transform)
test_loader=torch.utils.data.DataLoader(testset, batch_size=args.batch_size,
shuffle=False, num_workers=args.workers)
logger.info("Model loaded")
model=Net()
if torch.cuda.device_count() > 1:
logger.info("Gpu count: {}".format(torch.cuda.device_count()))
model=nn.DataParallel(model)
model=model.to(device)
criterion=nn.CrossEntropyLoss().to(device)
optimizer=torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum)
for epoch in range(0, args.epochs):
running_loss=0.0
for i, data in enumerate(train_loader):
# get the inputs
inputs, labels=data
inputs, labels=inputs.to(device), labels.to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs=model(inputs)
loss=criterion(outputs, labels)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
if i % 2000 == 1999: # print every 2000 mini-batches
print('[%d, %5d] loss: %.3f' %
(epoch + 1, i + 1, running_loss / 2000))
running_loss=0.0
print('Finished Training')
return _save_model(model, args.model_dir)
def _save_model(model, model_dir):
logger.info("Saving the model.")
path=os.path.join(model_dir, 'model.pth')
# recommended way from http://pytorch.org/docs/master/notes/serialization.html
torch.save(model.cpu().state_dict(), path)
def model_fn(model_dir):
logger.info('model_fn')
device="cuda" if torch.cuda.is_available() else "cpu"
model=Net()
if torch.cuda.device_count() > 1:
logger.info("Gpu count: {}".format(torch.cuda.device_count()))
model=nn.DataParallel(model)
with open(os.path.join(model_dir, 'model.pth'), 'rb') as f:
model.load_state_dict(torch.load(f))
return model.to(device)
if __name__ == '__main__':
parser=argparse.ArgumentParser()
parser.add_argument('--workers', type=int, default=2, metavar='W',
help='number of data loading workers (default: 2)')
parser.add_argument('--epochs', type=int, default=2, metavar='E',
help='number of total epochs to run (default: 2)')
parser.add_argument('--batch-size', type=int, default=4, metavar='BS',
help='batch size (default: 4)')
parser.add_argument('--lr', type=float, default=0.001, metavar='LR',
help='initial learning rate (default: 0.001)')
parser.add_argument('--momentum', type=float, default=0.9, metavar='M', help='momentum (default: 0.9)')
parser.add_argument('--dist-backend', type=str, default='gloo', help='distributed backend (default: gloo)')
# The parameters below retrieve their default values from SageMaker environment variables, which are
# instantiated by the SageMaker containers framework.
# https://github.com/aws/sagemaker-containers#how-a-script-is-executed-inside-the-container
parser.add_argument('--hosts', type=str, default=ast.literal_eval(os.environ['SM_HOSTS']))
parser.add_argument('--current-host', type=str, default=os.environ['SM_CURRENT_HOST'])
parser.add_argument('--model-dir', type=str, default=os.environ['SM_MODEL_DIR'])
parser.add_argument('--data-dir', type=str, default=os.environ['SM_CHANNEL_TRAINING'])
parser.add_argument('--num-gpus', type=int, default=os.environ['SM_NUM_GPUS'])
_train(parser.parse_args())
```
### É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’cône **Nouveau lancement**, puis choisissez **conda\$1pytorch\$1p39** 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. Connectez-vous à Docker pour accéder au conteneur de base :
```
! aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 763104351884.dkr.ecr.us-east-1.amazonaws.com
```
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 pytorch-extended-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. Sélectionnez **New Launcher** (Nouveau lanceur), puis **Notebooks** (Bloc-notes) dans le framework **`conda_pytorch_p39`**. Le reste des fragments de code doit s’exécuter à partir de l’instance de bloc-notes Jupyter.
1. Téléchargez le jeu de données CIFAR-10.
```
import torch
import torchvision
import torchvision.transforms as transforms
def _get_transform():
return transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])
def get_train_data_loader(data_dir='/tmp/pytorch/cifar-10-data'):
transform=_get_transform()
trainset=torchvision.datasets.CIFAR10(root=data_dir, train=True,
download=True, transform=transform)
return torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)
def get_test_data_loader(data_dir='/tmp/pytorch/cifar-10-data'):
transform=_get_transform()
testset=torchvision.datasets.CIFAR10(root=data_dir, train=False,
download=True, transform=transform)
return torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)
trainloader=get_train_data_loader('/tmp/pytorch-example/cifar-10-data')
testloader=get_test_data_loader('/tmp/pytorch-example/cifar-10-data')
```
1. Définissez `role` au rôle utilisé pour créer votre bloc-notes Jupyter. Ceci est utilisé pour configurer votre estimateur SageMaker AI.
```
from sagemaker import get_execution_role
role=get_execution_role()
```
1. Collez l'exemple de script suivant dans la cellule de code du bloc-notes pour configurer un estimateur SageMaker AI à l'aide de votre conteneur étendu.
```
from sagemaker.estimator import Estimator
hyperparameters={'epochs': 1}
estimator=Estimator(
image_uri='pytorch-extended-container-test',
role=role,
instance_count=1,
instance_type='local',
hyperparameters=hyperparameters
)
estimator.fit('file:///tmp/pytorch-example/cifar-10-data')
```
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.
Vous pouvez exécuter les lignes de commande suivantes dans une cellule de bloc-notes.
```
%%sh
# Specify an algorithm name
algorithm_name=pytorch-extended-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)
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
# Log into Docker
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}
```
1. Une fois que vous avez envoyé le conteneur, vous pouvez appeler l'image Amazon ECR depuis n'importe où dans l'environnement d' SageMaker IA. Exécutez l’exemple de code suivant dans la cellule de bloc-notes suivante.
Si vous souhaitez utiliser ce conteneur de formation avec SageMaker Studio pour utiliser ses fonctionnalités de visualisation, vous pouvez également exécuter le code suivant dans une cellule de bloc-notes Studio pour appeler l'image Amazon ECR de votre conteneur de formation.
```
import boto3
client=boto3.client('sts')
account=client.get_caller_identity()['Account']
my_session=boto3.session.Session()
region=my_session.region_name
algorithm_name="pytorch-extended-container-test"
ecr_image='{}.dkr.ecr.{}.amazonaws.com/{}:latest'.format(account, region, algorithm_name)
ecr_image
# This should return something like
# 12-digits-of-your-account.dkr.ecr.us-east-2.amazonaws.com/tf-2.2-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 permet de configurer un PyTorch estimateur SageMaker AI.
```
import sagemaker
from sagemaker import get_execution_role
from sagemaker.estimator import Estimator
estimator=Estimator(
image_uri=ecr_image,
role=get_execution_role(),
base_job_name='pytorch-extended-container-test',
instance_count=1,
instance_type='ml.p2.xlarge'
)
# start training
estimator.fit()
# deploy the trained model
predictor=estimator.deploy(1, instance_type)
```
### É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.