Adattamento del container di training

1. Apri la SageMaker console Amazon all'indirizzo https://console.aws.amazon.com/sagemaker/.

2. Nel riquadro di navigazione, scegliere Notebook, scegliere Notebook instances (Istanze notebook) quindi Create notebook instance (Crea un'istanza notebook).

3. Nella pagina Crea un'istanza notebook, immettere le seguenti informazioni:

   1. In Nome istanza notebook, immettere RunScriptNotebookInstance.

   2. Per Tipo di istanza notebook, scegliere ml.t2.medium.

   3. Nella sezione Permissions and encryption (Autorizzazioni e crittografia) e procedere come segue:

      1. Per Ruolo IAM, scegliere Crea un nuovo ruolo. Questa procedura apre una nuova finestra.

      2. Nella pagina Create an IAM role (Crea un ruolo IAM), scegliere Specific S3 buckets (Specifica bucket S3), specificare un bucket Amazon S3 denominato sagemaker-run-script e scegliere Create role (Crea ruolo).

         SageMaker crea un ruolo IAM denominatoAmazonSageMaker-ExecutionRole-YYYYMMDDTHHmmSS. Ad esempio, AmazonSageMaker-ExecutionRole-20190429T110788. Si noti che la convenzione di denominazione del ruolo di esecuzione utilizza la data e l'ora in cui il ruolo è stato creato, separato da T.

   4. Per Root Access (Accesso root), scegli Enable (Abilita).

   5. Scegliere Crea un'istanza notebook.

4. Nella pagina istanze Notebook, lo Status (Stato) è Pending (In sospeso). Amazon può impiegare alcuni minuti SageMaker 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 notebook include un server Notebook Jupyter preconfigurato e un set di librerie Anaconda. Per ulteriori informazioni, consulta CreateNotebookInstance.

5. Fare clic sul Name (Nome) del notebook appena creato. Questa procedura apre una nuova pagina.

6. Nella sezione Permissions and encryption (Autorizzazioni e crittografia), copiare il numero ARN del ruolo IAM e incollarlo in un file di blocco note per salvarlo temporaneamente. Verrà utilizzato questo numero ARN del ruolo IAM in seguito per configurare uno stimatore di training locale nell'istanza del notebook. Il numero ARN del ruolo IAM è simile al seguente: 'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'

7. Dopo che lo stato dell'istanza del notebook diventa 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, scegliere l'icona New Folder (Nuova cartella) e quindi inserire il nome della cartella docker_test_folder.

2. Nella directory Dockerfile, creare un file denominato docker_test_folder.

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

   2. Nel pannello di destra, nella sezione Other (Altro), scegliere Text File (File di testo).

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

      #Download an open source TensorFlow Docker image
      FROM tensorflow/tensorflow:latest-gpu-jupyter
      
      # Install sagemaker-training toolkit that contains the common functionality necessary to create a container compatible with SageMaker and the Python SDK.
      RUN pip3 install sagemaker-training
      
      # Copies the training code inside the container
      COPY train.py /opt/ml/code/train.py
      
      # Defines train.py as script entrypoint
      ENV SAGEMAKER_PROGRAM train.py

      Lo script Dockerfile esegue le seguenti attività:

      • FROM tensorflow/tensorflow:latest-gpu-jupyter— Scarica l'immagine di base TensorFlow Docker più recente. Puoi sostituirla con qualsiasi immagine di base Docker che desideri utilizzare per creare contenitori, nonché con immagini di base di container AWS predefinite.

      • RUN pip install sagemaker-training— Installa SageMakerTraining Toolkit che contiene le funzionalità comuni necessarie per creare un contenitore compatibile con. SageMaker

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

      • ENV SAGEMAKER_PROGRAM train.py – Prende lo script di training train.py come script del punto di ingresso copiato nella cartella /opt/ml/code del container. Questa è la sola variabile di ambiente che è necessario specificare quando si crea il proprio container.

   4. Nel riquadro di navigazione della directory di sinistra, il nome del file di testo può automaticamente essere denominato untitled.txt. Per rinominare il file, fare clic con il pulsante destro del mouse sul file, scegliere Rename (Rinomina), rinominare il file come Dockerfile senza l’estensione .txt, quindi premere Ctrl+s o Command+s per salvare il file.

3. Caricare uno script di training train.py su docker_test_folder È possibile utilizzare lo script di esempio seguente per creare un modello che legga le cifre scritte a mano addestrate sul set di dati MNIST per questo esercizio.

   import tensorflow as tf
   import os
   
   mnist = tf.keras.datasets.mnist
   
   (x_train, y_train), (x_test, y_test) = mnist.load_data()
   x_train, x_test = x_train / 255.0, x_test / 255.0
   
   model = tf.keras.models.Sequential([
   tf.keras.layers.Flatten(input_shape=(28, 28)),
   tf.keras.layers.Dense(128, activation='relu'),
   tf.keras.layers.Dropout(0.2),
   tf.keras.layers.Dense(10, activation='softmax')
   ])
   
   model.compile(optimizer='adam',
   loss='sparse_categorical_crossentropy',
   metrics=['accuracy'])
   
   model.fit(x_train, y_train, epochs=1)
   model_save_dir = f"{os.environ.get('SM_MODEL_DIR')}/1"
   
   model.evaluate(x_test, y_test)
   tf.saved_model.save(model, model_save_dir)

1. Nella JupyterLab home directory, apri un notebook Jupyter. Per aprire un nuovo notebook, scegliere l'icona New Launch (Nuovo lancio), quindi scegliere l'ultima versione di conda_tensorflow2 nella sezione Notebook.

2. Eseguire 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. Per compilare il container Docker, eseguire il seguente comando di compilazione Docker, incluso lo spazio seguito da un punto finale.

   ! docker build -t tf-custom-container-test .

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

   Nota

   Se si riceve il seguente messaggio di errore che indica che Docker non riesce a trovare il Dockerfile, assicurarsi 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

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

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

1. Per eseguire il test del container localmente nell’istanza notebook, aprire un notebook Jupyter. Scegliere New Launcher (Nuova utilità di avvio) e scegliere l'ultima versione di conda_tensorflow2 nella sezione Notebook.

2. Incolla il seguente script di esempio nella cella di codice del notebook per configurare un Estimator. SageMaker

   import sagemaker
   from sagemaker.estimator import Estimator
   
   estimator = Estimator(image_uri='tf-custom-container-test',
                         role=sagemaker.get_execution_role(),
                         instance_count=1,
                         instance_type='local')
   
   estimator.fit()

   Nell'esempio di codice precedente, sagemaker.get_execution_role() viene specificato all'roleargomento per recuperare automaticamente il ruolo impostato per la sessione. SageMaker È possibile anche sostituirlo con il valore stringa del numero ARN del ruolo IAM utilizzato quando è stata configurata l'istanza del notebook. L'ARN avrà un aspetto simile al seguente: 'arn:aws:iam::111122223333:role/service-role/AmazonSageMaker-ExecutionRole-20190429T110788'.

3. Eseguire 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 il training.

1. Dopo aver eseguito il test in modalità locale, è possibile eseguire il push del container Docker in Amazon ECR e utilizzarlo per eseguire processi di training. Se si desidera utilizzare un registro Docker privato anziché Amazon ECR, consultare Push your training container to a private registry (Inviare tramite push il container di training a un registro privato).

   Eseguire le seguenti righe di comando in una cella di notebook.

   %%sh
   
   # Specify an algorithm name
   algorithm_name=tf-custom-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)
   region=${region:-us-west-2}
   
   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
   
   # Get the login command from ECR and execute it directly
   
   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}

   Nota

   Questo script della shell bash può creare un problema di autorizzazione simile al seguente messaggio di errore:

   "denied: User: [ARN] is not authorized to perform: ecr:InitiateLayerUpload on resource:
   arn:aws:ecr:us-east-1:[id]:repository/tf-custom-container-test"

   Se si verifica questo errore, devi collegare la ContainerRegistryFullAccess policy AmazonEC2 al tuo ruolo IAM. Andare alla console IAM, scegliere Roles (Ruoli) dal riquadro di navigazione a sinistra, cercare l'IAMrole utilizzato per l'istanza Notebook. Nella scheda Autorizzazione, scegli il pulsante Allega politiche e cerca la politica di AmazonEC2. ContainerRegistryFullAccess Contrassegnare la casella di controllo della policy, quindi scegliere Add permissions (Aggiungi autorizzazioni) per finire.

2. Eseguire il codice seguente in una cella notebook Studio per chiamare l'immagine Amazon ECR del container di training.

   import boto3
   
   account_id = boto3.client('sts').get_caller_identity().get('Account')
   ecr_repository = 'tf-custom-container-test'
   tag = ':latest'
   
   region = boto3.session.Session().region_name
   
   uri_suffix = 'amazonaws.com'
   if region in ['cn-north-1', 'cn-northwest-1']:
       uri_suffix = 'amazonaws.com.cn'
   
   byoc_image_uri = '{}.dkr.ecr.{}.{}/{}'.format(account_id, region, uri_suffix, ecr_repository + tag)
   
   byoc_image_uri
   # This should return something like
   # 111122223333.dkr.ecr.us-east-2.amazonaws.com/sagemaker-byoc-test:latest

3. Utilizza quanto ecr_image recuperato dal passaggio precedente per configurare un oggetto estimatore. SageMaker Il seguente esempio di codice configura uno SageMaker stimatore con byoc_image_uri e avvia un processo di formazione su un'istanza Amazon EC2.

   SageMaker Python SDK v1

   import sagemaker
   from sagemaker import get_execution_role
   from sagemaker.estimator import Estimator
   
   estimator = Estimator(image_uri=byoc_image_uri,
                         role=get_execution_role(),
                         base_job_name='tf-custom-container-test-job',
                         instance_count=1,
                         instance_type='ml.g4dn.xlarge')
   
   #train your model
   estimator.fit()
   
   

   SageMaker Python SDK v2

   import sagemaker
   from sagemaker import get_execution_role
   from sagemaker.estimator import Estimator
   
   estimator = Estimator(image_uri=byoc_image_uri,
                         role=get_execution_role(),
                         base_job_name='tf-custom-container-test-job',
                         instance_count=1,
                         instance_type='ml.g4dn.xlarge')
   
   #train your model
   estimator.fit()
   

4. Se si desidera distribuire il proprio modello utilizzando il proprio container, fare riferimento a Adapting Your Own Inference Container (Adattamento del proprio container di inferenza). Puoi anche utilizzare un contenitore di AWS framework in grado di distribuire un modello. TensorFlow Per distribuire il modello di esempio per leggere le cifre scritte a mano, inserire lo script di esempio seguente nello stesso notebook usato per addestrare il modello nel passaggio secondario precedente per ottenere gli URI dell'immagine (URI, Universal Resource Identifier - Identificatori di risorse universali) necessari per la distribuzione, quindi distribuire il modello.

   import boto3
   import sagemaker
   
   #obtain image uris
   from sagemaker import image_uris
   container = image_uris.retrieve(framework='tensorflow',region='us-west-2',version='2.11.0',
                       image_scope='inference',instance_type='ml.g4dn.xlarge')
   
   #create the model entity, endpoint configuration and endpoint
   predictor = estimator.deploy(1,instance_type='ml.g4dn.xlarge',image_uri=container)

   Testare il proprio modello utilizzando un esempio di cifra scritta a mano dal set di dati MNIST utilizzando il seguente esempio di codice.

   #Retrieve an example test dataset to test
   import numpy as np
   import matplotlib.pyplot as plt
   from keras.datasets import mnist
   
   # Load the MNIST dataset and split it into training and testing sets
   (x_train, y_train), (x_test, y_test) = mnist.load_data()
   # Select a random example from the training set
   example_index = np.random.randint(0, x_train.shape[0])
   example_image = x_train[example_index]
   example_label = y_train[example_index]
   
   # Print the label and show the image
   print(f"Label: {example_label}")
   plt.imshow(example_image, cmap='gray')
   plt.show()

   Converti la cifra scritta a mano del test in un modulo in TensorFlow grado di inserire ed effettuare una previsione del test.

   from sagemaker.serializers import JSONSerializer
   data = {"instances": example_image.tolist()}
   predictor.serializer=JSONSerializer() #update the predictor to use the JSONSerializer
   predictor.predict(data) #make the prediction

Per cancellare le risorse al termine dell'esempio sulle nozioni di base

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

2. Dopo che lo Stato dell’istanza diventa Stopped (Arrestato), scegliere Actions (Azioni), scegliere Delete (Elimina) e quindi scegliere Delete (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. Aprire la console Amazon S3 ed eliminare il bucket creato per l'archiviazione degli artefatti del modello e del set di dati di training.

4. Aprire la console IAM ed eliminare il ruolo IAM. Se hai creato policy di autorizzazione, puoi anche eliminarle.

   Nota

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