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 ](https://github.com/aws/sagemaker-training-toolkit) tramite un'istanza 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'IA crea un ruolo IAM denominato`AmazonSageMaker-ExecutionRole-{{YYYYMMDD}}T{{HHmmSS}}`. 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 collegare ad essa 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 verrà utilizzato successivamente per configurare un training locale ModelTrainer 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 è cambiato in ** 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** (\+) 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'ultima immagine base TensorFlow Docker. 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\_tensorflow2** 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\_tensorflow2** nella sezione Notebook**. 1. Incolla il seguente script di esempio nella cella del codice del notebook per configurare un'IA. SageMaker ModelTrainer ``` import sagemaker from sagemaker.train import ModelTrainer from sagemaker.train.configs import Compute from sagemaker.core.helper.session_helper import get_execution_role model_trainer = ModelTrainer(training_image='{{tf-custom-container-test}}', role={{get_execution_role()}}, compute=Compute(instance_count={{1}}, instance_type={{'local'}})) model_trainer.train() ``` Nell'esempio di codice precedente, `get_execution_role()` viene specificato l'`role`argomento per recuperare automaticamente il ruolo impostato per la sessione SageMaker 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 allegare la ** AmazonEC2ContainerRegistryFullAccess ** policy al tuo ruolo IAM. Vai alla [console IAM](https://console.aws.amazon.com/iam/home), scegli **Ruoli** dal riquadro di navigazione a sinistra, cerca il ruolo IAM utilizzato per l'istanza del notebook. **Nella scheda ** Autorizzazione, scegli il ** pulsante ** Allega policy e cerca la ** AmazonEC2ContainerRegistryFullAccess ** policy. 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 ModelTrainer oggetto SageMaker AI. Il seguente esempio di codice configura un' SageMaker intelligenza artificiale ModelTrainer con `byoc_image_uri` e avvia un processo di formazione su un'istanza Amazon EC2. ------ #### [ SageMaker Python SDK v1 ] ``` import sagemaker from sagemaker.core.helper.session_helper import get_execution_role from sagemaker.train import ModelTrainer from sagemaker.train.configs import Compute model_trainer = ModelTrainer(training_image=byoc_image_uri, role=get_execution_role(), compute=Compute( instance_count=1, instance_type='ml.g4dn.xlarge'), base_job_name='tf-custom-container-test-job') #train your model model_trainer.train() ``` ------ #### [ SageMaker Python SDK v2 ] ``` import sagemaker from sagemaker.core.helper.session_helper import get_execution_role from sagemaker.train import ModelTrainer from sagemaker.train.configs import Compute model_trainer = ModelTrainer(training_image=byoc_image_uri, role=get_execution_role(), compute=Compute( instance_count=1, instance_type='ml.g4dn.xlarge'), base_job_name='tf-custom-container-test-job') #train your model model_trainer.train() ``` ------ 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 distribuire il modello di esempio per leggere le cifre scritte a mano, inserisci lo script di esempio seguente nello stesso notebook usato per addestrare il modello nella fase secondaria precedente per ottenere gli URI (Universal Resource Identifier) dell'immagine necessari per l’implementazione, quindi distribuisci il modello. ``` import boto3 import sagemaker import json #obtain image uris from sagemaker.core import image_uris from sagemaker.serve import ModelBuilder 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 model_builder = ModelBuilder( image_uri=container, s3_model_data_url=model_trainer.model_data, role_arn=get_execution_role(), instance_type='ml.g4dn.xlarge' ) model = model_builder.build() endpoint = model_builder.deploy() ``` 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() ``` Converte la cifra scritta a mano del test in un modulo in TensorFlow grado di assimilare e fare una previsione del test. ``` import json data = {"instances": example_image.tolist()} response = endpoint.invoke(body=json.dumps(data)) result = json.loads(response.body.read().decode('utf-8')) #make the prediction ``` Per un esempio completo che mostra come testare un contenitore personalizzato localmente e inviarlo a un'immagine Amazon ECR, consulta il taccuino di esempio [ Building Your Own Container. TensorFlow ](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 processi di formazione per monitorare i problemi di utilizzo del sistema (come i colli di bottiglia della CPU e il sottoutilizzo della GPU) e identificare i problemi di formazione (come sovradimensionamento, sovrallenamento, tensori esplosivi e gradienti che svaniscono), 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. Apri la console AI, scegli l'istanza del notebook, scegli Azioni e scegli Stop. [ SageMaker ](https://console.aws.amazon.com/sagemaker/) ** RunScriptNotebookInstance ** ** ** ** ** 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 tuo container 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)