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 ejecutar el guion de entrenamiento mediante 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 utilizar 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 con Keras dentro del alcance de la demanda. APIs [https://www.tensorflow.org/api_docs/python/tf/distribute/Strategy](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.