TensorFlow - Amazon SageMaker
Modelos TensorFlowModelos do TensorFlow com transformadores Hugging Face

TensorFlow

Traga seu próprio modelo do TensorFlow para o SageMaker e execute o trabalho de treinamento com o Compilador do Treinamento do SageMaker.

Modelos TensorFlow

O Compilador do Treinamento do SageMaker otimiza automaticamente as workloads de treinamento de modelos criadas com base na API nativa do TensorFlow ou na API Keras de alto nível.

dica

Para pré-processar seu conjunto de dados de entrada, certifique-se de usar um formato de entrada estática. O formato de entradas dinâmicas pode iniciar a recompilação do modelo e pode aumentar o tempo total de treinamento.

Usando o Keras (recomendado)

Para obter a melhor aceleração do compilador, recomendamos usar modelos que são subclasses do TensorFlow Keras (tf.Keras.Model).

Para treinamento em uma única GPU

Não há nenhuma alteração adicional que você precise fazer no script de treinamento.

Sem o Keras

O Compilador do Treinamento do SageMaker não oferece suporte à execução rápida no TensorFlow. Portanto, você deve envolver seu modelo e os loops de treinamento com a função decorador (@tf.function) do TensorFlow para aproveitar a aceleração do compilador.

O Compilador de Treinamento do SageMaker executa uma otimização no nível de gráfico e usa o decorador para garantir que suas funções do TensorFlow estejam configuradas para serem executadas no modo gráfico.

Para treinamento em uma única GPU

O TensorFlow 2.0 ou posterior tem a execução rápida ativada por padrão e, então, você deve adicionar o decorador @tf.function na frente de cada função que você usa para construir um modelo do TensorFlow.

Modelos do TensorFlow com transformadores Hugging Face

Os modelos do TensorFlow com Transformações do Hugging Face são baseados na API tf.Keras.model do TensorFlow. Os Transformadores do Hugging Face também fornecem classes de modelos pré-treinados para o TensorFlow para ajudar a reduzir o esforço de configuração de modelos de processamento de linguagem natural (PLN). Depois de criar seu próprio script de treinamento usando a biblioteca de Transformadores, você pode executar o script de treinamento usando o estimador HuggingFace com a classe de configuração do Compilador do Treinamento do SageMaker mostrada no tópico anterior em Execute trabalhos de treinamento do TensorFlow com o SageMaker Training Compiler.

O Compilador do Treinamento do SageMaker otimiza automaticamente as workloads de treinamento de modelos criadas sobre a API nativa do TensorFlow ou na API Keras de alto nível, como modelos de transformações do TensorFlow.

dica

Ao criar uma tokenização para um modelo de PNL com o uso de transformações no seu script de treinamento, certifique-se de usar uma forma de tensor de entrada estática especificando padding='max_length'. Não use padding='longest' porque o preenchimento da sequência mais longa do lote pode alterar a forma do tensor de cada lote de treinamento. A forma dinâmica de entrada pode iniciar a recompilação do modelo e pode aumentar o tempo total de treinamento. Para obter mais informações sobre as opções de preenchimento de tokenização de transformadores, consulte Preenchimento e truncamento na documentação de Transformadores do Hugging Face.

Como usar o Keras

Para obter a melhor aceleração do compilador, recomendamos usar modelos que são subclasses do TensorFlow Keras (tf.Keras.Model). Conforme observado na página Tour Rápido na documentação dos Transformadores do Hugging Face, você pode usar os modelos como modelos regulares do TensorFlow Keras.

Para treinamento em uma única GPU

Não há nenhuma alteração adicional que você precise fazer no script de treinamento.

Para treinamento distribuído

A aceleração do Compilador do Treinamento do SageMaker funciona de forma transparente para workloads com várias GPUs quando o modelo é construído e treinado usando as APIs do Keras dentro do escopo da chamada tf.distribute.Strategy.scope().

  1. Escolha a estratégia correta de treinamento distribuído.

    1. Para várias GPUs de nó único, use tf.distribute.MirroredStrategy para configurar a estratégia.

      strategy = tf.distribute.MirroredStrategy()

    2. Para várias GPUs de vários nódulos, adicione o código a seguir para configurar adequadamente a configuração de treinamento distribuído do TensorFlow antes de criar a estratégia.

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

      Use tf.distribute.MultiWorkerMirroredStrategy para configurar a estratégia.

      strategy = tf.distribute.MultiWorkerMirroredStrategy()

  2. Usando a estratégia de sua escolha, conclua o modelo.

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

Sem o Keras

Se você quiser trazer modelos personalizados fazendo loops de treinamento personalizados usando o TensorFlow sem o Keras, envolva o modelo e o loop de treinamento com a função decorador (@tf.function) do TensorFlow para aproveitar a aceleração do compilador.

O Compilador de Treinamento do SageMaker executa uma otimização no nível de gráfico e usa o decorador para garantir que suas funções do TensorFlow estejam configuradas para no modo gráfico.

Para treinamento em uma única GPU

O TensorFlow 2.0 ou posterior tem a execução rápida ativada por padrão e, então, você deve adicionar o decorador @tf.function na frente de cada função que você usa para construir um modelo do TensorFlow.

Para treinamento distribuído

Além das alterações necessárias para Usar o Keras para treinamento distribuído, você precisa garantir que as funções a serem executadas em cada GPU sejam anotadas com @tf.function, enquanto as funções de comunicação entre GPUs não forem anotadas. O código de treinamento de exemplo deve se parecer com o seguinte:

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

Observe que essas instruções podem ser usadas tanto para várias GPUs de nó único quanto para várias GPUs de vários nós.