Extension d'un conteneur préconçu

1. Ouvrez la SageMaker console.

2. 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).

3. 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).

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

5. 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'

6. Une fois que le statut de l'instance du bloc-notes est InServicepassé à, choisissez Ouvrir JupyterLab.

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 New Folder (Nouveau dossier), puis saisissez le nom du dossier docker_test_folder.

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

3. 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())

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_pytorch_p39 dans la section Bloc-notes.

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

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

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

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

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

3. 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()

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

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

1. 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}

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

3. 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)

Pour nettoyer les ressources lorsque vous avez terminé avec l'exemple de la rubrique Démarrage

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

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

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

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