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

# TensorFlow
<a name="training-compiler-tensorflow"></a>

Implementa il tuo TensorFlow modello all' SageMaker intelligenza artificiale ed esegui il processo di formazione con Training Compiler SageMaker .

## TensorFlow Modelli
<a name="training-compiler-tensorflow-models"></a>

SageMaker Training Compiler ottimizza automaticamente i carichi di lavoro di addestramento dei modelli basati sull' TensorFlow API nativa o sull'API Keras di alto livello.

**Suggerimento**  
Per la preelaborazione del set di dati di input, assicurati di utilizzare una forma di input statica. La forma di input dinamica può avviare la ricompilazione del modello e aumentare il tempo totale di addestramento. 

### Utilizzo di Keras (consigliato)
<a name="training-compiler-tensorflow-models-keras"></a>

[Per la migliore accelerazione del compilatore, consigliamo di utilizzare modelli che sono sottoclassi di Keras (tf.keras.Model). TensorFlow ](https://www.tensorflow.org/api_docs/python/tf/keras/Model)

#### Per l’addestramento su una singola GPU
<a name="training-compiler-tensorflow-models-keras-single-gpu"></a>

Non è necessario apportare ulteriori modifiche allo script di addestramento.

### Senza Keras
<a name="training-compiler-tensorflow-models-no-keras"></a>

SageMaker Training Compiler non supporta l'esecuzione rapida in. TensorFlow Di conseguenza, è necessario avvolgere il modello e i cicli di addestramento con la TensorFlow funzione decorator (`@tf.function`) per sfruttare l'accelerazione del compilatore.

SageMaker [Training Compiler esegue un'ottimizzazione a livello di grafico e utilizza il decoratore per assicurarsi che le funzioni siano impostate per l'esecuzione TensorFlow in modalità grafico.](https://www.tensorflow.org/guide/intro_to_graphs)

#### Per l’addestramento su una singola GPU
<a name="training-compiler-tensorflow-models-no-keras-single-gpu"></a>

TensorFlow La versione 2.0 o successiva ha l'esecuzione eager attiva per impostazione predefinita, quindi è necessario aggiungere il `@tf.function` decoratore davanti a ogni funzione che si utilizza per costruire un modello. TensorFlow 

## TensorFlow Modelli con Hugging Face Transformers
<a name="training-compiler-tensorflow-models-transformers"></a>

TensorFlow [i modelli con [Hugging Face Transformers](https://huggingface.co/docs/transformers/index) si basano sull'API tf.keras.Model. TensorFlow](https://www.tensorflow.org/api_docs/python/tf/keras/Model) Hugging Face Transformers fornisce anche classi di modelli preaddestrate per aiutare TensorFlow a ridurre lo sforzo di configurazione dei modelli di elaborazione del linguaggio naturale (NLP). Dopo aver creato il tuo script di addestramento utilizzando la libreria Transformers, puoi eseguire lo script di addestramento utilizzando lo `HuggingFace` stimatore SageMaker AI con la classe di configurazione Training Compiler, come mostrato nell'argomento precedente all'indirizzo SageMaker . [Esegui lavori TensorFlow di formazione con SageMaker Training Compiler](training-compiler-enable-tensorflow.md)

SageMaker Training Compiler ottimizza automaticamente i carichi di lavoro di addestramento dei modelli basati sull' TensorFlow API nativa o sull'API Keras di alto livello, come i modelli Transformer. TensorFlow 

**Suggerimento**  
Quando si crea un tokenizzatore per un modello NLP utilizzando Transformers nello script di addestramento, assicurarsi di utilizzare una forma di tensore di input statica specificando `padding='max_length'`. Non utilizzare `padding='longest'`, in quanto il padding sulla sequenza più lunga del batch può modificare la forma del tensore per ogni batch di addestramento. La forma di input dinamica può avviare la ricompilazione del modello e aumentare il tempo totale di addestramento. Per ulteriori informazioni sulle opzioni di riempimento dei tokenizzatori Transformers, vedere [Padding and troncation](https://huggingface.co/docs/transformers/pad_truncation) nella *documentazione di Hugging Face Transformers*.

**Topics**
+ [Utilizzo di Keras](#training-compiler-tensorflow-models-transformers-keras)
+ [Senza Keras](#training-compiler-tensorflow-models-transformers-no-keras)

### Utilizzo di Keras
<a name="training-compiler-tensorflow-models-transformers-keras"></a>

[Per la migliore accelerazione del compilatore, consigliamo di utilizzare modelli che sono sottoclassi di Keras (tf.keras.Model). TensorFlow ](https://www.tensorflow.org/api_docs/python/tf/keras/Model) Come indicato nella pagina [Quick tour](https://huggingface.co/docs/transformers/quicktour) nella *documentazione di Hugging Face Transformers*, è possibile utilizzare i modelli come normali modelli Keras. TensorFlow 

#### Per l’addestramento su una singola GPU
<a name="training-compiler-tensorflow-models-transformers-keras-single-gpu"></a>

Non è necessario apportare ulteriori modifiche allo script di addestramento.

#### Per l’addestramento distribuito
<a name="training-compiler-tensorflow-models-transformers-keras-distributed"></a>

SageMaker L'accelerazione di Training Compiler funziona in modo trasparente per i carichi di lavoro con più GPU quando il modello viene costruito e addestrato utilizzando Keras nell'ambito richiesto. APIs [https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy](https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy)

1. Scegli la giusta strategia di addestramento distribuito.

   1. Per una GPU multipla a nodo singolo, usa `tf.distribute.MirroredStrategy` per impostare la strategia.

      ```
      strategy = tf.distribute.MirroredStrategy()
      ```

   1. Per una GPU multi-nodo, aggiungi il codice seguente per impostare correttamente la configurazione di addestramento distribuito prima di creare la strategia. TensorFlow 

      ```
      def set_sm_dist_config():
          DEFAULT_PORT = '8890'
          DEFAULT_CONFIG_FILE = '/opt/ml/input/config/resourceconfig.json'
          with open(DEFAULT_CONFIG_FILE) as f:
              config = json.loads(f.read())
              current_host = config['current_host']
          tf_config = {
              'cluster': {
                  'worker': []
              },
              'task': {'type': 'worker', 'index': -1}
          }
          for i, host in enumerate(config['hosts']):
              tf_config['cluster']['worker'].append("%s:%s" % (host, DEFAULT_PORT))
              if current_host == host:
                  tf_config['task']['index'] = i
          os.environ['TF_CONFIG'] = json.dumps(tf_config)
      
      set_sm_dist_config()
      ```

       Usa `tf.distribute.MultiWorkerMirroredStrategy` per impostare la strategia.

      ```
      strategy = tf.distribute.MultiWorkerMirroredStrategy()
      ```

1. Utilizzando la strategia che preferisci, esegui il wrapping del modello.

   ```
   with strategy.scope():
       # create a model and do fit
   ```

### Senza Keras
<a name="training-compiler-tensorflow-models-transformers-no-keras"></a>

Se desideri portare modelli personalizzati con cicli di allenamento personalizzati utilizzando TensorFlow senza Keras, dovresti avvolgere il modello e il ciclo di allenamento con la TensorFlow funzione decorator () `@tf.function` per sfruttare l'accelerazione del compilatore.

SageMaker Training Compiler esegue un'ottimizzazione a livello di grafico e utilizza il decoratore per assicurarsi che le funzioni siano impostate per l'esecuzione in modalità grafico. TensorFlow 

#### Per l’addestramento su una singola GPU
<a name="training-compiler-tensorflow-models-transformers-no-keras-single-gpu"></a>

TensorFlow La versione 2.0 o successiva ha l'esecuzione eager attiva per impostazione predefinita, quindi è necessario aggiungere il `@tf.function` decoratore davanti a ogni funzione che si utilizza per costruire un modello. TensorFlow 

#### Per l’addestramento distribuito
<a name="training-compiler-tensorflow-models-transformers-no-keras-distributed"></a>

Oltre alle modifiche necessarie per l'[utilizzo di Keras per l'addestramento distribuito](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-tensorflow-models.html#training-compiler-tensorflow-models-transformers-keras), è necessario assicurarsi che le funzioni da eseguire su ciascuna GPU siano annotate con `@tf.function`, mentre le funzioni di comunicazione tra GPU non siano annotate. Il codice di addestramento deve essere simile a quello riportato nell'esempio:

```
@tf.function()
def compiled_step(inputs, outputs):
    with tf.GradientTape() as tape:
        pred=model(inputs, training=True)
        total_loss=loss_object(outputs, pred)/args.batch_size
    gradients=tape.gradient(total_loss, model.trainable_variables)
    return total_loss, pred, gradients

def train_step(inputs, outputs):
    total_loss, pred, gradients=compiled_step(inputs, outputs)
    if args.weight_decay > 0.:
        gradients=[g+v*args.weight_decay for g,v in zip(gradients, model.trainable_variables)]

    optimizer.apply_gradients(zip(gradients, model.trainable_variables))

    train_loss.update_state(total_loss)
    train_accuracy.update_state(outputs, pred)

@tf.function()
def train_step_dist(inputs, outputs):
    strategy.run(train_step, args= (inputs, outputs))
```

Tieni presente che questa istruzione può essere utilizzata sia per multi-GPU a nodo singolo che per multi-GPU multi-nodo.