Adattamento del container di addestramento

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

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 Ruolo IAM, scegli Crea un nuovo ruolo. Questa procedura apre una nuova finestra.

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

         SageMaker L'intelligenza artificiale crea un ruolo IAM 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, separato da T.

   4. Per Accesso root, scegli Abilita.

   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. Fai clic sul Nome del notebook appena creato. Questa procedura apre una nuova pagina.

6. Nella sezione Autorizzazioni e crittografia, copia il numero ARN del ruolo IAM e incollalo in un file di blocco note per salvarlo temporaneamente. Questo numero ARN del ruolo IAM viene utilizzato in seguito per configurare uno strumento di valutazione di addestramento 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, 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.

      #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 AI 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 SageMaker AI Training Toolkit che contiene le funzionalità comuni necessarie per creare un contenitore compatibile con l'IA. SageMaker

      • COPY train.py /opt/ml/code/train.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 train.py: prende lo script di addestramento 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, 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. Caricamento di uno script di addestramento train.py su docker_test_folder Puoi 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, seleziona l'icona Nuovo lancio, quindi scegli l'ultima versione di conda_tensorflow2 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. Per compilare il container Docker, esegui 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 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 passare il nome del file manualmente con il flag -f. Ad esempio, se il Dockerfile è stato chiamatoDockerfile-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 scegli 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 SageMaker AI Estimator.

   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 SageMaker sessione AI. Puoi 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. 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 il test in modalità locale, puoi eseguire il push del container Docker in Amazon ECR e utilizzarlo per eseguire processi di addestramento. Se desideri utilizzare un registro Docker privato anziché Amazon ECR, consulta Push your training container to a private registry.

   Esegui le seguenti righe di comando in una cella del 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 allegare la EC2 ContainerRegistryFullAccess policy di Amazon al tuo ruolo IAM. Vai alla console IAM, scegli Ruoli dal riquadro di navigazione a sinistra, cerca IAMrole quello che hai usato per l'istanza Notebook. Nella scheda Autorizzazione, scegli il pulsante Allega politiche e cerca la EC2 ContainerRegistryFullAccess politica di Amazon. Contrassegna la casella di controllo della policy, quindi scegli Aggiungi autorizzazioni per terminare.

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

   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. Usa quanto ecr_image recuperato dal passaggio precedente per configurare un oggetto di stima SageMaker AI. Il seguente esempio di codice configura uno stimatore SageMaker AI 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 desideri distribuire il tuo modello utilizzando il tuo container, fai riferimento a Adattamento del proprio container di inferenza. Puoi anche utilizzare un contenitore di AWS framework in grado di distribuire un modello. TensorFlow Per implementare il modello di esempio per leggere le cifre scritte a mano, inserisci lo script di esempio seguente nello stesso notebook che hai usato per addestrare il modello nel passaggio secondario precedente per ottenere l'immagine URIs (identificatori di risorse universali) necessaria per la distribuzione e distribuisci 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)

   Testa il tuo 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 grado TensorFlow di assimilare 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 eliminare le risorse al termine dell'esempio in nozioni di base

1. SageMaker Apri la console RunScriptNotebookInstanceAI, 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 è 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 console IAM ed elimina 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.