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à. # Container Docker per l’addestramento e l’implementazione di modelli Amazon SageMaker AI fa un uso estensivo dei *contenitori Docker* per le attività di compilazione e runtime. SageMaker L'intelligenza artificiale fornisce immagini Docker predefinite per i suoi algoritmi integrati e i framework di deep learning supportati utilizzati per la formazione e l'inferenza. Utilizzando i container, puoi eseguire l’addestramento di algoritmi di machine learning e distribuire modelli in modo rapido e affidabile su qualsiasi scala. Gli argomenti di questa sezione mostrano come distribuire questi container per i tuoi casi d'uso. Per informazioni su come portare i propri contenitori da utilizzare con Amazon SageMaker Studio Classic, consulta[Immagini personalizzate in Amazon SageMaker Studio Classic](studio-byoi.md). **Topics** + [Scenari per l'esecuzione di script, l'addestramento di algoritmi o la distribuzione di modelli con intelligenza artificiale SageMaker](#container-scenarios) + [Nozioni di base sui container Docker](docker-basics.md) + [Immagini Docker AI predefinite SageMaker](docker-containers-prebuilt.md) + [Contenitori Docker personalizzati con intelligenza artificiale SageMaker](docker-containers-adapt-your-own.md) + [Creazione di un container con algoritmi e modelli personalizzati](docker-containers-create.md) + [Esempi e ulteriori informazioni: utilizzo del proprio algoritmo o modello](docker-containers-notebooks.md) + [Risoluzione dei problemi relativi ai container Docker e alle implementazioni](#docker-containers-troubleshooting) ## Scenari per l'esecuzione di script, l'addestramento di algoritmi o la distribuzione di modelli con intelligenza artificiale SageMaker Amazon SageMaker AI utilizza sempre i contenitori Docker per eseguire script, addestrare algoritmi e distribuire modelli. Il tuo livello di coinvolgimento con i container varia a seconda del tuo caso d'uso. **Il seguente albero decisionale illustra tre scenari principali: casi d'uso **per l'utilizzo di contenitori Docker predefiniti con SageMaker intelligenza artificiale; casi d'uso per l'estensione di un contenitore Docker** **preconfigurato; casi d'uso per la creazione di container personalizzati**.** ![\[Albero decisionale per casi d’uso di container.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/your-algorithm-containers-flowchart-diagram.png) **Topics** + [Casi d'uso per l'utilizzo di contenitori Docker predefiniti con AI SageMaker](#container-scenarios-use-prebuilt) + [Casi d'uso per estendere un container Docker predefinito](#container-scenarios-extend-prebuilt) + [Caso d'uso per costruire il proprio container](#container-scenarios-byoc) ### Casi d'uso per l'utilizzo di contenitori Docker predefiniti con AI SageMaker Prendi in considerazione i seguenti casi d'uso quando utilizzi contenitori con SageMaker AI: + **Algoritmo SageMaker AI predefinito**: utilizza l'immagine fornita con l'algoritmo integrato. Per ulteriori informazioni, consulta [Utilizzare algoritmi integrati o modelli preaddestrati di Amazon SageMaker AI](https://docs.aws.amazon.com//sagemaker/latest/dg/algos.html). + **Modello personalizzato con contenitore SageMaker AI predefinito**: se addestra o distribuisci un modello personalizzato, ma utilizzi un framework con un contenitore SageMaker AI precostruito PyTorch, che include TensorFlow e scegli una delle seguenti opzioni: + Se non hai bisogno di un pacchetto personalizzato e il container include già tutti i pacchetti richiesti, usa l'immagine Docker predefinita associata al tuo framework. Per ulteriori informazioni, consulta [Immagini Docker AI predefinite SageMaker](docker-containers-prebuilt.md). + Se hai bisogno di un pacchetto personalizzato installato in uno dei container predefiniti: conferma che l'immagine Docker predefinita consenta un file requirements.txt oppure estendi il container predefinito in base ai seguenti casi d'uso. ### Casi d'uso per estendere un container Docker predefinito Di seguito sono riportati i casi d'uso per l'estensione di un container Docker predefinito: + **Non è possibile importare le dipendenze**: estendi l'immagine Docker predefinita associata al framework. Per ulteriori informazioni, consulta [Estensione di un container predefinito](prebuilt-containers-extend.md). + **Non puoi importare le dipendenze nel container predefinito, il container predefinito supporta requirements.txt**: aggiungi tutte le dipendenze richieste in requirements.txt. I seguenti framework supportano l'utilizzo di requirements.txt. + [TensorFlow](https://sagemaker.readthedocs.io/en/v2.18.0/frameworks/tensorflow/using_tf.html) + [Chainer](https://sagemaker.readthedocs.io/en/v2.18.0/frameworks/chainer/using_chainer.html?highlight=requirements.txt) + [Sci-kit learn](https://sagemaker.readthedocs.io/en/stable/frameworks/sklearn/using_sklearn.html?highlight=requirements.txt) + [PyTorch](https://sagemaker.readthedocs.io/en/v2.18.0/frameworks/pytorch/using_pytorch.html?highlight=requirements.txt) + [Apache MXNet](https://sagemaker.readthedocs.io/en/v2.18.0/frameworks/mxnet/using_mxnet.html?highlight=requirements.txt) ### Caso d'uso per costruire il proprio container Se crei o addestri un modello personalizzato e hai bisogno di un framework personalizzato che non abbia un'immagine predefinita, crea un container personalizzato. Come esempio di formazione e implementazione di un TensorFlow modello, la seguente guida mostra come determinare l'opzione delle sezioni precedenti di Casi d'**uso adatta al caso**. Si supponga di avere i seguenti requisiti per la formazione e l'implementazione di un TensorFlow modello. + Un TensorFlow modello è un modello personalizzato. + Poiché un TensorFlow modello verrà creato nel TensorFlow framework, utilizzate il contenitore framework TensorFlow predefinito per addestrare e ospitare il modello. + Se sono necessari pacchetti personalizzati nello script del [ punto di ingresso](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/using_tf.html#train-a-model-with-tensorflow) o nello script di inferenza [, estendi il container predefinito o usa un file requirements.txt per installare le dipendenze in fase di esecuzione.](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/deploying_tensorflow_serving.html#how-to-implement-the-pre-and-or-post-processing-handler-s) Dopo aver determinato il tipo di container necessario, il seguente elenco fornisce dettagli sulle opzioni elencate in precedenza. + **Utilizza un algoritmo o un framework di SageMaker intelligenza artificiale integrato**. Nella maggior parte dei casi d'uso, puoi utilizzare gli algoritmi e i framework integrati senza preoccuparti dei container. [Puoi addestrare e distribuire questi algoritmi dalla console SageMaker AI, da AWS Command Line Interface (AWS CLI), da un notebook Python o dall'SDK Amazon Python. SageMaker ](https://sagemaker.readthedocs.io/en/stable) È possibile farlo specificando l'algoritmo o la versione del framework durante la creazione dello strumento di valutazione. Gli algoritmi integrati disponibili sono descritti in modo dettagliato nell'argomento [Algoritmi integrati e modelli preaddestrati in Amazon SageMaker](algos.md). Per ulteriori informazioni sui framework disponibili, consulta [Framework e linguaggi ML](frameworks.md). Per un esempio di come addestrare e distribuire un algoritmo integrato utilizzando un notebook Jupyter in esecuzione in un'istanza di notebook, consulta l'argomento. SageMaker [Guida alla configurazione con Amazon SageMaker AI](gs.md) + **Utilizza immagini di container AI predefinite SageMaker **. In alternativa, puoi utilizzare gli algoritmi e i framework integrati utilizzando i contenitori Docker. SageMaker L'intelligenza artificiale fornisce contenitori per i suoi algoritmi integrati e immagini Docker predefinite per alcuni dei framework di apprendimento automatico più comuni, come Apache, e Chainer. MXNet TensorFlow PyTorch Per un elenco completo delle SageMaker immagini disponibili, consulta Available [Deep Learning Containers Images](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Inoltre, supporta librerie di machine learning quali scikit-learn e SparkML. Se utilizzi l'[SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), puoi distribuire i contenitori passando l'URI completo del contenitore alla rispettiva classe SDK. SageMaker `Estimator` Per l'elenco completo dei framework di deep learning attualmente supportati dall'IA, consulta. SageMaker [Immagini Docker SageMaker AI predefinite per il deep learning](pre-built-containers-frameworks-deep-learning.md) Per ulteriori informazioni sulle immagini container predefinite scikit-learn e SparkML, consulta [Accesso a immagini Docker per Scikit-learn e Spark ML](pre-built-docker-containers-scikit-learn-spark.md). Per ulteriori informazioni sull'uso dei framework con l'[SDK Amazon SageMaker Python](https://sagemaker.readthedocs.io/en/stable), consulta i rispettivi argomenti in. [Framework e linguaggi di machine learning](frameworks.md) + **Estendi un'immagine di contenitore AI preconfigurata SageMaker **. Se desideri estendere un algoritmo SageMaker AI predefinito o un'immagine Docker modello, puoi modificare l' SageMaker immagine per soddisfare le tue esigenze. Per un esempio, vedi [Estendere i nostri contenitori](https://github.com/aws/amazon-sagemaker-examples-community/blob/215215eb25b40eadaf126d055dbb718a245d7603/bring-your-own-container/pytorch_extending_our_containers/pytorch_extending_our_containers.ipynb). PyTorch + **Adattare un'immagine di contenitore esistente**: se desideri adattare un'immagine di contenitore preesistente per lavorare con l' SageMaker intelligenza artificiale, devi modificare il contenitore Docker per abilitare il toolkit SageMaker Training o Inference. Per un esempio che mostra come compilare i tuoi container per eseguire l’addestramento e l'hosting di un algoritmo, consulta [Bring Your Own R Algorithm](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/scikit_bring_your_own/scikit_bring_your_own.ipynb). # Nozioni di base sui container Docker Le seguenti informazioni descrivono gli aspetti più importanti dell’utilizzo dei container Docker con Amazon SageMaker AI. Docker è un programma che esegue la virtualizzazione a livello di sistema operativo per l’installazione, la distribuzione e la gestione del software. Crea pacchetti di applicazioni e delle relative dipendenze in container virtuali che forniscono isolamento, portabilità e sicurezza. Con Docker, puoi inviare il codice più rapidamente, standardizzare le operazioni delle applicazioni, spostare in modo lineare il codice ed economizzare migliorando l’utilizzo delle risorse. Per ulteriori informazioni su Docker, consulta [Panoramica Docker](https://docs.docker.com/engine/docker-overview/). **Funzioni SageMaker AI** SageMaker AI utilizza i container Docker nel backend per gestire i processi di addestramento e inferenza. SageMaker AI si allontana da questo processo, che avviene automaticamente quando viene utilizzato uno strumento di stima. Sebbene non sia necessario utilizzare i container Docker in modo esplicito con SageMaker AI per la maggior parte dei casi d’uso, è possibile utilizzare i container Docker per estendere e personalizzare le funzionalità di SageMaker AI. **Container con Amazon SageMaker Studio Classic** Studio Classic viene eseguito da un container Docker e lo utilizza per gestire le funzionalità. Di conseguenza, è necessario creare il container Docker seguendo le fasi descritte in [Immagini personalizzate in Amazon SageMaker Studio Classic](studio-byoi.md). # Immagini Docker AI predefinite SageMaker Amazon SageMaker AI fornisce contenitori per i suoi algoritmi integrati e immagini Docker predefinite per alcuni dei framework di machine learning più comuni, come Apache MXNet, e Chainer. TensorFlow PyTorch Inoltre, supporta librerie di machine learning quali scikit-learn e SparkML. Puoi usare queste immagini dall'istanza del tuo notebook o da Studio. SageMaker SageMaker È inoltre possibile estendere le SageMaker immagini predefinite per includere le librerie e le funzionalità necessarie. Gli argomenti seguenti forniscono informazioni sulle immagini disponibili e su come usarle. Per il percorso del registro Docker e altri parametri per ciascuno degli algoritmi e dei Deep Learning Containers (DLC) forniti da Amazon SageMaker AI, consulta [Docker Registry Paths](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths) and Example Code. [Per informazioni sulle immagini Docker per lo sviluppo di soluzioni di reinforcement learning (RL) nell'intelligenza artificiale, consulta SageMaker AI RL Containers. SageMaker ](https://github.com/aws/sagemaker-rl-container) **Nota** Le immagini predefinite dei container sono di proprietà di SageMaker AI e in alcuni casi includono codice proprietario. Funzionalità come i processi di formazione ed elaborazione, la trasformazione in batch e l'inferenza in tempo reale utilizzano credenziali di proprietà del servizio per estrarre ed eseguire immagini su istanze di intelligenza artificiale gestite. SageMaker Poiché le credenziali del cliente non vengono utilizzate, le politiche AWS IAM (incluse le politiche di controllo dei servizi e le politiche di controllo delle risorse) che negano le autorizzazioni di Amazon ECR non impediscono l'uso di immagini predefinite. **Topics** + [Politica di supporto delle SageMaker immagini preconfigurata](pre-built-containers-support-policy.md) + [Immagini Docker SageMaker AI predefinite per il deep learning](pre-built-containers-frameworks-deep-learning.md) + [Accesso a immagini Docker per Scikit-learn e Spark ML](pre-built-docker-containers-scikit-learn-spark.md) + [Reti di grafici profonde](deep-graph-library.md) + [Estensione di un container predefinito](prebuilt-containers-extend.md) # Politica di supporto delle SageMaker immagini preconfigurata [Tutte le [ SageMaker immagini predefinite](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html), inclusi i contenitori specifici del framework, i contenitori di algoritmi integrati, gli algoritmi e i pacchetti di modelli elencati in e Deep Marketplace AWS Learning Containers vengono regolarmente scansionate per individuare le vulnerabilità comuni elencate dal Common [Vulnerabilities and Exposures (CVE) [AWS Program](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/what-is-dlc.html) e dal National Vulnerability Database (](https://www.cve.org/)NVD).](https://nvd.nist.gov/) Per ulteriori informazioni [su FAQs](https://www.cve.org/ResourcesSupport/FAQs), vedere Domande frequenti su CVE (). CVEs Le immagini dei container predefinite supportate ricevono una versione secondaria aggiornata dopo eventuali patch di sicurezza. Tutte le immagini dei container supportate vengono aggiornate regolarmente per risolvere eventuali criticità. CVEs Per scenari ad alta gravità, è consigliabile creare e ospitare una versione con patch del container nel proprio [Amazon Elastic Container Registry (Amazon ECR)](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html). Se utilizzi una versione dell’immagine di un container non più supportata, potresti non disporre dei driver, delle librerie e dei pacchetti pertinenti più aggiornati. Per un'altra up-to-date versione, ti consigliamo di eseguire l'aggiornamento a uno dei framework supportati disponibili utilizzando l'immagine più recente di tua scelta. SageMaker L'intelligenza artificiale non rilascia out-of-patch immagini per contenitori nuove. Regioni AWS **Nota** A partire da agosto 2024, il container `forecasting-deepar` non riceve più patch o aggiornamenti di sicurezza. Sebbene sia possibile continuare a utilizzare questo container, si corrono rischi aggiuntivi. I contenitori sono obsoleti quando l'intero framework o gli algoritmi non sono più supportati e il MXNet framework sottostante per il contenitore è stato raggiunto. end-of-maintenance **Topics** + [AWS Politica di supporto per Deep Learning Containers (DLC)](#pre-built-containers-support-policy-dlc) + [SageMaker Politica di supporto di AI ML Framework Container](#pre-built-containers-support-policy-ml-framework) + [SageMaker Politica di supporto del contenitore algoritmico integrato AI](#pre-built-containers-support-policy-built-in) + [Policy di supporto per container per hosting di LLM](#pre-built-containers-support-policy-llm-hosting) + [Container non supportati e obsolescenza](#pre-built-containers-support-policy-deprecation) ## AWS Politica di supporto per Deep Learning Containers (DLC) AWS I Deep Learning Containers sono un set di immagini Docker per addestrare e servire modelli di deep learning. Per visualizzare le immagini disponibili, consulta [Immagini dei Deep Learning Containers disponibili](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) nel GitHub repository Deep Learning Containers. DLCs hanno raggiunto la data di fine della patch 365 giorni dopo la data di GitHub rilascio. Gli aggiornamenti delle patch per non DLCs sono aggiornamenti «sul posto». È necessario eliminare l’immagine esistente sull’istanza e recuperare l’immagine del container più recente senza terminare l’istanza. Per ulteriori informazioni, consulta [Framework Support Policy](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html) in *AWS Deep Learning Containers Developer Guide*. Fai riferimento alla [tabella AWS Deep Learning Containers Framework Support Policy](https://aws.amazon.com/releasenotes/dlc-support-policy/) per verificare quali framework e versioni sono supportati attivamente. AWS DLCs È possibile fare riferimento al framework associato a un Container DL nella tabella della policy di supporto per tutte le immagini non elencate in modo esplicito. Ad esempio, puoi fare riferimento **PyTorch**nella tabella dei criteri di supporto per immagini DLC come e. `huggingface-pytorch-inference` `stabilityai-pytorch-inference` **Nota** Se un Container DL utilizza HuggingFace [Transformers](https://huggingface.co/docs/transformers/en/index) SDK, è supportata solo l’immagine con la versione più recente di Transformers. Per ulteriori informazioni, consulta **HuggingFace** per la Regione desiderata in [Percorsi del registro Docker e codice di esempio](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html). ## SageMaker Politica di supporto di AI ML Framework Container I contenitori SageMaker AI ML Framework sono un set di immagini Docker per addestrare e servire carichi di lavoro di machine learning con ambienti ottimizzati per framework comuni come XGBoost Scikit Learn. Per visualizzare i contenitori SageMaker AI ML Framework disponibili, consulta [Docker](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html) Registry Paths and Example Code. Vai alla AWS regione che preferisci e sfoglia le immagini con il tag **(algorithm)**. SageMaker I contenitori AI ML Framework aderiscono anche alla [politica di supporto del framework AWS Deep Learning Containers](https://docs.aws.amazon.com/deep-learning-containers/latest/devguide/support-policy.html). Per recuperare l'ultima versione dell'immagine per XGBoost 1.7-1 in modalità framework, usa i seguenti comandi SDK: SageMaker Python ``` from sagemaker import image_uris image_uris.retrieve(framework='xgboost',region='us-east-1',version='3.0-5') ``` | Framework | Versione corrente | GitHub GA | Fine della patch | | --- | --- | --- | --- | | XGBoost | 3,0-5 | 17/11/2025 | 17/11/2026 | | XGBoost | 1,7-1 | 03/06/2023 | 03/06/2025 | | XGBoost | 1,5-1 | 21/02/2022 | 21/02/2023 | | XGBoost | 1,3-1 | 21/05/2021 | 21/05/2022 | | XGBoost | 1,2-2 | 20/09/2020 | 20/09/2021 | | XGBoost | 1,2-1 | 19/07/2020 | 19/07/2021 | | XGBoost | 1,0-1 | >4 anni | Non supportata | | Scikit-Learn | 1,4-2 | 30/10/2025 | 30/10/2026 | | Scikit-Learn | 1,2-1 | 03/06/2023 | 03/06/2025 | | Scikit-Learn | 1,0-1 | 04/07/2022 | 04/07/2023 | | Scikit-Learn | 0,2341 | 06/03/2023 | 06/02/2021 | | Scikit-Learn | 0,20-1 | >4 anni | Non supportata | ## SageMaker Politica di supporto del contenitore algoritmico integrato AI Gli SageMaker AI Built-in Algorithm Containers sono un set di immagini Docker per l'addestramento e la gestione [degli algoritmi di machine learning integrati nell'SageMaker IA](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html). Per visualizzare i contenitori di algoritmi integrati SageMaker AI disponibili, consulta [Docker Registry Paths and](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html) Example Code. Vai alla AWS regione che preferisci e sfoglia le immagini con il tag **(algorithm)**. Gli aggiornamenti delle patch per le immagini dei container integrati sono aggiornamenti “in-place”. Per rimanere up-to-date aggiornato sulle ultime patch di sicurezza, ti consigliamo di controllare l'ultima versione dell'immagine dell'algoritmo integrato utilizzando il tag `latest` image. | Container di immagini | Fine della patch | | --- | --- | | `blazingtext:latest` | 15/05/2024 | | `factorization-machines:latest` | 15/05/2024 | | `forecasting-deepar:latest` | 26/08/2025 | | `image-classification:latest` | 15/05/2024 | | `instance-segmentation:latest` | 15/05/2024 | | `ipembeddings:latest` | 15/05/2024 | | `ipinsights:latest` | 15/05/2024 | | `kmeans:latest` | 15/05/2024 | | `knn:latest` | 15/05/2024 | | `linear-learner:inference-cpu-1/training-cpu-1` | 15/05/2024 | | `linear-learner:latest` | 15/05/2024 | | `mxnet-algorithms:training-cpu/inference-cpu` | 15/05/2024 | | `ntm:latest` | 15/05/2024 | | `object-detection:latest` | 15/05/2024 | | `object2vec:latest` | 15/05/2024 | | `pca:latest` | 15/05/2024 | | `randomcutforest:latest` | 15/05/2024 | | `semantic-segmentation:latest` | 15/05/2024 | | `seq2seq:latest` | 15/05/2024 | ## Policy di supporto per container per hosting di LLM I contenitori di [hosting LLM come i contenitori](https://github.com/awslabs/llm-hosting-container) HuggingFace Text Generation Inference (TGI) raggiungono la data di fine della patch 30 giorni dopo la data di rilascio. GitHub **Importante** È prevista un’eccezione in caso di aggiornamento a una versione principale. Ad esempio, se il toolkit HuggingFace Text Generation Inference (TGI) viene aggiornato a TGI 2.0, continuiamo a supportare la versione più recente di TGI 1.4 per un periodo di tre mesi dalla data di rilascio. GitHub | Container di Kit di strumenti | Versione corrente | GitHub GA | Fine della patch | | --- | --- | --- | --- | | TGI | tgi2.3.1 | 14/10/2024 | 14/11/2024 | | TGI | optimum0.0.25 | 10/04/2024 | 11/04/2024 | | TGI | tgi2.2.0 | 26/07/2024 | 30/08/2024 | | TGI | tgi2.0.0 | 15/05/2024 | 15/08/2024 | | TGI | tgi1.4.5 | 04/03/2024 | 07/03/2024 | | TGI | tgi1.4.2 | 02/22/2024 | 22/03/2024 | | TGI | tgi1.4.0 | 29/01/2024 | 29/02/2024 | | TGI | tgi1.3.3 | 19/12/2023 | 19/01/2024 | | TGI | tgi1.3.1 | 11/12/2023 | 01/11/2024 | | TGI | tgi1.2.0 | 12/04/2023 | 01/04/2024 | | TGI | optimum 0.0.24 | 23/08/2024 | 30/09/2024 | | TGI | optimum 0.0.23 | 26/07/2024 | 30/08/2024 | | TGI | optimum 0.0.21 | 10/05/2024 | 15/08/2024 | | TGI | optimum 0.0.19 | 19/02/2024 | 19/03/2024 | | TGI | optimum 0.0.18 | 02/01/2024 | 01/03/2024 | | TGI | optimum 0.0.17 | 24/01/2024 | 24/02/2024 | | TGI | optimum 0.0.16 | 18/01/2024 | 18/02/2024 | | TEI | tei1.4.0 | 08/01/2024 | 09/01/2024 | | TEI | tei1.2.3 | 26/04/2024 | 26/05/2024 | ## Container non supportati e obsolescenza Quando un container raggiunge la fine della patch o diventa obsoleto, non riceve più le patch di sicurezza. I container diventano obsoleti quando interi framework o algoritmi non sono più supportati. I seguenti container non ricevono più supporto: + A partire da agosto 2024, il `forecasting-deepar` container non riceverà più patch o aggiornamenti di sicurezza a causa del framework sottostante MXNet a cui il contenitore accede. end-of-maintenance + A partire da aprile 2024, i [contenitori SageMaker AI Reinforcement Learning (RL)](https://github.com/aws/sagemaker-rl-container) non sono più supportati. Per creare le tue immagini RL, consulta [Building Your Image](https://github.com/aws/sagemaker-rl-container#building-your-image) nel repository dei contenitori SageMaker GitHub AI RL. + A settembre 2023, i container JumpStart Industria: Financial non sono più supportati. # Immagini Docker SageMaker AI predefinite per il deep learning Amazon SageMaker AI fornisce immagini Docker predefinite che includono framework di deep learning e altre dipendenze necessarie per la formazione e l'inferenza. [Per un elenco completo delle immagini Docker predefinite gestite dall' SageMaker intelligenza artificiale, consulta Docker Registry Paths and Example Code.](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths.html) ## Utilizzo dell' SageMaker SDK AI Python Con [SageMaker Python SDK](https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk), puoi addestrare e distribuire modelli utilizzando questi popolari framework di deep learning. Per istruzioni sull'installazione e l'uso dell'SDK, consulta [https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk](https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk) SDK. [La tabella seguente elenca i framework disponibili e le istruzioni su come usarli con Python SageMaker SDK:](https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk) | Framework | Istruzioni | | --- | --- | | TensorFlow | [Utilizzo TensorFlow con SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/using_tf.html) | | MXNet | [Utilizzo MXNet con SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html) | | PyTorch | [Utilizzo PyTorch con SageMaker Python SDK](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html) | | Chainer | [Usare Chainer con Python SDK SageMaker ](https://sagemaker.readthedocs.io/en/stable/frameworks/chainer/using_chainer.html) | | Hugging Face | [Usare Hugging Face con Python SDK SageMaker ](https://sagemaker.readthedocs.io/en/stable/frameworks/huggingface/index.html) | ## Estensione delle immagini Docker AI predefinite SageMaker I container predefiniti possono essere personalizzati o estesi in base alle esigenze. Con questa personalizzazione, puoi gestire qualsiasi requisito funzionale aggiuntivo per il tuo algoritmo o modello che l'immagine Docker SageMaker AI precostruita non supporta. Per un esempio, consulta [Ottimizzazione e implementazione di un BERTopic modello sull' SageMaker intelligenza artificiale con script e set di dati personalizzati, estendendo i](https://sagemaker-examples.readthedocs.io/en/latest/advanced_functionality/pytorch_extend_container_train_deploy_bertopic/BERTtopic_extending_container.html) contenitori esistenti. PyTorch Puoi anche utilizzare contenitori predefiniti per distribuire modelli personalizzati o modelli che sono stati addestrati in un framework diverso dall'intelligenza artificiale. SageMaker Per una panoramica del processo, consulta [Bring Your Own Pretraining MXNet or TensorFlow Models in Amazon SageMaker](https://aws.amazon.com/blogs/machine-learning/bring-your-own-pre-trained-mxnet-or-tensorflow-models-into-amazon-sagemaker/). Questo tutorial spiega come trasferire gli artefatti del modello addestrato nell' SageMaker intelligenza artificiale e ospitarli su un endpoint. # Accesso a immagini Docker per Scikit-learn e Spark ML SageMaker L'intelligenza artificiale fornisce immagini Docker predefinite che installano le librerie scikit-learn e Spark ML. Queste librerie includono anche le dipendenze necessarie per creare immagini Docker compatibili con l' SageMaker intelligenza artificiale utilizzando l'SDK Amazon [Python SageMaker ](https://sagemaker.readthedocs.io/en/stable). L’SDK consente di utilizzare scikit-learn per le attività di machine learning e Spark ML per creare e ottimizzare le pipeline di machine learning. Per istruzioni sull'installazione e l'utilizzo dell'SDK, consulta [SageMaker Python SDK](https://github.com/aws/sagemaker-python-sdk#installing-the-sagemaker-python-sdk). Puoi anche accedere alle immagini da un repository Amazon ECR nel tuo ambiente. Utilizza i seguenti comandi per scoprire quali versioni delle immagini sono disponibili. Ad esempio, utilizza quanto segue per trovare l'immagine `sagemaker-sparkml-serving` disponibile nella Regione `ca-central-1`: ``` aws \ ecr describe-images \ --region ca-central-1 \ --registry-id 341280168497 \ --repository-name sagemaker-sparkml-serving ``` ## Accesso a un'immagine dall' SageMaker SDK AI Python La tabella seguente contiene i collegamenti ai GitHub repository con il codice sorgente per i contenitori scikit-learn e Spark ML. La tabella contiene anche link a istruzioni che mostrano come utilizzare questi container con gli strumenti di valutazione Python SDK per eseguire i propri algoritmi di addestramento e ospitare i propri modelli. | Libreria | Codice sorgente dell'immagine Docker predefinita | Istruzioni | | --- | --- | --- | | scikit-learn | [SageMaker Contenitori AI Scikit-learn](https://github.com/aws/sagemaker-scikit-learn-container) | [Usare Scikit-learn con l'SDK Amazon Python SageMaker ](https://sagemaker.readthedocs.io/en/stable/using_sklearn.html) | | Spark ML | [SageMaker Contenitori di servizio AI Spark ML](https://github.com/aws/sagemaker-sparkml-serving-container) | [Documentazione di SparkML Python SDK](https://sagemaker.readthedocs.io/en/stable/sagemaker.sparkml.html) | Per ulteriori informazioni e link ai repository github, consulta [Risorse per usare Scikit-learn con Amazon AI SageMaker](sklearn.md) e [Risorse per l'utilizzo di SparkML Serving con Amazon AI SageMaker](sparkml-serving.md). ## Specificazione manuale delle immagini predefinite Se non stai utilizzando SageMaker Python SDK e uno dei suoi estimatori per gestire il contenitore, devi recuperare manualmente il contenitore precostruito pertinente. Le immagini Docker predefinite SageMaker AI sono archiviate in Amazon Elastic Container Registry (Amazon ECR). Puoi inviarle o estrarle utilizzando i loro nomi completi, gli indirizzi di registro. SageMaker L'intelligenza artificiale utilizza i seguenti pattern di URL di Docker Image per scikit-learn e Spark ML: + `.dkr.ecr..amazonaws.com/sagemaker-scikit-learn:-cpu-py` Ad esempio, `746614075791.dkr.ecr.us-west-1.amazonaws.com/sagemaker-scikit-learn:1.2-1-cpu-py3` + `.dkr.ecr..amazonaws.com/sagemaker-sparkml-serving:` Ad esempio, `341280168497.dkr.ecr.ca-central-1.amazonaws.com/sagemaker-sparkml-serving:2.4` Per i nomi degli account IDs e delle AWS regioni, consulta [Docker](https://docs.aws.amazon.com/sagemaker/latest/dg-ecr-paths/sagemaker-algo-docker-registry-paths) Registry Paths and Example Code. # Reti di grafici profonde Le reti di grafici profonde si riferiscono a un tipo di rete neurale formata per risolvere i problemi dei grafici. Una rete di grafici profonda utilizza un framework di deep learning sottostante come PyTorch o MXNet. Il potenziale per le reti a grafi nelle applicazioni IA pratiche è evidenziato nei tutorial relativi ad Amazon SageMaker AI per [Deep Graph Library](https://www.dgl.ai/) (DGL). Esempi di modelli di addestramento sui set di dati grafici includono i social network, le basi di conoscenza, la biologia e la chimica. ![\[The Deep Graph Library (DGL) ecosystem.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/dgl_white_background_bold.png) *Figura 1. L'ecosistema DGL * Vengono forniti diversi esempi di utilizzo di container deep learning di Amazon SageMaker AI preconfigurati con DGL. Se si dispone di moduli speciali che si desidera utilizzare con DGL, è anche possibile creare il proprio container. Gli esempi riguardano eterografici, che sono grafici che hanno più tipi di nodi ed edge e si basano su una varietà di applicazioni in diversi campi scientifici, come la bioinformatica e l'analisi dei social network. DGL fornisce una vasta gamma di [implementazioni di rete neurale grafica per modelli di diversi tipi](https://docs.dgl.ai/tutorials/models/index.html). Alcuni dei punti salienti includono: + Rete convoluzionale di grafici (GCN) + Rete convoluzionale di grafici relazionali (R-GCN) + Rete di attenzione del grafico (GAT) + Modelli generativi profondi di grafici (DGMG) + Rete neurale dell'albero di giunzione (JTNN) # Guida introduttiva all’addestramento di una rete a grafi profonda DGL è disponibile come container di deep learning in Amazon ECR. È possibile selezionare container di deep learning quando si scrive la funzione dello strumento di valutazione in un notebook Amazon SageMaker. Puoi anche creare un container personalizzato con DGL seguendo la guida [Utilizza un container personalizzato](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms.html). Il metodo più semplice per prendere dimestichezza con una rete a grafi profonda consiste nell’utilizzare uno dei container DGL in Amazon Elastic Container Registry.  **Nota** Il supporto del framework di backend è limitato a PyTorch e MXNet. **Configurazione** Se stai utilizzando Amazon SageMaker Studio, devi prima clonare il repository degli esempi. Se stai utilizzando un’istanza del notebook, puoi trovare i relativi esempi scegliendo l’icona di SageMaker AI nella parte inferiore sinistra della barra degli strumenti. **Per clonare il repository degli esempi di notebook e l'SDK per Amazon SageMaker** 1. Dalla vista **JupyterLab** in Amazon SageMaker AI, accedi al **browser dei file** nella parte superiore sinistra della barra degli strumenti. Dal **riquadro del browser dei file** è possibile vedere una nuova navigazione nella parte superiore del pannello. 1. Scegliere l'icona all'estrema destra per clonare un repository Git. 1. Aggiungere l'URL del repository: [https://github.com/awslabs/amazon-sagemaker-examples.git](https://github.com/awslabs/amazon-sagemaker-examples.git) 1. Sfogliare la cartella appena aggiunta e il relativo contenuto. Gli esempi DGL sono memorizzati nella cartella **sagemaker-python-sdk**. **Addestramento** Una volta completata la configurazione, la rete a grafi profonda può essere addestrata. **Per addestrare una rete di grafici profonda** 1. Dalla vista **JupyterLab** in Amazon SageMaker AI, accedi ai [notebook di esempio](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/sagemaker-python-sdk) e cerca le cartelle DGL. File diversi possono essere inclusi per supportare un esempio. Esaminare il README per eventuali prerequisiti. 1. Eseguire l'esempio del notebook con estensione ipynb.  1. Trova la funzione dello strumento di valutazione e annota la riga in cui utilizza un container Amazon ECR per DGL e un tipo di istanza specifico. Potrebbe essere necessario aggiornare questo per utilizzare un container nella Regione preferita. 1. Eseguire la funzione per avviare l'istanza e utilizzare il container DGL per addestrare una rete di grafici. Vengono addebitati i costi per l'avvio di questa istanza. L'istanza si interrompe automaticamente quando l’addestramento è completato. Viene fornito un esempio di Knowledge Graph Embedding (KGE) in cui si utilizza il set di dati Freebase, una base di conoscenza di fatti generali. Un caso d'uso esemplificativo sarebbe quello di tracciare graficamente le relazioni delle persone e prevedere la loro nazionalità.  Un esempio di implementazione di una rete convoluzionale di grafici (GCN) mostra come è possibile addestrare una rete di grafici per prevedere la tossicità. Un set di dati di fisiologia, Tox21, fornisce misure di tossicità per il modo in cui le sostanze influenzano le risposte biologiche.  Un altro esempio di GCN mostra come addestrare una rete di grafici su un dataset bibliografico di pubblicazioni scientifiche, noto come Cora. È possibile utilizzarlo per trovare relazioni tra autori, argomenti e conferenze. L'ultimo esempio è un sistema di suggerimenti per le recensioni di film. Esso utilizza una rete di completamento della matrice convoluzionale dei grafici (GCMC) formata sui set di dati MovieLens. Questi set di dati sono costituiti da titoli di film, generi e classificazioni degli utenti. # Estensione di un container predefinito Se un contenitore SageMaker AI preconfigurato non soddisfa tutti i tuoi requisiti, puoi estendere l'immagine esistente per soddisfare le tue esigenze. Anche se è disponibile un supporto diretto per l'ambiente o il framework, è possibile aggiungere funzionalità aggiuntive o configurare l'ambiente del container in modo diverso. Estendendo un'immagine predefinita, è possibile sfruttare le librerie e le impostazioni di deep learning incluse senza dover creare un'immagine da zero. È possibile estendere il container per aggiungere librerie, modificare le impostazioni e installare dipendenze aggiuntive. Il seguente tutorial mostra come estendere un' SageMaker immagine predefinita e pubblicarla su Amazon ECR. **Topics** + [Requisiti per estendere un container predefinito](#prebuilt-containers-extend-required) + [Estendi i contenitori SageMaker AI per eseguire uno script Python](#prebuilt-containers-extend-tutorial) ## Requisiti per estendere un container predefinito Per estendere un' SageMaker immagine predefinita, devi impostare le seguenti variabili di ambiente all'interno del tuo Dockerfile. Per ulteriori informazioni sulle variabili di ambiente con i contenitori SageMaker AI, consulta il repository [SageMaker Training](https://github.com/aws/sagemaker-training-toolkit/blob/master/ENVIRONMENT_VARIABLES.md) Toolkit. GitHub + `SAGEMAKER_SUBMIT_DIRECTORY`: la directory all'interno del container in cui si trova lo script Python per l’addestramento. + `SAGEMAKER_PROGRAM`: lo script Python che dovrebbe essere invocato e usato come punto di ingresso per l'addestramento. È possibile anche installare librerie aggiuntive includendo quanto segue nel Dockerfile: ``` RUN pip install ``` Il tutorial seguente mostra l'utilizzo di queste variabili di ambiente. ## Estendi i contenitori SageMaker AI per eseguire uno script Python In questo tutorial, imparerai come estendere il PyTorch contenitore SageMaker AI con un file Python che utilizza il set di dati CIFAR-10. Estendendo il PyTorch contenitore SageMaker AI, utilizzi la soluzione di formazione esistente creata per funzionare con l'IA. SageMaker Questo tutorial estende un'immagine di addestramento, ma è possibile eseguire le stesse fasi per estendere un'immagine di inferenza. Per un elenco completo di immagini disponibili, consulta [Immagini dei container di deep learning disponibili](https://github.com/aws/deep-learning-containers/blob/master/available_images.md). Per eseguire il tuo modello di formazione utilizzando i contenitori SageMaker AI, crea un contenitore Docker tramite un' SageMaker istanza Notebook. ### Passaggio 1: creare un'istanza SageMaker Notebook 1. Apri la [console SageMaker AI](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**. 1. Nella pagina **Crea un ruolo IAM**, scegli **Specifica bucket S3**, specifica un bucket S3 Amazon denominato **sagemaker-run-script** e scegli **Crea ruolo**. SageMaker L'IA 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, separati da `T`. 1. Per **Accesso root**, seleziona **Abilitato**. 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. 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. ``` # SageMaker PyTorch image FROM 763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-training:1.5.1-cpu-py36-ubuntu16.04 ENV PATH="/opt/ml/code:${PATH}" # this environment variable is used by the SageMaker PyTorch container to determine our user code directory. ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code # /opt/ml and all subdirectories are utilized by SageMaker, use the /code subdirectory to store your user code. COPY cifar10.py /opt/ml/code/cifar10.py # Defines cifar10.py as script entrypoint ENV SAGEMAKER_PROGRAM cifar10.py ``` Lo script Dockerfile esegue le seguenti attività: + `FROM 763104351884.dkr.ecr.us-east-1.amazonaws.com/pytorch-training:1.5.1-cpu-py36-ubuntu16.04`— Scarica l'immagine di PyTorch base SageMaker AI. Puoi sostituirla con qualsiasi immagine di base SageMaker AI che desideri utilizzare per creare contenitori. + `ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code` – imposta `/opt/ml/code` come directory dello script di addestramento. + `COPY cifar10.py /opt/ml/code/cifar10.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 cifar10.py` – imposta lo script di addestramento `cifar10.py` come script del punto di ingresso. 1. Nel riquadro di navigazione a sinistra, il nome del file di testo viene automaticamente 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. Crea o carica uno script di addestramento `cifar10.py` in `docker_test_folder`. Puoi utilizzare il seguente script di esempio per questo esercizio. ``` import ast import argparse import logging import os import torch import torch.distributed as dist import torch.nn as nn import torch.nn.parallel import torch.optim import torch.utils.data import torch.utils.data.distributed import torchvision import torchvision.models import torchvision.transforms as transforms import torch.nn.functional as F logger=logging.getLogger(__name__) logger.setLevel(logging.DEBUG) classes=('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck') # https://github.com/pytorch/tutorials/blob/master/beginner_source/blitz/cifar10_tutorial.py#L118 class Net(nn.Module): def __init__(self): super(Net, self).__init__() self.conv1=nn.Conv2d(3, 6, 5) self.pool=nn.MaxPool2d(2, 2) self.conv2=nn.Conv2d(6, 16, 5) self.fc1=nn.Linear(16 * 5 * 5, 120) self.fc2=nn.Linear(120, 84) self.fc3=nn.Linear(84, 10) def forward(self, x): x=self.pool(F.relu(self.conv1(x))) x=self.pool(F.relu(self.conv2(x))) x=x.view(-1, 16 * 5 * 5) x=F.relu(self.fc1(x)) x=F.relu(self.fc2(x)) x=self.fc3(x) return x def _train(args): is_distributed=len(args.hosts) > 1 and args.dist_backend is not None logger.debug("Distributed training - {}".format(is_distributed)) if is_distributed: # Initialize the distributed environment. world_size=len(args.hosts) os.environ['WORLD_SIZE']=str(world_size) host_rank=args.hosts.index(args.current_host) dist.init_process_group(backend=args.dist_backend, rank=host_rank, world_size=world_size) logger.info( 'Initialized the distributed environment: \'{}\' backend on {} nodes. '.format( args.dist_backend, dist.get_world_size()) + 'Current host rank is {}. Using cuda: {}. Number of gpus: {}'.format( dist.get_rank(), torch.cuda.is_available(), args.num_gpus)) device='cuda' if torch.cuda.is_available() else 'cpu' logger.info("Device Type: {}".format(device)) logger.info("Loading Cifar10 dataset") transform=transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) trainset=torchvision.datasets.CIFAR10(root=args.data_dir, train=True, download=False, transform=transform) train_loader=torch.utils.data.DataLoader(trainset, batch_size=args.batch_size, shuffle=True, num_workers=args.workers) testset=torchvision.datasets.CIFAR10(root=args.data_dir, train=False, download=False, transform=transform) test_loader=torch.utils.data.DataLoader(testset, batch_size=args.batch_size, shuffle=False, num_workers=args.workers) logger.info("Model loaded") model=Net() if torch.cuda.device_count() > 1: logger.info("Gpu count: {}".format(torch.cuda.device_count())) model=nn.DataParallel(model) model=model.to(device) criterion=nn.CrossEntropyLoss().to(device) optimizer=torch.optim.SGD(model.parameters(), lr=args.lr, momentum=args.momentum) for epoch in range(0, args.epochs): running_loss=0.0 for i, data in enumerate(train_loader): # get the inputs inputs, labels=data inputs, labels=inputs.to(device), labels.to(device) # zero the parameter gradients optimizer.zero_grad() # forward + backward + optimize outputs=model(inputs) loss=criterion(outputs, labels) loss.backward() optimizer.step() # print statistics running_loss += loss.item() if i % 2000 == 1999: # print every 2000 mini-batches print('[%d, %5d] loss: %.3f' % (epoch + 1, i + 1, running_loss / 2000)) running_loss=0.0 print('Finished Training') return _save_model(model, args.model_dir) def _save_model(model, model_dir): logger.info("Saving the model.") path=os.path.join(model_dir, 'model.pth') # recommended way from http://pytorch.org/docs/master/notes/serialization.html torch.save(model.cpu().state_dict(), path) def model_fn(model_dir): logger.info('model_fn') device="cuda" if torch.cuda.is_available() else "cpu" model=Net() if torch.cuda.device_count() > 1: logger.info("Gpu count: {}".format(torch.cuda.device_count())) model=nn.DataParallel(model) with open(os.path.join(model_dir, 'model.pth'), 'rb') as f: model.load_state_dict(torch.load(f)) return model.to(device) if __name__ == '__main__': parser=argparse.ArgumentParser() parser.add_argument('--workers', type=int, default=2, metavar='W', help='number of data loading workers (default: 2)') parser.add_argument('--epochs', type=int, default=2, metavar='E', help='number of total epochs to run (default: 2)') parser.add_argument('--batch-size', type=int, default=4, metavar='BS', help='batch size (default: 4)') parser.add_argument('--lr', type=float, default=0.001, metavar='LR', help='initial learning rate (default: 0.001)') parser.add_argument('--momentum', type=float, default=0.9, metavar='M', help='momentum (default: 0.9)') parser.add_argument('--dist-backend', type=str, default='gloo', help='distributed backend (default: gloo)') # The parameters below retrieve their default values from SageMaker environment variables, which are # instantiated by the SageMaker containers framework. # https://github.com/aws/sagemaker-containers#how-a-script-is-executed-inside-the-container parser.add_argument('--hosts', type=str, default=ast.literal_eval(os.environ['SM_HOSTS'])) parser.add_argument('--current-host', type=str, default=os.environ['SM_CURRENT_HOST']) parser.add_argument('--model-dir', type=str, default=os.environ['SM_MODEL_DIR']) parser.add_argument('--data-dir', type=str, default=os.environ['SM_CHANNEL_TRAINING']) parser.add_argument('--num-gpus', type=int, default=os.environ['SM_NUM_GPUS']) _train(parser.parse_args()) ``` ### Fase 3: costruzione del container 1. Nella JupyterLab home directory, apri un notebook Jupyter. Per aprire un nuovo notebook, scegli l'icona **Nuovo avvio**, quindi scegli **conda\$1pytorch\$1p39** 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. Effettua il login a Docker per accedere al container di base: ``` ! aws ecr get-login-password --region us-east-1 | docker login --username AWS --password-stdin 763104351884.dkr.ecr.us-east-1.amazonaws.com ``` 1. Per compilare il container Docker, esegui il seguente comando di compilazione Docker, incluso lo spazio seguito da un punto finale: ``` ! docker build -t pytorch-extended-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 hai inserito un nome per il Dockerfile `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 seleziona **Notebook** nel framework **`conda_pytorch_p39`**. Il resto dei frammenti di codice deve essere eseguito dall'istanza del notebook Jupyter. 1. Scarica il set di dati CIFAR-10. ``` import torch import torchvision import torchvision.transforms as transforms def _get_transform(): return transforms.Compose( [transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]) def get_train_data_loader(data_dir='/tmp/pytorch/cifar-10-data'): transform=_get_transform() trainset=torchvision.datasets.CIFAR10(root=data_dir, train=True, download=True, transform=transform) return torch.utils.data.DataLoader(trainset, batch_size=4, shuffle=True, num_workers=2) def get_test_data_loader(data_dir='/tmp/pytorch/cifar-10-data'): transform=_get_transform() testset=torchvision.datasets.CIFAR10(root=data_dir, train=False, download=True, transform=transform) return torch.utils.data.DataLoader(testset, batch_size=4, shuffle=False, num_workers=2) trainloader=get_train_data_loader('/tmp/pytorch-example/cifar-10-data') testloader=get_test_data_loader('/tmp/pytorch-example/cifar-10-data') ``` 1. Imposta `role` sul ruolo utilizzato per creare il notebook Jupyter. Viene utilizzato per configurare AI Estimator. SageMaker ``` from sagemaker import get_execution_role role=get_execution_role() ``` 1. Incolla il seguente script di esempio nella cella di codice del notebook per configurare un SageMaker AI Estimator utilizzando il tuo contenitore esteso. ``` from sagemaker.estimator import Estimator hyperparameters={'epochs': 1} estimator=Estimator( image_uri='pytorch-extended-container-test', role=role, instance_count=1, instance_type='local', hyperparameters=hyperparameters ) estimator.fit('file:///tmp/pytorch-example/cifar-10-data') ``` 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 questo test in modalità locale, è possibile 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. Esegui le seguenti linee di comando in una cella del notebook. ``` %%sh # Specify an algorithm name algorithm_name=pytorch-extended-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) 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 # Log into Docker 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} ``` 1. Dopo aver inviato il container, puoi richiamare l'immagine Amazon ECR da qualsiasi punto dell'ambiente SageMaker AI. Esegui il seguente esempio di codice nella cella successiva del notebook. Se desideri utilizzare questo contenitore di formazione con SageMaker Studio per utilizzare le sue funzionalità di visualizzazione, puoi anche eseguire il codice seguente in una cella notebook Studio per richiamare l'immagine Amazon ECR del tuo contenitore di formazione. ``` import boto3 client=boto3.client('sts') account=client.get_caller_identity()['Account'] my_session=boto3.session.Session() region=my_session.region_name algorithm_name="pytorch-extended-container-test" ecr_image='{}.dkr.ecr.{}.amazonaws.com/{}:latest'.format(account, region, algorithm_name) ecr_image # This should return something like # 12-digits-of-your-account.dkr.ecr.us-east-2.amazonaws.com/tf-2.2-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 SageMaker stimatore AI. PyTorch ``` import sagemaker from sagemaker import get_execution_role from sagemaker.estimator import Estimator estimator=Estimator( image_uri=ecr_image, role=get_execution_role(), base_job_name='pytorch-extended-container-test', instance_count=1, instance_type='ml.p2.xlarge' ) # start training estimator.fit() # deploy the trained model predictor=estimator.deploy(1, instance_type) ``` ### Fase 6: eliminazione delle risorse **Per eliminare le risorse al termine dell'esempio sulle Nozioni di base** 1. **Apri la [console SageMaker AI](https://console.aws.amazon.com/sagemaker/), scegli l'istanza del notebook **RunScriptNotebookInstance**, 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. # Contenitori Docker personalizzati con intelligenza artificiale SageMaker Puoi adattare un'immagine Docker esistente per utilizzarla con l'intelligenza artificiale. SageMaker Potrebbe essere necessario utilizzare un'immagine Docker esterna esistente con SageMaker AI quando si dispone di un contenitore che soddisfa requisiti di funzionalità o sicurezza che attualmente non sono supportati da un'immagine AI predefinita. SageMaker Esistono due toolkit che ti consentono di portare il tuo contenitore e adattarlo per funzionare con l'intelligenza artificiale: SageMaker + [SageMaker Toolkit di formazione](https://github.com/aws/sagemaker-training-toolkit): utilizza questo toolkit per addestrare modelli con intelligenza artificiale. SageMaker + [SageMaker AI Inference Toolkit](https://github.com/aws/sagemaker-inference-toolkit): utilizza questo toolkit per implementare modelli con AI. SageMaker I seguenti argomenti mostrano come adattare l'immagine esistente utilizzando i toolkit SageMaker Training and Inference: **Topics** + [Librerie framework individuali](#docker-containers-adapt-your-own-frameworks) + [SageMaker Toolkit di formazione e inferenza](amazon-sagemaker-toolkits.md) + [Adattamento del container di addestramento](adapt-training-container.md) + [Adatta il tuo contenitore di inferenza per Amazon SageMaker AI](adapt-inference-container.md) ## Librerie framework individuali Oltre al SageMaker Training Toolkit e all' SageMaker AI Inference Toolkit, SageMaker AI fornisce anche toolkit specializzati per,, e Chainer. TensorFlow MXNet PyTorch La tabella seguente fornisce i collegamenti ai GitHub repository che contengono il codice sorgente per ogni framework e i rispettivi toolkit di servizio. Le istruzioni collegate riguardano l'utilizzo dell'SDK Python per eseguire algoritmi di addestramento e ospitare modelli sull'intelligenza artificiale. SageMaker La funzionalità di queste singole librerie è inclusa nell' SageMaker AI Training Toolkit e SageMaker nell'AI Inference Toolkit. | Framework | Codice sorgente toolkit | | --- | --- | | TensorFlow | [SageMaker Formazione sull'intelligenza artificiale TensorFlow ](https://github.com/aws/sagemaker-tensorflow-training-toolkit) [SageMaker TensorFlow Servizio basato sull'intelligenza artificiale](https://github.com/aws/sagemaker-tensorflow-serving-container) | | MXNet | [SageMaker MXNet Formazione sull'intelligenza artificiale](https://github.com/aws/sagemaker-mxnet-training-toolkit) [SageMaker MXNet Inferenza AI](https://github.com/aws/sagemaker-mxnet-inference-toolkit) | | PyTorch | [SageMaker Formazione sull'intelligenza artificiale PyTorch ](https://github.com/aws/sagemaker-pytorch-training-toolkit) [SageMaker PyTorch Inferenza AI](https://github.com/aws/sagemaker-pytorch-inference-toolkit) | | Chainer | [SageMaker Contenitori AI Chainer SageMaker AI](https://github.com/aws/sagemaker-chainer-container) | # SageMaker Toolkit di formazione e inferenza I toolkit [SageMaker Training](https://github.com/aws/sagemaker-training-toolkit) e [SageMaker AI Inference](https://github.com/aws/sagemaker-inference-toolkit) implementano le funzionalità necessarie per adattare i contenitori all'esecuzione di script, addestrare algoritmi e distribuire modelli sull'intelligenza artificiale. SageMaker Una volta installata, la libreria definisce quanto segue per gli utenti: + Le posizioni per l'archiviazione di codice e altre risorse. + Il punto di ingresso che contiene il codice da eseguire all'avvio del container. Il tuo Dockerfile deve copiare il codice che deve essere eseguito nella posizione prevista da un contenitore compatibile con l'intelligenza artificiale. SageMaker + Altre informazioni richieste da un container per gestire le distribuzioni per addestramento e inferenza. ## SageMaker Struttura dei contenitori di AI Toolkits Quando SageMaker AI addestra un modello, crea la seguente struttura di cartelle di file nella directory del `/opt/ml` contenitore. ``` /opt/ml ├── input │ ├── config │ │ ├── hyperparameters.json │ │ └── resourceConfig.json │ └── data │ └── │ └── ├── model │ ├── code │ ├── output │ └── failure ``` Quando si esegue un processo di *addestramento* dei modelli, il contenitore SageMaker AI utilizza la `/opt/ml/input/` directory, che contiene i file JSON che configurano gli iperparametri per l'algoritmo e il layout di rete utilizzato per l'addestramento distribuito. La `/opt/ml/input/` directory contiene anche file che specificano i canali attraverso i quali l' SageMaker IA accede ai dati, che sono archiviati in Amazon Simple Storage Service (Amazon S3). La libreria di contenitori SageMaker AI inserisce gli script che il contenitore eseguirà nella directory. `/opt/ml/code/` Lo script deve scrivere il modello generato dall'algoritmo nella directory `/opt/ml/model/`. Per ulteriori informazioni, consulta [Container con algoritmi di addestramento personalizzati](your-algorithms-training-algo.md). Quando *ospiti* un modello addestrato sull' SageMaker intelligenza artificiale per effettuare inferenze, distribuisci il modello su un endpoint HTTP. Il modello esegue previsioni in tempo reale in risposta a richieste di inferenza. Il container deve contenere uno stack di server per elaborare queste richieste. In un container di hosting o trasformazione in batch, i file del modello si trovano nella stessa cartella in cui sono stati scritti durante l’addestramento. ``` /opt/ml/model │ └── ``` Per ulteriori informazioni, consulta [Container con codice di inferenza personalizzato](your-algorithms-inference-main.md). ## Container singoli o multipli Puoi fornire immagini Docker separate per l'algoritmo di addestramento e il codice di inferenza oppure utilizzare una singola immagine Docker per entrambi. Quando crei immagini Docker da utilizzare con l' SageMaker intelligenza artificiale, considera quanto segue: + Fornire due immagini Docker può aumentare i requisiti di archivio e i costi, perché le librerie comuni possono essere duplicate. + In generale, i container più piccoli si avviano più rapidamente sia per l’addestramento sia per l'hosting. I modelli si preparano più rapidamente e il servizio di hosting può reagire a un aumento di traffico ridimensionandosi automaticamente in modo più rapido. + Potresti riuscire a scrivere un container di inferenza notevolmente inferiore al container di addestramento. Ciò è particolarmente comune quando si utilizza GPUs per la formazione, ma il codice di inferenza è ottimizzato per. CPUs + SageMaker L'intelligenza artificiale richiede che i contenitori Docker funzionino senza accesso privilegiato. + Sia i contenitori Docker che crei che quelli forniti dall' SageMaker IA possono inviare messaggi ai file and. `Stdout` `Stderr` SageMaker L'intelligenza artificiale invia questi messaggi ai CloudWatch log di Amazon nel tuo AWS account. Per ulteriori informazioni su come creare contenitori SageMaker AI e su come gli script vengono eseguiti al loro interno, consulta i repository [SageMaker AI Training Toolkit e [SageMaker AI Inference](https://github.com/aws/sagemaker-inference-toolkit) Toolkit](https://github.com/aws/sagemaker-training-toolkit) su. GitHub Forniscono inoltre elenchi di importanti variabili ambientali e delle variabili ambientali fornite dai contenitori AI. SageMaker # 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) # Adatta il tuo processo di addestramento per accedere alle immagini in un registro Docker privato Puoi utilizzare un [registro Docker](https://docs.docker.com/registry/) privato anziché un Amazon Elastic Container Registry (Amazon ECR) per ospitare le tue immagini per l'AI Training. SageMaker Le seguenti istruzioni mostrano come creare un registro Docker, configurare il cloud privato virtuale (VPC) e il processo di formazione, archiviare immagini e consentire all'IA di accedere all'immagine di formazione nel registro docker privato. SageMaker Queste istruzioni mostrano anche come utilizzare un registro Docker che richiede l'autenticazione per un processo di formazione. SageMaker ## Creazione e archiviazione di immagini in un registro Docker privato Creazione di un registro Docker privato per archiviare le immagini. Il registro deve: + utilizzare il protocollo del [Registro Docker HTTP API](https://docs.docker.com/registry/spec/api/) + essere accessibile dallo stesso VPC specificato nel [VpcConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)parametro nell'`CreateTrainingJob`API. Inserisci `VpcConfig` quando crei il processo di addestramento. + protetto con un [certificato TLS](https://aws.amazon.com/what-is/ssl-certificate/) rilasciato da un'autorità di certificazione pubblica nota. Per ulteriori informazioni sulla creazione di un registro Docker, consulta [Deploy a registry server](https://docs.docker.com/registry/deploying/). ## Configura il tuo VPC e SageMaker il tuo lavoro di formazione SageMaker L'intelligenza artificiale utilizza una connessione di rete all'interno del tuo VPC per accedere alle immagini nel tuo registro Docker. Per utilizzare le immagini del registro Docker per l’addestramento, il registro deve essere accessibile da un Amazon VPC del proprio account. Per ulteriori informazioni, consulta [Utilizzo di un registro Docker che richiede l'autenticazione per l’addestramento](docker-containers-adapt-your-own-private-registry-authentication.md). Devi inoltre configurare il processo di addestramento per connetterti allo stesso VPC a cui ha accesso il registro Docker. Per ulteriori informazioni, consulta [Configure a Training Job for Amazon VPC Access](https://docs.aws.amazon.com/sagemaker/latest/dg/train-vpc.html#train-vpc-configure). ## Creazione di un processo di addestramento utilizzando un'immagine dal registro Docker privato Per utilizzare un'immagine del registro Docker privato per l’addestramento, usa la seguente guida per configurare l'immagine, configurare e creare un processo di addestramento. Gli esempi di codice che seguono utilizzano il AWS SDK per Python (Boto3) client. 1. Crea un oggetto di configurazione dell'immagine di addestramento e inserisci `Vpc` il campo `TrainingRepositoryAccessMode` come segue. ``` training_image_config = { 'TrainingRepositoryAccessMode': 'Vpc' } ``` **Nota** Se il registro Docker privato richiede l'autenticazione, devi aggiungere un oggetto `TrainingRepositoryAuthConfig` all'oggetto di configurazione dell'immagine di addestramento. È inoltre necessario specificare l'Amazon Resource Name (ARN) di una AWS Lambda funzione che fornisce credenziali di accesso all' SageMaker IA utilizzando il `TrainingRepositoryCredentialsProviderArn` campo dell'oggetto. `TrainingRepositoryAuthConfig` Per ulteriori informazioni, consulta la struttura del codice di esempio qui di seguito. ``` training_image_config = { 'TrainingRepositoryAccessMode': 'Vpc', 'TrainingRepositoryAuthConfig': { 'TrainingRepositoryCredentialsProviderArn': 'arn:aws:lambda:Region:Acct:function:FunctionName' } } ``` Per informazioni su come creare la funzione Lambda per consentire l'autenticazione, consulta [Utilizzo di un registro Docker che richiede l'autenticazione per l’addestramento](docker-containers-adapt-your-own-private-registry-authentication.md). 1. Utilizzo di un client Boto3 per creare un processo di addestramento e inoltrare la configurazione corretta all'API [create\$1training\$1job](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html). Le seguenti istruzioni mostrano come configurare i componenti e creare un processo di addestramento. 1. Crea l’oggetto `AlgorithmSpecification` che desideri inoltrare a `create_training_job`. Utilizza l'oggetto di configurazione dell'immagine di addestramento creato nella fase precedente, come illustrato nell'esempio di codice seguente. ``` algorithm_specification = { 'TrainingImage': 'myteam.myorg.com/docker-local/my-training-image:', 'TrainingImageConfig': training_image_config, 'TrainingInputMode': 'File' } ``` **Nota** Per utilizzare una versione fissa, anziché aggiornata, di un'immagine, fai riferimento al [digest](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier) dell'immagine anziché al nome o al tag. 1. Specifica il nome del processo di addestramento e il ruolo che desideri inoltrare a `create_training_job`, come illustrato nell'esempio di codice seguente. ``` training_job_name = 'private-registry-job' execution_role_arn = 'arn:aws:iam::123456789012:role/SageMakerExecutionRole' ``` 1. Specifica un gruppo di sicurezza e una sottorete per la configurazione VPC per il processo di addestramento. Il registro Docker privato deve consentire il traffico in entrata proveniente dai gruppi di sicurezza specificati, come illustrato nel seguente esempio di codice. ``` vpc_config = { 'SecurityGroupIds': ['sg-0123456789abcdef0'], 'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1'] } ``` **Nota** Se la sottorete non si trova nello stesso VPC del registro Docker privato, è necessario configurare una connessione di rete tra i due. VPCs SeeConnect VPCs utilizzando il [peering VPC per ulteriori informazioni](https://docs.aws.amazon.com/vpc/latest/userguide/vpc-peering.html). 1. Specifica la configurazione delle risorse, incluse le istanze di calcolo di machine learning e i volumi di archiviazione da utilizzare per l’addestramento, come illustrato nel seguente esempio di codice. ``` resource_config = { 'InstanceType': 'ml.m4.xlarge', 'InstanceCount': 1, 'VolumeSizeInGB': 10, } ``` 1. Specifica la configurazione dei dati di input e output, dove è archiviato il set di dati di addestramento e dove desideri memorizzare gli artefatti del modello, come illustrato nel seguente esempio di codice. ``` input_data_config = [ { "ChannelName": "training", "DataSource": { "S3DataSource": { "S3DataDistributionType": "FullyReplicated", "S3DataType": "S3Prefix", "S3Uri": "s3://your-training-data-bucket/training-data-folder" } } } ] output_data_config = { 'S3OutputPath': 's3://your-output-data-bucket/model-folder' } ``` 1. Specifica il numero massimo di secondi in cui un processo di addestramento del modello può effettuare l’esecuzione come illustrato nel seguente esempio di codice. ``` stopping_condition = { 'MaxRuntimeInSeconds': 1800 } ``` 1. Infine, crea il processo di addestramento utilizzando i parametri specificati nella fase precedente, come illustrato nell'esempio di codice seguente. ``` import boto3 sm = boto3.client('sagemaker') try: resp = sm.create_training_job( TrainingJobName=training_job_name, AlgorithmSpecification=algorithm_specification, RoleArn=execution_role_arn, InputDataConfig=input_data_config, OutputDataConfig=output_data_config, ResourceConfig=resource_config, VpcConfig=vpc_config, StoppingCondition=stopping_condition ) except Exception as e: print(f'error calling CreateTrainingJob operation: {e}') else: print(resp) ``` # Usa uno stimatore di SageMaker intelligenza artificiale per eseguire un lavoro di formazione Puoi anche usare uno [stimatore](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) dell'SDK SageMaker Python per gestire la configurazione e l'esecuzione del tuo processo di SageMaker formazione. Gli esempi di codice seguenti mostrano come configurare ed eseguire uno strumento di valutazione utilizzando immagini da un registro Docker privato. 1. Importa le librerie e le dipendenze richieste, come mostrato nell'esempio di codice seguente. ``` import boto3 import sagemaker from sagemaker.estimator import Estimator session = sagemaker.Session() role = sagemaker.get_execution_role() ``` 1. Fornisci un URI (Uniform Resource Identifier) all'immagine di addestramento, ai gruppi di sicurezza e alle sottoreti per la configurazione VPC per il processo di addestramento, come mostrato nel seguente esempio di codice. ``` image_uri = "myteam.myorg.com/docker-local/my-training-image:" security_groups = ["sg-0123456789abcdef0"] subnets = ["subnet-0123456789abcdef0", "subnet-0123456789abcdef0"] ``` Per ulteriori informazioni su `security_group_ids` e`subnets`, consultate la descrizione dei parametri appropriata nella sezione [Estimators](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html) di SageMaker Python SDK. **Nota** SageMaker L'intelligenza artificiale utilizza una connessione di rete all'interno del tuo VPC per accedere alle immagini nel tuo registro Docker. Per utilizzare le immagini del registro Docker per l’addestramento, il registro deve essere accessibile da un Amazon VPC del proprio account. 1. Facoltativamente, se il registro Docker richiede l'autenticazione, devi anche specificare l'Amazon Resource Name (ARN) di una AWS Lambda funzione che fornisce le credenziali di accesso all'IA. SageMaker Il seguente esempio di codice mostra come specificare l’ARN. ``` training_repository_credentials_provider_arn = "arn:aws:lambda:us-west-2:1234567890:function:test" ``` Per ulteriori informazioni sull'utilizzo di immagini in un registro Docker che richiede l'autenticazione, consulta **Use a Docker registry that requires authentication for training** di seguito. 1. Usa gli esempi di codice delle fasi precedenti per configurare uno strumento di valutazione, come mostrato nel seguente esempio di codice. ``` # The training repository access mode must be 'Vpc' for private docker registry jobs training_repository_access_mode = "Vpc" # Specify the instance type, instance count you want to use instance_type="ml.m5.xlarge" instance_count=1 # Specify the maximum number of seconds that a model training job can run max_run_time = 1800 # Specify the output path for the model artifacts output_path = "s3://your-output-bucket/your-output-path" estimator = Estimator( image_uri=image_uri, role=role, subnets=subnets, security_group_ids=security_groups, training_repository_access_mode=training_repository_access_mode, training_repository_credentials_provider_arn=training_repository_credentials_provider_arn, # remove this line if auth is not needed instance_type=instance_type, instance_count=instance_count, output_path=output_path, max_run=max_run_time ) ``` 1. Avvia il processo di addestramento chiamando `estimator.fit` con il nome del processo e il percorso di input come parametri, come illustrato nel seguente esempio di codice. ``` input_path = "s3://your-input-bucket/your-input-path" job_name = "your-job-name" estimator.fit( inputs=input_path, job_name=job_name ) ``` # Utilizzo di un registro Docker che richiede l'autenticazione per l’addestramento Se il registro Docker richiede l'autenticazione, devi creare una AWS Lambda funzione che fornisca le credenziali di accesso all'IA. SageMaker Quindi, crea un processo di addestramento e inserisci l’ARN di questa funzione Lambda all’interno dell’API [create\$1training\$1job](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_training_job). Infine, è possibile facoltativamente creare un endpoint VPC di interfaccia in modo che il VPC possa comunicare con la propria funzione Lambda senza inviare traffico su Internet. La seguente guida mostra come creare una funzione Lambda, assegnarle il ruolo corretto e creare un endpoint VPC di interfaccia. ## Creazione della funzione Lambda Crea una AWS Lambda funzione che passi le credenziali di accesso all' SageMaker IA e restituisca una risposta. Il seguente esempio di codice crea il gestore di funzioni Lambda, come segue. ``` def handler(event, context): response = { "Credentials": {"Username": "username", "Password": "password"} } return response ``` Il tipo di autenticazione utilizzato per configurare il registro Docker privato determina il contenuto della risposta restituita dalla funzione Lambda come segue. + Se il registro Docker privato utilizza l'autenticazione di base, la funzione Lambda restituirà il nome utente e la password necessari per l'autenticazione nel registro. + Se il registro Docker privato utilizza [l'autenticazione con token bearer](https://docs.docker.com/registry/spec/auth/token/), il nome utente e la password vengono inviati al server di autorizzazione, che quindi restituisce un token bearer. Questo token viene quindi utilizzato per l'autenticazione nel registro Docker privato. **Nota** Se disponi di più di una funzione Lambda per i tuoi registri nello stesso account e il ruolo di esecuzione è lo stesso per i tuoi processi di addestramento, allora i processi di addestramento per il registro uno avranno accesso alle funzioni Lambda per gli altri registri. ## Concedi l'autorizzazione del ruolo corretto alla tua funzione Lambda [IAMrole](https://docs.aws.amazon.com/sagemaker/latest/dg/sagemaker-roles.html)Quello che usi nell'`create_training_job`API deve avere l'autorizzazione per chiamare una AWS Lambda funzione. L'esempio di codice seguente mostra come estendere la policy delle autorizzazioni di un ruolo IAM per chiamare `myLambdaFunction`. ``` { "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": [ "arn:aws:lambda:*:*:function:*myLambdaFunction*" ] } ``` Per ulteriori informazioni su come modificare la policy delle autorizzazioni di un ruolo, consulta [Modifying a role permission policy (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) nella *AWS Guida per l'utente di AWS Identity and Access Management*. **Nota** Un ruolo IAM con una policy **AmazonSageMakerFullAccess**gestita allegata è autorizzato a chiamare qualsiasi funzione Lambda con "SageMaker AI» nel nome. ## Creazione di un endpoint VPC di interfaccia per Lambda Se crei un endpoint di interfaccia, Amazon VPC può comunicare con la funzione Lambda senza inviare traffico su Internet. Per ulteriori informazioni, consulta [Configuring interface VPC endpoints for Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) nella *AWS Lambda Guida per gli sviluppatori*. Dopo aver creato l'endpoint dell'interfaccia, la SageMaker formazione richiamerà la funzione Lambda inviando una richiesta tramite il VPC a. `lambda.region.amazonaws.com` Se selezioni **Abilita nome DNS** quando crei l'endpoint di interfaccia, [Amazon Route 53](https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/Welcome.html) indirizza la chiamata all'endpoint dell'interfaccia Lambda. Se utilizzi un provider DNS diverso, devi mappare `lambda.region.amazonaws.co`, all'endpoint dell'interfaccia Lambda. # Adatta il tuo contenitore di inferenza per Amazon SageMaker AI Se non puoi utilizzare nessuna delle immagini elencate in [Immagini Docker AI predefinite SageMaker](docker-containers-prebuilt.md) Amazon SageMaker AI per il tuo caso d'uso, puoi creare il tuo contenitore Docker e utilizzarlo all'interno dell' SageMaker intelligenza artificiale per la formazione e l'inferenza. Per essere compatibile con l' SageMaker intelligenza artificiale, il contenitore deve avere le seguenti caratteristiche: + Il container deve avere un elenco di server web sulla porta `8080`. + Il container deve accettare richieste `POST` verso gli endpoint `/invocations` e `/ping` in tempo reale. Le richieste inviate a questi endpoint devono essere restituite entro 60 secondi per le risposte normali e 8 minuti per le risposte in streaming, nonché avere una dimensione massima di 25 MB. Per ulteriori informazioni e un esempio di come creare un contenitore Docker personalizzato per l'addestramento e l'inferenza con l' SageMaker intelligenza artificiale, vedi [Creazione di un contenitore di algoritmi personalizzato](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/scikit_bring_your_own/scikit_bring_your_own.ipynb). La seguente guida mostra come utilizzare uno `JupyterLab` spazio con Amazon SageMaker Studio Classic per adattare un contenitore di inferenza all'utilizzo dell'hosting SageMaker AI. L’esempio utilizza un server web NGINX, Gunicorn come interfaccia gateway per server Web Python e Flask come framework di applicazioni Web. È possibile utilizzare diverse applicazioni per adattare il container, a condizione che vengano soddisfatti i requisiti elencati in precedenza. Per ulteriori informazioni sull’uso del tuo codice di inferenza, consulta [Codice di inferenza personalizzato con servizi di hosting](your-algorithms-inference-code.md). **Adattare un container di inferenza** Utilizza i seguenti passaggi per adattare il tuo contenitore di inferenza all'utilizzo con l'hosting SageMaker AI. L’esempio mostrato nei passaggi seguenti utilizza un [modello NER (Named Entity Recognition)](https://spacy.io/universe/project/video-spacys-ner-model-alt) preaddestrato che utilizza la libreria [spaCy](https://spacy.io/) di elaborazione del linguaggio naturale (NLP) per `Python` e: + un Dockerfile per creare il container che contiene il modello NER; + script di inferenza per servire il modello NER. Adattando questo esempio al tuo caso d’uso, è necessario utilizzare un Dockerfile e gli script di inferenza necessari per implementare e gestire il modello. 1. Crea JupyterLab spazio con Amazon SageMaker Studio Classic (opzionale). Puoi usare qualsiasi notebook per eseguire script per adattare il tuo contenitore di inferenza all'hosting basato sull' SageMaker intelligenza artificiale. Questo esempio mostra come utilizzare uno JupyterLab spazio all'interno di Amazon SageMaker Studio Classic per avviare un'JupyterLabapplicazione dotata di un'immagine di distribuzione SageMaker AI. Per ulteriori informazioni, consulta [SageMaker JupyterLab](studio-updated-jl.md). 1. Carica un Dockerfile e script di inferenza. 1. Crea una nuova cartella nella directory home. Se utilizzi JupyterLab, nell’angolo in alto a sinistra, scegli l’icona **New Folder** e inserisci un nome di cartella per il tuo Dockerfile. Per questo esempio, la cartella è denominata `docker_test_folder`. 1. Carica un file di testo Dockerfile nella nuova cartella. Di seguito è riportato un Dockerfile di esempio che crea un container Docker con un [modello NER](https://spacy.io/universe/project/video-spacys-ner-model) preaddestrato di [spaCy](https://spacy.io/), le applicazioni e le variabili di ambiente necessarie per eseguire l’esempio: ``` FROM python:3.8 RUN apt-get -y update && apt-get install -y --no-install-recommends \ wget \ python3 \ nginx \ ca-certificates \ && rm -rf /var/lib/apt/lists/* RUN wget https://bootstrap.pypa.io/get-pip.py && python3 get-pip.py && \ pip install flask gevent gunicorn && \ rm -rf /root/.cache #pre-trained model package installation RUN pip install spacy RUN python -m spacy download en # Set environment variables ENV PYTHONUNBUFFERED=TRUE ENV PYTHONDONTWRITEBYTECODE=TRUE ENV PATH="/opt/program:${PATH}" COPY NER /opt/program WORKDIR /opt/program ``` Nell’esempio di codice precedente, la variabile di ambiente `PYTHONUNBUFFERED` impedisce il buffering del flusso di output standard da parte di Python, permettendo una consegna più rapida dei log all’utente. La variabile di ambiente `PYTHONDONTWRITEBYTECODE` impedisce la scrittura di file `.pyc` bytecode compilati da parte di Python, non necessari in questo caso d’uso. La variabile di ambiente `PATH` consente di identificare la posizione dei programmi `train` e `serve` quando viene invocato il container. 1. Crea una nuova directory all’interno della nuova cartella per contenere gli script di gestione del modello. Questo esempio utilizza una directory denominata `NER`, che contiene i seguenti script necessari per eseguire questo esempio: + `predictor.py` - Uno script Python contenente la logica per caricare ed eseguire l’inferenza con il modello. + `nginx.conf` - Uno script per configurare un server web. + `serve` - Uno script che avvia un server di inferenza. + `wsgi.py` - Uno script di assistenza per gestire un modello. **Importante** Copiando gli script di inferenza in un notebook che termina con `.ipynb` e rinominandoli, gli script potrebbero contenere caratteri di formattazione che impediscono l’implementazione dell’endpoint. Crea invece un file di testo e rinominalo. 1. Carica uno script per rendere il modello disponibile per l’inferenza. Di seguito è riportato uno script di esempio denominato `predictor.py` che utilizza Flask per fornire gli endpoint `/ping` e `/invocations`: ``` from flask import Flask import flask import spacy import os import json import logging #Load in model nlp = spacy.load('en_core_web_sm') #If you plan to use a your own model artifacts, #your model artifacts should be stored in /opt/ml/model/ # The flask app for serving predictions app = Flask(__name__) @app.route('/ping', methods=['GET']) def ping(): # Check if the classifier was loaded correctly health = nlp is not None status = 200 if health else 404 return flask.Response(response= '\n', status=status, mimetype='application/json') @app.route('/invocations', methods=['POST']) def transformation(): #Process input input_json = flask.request.get_json() resp = input_json['input'] #NER doc = nlp(resp) entities = [(X.text, X.label_) for X in doc.ents] # Transform predictions to JSON result = { 'output': entities } resultjson = json.dumps(result) return flask.Response(response=resultjson, status=200, mimetype='application/json') ``` L’endpoint `/ping` dell’esempio di script precedente restituisce un codice di stato `200` se il modello è stato caricato correttamente o `404` se il modello è stato caricato in modo errato. L’endpoint `/invocations` elabora una richiesta formattata in JSON, estrae il campo di input e utilizza il modello NER per identificare e archiviare entità nelle entità variabili. L’applicazione Flask restituisce la risposta che contiene queste entità. Per ulteriori informazioni su tali richieste di integrità necessarie, consulta [Come il tuo container deve rispondere alle richieste di controllo dello stato (Ping)](your-algorithms-inference-code.md#your-algorithms-inference-algo-ping-requests). 1. Carica uno script per avviare un server di inferenza. Il seguente esempio di script chiama `serve` utilizzando Gunicorn come server delle applicazioni e Nginx come server web: ``` #!/usr/bin/env python # This file implements the scoring service shell. You don't necessarily need to modify it for various # algorithms. It starts nginx and gunicorn with the correct configurations and then simply waits until # gunicorn exits. # # The flask server is specified to be the app object in wsgi.py # # We set the following parameters: # # Parameter Environment Variable Default Value # --------- -------------------- ------------- # number of workers MODEL_SERVER_WORKERS the number of CPU cores # timeout MODEL_SERVER_TIMEOUT 60 seconds import multiprocessing import os import signal import subprocess import sys cpu_count = multiprocessing.cpu_count() model_server_timeout = os.environ.get('MODEL_SERVER_TIMEOUT', 60) model_server_workers = int(os.environ.get('MODEL_SERVER_WORKERS', cpu_count)) def sigterm_handler(nginx_pid, gunicorn_pid): try: os.kill(nginx_pid, signal.SIGQUIT) except OSError: pass try: os.kill(gunicorn_pid, signal.SIGTERM) except OSError: pass sys.exit(0) def start_server(): print('Starting the inference server with {} workers.'.format(model_server_workers)) # link the log streams to stdout/err so they will be logged to the container logs subprocess.check_call(['ln', '-sf', '/dev/stdout', '/var/log/nginx/access.log']) subprocess.check_call(['ln', '-sf', '/dev/stderr', '/var/log/nginx/error.log']) nginx = subprocess.Popen(['nginx', '-c', '/opt/program/nginx.conf']) gunicorn = subprocess.Popen(['gunicorn', '--timeout', str(model_server_timeout), '-k', 'sync', '-b', 'unix:/tmp/gunicorn.sock', '-w', str(model_server_workers), 'wsgi:app']) signal.signal(signal.SIGTERM, lambda a, b: sigterm_handler(nginx.pid, gunicorn.pid)) # Exit the inference server upon exit of either subprocess pids = set([nginx.pid, gunicorn.pid]) while True: pid, _ = os.wait() if pid in pids: break sigterm_handler(nginx.pid, gunicorn.pid) print('Inference server exiting') # The main routine to invoke the start function. if __name__ == '__main__': start_server() ``` L’esempio di script precedente definisce una funzione di gestore di segnale denominata `sigterm_handler`, che arresta i sottoprocessi Nginx e Gunicorn quando riceve un segnale `SIGTERM`. Una funzione `start_server` avvia il gestore di segnale, monitora i sottoprocessi Nginx e Gunicorn e acquisisce flussi di log. 1. Carica uno script per configurare il server web. Il seguente esempio di script, denominato `nginx.conf`, configura un server web Nginx utilizzando Gunicorn come server di applicazioni per gestire il modello per l’inferenza: ``` worker_processes 1; daemon off; # Prevent forking pid /tmp/nginx.pid; error_log /var/log/nginx/error.log; events { # defaults } http { include /etc/nginx/mime.types; default_type application/octet-stream; access_log /var/log/nginx/access.log combined; upstream gunicorn { server unix:/tmp/gunicorn.sock; } server { listen 8080 deferred; client_max_body_size 5m; keepalive_timeout 5; proxy_read_timeout 1200s; location ~ ^/(ping|invocations) { proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for; proxy_set_header Host $http_host; proxy_redirect off; proxy_pass http://gunicorn; } location / { return 404 "{}"; } } } ``` L’esempio di script precedente configura Nginx per l’esecuzione in primo piano, imposta la posizione in cui acquisire il file `error_log` e definisce `upstream` come socket sock del server Gunicorn. Il server configura il blocco server per l’ascolto sulla porta `8080` e imposta limiti alla dimensione del corpo della richiesta del client e ai valori di timeout. Il blocco server inoltra le richieste contenenti uno dei due percorsi `/ping` o `/invocations` a Gunicorn, all’indirizzo del `server http://gunicorn`, e restituisce un errore `404` per gli altri percorsi. 1. Carica tutti gli altri script necessari per gestire il tuo modello. Questo esempio richiede il seguente script di esempio denominato `wsgi.py` per consentire a Gunicorn di individuare la tua applicazione: ``` import predictor as myapp # This is just a simple wrapper for gunicorn to find your app. # If you want to change the algorithm file, simply change "predictor" above to the # new file. app = myapp.app ``` Dalla cartella `docker_test_folder`, la struttura di directory deve contenere un Dockerfile e la cartella NER. La cartella NER deve contenere i file `nginx.conf`, `predictor.py`, `serve` e `wsgi.py`, come illustrato di seguito: ![\[The Dockerfile structure has inference scripts under the NER directory next to the Dockerfile.\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/images/docker-file-struct-adapt-ex.png) 1. Crea il tuo container. Dalla cartella `docker_test_folder`, crea il tuo container Docker. Il seguente comando di esempio crea il container Docker configurato nel tuo Dockerfile: ``` ! docker build -t byo-container-test . ``` Il comando precedente crea un container denominato `byo-container-test` nella directory di lavoro corrente. Per ulteriori informazioni sui parametri di generazione di Docker, consulta [Build variables](https://docs.docker.com/build/guide/build-args/). **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_test_folder/Dockerfile: no such file or directory ``` 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 hai denominato il Dockerfile Dockerfile-text.txt, crea il container Docker utilizzando il flag `-f` seguito dal file, come illustrato di seguito: ``` ! docker build -t byo-container-test -f Dockerfile-text.txt . ``` 1. Invia l’immagine Docker a un registro Amazon Elastic Container Registry (Amazon ECR). Nella cella di un notebook, invia l’immagine Docker a un registro ECR. Il seguente esempio di codice mostra come creare il container localmente, eseguire l’accesso e inviarlo a un registro ECR: ``` %%sh # Name of algo -> ECR algorithm_name=sm-pretrained-spacy #make serve executable chmod +x NER/serve account=$(aws sts get-caller-identity --query Account --output text) # Region, defaults to us-west-2 region=$(aws configure get region) region=${region:-us-east-1} 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/nullfi # 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} ``` Nell’esempio precedente viene illustrato come eseguire i seguenti passaggi necessari per inviare il container Docker di esempio a un registro ECR: 1. Definire il nome dell’algoritmo come `sm-pretrained-spacy`. 1. Rendere eseguibile il file `serve` all’interno della cartella NER. 1. Imposta il Regione AWS. 1. Creare un registro ECR, se non esiste già. 1. Accedere al registro ECR. 1. Creare il container Docker in locale. 1. Inviare l’immagine Docker al registro ECR. 1. Configura il client SageMaker AI Se desideri utilizzare i servizi di hosting SageMaker AI per l'inferenza, devi [creare un modello, creare una](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_model.html) [configurazione dell'endpoint e [creare](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint.html#) un endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker/client/create_endpoint_config.html#). Per ottenere inferenze dal tuo endpoint, puoi utilizzare il client SageMaker AI boto3 Runtime per richiamare il tuo endpoint. [Il codice seguente mostra come configurare sia il client AI che il client SageMaker Runtime utilizzando il SageMaker client SageMaker AI boto3:](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html) ``` import boto3 from sagemaker import get_execution_role sm_client = boto3.client(service_name='sagemaker') runtime_sm_client = boto3.client(service_name='sagemaker-runtime') account_id = boto3.client('sts').get_caller_identity()['Account'] region = boto3.Session().region_name #used to store model artifacts which SageMaker AI will extract to /opt/ml/model in the container, #in this example case we will not be making use of S3 to store the model artifacts #s3_bucket = '' role = get_execution_role() ``` Nell’esempio di codice precedente, il bucket Amazon S3 non viene utilizzato, ma inserito come commento per mostrare come archiviare gli artefatti del modello. Se ricevi un errore di autorizzazione dopo aver eseguito l’esempio di codice precedente, potresti dover aggiungere autorizzazioni al tuo ruolo IAM. Per ulteriori informazioni sui ruoli IAM, consultare [Gestore SageMaker ruoli Amazon](role-manager.md). Per ulteriori informazioni sull’aggiunta di autorizzazioni al ruolo corrente, consulta [AWS politiche gestite per Amazon SageMaker AI](security-iam-awsmanpol.md). 1. Crea il tuo modello. Se desideri utilizzare i servizi di hosting SageMaker AI per l'inferenza, devi creare un modello in AI. SageMaker Il seguente esempio di codice mostra come creare il spaCy NER modello all'interno dell' SageMaker IA: ``` from time import gmtime, strftime model_name = 'spacy-nermodel-' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) # MODEL S3 URL containing model atrifacts as either model.tar.gz or extracted artifacts. # Here we are not #model_url = 's3://{}/spacy/'.format(s3_bucket) container = '{}.dkr.ecr.{}.amazonaws.com/sm-pretrained-spacy:latest'.format(account_id, region) instance_type = 'ml.c5d.18xlarge' print('Model name: ' + model_name) #print('Model data Url: ' + model_url) print('Container image: ' + container) container = { 'Image': container } create_model_response = sm_client.create_model( ModelName = model_name, ExecutionRoleArn = role, Containers = [container]) print("Model Arn: " + create_model_response['ModelArn']) ``` L’esempio di codice precedente mostra come definire una variabile `model_url` mediante `s3_bucket`, in caso di utilizzo del bucket Amazon S3 come indicato nei commenti alla fase 5, e definisce l’URI ECR per l’immagine del container. Gli esempi di codice precedenti definiscono `ml.c5d.18xlarge` come tipo di istanza. È anche possibile scegliere un tipo di istanza diverso. Per ulteriori informazioni sui tipi di istanza disponibili, consulta [Tipi di istanze Amazon EC2](https://aws.amazon.com/ec2/instance-types/). Nell’esempio di codice precedente, la chiave `Image` punta all’URI dell’immagine del container. La definizione `create_model_response` utilizza il `create_model method` per creare un modello e restituire il nome del modello, il ruolo e un elenco contenente le informazioni sul container. Segue un esempio di output dello script precedente: ``` Model name: spacy-nermodel-YYYY-MM-DD-HH-MM-SS Model data Url: s3://spacy-sagemaker-us-east-1-bucket/spacy/ Container image: 123456789012.dkr.ecr.us-east-2.amazonaws.com/sm-pretrained-spacy:latest Model Arn: arn:aws:sagemaker:us-east-2:123456789012:model/spacy-nermodel-YYYY-MM-DD-HH-MM-SS ``` 1. 1. **Configura e crea un endpoint** Per utilizzare l'hosting SageMaker AI per l'inferenza, devi anche configurare e creare un endpoint. SageMaker L'intelligenza artificiale utilizzerà questo endpoint per l'inferenza. Il seguente esempio di configurazione mostra come generare e configurare un endpoint con il tipo di istanza e il nome di modello definiti in precedenza: ``` endpoint_config_name = 'spacy-ner-config' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) print('Endpoint config name: ' + endpoint_config_name) create_endpoint_config_response = sm_client.create_endpoint_config( EndpointConfigName = endpoint_config_name, ProductionVariants=[{ 'InstanceType': instance_type, 'InitialInstanceCount': 1, 'InitialVariantWeight': 1, 'ModelName': model_name, 'VariantName': 'AllTraffic'}]) print("Endpoint config Arn: " + create_endpoint_config_response['EndpointConfigArn']) ``` Nell’esempio di configurazione precedente, `create_endpoint_config_response` associa `model_name` a un nome di configurazione dell’endpoint univoco, `endpoint_config_name`, creato con un timestamp. Segue un esempio di output dello script precedente: ``` Endpoint config name: spacy-ner-configYYYY-MM-DD-HH-MM-SS Endpoint config Arn: arn:aws:sagemaker:us-east-2:123456789012:endpoint-config/spacy-ner-config-MM-DD-HH-MM-SS ``` Per ulteriori informazioni sugli errori degli endpoint, consulta [Perché il mio endpoint Amazon SageMaker AI entra nello stato di errore quando creo o aggiorno un](https://repost.aws/knowledge-center/sagemaker-endpoint-creation-fail) endpoint? 1. **Crea un endpoint e attendi che sia attivo.** Il seguente esempio di codice crea l’endpoint utilizzando la configurazione dell’esempio di configurazione precedente e implementa il modello: ``` %%time import time endpoint_name = 'spacy-ner-endpoint' + strftime("%Y-%m-%d-%H-%M-%S", gmtime()) print('Endpoint name: ' + endpoint_name) create_endpoint_response = sm_client.create_endpoint( EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name) print('Endpoint Arn: ' + create_endpoint_response['EndpointArn']) resp = sm_client.describe_endpoint(EndpointName=endpoint_name) status = resp['EndpointStatus'] print("Endpoint Status: " + status) print('Waiting for {} endpoint to be in service...'.format(endpoint_name)) waiter = sm_client.get_waiter('endpoint_in_service') waiter.wait(EndpointName=endpoint_name) ``` Nell’esempio di codice precedente, il metodo `create_endpoint` crea l’endpoint con il nome dell’endpoint generato creato nell’esempio di codice precedente e visualizza il nome della risorsa Amazon (ARN) dell’endpoint. Il metodo `describe_endpoint` restituisce informazioni sull’endpoint e sul relativo stato. Un cameriere dotato di SageMaker intelligenza artificiale attende che l'endpoint sia in servizio. 1. Testa l’endpoint. Una volta che l’endpoint è attivo, invia una [richiesta di invocazione](https://boto3.amazonaws.com/v1/documentation/api/1.9.42/reference/services/sagemaker-runtime.html#SageMakerRuntime.Client.invoke_endpoint) all’endpoint. L’esempio di codice seguente mostra come inviare una richiesta di test all’endpoint: ``` import json content_type = "application/json" request_body = {"input": "This is a test with NER in America with \ Amazon and Microsoft in Seattle, writing random stuff."} #Serialize data for endpoint #data = json.loads(json.dumps(request_body)) payload = json.dumps(request_body) #Endpoint invocation response = runtime_sm_client.invoke_endpoint( EndpointName=endpoint_name, ContentType=content_type, Body=payload) #Parse results result = json.loads(response['Body'].read().decode())['output'] result ``` Nell’esempio di codice precedente, il metodo `json.dumps` serializza `request_body` in una stringa formattata in JSON e la salva nella variabile payload. Quindi il client SageMaker AI Runtime utilizza il metodo [invoke endpoint per inviare il payload](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker-runtime/client/invoke_endpoint.html) all'endpoint. Il risultato contiene la risposta dell’endpoint dopo l’estrazione del campo di output. L’esempio di codice precedente deve restituire l’output seguente: ``` [['NER', 'ORG'], ['America', 'GPE'], ['Amazon', 'ORG'], ['Microsoft', 'ORG'], ['Seattle', 'GPE']] ``` 1. Elimina l’endpoint. Dopo aver completato le invocazioni, elimina l’endpoint per risparmiare risorse. L’esempio di codice seguente mostra come eliminare l’endpoint: ``` sm_client.delete_endpoint(EndpointName=endpoint_name) sm_client.delete_endpoint_config(EndpointConfigName=endpoint_config_name) sm_client.delete_model(ModelName=model_name) ``` Per un notebook completo contenente il codice in questo esempio, consulta [BYOC-Single-Model](https://github.com/aws-samples/sagemaker-hosting/tree/main/Bring-Your-Own-Container/BYOC-Single-Model). # Creazione di un container con algoritmi e modelli personalizzati Se nessuno dei contenitori SageMaker AI esistenti soddisfa le tue esigenze e non disponi di un contenitore esistente, potresti dover creare un nuovo contenitore Docker. Le sezioni seguenti mostrano come creare contenitori Docker con i tuoi algoritmi di addestramento e inferenza da utilizzare con l'intelligenza artificiale. SageMaker **Topics** + [Container con algoritmi di addestramento personalizzati](your-algorithms-training-algo.md) + [Container con codice di inferenza personalizzato](your-algorithms-inference-main.md) # Container con algoritmi di addestramento personalizzati Questa sezione spiega come Amazon SageMaker AI interagisce con un contenitore Docker che esegue il tuo algoritmo di addestramento personalizzato. Utilizza queste informazioni per scrivere codice di addestramento e creare un'immagine Docker per i tuoi algoritmi di addestramento. **Topics** + [In che modo Amazon SageMaker AI gestisce la tua immagine di formazione](your-algorithms-training-algo-dockerfile.md) + [In che modo Amazon SageMaker AI fornisce informazioni sulla formazione](your-algorithms-training-algo-running-container.md) + [Esecuzione di un addestramento con EFA](your-algorithms-training-efa.md) + [In che modo Amazon SageMaker AI segnala il successo e il fallimento di un algoritmo](your-algorithms-training-signal-success-failure.md) + [In che modo Amazon SageMaker AI elabora i risultati della formazione](your-algorithms-training-algo-output.md) # In che modo Amazon SageMaker AI gestisce la tua immagine di formazione Puoi utilizzare uno script del punto di ingresso personalizzato per automatizzare l'infrastruttura per l'addestramento in un ambiente di produzione. Se passi lo script entrypoint nel contenitore Docker, puoi anche eseguirlo come script autonomo senza ricostruire le immagini. SageMaker L'intelligenza artificiale elabora l'immagine di allenamento utilizzando uno script entrypoint del contenitore Docker. In questa sezione viene descritto come utilizzare un punto di ingresso personalizzato senza utilizzare il toolkit. [Se desideri utilizzare un punto di ingresso personalizzato ma non hai familiarità con la configurazione manuale di un contenitore Docker, ti consigliamo di utilizzare invece la libreria di strumenti di formazione. SageMaker ](https://github.com/aws/sagemaker-training-toolkit) Per ulteriori informazioni su come utilizzare il toolkit di addestramento, consulta [Adattamento del container di addestramento](adapt-training-container.md). Per impostazione predefinita, l' SageMaker intelligenza artificiale cerca uno script chiamato all'interno del contenitore. `train` Puoi anche fornire manualmente il tuo punto di ingresso personalizzato utilizzando i `ContainerEntrypoint` parametri `ContainerArguments` e dell'[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)API. Sono disponibili le due opzioni seguenti per configurare manualmente il container Docker per l'esecuzione della tua immagine. + Utilizza l'[CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API e un contenitore Docker con un'istruzione entrypoint contenuta al suo interno. + Usa l'API `CreateTrainingJob` e trasmetti lo script di addestramento dall'esterno del tuo container Docker. Se inoltri lo script di addestramento dall'esterno del tuo container Docker, non devi ricostruire il container Docker quando aggiorni lo script. Puoi anche utilizzare diversi script da eseguire nello stesso container. Lo script del punto di ingresso deve contenere il codice di addestramento per l'immagine. Se utilizzi il parametro opzionale `source_dir` all'interno di uno [strumento di valutazione](https://sagemaker.readthedocs.io/en/stable/api/training/estimators.html), dovrebbe fare riferimento al percorso Amazon S3 relativo alla cartella contenente lo script del punto di ingresso. Puoi fare riferimento a più file utilizzando il parametro `source_dir`. Se non utilizzi `source_dir`, puoi specificare il punto di ingresso utilizzando il parametro `entry_point`. Per un esempio di script entrypoint personalizzato che contiene uno stimatore, consulta [Bring Your Own](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-script-mode/sagemaker-script-mode.html) Model with AI Script Model. SageMaker SageMaker L'addestramento sui modelli AI supporta i bucket di directory S3 Express One Zone ad alte prestazioni come posizione di input dei dati per la modalità file, la modalità file veloce e la modalità pipe. È anche possibile utilizzare i bucket di directory S3 Express One Zone per archiviare l’output dell’addestramento. Per utilizzare S3 Express One Zone, fornisci l’URI di un bucket di directory S3 Express One Zone anziché di un bucket Amazon S3 per uso generico. Puoi crittografare i dati di output SageMaker AI solo in bucket di directory con crittografia lato server con chiavi gestite di Amazon S3 (SSE-S3). La crittografia lato server con AWS KMS chiavi (SSE-KMS) non è attualmente supportata per l'archiviazione dei dati di output AI nei bucket di directory. SageMaker Per ulteriori informazioni, consulta [S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html). ## Esecuzione di un processo di addestramento con uno script del punto di ingresso incluso nel container Docker SageMaker L'intelligenza artificiale può eseguire uno script di ingresso incluso nel contenitore Docker. + Per impostazione predefinita, Amazon SageMaker AI esegue il seguente contenitore. ``` docker run image train ``` + SageMaker L'intelligenza artificiale sostituisce qualsiasi istruzione [CMD](https://docs.docker.com/engine/reference/builder/#cmd) predefinita in un contenitore specificando l'`train`argomento dopo il nome dell'immagine. Nel tuo container Docker, usa il seguente modulo `exec` dell'istruzione `ENTRYPOINT`. ``` ENTRYPOINT ["executable", "param1", "param2", ...] ``` L'esempio seguente illustra come specificare un'istruzione di punto di ingresso python chiamata `k-means-algorithm.py`. ``` ENTRYPOINT ["python", "k-means-algorithm.py"] ``` Il modulo `exec` dell'istruzione `ENTRYPOINT` avvia l'eseguibile direttamente, non come figlio di `/bin/sh`. Ciò gli consente di ricevere segnali simili e provenienti da. `SIGTERM` `SIGKILL` SageMaker APIs Le seguenti condizioni si applicano quando si utilizza il SageMaker APIs. + L'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)API presenta una condizione di arresto che impone all' SageMaker IA di interrompere l'addestramento dei modelli dopo un periodo di tempo specifico. + Quanto segue mostra l’API [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_StopTrainingJob.html). Questo API rilascia l'equivalente del comando `docker stop`, con un timeout di due minuti, per arrestare in modo normale il container specificato. ``` docker stop -t 120 ``` Il comando tenta di arrestare il container in esecuzione inviando un segnale `SIGTERM`. Dopo il timeout di 2 minuti, l'API invia `SIGKILL` e blocca forzatamente i container. Se il container gestisce il segnale `SIGTERM` normalmente ed esce entro 120 secondi dalla ricezione, non viene inviato alcun segnale `SIGKILL`. Se desideri accedere agli artefatti intermedi del modello dopo che l' SageMaker IA ha interrotto l'addestramento, aggiungi il codice per gestire il salvataggio degli artefatti nel tuo gestore. `SIGTERM` + Se prevedi di utilizzare i dispositivi GPU per l’addestramento del modello, assicurati che i tuoi container siano compatibili con `nvidia-docker`. Includi soltanto il tooklit CUDA sui container; non raggruppare i driver NVIDIA con l'immagine. Per ulteriori informazioni su `nvidia-docker`, consulta [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker). + Non puoi usare l'`tini`inizializzatore come script di ingresso nei contenitori SageMaker AI perché viene confuso dagli argomenti and. `train` `serve` + `/opt/ml`e tutte le sottodirectory sono riservate tramite training. SageMaker Quando crei l'immagine Docker del tuo algoritmo, assicurati di non inserire in questa directory i dati richiesti dall'algoritmo. Se lo fai, i dati potrebbero non essere più visibili durante l'addestramento. Per raggruppare gli script di shell o Python all'interno dell'immagine Docker o per fornire lo script in un bucket Amazon S3 o utilizzando (CLI), continua con AWS Command Line Interface la sezione seguente. ### Raggruppa lo script di shell (interprete di comandi) in un container Docker Se desideri raggruppare uno script di shell personalizzato all'interno della tua immagine Docker, completa la seguente procedura. 1. Copia lo script di shell (interprete di comandi) dalla directory di lavoro all'interno del container Docker. Il seguente frammento di codice copia uno script del punto di ingresso personalizzato `custom_entrypoint.sh` dalla directory di lavoro corrente a un container Docker situato in `mydir`. L'esempio seguente presuppone che nell'immagine Docker di base sia installato Python. ``` FROM : # Copy custom entrypoint from current dir to /mydir on container COPY ./custom_entrypoint.sh /mydir/ ``` 1. Crea e invia con notifica push un container Docker all’Amazon Elastic Container Registry ([Amazon ECR](https://docs.aws.amazon.com/AmazonECR/latest/userguide/what-is-ecr.html)) seguendo le istruzioni riportate nella sezione [Push di un’immagine Docker](https://docs.aws.amazon.com/AmazonECR/latest/userguide/docker-push-ecr-image.html) nella Guida per l’utente *Amazon ECR*. 1. Avvia il processo di formazione eseguendo il comando seguente. AWS CLI ``` aws --region sagemaker create-training-job \ --training-job-name \ --role-arn \ --algorithm-specification '{ \ "TrainingInputMode": "File", \ "TrainingImage": "", \ "ContainerEntrypoint": ["/bin/sh"], \ "ContainerArguments": ["/mydir/custom_entrypoint.sh"]}' \ --output-data-config '{"S3OutputPath": "s3://custom-entrypoint-output-bucket/"}' \ --resource-config '{"VolumeSizeInGB":10,"InstanceCount":1,"InstanceType":"ml.m5.2xlarge"}' \ --stopping-condition '{"MaxRuntimeInSeconds": 180}' ``` ### Raggruppa il tuo script Python in un container Docker Per raggruppare uno script Python personalizzato all'interno della tua immagine Docker, completa la seguente procedura. 1. Copia lo script Python dalla tua directory di lavoro all'interno del tuo container Docker. Il seguente frammento di codice copia uno script del punto di ingresso personalizzato `custom_entrypoint.py` dalla directory di lavoro corrente a un container Docker situato in `mydir`. ``` FROM : # Copy custom entrypoint from current dir to /mydir on container COPY ./custom_entrypoint.py /mydir/ ``` 1. Avvia il processo di formazione eseguendo il AWS CLI comando seguente. ``` --algorithm-specification '{ \ "TrainingInputMode": "File", \ "TrainingImage": "", \ "ContainerEntrypoint": ["python"], \ "ContainerArguments": ["/mydir/custom_entrypoint.py"]}' \ ``` ## Esecuzione di un processo di addestramento con uno script del punto di ingresso al di fuori del container Docker Puoi usare il tuo container Docker per l’addestramento e inserire uno script del punto di ingresso dall'esterno del container Docker. Ci sono alcuni vantaggi nello strutturare lo script del punto di ingresso all'esterno del container. Se aggiorni lo script di ingresso, non devi ricostruire il container Docker. Puoi anche utilizzare diversi script da eseguire nello stesso container. Specificate la posizione dello script di formazione utilizzando i `ContainerArguments` parametri `ContainerEntrypoint` e dell'[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_AlgorithmSpecification.html)API. Questi punti di ingresso e argomenti si comportano allo stesso modo dei punti di ingresso e degli argomenti Docker. I valori di questi parametri hanno la precedenza su quelli corrispondenti `ENTRYPOINT` o `CMD` forniti come parte del container Docker. Quando inoltrii il tuo script del punto di ingresso personalizzato al tuo container di addestramento Docker, gli input forniti determinano il comportamento del container. + Ad esempio, se fornite solo`ContainerEntrypoint`, la sintassi della richiesta che utilizza l' CreateTrainingJob API è la seguente. ``` { "AlgorithmSpecification": { "ContainerEntrypoint": ["string"], ... } } ``` Quindi, il backend SageMaker di formazione esegue il punto di ingresso personalizzato come segue. ``` docker run --entrypoint image ``` **Nota** Se `ContainerEntrypoint` fornito, il backend di SageMaker formazione esegue l'immagine con il punto di ingresso specificato e sostituisce l'impostazione predefinita nell'immagine. `ENTRYPOINT` + Se fornisci solo`ContainerArguments`, SageMaker AI presuppone che il contenitore Docker contenga uno script di ingresso. La sintassi della richiesta che utilizza l'API `CreateTrainingJob` è la seguente. ``` { "AlgorithmSpecification": { "ContainerArguments": ["arg1", "arg2"], ... } } ``` Il backend SageMaker di formazione esegue il punto di ingresso personalizzato come segue. ``` docker run image ``` + Se fornisci sia l’opzione `ContainerEntrypoint` che `ContainerArguments`, la sintassi della richiesta tramite l'API `CreateTrainingJob` è la seguente. ``` { "AlgorithmSpecification": { "ContainerEntrypoint": ["string"], "ContainerArguments": ["arg1", "arg2"], ... } } ``` Il backend SageMaker di formazione gestisce il punto di ingresso personalizzato come segue. ``` docker run --entrypoint image ``` Puoi utilizzare qualsiasi origine `InputDataConfig` supportata nell'API `CreateTrainingJob` per fornire uno script del punto di ingresso per eseguire la tua immagine di addestramento. ### Inserimento dello script del tuo punto di ingresso in un bucket Amazon S3 Per fornire uno script entrypoint personalizzato utilizzando un bucket S3, utilizza il `S3DataSource` parametro dell'[DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)API per specificare la posizione dello script. Se utilizzi il parametro `S3DataSource`, i seguenti requisiti sono necessari. + [InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)Deve essere del tipo. `File` + L'[S3 DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource) deve essere`FullyReplicated`. L'esempio seguente presenta uno script chiamato custom\$1entrypoint.sh inserito nel percorso di un bucket S3 `s3:////custom_entrypoint.sh`. ``` #!/bin/bash echo "Running custom_entrypoint.sh" echo "Hello you have provided the following arguments: " "$@" ``` Successivamente, devi impostare la configurazione del canale dati di input per eseguire un processo di addestramento. Fatelo utilizzando AWS CLI direttamente o con un file JSON. #### Configura il canale dati di input utilizzando AWS CLI un file JSON Per configurare il canale dati di input con un file JSON, utilizzate AWS CLI come mostrato nella seguente struttura di codice. Assicurati che tutti i seguenti campi utilizzino la sintassi della richiesta definita nell'[CreateTrainingJob](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#API_CreateTrainingJob_RequestSyntax)API. ``` // run-my-training-job.json { "[AlgorithmSpecification](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-AlgorithmSpecification)": { "ContainerEntrypoint": ["/bin/sh"], "ContainerArguments": ["/opt/ml/input/data//custom_entrypoint.sh"], ... }, "[InputDataConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-InputDataConfig)": [ { "[ChannelName](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-ChannelName)": "", "[DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-DataSource)": { "[S3DataSource](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_DataSource.html#sagemaker-Type-DataSource-S3DataSource)": { "[S3DataDistributionType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataDistributionType)": "FullyReplicated", "[S3DataType](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3DataType)": "S3Prefix", "[S3Uri](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_S3DataSource.html#sagemaker-Type-S3DataSource-S3Uri)": "s3:///" } }, "[InputMode](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_Channel.html#sagemaker-Type-Channel-InputMode)": "File", }, ...] } ``` Quindi, esegui il AWS CLI comando per avviare il processo di formazione dal file JSON come segue. ``` aws sagemaker create-training-job --cli-input-json file://run-my-training-job.json ``` #### Configura il canale dati di input utilizzando direttamente AWS CLI Per configurare il canale dati di input senza un file JSON, utilizzate la seguente struttura di AWS CLI codice. ``` aws --region sagemaker create-training-job \ --training-job-name \ --role-arn \ --algorithm-specification '{ \ "TrainingInputMode": "File", \ "TrainingImage": "", \ "ContainerEntrypoint": ["/bin/sh"], \ "ContainerArguments": ["/opt/ml/input/data//custom_entrypoint.sh"]}' \ --input-data-config '[{ \ "ChannelName":"", \ "DataSource":{ \ "S3DataSource":{ \ "S3DataType":"S3Prefix", \ "S3Uri":"s3:///", \ "S3DataDistributionType":"FullyReplicated"}}}]' \ --output-data-config '{"S3OutputPath": "s3://custom-entrypoint-output-bucket/"}' \ --resource-config '{"VolumeSizeInGB":10,"InstanceCount":1,"InstanceType":"ml.m5.2xlarge"}' \ --stopping-condition '{"MaxRuntimeInSeconds": 180}' ``` # In che modo Amazon SageMaker AI fornisce informazioni sulla formazione Questa sezione spiega come l' SageMaker intelligenza artificiale rende disponibili le informazioni sulla formazione, come dati di addestramento, iperparametri e altre informazioni di configurazione, nel contenitore Docker. Quando invii una [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html)richiesta all' SageMaker IA per avviare l'addestramento del modello, specifichi il percorso Amazon Elastic Container Registry (Amazon ECR) dell'immagine Docker che contiene l'algoritmo di addestramento. È inoltre necessario specificare la posizione di Amazon Simple Storage Service (Amazon S3) in cui vengono archiviati i dati di addestramento e i parametri specifici dell'algoritmo. SageMaker L'intelligenza artificiale mette queste informazioni a disposizione del contenitore Docker in modo che l'algoritmo di addestramento possa utilizzarle. Questa sezione spiega come rendere queste informazioni disponibili al tuo container Docker. Per informazioni sulla creazione di un processo di addestramento, consulta `CreateTrainingJob`. Per ulteriori informazioni sul modo in cui i contenitori SageMaker AI organizzano le informazioni, consulta[SageMaker Toolkit di formazione e inferenza](amazon-sagemaker-toolkits.md). **Topics** + [Iperparametri](#your-algorithms-training-algo-running-container-hyperparameters) + [Variabili di ambiente](#your-algorithms-training-algo-running-container-environment-variables) + [Configurazione dei dati di input](#your-algorithms-training-algo-running-container-inputdataconfig) + [Dati di addestramento](#your-algorithms-training-algo-running-container-trainingdata) + [Configurazione dell’addestramento distribuito](#your-algorithms-training-algo-running-container-dist-training) ## Iperparametri SageMaker L'intelligenza artificiale rende disponibili gli iperparametri di una `CreateTrainingJob` richiesta nel contenitore Docker del `/opt/ml/input/config/hyperparameters.json` file. Di seguito è riportato un esempio di configurazione iperparametrica in `hyperparameters.json` per specificare gli `num_round` e gli `eta` iperparametri nell'operazione per. `CreateTrainingJob` [XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost.html) ``` { "num_round": "128", "eta": "0.001" } ``` [Per un elenco completo degli iperparametri che possono essere utilizzati per l' XGBoost algoritmo integrato di SageMaker intelligenza artificiale, vedi Iperparametri. XGBoost](https://docs.aws.amazon.com/sagemaker/latest/dg/xgboost_hyperparameters.html) Gli iperparametri che puoi ottimizzare dipendono dall'algoritmo che stai addestrando. Per un elenco degli iperparametri disponibili per un algoritmo integrato di SageMaker intelligenza artificiale, trovali elencati in **Iperparametri** sotto il link dell'algoritmo in Use [Amazon SageMaker AI Built-in Algorithms or](https://docs.aws.amazon.com/sagemaker/latest/dg/algos.html) Pre-training Models. ## Variabili di ambiente SageMaker L'intelligenza artificiale imposta le seguenti variabili di ambiente nel tuo contenitore: + TRAINING\$1JOB\$1NAME: specificato nel parametro `TrainingJobName` della richiesta `CreateTrainingJob`. + TRAINING\$1JOB\$1ARN: il nome della risorsa Amazon (ARN) del processo di addestramento restituito come `TrainingJobArn` nella risposta `CreateTrainingJob`. + Tutte le variabili di ambiente specificate nel parametro [Ambiente](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html#sagemaker-CreateTrainingJob-request-Environment) nella richiesta `CreateTrainingJob`. ## Configurazione dei dati di input SageMaker L'intelligenza artificiale rende disponibili le informazioni sul canale dati contenute nel `InputDataConfig` parametro della `CreateTrainingJob` richiesta nel `/opt/ml/input/config/inputdataconfig.json` file nel contenitore Docker. Ad esempio, supponiamo di specificare tre canali di dati (`train``evaluation`, e`validation`) nella richiesta. SageMaker L'IA fornisce il seguente codice JSON: ``` { "train" : {"ContentType": "trainingContentType", "TrainingInputMode": "File", "S3DistributionType": "FullyReplicated", "RecordWrapperType": "None"}, "evaluation" : {"ContentType": "evalContentType", "TrainingInputMode": "File", "S3DistributionType": "FullyReplicated", "RecordWrapperType": "None"}, "validation" : {"TrainingInputMode": "File", "S3DistributionType": "FullyReplicated", "RecordWrapperType": "None"} } ``` **Nota** SageMaker L'intelligenza artificiale fornisce al contenitore solo informazioni pertinenti su ciascun canale di dati (ad esempio, il nome del canale e il tipo di contenuto), come mostrato nell'esempio precedente. `S3DistributionType`verrà impostato come `FullyReplicated` se si specificasse EFS o FSx Lustre come origini dati di input. ## Dati di addestramento Il parametro `TrainingInputMode` nella `AlgorithmSpecification` della richiesta [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTrainingJob.html) specifica in che modo il set di dati di addestramento viene reso disponibile per il container. Sono disponibili le modalità di input seguenti: + **Modalità `File`** Se usi `File` mode come `TrainingInputMode` valore, SageMaker AI imposta i seguenti parametri nel tuo contenitore. + Il parametro `TrainingInputMode` viene scritto in `inputdataconfig.json` come "File". + La directory del tuo canale dati viene scritta in `/opt/ml/input/data/channel_name`. Se utilizzi `File` la modalità, l' SageMaker IA crea una directory per ogni canale. Ad esempio, se hai tre canali denominati `training``validation`, e`testing`, SageMaker AI crea le seguenti tre directory nel tuo contenitore Docker: + `/opt/ml/input/data/training` + `/opt/ml/input/data/validation` + `/opt/ml/input/data/testing` La modalità `File` supporta le seguenti origini dati. + Amazon Simple Storage Service (Amazon S3) + Amazon Elastic File System (Amazon EFS) + Amazon FSx per Lustre **Nota** I canali che utilizzano fonti di dati di file system come Amazon EFS e Amazon FSx devono utilizzare `File` la modalità. In questo caso, il percorso della directory fornito nel canale viene montato in `/opt/ml/input/data/channel_name`. + **Modalità `FastFile`** Se utilizzi la `FastFile` modalità come modalità`TrainingInputNodeParameter`, l' SageMaker intelligenza artificiale imposta i seguenti parametri nel tuo contenitore. + Analogamente alla modalità `File`, nella modalità `FastFile` il tuo parametro `TrainingInputMode` viene scritto in `inputdataconfig.json` come "File". + La directory del tuo canale dati viene scritta in `/opt/ml/input/data/channel_name`. La modalità `FastFile` supporta le seguenti origini dati. + Simple Storage Service (Amazon S3) Se utilizzi la modalità `FastFile`, la directory dei canali viene montata con l'autorizzazione di sola lettura. Storicamente, la modalità `File` precedeva la modalità `FastFile`. Per garantire la compatibilità con le versioni precedenti, gli algoritmi che supportano la modalità `File` possono funzionare senza problemi anche con la modalità `FastFile`, purché il parametro `TrainingInputMode` sia impostato su `File` in `inputdataconfig.json.`. **Nota** I canali che utilizzano la modalità `FastFile` devono utilizzare un `S3DataType` di "S3Prefix". La modalità `FastFile` presenta una visualizzazione di cartelle che utilizza la barra in avanti (`/`) come delimitatore per raggruppare oggetti Amazon S3 nelle cartelle. I prefissi `S3Uri` non devono corrispondere a un nome parziale di cartella. Ad esempio, se un set di dati Amazon S3 contiene `s3://amzn-s3-demo-bucket/train-01/data.csv`, allora non sono consentiti né `s3://amzn-s3-demo-bucket/train` né `s3://amzn-s3-demo-bucket/train-01` come prefissi `S3Uri`. Consigliamo di utilizzare una barra finale per definire un canale corrispondente a una cartella. Ad esempio, il canale `s3://amzn-s3-demo-bucket/train-01/` per la cartella `train-01`. Senza la barra finale, il canale sarebbe ambiguo se esistesse un'altra cartella `s3://amzn-s3-demo-bucket/train-011/` o un file `s3://amzn-s3-demo-bucket/train-01.txt/`. + **Modalità `Pipe`** + Il parametro `TrainingInputMode` scritto in `inputdataconfig.json`: "Pipe" + Directory del canale dati nel container Docker: `/opt/ml/input/data/channel_name_epoch_number` + Fonti di dati supportate: Amazon S3 Devi leggere da una pipe separata per ogni canale. Ad esempio, se hai tre canali denominati `training`, `validation` e `testing`, devi leggere dalle seguenti pipe: + `/opt/ml/input/data/training_0, /opt/ml/input/data/training_1, ...` + `/opt/ml/input/data/validation_0, /opt/ml/input/data/validation_1, ...` + `/opt/ml/input/data/testing_0, /opt/ml/input/data/testing_1, ...` Leggi le pipe sequenzialmente. Ad esempio, se hai un canale che si chiama `training`, leggi le pipe in questa sequenza: 1. Apri `/opt/ml/input/data/training_0` in modalità lettura e leggilo su end-of-file (EOF) oppure, se hai finito con la prima epoca, chiudi il file pipe in anticipo. 1. Dopo aver chiuso il primo file pipe, cerca `/opt/ml/input/data/training_1` e leggilo finché non hai completato la seconda epoca e così via. Se il file per una determinata epoca non esiste ancora, il tuo codice potrebbe dover riprovare finché non viene creata la pipe. Non c'è alcuna restrizione di sequenziamento sui tipi di canale. Ad esempio, puoi leggere più epoche per il canale `training`, e iniziare a leggere il canale `validation` solo quando sei pronto. In alternativa, li puoi leggere simultaneamente se il tuo algoritmo lo richiede. Per un esempio di notebook Jupyter che mostra come usare la modalità Pipe quando porti il tuo contenitore, vedi [Bring your own pipe-mode](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/pipe_bring_your_own/pipe_bring_your_own.ipynb) algorithm to Amazon AI. SageMaker SageMaker L'addestramento sui modelli AI supporta i bucket di directory S3 Express One Zone ad alte prestazioni come posizione di input dei dati per la modalità file, la modalità fast file e la modalità pipe. Per utilizzare S3 Express One Zone, inserisci la posizione del bucket di directory S3 Express One Zone anziché un bucket Amazon S3 per uso generico. Fornisci l’ARN per il ruolo IAM con la policy di controllo degli accessi e delle autorizzazioni richiesta. Fare riferimento a [AmazonSageMakerFullAccesspolicy](https://docs.aws.amazon.com/aws-managed-policy/latest/reference/AmazonSageMakerFullAccess.html) per ulteriori dettagli. Puoi crittografare i dati di output SageMaker AI solo in bucket di directory con crittografia lato server con chiavi gestite di Amazon S3 (SSE-S3). La crittografia lato server con AWS KMS chiavi (SSE-KMS) non è attualmente supportata per l'archiviazione dei dati di output AI nei bucket di directory. SageMaker Per ulteriori informazioni, consulta [S3 Express One Zone](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-one-zone.html). ## Configurazione dell’addestramento distribuito Se stai eseguendo corsi di formazione distribuiti con più contenitori, l' SageMaker intelligenza artificiale rende disponibili le informazioni su tutti i contenitori nel file. `/opt/ml/input/config/resourceconfig.json` Per abilitare la comunicazione tra contenitori, questo file JSON contiene informazioni per tutti i contenitori. SageMaker L'intelligenza artificiale rende questo file disponibile per entrambi gli algoritmi`File`. `Pipe` Il file fornisce le informazioni che seguono: + `current_host`: il nome del container corrente sulla rete di container. Ad esempio, `algo-1`. I valori host possono cambiare in qualsiasi momento. Non scrivere codice con valori specifici per questa variabile. + `hosts`: l'elenco dei nomi di tutti i container nella rete di container, ordinato in ordine lessicografico. Ad esempio, `["algo-1", "algo-2", "algo-3"]` per un cluster a tre nodi. I container possono utilizzare questi nomi per gestire altri container sulla rete di container. I valori host possono cambiare in qualsiasi momento. Non scrivere codice con valori specifici per queste variabili. + `network_interface_name`: il nome dell'interfaccia di rete esposta al tuo container. Ad esempio, container che eseguono l'interfaccia MPI (Message Passing Interface) possono utilizzare questa informazione per impostare il nome dell'interfaccia di rete. + Non utilizzare le informazioni in `/etc/hostname` o `/etc/hosts` perché potrebbero non essere accurate. + Le informazioni sul nome host potrebbero non essere immediatamente disponibili per il container degli algoritmi. Ti consigliamo di aggiungere una policy per i nuovi tentativi sulle operazioni di risoluzione del nome host man mano che i nodi diventano disponibili nel cluster. Di seguito è riportato un file di esempio sul nodo 1 in un cluster a tre nodi. ``` { "current_host": "algo-1", "hosts": ["algo-1","algo-2","algo-3"], "network_interface_name":"eth1" } ``` # Esecuzione di un addestramento con EFA SageMaker L'intelligenza artificiale fornisce l'integrazione con i dispositivi [EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) per accelerare le applicazioni di High Performance Computing (HPC) e machine learning. Questa integrazione consente di sfruttare un dispositivo EFA per eseguire processi di addestramento distribuiti. Puoi aggiungere l'integrazione EFA a un contenitore Docker esistente da aggiungere all'IA. SageMaker Le seguenti informazioni descrivono come configurare il proprio container per utilizzare un dispositivo EFA per i processi di addestramento distribuiti. ## Prerequisiti Il contenitore deve soddisfare le specifiche del [contenitore SageMaker di formazione](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-dockerfile.html).  ## Installazione dei pacchetti EFA richiesti Il container deve scaricare e installare il [ software EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html). Ciò consente al container di riconoscere il dispositivo EFA e fornisce versioni compatibili di Libfabric e Open MPI. Tutti gli strumenti come MPI e NCCL devono essere installati e gestiti all'interno del container per essere utilizzati come parte del processo di addestramento abilitato EFA. Per un elenco di tutte le versioni EFA disponibili, consulta [Verifica del programma di installazione EFA utilizzando un checksum](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-verify.html). L'esempio seguente mostra come modificare il file Docker del container abilitato EFA per installare EFA, MPI, OFI, NCCL e NCCL-TEST. **Nota** Quando si utilizza PyTorch con EFA sul contenitore, la versione NCCL del contenitore deve corrispondere alla versione NCCL dell'installazione. PyTorch Per verificare la versione PyTorch NCCL, usa il seguente comando: ``` torch.cuda.nccl.version() ``` ``` ARG OPEN_MPI_PATH=/opt/amazon/openmpi/ ENV NCCL_VERSION=2.7.8 ENV EFA_VERSION=1.30.0 ENV BRANCH_OFI=1.1.1 ################################################# ## EFA and MPI SETUP RUN cd $HOME \ && curl -O https://s3-us-west-2.amazonaws.com/aws-efa-installer/aws-efa-installer-${EFA_VERSION}.tar.gz \ && tar -xf aws-efa-installer-${EFA_VERSION}.tar.gz \ && cd aws-efa-installer \ && ./efa_installer.sh -y --skip-kmod -g \ ENV PATH="$OPEN_MPI_PATH/bin:$PATH" ENV LD_LIBRARY_PATH="$OPEN_MPI_PATH/lib/:$LD_LIBRARY_PATH" ################################################# ## NCCL, OFI, NCCL-TEST SETUP RUN cd $HOME \ && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \ && cd nccl \ && make -j64 src.build BUILDDIR=/usr/local RUN apt-get update && apt-get install -y autoconf RUN cd $HOME \ && git clone https://github.com/aws/aws-ofi-nccl.git -b v${BRANCH_OFI} \ && cd aws-ofi-nccl \ && ./autogen.sh \ && ./configure --with-libfabric=/opt/amazon/efa \ --with-mpi=/opt/amazon/openmpi \ --with-cuda=/usr/local/cuda \ --with-nccl=/usr/local --prefix=/usr/local \ && make && make install RUN cd $HOME \ && git clone https://github.com/NVIDIA/nccl-tests \ && cd nccl-tests \ && make MPI=1 MPI_HOME=/opt/amazon/openmpi CUDA_HOME=/usr/local/cuda NCCL_HOME=/usr/local ``` ## Considerazioni sulla creazione di un container Il dispositivo EFA è montato sul container come indicato `/dev/infiniband/uverbs0` nell'elenco dei dispositivi accessibili al container. Nelle istanze P4d, il container ha accesso a 4 dispositivi EFA. I dispositivi EFA sono riportati nell'elenco dei dispositivi accessibili al container come: + `/dev/infiniband/uverbs0` + `/dev/infiniband/uverbs1` + `/dev/infiniband/uverbs2` + `/dev/infiniband/uverbs3` Per ottenere informazioni sul nome host, sui nomi host dei peer e sull'interfaccia di rete (per MPI) dal file `resourceconfig.json` fornito a ciascuna istanza di container, consulta [Distributed Training Configuration](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo-running-container.html#your-algorithms-training-algo-running-container-dist-training). Il container gestisce il normale traffico TCP tra peer tramite le interfacce di rete elastiche (ENI) predefinite, mentre gestisce il traffico OFI (bypassando il kernel) attraverso il dispositivo EFA. ## Verifica che il tuo dispositivo EFA sia riconosciuto  Per verificare che il tuo dispositivo EFA sia riconosciuto, esegui il comando seguente dall'interno del container. ``` /opt/amazon/efa/bin/fi_info -p efa ``` L'aspetto dell'output sarà simile al seguente. ``` provider: efa fabric: EFA-fe80::e5:56ff:fe34:56a8 domain: efa_0-rdm version: 2.0 type: FI_EP_RDM protocol: FI_PROTO_EFA provider: efa fabric: EFA-fe80::e5:56ff:fe34:56a8 domain: efa_0-dgrm version: 2.0 type: FI_EP_DGRAM protocol: FI_PROTO_EFA provider: efa;ofi_rxd fabric: EFA-fe80::e5:56ff:fe34:56a8 domain: efa_0-dgrm version: 1.0 type: FI_EP_RDM protocol: FI_PROTO_RXD ``` ## Esecuzione di un processo di addestramento con EFA Dopo aver creato un contenitore compatibile con EFA, puoi eseguire un processo di formazione con EFA utilizzando un SageMaker AI Estimator nello stesso modo in cui faresti con qualsiasi altra immagine Docker. Per ulteriori informazioni sulla registrazione del container e sul suo utilizzo per l’addestramento, consulta [Adapting your own training container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html#byoc-training-step5). # In che modo Amazon SageMaker AI segnala il successo e il fallimento di un algoritmo Un algoritmo di addestramento indica se ha funzionato o meno utilizzando il codice di uscita del suo processo. Un'esecuzione di addestramento che funziona deve uscire con un codice di uscita 0 e un'esecuzione di addestramento non riuscita deve uscire con un codice di uscita diverso da zero. Verranno convertite in `Completed` e `Failed` nel `TrainingJobStatus` restituito da `DescribeTrainingJob`. Questo codice di uscita di convenzione è standard ed è facilmente implementato in tutti i linguaggi. Ad esempio, in Python, puoi utilizzare `sys.exit(1)` per segnalare un errore nell'uscita e l'esecuzione fino alla fine della routine principale farà uscire Python con il codice 0. Nel caso di errori, l'algoritmo può scrivere una descrizione dell'errore nel file di errore. Per ulteriori informazioni, consulta la prossima sezione. # In che modo Amazon SageMaker AI elabora i risultati della formazione Poiché il tuo algoritmo viene eseguito in un container, genera output, tra cui lo stato del processo di addestramento e artefatti del modello e di output. Il tuo algoritmo deve scrivere queste informazioni nei file seguenti, che si trovano nella directory del container `/output`. Amazon SageMaker AI elabora le informazioni contenute in questa directory come segue: + `/opt/ml/model`— Il tuo algoritmo dovrebbe scrivere tutti gli artefatti finali del modello in questa directory. SageMaker AI copia questi dati come un singolo oggetto in formato tar compresso nella posizione S3 specificata nella richiesta. `CreateTrainingJob` Se più contenitori in un singolo processo di formazione scrivono in questa directory, dovrebbero assicurarsi che non ci `file/directory` siano conflitti tra i nomi. SageMaker L'IA aggrega il risultato in un file TAR e lo carica su S3 al termine del processo di formazione. + `/opt/ml/output/data`— Il tuo algoritmo dovrebbe scrivere gli artefatti che desideri archiviare diversi dal modello finale in questa directory. SageMaker AI copia questi dati come un singolo oggetto in formato tar compresso nella posizione S3 specificata nella richiesta. `CreateTrainingJob` Se più contenitori in un singolo processo di formazione scrivono in questa directory, dovrebbero assicurarsi che non ci `file/directory` siano conflitti tra i nomi. SageMaker L'IA aggrega il risultato in un file TAR e lo carica su S3 al termine del processo di formazione. + `/opt/ml/output/failure`: se si verifica un errore nell’addestramento, dopo che l'output dell'algoritmo è completato (ad esempio, registrazione), il tuo algoritmo deve scrivere la descrizione dell'errore in questo file. In `DescribeTrainingJob` risposta, SageMaker AI restituisce i primi 1024 caratteri di questo file come. `FailureReason` È possibile specificare un bucket S3 generico o di directory per archiviare l’output dell’addestramento. I bucket di directory utilizzano solo la classe di archiviazione Amazon S3 Express One Zone, progettata per carichi di lavoro o applicazioni con requisiti di prestazioni elevati che richiedono una latenza costante di pochi millisecondi. Scegli il tipo di bucket più adatto ai requisiti applicativi e di prestazioni. Per ulteriori informazioni sui bucket di directory S3, consulta [Bucket di directory](https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-buckets-overview.html) nella *Guida per l’utente di Amazon Simple Storage Service*. **Nota** Puoi crittografare i dati di output SageMaker AI solo nei bucket di directory S3 con crittografia lato server con chiavi gestite di Amazon S3 (SSE-S3). La crittografia lato server con AWS KMS chiavi (SSE-KMS) non è attualmente supportata per l'archiviazione dei dati di output AI nei bucket di directory. SageMaker # Container con codice di inferenza personalizzato Puoi utilizzare Amazon SageMaker AI per interagire con i container Docker ed eseguire codice di inferenza personalizzato in due modi: + Per utilizzare il tuo codice di inferenza con un endpoint persistente e ottenere una previsione alla volta, utilizza i servizi di hosting di SageMaker AI. + Per utilizzare il tuo codice di inferenza per ottenere previsioni per un intero set di dati, utilizza la trasformazione in batch di SageMaker AI. **Topics** + [Codice di inferenza personalizzato con servizi di hosting](your-algorithms-inference-code.md) + [Codice di inferenza personalizzato con la trasformazione in batch](your-algorithms-batch-code.md) # Codice di inferenza personalizzato con servizi di hosting Questa sezione spiega come Amazon SageMaker AI interagisce con un contenitore Docker che esegue il tuo codice di inferenza per i servizi di hosting. Utilizza queste informazioni per scrivere il codice di inferenza e creare un'immagine Docker. **Topics** + [In che modo l' SageMaker intelligenza artificiale gestisce la tua immagine di inferenza](#your-algorithms-inference-code-run-image) + [In che modo l' SageMaker IA carica gli artefatti del modello](#your-algorithms-inference-code-load-artifacts) + [Come il tuo container deve rispondere alle richieste di inferenza](#your-algorithms-inference-code-container-response) + [Come il tuo container deve rispondere alle richieste di controllo dello stato (Ping)](#your-algorithms-inference-algo-ping-requests) + [Contratto container per supportare funzionalità di streaming bidirezionale](#your-algorithms-inference-algo-bidi) + [Utilizzo di un registro Docker privato per container di inferenza in tempo reale](your-algorithms-containers-inference-private.md) ## In che modo l' SageMaker intelligenza artificiale gestisce la tua immagine di inferenza Per configurare un container per l'esecuzione come un eseguibile, utilizza un'istruzione `ENTRYPOINT` in un Dockerfile. Tenere presente quanto segue: + Per l'inferenza dei modelli, l' SageMaker intelligenza artificiale esegue il contenitore come: ``` docker run image serve ``` SageMaker L'IA sostituisce `CMD` le istruzioni predefinite in un contenitore specificando l'`serve`argomento dopo il nome dell'immagine. L'argomento `serve` sostituisce gli argomenti che fornisci con il comando `CMD` nel Dockerfile.   + SageMaker L'IA si aspetta che tutti i contenitori vengano eseguiti con utenti root. Crea il tuo container in modo che utilizzi solo utenti root. Quando l' SageMaker intelligenza artificiale esegue il contenitore, gli utenti che non dispongono dell'accesso a livello di root possono causare problemi di autorizzazione.   + Ti consigliamo di utilizzare il modulo `exec` dell'istruzione `ENTRYPOINT`: ``` ENTRYPOINT ["executable", "param1", "param2"] ``` Esempio: ``` ENTRYPOINT ["python", "k_means_inference.py"] ``` Il modulo `exec` dell'istruzione `ENTRYPOINT` avvia l'eseguibile direttamente, non come figlio di `/bin/sh`. Ciò gli consente di ricevere segnali simili `SIGTERM` e provenienti `SIGKILL` dalle operazioni dell' SageMaker API, il che è un requisito.   Ad esempio, quando si utilizza l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateEndpoint.html)API per creare un endpoint, l' SageMaker intelligenza artificiale fornisce il numero di istanze di calcolo ML richieste dalla configurazione dell'endpoint, specificato nella richiesta. SageMaker L'IA esegue il contenitore Docker su tali istanze.   Se riduci il numero di istanze che eseguono il backup dell'endpoint (chiamando l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpointWeightsAndCapacities.html)API), SageMaker AI esegue un comando per arrestare il contenitore Docker sulle istanze che vengono terminate. Il comando invia il segnale `SIGTERM` e poi invia il segnale `SIGKILL` trenta secondi più tardi.   Se aggiorni l'endpoint (chiamando l'[https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_UpdateEndpoint.html)API), SageMaker AI avvia un altro set di istanze di calcolo ML ed esegue i contenitori Docker che contengono il tuo codice di inferenza su di esse. Poi esegue un comando per interrompere il precedente container Docker. Per interrompere un container Docker, il comando invia il segnale `SIGTERM` e poi invia il segnale `SIGKILL` 30 secondi più tardi.   + SageMaker AI utilizza la definizione del contenitore fornita nella [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)richiesta per impostare le variabili di ambiente e il nome host DNS per il contenitore nel modo seguente:   + Imposta le variabili di ambiente utilizzando la `ContainerDefinition.Environment` string-to-string mappa. + Imposta l'hostname DNS utilizzando `ContainerDefinition.ContainerHostname`.   + Se prevedi di utilizzare dispositivi GPU per le inferenze di modelli (specificando le istanze di calcolo ML basate su GPU nella richiesta `CreateEndpointConfig`), accertati che i container siano compatibili con `nvidia-docker`. Non aggregare i driver NVIDIA con l'immagine. Per ulteriori informazioni su `nvidia-docker`, consulta [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).   + Non puoi usare l'`tini`inizializzatore come punto di ingresso nei contenitori SageMaker AI perché viene confuso dagli argomenti `train` and`serve`. ## In che modo l' SageMaker IA carica gli artefatti del modello Nella richiesta [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)API, puoi utilizzare il `S3DataSource` parametro `ModelDataUrl` o per identificare la posizione S3 in cui sono archiviati gli artefatti del modello. SageMaker L'intelligenza artificiale copia gli artefatti del modello dalla posizione S3 alla `/opt/ml/model` directory per essere utilizzati dal codice di inferenza. Il container ha accesso in sola lettura a `/opt/ml/model`. Non scrivere in questa directory. Il valore di `ModelDataUrl` deve puntare a un file tar.gz. Altrimenti, l' SageMaker IA non scaricherà il file. Se hai addestrato il tuo modello all' SageMaker intelligenza artificiale, gli artefatti del modello vengono salvati come un singolo file tar compresso in Amazon S3. Se hai addestrato il tuo modello al di fuori dell' SageMaker intelligenza artificiale, devi creare questo singolo file tar compresso e salvarlo in una posizione S3. SageMaker AI decomprime questo file tar nella directory/opt/ml/modelprima dell'avvio del contenitore. Per distribuire modelli di grandi dimensioni, consigliamo di seguire [Implementazione di modelli non compressi](large-model-inference-uncompressed.md). ## Come il tuo container deve rispondere alle richieste di inferenza Per ottenere inferenze, l'applicazione client invia una richiesta POST all'endpoint AI. SageMaker SageMaker L'IA passa la richiesta al contenitore e restituisce il risultato dell'inferenza dal contenitore al client. Per ulteriori informazioni sulle richieste di inferenza che il contenitore riceverà, consulta le seguenti azioni nel *riferimento all'API di Amazon SageMaker AI*: + [ InvokeEndpoint](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpoint.html) + [ InvokeEndpointAsync](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointAsync.html) + [ InvokeEndpointWithResponseStream](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithResponseStream.html) + [ InvokeEndpointWithResponseStream](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_runtime_InvokeEndpointWithBidirectionalStream.html) **Requisiti per i container di inferenza** Per rispondere alle richieste di inferenza, il container deve soddisfare i seguenti requisiti: + SageMaker AI rimuove tutte le `POST` intestazioni tranne quelle supportate da. `InvokeEndpoint` SageMaker L'IA potrebbe aggiungere intestazioni aggiuntive. I container dell'inferenza devono essere in grado di ignorare queste intestazioni aggiuntive. + Per ricevere le richieste di inferenza, il container deve disporre di un server Web in ascolto sulla porta 8080 e deve accettare le richieste `POST` agli endpoint `/invocations` e `/ping`. + I container di modello del cliente devono accettare le richieste di connessione socket entro 250 ms. + I container di modello del cliente devono rispondere alle richieste entro 60 secondi. Il modello stesso può avere un tempo di elaborazione massimo di 60 secondi prima di rispondere a `/invocations`. Se il modello impiega 50-60 secondi di tempo di elaborazione, il timeout del socket dell'SDK deve essere impostato su 70 secondi. + Il contenitore modello di un cliente che supporta lo streaming bidirezionale deve: + supportare WebSockets le connessioni sulla porta da 8080 a/invocations-bidirectional-stream per impostazione predefinita. + dispongono di un server Web in ascolto sulla porta 8080 e devono accettare le richieste POST agli endpoint /ping. + Oltre ai controlli dello stato del contenitore tramite HTTP, il contenitore deve rispondere con Pong Frame per ([RFC6455](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)), per l'invio di WebSocket Ping Frame. **Example funzioni di invocazione** Negli esempi seguenti viene illustrato come il codice nel container può elaborare richieste di inferenza. Questi esempi gestiscono le richieste inviate dalle applicazioni client utilizzando l' InvokeEndpoint azione. FastAPI è un framework web per la creazione APIs con Python. ``` from fastapi import FastAPI, status, Request, Response . . . app = FastAPI() . . . @app.post('/invocations') async def invocations(request: Request): # model() is a hypothetical function that gets the inference output: model_resp = await model(Request) response = Response( content=model_resp, status_code=status.HTTP_200_OK, media_type="text/plain", ) return response . . . ``` In questo esempio, la `invocations` funzione gestisce la richiesta di inferenza che l' SageMaker IA invia all'endpoint. `/invocations` Flask è un framework per lo sviluppo di applicazioni web con Python. ``` import flask . . . app = flask.Flask(__name__) . . . @app.route('/invocations', methods=["POST"]) def invoke(request): # model() is a hypothetical function that gets the inference output: resp_body = model(request) return flask.Response(resp_body, mimetype='text/plain') ``` In questo esempio, la `invoke` funzione gestisce la richiesta di inferenza che l' SageMaker IA invia all'endpoint. `/invocations` **Example funzioni di invocazione per le richieste di streaming** Gli esempi seguenti mostrano come il codice nel container di inferenza può elaborare le richieste di inferenza in streaming. Questi esempi gestiscono le richieste inviate dalle applicazioni client utilizzando l'azione InvokeEndpointWithResponseStream . Quando un container gestisce una richiesta di inferenza in streaming, restituisce l'inferenza del modello in blocchi incrementali man mano che il modello le genera. Le applicazioni client iniziano a ricevere risposte immediatamente quando sono disponibili. Non è necessario attendere che il modello generi l'intera risposta. Puoi implementare lo streaming per supportare esperienze interattive veloci, come chatbot, assistenti virtuali e generatori di musica. FastAPI è un framework web per la creazione APIs con Python. ``` from starlette.responses import StreamingResponse from fastapi import FastAPI, status, Request . . . app = FastAPI() . . . @app.post('/invocations') async def invocations(request: Request): # Streams inference response using HTTP chunked encoding async def generate(): # model() is a hypothetical function that gets the inference output: yield await model(Request) yield "\n" response = StreamingResponse( content=generate(), status_code=status.HTTP_200_OK, media_type="text/plain", ) return response . . . ``` In questo esempio, la `invocations` funzione gestisce la richiesta di inferenza che l' SageMaker IA invia all'endpoint. `/invocations` Per lo streaming della risposta, l'esempio utilizza la classe `StreamingResponse` dal framework Starlette. Flask è un framework per lo sviluppo di applicazioni web con Python. ``` import flask . . . app = flask.Flask(__name__) . . . @app.route('/invocations', methods=["POST"]) def invocations(request): # Streams inference response using HTTP chunked encoding def generate(): # model() is a hypothetical function that gets the inference output: yield model(request) yield "\n" return flask.Response( flask.stream_with_context(generate()), mimetype='text/plain') . . . ``` In questo esempio, la `invocations` funzione gestisce la richiesta di inferenza che l' SageMaker IA invia all'endpoint. `/invocations` Per lo streaming della risposta, l'esempio utilizza la funzione `flask.stream_with_context` del framework Flask. **Example Esempi di funzioni di invocazione per lo streaming bidirezionale** Gli esempi seguenti mostrano come il codice del contenitore può elaborare richieste e risposte di inferenza in streaming. Questi esempi gestiscono le richieste di streaming inviate dalle applicazioni client utilizzando l' InvokeEndpointWithBidirectionalStreamazione. Un contenitore con funzionalità di streaming bidirezionale gestisce le richieste di inferenza in streaming in cui le parti vengono generate in modo incrementale sul client e trasmesse al contenitore. Restituisce l'inferenza del modello al client sotto forma di una serie di parti man mano che il modello le genera. Le applicazioni client iniziano a ricevere risposte immediatamente quando sono disponibili. Non è necessario attendere che la richiesta sia completamente generata dal client o che il modello generi l'intera risposta. Puoi implementare lo streaming bidirezionale per supportare esperienze interattive veloci, come chatbot, assistenti vocali interattivi di intelligenza artificiale e traduzioni in tempo reale per un'esperienza più in tempo reale. FastAPI è un framework web per la creazione APIs con Python. ``` import sys import asyncio import json from fastapi import FastAPI, WebSocket, WebSocketDisconnect from fastapi.responses import JSONResponse import uvicorn app = FastAPI() ... @app.websocket("/invocations-bidirectional-stream") async def websocket_invoke(websocket: WebSocket): """ WebSocket endpoint with RFC 6455 ping/pong and fragmentation support Handles: - Text messages (JSON) - including fragmented frames - Binary messages - including fragmented frames - Ping frames (automatically responds with pong) - Pong frames (logs receipt) - Fragmented frames per RFC 6455 Section 5.4 """ await manager.connect(websocket) # Fragment reassembly buffers per RFC 6455 Section 5.4 text_fragments = [] binary_fragments = [] while True: # Use receive() to handle all WebSocket frame types message = await websocket.receive() print(f"Received message: {message}") if message["type"] == "websocket.receive": if "text" in message: # Handle text frames (including fragments) text_data = message["text"] more_body = message.get("more_body", False) if more_body: # This is a fragment, accumulate it text_fragments.append(text_data) print(f"Received text fragment: {len(text_data)} chars (more coming)") else: # This is the final frame or a complete message if text_fragments: # Reassemble fragmented message text_fragments.append(text_data) complete_text = "".join(text_fragments) text_fragments.clear() print(f"Reassembled fragmented text message: {len(complete_text)} chars total") await handle_text_message(websocket, complete_text) else: # Complete message in single frame await handle_text_message(websocket, text_data) elif "bytes" in message: # Handle binary frames (including fragments) binary_data = message["bytes"] more_body = message.get("more_body", False) if more_body: # This is a fragment, accumulate it binary_fragments.append(binary_data) print(f"Received binary fragment: {len(binary_data)} bytes (more coming)") else: # This is the final frame or a complete message if binary_fragments: # Reassemble fragmented message binary_fragments.append(binary_data) complete_binary = b"".join(binary_fragments) binary_fragments.clear() print(f"Reassembled fragmented binary message: {len(complete_binary)} bytes total") await handle_binary_message(websocket, complete_binary) else: # Complete message in single frame await handle_binary_message(websocket, binary_data) elif message["type"] == "websocket.ping": # Handle ping frames - RFC 6455 Section 5.5.2 ping_data = message.get("bytes", b"") print(f"Received PING frame with payload: {ping_data}") # FastAPI automatically sends pong response elif message["type"] == "websocket.pong": # Handle pong frames pong_data = message.get("bytes", b"") print(f"Received PONG frame with payload: {pong_data}") elif message["type"] == "websocket.close": # Handle close frames - RFC 6455 Section 5.5.1 close_code = message.get("code", 1000) close_reason = message.get("reason", "") print(f"Received CLOSE frame - Code: {close_code}, Reason: '{close_reason}'") # Send close frame response if not already closing try: await websocket.close(code=close_code, reason=close_reason) print(f"Sent CLOSE frame response - Code: {close_code}") except Exception as e: print(f"Error sending close frame: {e}") break elif message["type"] == "websocket.disconnect": print("Client initiated disconnect") break else: print(f"Received unknown message type: {message['type']}") break async def handle_binary_message(websocket: WebSocket, binary_data: bytes): """Handle incoming binary messages (complete or reassembled from fragments)""" print(f"Processing complete binary message: {len(binary_data)} bytes") try: # Echo back the binary data await websocket.send_bytes(binary_data) except Exception as e: print(f"Error handling binary message: {e}") async def handle_text_message(websocket: WebSocket, data: str): """Handle incoming text messages""" try: # Send response back to the same client await manager.send_personal_message(data, websocket) except Exception as e: print(f"Error handling text message: {e}") def main(): if len(sys.argv) > 1 and sys.argv[1] == "serve": print("Starting server on port 8080...") uvicorn.run(app, host="0.0.0.0", port=8080) else: print("Usage: python app.py serve") sys.exit(1) if __name__ == "__main__": main() ``` In questo esempio, la `websocket_invoke` funzione gestisce la richiesta di inferenza che l' SageMaker IA invia all'endpoint. `/invocations-bidirectional-stream` Mostra la gestione delle richieste di streaming e lo streaming delle risposte al client. ## Come il tuo container deve rispondere alle richieste di controllo dello stato (Ping) SageMaker L'intelligenza artificiale lancia nuovi contenitori di inferenza nelle seguenti situazioni: + Risposta a `CreateEndpoint` `UpdateEndpoint` e chiamate API `UpdateEndpointWeightsAndCapacities` + Applicazione di patch di sicurezza + Sostituzione delle istanze non integre Subito dopo l'avvio del contenitore, l' SageMaker IA inizia a inviare richieste GET periodiche all'endpoint. `/ping` Il più semplice requisito per il container è di rispondere con un codice di stato HTTP 200 e un corpo vuoto. Ciò indica all' SageMaker IA che il contenitore è pronto ad accettare richieste di inferenza sull'endpoint. `/invocations` Se il container non inizia a passare i controlli dell’integrità rispondendo costantemente con 200 secondi durante gli 8 minuti successivi all’avvio, l’avvio della nuova istanza ha esito negativo. Ciò causa un errore in `CreateEndpoint` e lascia l’endpoint in uno stato di errore. L’aggiornamento richiesto da `UpdateEndpoint` non viene completato, le patch di sicurezza non verranno applicate e le istanze non integre non vengono sostituite. Nonostante la barra minima per il container è di fornire uno 200 statico, uno sviluppatore di container può utilizzare questa funzionalità per eseguire maggiori controlli. Il timeout della richiesta sui tentativi `/ping` è 2 secondi. Inoltre, un contenitore in grado di gestire richieste di streaming bidirezionali deve rispondere con un Pong Frame (per WebSocket protocollo [RFC6455](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)) a un Ping Frame. Se non viene ricevuto alcun Pong Frame per 5 Ping consecutivi, la connessione al contenitore verrà chiusa dalla SageMaker piattaforma AI. SageMaker La piattaforma AI risponderà anche ai Ping Frames del container modello con Pong Frames. ## Contratto container per supportare funzionalità di streaming bidirezionale Se desideri ospitare il tuo contenitore modello come endpoint SageMaker AI che supporta funzionalità di streaming bidirezionale, il contenitore modello deve supportare il seguente contratto: **1. Etichetta Docker bidirezionale** Il contenitore del modello dovrebbe avere un'etichetta Docker che indichi alla piattaforma SageMaker AI che la funzionalità di streaming bidirezionale è supportata su questo contenitore. ``` com.amazonaws.sagemaker.capabilities.bidirectional-streaming=true ``` **2. Support WebSocket Connection per le chiamate** Il contenitore modello di un cliente che supporta lo streaming bidirezionale deve supportare per impostazione predefinita WebSockets le connessioni sulla porta 8080 to. `/invocations-bidirectional-stream` Questo percorso può essere sovrascritto passando X-Amzn-SageMaker-Model l'intestazione -Invocation-Path quando si richiama l'API. InvokeEndpointWithBidirectionalStream Inoltre, gli utenti possono specificare una stringa di query da aggiungere a questo percorso passando l'intestazione -Query-String quando richiamano l'API. X-Amzn-SageMaker-Model InvokeEndpointWithBidirectionalStream **3. Richiedi la gestione dello stream** I payload di input dell' InvokeEndpointWithBidirectionalStream API vengono trasmessi in streaming come una serie di PayloadParts, che è solo un wrapper di un blocco binario («Bytes»:): ****** ``` { "PayloadPart": { "Bytes": , "DataType": , "CompletionState": "P": } } ``` **3.1. Frame di dati** SageMaker AI passa l'input PayloadParts al contenitore del modello come frame di WebSocket dati ([RFC6455-Section-5.6](https://datatracker.ietf.org/doc/html/rfc6455#section-5.6)) 1. SageMaker L'IA non ispeziona il blocco binario. 1. Alla ricezione di un input PayloadPart + SageMaker L'IA crea esattamente un WebSocket Data Frame da`PayloadPart.Bytes`, quindi lo passa al contenitore del modello. + Se`PayloadPart.DataType = UTF8`, SageMaker AI crea un frame di dati di testo + Se `PayloadPart.DataType` non presenta o`PayloadPart.DataType = BINARY`, SageMaker AI crea un Binary Data Frame 1. Per una sequenza di PayloadParts con e terminata da un con`PayloadPart.CompletionState = PARTIAL`, l' SageMaker IA li traduce in un PayloadPart messaggio WebSocket frammentato [RFC6455-Section-5.4](https://datatracker.ietf.org/doc/html/rfc6455#section-5.4): Frammentazione: `PayloadPart.CompletionState = COMPLETE` + La larghezza iniziale `PayloadPart.CompletionState = PARTIAL` verrà tradotta in un Data Frame, PayloadPart con FIN bit clear WebSocket . + Il PayloadParts with successivo `PayloadPart.CompletionState = PARTIAL` verrà tradotto in WebSocket Continuation Frames con FIN bit clear. + Il risultato finale PayloadPart `PayloadPart.CompletionState = COMPLETE` verrà tradotto in WebSocket Continuation Frame con bit FIN impostato. 1. SageMaker L'IA non codifica o decodifica il blocco binario dall'input PayloadPart, i byte vengono passati al contenitore del modello così com'è. 1. SageMaker L'intelligenza artificiale non combina più input in uno solo. PayloadParts BinaryDataFrame 1. SageMaker L'intelligenza artificiale non suddivide un input PayloadPart in più BinaryDataFrames input. **Esempio: flusso di messaggi frammentato** ``` Client sends: PayloadPart 1: {Bytes: "Hello ", DataType: "UTF8", CompletionState: "PARTIAL"} PayloadPart 2: {Bytes: "World", DataType: "UTF8", CompletionState: "COMPLETE"} Container receives: Frame 1: Text Data Frame with "Hello " (FIN=0) Frame 2: Continuation Frame with "World" (FIN=1) ``` **3.2. Telai di controllo** Oltre ai Data Frames, SageMaker AI invia anche Control Frames al contenitore del modello ([RFC6455-Section-5.5](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5)): 1. Close Frame: L' SageMaker IA può inviare Close Frame ([RFC6455-Section-5.5.1](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.1)) al contenitore del modello se la connessione viene chiusa per qualsiasi motivo. 1. Ping Frame: l' SageMaker IA invia Ping Frame ([RFC6455-Section-5.5.2](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2)) una volta ogni 60 secondi, il contenitore del modello deve rispondere con Pong Frame. Se non viene ricevuto alcun Pong Frame ([RFC6455-Section-5.5.3](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)) per 5 Ping consecutivi, la connessione verrà chiusa dall'IA. SageMaker 1. Pong Frame: SageMaker AI risponderà ai Ping Frame del contenitore modello con Pong Frames. **4. Gestione del flusso di risposta** L'output viene trasmesso in streaming come una serie di PayloadParts, ModelStreamErrors o InternalStreamFailures. ``` { "PayloadPart": { "Bytes": , "DataType": , "CompletionState": , }, "ModelStreamError": { "ErrorCode": , "Message": }, "InternalStreamFailure": { "Message": } } ``` **4.1. Frame di dati** SageMaker L'IA converte i frame di dati ricevuti dal contenitore del modello in output PayloadParts: 1. Dopo aver ricevuto un WebSocket Text Data Frame dal contenitore del modello, l' SageMaker IA ottiene i byte grezzi dal Text Data Frame e li avvolge in una risposta PayloadPart, nel frattempo impostata. `PayloadPart.DataType = UTF8` 1. Quando riceve un WebSocket Binary Data Frame dal contenitore del modello, l' SageMaker IA avvolge direttamente i byte dal frame di dati in una risposta, nel frattempo impostata. PayloadPart `PayloadPart.DataType = BINARY` 1. [Per i messaggi frammentati come definiti nella RFC6455 -Section-5.4: Frammentazione:](https://datatracker.ietf.org/doc/html/rfc6455#section-5.4) + Il Data Frame iniziale con FIN bit clear verrà tradotto in un with. PayloadPart `PayloadPart.CompletionState = PARTIAL` + I successivi Continuation Frames con FIN bit clear verranno tradotti in PayloadParts with`PayloadPart.CompletionState = PARTIAL`. + Il Continuation Frame finale con set di bit FIN verrà tradotto in PayloadPart with. `PayloadPart.CompletionState = COMPLETE` 1. SageMaker L'IA non codifica o decodifica i byte ricevuti dai contenitori del modello, i byte vengono passati al contenitore del modello così com'è. 1. SageMaker L'IA non combina più frame di dati ricevuti dal contenitore del modello in un'unica risposta. PayloadPart 1. SageMaker L'intelligenza artificiale non suddivide un Data Frame ricevuto dal contenitore del modello in più risposte PayloadParts. **Esempio: Streaming Response Flow** ``` Container sends: Frame 1: Text Data Frame with "Generating" (FIN=0) Frame 2: Continuation Frame with " response..." (FIN=1) Client receives: PayloadPart 1: {Bytes: "Generating", DataType: "UTF8", CompletionState: "PARTIAL"} PayloadPart 2: {Bytes: " response...", DataType: "UTF8", CompletionState: "COMPLETE"} ``` **4.2. Telai di controllo** SageMaker L'IA risponde ai seguenti Control Frames dal contenitore del modello: 1. Dopo aver ricevuto un Close Frame ([RFC6455-Section-5.5.1](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.1)) dal contenitore del modello, SageMaker AI ModelStreamError inserirà il codice di stato ([RFC6455-Section-7.4](https://datatracker.ietf.org/doc/html/rfc6455#section-7.4)) e i messaggi di errore e lo trasmetterà all'utente finale. 1. Alla ricezione di un Ping Frame ([RFC6455-Section-5.5.2](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.2)) dal contenitore del modello, l'IA risponderà con Pong Frame. SageMaker 1. Pong Frame ([RFC6455-Section-5.5.3](https://datatracker.ietf.org/doc/html/rfc6455#section-5.5.3)): Se non viene ricevuto alcun Pong Frame per 5 ping consecutivi, la connessione verrà chiusa dall'IA. SageMaker # Utilizzo di un registro Docker privato per container di inferenza in tempo reale L'hosting Amazon SageMaker AI ti consente di utilizzare le immagini archiviate in Amazon ECR per creare contenitori per l'inferenza in tempo reale per impostazione predefinita. Facoltativamente, puoi creare container per l'inferenza in tempo reale da immagini in un registro Docker privato. Il registro privato deve essere accessibile da un Amazon VPC nel tuo account. I modelli creati in base alle immagini archiviate nel registro Docker privato devono essere configurati per connettersi allo stesso VPC in cui è accessibile il registro Docker privato. Per ulteriori informazioni sulla connessione del modello a un VPC, consulta [Offri agli endpoint ospitati dall' SageMaker intelligenza artificiale l'accesso alle risorse nel tuo Amazon VPC](host-vpc.md). Il registro Docker deve essere protetto con un certificato TLS di un'autorità di certificazione (CA) pubblica nota. **Nota** Il tuo registro Docker privato deve consentire il traffico in entrata dai gruppi di sicurezza specificati nella configurazione VPC per il tuo modello, in modo che l'hosting SageMaker AI sia in grado di estrarre le immagini del modello dal tuo registro. SageMaker L'intelligenza artificiale può estrarre immagini di modelli DockerHub se esiste un percorso verso una rete Internet aperta all'interno del tuo VPC. **Topics** + [Archiviazione delle immagini in un registro Docker privato diverso da Amazon Elastic Container Registry](#your-algorithms-containers-inference-private-registry) + [Utilizzo di un'immagine da un registro Docker privato per l'inferenza in tempo reale](#your-algorithms-containers-inference-private-use) + [Consenti all' SageMaker IA di autenticarsi in un registro Docker privato](#inference-private-docker-authenticate) + [Creazione della funzione Lambda](#inference-private-docker-lambda) + [Concedi a Lamba l’autorizzazione per il tuo ruolo di esecuzione](#inference-private-docker-perms) + [Creazione di un endpoint VPC di interfaccia per Lambda](#inference-private-docker-vpc-interface) ## Archiviazione delle immagini in un registro Docker privato diverso da Amazon Elastic Container Registry Per utilizzare un registro Docker privato per archiviare le tue immagini per l'inferenza SageMaker AI in tempo reale, crea un registro privato accessibile dal tuo Amazon VPC. Per informazioni sulla creazione di un registro Docker, consulta [Deploy a registry server](https://docs.docker.com/registry/deploying/) nella documentazione Docker. Il registro Docker deve rispettare quanto segue: + Il registro deve essere un registro [Registro Docker HTTP API V2](https://docs.docker.com/registry/spec/api/). + Il registro Docker deve essere accessibile dallo stesso VPC specificato nel parametro `VpcConfig` al momento della creazione del modello. ## Utilizzo di un'immagine da un registro Docker privato per l'inferenza in tempo reale Quando crei un modello e lo distribuisci su un hosting SageMaker AI, puoi specificare che utilizzi un'immagine del tuo registro Docker privato per creare il contenitore di inferenza. Specificalo nell'oggetto `ImageConfig` nel parametro `PrimaryContainer` che inoltri a una chiamata alla funzione [create\$1model](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model). **Per utilizzare un'immagine archiviata nel registro Docker privato per il container di inferenza** 1. Crea l'oggetto di configurazione dell'immagine e specifica un valore `Vpc` per il campo `RepositoryAccessMode`. ``` image_config = { 'RepositoryAccessMode': 'Vpc' } ``` 1. Se il registro Docker privato richiede l'autenticazione, aggiungi un oggetto `RepositoryAuthConfig` all'oggetto di configurazione dell'immagine. Per il `RepositoryCredentialsProviderArn` campo dell'`RepositoryAuthConfig`oggetto, specifica l'Amazon Resource Name (ARN) di una AWS Lambda funzione che fornisce credenziali che consentono all' SageMaker IA di autenticarsi nel tuo registro Docker privato. Per informazioni su come creare la funzione Lambda per fornire l'autenticazione, consulta [Consenti all' SageMaker IA di autenticarsi in un registro Docker privato](#inference-private-docker-authenticate). ``` image_config = { 'RepositoryAccessMode': 'Vpc', 'RepositoryAuthConfig': { 'RepositoryCredentialsProviderArn': 'arn:aws:lambda:Region:Acct:function:FunctionName' } } ``` 1. Crea l'oggetto container principale da trasferire a `create_model`, utilizzando l'oggetto di configurazione dell'immagine creato nella fase precedente. Fornisci la tua immagine in formato [digest](https://docs.docker.com/engine/reference/commandline/pull/#pull-an-image-by-digest-immutable-identifier). Se fornisci l'immagine utilizzando il `:latest` tag, c'è il rischio che l' SageMaker intelligenza artificiale recuperi una versione dell'immagine più recente di quella prevista. L'utilizzo del modulo riepilogativo garantisce che l' SageMaker intelligenza artificiale estragga la versione dell'immagine desiderata. ``` primary_container = { 'ContainerHostname': 'ModelContainer', 'Image': 'myteam.myorg.com/docker-local/my-inference-image:', 'ImageConfig': image_config } ``` 1. Specifica il nome del modello e il ruolo di esecuzione che desideri inoltrare a `create_model`. ``` model_name = 'vpc-model' execution_role_arn = 'arn:aws:iam::123456789012:role/SageMakerExecutionRole' ``` 1. Specifica uno o più gruppi di sicurezza e sottoreti per la configurazione VPC per il tuo modello. Il registro Docker privato deve consentire il traffico in ingresso dai gruppi di sicurezza specificati. Le sottoreti specificate devono trovarsi nello stesso VPC del registro Docker privato. ``` vpc_config = { 'SecurityGroupIds': ['sg-0123456789abcdef0'], 'Subnets': ['subnet-0123456789abcdef0','subnet-0123456789abcdef1'] } ``` 1. Ottieni un client AI Boto3 SageMaker . ``` import boto3 sm = boto3.client('sagemaker') ``` 1. Crea il modello richiamando `create_model`, utilizzando i valori specificati nelle fasi precedenti per i parametri `PrimaryContainer` e `VpcConfig`. ``` try: resp = sm.create_model( ModelName=model_name, PrimaryContainer=primary_container, ExecutionRoleArn=execution_role_arn, VpcConfig=vpc_config, ) except Exception as e: print(f'error calling CreateModel operation: {e}') else: print(resp) ``` 1. Infine, richiama [create\$1endpoint\$1config](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint_config) e [create\$1endpoint](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_endpoint) per creare l'endpoint di hosting, utilizzando il modello creato nella fase precedente. ``` endpoint_config_name = 'my-endpoint-config' sm.create_endpoint_config( EndpointConfigName=endpoint_config_name, ProductionVariants=[ { 'VariantName': 'MyVariant', 'ModelName': model_name, 'InitialInstanceCount': 1, 'InstanceType': 'ml.t2.medium' }, ], ) endpoint_name = 'my-endpoint' sm.create_endpoint( EndpointName=endpoint_name, EndpointConfigName=endpoint_config_name, ) sm.describe_endpoint(EndpointName=endpoint_name) ``` ## Consenti all' SageMaker IA di autenticarsi in un registro Docker privato [Per estrarre un'immagine di inferenza da un registro Docker privato che richiede l'autenticazione, crea una AWS Lambda funzione che fornisca le credenziali e fornisci l'Amazon Resource Name (ARN) della funzione Lambda quando chiami create\$1model.](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sagemaker.html#SageMaker.Client.create_model) Quando l' SageMaker intelligenza artificiale viene eseguita`create_model`, chiama la funzione Lambda specificata per ottenere le credenziali per l'autenticazione nel registro Docker. ## Creazione della funzione Lambda Crea una AWS Lambda funzione che restituisca una risposta con il seguente modulo: ``` def handler(event, context): response = { "Credentials": {"Username": "username", "Password": "password"} } return response ``` A seconda di come configuri l'autenticazione per il tuo registro Docker privato, le credenziali restituite dalla funzione Lambda possono significare una delle seguenti cose: + Se configuri il registro Docker privato per utilizzare l'autenticazione di base, fornisci le credenziali di accesso per l'autenticazione nel registro. + Se configuri il tuo registro Docker privato per utilizzare l'autenticazione con token bearer, le credenziali di accesso vengono inviate al tuo server di autorizzazione, che restituisce un token bearer che può quindi essere utilizzato per l'autenticazione nel registro Docker privato. ## Concedi a Lamba l’autorizzazione per il tuo ruolo di esecuzione Il ruolo di esecuzione utilizzato per chiamare `create_model` deve disporre delle autorizzazioni per chiamare AWS Lambda le funzioni. Aggiungi quanto segue alla policy sulle autorizzazioni del tuo ruolo di esecuzione. ``` { "Effect": "Allow", "Action": [ "lambda:InvokeFunction" ], "Resource": [ "arn:aws:lambda:*:*:function:*myLambdaFunction*" ] } ``` *myLambdaFunction*Dov'è il nome della tua funzione Lambda. Per informazioni su come modificare le autorizzazioni per un ruolo, consulta [Modifying a role permissions policy (console)](https://docs.aws.amazon.com/IAM/latest/UserGuide/roles-managingrole-editing-console.html#roles-modify_permissions-policy) nella *Guida per l’utente AWS Identity and Access Management *. **Nota** Un ruolo di esecuzione a cui è associata la policy `AmazonSageMakerFullAccess` gestita è autorizzato a chiamare qualsiasi funzione Lambda con **SageMaker**nel suo nome. ## Creazione di un endpoint VPC di interfaccia per Lambda Crea un endpoint di interfaccia in modo che Amazon VPC possa comunicare con la tua funzione AWS Lambda senza inviare traffico su Internet. Per informazioni su come svolgere questa operazione, consulta [Configuring interface VPC endpoints for Lambda](https://docs.aws.amazon.com/lambda/latest/dg/configuration-vpc-endpoints.html) nella *AWS Lambda Guida per gli sviluppatori*. SageMaker L'hosting AI invia una richiesta tramite il tuo VPC a`lambda.region.amazonaws.com`, per chiamare la tua funzione Lambda. Se scegli il Nome DNS privato quando crei l'endpoint di interfaccia, Amazon Route 53 indirizza la chiamata all'endpoint dell'interfaccia Lambda. Se utilizzi un provider DNS diverso, assicurati di mappare `lambda.region.amazonaws.com` all'endpoint dell'interfaccia Lambda. # Codice di inferenza personalizzato con la trasformazione in batch Questa sezione spiega come Amazon SageMaker AI interagisce con un contenitore Docker che esegue il tuo codice di inferenza per la trasformazione in batch. Utilizza queste informazioni per scrivere il codice di inferenza e creare un'immagine Docker. **Topics** + [In che modo l' SageMaker intelligenza artificiale gestisce la tua immagine di inferenza](#your-algorithms-batch-code-run-image) + [In che modo l' SageMaker IA carica gli artefatti del modello](#your-algorithms-batch-code-load-artifacts) + [Come i container servono le richieste](#your-algorithms-batch-code-how-containe-serves-requests) + [Come il tuo container deve rispondere alle richieste di inferenza](#your-algorithms-batch-code-how-containers-should-respond-to-inferences) + [Come il tuo container deve rispondere alle richieste di controllo dello stato (Ping)](#your-algorithms-batch-algo-ping-requests) ## In che modo l' SageMaker intelligenza artificiale gestisce la tua immagine di inferenza Per configurare un container per l'esecuzione come un eseguibile, utilizza un'istruzione `ENTRYPOINT` in un Dockerfile. Tenere presente quanto segue: + Per le trasformazioni in batch, l' SageMaker intelligenza artificiale richiama il modello per tuo conto. SageMaker L'IA esegue il contenitore come: ``` docker run image serve ``` L'input per le trasformazioni in batch deve essere in un formato che possa essere suddiviso in file più piccoli da elaborare in parallelo. [Questi formati includono CSV, [JSON, JSON](https://www.json.org/json-en.html)[Lines](https://jsonlines.org/) e [TFRecord](https://www.tensorflow.org/tutorials/load_data/tfrecord)ReCordio.](https://mesos.apache.org/documentation/latest/recordio/) SageMaker L'IA sostituisce le `CMD` istruzioni predefinite in un contenitore specificando l'argomento dopo il nome dell'immagine. `serve` L'argomento `serve` sostituisce gli argomenti che fornisci con il comando `CMD` nel Dockerfile.   + Ti consigliamo di utilizzare il modulo `exec` dell'istruzione `ENTRYPOINT`: ``` ENTRYPOINT ["executable", "param1", "param2"] ``` Esempio: ``` ENTRYPOINT ["python", "k_means_inference.py"] ```   + SageMaker L'intelligenza artificiale imposta le variabili di ambiente specificate nel [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html)e [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateTransformJob.html)sul contenitore. Inoltre, vengono popolate le seguenti variabili di ambiente: + `SAGEMAKER_BATCH` è impostato su `true` quando il container esegue una trasformazione in batch. + `SAGEMAKER_MAX_PAYLOAD_IN_MB` è impostato sul payload di dimensioni più grandi che viene inviato al container tramite HTTP. + `SAGEMAKER_BATCH_STRATEGY` è impostato su `SINGLE_RECORD` quando il container invia un singolo record per effettuare le invocazioni e chiamare `MULTI_RECORD` quando il container riceve tutti i record che rientrano nel payload. + `SAGEMAKER_MAX_CONCURRENT_TRANSFORMS` è impostato sul numero massimo di richieste di `/invocations` che possono essere aperte contemporaneamente. **Nota** Le ultime tre variabili di ambiente provengono dalla chiamata API effettuata dall'utente. Se l'utente non ne imposta i valori, le variabili non vengono inoltrate. In questo caso, sono utilizzati i valori predefiniti o i valori richiesti dall'algoritmo (in risposta a `/execution-parameters`). + Se prevedi di utilizzare dispositivi GPU per le inferenze di modelli (specificando le istanze di calcolo ML basate su GPU nella richiesta `CreateTransformJob`), accertati che i container siano compatibili con nvidia-docker. Non aggregare i driver NVIDIA con l'immagine. Per ulteriori informazioni su nvidia-docker, consulta [NVIDIA/nvidia-docker](https://github.com/NVIDIA/nvidia-docker).   + Non puoi usare l'`init`inizializzatore come punto di ingresso nei contenitori SageMaker AI perché viene confuso dagli argomenti «train and serve». ## In che modo l' SageMaker IA carica gli artefatti del modello In una richiesta [https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_CreateModel.html), le definizioni del container comprendono il parametro `ModelDataUrl`, che identifica la posizione in Amazon S3 in cui sono archiviati gli artefatti del modello. Quando si utilizza l' SageMaker intelligenza artificiale per eseguire inferenze, utilizza queste informazioni per determinare da dove copiare gli artefatti del modello. Gli artefatti vengono copiati nella directory `/opt/ml/model` nel container Docker per essere utilizzati dal codice di inferenza. Il parametro di `ModelDataUrl` deve puntare a un file tar.gz. Altrimenti, l' SageMaker IA non può scaricare il file. Se si addestra un modello in SageMaker intelligenza artificiale, gli artefatti vengono salvati in un unico file tar compresso in Amazon S3. Se addestra un modello in un altro framework, devi archiviare gli artefatti del modello in Amazon S3 come file tar compresso. SageMaker AI decomprime questo file tar e lo salva nella `/opt/ml/model` directory del contenitore prima dell'inizio del processo di trasformazione in batch. ## Come i container servono le richieste I container devono implementare un server Web che risponde a invocazioni e richieste ping sulla porta 8080. Per le trasformazioni in batch, hai la possibilità di impostare algoritmi per implementare le richieste di parametri di esecuzione per fornire una configurazione di runtime dinamica all'IA. SageMaker SageMaker L'intelligenza artificiale utilizza i seguenti endpoint: + `ping`—Utilizzato per controllare periodicamente lo stato del contenitore. SageMaker L'IA attende un codice di `200` stato HTTP e un corpo vuoto per una richiesta ping riuscita prima di inviare una richiesta di invocazione. Puoi utilizzare una richiesta ping per caricare un modello in memoria per generare inferenza quando vengono inviate richieste di invocazioni. + (Facoltativo) `execution-parameters`: consente all'algoritmo di fornire i parametri di sincronizzazione ottimali per un processo durante il runtime. In base alla memoria e alla CPUs disponibilità di un contenitore, l'algoritmo sceglie i `MaxPayloadInMB` valori e i valori appropriati `MaxConcurrentTransforms` per il lavoro. `BatchStrategy` Prima di chiamare la richiesta di invocazione, l' SageMaker IA tenta di richiamare la richiesta dei parametri di esecuzione. Quando si crea un processo di trasformazione in batch, è possibile fornire valori per i `MaxConcurrentTransforms` parametri, e. `BatchStrategy` `MaxPayloadInMB` SageMaker L'IA determina i valori per questi parametri utilizzando questo ordine di precedenza: 1. I valori dei parametri forniti al momento della creazione della richiesta `CreateTransformJob`. 1. I valori restituiti dal contenitore del modello quando l' SageMaker IA richiama l'endpoint-parameters di esecuzione> 1. I valori predefiniti del parametro, elencati nella seguente tabella. [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/it_it/sagemaker/latest/dg/your-algorithms-batch-code.html) La risposta per una richiesta execution-parameters `GET` è un oggetto JSON con chiavi per i parametri `MaxConcurrentTransforms`, `BatchStrategy` e `MaxPayloadInMB`. Di seguito è riportato un esempio di risposta valida: ``` { “MaxConcurrentTransforms”: 8, “BatchStrategy": "MULTI_RECORD", "MaxPayloadInMB": 6 } ``` ## Come il tuo container deve rispondere alle richieste di inferenza Per ottenere inferenze, Amazon SageMaker AI invia una richiesta POST al contenitore di inferenza. Il corpo della richiesta POST contiene dati da Amazon S3. Amazon SageMaker AI passa la richiesta al contenitore e ne restituisce il risultato dell'inferenza, salvando i dati della risposta ad Amazon S3. Per ricevere le richieste di inferenza, il container deve disporre di un server Web in ascolto sulla porta 8080 e deve accettare le richieste all'endpoint `/invocations`. Il timeout della richiesta di inferenza e il numero massimo di tentativi possono essere configurati tramite `[ModelClientConfig](https://docs.aws.amazon.com/sagemaker/latest/APIReference/API_ModelClientConfig.html)`. ## Come il tuo container deve rispondere alle richieste di controllo dello stato (Ping) Il più semplice requisito per il container è di rispondere con un codice di stato HTTP 200 e un corpo vuoto. Ciò indica all' SageMaker IA che il contenitore è pronto ad accettare richieste di inferenza sull'endpoint. `/invocations` Nonostante la barra minima per il container è di fornire uno 200 statico, uno sviluppatore di container può utilizzare questa funzionalità per eseguire maggiori controlli. Il timeout della richiesta sui tentativi `/ping` è 2 secondi. # Esempi e ulteriori informazioni: utilizzo del proprio algoritmo o modello I seguenti notebook Jupyter e le informazioni aggiuntive mostrano come utilizzare i propri algoritmi o modelli preaddestrati da un'istanza di Amazon Notebook. SageMaker Per i collegamenti agli GitHub archivi con i Dockerfile predefiniti per TensorFlow, MXNet, Chainer e i PyTorch framework e le istruzioni sull'uso degli AWS SDK per Python (Boto3) stimatori per eseguire i tuoi algoritmi di addestramento su AI Learner e i tuoi modelli sull'hosting AI, consulta SageMaker SageMaker [Immagini Docker SageMaker AI predefinite per il deep learning](pre-built-containers-frameworks-deep-learning.md) ## Configurazione 1. Crea un'istanza di notebook. SageMaker Per istruzioni su come creare e accedere a istanze del notebook Jupyter, consulta [Istanze SageMaker per notebook Amazon](nbi.md). 1. Apri l'istanza del notebook che hai creato. 1. Scegli la scheda **Esempi SageMaker AI** per un elenco di tutti i notebook di esempio SageMaker AI. 1. Apri i taccuini di esempio dalla sezione **Funzionalità avanzate** dell'istanza del tuo notebook o utilizzando i link forniti. GitHub Per aprire un notebook, seleziona la relativa scheda **Usa**, quindi scegli **Crea copia**. ## Hosting di modelli addestrati in Scikit-learn Per scoprire come ospitare modelli addestrati in Scikit-learn per fare previsioni nell' SageMaker intelligenza artificiale iniettandoli in k-means e contenitori di prima parte, consulta i seguenti notebook di esempio. XGBoost + [kmeans\$1bring\$1your\$1own\$1model](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/kmeans_bring_your_own_model) + [xgboost\$1bring\$1your\$1own\$1model](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/xgboost_bring_your_own_model) ## Modelli Package TensorFlow e Scikit-learn da utilizzare nell'IA SageMaker Per imparare a impacchettare gli algoritmi che hai sviluppato e i framework scikit-learn per l'addestramento TensorFlow e l'implementazione nell'ambiente AI, consulta i seguenti taccuini. SageMaker Questi mostrano come compilare, registrare e distribuire i container Docker utilizzando Dockerfile. + [tensorflow\$1bring\$1your\$1own](https://github.com/aws/amazon-sagemaker-examples/blob/main/advanced_functionality/tensorflow_iris_byom/tensorflow_BYOM_iris.ipynb) + [scikit\$1bring\$1your\$1own](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/scikit_bring_your_own) ## Addestra e implementa una rete neurale sull'intelligenza artificiale SageMaker Per informazioni su come addestrare una rete neurale localmente utilizzando MXNet o TensorFlow, quindi, creare un endpoint dal modello addestrato e distribuirlo sull' SageMaker intelligenza artificiale, consulta i seguenti taccuini. Il MXNet modello è addestrato a riconoscere i numeri scritti a mano dal set di dati MNIST. Il TensorFlow modello è addestrato a classificare le iridi. + [mxnet\$1mnist\$1byom](https://sagemaker.readthedocs.io/en/stable/frameworks/mxnet/using_mxnet.html) + [tensorflow\$1BYOM\$1iris](https://github.com/awslabs/amazon-sagemaker-examples/tree/master/advanced_functionality/tensorflow_iris_byom/tensorflow_BYOM_iris.ipynb) ## Addestramento in modalità pipe Per ulteriori informazioni su come utilizzare un Dockerfile per compilare un container che chiama `train.py script` e utilizza la modalità pipe per eseguire l’addestramento personalizzato di un algoritmo, consulta i seguenti notebook. In modalità pipe, i dati di input vengono trasferiti all'algoritmo durante l’addestramento dello stesso. Questo consente di ridurre il tempo di addestramento rispetto all'utilizzo della modalità file. + [pipe\$1bring\$1your\$1own](https://github.com/aws/amazon-sagemaker-examples/blob/0efd885ef2a5c04929d10c5272681f4ca17dac17/advanced_functionality/pipe_bring_your_own/pipe_bring_your_own.ipynb) ## Usa il tuo modello R Per informazioni su come utilizzare l'aggiunta di un'immagine R personalizzata per creare e addestrare un modello in un notebook AWS SMS , consulta il seguente post del blog. Questo post sul blog utilizza un Dockerfile R di esempio da una libreria di esempi di [immagini personalizzate di SageMaker AI Studio Classic](https://github.com/aws-samples/sagemaker-studio-custom-image-samples). + [Portare il proprio ambiente R in Amazon SageMaker Studio Classic](https://aws.amazon.com/blogs/machine-learning/bringing-your-own-r-environment-to-amazon-sagemaker-studio/) ## Estendi un'immagine del PyTorch contenitore preconfigurata Per sapere come estendere un'immagine di PyTorch contenitore SageMaker AI precostruita quando hai requisiti funzionali aggiuntivi per il tuo algoritmo o modello che l'immagine Docker precostruita non supporta, consulta il seguente taccuino. + [BERTtopic\$1estending\$1container](https://github.com/aws/amazon-sagemaker-examples/blob/0efd885ef2a5c04929d10c5272681f4ca17dac17/advanced_functionality/pytorch_extend_container_train_deploy_bertopic/BERTtopic_extending_container.ipynb) Per ulteriori informazioni sull'estensione di un container, consulta [Extend a Pre-built Container](https://docs.aws.amazon.com/sagemaker/latest/dg/prebuilt-containers-extend.html). ## Addestra ed esegui il debug di processi di addestramento su un container personalizzato Per informazioni su come addestrare ed eseguire il debug dei lavori di formazione utilizzando SageMaker Debugger, consulta il seguente taccuino. Uno script di formazione fornito tramite questo esempio utilizza il modello TensorFlow Keras ResNet 50 e il set di dati. CIFAR10 Un container personalizzato Docker viene creato con lo script di addestramento e inviato ad Amazon ECR. Durante l'esecuzione del processo di addestramento, Debugger raccoglie gli output dei tensori e identifica i problemi di debug. Con gli strumenti della libreria client `smdebug`, puoi impostare un oggetto di prova `smdebug` che richiama il processo di addestramento e le informazioni di debug, controlla lo stato delle regole di addestramento e Debugger e recupera i tensori salvati in un bucket Amazon S3 per analizzare i problemi di addestramento. + [build\$1your\$1own\$1container\$1with\$1debugger](https://sagemaker-examples.readthedocs.io/en/latest/sagemaker-debugger/build_your_own_container_with_debugger/debugger_byoc.html) ## Risoluzione dei problemi relativi ai container Docker e alle implementazioni Di seguito sono riportati gli errori più comuni che potresti riscontrare quando utilizzi Docker contenitori con intelligenza artificiale. SageMaker Ogni errore è seguito da una soluzione all'errore. + **Errore: l' SageMaker IA ha perso il Docker demone.** Per risolvere questo errore, riavvia Docker utilizzando il comando seguente. ``` sudo service docker restart ``` + ** Errore: lo spazio nella directory `/tmp` del container Docker è esaurito.** I container Docker utilizzano le partizioni `/` e `/tmp` per archiviare codice. Queste partizioni possono riempirsi facilmente quando si utilizzano moduli di codice di grandi dimensioni in modalità locale. L'SDK SageMaker AI Python supporta la specificazione di una directory temporanea personalizzata per la directory principale in modalità locale per evitare questo problema. Per specificare la directory temporanea personalizzata nell’archiviazione del volume Amazon Elastic Block Store, crea un file al seguente percorso `~/.sagemaker/config.yaml` e aggiungi la seguente configurazione. La directory specificata come `container_root` deve essere già esistente. L'SDK SageMaker AI Python non proverà a crearlo. ``` local: container_root: /home/ec2-user/SageMaker/temp ``` Con questa configurazione, la modalità locale utilizza la directory `/temp` e non la directory predefinita `/tmp`. + **Errori di spazio insufficiente sulle istanze del notebook SageMaker ** Un Docker contenitore che funziona su istanze SageMaker notebook utilizza per impostazione predefinita il volume Amazon EBS root dell'istanza notebook. Per risolvere errori di spazio insufficiente, fornisci il percorso del volume Amazon EBS collegato all’istanza di notebook come parte del parametro volume dei comandi Docker. ``` docker run -v EBS-volume-path:container-path ```