Support für Hugging Face Transformator-Modelle - Amazon SageMaker KI
Ab Werk unterstützte Modelle

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Support für Hugging Face Transformator-Modelle

Die Tensor-Parallelität der SageMaker-Modellparallelitätsbibliothek bietet ab Werk Support für die folgenden Hugging Face Transformer-Modelle:

  • GPT-2, BERT und RobertA (die in der SageMaker-Modellparallelitätsbibliothek v1.7.0 und höher zur Verfügung stehen)

  • GPT-J (das in der SageMaker-Modellparallelitätsbibliothek v1.8.0 und höher zur Verfügung steht)

  • GPT-Neo (das in der SageMaker-Modellparallelitätsbibliothek v1.10.0 und höher zur Verfügung steht)

Anmerkung

Für alle anderen Transformer-Modelle müssen Sie die API smdistributed.modelparallel.torch.tp_register_with_module() verwenden, um die Tensor-Parallelität anzuwenden.

Anmerkung

Um die Tensor-Parallelität für das Training von Hugging Face Transformer-Modellen zu verwenden, vergewissern Sie sich, dass Sie Hugging Face Deep-Learning-Container für PyTorch verwenden, das über die SageMaker-Modellparallelitätsbibliothek v1.7.0 und höher verfügt. Weitere Informationen finden Sie in den Versionshinweisen zur Modell-Parallelitätsbibliothek von SageMaker.

Ab Werk unterstützte Modelle

Für die Hugging Face Face-Transformer-Modelle, die von der Bibliothek standardmäßig unterstützt werden, brauchen Sie keine Hooks manuell zu implementieren, um Transformer-APIs in smdistributed Transformer-Layers zu übersetzen. Sie können die Tensor-Parallelität aktivieren, indem Sie den Kontextmanager smdistributed.modelparallel.torch.tensor_parallelism() verwenden und das Modell mit smDistributed.ModelParallel.Torch.DistributedModel() umschließen. Sie brauchen für die Tensor-Parallelität keine Hooks mit Hilfe der smp.tp_register API manuell zu registrieren.

Die state_dict Übersetzung funktioniert zwischen Hugging Face Transformers und smdistributed.modelparallel kann wie folgt aufgerufen werden.

  • 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) (Verfügbar in der SageMaker-Modellparallelitätsbibliothek v1.8.0 und höher)

  • smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj (Verfügbar in der SageMaker-Modellparallelitätsbibliothek v1.8.0 und höher)

  • smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None) (Verfügbar in der SageMaker-Modellparallelitätsbibliothek v1.10.0 und höher)

  • smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict) (Verfügbar in der SageMaker-Modellparallelitätsbibliothek v1.10.0 und höher)

Beispiel für die Verwendung der GPT-2-Übersetzungsfunktion

Beginnen Sie damit, das Modell wie im folgenden Code gezeigt zu umschließen:

from transformers import AutoModelForCausalLM

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

model = smp.DistributedModel(model)

Ausgehend von state_dict von einem DistributedModel Objekt können Sie die Gewichtungen mithilfe der im folgenden Code gezeigten translate_state_dict_to_hf_gpt2 Funktion in das ursprüngliche Hugging Face GPT-2-Modell laden.

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

Beispiel für die Verwendung der Übersetzungsfunktion RoBERTa

In ähnlicher Weise können Sie es bei einem unterstützten HuggingFace-Modell state_dict mit Hilfe der translate_hf_state_dict_to_smdistributed Funktion in ein für smp.DistributedModel lesbares Format konvertieren. Dies kann bei Anwendungsfällen für Transfer Learning nützlich sein, wo ein vortrainiertes Modell zur parallelen Feinabstimmung des Modells in ein smp.DistributedModel geladen wird:

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...