Erweitern eines vorgefertigten Containers

1. Öffnen Sie die SageMaker AI-Konsole.

2. Wählen Sie im linken Navigationsbereich Notebook, wählen Sie danach Notebook-Instances und anschließend Notebook-Instance erstellen.

3. Geben Sie auf der Seite Notebook-Instance erstellen folgende Informationen ein:

   1. Geben Sie unter Notebook instance name (Name der Notebook-Instance) RunScriptNotebookInstance ein.

   2. Wählen Sie für Notebook instance type (Typ der Notebook-Instance) ml.t2.medium aus.

   3. Im Abschnitt Berechtigungen und Verschlüsselung gehen Sie wie folgt vor:

      1. Wählen Sie für IAM Role (IAM-Rolle) die Option Create a New Role (Neue Rolle erstellen) aus.

      2. Wählen Sie auf der Seite IAM-Rolle erstellen die Option Spezifische S3-Buckets aus, spezifizieren Sie einen S3-Bucket mit dem Namen sagemaker-run-script und wählen Sie dann Rolle erstellen aus.

         SageMaker AI erstellt eine IAM-Rolle mit AmazonSageMaker-ExecutionRole-YYYYMMDDTHHmmSS dem Namen. AmazonSageMaker-ExecutionRole-20190429T110788 Beachten Sie, dass bei der Namenskonvention für Ausführungsrollen das Datum und die Uhrzeit verwendet werden, zu denen die Rolle erstellt wurde, getrennt durch einen T.

   4. Wählen Sie für Root-Zugriff die Option Aktiviert aus.

   5. Wählen Sie Create notebook instance (Notebook-Instance erstellen) aus.

4. Auf der Seite Notebook-Instances lautet der Status Ausstehend. Es kann einige Minuten dauern, bis Amazon SageMaker AI eine Recheninstanz für maschinelles Lernen startet — in diesem Fall startet sie eine Notebook-Instance — und ihr ein ML-Speichervolume anhängt. Die Notebook-Instance verfügt über einen vorkonfigurierten Jupyter-Notebook-Server und mehrere Anaconda-Bibliotheken. Weitere Informationen finden Sie unter CreateNotebookInstance.

5. Kopieren Sie im Abschnitt Berechtigungen und Verschlüsselung die ARN-Nummer der IAM-Rolle und fügen Sie sie in eine Notepad-Datei ein, um sie vorübergehend zu speichern. Sie verwenden diese IAM-Rollen-ARN-Nummer später, um einen lokalen Trainingsschätzer in der Notebook-Instance zu konfigurieren. Die ARN-Nummer der IAM-Rolle sieht wie folgt aus: 'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'

6. Nachdem sich der Status der Notebook-Instanz auf geändert hat InService, wählen Sie Öffnen JupyterLab.

1. Erstellen Sie nach dem JupyterLab Öffnen einen neuen Ordner im Home-Verzeichnis Ihres JupyterLab. Wählen Sie links oben das Symbol Neuer Ordner und geben Sie dann den Ordnernamen docker_test_folder ein.

2. Erstellen Sie in dem Verzeichnis docker_test_folder eine Datei namens Dockerfile.

   1. Wählen Sie das Symbol Neuer Launcher (+) in der oberen linken Ecke.

   2. Wählen Sie im rechten Bereich unter dem Abschnitt Andere die Option Textdatei.

   3. Fügen Sie den folgenden Dockerfile-Beispielcode in Ihre Textdatei ein.

      # 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

      Das Dockerfile-Skript führt die folgenden Aufgaben aus:

      • FROM 763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-training:1.5.1-cpu-py36-ubuntu16.04— Lädt das SageMaker PyTorch AI-Basisimage herunter. Sie können dies durch ein beliebiges SageMaker AI-Basisimage ersetzen, das Sie zum Erstellen von Containern verwenden möchten.

      • ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code – Legt /opt/ml/code als Trainingsskriptverzeichnis fest.

      • COPY cifar10.py /opt/ml/code/cifar10.py— Kopiert das Skript an die Stelle innerhalb des Containers, die von der SageMaker KI erwartet wird. Das Skript muss sich in diesem Ordner befinden.

      • ENV SAGEMAKER_PROGRAM cifar10.py – Legt Ihr cifar10.py-Trainingsskript als Einstiegsskript fest.

   4. In der linken Verzeichnisnavigation wird der Name der Textdatei automatisch auf untitled.txt festgelegt. Um die Datei umzubenennen, klicken Sie mit der rechten Maustaste auf die Datei, wählen Sie Umbenennen, benennen Sie die Datei in Dockerfile ohne die .txt-Erweiterung um und drücken Sie dann auf Ctrl+s oder Command+s, um die Datei zu speichern.

3. Erstellen Sie oder laden Sie ein Trainingsskript cifar10.py in der docker_test_folder hoch. Sie können das folgende Beispiel-Skript für diese Übung nutzen.

   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. Öffnen Sie im JupyterLab Home-Verzeichnis ein Jupyter-Notizbuch. Um ein neues Notebook zu öffnen, wählen Sie das Symbol Neuer Start und dann conda_pytorch_p39 im Abschnitt Notebook.

2. Führen Sie den folgenden Befehl in der ersten Notebook-Zelle aus, um in das Verzeichnis docker_test_folder zu wechseln:

   % cd ~/SageMaker/docker_test_folder

   Dies gibt Ihr aktuelles Verzeichnis wie folgt zurück:

   ! pwd

   output: /home/ec2-user/SageMaker/docker_test_folder

3. Melden Sie sich bei Docker an, um auf den Basis-Container zuzugreifen:

   ! aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 763104351884.dkr.ecr.us-east-1.amazonaws.com

4. Zum Erstellen des Docker-Containers führen Sie den folgenden Docker-Build-Befehl, einschließlich des Punkts am Ende, aus:

   ! docker build -t pytorch-extended-container-test .

   Der Docker-Build-Befehl muss von der von Ihnen erstellten Docker-Registry aus ausgeführt werden. In diesem Fall ist dies docker_test_folder.

   Anmerkung

   Wenn Sie die folgende Fehlermeldung erhalten, dass Docker das Dockerfile nicht finden kann, stellen Sie sicher, dass das Dockerfile den richtigen Namen hat und im Verzeichnis gespeichert wurde.

   unable to prepare context: unable to evaluate symlinks in Dockerfile path: 
   lstat /home/ec2-user/SageMaker/docker/Dockerfile: no such file or directory

   Denken Sie daran, dass docker im aktuellen Verzeichnis spezifisch nach einer Datei namens Dockerfile ohne Erweiterung sucht. Wenn Sie sie anders benannt haben, können Sie den Dateinamen manuell mit dem -f-Flag übergeben. Wenn Sie Ihre Docker-Datei beispielsweise Dockerfile-text.txt benannt haben, führen Sie den folgenden Befehl aus:

   ! docker build -t tf-custom-container-test -f Dockerfile-text.txt .

1. Um den Container lokal für die Notebook-Instance zu testen, öffnen Sie ein Jupyter Notebook. Wählen Sie Neuer Launcher und dann Notebook im conda_pytorch_p39-Framework aus. Der Rest der Codeausschnitte muss von der Jupyter-Notebook-Instance aus ausgeführt werden.

2. Laden Sie den CIFAR-10-Datensatz herunter.

   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. Setzen Sie role auf die Rolle, mit der Sie Ihr Jupyter Notebook erstellt haben. Dies wird verwendet, um Ihren SageMaker AI Estimator zu konfigurieren.

   from sagemaker import get_execution_role
   
   role=get_execution_role()

4. Fügen Sie das folgende Beispielskript in die Notebook-Codezelle ein, um einen SageMaker AI Estimator mithilfe Ihres erweiterten Containers zu konfigurieren.

   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. Führen Sie die Code-Zelle aus. Dieser Test gibt die Konfiguration der Trainingsumgebung, die Werte für die Umgebungsvariablen, die Quelle der Daten sowie den Verlust und die Genauigkeit aus, die bei dem Training erreicht wurden.

1. Nachdem Sie den Test im lokalen Modus erfolgreich durchgeführt haben, können Sie den Docker-Container an Amazon ECR senden und ihn zur Ausführung von Trainingsaufträgen verwenden.

   Führen Sie die folgenden Befehlszeilen in einer Notebook-Zelle aus.

   %%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. Nachdem Sie den Container gepusht haben, können Sie das Amazon ECR-Image von überall in der SageMaker KI-Umgebung aufrufen. Führen Sie das folgende Codebeispiel in der nächsten Notebook-Zelle aus.

   Wenn Sie diesen Trainingscontainer mit SageMaker Studio verwenden möchten, um seine Visualisierungsfunktionen zu nutzen, können Sie auch den folgenden Code in einer Studio-Notebookzelle ausführen, um das Amazon ECR-Image Ihres Trainingscontainers aufzurufen.

   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. Verwenden Sie das aus dem vorherigen Schritt ecr_image abgerufene Objekt, um ein SageMaker AI-Estimator-Objekt zu konfigurieren. Das folgende Codebeispiel konfiguriert einen SageMaker PyTorch AI-Schätzer.

   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)

So bereinigen Sie die Ressourcen, wenn Sie mit dem Beispiel Erste Schritte fertig sind

1. Öffnen Sie die SageMaker AI-Konsole, wählen Sie die Notebook-Instanz aus RunScriptNotebookInstance, wählen Sie Aktionen und dann Stopp aus. Das Anhalten der Instance kann einige Minuten dauern.

2. Nachdem sich der Instance-Status auf Gestoppt geändert hat, wählen Sie Aktionen, dann Löschen und anschließend im Dialogfeld Löschen aus. Das Löschen der Instance kann einige Minuten dauern. Die Notebook-Instance verschwindet aus der Tabelle, wenn sie gelöscht wurde.

3. Öffnen Sie die Amazon S3-Konsole und löschen Sie den Bucket, den Sie zum Speichern von Modellartefakten und dem Trainingsdatensatz erstellt haben.

4. Öffnen Sie die IAM-Konsole und löschen Sie die IAM-Rolle. Wenn Sie Berechtigungsrichtlinien erstellt haben, können Sie diese ebenfalls löschen.

   Anmerkung

   Der Docker-Container wird nach seiner Ausführung automatisch beendet. Sie müssen ihn nicht löschen.