Prácticas recomendadas y consideraciones sobre el Compilador de entrenamiento de SageMaker

Prácticas recomendadas generales

• Asegúrese de utilizar una de Tipos de instancias admitidos y Modelos probados.

• Cuando cree un tokenizador para un modelo de PNL con la biblioteca Hugging Face Transformers de 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 en la documentación de Hugging Face Transformers.

• Mida el uso de la memoria de la GPU para asegurarse de que utiliza el tamaño de lote máximo que cabe en la memoria de la GPU. El Compilador de entrenamiento de Amazon SageMaker reduce la huella de memoria del modelo durante el entrenamiento, lo que normalmente le permite incluir un batch_size más grande en la memoria GPU. El uso de un batch_size más grande da como resultado un mejor uso de la GPU y reduce el tiempo total de entrenamiento.

  Al ajustar el tamaño del lote, también hay que ajustar learning_rate adecuadamente. Por ejemplo, si aumentaste el tamaño del lote en un factor de k, tendrá que ajustar learning_rate linealmente (multiplicación simple por k) o multiplicar por la raíz cuadrada de k. Esto es para lograr un comportamiento de convergencia igual o similar en el reducido tiempo de entrenamiento. Para obtener una referencia sobre los modelos batch_size probados para los más populares, consulte Modelos probados.

• Para depurar el trabajo de entrenamiento acelerado por el compilador, active la marca debug en el parámetro compiler_config. Esto permite a SageMaker AI colocar los registros de depuración en los registros de trabajos de entrenamiento de SageMaker.

  huggingface_estimator=HuggingFace(
      ...
      compiler_config=TrainingCompilerConfig(debug=True)
  )

  Tenga en cuenta que si habilita la depuración completa del trabajo de entrenamiento con el compilador, esto podría suponer una sobrecarga.

Prácticas recomendadas para PyTorch

• Si trae un modelo de PyTorch y quiere comprobarlo, asegúrese de utilizar la función de guardado de modelos de PyTorch/XLA para comprobar correctamente su modelo. Para obtener más información sobre la función, consulte torch_xla.core.xla_model.saveen la documentación de PyTorch en dispositivos XLA.

  Para aprender a añadir las modificaciones a su script de PyTorch de, consulte Grandes modelos lingüísticos utilizando PyTorch directamente (sin la API Hugging Face Transformers Trainer).

  Para obtener más información sobre la aplicación real del uso de la función de guardar modelos, consulte el blog de entrenamiento Checkpoint Writing and Loading en Hugging Face on PyTorch/XLA TPUs: Faster and cheaper.

• Para lograr el tiempo de entrenamiento más óptimo para un entrenamiento distribuido, tenga en cuenta lo siguiente.

  • Use instancias con varias GPU en lugar de usar instancias de una sola GPU. Por ejemplo, una sola instancia ml.p3dn.24xlarge tiene un tiempo de entrenamiento más rápido en comparación con 8 instancias ml.p3.2xlarge.

  • Use instancias compatibles con EFA, como ml.p3dn.24xlarge y ml.p4d.24xlarge. Estos tipos de instancias tienen una velocidad de red acelerada y reducen el tiempo de entrenamiento.

  • Ajuste el parámetro preprocessing_num_workers de los conjuntos de datos para que el entrenamiento del modelo no se retrase debido a la lentitud del preprocesamiento.

• Evite registrar, comprobar y perfilar los tensores del modelo que conducen a evaluaciones explícitas. Para entender qué es una evaluación explícita, considere el siguiente ejemplo de compilación de código.

  a = b+c
  e = a+d

  Un compilador interpreta el código de la siguiente manera y reduce el consumo de memoria de la variable a:

  e = b+c+d

  Consideremos ahora el siguiente caso en el que se cambia el código para añadir una función de impresión para la variable a.

  a = b+c
  e = a+d
  print(a)

  El compilador realiza una evaluación explícita de la variable a de la siguiente manera.

  e = b+c+d
  a = b+c    # Explicit evaluation
  print(a)

  En PyTorch, por ejemplo, evite usar torch.tensor.items(), ya que podría introducir evaluaciones explícitas. En el aprendizaje profundo, estas evaluaciones explícitas pueden provocar una sobrecarga porque rompen las operaciones combinadas en un gráfico de compilación de un modelo y conducen al recálculo de los tensores.

  Si aún desea evaluar periódicamente el modelo durante el entrenamiento mientras utiliza el Compilador de entrenamiento de SageMaker, le recomendamos que registre y compruebe con una frecuencia más baja para reducir la sobrecarga debida a las evaluaciones explícitas. Por ejemplo, registre cada 10 fechas de inicio en lugar de cada fecha de inicio.

• La compilación de gráficos se ejecuta durante los primeros pasos del entrenamiento. Como resultado, se espera que los primeros pasos sean excepcionalmente lentos. Sin embargo, se trata de un coste de compilación único y se puede amortizar mediante una entrenamiento de mayor duración, ya que la compilación agiliza los pasos futuros. La sobrecarga de compilación inicial depende del tamaño del modelo, el tamaño de los tensores de entrada y la distribución de las formas de los tensores de entrada.

• Uno de los errores más típicos al compilar un modelo de PyTorch se debe a un tipo de dispositivo incorrecto para los operadores y los tensores. Para compilar correctamente un modelo de PyTorch, asegúrese de usar dispositivos XLA xm.xla_device()() en lugar de usar CUDA o mezclar dispositivos CUDA y dispositivos XLA.

• mark_step() es una barrera solo para XLA. Si no se configura correctamente, se interrumpe un trabajo de entrenamiento.

• PyTorch/XLA proporciona API de entrenamiento distribuidas adicionales. Si no se programan las API correctamente, los gradientes se recopilan de forma incorrecta, lo que provoca un error de convergencia en el entrenamiento.