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

# Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker
<a name="data-parallel-use-api"></a>

Per eseguire un processo di formazione distribuito con il tuo script adattato da[Adattamento dello script di addestramento per l’utilizzo delle operazioni collettive SMDDP](data-parallel-modify-sdp-select-framework.md), usa il framework di SageMaker Python SDK o gli stimatori generici specificando lo script di formazione preparato come script di ingresso e la configurazione di formazione distribuita.

Questa pagina illustra come utilizzare [SageMaker AI Python SDK](https://sagemaker.readthedocs.io/en/stable/api/training/index.html) in due modi.
+ Se vuoi adottare rapidamente il tuo lavoro di formazione distribuito sull' SageMaker intelligenza artificiale, configura una classe di stima dell' SageMaker intelligenza artificiale [PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch)o del [TensorFlow](https://sagemaker.readthedocs.io/en/stable/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator)framework. Il framework estimator preleva lo script di allenamento e abbina automaticamente l'URI dell'immagine corretta dei Deep Learning Containers (DLC) [predefiniti PyTorch o dei TensorFlow Deep Learning Containers (DLC)](https://github.com/aws/deep-learning-containers/blob/master/available_images.md#sagemaker-framework-containers-sm-support-only), dato il valore specificato nel parametro. `framework_version`
+ Se desideri estendere uno dei container predefiniti o creare un contenitore personalizzato per creare il tuo ambiente ML con SageMaker AI, usa la `Estimator` classe generica SageMaker AI e specifica l'URI dell'immagine del contenitore Docker personalizzato ospitato nel tuo Amazon Elastic Container Registry (Amazon ECR).

I tuoi set di dati di formazione devono essere archiviati in Amazon S3 o [ FSx Amazon for](https://docs.aws.amazon.com/fsx/latest/LustreGuide/what-is.html) Lustre nel luogo in cui stai avviando Regione AWS il tuo processo di formazione. Se utilizzi notebook Jupyter, dovresti avere un'istanza SageMaker notebook o un'app Studio Classic in esecuzione sullo stesso. SageMaker Regione AWS Per ulteriori informazioni sull'archiviazione dei dati di addestramento, consulta la documentazione sugli input di [dati dell'SDK di SageMaker Python](https://sagemaker.readthedocs.io/en/stable/overview.html#use-file-systems-as-training-input). 

**Suggerimento**  
Ti consigliamo di utilizzare Amazon FSx for Lustre anziché Amazon S3 per migliorare le prestazioni di formazione. Amazon FSx ha un throughput più elevato e una latenza inferiore rispetto ad Amazon S3.

**Suggerimento**  
Per eseguire correttamente l’addestramento distribuito sui tipi di istanze abilitati per EFA, è necessario abilitare il traffico tra le istanze configurando il gruppo di sicurezza del VPC per consentire tutto il traffico in entrata e in uscita dal gruppo stesso. Per informazioni su come configurare le regole del gruppo di sicurezza, consulta [Fase 1: preparare un gruppo di sicurezza abilitato per EFA](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html#efa-start-security) nella *Guida per l’utente di Amazon EC2*.

Scegli uno degli argomenti seguenti per istruzioni su come eseguire un job di addestramento distribuito del tuo script di addestramento. Dopo aver avviato un processo di formazione, puoi monitorare l'utilizzo del sistema e modellare le prestazioni utilizzando Amazon [Amazon SageMaker Debugger](train-debugger.md) o Amazon CloudWatch.

Oltre a seguire le istruzioni riportate nei seguenti argomenti per saperne di più sui dettagli tecnici, ti consigliamo anche di provare [Esempi di librerie di parallelismo dei dati di Amazon SageMaker AI](distributed-data-parallel-v2-examples.md) per iniziare.

**Topics**
+ [Usa gli stimatori del PyTorch framework nell'SDK SageMaker Python](data-parallel-framework-estimator.md)
+ [Usa lo stimatore generico SageMaker AI per estendere i contenitori DLC predefiniti](data-parallel-use-python-skd-api.md)
+ [Crea il tuo contenitore Docker con la libreria parallela di dati distribuiti SageMaker AI](data-parallel-bring-your-own-container.md)

# Usa gli stimatori del PyTorch framework nell'SDK SageMaker Python
<a name="data-parallel-framework-estimator"></a>

Puoi avviare un corso di formazione distribuito aggiungendo l'`distribution`argomento agli estimatori del framework SageMaker AI oppure. [https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/sagemaker.pytorch.html#sagemaker.pytorch.estimator.PyTorch) Per maggiori dettagli, scegli uno dei framework supportati dalla libreria SageMaker AI distributed data parallelism (SMDDP) tra le seguenti selezioni.

------
#### [ PyTorch ]

Le seguenti opzioni di avvio sono disponibili per avviare la formazione distribuita. PyTorch 
+ `pytorchddp`— Questa opzione esegue `mpirun` e imposta le variabili di ambiente necessarie per eseguire la formazione PyTorch distribuita sull' SageMaker intelligenza artificiale. Per utilizzare questa opzione, passa il seguente dizionario al parametro `distribution`.

  ```
  { "pytorchddp": { "enabled": True } }
  ```
+ `torch_distributed`— Questa opzione esegue `torchrun` e imposta le variabili di ambiente necessarie per eseguire l'addestramento PyTorch distribuito sull' SageMaker intelligenza artificiale. Per utilizzare questa opzione, passa il seguente dizionario al parametro `distribution`.

  ```
  { "torch_distributed": { "enabled": True } }
  ```
+ `smdistributed`— Anche questa opzione funziona`mpirun`, ma insieme a `smddprun` ciò imposta le variabili di ambiente necessarie per eseguire la formazione PyTorch distribuita sull' SageMaker intelligenza artificiale.

  ```
  { "smdistributed": { "dataparallel": { "enabled": True } } }
  ```

Se si sceglie di sostituire `AllGather` NCCL con `AllGather` SMDDP, è possibile utilizzare tutte le tre opzioni. Scegli un’opzione adatta al tuo caso d’uso.

Se hai scelto di sostituire `AllReduce` NCCL con `AllReduce` SMDDP, devi scegliere una delle opzioni basate su `mpirun`: `smdistributed` o `pytorchddp`. Puoi anche aggiungere ulteriori opzioni MPI come segue.

```
{ 
    "pytorchddp": {
        "enabled": True, 
        "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION"
    }
}
```

```
{ 
    "smdistributed": { 
        "dataparallel": {
            "enabled": True, 
            "custom_mpi_options": "-verbose -x NCCL_DEBUG=VERSION"
        }
    }
}
```

Il seguente esempio di codice mostra la struttura di base di uno PyTorch stimatore con opzioni di formazione distribuite.

```
from sagemaker.pytorch import PyTorch

pt_estimator = PyTorch(
    base_job_name="training_job_name_prefix",
    source_dir="subdirectory-to-your-code",
    entry_point="adapted-training-script.py",
    role="SageMakerRole",
    py_version="py310",
    framework_version="2.0.1",

    # For running a multi-node distributed training job, specify a value greater than 1
    # Example: 2,3,4,..8
    instance_count=2,

    # Instance types supported by the SageMaker AI data parallel library: 
    # ml.p4d.24xlarge, ml.p4de.24xlarge
    instance_type="ml.p4d.24xlarge",

    # Activate distributed training with SMDDP
    distribution={ "pytorchddp": { "enabled": True } }  # mpirun, activates SMDDP AllReduce OR AllGather
    # distribution={ "torch_distributed": { "enabled": True } }  # torchrun, activates SMDDP AllGather
    # distribution={ "smdistributed": { "dataparallel": { "enabled": True } } }  # mpirun, activates SMDDP AllReduce OR AllGather
)

pt_estimator.fit("s3://bucket/path/to/training/data")
```

**Nota**  
PyTorch Lightning e le sue librerie di utilità come Lightning Bolts non sono preinstallate nell'IA. SageMaker PyTorch DLCs Crea il seguente file `requirements.txt` e salvalo nella directory di origine in cui salvi lo script di addestramento.  

```
# requirements.txt
pytorch-lightning
lightning-bolts
```
Ad esempio, la struttura di directory deve essere simile alla seguente:  

```
├── pytorch_training_launcher_jupyter_notebook.ipynb
└── sub-folder-for-your-code
    ├──  adapted-training-script.py
    └──  requirements.txt
```
Per ulteriori informazioni su come specificare la directory di origine in cui inserire il `requirements.txt` file insieme allo script di formazione e all'invio di un lavoro, consulta la sezione [Utilizzo di librerie di terze parti nella documentazione](https://sagemaker.readthedocs.io/en/stable/frameworks/pytorch/using_pytorch.html#id12) di *Amazon AI SageMaker Python SDK*.

**Considerazioni sull’attivazione delle operazioni collettive SMDDP e sull’utilizzo delle opzioni idonee di avvio dell’addestramento distribuito**
+ `AllReduce` e `AllGather` SMDDP non sono attualmente compatibili tra loro.
+ `AllReduce` SMDDP è attivato per impostazione predefinita in caso di utilizzo di `smdistributed` o `pytorchddp`, ovvero programmi di avvio basati su `mpirun`, e viene utilizzata l’operazione `AllGather` NCCL.
+ L’operazione `AllGather` SMDDP è attivata per impostazione predefinita in caso di utilizzo del programma di avvio `torch_distributed` e `AllReduce` ricorre a NCCL.
+ È possibile attivare `AllGather` SMDDP anche in caso di utilizzo dei programmi di avvio basati su `mpirun` con una variabile di ambiente aggiuntiva impostata come segue.

  ```
  export SMDATAPARALLEL_OPTIMIZE_SDP=true
  ```

------
#### [ TensorFlow ]

**Importante**  
La libreria SMDDP ha interrotto il supporto TensorFlow e non è più disponibile nelle versioni successive alla versione 2.11.0. DLCs TensorFlow Per trovare le versioni precedenti TensorFlow DLCs con la libreria SMDDP installata, vedere. [TensorFlow (obsoleto)](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks-tensorflow)

```
from sagemaker.tensorflow import TensorFlow

tf_estimator = TensorFlow(
    base_job_name = "training_job_name_prefix",
    entry_point="adapted-training-script.py",
    role="SageMakerRole",
    framework_version="2.11.0",
    py_version="py38",

    # For running a multi-node distributed training job, specify a value greater than 1
    # Example: 2,3,4,..8
    instance_count=2,

    # Instance types supported by the SageMaker AI data parallel library: 
    # ml.p4d.24xlarge, ml.p3dn.24xlarge, and ml.p3.16xlarge
    instance_type="ml.p3.16xlarge",

    # Training using the SageMaker AI data parallel distributed training strategy
    distribution={ "smdistributed": { "dataparallel": { "enabled": True } } }
)

tf_estimator.fit("s3://bucket/path/to/training/data")
```

------

# Usa lo stimatore generico SageMaker AI per estendere i contenitori DLC predefiniti
<a name="data-parallel-use-python-skd-api"></a>

Puoi personalizzare i contenitori SageMaker AI predefiniti o estenderli per gestire eventuali requisiti funzionali aggiuntivi per il tuo algoritmo o modello che l'immagine Docker SageMaker AI precostruita non supporta. Per un esempio di come è possibile estendere un container predefinito, consulta [Estendere un container predefinito](https://docs.aws.amazon.com/sagemaker/latest/dg/prebuilt-containers-extend.html).

Per estendere un container predefinito o adattare il tuo container all'uso della libreria, devi utilizzare una delle immagini elencate in [Framework supportati](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks).

**Nota**  
A partire dalla TensorFlow versione 2.4.1 e PyTorch 1.8.1, il framework SageMaker DLCs AI supporta i tipi di istanze abilitati per EFA. Ti consigliamo di utilizzare le immagini DLC che contengono la TensorFlow versione 2.4.1 o successiva e la versione 1.8.1 o successiva. PyTorch 

Ad esempio, se lo utilizzi PyTorch, il tuo Dockerfile dovrebbe contenere un'`FROM`istruzione simile alla seguente:

```
# SageMaker AI PyTorch image
FROM 763104351884.dkr.ecr.<aws-region>.amazonaws.com/pytorch-training:<image-tag>

ENV PATH="/opt/ml/code:${PATH}"

# this environment variable is used by the SageMaker AI PyTorch container to determine our user code directory.
ENV SAGEMAKER_SUBMIT_DIRECTORY /opt/ml/code

# /opt/ml and all subdirectories are utilized by SageMaker AI, use the /code subdirectory to store your user code.
COPY train.py /opt/ml/code/train.py

# Defines cifar10.py as script entrypoint
ENV SAGEMAKER_PROGRAM train.py
```

Puoi personalizzare ulteriormente il tuo contenitore Docker per lavorare con l' SageMaker intelligenza artificiale utilizzando il [toolkit di SageMaker formazione](https://github.com/aws/sagemaker-training-toolkit) e il file binario della libreria parallela di SageMaker dati distribuiti AI. Per ulteriori informazioni, consulta le istruzioni nella sezione seguente.

# Crea il tuo contenitore Docker con la libreria parallela di dati distribuiti SageMaker AI
<a name="data-parallel-bring-your-own-container"></a>

Per creare il tuo contenitore Docker per l'addestramento e utilizzare la libreria parallela di dati SageMaker AI, devi includere le dipendenze corrette e i file binari delle librerie parallele distribuite SageMaker AI nel tuo Dockerfile. Questa sezione fornisce istruzioni su come creare un Dockerfile completo con il set minimo di dipendenze per l'addestramento distribuito nell' SageMaker intelligenza artificiale utilizzando la libreria parallela di dati.

**Nota**  
Questa opzione Docker personalizzata con la libreria parallela di dati SageMaker AI come binario è disponibile solo per PyTorch.

**Per creare un Dockerfile con il toolkit di SageMaker formazione e la libreria data parallel**

1. Inizia con un'immagine Docker di [NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda). [Usa le versioni per sviluppatori cuDNN che contengono il runtime CUDA e gli strumenti di sviluppo (intestazioni e librerie) per creare dal codice sorgente. PyTorch ](https://github.com/pytorch/pytorch#from-source)

   ```
   FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04
   ```
**Suggerimento**  
[Le immagini ufficiali del AWS Deep Learning Container (DLC) sono create a partire dalle immagini di base di NVIDIA CUDA.](https://hub.docker.com/r/nvidia/cuda) Se desideri utilizzare le immagini DLC predefinite come riferimenti mentre segui il resto delle istruzioni, consulta [AWS Deep Learning Containers for PyTorch ](https://github.com/aws/deep-learning-containers/tree/master/pytorch) Dockerfiles. 

1. Aggiungi i seguenti argomenti per specificare le versioni e gli altri pacchetti. PyTorch Inoltre, indica i percorsi dei bucket Amazon S3 verso la libreria parallela di SageMaker dati AI e altri software per utilizzare AWS le risorse, come il plug-in Amazon S3. 

   Per utilizzare versioni delle librerie di terze parti diverse da quelle fornite nel seguente esempio di codice, ti consigliamo di consultare i [Dockerfile ufficiali di AWS Deep Learning Container PyTorch per](https://github.com/aws/deep-learning-containers/tree/master/pytorch/training/docker) trovare versioni testate, compatibili e adatte alla tua applicazione. 

    URLs Per trovare l'`SMDATAPARALLEL_BINARY`argomento, consulta le tabelle di ricerca all'indirizzo. [Framework supportati](distributed-data-parallel-support.md#distributed-data-parallel-supported-frameworks)

   ```
   ARG PYTORCH_VERSION=1.10.2
   ARG PYTHON_SHORT_VERSION=3.8
   ARG EFA_VERSION=1.14.1
   ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
   ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl
   ARG CONDA_PREFIX="/opt/conda"
   ARG BRANCH_OFI=1.1.3-aws
   ```

1. Imposta le seguenti variabili di ambiente per creare correttamente i componenti di SageMaker addestramento ed eseguire la libreria parallela di dati. Queste variabili vengono utilizzate per i componenti nelle fasi successive.

   ```
   # Set ENV variables required to build PyTorch
   ENV TORCH_CUDA_ARCH_LIST="7.0+PTX 8.0"
   ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all"
   ENV NCCL_VERSION=2.10.3
   
   # Add OpenMPI to the path.
   ENV PATH /opt/amazon/openmpi/bin:$PATH
   
   # Add Conda to path
   ENV PATH $CONDA_PREFIX/bin:$PATH
   
   # Set this enviroment variable for SageMaker AI to launch SMDDP correctly.
   ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main
   
   # Add enviroment variable for processes to be able to call fork()
   ENV RDMAV_FORK_SAFE=1
   
   # Indicate the container type
   ENV DLC_CONTAINER_TYPE=training
   
   # Add EFA and SMDDP to LD library path
   ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH"
   ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH
   ```

1. Installa o aggiorna `curl`, `wget` e `git` per scaricare e creare pacchetti nelle fasi successive.

   ```
   RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
       apt-get update && apt-get install -y  --no-install-recommends \
           curl \
           wget \
           git \
       && rm -rf /var/lib/apt/lists/*
   ```

1. Installa il software [Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html) per la comunicazione di rete Amazon EC2.

   ```
   RUN DEBIAN_FRONTEND=noninteractive apt-get update
   RUN mkdir /tmp/efa \
       && cd /tmp/efa \
       && curl --silent -O https://efa-installer.amazonaws.com/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 \
       && rm -rf /tmp/efa
   ```

1. Installa [Conda](https://docs.conda.io/en/latest/) per eseguire la gestione dei pacchetti. 

   ```
   RUN curl -fsSL -v -o ~/miniconda.sh -O  https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh  && \
       chmod +x ~/miniconda.sh && \
       ~/miniconda.sh -b -p $CONDA_PREFIX && \
       rm ~/miniconda.sh && \
       $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \
       $CONDA_PREFIX/bin/conda clean -ya
   ```

1. Ottieni, compila e installa PyTorch e le relative dipendenze. Creiamo [PyTorch a partire dal codice sorgente](https://github.com/pytorch/pytorch#from-source) perché dobbiamo avere il controllo della versione NCCL per garantire la compatibilità con il plug-in [AWS OFI](https://github.com/aws/aws-ofi-nccl) NCCL.

   1. [Seguendo i passaggi del [dockerfile PyTorch ufficiale](https://github.com/pytorch/pytorch/blob/master/Dockerfile), installa build dependencies e configura ccache per velocizzare la ricompilazione.](https://ccache.dev/)

      ```
      RUN DEBIAN_FRONTEND=noninteractive \
          apt-get install -y --no-install-recommends \
              build-essential \
              ca-certificates \
              ccache \
              cmake \
              git \
              libjpeg-dev \
              libpng-dev \
          && rm -rf /var/lib/apt/lists/*
        
      # Setup ccache
      RUN /usr/sbin/update-ccache-symlinks
      RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache
      ```

   1. [Le dipendenze comuni di Install PyTorch e Linux.](https://github.com/pytorch/pytorch#install-dependencies)

      ```
      # Common dependencies for PyTorch
      RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses
      
      # Linux specific dependency for PyTorch
      RUN conda install -c pytorch magma-cuda113
      ```

   1. [Clona il PyTorch GitHub repository.](https://github.com/pytorch/pytorch)

      ```
      RUN --mount=type=cache,target=/opt/ccache \
          cd / \
          && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION}
      ```

   1. Installa e crea una versione [NCCL](https://developer.nvidia.com/nccl) specifica. Per fare ciò, sostituisci il contenuto nella cartella NCCL predefinita (`/pytorch/third_party/nccl`) con la PyTorch versione NCCL specifica del repository NVIDIA. La versione NCCL è stata impostata nella fase 3 di questa guida.

      ```
      RUN cd /pytorch/third_party/nccl \
          && rm -rf nccl \
          && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
          && cd nccl \
          && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \
          && make pkg.txz.build \
          && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1
      ```

   1.  PyTorchCompila e installa. Questo processo dura in genere poco più di 1 ora. È costruito utilizzando la versione NCCL scaricata nella fase precedente.

      ```
      RUN cd /pytorch \
          && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \
          python setup.py install \
          && rm -rf /pytorch
      ```

1. Crea e installa il plugin [AWS OFI NCCL](https://github.com/aws/aws-ofi-nccl). Ciò consente il supporto [libfabric](https://github.com/ofiwg/libfabric) per la libreria parallela di dati SageMaker AI.

   ```
   RUN DEBIAN_FRONTEND=noninteractive apt-get update \
       && apt-get install -y --no-install-recommends \
           autoconf \
           automake \
           libtool
   RUN mkdir /tmp/efa-ofi-nccl \
       && cd /tmp/efa-ofi-nccl \
       && 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=$CONDA_PREFIX \
       && make \
       && make install \
       && rm -rf /tmp/efa-ofi-nccl
   ```

1. Compila e installa [TorchVision](https://github.com/pytorch/vision.git).

   ```
   RUN pip install --no-cache-dir -U \
       packaging \
       mpi4py==3.0.3
   RUN cd /tmp \
       && git clone https://github.com/pytorch/vision.git -b v0.9.1 \
       && cd vision \
       && BUILD_VERSION="0.9.1+cu111" python setup.py install \
       && cd /tmp \
       && rm -rf vision
   ```

1. Installa e configura OpenSSH. OpenSSH è necessario per consentire a MPI di comunicare tra container. Consenti a OpenSSH di comunicare con i container senza chiedere conferma.

   ```
   RUN apt-get update \
       && apt-get install -y  --allow-downgrades --allow-change-held-packages --no-install-recommends \
       && apt-get install -y --no-install-recommends openssh-client openssh-server \
       && mkdir -p /var/run/sshd \
       && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \
       && echo "    StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \
       && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \
       && rm -rf /var/lib/apt/lists/*
   
   # Configure OpenSSH so that nodes can communicate with each other
   RUN mkdir -p /var/run/sshd && \
    sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
   RUN rm -rf /root/.ssh/ && \
    mkdir -p /root/.ssh/ && \
    ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \
    cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \
    && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config
   ```

1. Installa il plug-in PT S3 per accedere in modo efficiente ai set di dati in Amazon S3.

   ```
   RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU}
   RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt
   ```

1. Installa la libreria [libboost](https://www.boost.org/). Questo pacchetto è necessario per collegare in rete la funzionalità IO asincrona della libreria parallela di SageMaker dati AI.

   ```
   WORKDIR /
   RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \
       && tar -xzf boost_1_73_0.tar.gz \
       && cd boost_1_73_0 \
       && ./bootstrap.sh \
       && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \
       && cd .. \
       && rm -rf boost_1_73_0.tar.gz \
       && rm -rf boost_1_73_0 \
       && cd ${CONDA_PREFIX}/include/boost
   ```

1. Installa i seguenti strumenti di SageMaker intelligenza artificiale per la formazione. PyTorch 

   ```
   WORKDIR /root
   RUN pip install --no-cache-dir -U \
       smclarify \
       "sagemaker>=2,<3" \
       sagemaker-experiments==0.* \
       sagemaker-pytorch-training
   ```

1. Infine, installa il binario parallelo dei dati SageMaker AI e le dipendenze rimanenti.

   ```
   RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
     apt-get update && apt-get install -y  --no-install-recommends \
     jq \
     libhwloc-dev \
     libnuma1 \
     libnuma-dev \
     libssl1.1 \
     libtool \
     hwloc \
     && rm -rf /var/lib/apt/lists/*
   
   RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY}
   ```

1. Dopo aver finito di creare il Dockerfile, consulta [Adapting Your Own Training Container](https://docs.aws.amazon.com/sagemaker/latest/dg/adapt-training-container.html) per scoprire come creare il contenitore Docker, ospitarlo in Amazon ECR ed eseguire un processo di formazione utilizzando l'SDK Python. SageMaker 

Il codice di esempio seguente mostra un Dockerfile completo dopo aver combinato tutti i blocchi di codice precedenti.

```
# This file creates a docker image with minimum dependencies to run SageMaker AI data parallel training
FROM nvidia/cuda:11.3.1-cudnn8-devel-ubuntu20.04

# Set appropiate versions and location for components
ARG PYTORCH_VERSION=1.10.2
ARG PYTHON_SHORT_VERSION=3.8
ARG EFA_VERSION=1.14.1
ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/${PYTORCH_VERSION}/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
ARG PT_S3_WHL_GPU=https://aws-s3-plugin.s3.us-west-2.amazonaws.com/binaries/0.0.1/1c3e69e/awsio-0.0.1-cp38-cp38-manylinux1_x86_64.whl
ARG CONDA_PREFIX="/opt/conda"
ARG BRANCH_OFI=1.1.3-aws

# Set ENV variables required to build PyTorch
ENV TORCH_CUDA_ARCH_LIST="3.7 5.0 7.0+PTX 8.0"
ENV TORCH_NVCC_FLAGS="-Xfatbin -compress-all"
ENV NCCL_VERSION=2.10.3

# Add OpenMPI to the path.
ENV PATH /opt/amazon/openmpi/bin:$PATH

# Add Conda to path
ENV PATH $CONDA_PREFIX/bin:$PATH

# Set this enviroment variable for SageMaker AI to launch SMDDP correctly.
ENV SAGEMAKER_TRAINING_MODULE=sagemaker_pytorch_container.training:main

# Add enviroment variable for processes to be able to call fork()
ENV RDMAV_FORK_SAFE=1

# Indicate the container type
ENV DLC_CONTAINER_TYPE=training

# Add EFA and SMDDP to LD library path
ENV LD_LIBRARY_PATH="/opt/conda/lib/python${PYTHON_SHORT_VERSION}/site-packages/smdistributed/dataparallel/lib:$LD_LIBRARY_PATH"
ENV LD_LIBRARY_PATH=/opt/amazon/efa/lib/:$LD_LIBRARY_PATH

# Install basic dependencies to download and build other dependencies
RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
  apt-get update && apt-get install -y  --no-install-recommends \
  curl \
  wget \
  git \
  && rm -rf /var/lib/apt/lists/*

# Install EFA.
# This is required for SMDDP backend communication
RUN DEBIAN_FRONTEND=noninteractive apt-get update
RUN mkdir /tmp/efa \
    && cd /tmp/efa \
    && curl --silent -O https://efa-installer.amazonaws.com/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 \
    && rm -rf /tmp/efa

# Install Conda
RUN curl -fsSL -v -o ~/miniconda.sh -O  https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh  && \
    chmod +x ~/miniconda.sh && \
    ~/miniconda.sh -b -p $CONDA_PREFIX && \
    rm ~/miniconda.sh && \
    $CONDA_PREFIX/bin/conda install -y python=${PYTHON_SHORT_VERSION} conda-build pyyaml numpy ipython && \
    $CONDA_PREFIX/bin/conda clean -ya

# Install PyTorch.
# Start with dependencies listed in official PyTorch dockerfile
# https://github.com/pytorch/pytorch/blob/master/Dockerfile
RUN DEBIAN_FRONTEND=noninteractive \
    apt-get install -y --no-install-recommends \
        build-essential \
        ca-certificates \
        ccache \
        cmake \
        git \
        libjpeg-dev \
        libpng-dev && \
    rm -rf /var/lib/apt/lists/*

# Setup ccache
RUN /usr/sbin/update-ccache-symlinks
RUN mkdir /opt/ccache && ccache --set-config=cache_dir=/opt/ccache

# Common dependencies for PyTorch
RUN conda install astunparse numpy ninja pyyaml mkl mkl-include setuptools cmake cffi typing_extensions future six requests dataclasses

# Linux specific dependency for PyTorch
RUN conda install -c pytorch magma-cuda113

# Clone PyTorch
RUN --mount=type=cache,target=/opt/ccache \
    cd / \
    && git clone --recursive https://github.com/pytorch/pytorch -b v${PYTORCH_VERSION}
# Note that we need to use the same NCCL version for PyTorch and OFI plugin.
# To enforce that, install NCCL from source before building PT and OFI plugin.

# Install NCCL.
# Required for building OFI plugin (OFI requires NCCL's header files and library)
RUN cd /pytorch/third_party/nccl \
    && rm -rf nccl \
    && git clone https://github.com/NVIDIA/nccl.git -b v${NCCL_VERSION}-1 \
    && cd nccl \
    && make -j64 src.build CUDA_HOME=/usr/local/cuda NVCC_GENCODE="-gencode=arch=compute_70,code=sm_70 -gencode=arch=compute_80,code=sm_80" \
    && make pkg.txz.build \
    && tar -xvf build/pkg/txz/nccl_*.txz -C $CONDA_PREFIX --strip-components=1

# Build and install PyTorch.
RUN cd /pytorch \
    && CMAKE_PREFIX_PATH="$(dirname $(which conda))/../" \
    python setup.py install \
    && rm -rf /pytorch

RUN ccache -C

# Build and install OFI plugin. \
# It is required to use libfabric.
RUN DEBIAN_FRONTEND=noninteractive apt-get update \
    && apt-get install -y --no-install-recommends \
        autoconf \
        automake \
        libtool
RUN mkdir /tmp/efa-ofi-nccl \
    && cd /tmp/efa-ofi-nccl \
    && 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=$CONDA_PREFIX \
    && make \
    && make install \
    && rm -rf /tmp/efa-ofi-nccl

# Build and install Torchvision
RUN pip install --no-cache-dir -U \
    packaging \
    mpi4py==3.0.3
RUN cd /tmp \
    && git clone https://github.com/pytorch/vision.git -b v0.9.1 \
    && cd vision \
    && BUILD_VERSION="0.9.1+cu111" python setup.py install \
    && cd /tmp \
    && rm -rf vision

# Install OpenSSH.
# Required for MPI to communicate between containers, allow OpenSSH to talk to containers without asking for confirmation
RUN apt-get update \
    && apt-get install -y  --allow-downgrades --allow-change-held-packages --no-install-recommends \
    && apt-get install -y --no-install-recommends openssh-client openssh-server \
    && mkdir -p /var/run/sshd \
    && cat /etc/ssh/ssh_config | grep -v StrictHostKeyChecking > /etc/ssh/ssh_config.new \
    && echo "    StrictHostKeyChecking no" >> /etc/ssh/ssh_config.new \
    && mv /etc/ssh/ssh_config.new /etc/ssh/ssh_config \
    && rm -rf /var/lib/apt/lists/*
# Configure OpenSSH so that nodes can communicate with each other
RUN mkdir -p /var/run/sshd && \
    sed 's@session\s*required\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd
RUN rm -rf /root/.ssh/ && \
    mkdir -p /root/.ssh/ && \
    ssh-keygen -q -t rsa -N '' -f /root/.ssh/id_rsa && \
    cp /root/.ssh/id_rsa.pub /root/.ssh/authorized_keys \
    && printf "Host *\n StrictHostKeyChecking no\n" >> /root/.ssh/config

# Install PT S3 plugin.
# Required to efficiently access datasets in Amazon S3
RUN pip install --no-cache-dir -U ${PT_S3_WHL_GPU}
RUN mkdir -p /etc/pki/tls/certs && cp /etc/ssl/certs/ca-certificates.crt /etc/pki/tls/certs/ca-bundle.crt

# Install libboost from source.
# This package is needed for smdataparallel functionality (for networking asynchronous IO).
WORKDIR /
RUN wget https://sourceforge.net/projects/boost/files/boost/1.73.0/boost_1_73_0.tar.gz/download -O boost_1_73_0.tar.gz \
    && tar -xzf boost_1_73_0.tar.gz \
    && cd boost_1_73_0 \
    && ./bootstrap.sh \
    && ./b2 threading=multi --prefix=${CONDA_PREFIX} -j 64 cxxflags=-fPIC cflags=-fPIC install || true \
    && cd .. \
    && rm -rf boost_1_73_0.tar.gz \
    && rm -rf boost_1_73_0 \
    && cd ${CONDA_PREFIX}/include/boost

# Install SageMaker AI PyTorch training.
WORKDIR /root
RUN pip install --no-cache-dir -U \
    smclarify \
    "sagemaker>=2,<3" \
    sagemaker-experiments==0.* \
    sagemaker-pytorch-training

# Install SageMaker AI data parallel binary (SMDDP)
# Start with dependencies
RUN --mount=type=cache,id=apt-final,target=/var/cache/apt \
    apt-get update && apt-get install -y  --no-install-recommends \
        jq \
        libhwloc-dev \
        libnuma1 \
        libnuma-dev \
        libssl1.1 \
        libtool \
        hwloc \
    && rm -rf /var/lib/apt/lists/*

# Install SMDDP
RUN SMDATAPARALLEL_PT=1 pip install --no-cache-dir ${SMDATAPARALLEL_BINARY}
```

**Suggerimento**  
[Per informazioni più generali sulla creazione di un Dockerfile personalizzato per la formazione nell'intelligenza artificiale, consulta Use Your Own Training Algorithms SageMaker .](https://docs.aws.amazon.com/sagemaker/latest/dg/your-algorithms-training-algo.html)

**Suggerimento**  
Se desideri estendere il Dockerfile personalizzato per incorporare la libreria parallela del SageMaker modello AI, consulta. [Crea il tuo contenitore Docker con la Distributed Model Parallel Library SageMaker](model-parallel-sm-sdk.md#model-parallel-bring-your-own-container)