Exigences relatives à l'extension d'un conteneur préconçu Démarrez avec les conteneurs

Extension d'un conteneur préconçu

Si un SageMaker conteneur préfabriqué ne répond pas à toutes vos exigences, vous pouvez étendre l'image existante pour l'adapter à 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.

Rubriques

Exigences relatives à l'extension d'un conteneur préconçu
Étendre SageMaker les conteneurs pour exécuter un script Python

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 à SageMaker des conteneurs, consultez le GitHub référentiel SageMaker Training Toolkit.

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

Le didacticiel suivant explique comment utiliser ces variables d'environnement.

Étendre SageMaker les conteneurs pour exécuter un script Python

Dans ce didacticiel, vous allez apprendre à étendre le SageMaker PyTorch conteneur avec un fichier Python qui utilise le jeu de données CIFAR-10. En étendant le SageMaker PyTorch conteneur, vous utilisez la solution de formation existante conçue pour fonctionner SageMaker. 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, veuillez consulter Available Deep Learning Containers Images (Images de Deep Learning Containers disponibles).

Pour exécuter votre propre modèle de formation à l'aide SageMaker des conteneurs, créez un conteneur Docker via une instance SageMaker Notebook.

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

Ouvrez la SageMaker console.
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.
  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, tel queAmazonSageMaker-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 CloudWatch Internet Monitor 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.
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 du bloc-notes est InServicepassé à, choisissez Ouvrir JupyterLab.

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

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 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.
```
# 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 SageMaker PyTorch de base. Vous pouvez la remplacer par n'importe quelle image de SageMaker base 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 le conteneur SageMaker. 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.
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.

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

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

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

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

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 de Jupyter.

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

Définissez role au rôle utilisé pour créer votre bloc-notes Jupyter. Ceci est utilisé pour configurer votre SageMaker estimateur.
```
from sagemaker import get_execution_role

role=get_execution_role()
```

Collez l'exemple de script suivant dans la cellule de code du bloc-notes pour configurer un SageMaker estimateur à 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')

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.

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}

Après avoir envoyé le conteneur, vous pouvez appeler l'image Amazon ECR depuis n'importe quel endroit de l' SageMaker environnement. 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
```

Utilisez le résultat ecr_image obtenu à l'étape précédente pour configurer un objet SageMaker estimateur. L'exemple de code suivant configure un SageMaker PyTorch estimateur.


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 la rubrique Démarrage

Ouvrez la SageMaker console, choisissez l'instance du bloc-notes RunScriptNotebookInstance, sélectionnez Actions, puis Stop. 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.

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

Réseaux graphiques profonds

Adapter votre propre conteneur Docker pour qu'il fonctionne avec SageMaker