Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# TensorFlow
Incorpore su propio TensorFlow modelo a la SageMaker IA y ejecute el trabajo de formación con SageMaker Training Compiler.
## TensorFlow Modelos
SageMaker Training Compiler optimiza automáticamente las cargas de trabajo de entrenamiento de modelos que se crean sobre la TensorFlow API nativa o la API de Keras de alto nivel.
**sugerencia**
Para preprocesar el conjunto de datos de entrada, asegúrese de utilizar una forma de entrada estática. La forma de entrada dinámica puede iniciar la recompilación del modelo y aumentar el tiempo total de entrenamiento.
### Uso de Keras (recomendado)
[Para obtener la mejor aceleración del compilador, recomendamos utilizar modelos que sean subclases de Keras (tf.Keras.model). TensorFlow ](https://www.tensorflow.org/api_docs/python/tf/keras/Model)
#### Para el entrenamiento con una sola GPU
No es necesario realizar ningún cambio adicional en el script de entrenamiento.
### Sin Keras
SageMaker Training Compiler no admite la ejecución intensiva en. TensorFlow En consecuencia, deberías combinar tu modelo y tus ciclos de entrenamiento con la TensorFlow función decorator (`@tf.function`) para aprovechar la aceleración del compilador.
SageMaker [Training Compiler realiza una optimización a nivel de gráfico y utiliza el decorador para asegurarse de que las TensorFlow funciones estén configuradas para ejecutarse en modo gráfico.](https://www.tensorflow.org/guide/intro_to_graphs)
#### Para el entrenamiento con una sola GPU
TensorFlow La versión 2.0 o posterior tiene activada la ejecución rápida de forma predeterminada, por lo que debes añadir el `@tf.function` decorador delante de cada función que utilices para construir un modelo. TensorFlow
## TensorFlow Modelos con Hugging Face Transformers
TensorFlow los modelos con [Hugging Face](https://huggingface.co/docs/transformers/index) Transformers se TensorFlow basan en la API [tf.Keras.Model](https://www.tensorflow.org/api_docs/python/tf/keras/Model). Hugging Face Transformers también ofrece clases de modelos previamente entrenadas TensorFlow para ayudar a reducir el esfuerzo de configurar los modelos de procesamiento del lenguaje natural (NLP). Tras crear su propio guion de entrenamiento con la biblioteca de Transformers, puede ejecutarlo utilizando el `HuggingFace` estimador de SageMaker IA con la clase de configuración SageMaker Training Compiler, tal y como se muestra en el tema anterior en. [Ejecute trabajos TensorFlow de entrenamiento con SageMaker Training Compiler](training-compiler-enable-tensorflow.md)
SageMaker Training Compiler optimiza automáticamente las cargas de trabajo de entrenamiento de modelos que se basan en la TensorFlow API nativa o en la API de alto nivel de Keras, como los modelos de transformadores. TensorFlow
**sugerencia**
Cuando cree un tokenizador para un modelo de PNL con Transformers en su script de entrenamiento, asegúrese de utilizar una forma de tensor de entrada estática especificando `padding='max_length'`. No utilice `padding='longest'` porque rellenar la secuencia más larga del lote puede cambiar la forma del tensor de cada lote de entrenamiento. La forma de entrada dinámica puede iniciar la recompilación del modelo y aumentar el tiempo total de entrenamiento. Para obtener más información sobre las opciones de relleno de los tokenizadores de Transformers, consulte [Padding and truncation](https://huggingface.co/docs/transformers/pad_truncation) en la *documentación de Hugging Face Transformers*.
**Topics**
+ [Uso de Keras](#training-compiler-tensorflow-models-transformers-keras)
+ [Sin Keras](#training-compiler-tensorflow-models-transformers-no-keras)
### Uso de Keras
[Para obtener la mejor aceleración del compilador, recomendamos usar modelos que sean subclases de Keras (tf.Keras.Model). TensorFlow ](https://www.tensorflow.org/api_docs/python/tf/keras/Model) Como se indica en la página de [recorrido rápido](https://huggingface.co/docs/transformers/quicktour) de la documentación de *Hugging Face Transformers*, puede utilizar los modelos como modelos Keras TensorFlow normales.
#### Para el entrenamiento con una sola GPU
No es necesario realizar ningún cambio adicional en el script de entrenamiento.
#### Para entrenamiento distribuido
SageMaker La aceleración del compilador de entrenamiento funciona de forma transparente para cargas de trabajo con varias GPU cuando el modelo se construye y entrena utilizando las API de Keras dentro del ámbito de la demanda. [`tf.distribute.Strategy.scope()`](https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy)
1. Elija la estrategia de entrenamiento distribuida adecuada.
1. En el caso de varias GPU de un solo nodo, utilíice `tf.distribute.MirroredStrategy` para establecer la estrategia.
```
strategy = tf.distribute.MirroredStrategy()
```
1. En el caso de varios nodos y varias GPU, añade el siguiente código para configurar correctamente la configuración de entrenamiento TensorFlow distribuido antes de crear la estrategia.
```
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()
```
Utilice `tf.distribute.MultiWorkerMirroredStrategy` para establecer la estrategia.
```
strategy = tf.distribute.MultiWorkerMirroredStrategy()
```
1. Usando la estrategia que elija, encapsule el modelo.
```
with strategy.scope():
# create a model and do fit
```
### Sin Keras
Si quieres crear modelos personalizados con bucles de entrenamiento personalizados TensorFlow sin usar Keras, deberías combinar el modelo y el ciclo de entrenamiento con la TensorFlow función decorator (`@tf.function`) para aprovechar la aceleración del compilador.
SageMaker Training Compiler realiza una optimización a nivel de gráfico y utiliza el decorador para asegurarse de que las TensorFlow funciones estén configuradas para ejecutarse en modo gráfico.
#### Para el entrenamiento con una sola GPU
TensorFlow La versión 2.0 o posterior tiene activada la ejecución rápida de forma predeterminada, por lo que debes añadir el `@tf.function` decorador delante de cada función que utilices para construir un modelo. TensorFlow
#### Para entrenamiento distribuido
Además de los cambios necesarios para [usar Keras para el entrenamiento distribuido](https://docs.aws.amazon.com/sagemaker/latest/dg/training-compiler-tensorflow-models.html#training-compiler-tensorflow-models-transformers-keras), debe asegurarse de que las funciones que se ejecutarán en cada GPU estén anotadas con `@tf.function`, mientras que las funciones de comunicación entre GPU no estén anotadas. El ejemplo deñ código de entrenamiento debería ser como el siguiente:
```
@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))
```
Tenga en cuenta que esta instrucción se puede utilizar tanto para varias GPU de un solo nodo como para varias GPU de varios nodos.