TensorFlow - Amazon SageMaker AI
Modelli TensorFlowModelli TensorFlow con Hugging Face Transformers

TensorFlow

Porta il tuo modello TensorFlow in SageMaker AI ed esegui il job di addestramento con il Compilatore SageMaker per l’addestramento.

Modelli TensorFlow

Il Compilatore di addestramento SageMaker ottimizza automaticamente i carichi di lavoro di addestramento dei modelli basati sull'API TensorFlow 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)

Per la migliore accelerazione del compilatore, consigliamo di utilizzare modelli che sono sottoclassi di TensorFlow Keras (tf.keras.Model).

Per l’addestramento su una singola GPU

Non è necessario apportare ulteriori modifiche allo script di addestramento.

Senza Keras

Il Compilatore di addestramento SageMaker non supporta l'esecuzione rapida in TensorFlow. Di conseguenza, è necessario racchiudere il modello e i cicli di addestramento con il decoratore di funzione TensorFlow (@tf.function) per sfruttare l'accelerazione del compilatore.

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

Per l’addestramento su una singola GPU

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

Modelli TensorFlow con Hugging Face Transformers

I modelli TensorFlow con Hugging Face Transformers si basano sull'API tf.keras.Model di TensorFlow. Hugging Face Transformers fornisce anche classi di modelli pre-addestrati per TensorFlow per aiutare a ridurre lo sforzo di configurazione dei modelli di elaborazione del linguaggio naturale (NLP). Dopo aver creato uno script di addestramento utilizzando la libreria Transformers, è possibile eseguire lo script di addestramento utilizzando lo strumento di stima HuggingFace di SageMaker AI con la classe di configurazione del Compilatore SageMaker per l’addestramento, come mostrato nell’argomento precedente in Esegui processi di addestramento TensorFlow con il compilatore Addestramento SageMaker.

SageMaker Training Compiler ottimizza automaticamente i carichi di lavoro di addestramento dei modelli basati sull'API TensorFlow nativa o sull'API Keras di alto livello, come i modelli di trasformatore 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 nella documentazione di Hugging Face Transformers.

Utilizzo di Keras

Per la migliore accelerazione del compilatore, consigliamo di utilizzare modelli che sono sottoclassi di TensorFlow Keras (tf.keras.Model). Come indicato nella pagina Tour veloce nella documentazione di Hugging Face Transformers, puoi utilizzare i modelli come normali modelli TensorFlow Keras.

Per l’addestramento su una singola GPU

Non è necessario apportare ulteriori modifiche allo script di addestramento.

Per l’addestramento distribuito

L'accelerazione del Compilatore di addestramento SageMaker funziona in modo trasparente per carichi di lavoro multi-GPU quando il modello viene costruito e addestrato utilizzando le API Keras nell'ambito della chiamata tf.distribute.Strategy.scope().

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

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

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

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

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

Senza Keras

Se desideri portare modelli personalizzati con cicli di addestramento personalizzati utilizzando TensorFlow senza Keras, devi racchiudere il modello e il ciclo di addestramento con il decoratore della funzione TensorFlow (@tf.function) per sfruttare l'accelerazione del compilatore.

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

Per l’addestramento su una singola GPU

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

Per l’addestramento distribuito

Oltre alle modifiche necessarie per l'utilizzo di Keras per l'addestramento distribuito, è 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.