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

# Passaggio 1: modifica il tuo script di addestramento utilizzando SageMaker la libreria parallela di modelli distribuiti
<a name="model-parallel-customize-training-script"></a>

Utilizza questa sezione per scoprire come personalizzare lo script di formazione per utilizzare le funzionalità principali della libreria di parallelismo dei modelli Amazon SageMaker AI. *Per utilizzare le funzioni e i parametri API specifici della libreria, ti consigliamo di utilizzare questa documentazione insieme alla [libreria model SageMaker parallel APIs](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel.html) nella documentazione di Python SageMaker SDK.*

Gli esempi di script di addestramento forniti in queste sezioni sono semplificati e progettati per evidenziare le modifiche necessarie da apportare per utilizzare la libreria. Per end-to-end esempi di notebook eseguibili che dimostrano come utilizzare uno script di PyTorch addestramento TensorFlow o di addestramento con la libreria Model Parallelism, consulta. SageMaker [Esempi di Amazon SageMaker AI Model Parallelism Library v2](distributed-model-parallel-v2-examples.md)

**Topics**
+ [Dividi il modello del tuo script di addestramento utilizzando la libreria di parallelismo dei modelli SageMaker](#model-parallel-model-splitting-using-smp-lib)
+ [Modificare uno script di addestramento TensorFlow](model-parallel-customize-training-script-tf.md)
+ [Modificare uno script PyTorch di addestramento](model-parallel-customize-training-script-pt.md)

## Dividi il modello del tuo script di addestramento utilizzando la libreria di parallelismo dei modelli SageMaker
<a name="model-parallel-model-splitting-using-smp-lib"></a>

Esistono due modi per modificare lo script di addestramento per configurare la suddivisione dei modelli: suddivisione automatica o suddivisione manuale.

### Suddivisione automatica dei modelli
<a name="model-parallel-automated-model-splitting"></a>

*Quando si utilizza SageMaker la libreria di parallelismo dei modelli, è possibile sfruttare la *suddivisione automatica dei modelli*, nota anche come partizionamento automatico dei modelli.* La libreria utilizza un algoritmo di partizionamento che bilancia la memoria, riduce al minimo la comunicazione tra i dispositivi e ottimizza le prestazioni. È possibile configurare l'algoritmo di partizionamento automatico per ottimizzare la velocità o la memoria. 

In alternativa, è possibile ricorrere alla suddivisione manuale dei modelli. Consigliamo la suddivisione automatica dei modelli, a meno che non si abbia molta dimestichezza con l'architettura dei modelli e si abbia una buona idea di come partizionare i modelli in modo efficiente.

#### Come funziona
<a name="model-parallel-automated-model-splitting-how-it-works"></a>

Il partizionamento automatico avviene durante la prima fase di addestramento, quando viene chiamata per la prima volta la funzione lavorata da `smp.step`. Durante questa chiamata, la libreria costruisce innanzitutto una versione del modello sulla RAM della CPU (per evitare limitazioni di memoria della GPU), quindi analizza il grafico del modello e prende una decisione sul partizionamento. In base a questa decisione, ogni partizione del modello viene caricata su una GPU e solo allora viene eseguita la prima fase. A causa di queste fasi di analisi e partizionamento, la prima fase di addestramento potrebbe richiedere più tempo. 

In entrambi i framework, la libreria gestisce la comunicazione tra i dispositivi tramite il proprio backend, ottimizzato per l'infrastruttura. AWS 

Il design della partizione automatica si adatta alle caratteristiche del framework e la libreria esegue il partizionamento al livello di granularità più naturale in ciascun framework. Ad esempio, in TensorFlow, ogni operazione specifica può essere assegnata a un dispositivo diverso, mentre in PyTorch, l'assegnazione viene eseguita a livello di modulo, dove ogni modulo è composto da più operazioni. La sezione seguente esamina le specifiche di design in ciascun framework.

##### Divisione automatica del modello con PyTorch
<a name="model-parallel-auto-model-split-pt"></a>

Durante la prima fase di addestramento, la libreria di parallelismo dei modelli esegue internamente una fase di tracciamento che ha lo scopo di realizzare il grafico dei modelli e determinare le forme del tensore e dei parametri. Dopo questa fase di tracciamento, la libreria realizza un albero, costituito dagli oggetti `nn.Module` annidati nel modello, oltre ai dati aggiuntivi raccolti dal tracciamento, come la quantità di dati archiviati `nn.Parameters` e il tempo di esecuzione per ciascuno `nn.Module`. 

Successivamente, la libreria attraversa questo albero dalla radice ed esegue un algoritmo di partizionamento che assegna ciascun `nn.Module` a un dispositivo, che bilancia il carico computazionale (misurato dal tempo di esecuzione del modulo) e l'uso della memoria (misurato dalla dimensione `nn.Parameter` totale memorizzata e dalle attivazioni). Se più `nn.Modules` condividono lo stesso `nn.Parameter`, questi moduli vengono posizionati sullo stesso dispositivo per evitare di mantenere più versioni dello stesso parametro. Una volta presa la decisione sul partizionamento, i moduli e i pesi assegnati vengono caricati sui rispettivi dispositivi.

Per istruzioni su come registrare il `smp.step` decoratore nel copione di PyTorch allenamento, consulta. [Divisione automatica con PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16)

##### Divisione automatica del modello con TensorFlow
<a name="model-parallel-auto-model-split-tf"></a>

La libreria di parallelismo dei modelli analizza le dimensioni delle variabili addestrabili e la struttura dei grafici e utilizza internamente un algoritmo di partizionamento dei grafici. Questo algoritmo prevede l'assegnazione di un dispositivo per ogni operazione, con l'obiettivo di ridurre al minimo la quantità di comunicazioni necessarie tra i dispositivi, nel rispetto di due vincoli: 
+ Bilanciamento del numero di variabili memorizzate in ogni dispositivo
+ Bilanciamento del numero di operazioni eseguite in ogni dispositivo

Se specifichi `speed` per `optimize` (nei parametri di parallelismo dei modelli in SDK per Python), la libreria tenta di bilanciare il numero di operazioni e gli oggetti `tf.Variable` in ogni dispositivo. Altrimenti, tenta di bilanciare la dimensione totale di `tf.Variables`.

Una volta presa la decisione sul partizionamento, la libreria crea una rappresentazione serializzata del grafico secondario che ogni dispositivo deve eseguire e la importa su ogni dispositivo. Durante il partizionamento, la libreria colloca le operazioni che utilizzano la stessa `tf.Variable` e quelle che fanno parte dello stesso livello Keras sullo stesso dispositivo. Rispetta inoltre i vincoli di colocation imposti da. TensorFlow Ciò significa che, ad esempio, se ci sono due livelli Keras che condividono una `tf.Variable`, tutte le operazioni che fanno parte di questi livelli vengono posizionate su un singolo dispositivo.

Per istruzioni su come registrare il `smp.step` decoratore nel copione di allenamento, consulta. PyTorch [Divisione automatica con TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-23)

##### Confronto della suddivisione automatica dei modelli tra framework
<a name="model-parallel-auto-model-split-comparison"></a>

In TensorFlow, l'unità di calcolo fondamentale è a`tf.Operation`, e TensorFlow rappresenta il modello come un grafo aciclico diretto (DAG) di `tf.Operation` s, e quindi la libreria di parallelismo del modello partiziona questo DAG in modo che ogni nodo vada su un dispositivo. È fondamentale che gli oggetti `tf.Operation` siano sufficientemente ricchi di attributi personalizzabili e siano universali, nel senso che è garantito che ogni modello sia costituito di un grafico di tali oggetti. 

PyTorch d'altra parte, non ha una nozione di funzionamento equivalente sufficientemente ricca e universale. L'unità di calcolo più simile PyTorch che presenta queste caratteristiche è an`nn.Module`, che ha un livello di granularità molto più elevato, ed è per questo che la libreria esegue il partizionamento a questo livello in. PyTorch

### Suddivisione manuale dei modelli
<a name="model-parallel-manual-model-splitting"></a>

Se desideri specificare manualmente come partizionare il modello tra i dispositivi, usa il gestore di contesto `smp.partition`. Per istruzioni sulla modalità di impostazione del gestore di contesto per il partizionamento manuale, consulta le pagine seguenti.
+ [Divisione manuale con TensorFlow](model-parallel-customize-training-script-tf.md#model-parallel-customize-training-script-tf-manual)
+ [Divisione manuale con PyTorch](model-parallel-customize-training-script-pt.md#model-parallel-customize-training-script-pt-16-hvd)

Per utilizzare questa opzione dopo aver apportato le modifiche, nel passaggio 2, dovrai impostare `auto_partition` e definire un `default_partition` nella classe di stima del framework dell'SDK Python SageMaker. `False` Qualsiasi operazione che non viene inserita in modo esplicito su una partizione tramite il gestore di contesto `smp.partition` è eseguita su `default_partition`. In questo caso, la logica di suddivisione automatica viene ignorata e ogni operazione viene posizionata in base alle specifiche dell'utente. In base alla struttura del grafico risultante, la libreria di parallelismo dei modelli crea automaticamente una pianificazione di esecuzione in pipeline.