Support für Hugging Face Transformator-Modelle

Die Tensorparallelität der SageMaker Modellparallelitätsbibliothek bietet sofort einsatzbereite Unterstützung für die folgenden Hugging Face Transformer-Modelle:

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 Tensorparallelität aktivieren, indem Sie den Kontextmanager smdistributed.modelparallel.torch.tensor_parallelism () verwenden und das Modell mit smdistributed.modelparallel.torch umschließen. DistributedModel(). 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.

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

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 state_dict von einem DistributedModel Objekt können Sie die Gewichte mithilfe der translate_state_dict_to_hf_gpt2 Funktion, wie im folgenden Code gezeigt, in das ursprüngliche Hugging Face GPT-2 Face-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

Auf ähnliche Weise können Sie ein HuggingFace state_dict unterstütztes Modell mithilfe der translate_hf_state_dict_to_smdistributed Funktion in ein Format konvertieren, das von gelesen werden kann. smp.DistributedModel 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...