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 IAMruolo, scegli Crea un nuovo ruolo. Si apre una nuova finestra.

      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 ruolo denominato. IAM AmazonSageMaker-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 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'

7. 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.

      #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 È possibile utilizzare lo script di esempio seguente per creare un modello che legga le cifre scritte a mano addestrate sul MNISTset di dati 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, aprite 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. È inoltre possibile sostituirlo con il valore di stringa del ARNnumero di IAM ruolo utilizzato durante la configurazione dell'istanza del notebook. ARNDovrebbe essere 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 con successo il test in modalità locale, puoi inviare il contenitore Docker ad Amazon ECR e utilizzarlo per eseguire lavori di formazione. Se desideri utilizzare un registro Docker privato anziché AmazonECR, 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 EC2ContainerRegistryFullAccess politica di Amazon al tuo IAM ruolo. Vai alla IAMconsole, 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 EC2ContainerRegistryFullAccess 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 richiamare l'ECRimmagine Amazon del tuo contenitore di formazione.

   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 utilizzando il seguente esempio di codice. MNIST

   #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 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 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.