Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # Adattamento del container di addestramento Per eseguire il tuo modello di formazione, crea un contenitore Docker utilizzando [Amazon SageMaker Training Toolkit tramite un'istanza](https://github.com/aws/sagemaker-training-toolkit) Amazon SageMaker Notebook. ## Passaggio 1: crea un'istanza di notebook SageMaker 1. Apri la console Amazon SageMaker AI all'indirizzo [https://console.aws.amazon.com/sagemaker/](https://console.aws.amazon.com/sagemaker/). 1. Nel riquadro di navigazione, scegli **Notebook**, scegli **Istanze del notebook** e quindi scegli **Crea istanza del notebook**. 1. Nella pagina **Crea istanza del notebook**, inserisci le seguenti informazioni: 1. Per **Nome dell’istanza del notebook**, inserisci **RunScriptNotebookInstance**. 1. Per **Tipo di istanza del notebook**, scegli **ml.t2.medium**. 1. 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. 1. 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 denominato`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`. 1. Per **Accesso root**, scegli **Abilita**. 1. Scegli **Crea un'istanza del notebook**. 1. 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](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateNotebookInstance.html). 1. Fai clic sul **Nome** del notebook appena creato. Questa procedura apre una nuova pagina. 1. 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'` 1. Dopo che lo stato dell'istanza del notebook diventa **InService**, scegli **Apri JupyterLab**. ## Fase 2: creazione e caricamento del Dockerfile e degli script di addestramento Python 1. Dopo l' JupyterLab apertura, crea una nuova cartella nella home directory del tuo JupyterLab. Nell’angolo in alto a sinistra, scegli l’icona**Nuova cartella**, quindi inserisci il nome della cartella `docker_test_folder`. 1. Crea un `Dockerfile` file di testo nella directory `docker_test_folder`. 1. Scegli l'icona **Nuova utilità di avvio** (\$1) nell'angolo in alto a sinistra. 1. Nel pannello di destra, seleziona **File di testo** nella sezione **Altro**. 1. 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](https://github.com/aws/sagemaker-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. 1. 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. 1. 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](https://en.wikipedia.org/wiki/MNIST_database) 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) ``` ## Fase 3: creazione del container 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\$1tensorflow2** nella sezione **Notebook**. 1. 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` 1. 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 inserire il nome del file manualmente con il flag `-f`. Ad esempio, se il Dockerfile è stato chiamato`Dockerfile-text.txt`, esegui il comando seguente: ``` ! docker build -t tf-custom-container-test -f Dockerfile-text.txt . ``` ## Fase 4: test del container 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\$1tensorflow2** nella sezione Notebook**. 1. 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'`role`argomento 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'`. 1. 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. ## Fase 5: push del container ad Amazon Elastic Container Registry (Amazon ECR) 1. Dopo aver eseguito il test in modalità locale, puoi eseguire il push del container Docker in [Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html) 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](https://docs.aws.amazon.com/sagemaker/latest/dg/docker-containers-adapt-your-own-private-registry.html). 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 collegare la EC2 ContainerRegistryFullAccess policy di **Amazon** al tuo ruolo IAM. Vai alla [console IAM](https://console.aws.amazon.com/iam/home), 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. 1. 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 ``` 1. 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() ``` ------ 1. Se desideri distribuire il tuo modello utilizzando il tuo container, fai riferimento a [Adattamento del proprio container di inferenza](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-inference-container.html). 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 un esempio completo che mostra come testare un contenitore personalizzato localmente e inviarlo a un'immagine Amazon ECR, consulta il notebook di esempio [Building Your Own TensorFlow Container](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/tensorflow_bring_your_own/tensorflow_bring_your_own.html). **Suggerimento** Per profilare ed eseguire il debug dei lavori di formazione per monitorare i problemi di utilizzo del sistema (come colli di bottiglia della CPU e sottoutilizzo della GPU) e identificare i problemi di formazione (come sovradimensionamento, sovrallenamento, tensori esplosivi e gradienti che scompaiono), usa Amazon Debugger. SageMaker Per ulteriori informazioni, consulta [Utilizzo di Debugger con container di addestramento personalizzati](debugger-bring-your-own-container.md). ## Fase 6: eliminazione delle risorse **Per eliminare le risorse al termine dell'esempio in nozioni di base** 1. [SageMaker Apri la](https://console.aws.amazon.com/sagemaker/) **console **RunScriptNotebookInstance**AI, scegli l'**istanza del notebook**, scegli Azioni e scegli Stop.** Possono essere necessari alcuni minuti per arrestare l'istanza. 1. 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. 1. Apri la [console Amazon S3](https://console.aws.amazon.com/s3/) ed elimina il bucket creato per l'archiviazione degli artefatti del modello e del set di dati di addestramento. 1. Apri la [console IAM](https://console.aws.amazon.com/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. ## Blog e casi di studio I seguenti blog illustrano casi di studio sull'utilizzo di contenitori di formazione personalizzati in Amazon SageMaker AI. + [Perché portare il proprio contenitore su Amazon SageMaker AI e come farlo nel modo giusto](https://medium.com/@pandey.vikesh/why-bring-your-own-container-to-amazon-sagemaker-and-how-to-do-it-right-bc158fe41ed1), *Medium* (20 gennaio 2023)