Erweitern eines vorgefertigter Containers

1. Öffnen Sie die SageMaker -Konsole.

2. Wählen Sie im linken Navigationsbereich Notebook, wählen Sie danach Notebook-Instanzen und dann Erstelle eine Notebook-Instanze.

3. Geben Sie auf der Seite Notebook-Instanze 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 Genehmigung 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 erstellt eine IAM-Rolle mit dem Namen AmazonSageMaker-ExecutionRole-YYYYMMDDTHHmmSS, z. B. 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-Instanzen lautet der Status Ausstehend. Es kann einige Minuten dauern, bis Amazon CloudWatch Internet Monitor eine Machine-Learning-Computing-Instance startet – in diesem Fall startet es eine Notebook-Instance – und ihr ein ML-Speicher-Volume anfügt. 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 ARN-Nummer der IAM-Rolle 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-Instance in geändert hatInService, wählen Sie Öffnen aus JupyterLab.

1. Nachdem JupyterLab geöffnet wurde, erstellen Sie einen neuen Ordner im Stammverzeichnis Ihres JupyterLab. Wählen Sie links oben das Symbol für Neuer Ordner und geben Sie dann den Ordnernamen ein docker_test_folder.

2. Erstellen Sie in dem docker_test_folder Verzeichnis eine Dockerfile Textdatei.

   1. Wählen Sie das Symbol Neuer Launcher (+) links oben.

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

   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 Basis-Image herunter. Sie können dies durch jedes SageMaker Basis-Image ersetzen, das Sie zum Erstellen von Containern verwenden möchten.

      • ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code — Wird /opt/ml/code als Schulungsskriptverzeichnis festgelegt.

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

      • ENV SAGEMAKER_PROGRAM cifar10.py— Legt Ihr cifar10.py Schulungsskript 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 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 Schulungsskript cifar10.py hoch in der docker_test_folder. 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 Stammverzeichnis ein Jupyter-Notebook. 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 docker_test_folder Verzeichnis 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 dem von Ihnen erstellten Docker-Verzeichnis 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 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 Schätzer zu konfigurieren.

   from sagemaker import get_execution_role
   
   role=get_execution_role()

4. Fügen Sie das folgende Beispielskript in die Codezelle des SageMaker Notebooks ein, um einen Schätzer mit Ihrem erweiterten Container 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 Schulungsumgebung, die Werte für die Umgebungsvariablen, die Quelle der Daten sowie den Verlust und die Genauigkeit aus, die bei der Schulung 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 Schulungsaufträ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 übertragen haben, können Sie das Amazon-ECR-Image von überall in der SageMaker 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 verwenden, können Sie auch den folgenden Code in einer Studio-Notebook-Zelle 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 die aus dem vorherigen Schritt ecr_image abgerufene , um ein SageMaker Schätzerobjekt zu konfigurieren. Das folgende Codebeispiel konfiguriert einen SageMaker PyTorch 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 -Konsole, wählen Sie die Notebook-Instance RunScriptNotebookInstanceaus, wählen Sie Aktionen und dann Stoppen aus. Das Anhalten der Instance kann einige Minuten dauern.

2. Nachdem sich der Instanz-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 Instanz kann einige Minuten dauern. Die Notebook-Instanz 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 Trainingsdataset 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.