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

# Fase 2: Avviare un job di formazione utilizzando SageMaker Python SDK
<a name="model-parallel-sm-sdk"></a>

L'SDK SageMaker Python supporta l'addestramento gestito di modelli con framework ML come e. TensorFlow PyTorch Per avviare un processo di formazione utilizzando uno di questi framework, è necessario definire uno stimatore, uno estimatore o un SageMaker [TensorFlow Estimator](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/sagemaker.tensorflow.html#tensorflow-estimator) SageMaker generico per utilizzare lo SageMaker [PyTorch script](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/sagemaker.pytorch.html#pytorch-estimator) di addestramento modificato e la configurazione del [parallelismo](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/estimators.html#sagemaker.estimator.Estimator) del modello.

**Topics**
+ [PyTorch Utilizzo degli stimatori e SageMaker TensorFlow](#model-parallel-using-sagemaker-pysdk)
+ [Estendi un contenitore Docker predefinito che contiene la libreria parallela SageMaker di modelli distribuiti](#model-parallel-customize-container)
+ [Crea il tuo contenitore Docker con la Distributed Model Parallel Library SageMaker](#model-parallel-bring-your-own-container)

## PyTorch Utilizzo degli stimatori e SageMaker TensorFlow
<a name="model-parallel-using-sagemaker-pysdk"></a>

Le classi TensorFlow and PyTorch estimator contengono il `distribution` parametro, che è possibile utilizzare per specificare i parametri di configurazione per l'utilizzo di framework di formazione distribuiti. La libreria SageMaker model parallel utilizza internamente MPI per i dati ibridi e il parallelismo dei modelli, pertanto è necessario utilizzare l'opzione MPI con la libreria.

Il seguente modello di PyTorch estimatore TensorFlow or mostra come configurare il `distribution` parametro per l'utilizzo della libreria SageMaker model parallel con MPI.

------
#### [ Using the SageMaker TensorFlow estimator ]

```
import sagemaker
from sagemaker.tensorflow import TensorFlow

smp_options = {
    "enabled":True,              # Required
    "parameters": {
        "partitions": 2,         # Required
        "microbatches": 4,
        "placement_strategy": "spread",
        "pipeline": "interleaved",
        "optimize": "speed",
        "horovod": True,         # Use this for hybrid model and data parallelism
    }
}

mpi_options = {
    "enabled" : True,            # Required
    "processes_per_host" : 8,    # Required
    # "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none"
}

smd_mp_estimator = TensorFlow(
    entry_point="your_training_script.py", # Specify your train script
    source_dir="location_to_your_script",
    role=sagemaker.get_execution_role(),
    instance_count=1,
    instance_type='ml.p3.16xlarge',
    framework_version='2.6.3',
    py_version='py38',
    distribution={
        "smdistributed": {"modelparallel": smp_options},
        "mpi": mpi_options
    },
    base_job_name="SMD-MP-demo",
)

smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```

------
#### [ Using the SageMaker PyTorch estimator ]

```
import sagemaker
from sagemaker.pytorch import PyTorch

smp_options = {
    "enabled":True,
    "parameters": {                        # Required
        "pipeline_parallel_degree": 2,     # Required
        "microbatches": 4,
        "placement_strategy": "spread",
        "pipeline": "interleaved",
        "optimize": "speed",
        "ddp": True,
    }
}

mpi_options = {
    "enabled" : True,                      # Required
    "processes_per_host" : 8,              # Required
    # "custom_mpi_options" : "--mca btl_vader_single_copy_mechanism none"
}

smd_mp_estimator = PyTorch(
    entry_point="your_training_script.py", # Specify your train script
    source_dir="location_to_your_script",
    role=sagemaker.get_execution_role(),
    instance_count=1,
    instance_type='ml.p3.16xlarge',
    framework_version='1.13.1',
    py_version='py38',
    distribution={
        "smdistributed": {"modelparallel": smp_options},
        "mpi": mpi_options
    },
    base_job_name="SMD-MP-demo",
)

smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```

------

Per abilitare la libreria, è necessario passare i dizionari di configurazione alle `"mpi"` chiavi `"smdistributed"` and tramite l'`distribution`argomento dei costruttori dello estimatore. SageMaker 

**Parametri di configurazione per il parallelismo dei modelli SageMaker**
+ Per la chiave `"smdistributed"`, passa un dizionario con la chiave `"modelparallel"` e i seguenti dizionari interni. 
**Nota**  
L'utilizzo di `"modelparallel"` e `"dataparallel"` in un unico processo di addestramento non è supportato. 
  + `"enabled"`: obbligatorio Per abilitare il parallelismo dei modelli, imposta `"enabled": True`.
  + `"parameters"`: obbligatorio Specificate un set di parametri per il parallelismo del SageMaker modello.
    + Per un elenco completo dei parametri comuni, consulta [Parametri `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters) nella documentazione di *SageMaker Python SDK*.

      Per TensorFlow, vedi [TensorFlow-specific](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#tensorflow-specific-parameters) Parameters.

      Per PyTorch, vedi [PyTorch-specific](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#pytorch-specific-parameters) Parameters.
    + `"pipeline_parallel_degree"` (o `"partitions"` in `smdistributed-modelparallel<v1.6.0`): obbligatorio. Tra i [parametri per `smdistributed`](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#smdistributed-parameters), questo parametro è necessario per specificare in quante partizioni del modello desideri suddividere.
**Importante**  
C'è una modifica che causerà interruzioni nel nome del parametro. Il parametro `"pipeline_parallel_degree"` sostituisce le `"partitions"` dal `smdistributed-modelparallel` v1.6.0. Per ulteriori informazioni, consulta [Parametri comuni](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_general.html#common-parameters) per la configurazione SageMaker del parallelismo del modello e [SageMaker Distributed Model Parallel Release Notes](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) nella documentazione di *SageMaker Python* SDK.
+ Per la chiave, passa un dizionario che contenga quanto segue `"mpi"`:
  + `"enabled"`: obbligatorio Imposta `True` per avviare il processo di addestramento distribuito con MPI.
  + `"processes_per_host"`: obbligatorio Specifica il numero di processi che MPI deve avviare su ciascun host. Nell' SageMaker intelligenza artificiale, un host è una singola istanza ML di Amazon EC2. L'SDK SageMaker Python mantiene una one-to-one mappatura tra i processi e il parallelismo GPUs tra modelli e dati. Ciò significa che l' SageMaker IA pianifica ogni processo su un'unica GPU separata e nessuna GPU contiene più di un processo. Se si utilizza PyTorch, è necessario limitare ogni processo al proprio dispositivo tramite. `torch.cuda.set_device(smp.local_rank())` Per ulteriori informazioni, consulta [Divisione automatica con PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16).
**Importante**  
 `process_per_host`non *deve* essere maggiore del numero di GPUs istanze e in genere sarà uguale al numero di GPUs per istanza.
  + `"custom_mpi_options"` (facoltativo): utilizza questa chiave per passare le opzioni MPI personalizzate di cui potresti aver bisogno. Se non passi alcuna opzione personalizzata MPI alla chiave, l'opzione MPI viene impostata per impostazione predefinita sul seguente flag.

    ```
    --mca btl_vader_single_copy_mechanism none
    ```
**Nota**  
Non è necessario specificare esplicitamente questo flag predefinito sulla chiave. Se lo specifichi in modo esplicito, il processo di addestramento parallelo del modello distribuito potrebbe fallire con il seguente errore:  

    ```
    The following MCA parameter has been listed multiple times on the command line: 
    MCA param: btl_vader_single_copy_mechanism MCA parameters can only be listed once 
    on a command line to ensure there is no ambiguity as to its value. 
    Please correct the situation and try again.
    ```
**Suggerimento**  
Se avvii un processo di addestramento utilizzando un tipo di istanza compatibile con EFA, ad esempio `ml.p4d.24xlarge` e `ml.p3dn.24xlarge`, utilizza il seguente flag per ottenere prestazioni ottimali:  

    ```
    -x FI_EFA_USE_DEVICE_RDMA=1 -x FI_PROVIDER=efa -x RDMAV_FORK_SAFE=1
    ```

Per avviare il processo di formazione utilizzando lo stimatore e lo script di addestramento con configurazione parallela del SageMaker modello, esegui la `estimator.fit()` funzione.

Usa le seguenti risorse per saperne di più sull'uso delle funzionalità di parallelismo dei modelli in Python SageMaker SDK:
+ [Usare TensorFlow con SageMaker Python SDK](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/tensorflow/using_tf.html)
+ [Usare PyTorch con SageMaker Python SDK](https://sagemaker.readthedocs.io/en/v2.199.0/frameworks/pytorch/using_pytorch.html)
+ Ti consigliamo di utilizzare un'istanza SageMaker notebook se sei un nuovo utente. Per vedere un esempio di come è possibile avviare un processo di formazione utilizzando un'istanza di SageMaker notebook, consulta[Esempi di Amazon SageMaker AI Model Parallelism Library v2](distributed-model-parallel-v2-examples.md).
+ Puoi inoltre inviare un processo di addestramento distribuito dal tuo computer utilizzando AWS CLI. Per eseguire la configurazione AWS CLI sul computer, consulta [Configurazione AWS delle credenziali e Regione per lo sviluppo](https://docs.aws.amazon.com/sdk-for-java/v1/developer-guide/setup-credentials.html).

## Estendi un contenitore Docker predefinito che contiene la libreria parallela SageMaker di modelli distribuiti
<a name="model-parallel-customize-container"></a>

Per estendere un contenitore precostruito e utilizzare la libreria SageMaker di parallelismo dei modelli, devi utilizzare una delle immagini AWS Deep Learning Containers (DLC) disponibili per o. PyTorch TensorFlow La libreria di parallelismo dei SageMaker modelli è inclusa nelle immagini DLC TensorFlow (2.3.0 e successive) e (1.6.0 e successive) con CUDA PyTorch (). `cuxyz` Per un elenco completo delle immagini dei DLC, consulta Immagini dei [Deep Learning Containers disponibili](https://github.com/aws/deep-learning-containers/blob/master/available_images.md) nel * GitHub repository AWS Deep Learning Containers*.

**Suggerimento**  
Ti consigliamo di utilizzare l'immagine che contiene la versione più recente TensorFlow o di accedere PyTorch alla maggior parte up-to-date della libreria di parallelismo dei SageMaker modelli.

Ad esempio, il Dockerfile deve contenere un'istruzione `FROM` simile alla seguente:

```
# Use the SageMaker DLC image URI for TensorFlow or PyTorch
FROM aws-dlc-account-id.dkr.ecr.aws-region.amazonaws.com/framework-training:{framework-version-tag}

# Add your dependencies here
RUN ...

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

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

Inoltre, quando si definisce uno PyTorch TensorFlow stimatore OR, è necessario specificarlo `entry_point` per lo script di addestramento. Questo deve essere lo stesso percorso identificato con `ENV SAGEMAKER_SUBMIT_DIRECTORY` nel Dockerfile. 

**Suggerimento**  
È necessario inviare questo contenitore Docker ad Amazon Elastic Container Registry (Amazon ECR) e utilizzare l'URI dell'immagine (`image_uri`) per definire uno stimatore per la formazione. SageMaker Per ulteriori informazioni, consulta [Estensione di un container predefinito](prebuilt-containers-extend.md). 

Dopo aver completato l'hosting del contenitore Docker e aver recuperato l'URI dell'immagine del contenitore, crea un oggetto estimatore come segue. SageMaker `PyTorch` Questo esempio presuppone che tu abbia già definito `smp_options` e `mpi_options`. 

```
smd_mp_estimator = Estimator(
    entry_point="your_training_script.py",
    role=sagemaker.get_execution_role(),
    instance_type='ml.p3.16xlarge',
    sagemaker_session=sagemaker_session,
    image_uri='your_aws_account_id.dkr.ecr.region.amazonaws.com/name:tag'
    instance_count=1,
    distribution={
        "smdistributed": smp_options,
        "mpi": mpi_options
    },
    base_job_name="SMD-MP-demo",
)

smd_mp_estimator.fit('s3://my_bucket/my_training_data/')
```

## Crea il tuo contenitore Docker con la Distributed Model Parallel Library SageMaker
<a name="model-parallel-bring-your-own-container"></a>

Per creare il tuo contenitore Docker per l'addestramento e utilizzare la libreria parallela del SageMaker modello, devi includere le dipendenze corrette e i file binari delle librerie SageMaker parallele distribuite nel tuo Dockerfile. Questa sezione fornisce il set minimo di blocchi di codice da includere per preparare correttamente un ambiente di SageMaker formazione e la libreria parallela del modello nel proprio contenitore Docker.

**Nota**  
Questa opzione Docker personalizzata con la libreria parallel del SageMaker modello come binario è disponibile solo per PyTorch.

**Per creare un Dockerfile con il toolkit di SageMaker formazione e la libreria parallela del modello**

1. Inizia con una delle [immagini di base di NVIDIA CUDA](https://hub.docker.com/r/nvidia/cuda).

   ```
   FROM <cuda-cudnn-base-image>
   ```
**Suggerimento**  
Le immagini ufficiali del AWS Deep Learning Container (DLC) sono create a partire dalle immagini di base di [NVIDIA](https://hub.docker.com/r/nvidia/cuda) CUDA. 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) scoprire quali versioni delle librerie devi installare e come configurarle. I Dockerfile ufficiali sono completi, testati con benchmark e gestiti dai team di assistenza e di Deep Learning SageMaker Container. Nel link fornito, scegli la PyTorch versione che usi, scegli la cartella CUDA (`cuxyz`) e scegli il Dockerfile che termina con o. `.gpu` `.sagemaker.gpu`

1. Per configurare un ambiente di addestramento distribuito, devi installare software per dispositivi di comunicazione e di rete, come [Elastic Fabric Adapter (EFA)](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html), [NVIDIA Collective Communications Library (NCCL)](https://developer.nvidia.com/nccl) e[Open MPI](https://www.open-mpi.org/). A seconda delle versioni PyTorch di CUDA scelte, è necessario installare versioni compatibili delle librerie.
**Importante**  
Poiché la libreria parallela del SageMaker modello richiede la libreria parallela SageMaker dei dati nei passaggi successivi, ti consigliamo vivamente di seguire le istruzioni riportate [Crea il tuo contenitore Docker con la libreria parallela di dati distribuiti SageMaker AI](data-parallel-bring-your-own-container.md) per configurare correttamente un ambiente di SageMaker formazione per la formazione distribuita.

   Per ulteriori informazioni sulla configurazione di EFA con NCCL e Open MPI, consulta [Get Started with EFA and MPI](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start.html) e la [Guida introduttiva a EFA e NCCL](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa-start-nccl.html).

1. Aggiungete i seguenti argomenti per specificare i pacchetti URLs di formazione SageMaker distribuiti per PyTorch. La libreria parallela del SageMaker modello richiede che la libreria parallela SageMaker dei dati utilizzi il Remote Direct Memory Access (RDMA) tra nodi.

   ```
   ARG SMD_MODEL_PARALLEL_URL=https://sagemaker-distributed-model-parallel.s3.us-west-2.amazonaws.com/pytorch-1.10.0/build-artifacts/2022-02-21-19-26/smdistributed_modelparallel-1.7.0-cp38-cp38-linux_x86_64.whl
   ARG SMDATAPARALLEL_BINARY=https://smdataparallel.s3.amazonaws.com/binary/pytorch/1.10.2/cu113/2022-02-18/smdistributed_dataparallel-1.4.0-cp38-cp38-linux_x86_64.whl
   ```

1. Installa le dipendenze richieste dalla libreria parallela del SageMaker modello.

   1. Installa la libreria [METIS](http://glaros.dtc.umn.edu/gkhome/metis/metis/overview).

      ```
      ARG METIS=metis-5.1.0
      
      RUN rm /etc/apt/sources.list.d/* \
        && wget -nv http://glaros.dtc.umn.edu/gkhome/fetch/sw/metis/${METIS}.tar.gz \
        && gunzip -f ${METIS}.tar.gz \
        && tar -xvf ${METIS}.tar \
        && cd ${METIS} \
        && apt-get update \
        && make config shared=1 \
        && make install \
        && cd .. \
        && rm -rf ${METIS}.tar* \
        && rm -rf ${METIS} \
        && rm -rf /var/lib/apt/lists/* \
        && apt-get clean
      ```

   1. Installa la libreria [RAPIDS Memory Manager](https://github.com/rapidsai/rmm#rmm-rapids-memory-manager). Ciò richiede la versione [CMake](https://cmake.org/)3.14 o successiva.

      ```
      ARG RMM_VERSION=0.15.0
      
      RUN  wget -nv https://github.com/rapidsai/rmm/archive/v${RMM_VERSION}.tar.gz \
        && tar -xvf v${RMM_VERSION}.tar.gz \
        && cd rmm-${RMM_VERSION} \
        && INSTALL_PREFIX=/usr/local ./build.sh librmm \
        && cd .. \
        && rm -rf v${RMM_VERSION}.tar* \
        && rm -rf rmm-${RMM_VERSION}
      ```

1. Installa la libreria parallela del SageMaker modello.

   ```
   RUN pip install --no-cache-dir -U ${SMD_MODEL_PARALLEL_URL}
   ```

1. Installa la libreria parallela di SageMaker dati.

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

1. Installa il [toolkit di addestramento sagemaker](https://github.com/aws/sagemaker-training-toolkit). Il toolkit contiene le funzionalità comuni necessarie per creare un contenitore compatibile con la piattaforma di SageMaker formazione e l'SDK SageMaker Python.

   ```
   RUN pip install sagemaker-training
   ```

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 container Docker e ospitarlo in Amazon ECR.

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