Prise en charge des modèles Transformer Hugging Face - Amazon SageMaker
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 des tenseurs de la bibliothèque de parallélisme des SageMaker modèles prend en out-of-the-box charge les modèles Hugging Face Transformer suivants :

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

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

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

Note

Pour tous les autres modèles de Transformers, vous devez utiliser le smdistributed.modelparallel.torch.tp_register_with_module () pour appliquer le parallélisme des tenseurs. API

Note

Pour utiliser le parallélisme tensoriel pour entraîner les modèles Hugging Face Transformer, assurez-vous d'utiliser Hugging Face Deep Learning Containers car ils disposent de la bibliothèque de parallélisme PyTorch des modèles v1.7.0 et SageMaker versions ultérieures. Pour plus d'informations, consultez les notes de mise à jour de la bibliothèque de parallélisme de SageMaker modèles.

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

Pour les modèles de transformateurs Hugging Face pris en charge par la bibliothèque prêts à l'emploi, il n'est pas nécessaire d'implémenter manuellement des crochets pour traduire le transformateur en APIs couches smdistributed de transformateur. Vous pouvez activer le parallélisme tensoriel en utilisant le gestionnaire de contexte smdistributed.modelparallel.torch.tensor_parallelism () et en encapsulant le modèle par smdistributed.modelparallel.torch. DistributedModel(). Vous n'avez pas besoin d'enregistrer manuellement les crochets pour le parallélisme des tenseurs à l'aide du. smp.tp_register API

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 des SageMaker modèles v1.8.0 et versions ultérieures)

  • smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj(Disponible dans la bibliothèque de parallélisme des SageMaker modèles v1.8.0 et versions 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 des SageMaker modèles v1.10.0 et versions 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 des SageMaker modèles v1.10.0 et versions 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)

state_dictÀ partir de l'DistributedModelobjet, vous pouvez charger les poids dans le modèle Hugging GPT Face -2 original en utilisant translate_state_dict_to_hf_gpt2 la fonction indiquée dans le 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 oBERTa de traduction R

De même, étant donné qu'un HuggingFace modèle est pris en chargestate_dict, vous pouvez utiliser la translate_hf_state_dict_to_smdistributed fonction pour le convertir en un format lisible parsmp.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...