SageMaker Bonnes pratiques et considérations relatives à la formation des compilateurs

Bonnes pratiques d'ordre général

• Pensez à consulter Types d'instance pris en charge et Modèles testés.

• Lorsque vous créez un tokenizer pour un NLP modèle à l'aide de la bibliothèque Hugging Face Transformers de votre script d'entraînement, assurez-vous d'utiliser une forme de tenseur d'entrée statique en spécifiant. padding='max_length' N'utilisez pas padding='longest' car le remplissage à la séquence la plus longue du lot peut changer la forme du tenseur pour chaque lot d'entraînement. La forme d'entrée dynamique peut déclencher une recompilation du modèle et augmenter la durée totale d'entraînement. Pour obtenir plus d'informations sur les options de remplissage des créateurs de jetons Transformers, consultez Padding and truncation (Remplissage et troncature) dans la documentation de Hugging Face Transformers.

• Mesurez l'utilisation de la GPU mémoire pour vous assurer que vous utilisez la taille de lot maximale que la GPU mémoire peut contenir. Amazon SageMaker Training Compiler réduit l'empreinte mémoire de votre modèle pendant l'entraînement, ce qui vous permet généralement de placer une plus grande batch_size quantité de GPU mémoire. L'utilisation d'une batch_size plus grande taille permet une meilleure GPU utilisation et réduit le temps total d'entraînement.

  Lorsque vous ajustez la taille du lot, vous devez également ajuster learning_rate de manière appropriée. Par exemple, si vous avez augmenté la taille du lot d'un facteur de k, vous devez procéder à un ajustement linéaire de learning_rate (simple multiplication par k) ou multiplier par la racine carrée de k. Vous obtiendrez ainsi un comportement de convergence identique ou similaire avec un temps d'entraînement réduit. Pour connaître les références des tests de batch_size pour les modèles les plus populaires, consultez Modèles testés.

• Pour déboguer la tâche d'entraînement accélérée par le compilateur, activez l'indicateur debug dans le paramètre compiler_config. Cela permet SageMaker de placer les journaux de débogage dans les journaux des tâches de SageMaker formation.

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

  Notez que si vous activez le débogage complet de la tâche d'entraînement avec le compilateur, cela peut ajouter une surcharge.

Bonnes pratiques pour PyTorch

• Si vous apportez un PyTorch modèle et que vous souhaitez le contrôler, assurez-vous d'utiliser la fonction de sauvegarde XLA du modèle de PyTorch/pour vérifier correctement votre modèle. Pour plus d'informations sur cette fonction, consultez torch_xla.core.xla_model.savela documentation PyTorch sur XLA les appareils.

  Pour savoir comment ajouter les modifications à votre PyTorch script, consultezUtilisation PyTorch directe de grands modèles linguistiques (sans l'API Hugging Face Transformers Trainer).

  Pour plus d'informations sur l'application réelle de l'utilisation de la fonction de sauvegarde du modèle, consultez le blog de formation Checkpoint Writing and Loading in the Hugging Face on PyTorch/XLATPUs: Faster and cheaper.

• Pour bénéficier d'une durée d'entraînement optimale pour l'entraînement distribué, considérez ce qui suit.

  • Utilisez des instances à plusieurs GPUs au lieu d'utiliser des instances à processeur graphique unique. Par exemple, une seule instance ml.p3dn.24xlarge présente une durée d'entraînement plus courte que 8 instances ml.p3.2xlarge.

  • Utilisez des instances dotées d'EFAun support tel que ml.p3dn.24xlarge etml.p4d.24xlarge. Ces types d'instance présentent de plus grandes vitesses réseau et réduisent la durée d'entraînement.

  • Réglez le paramètre preprocessing_num_workers pour les jeux de données, afin que l'entraînement de modèle ne soit pas retardé par un prétraitement lent.

• Évitez la journalisation, les points de contrôle et le profilage des tenseurs de modèles qui conduisent à des évaluations explicites. Pour comprendre ce qu'est une évaluation explicite, prenons l'exemple de compilation de code suivant.

  a = b+c
  e = a+d

  Un compilateur interprète le code comme suit et réduit l'empreinte mémoire de la variable a :

  e = b+c+d

  Considérons maintenant le cas suivant où le code est modifié pour ajouter une fonction d'affichage de la variable a.

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

  Le compilateur effectue une évaluation explicite de la variable a comme suit.

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

  Par exemple PyTorch, évitez d'utiliser torch.tensor.items (), qui pourrait introduire des évaluations explicites. Dans le cadre du deep learning, ces évaluations explicites peuvent entraîner une surcharge, car elles rompent les opérations fusionnées dans le graphe de compilation d'un modèle et conduisent à un nouveau calcul des tenseurs.

  Si vous souhaitez toujours évaluer régulièrement le modèle pendant l'entraînement tout en utilisant SageMaker Training Compiler, nous vous recommandons d'enregistrer et de vérifier à une fréquence plus faible afin de réduire les frais liés aux évaluations explicites. Par exemple, effectuez une journalisation toutes les 10 époques plutôt qu'à chaque époque.

• La compilation des graphes est exécutée durant les premières étapes de l'entraînement. Par conséquent, les premières étapes sont généralement très lentes. Cependant, il s'agit d'un coût de compilation unique qui peut être amorti par un entraînement de plus longue durée, car la compilation permet d'accélérer considérablement les prochaines étapes. La surcharge de compilation initiale dépend de la taille du modèle, de la taille des tenseurs d'entrée et de la distribution des formes des tenseurs d'entrée.

• L'une des erreurs les plus courantes lors de la compilation d'un PyTorch modèle est due à un type d'appareil incorrect pour les opérateurs et les tenseurs. Pour compiler correctement un PyTorch modèle, assurez-vous d'utiliser XLA devices (xm.xla_device()) au lieu d'utiliser CUDA ou de mélanger des CUDA appareils et XLA des appareils.

• mark_step()est une barrière juste pourXLA. Si la tâche d'entraînement n'est pas correctement définie, cela entraînera son blocage.

• PyTorch/XLAfournit une formation distribuée supplémentaireAPIs. Si vous ne les programmez pas APIs correctement, les dégradés ne sont pas collectés correctement, ce qui entraîne un échec de la convergence d'apprentissage.