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

# Formazione distribuita con la libreria di parallelismo dei dati distribuiti SageMaker AI
<a name="data-parallel-modify-sdp"></a>

La libreria SageMaker AI Distributed Data Parallelism (SMDDP) è progettata per la facilità d'uso e per fornire una perfetta integrazione con. PyTorch

Durante l'addestramento di un modello di deep learning con la libreria SMDDP sull' SageMaker intelligenza artificiale, puoi concentrarti sulla stesura dello script di addestramento e sulla formazione del modello. 

Per iniziare, importa la libreria SMDDP per utilizzarne le operazioni collettive ottimizzate per AWS. I seguenti argomenti forniscono istruzioni sugli elementi da aggiungere allo script di addestramento a seconda dell’operazione collettiva da ottimizzare.

**Topics**
+ [Adattamento dello script di addestramento per l’utilizzo delle operazioni collettive SMDDP](data-parallel-modify-sdp-select-framework.md)
+ [Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md)

# Adattamento dello script di addestramento per l’utilizzo delle operazioni collettive SMDDP
<a name="data-parallel-modify-sdp-select-framework"></a>

Gli esempi di script di addestramento forniti in questa sezione sono semplificati ed evidenziano solo le modifiche necessarie per abilitare la libreria SageMaker AI Distributed Data Parallelism (SMDDP) nello script di addestramento. Per esempi di notebook end-to-end Jupyter che dimostrano come eseguire un processo di formazione distribuito con la libreria SMDDP, vedere. [Esempi di librerie di parallelismo dei dati di Amazon SageMaker AI](distributed-data-parallel-v2-examples.md)

**Topics**
+ [Utilizzate la libreria SMDDP nello script di addestramento PyTorch](data-parallel-modify-sdp-pt.md)
+ [Usa la libreria SMDDP nello script di addestramento Lightning PyTorch](data-parallel-modify-sdp-pt-lightning.md)
+ [Usa la libreria SMDDP nello script di formazione (obsoleto) TensorFlow](data-parallel-modify-sdp-tf2.md)

# Utilizzate la libreria SMDDP nello script di addestramento PyTorch
<a name="data-parallel-modify-sdp-pt"></a>

[A partire dalla libreria SageMaker AI Distributed Data Parallelism (SMDDP) v1.4.0, puoi utilizzare la libreria come opzione di backend per il pacchetto distribuito. PyTorch ](https://pytorch.org/tutorials/beginner/dist_overview.html) Per utilizzare SMDDP `AllReduce` e le operazioni `AllGather` collettive, è sufficiente importare la libreria SMDDP all'inizio dello script di formazione e impostare SMDDP come backend dei moduli distribuiti durante l'inizializzazione del gruppo di processi. PyTorch Con la singola riga di specifiche del backend, è possibile mantenere invariati tutti i moduli distribuiti nativi PyTorch e l'intero script di formazione. [I seguenti frammenti di codice mostrano come utilizzare la libreria SMDDP come backend di pacchetti di formazione distribuiti PyTorch basati: distributed [PyTorch data parallel (DDP), PyTorch Fully Sharded Data Parallelism (FSDP)](https://pytorch.org/docs/stable/notes/ddp.html)[e Megatron](https://pytorch.org/docs/stable/fsdp.html) -. [DeepSpeed](https://github.com/microsoft/DeepSpeed)DeepSpeed](https://github.com/microsoft/Megatron-DeepSpeed)

## PyTorch Per DDP o FSDP
<a name="data-parallel-enable-for-ptddp-ptfsdp"></a>

Inizializza il gruppo di processi come segue.

```
import torch.distributed as dist
import smdistributed.dataparallel.torch.torch_smddp

dist.init_process_group(backend="smddp")
```

**Nota**  
(Solo per i lavori PyTorch DDP) Il `smddp` backend attualmente non supporta la creazione di gruppi di sottoprocessi con l'API. `torch.distributed.new_group()` Non è possibile utilizzare il backend `smddp` contemporaneamente ad altri back-end di gruppi di processi come `NCCL` e `Gloo`.

## Per DeepSpeed o Megatron- DeepSpeed
<a name="data-parallel-enable-for-deepspeed"></a>

Inizializza il gruppo di processi come segue.

```
import deepspeed
import smdistributed.dataparallel.torch.torch_smddp

deepspeed.init_distributed(dist_backend="smddp")
```

**Nota**  
Per utilizzare `AllGather` SMDDP con i programmi di avvio basati su `mpirun` (`smdistributed` e `pytorchddp`) in [Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md), è inoltre necessario impostare la seguente variabile di ambiente nello script di addestramento.  

```
export SMDATAPARALLEL_OPTIMIZE_SDP=true
```

Per indicazioni generali sulla scrittura di uno script di formazione PyTorch FSDP, consulta [Advanced Model Training with Fully Sharded Data Parallel (FSDP](https://pytorch.org/tutorials/intermediate/FSDP_adavnced_tutorial.html)) nella documentazione. PyTorch

Per indicazioni generali sulla scrittura di uno script di addestramento PyTorch DDP, consulta [Getting started with distributed data parallel](https://pytorch.org/tutorials/intermediate/ddp_tutorial.html) nella PyTorch documentazione.

Dopo aver completato l’adattamento dello script di addestramento, procedi con [Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md).

# Usa la libreria SMDDP nello script di addestramento Lightning PyTorch
<a name="data-parallel-modify-sdp-pt-lightning"></a>

Se desideri utilizzare lo script di formazione [PyTorchLightning](https://pytorch-lightning.readthedocs.io/en/latest/starter/introduction.html) ed eseguire un processo di formazione parallela con dati distribuiti in SageMaker AI, puoi eseguire il processo di formazione con modifiche minime allo script di formazione. Le modifiche necessarie includono quanto segue: importazione dei PyTorch moduli della `smdistributed.dataparallel` libreria, impostazione delle variabili di ambiente per PyTorch Lightning in modo che accettino le variabili di ambiente SageMaker AI preimpostate dal toolkit di SageMaker formazione e attivazione della libreria SMDDP impostando il backend del gruppo di processi su. `"smddp"` Per ulteriori informazioni, segui le seguenti istruzioni che descrivono le fasi con esempi di codice.

**Nota**  
Il supporto PyTorch Lightning è disponibile nella libreria parallela di dati SageMaker AI v1.5.0 e versioni successive.

## PyTorch Lightning == v2.1.0 e == 2.0.1 PyTorch
<a name="smddp-pt-201-lightning-210"></a>

1. Importa la libreria `pytorch_lightning` e i moduli `smdistributed.dataparallel.torch`.

   ```
   import lightning as pl
   import smdistributed.dataparallel.torch.torch_smddp
   ```

1. [LightningEnvironment](https://pytorch-lightning.readthedocs.io/en/stable/api/pytorch_lightning.plugins.environments.LightningEnvironment.html)Istanzia il.

   ```
   from lightning.fabric.plugins.environments.lightning import LightningEnvironment
   
   env = LightningEnvironment()
   env.world_size = lambda: int(os.environ["WORLD_SIZE"])
   env.global_rank = lambda: int(os.environ["RANK"])
   ```

1. **Per PyTorch DDP**[: crea un oggetto della [DDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.DDPStrategy.html)classe con `"smddp"` for `process_group_backend` e `"gpu"` for`accelerator`, e passalo alla classe Trainer.](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html)

   ```
   import lightning as pl
   from lightning.pytorch.strategies import DDPStrategy
   
   ddp = DDPStrategy(
       cluster_environment=env, 
       process_group_backend="smddp", 
       accelerator="gpu"
   )
   
   trainer = pl.Trainer(
       max_epochs=200, 
       strategy=ddp, 
       devices=num_gpus, 
       num_nodes=num_nodes
   )
   ```

   **Per PyTorch FSDP**[: crea un oggetto della [FSDPStrategy](https://lightning.ai/docs/pytorch/stable/api/lightning.pytorch.strategies.FSDPStrategy.html)classe (con la [politica di wrapping](https://pytorch.org/docs/stable/fsdp.html) preferita) con `"smddp"` for `process_group_backend` e `"gpu"` for `accelerator` e passalo alla classe Trainer.](https://pytorch-lightning.readthedocs.io/en/stable/common/trainer.html)

   ```
   import lightning as pl
   from lightning.pytorch.strategies import FSDPStrategy
   
   from functools import partial
   from torch.distributed.fsdp.wrap import size_based_auto_wrap_policy
   
   policy = partial(
       size_based_auto_wrap_policy, 
       min_num_params=10000
   )
   
   fsdp = FSDPStrategy(
       auto_wrap_policy=policy,
       process_group_backend="smddp", 
       cluster_environment=env
   )
   
   trainer = pl.Trainer(
       max_epochs=200, 
       strategy=fsdp, 
       devices=num_gpus, 
       num_nodes=num_nodes
   )
   ```

Dopo aver completato l’adattamento dello script di addestramento, procedi con [Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md). 

**Nota**  
Quando costruisci uno strumento di PyTorch valutazione dell' SageMaker intelligenza artificiale e invii una richiesta di lavoro di formazione in[Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md), devi provvedere all'installazione `pytorch-lightning` e `lightning-bolts` all'inserimento nel contenitore di formazione `requirements.txt` AI. SageMaker PyTorch   

```
# requirements.txt
pytorch-lightning
lightning-bolts
```
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*.

# Usa la libreria SMDDP nello script di formazione (obsoleto) TensorFlow
<a name="data-parallel-modify-sdp-tf2"></a>

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

I passaggi seguenti mostrano come modificare uno script di TensorFlow addestramento per utilizzare la libreria parallela di dati distribuiti di SageMaker AI.  

La libreria APIs è progettata per essere simile a APIs Horovod. Per ulteriori dettagli su ciascuna API offerta dalla libreria TensorFlow, consulta la [documentazione dell' TensorFlow API SageMaker AI distributed data parallel](https://sagemaker.readthedocs.io/en/stable/api/training/smd_data_parallel.html#api-documentation).

**Nota**  
SageMaker L'AI distributed data parallel è adattabile agli script di TensorFlow addestramento composti da moduli `tf` principali ad eccezione `tf.keras` dei moduli. SageMaker L'AI distributed data parallel non supporta TensorFlow l'implementazione Keras.

**Nota**  
La libreria di parallelismo dei dati distribuiti SageMaker AI supporta immediatamente Automatic Mixed Precision (AMP). Non è necessaria alcuna azione aggiuntiva per abilitare AMP oltre alle modifiche a livello di framework allo script di addestramento. Se i gradienti sono presenti FP16, la libreria di parallelismo dei dati SageMaker AI esegue il suo funzionamento in. `AllReduce` FP16 Per ulteriori informazioni sull'implementazione di AMP nello script APIs di formazione, consulta le seguenti risorse:  
[Frameworks: TensorFlow nella documentazione](https://docs.nvidia.com/deeplearning/performance/mixed-precision-training/index.html#tensorflow) di *NVIDIA Deep* Learning Performance
[Automatic mixed precision for deep learning](https://developer.nvidia.com/automatic-mixed-precision) nella *documentazione per sviluppatori NVIDIA*
[TensorFlow precisione APIs mista](https://www.tensorflow.org/guide/mixed_precision) *nella documentazione TensorFlow*

1. Importa il TensorFlow client della libreria e inizializzalo.

   ```
   import smdistributed.dataparallel.tensorflow as sdp 
   sdp.init()
   ```

1. Associa ogni GPU a un singolo processo `smdistributed.dataparallel` con `local_rank` —questo si riferisce al grado relativo del processo all'interno di un determinato nodo. L’API `sdp.tensorflow.local_rank()` fornisce la classificazione locale del dispositivo. Il nodo principale è di classificazione 0 e i nodi di lavoro sono di grado 1, 2, 3 e così via. Questo viene richiamato nel seguente blocco di codice come. `sdp.local_rank()` `set_memory_growth`non è direttamente correlato all' SageMaker intelligenza artificiale distribuita, ma deve essere impostato per l'addestramento distribuito con TensorFlow. 

   ```
   gpus = tf.config.experimental.list_physical_devices('GPU')
   for gpu in gpus:
       tf.config.experimental.set_memory_growth(gpu, True)
   if gpus:
       tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU')
   ```

1. Scala il tasso di apprendimento in base al numero di worker. L'API `sdp.tensorflow.size()` fornisce il numero di worker nel cluster. Questo viene richiamato nel seguente blocco di codice come `sdp.size()`. 

   ```
   learning_rate = learning_rate * sdp.size()
   ```

1. Utilizza le librerie `DistributedGradientTape` per ottimizzare le operazioni `AllReduce` durante l'addestramento. Questo esegue il wrapping di `tf.GradientTape`.  

   ```
   with tf.GradientTape() as tape:
         output = model(input)
         loss_value = loss(label, output)
       
   # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape
   tape = sdp.DistributedGradientTape(tape)
   ```

1. Trasmetti le variabili iniziali del modello dal nodo leader (rango 0) a tutti i nodi di lavoro (dai ranghi da 1 a n). Ciò è necessario per garantire un'inizializzazione coerente tra tutte le classificazioni dei worker. Utilizza l'API `sdp.tensorflow.broadcast_variables` dopo l'inizializzazione delle variabili del modello e dell'ottimizzatore. Questo viene richiamato nel seguente blocco di codice come `sdp.broadcast_variables()`. 

   ```
   sdp.broadcast_variables(model.variables, root_rank=0)
   sdp.broadcast_variables(opt.variables(), root_rank=0)
   ```

1. Infine, modifica dello script per salvare i checkpoint solo sul nodo principale. Il nodo principale ha un modello sincronizzato. Ciò evita inoltre che i nodi di lavoro sovrascrivano i checkpoint e possano danneggiarli. 

   ```
   if sdp.rank() == 0:
       checkpoint.save(checkpoint_dir)
   ```

Di seguito è riportato un esempio di script di TensorFlow formazione per la formazione distribuita con la libreria.

```
import tensorflow as tf

# SageMaker AI data parallel: Import the library TF API
import smdistributed.dataparallel.tensorflow as sdp

# SageMaker AI data parallel: Initialize the library
sdp.init()

gpus = tf.config.experimental.list_physical_devices('GPU')
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu, True)
if gpus:
    # SageMaker AI data parallel: Pin GPUs to a single library process
    tf.config.experimental.set_visible_devices(gpus[sdp.local_rank()], 'GPU')

# Prepare Dataset
dataset = tf.data.Dataset.from_tensor_slices(...)

# Define Model
mnist_model = tf.keras.Sequential(...)
loss = tf.losses.SparseCategoricalCrossentropy()

# SageMaker AI data parallel: Scale Learning Rate
# LR for 8 node run : 0.000125
# LR for single node run : 0.001
opt = tf.optimizers.Adam(0.000125 * sdp.size())

@tf.function
def training_step(images, labels, first_batch):
    with tf.GradientTape() as tape:
        probs = mnist_model(images, training=True)
        loss_value = loss(labels, probs)

    # SageMaker AI data parallel: Wrap tf.GradientTape with the library's DistributedGradientTape
    tape = sdp.DistributedGradientTape(tape)

    grads = tape.gradient(loss_value, mnist_model.trainable_variables)
    opt.apply_gradients(zip(grads, mnist_model.trainable_variables))

    if first_batch:
       # SageMaker AI data parallel: Broadcast model and optimizer variables
       sdp.broadcast_variables(mnist_model.variables, root_rank=0)
       sdp.broadcast_variables(opt.variables(), root_rank=0)

    return loss_value

...

# SageMaker AI data parallel: Save checkpoints only from master node.
if sdp.rank() == 0:
    checkpoint.save(checkpoint_dir)
```

Dopo aver completato l'adattamento dello script di addestramento, passa a [Avvio di lavori di formazione distribuiti con SMDDP utilizzando Python SDK SageMaker](data-parallel-use-api.md). 

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