Estensione di un container predefinito

1. Apri la console SageMaker AI.

2. Nel riquadro di navigazione, scegli Notebook, scegli Istanze del notebook e quindi scegli Crea istanza del notebook.

3. Nella pagina Crea istanza del notebook, inserisci le seguenti informazioni:

   1. Per Nome dell’istanza del notebook, inserisci RunScriptNotebookInstance.

   2. Per Tipo di istanza del notebook, scegli ml.t2.medium.

   3. Espandi la sezione Autorizzazioni e crittografia e procedi come segue:

      1. Per IAMruolo, scegli Crea un nuovo ruolo.

      2. Nella pagina Crea un IAM ruolo, scegli bucket S3 specifici, specifica un bucket Amazon S3 sagemaker-run-script denominato, quindi scegli Crea ruolo.

         SageMaker L'intelligenza artificiale crea un IAM ruolo denominatoAmazonSageMaker-ExecutionRole-YYYYMMDDTHHmmSS, ad esempio. AmazonSageMaker-ExecutionRole-20190429T110788 Nota che la convenzione di denominazione del ruolo di esecuzione utilizza la data e l'ora in cui il ruolo è stato creato, separati da T.

   4. Per Accesso root, seleziona Abilitato.

   5. Scegli Crea un'istanza del notebook.

4. Nella pagina delle istanze del notebook, lo Stato è In sospeso. Amazon SageMaker AI può impiegare alcuni minuti per avviare un'istanza di calcolo di machine learning (in questo caso, avvia un'istanza notebook) e collegarvi un volume di storage ML. L'istanza del notebook include un server Notebook Jupyter preconfigurato e un set di librerie Anaconda. Per ulteriori informazioni, consulta CreateNotebookInstance.

5. Nella sezione Autorizzazioni e crittografia, copia il ARN numero del IAM ruolo e incollalo in un file di blocco note per salvarlo temporaneamente. Successivamente utilizzerai questo ARN numero di IAM ruolo per configurare uno strumento di valutazione della formazione locale nell'istanza del notebook. Il ARN numero del IAM ruolo è simile al seguente: 'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'

6. Dopo che lo stato dell'istanza del notebook è cambiato in InService, scegli Apri JupyterLab.

1. Dopo l' JupyterLab apertura, crea una nuova cartella nella home directory del tuo JupyterLab. Nell’angolo in alto a sinistra, scegli l’iconaNuova cartella, quindi inserisci il nome della cartella docker_test_folder.

2. Crea un Dockerfile file di testo nella directory docker_test_folder.

   1. Scegli l'icona Nuova utilità di avvio (+) nell'angolo in alto a sinistra.

   2. Nel pannello di destra, seleziona File di testo nella sezione Altro.

   3. Incolla il seguente codice campione Dockerfile nel file di testo.

      # 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

      Lo script Dockerfile esegue le seguenti attività:

      • FROM 763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-training:1.5.1-cpu-py36-ubuntu16.04— Scarica l'immagine di PyTorch base SageMaker AI. Puoi sostituirla con qualsiasi immagine di base SageMaker AI che desideri utilizzare per creare contenitori.

      • ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code – imposta /opt/ml/code come directory dello script di addestramento.

      • COPY cifar10.py /opt/ml/code/cifar10.py— Copia lo script nella posizione all'interno del contenitore prevista dall' SageMaker IA. Lo script si deve trovare in questa cartella.

      • ENV SAGEMAKER_PROGRAM cifar10.py – imposta lo script di addestramento cifar10.py come script del punto di ingresso.

   4. Nel riquadro di navigazione a sinistra, il nome del file di testo viene automaticamente denominato untitled.txt. Per rinominare il file, fai clic con il pulsante destro del mouse sul file, scegli Rinomina, rinomina il file come Dockerfile senza l’estensione .txt, quindi premi Ctrl+s o Command+s per salvare il file.

3. Crea o carica uno script di addestramento cifar10.py in docker_test_folder. Puoi utilizzare il seguente script di esempio per questo esercizio.

   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. Nella JupyterLab home directory, apri un notebook Jupyter. Per aprire un nuovo notebook, scegli l'icona Nuovo avvio, quindi scegli conda_pytorch_p39 nella sezione Notebook.

2. Esegui il comando seguente nella prima cella del notebook per passare alla directory docker_test_folder:

   % cd ~/SageMaker/docker_test_folder

   Viene restituita la directory corrente come segue:

   ! pwd

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

3. Effettua il login a Docker per accedere al container di 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. Per compilare il container Docker, esegui il seguente comando di compilazione Docker, incluso lo spazio seguito da un punto finale:

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

   Il comando build Docker deve essere eseguito dalla directory Docker creata, in questo caso docker_test_folder.

   Nota

   Se visualizzi il seguente messaggio di errore che indica che Docker non riesce a trovare il Dockerfile, assicurati che il Dockerfile abbia il nome corretto e che sia stato salvato nella directory.

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

   Ricorda che docker cerca un file chiamato specificamente Dockerfile senza alcuna estensione all'interno della directory corrente. Se è stato rinominato, è possibile inserire il nome del file manualmente con il flag -f. Ad esempio, se hai inserito un nome per il Dockerfile Dockerfile-text.txt, esegui il comando seguente:

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

1. Per eseguire il test del container localmente nell’istanza del notebook, apri un notebook Jupyter. Scegli Nuova utilità di avvio e seleziona Notebook nel framework conda_pytorch_p39. Il resto dei frammenti di codice deve essere eseguito dall'istanza del notebook Jupyter.

2. Scarica il set di dati -10CIFAR.

   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. Imposta role sul ruolo utilizzato per creare il notebook Jupyter. Viene utilizzato per configurare il tuo SageMaker AI Estimator.

   from sagemaker import get_execution_role
   
   role=get_execution_role()

4. Incolla il seguente script di esempio nella cella di codice del notebook per configurare un SageMaker AI Estimator utilizzando il tuo contenitore esteso.

   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. Esegui la cella di codice. Questo test genera la configurazione dell'ambiente utilizzato per le variabili di ambiente, l'origine dei dati e la perdita e la precisione ottenuti durante l’addestramento.

1. Dopo aver eseguito con successo il test in modalità locale, puoi inviare il contenitore Docker ad Amazon ECR e utilizzarlo per eseguire lavori di formazione.

   Esegui le seguenti linee di comando in una cella del notebook.

   %%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. Dopo aver inviato il container, puoi richiamare l'ECRimmagine Amazon da qualsiasi punto dell'ambiente SageMaker AI. Esegui il seguente esempio di codice nella cella successiva del notebook.

   Se desideri utilizzare questo contenitore di formazione con SageMaker Studio per utilizzare le sue funzionalità di visualizzazione, puoi anche eseguire il codice seguente in una cella notebook Studio per richiamare l'ECRimmagine Amazon del tuo contenitore di formazione.

   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. Usa quanto ecr_image recuperato dal passaggio precedente per configurare un oggetto di stima SageMaker AI. Il seguente esempio di codice configura uno SageMaker stimatore AI. PyTorch

   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)

Per eliminare le risorse al termine dell'esempio sulle Nozioni di base

1. Apri la console SageMaker AI, scegli l'istanza del notebook RunScriptNotebookInstance, scegli Azioni e scegli Stop. Possono essere necessari alcuni minuti per arrestare l'istanza.

2. Dopo che lo Stato dell'istanza è passato ad Arrestato, scegli Azioni, seleziona Elimina, quindi scegli Elimina nella casella di dialogo. Possono essere necessari alcuni minuti per eliminare l'istanza. L'istanza del notebook scompare dalla tabella una volta eliminata.

3. Apri la console Amazon S3 ed elimina il bucket creato per l'archiviazione degli artefatti del modello e del set di dati di addestramento.

4. Apri la IAMconsole ed elimina il IAM ruolo. Se hai creato policy di autorizzazione, puoi anche eliminarle.

   Nota

   Il container Docker si arresta automaticamente dopo che è stato eseguito. Non è necessario eliminarlo.