Prise en charge des modèles Transformer Hugging Face - Amazon SageMaker AI
Modèles pris en charge prêts à l'emploi

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Prise en charge des modèles Transformer Hugging Face

Le parallélisme de tenseur de la bibliothèque de parallélisme de modèles SageMaker offre une prise en charge immédiate des modèles de transformateur Hugging Face suivants :

  • GPT-2, BERT et RoBERTa (disponibles dans la bibliothèque de parallélisme de modèles SageMaker v1.7.0 et ultérieures)

  • GPT-J (disponible dans la bibliothèque de parallélisme de modèles SageMaker v1.8.0 et ultérieures)

  • GPT-Neo (disponible dans la bibliothèque de parallélisme de modèles de SageMaker v1.10.0 et ultérieures)

Note

Pour tous les autres modèles de transformateurs, vous devez utiliser l'API smdistributed.modelparallel.torch.tp_register_with_module() pour appliquer le parallélisme de tenseur.

Note

Pour utiliser le parallélisme de tenseur pour l'entraînement de modèles Hugging Face Transformer, assurez-vous d'utiliser Hugging Face Deep Learning Containers pour PyTorch qui dispose de la bibliothèque de parallélisme de modèles de SageMaker v1.7.0 et ultérieures. Pour plus d'informations, consultez SageMaker model parallelism library release notes (Notes de publication de mises à jour de la bibliothèque de parallélisme de modèles SageMaker).

Modèles pris en charge prêts à l'emploi

Si vous utilisez l'un des modèles de transformateurs Hugging Face, vous n'avez pas besoin d'implémenter manuellement de hook pour traduire les API des Transformers en couches de transformateurs smdistributed. Vous pouvez activer le parallélisme des tenseurs à l'aide du gestionnaire de contexte smdistributed.modelparallel.torch.tensor_parallelism () et en enveloppant le modèle par smdistributed.modelparallel.torch.distributedModel (). Vous n'avez pas non plus besoin d'enregistrer manuellement les crochets pour le parallélisme de tenseur à l'aide de l'API smp.tp_register.

Il est possible d'accéder aux fonctions de traduction state_dict entre les transformateurs Hugging Face et smdistributed.modelparallel comme suit.

  • smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_state_dict_to_hf_gpt2(state_dict, max_seq_len=None)

  • smdistributed.modelparallel.torch.nn.huggingface.gpt2.translate_hf_state_dict_to_smdistributed_gpt2(state_dict)

  • smdistributed.modelparallel.torch.nn.huggingface.bert.translate_state_dict_to_hf_bert(state_dict, max_seq_len=None)

  • smdistributed.modelparallel.torch.nn.huggingface.bert.translate_hf_state_dict_to_smdistributed_bert(state_dict)

  • smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_state_dict_to_hf_roberta(state_dict, max_seq_len=None)

  • smdistributed.modelparallel.torch.nn.huggingface.roberta.translate_hf_state_dict_to_smdistributed_roberta(state_dict)

  • smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_state_dict_to_hf_gptj(state_dict, max_seq_len=None) (disponible dans la bibliothèque de parallélisme de modèles SageMaker v1.8.0 et ultérieures)

  • smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj (disponible dans la bibliothèque de parallélisme de modèles SageMaker v1.8.0 et ultérieures)

  • smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None) (disponible dans la bibliothèque de parallélisme de modèles SageMaker v1.10.0 et ultérieures)

  • smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict) (disponible dans la bibliothèque de parallélisme de modèles SageMaker v1.10.0 et ultérieures)

Exemple d'utilisation de la fonction de traduction GPT-2

Commencez par envelopper le modèle, comme indiqué dans le code suivant.

from transformers import AutoModelForCausalLM

with smp.tensor_parallelism():
    model = AutoModelForCausalLM.from_config(hf_gpt2_config)

model = smp.DistributedModel(model)

De plus, avec un state_dict de l'objet DistributedModel, vous pouvez charger les poids dans le modèle HuggingFace GPT-2 d'origine à l'aide de la fonction translate_state_dict_to_hf_gpt2 du code suivant :

from smdistributed.modelparallel.torch.nn.huggingface.gpt2 \
                                      import translate_state_dict_to_hf_gpt2
max_seq_len = 1024

# [... code block for training ...]

if smp.rdp_rank() == 0:
    state_dict = dist_model.state_dict()
    hf_state_dict = translate_state_dict_to_hf_gpt2(state_dict, max_seq_len)

    # can now call model.load_state_dict(hf_state_dict) to the original HF model

Exemple d'utilisation de la fonction de traduction RoBERTa

De même, avec un state_dict de modèle HuggingFace pris en charge, vous pouvez utiliser la fonction translate_hf_state_dict_to_smdistributed pour le convertir en un format lisible par smp.DistributedModel. Cela peut être utile dans les cas d'utilisation d'apprentissage par transfert, où un modèle préentraîné est chargé dans un smp.DistributedModel pour le réglage fin du parallélisme de modèles :

from smdistributed.modelparallel.torch.nn.huggingface.roberta \
                                      import translate_state_dict_to_smdistributed

model = AutoModelForMaskedLM.from_config(roberta_config)
model = smp.DistributedModel(model)

pretrained_model = AutoModelForMaskedLM.from_pretrained("roberta-large")
translated_state_dict =
        translate_state_dict_to_smdistributed(pretrained_model.state_dict())

# load the translated pretrained weights into the smp.DistributedModel
model.load_state_dict(translated_state_dict)

# start fine-tuning...