Supporto per i modelli Hugging Face Transformer

Il parallelismo tensoriale della libreria di parallelismo dei SageMaker modelli offre supporto per i seguenti modelli Hugging out-of-the-box Face Transformer:

Modelli supportati pronti all'uso

Per i modelli di trasformatori Hugging Face supportati dalla libreria pronti all'uso, non è necessario implementare manualmente gli hook per tradurre Transformer in livelli di trasformatore. APIs smdistributed È possibile attivare il parallelismo tensoriale utilizzando il gestore di contesto smdistributed.modelparallel.torch.tensor_parallelism () e avvolgendo il modello con smdistributed.modelparallel.torch. DistributedModel(). Non è necessario registrare manualmente gli hook per il parallelismo tensoriale utilizzando. smp.tp_register API

È possibile accedere alle funzioni di traduzione state_dict tra Hugging Face Transformers e smdistributed.modelparallel come segue.

Esempio di utilizzo della funzione di traduzione -2 GPT

Inizia effettuando il wrapping del modello come mostrato nel codice seguente.

from transformers import AutoModelForCausalLM

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

model = smp.DistributedModel(model)

Dato un state_dict dall'DistributedModeloggetto, puoi caricare i pesi nel modello originale Hugging GPT Face -2 usando translate_state_dict_to_hf_gpt2 la funzione mostrata nel codice seguente.

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

Esempio di utilizzo della funzione di oBERTa traduzione R

Allo stesso modo, dato un HuggingFace modello supportatostate_dict, è possibile utilizzare la translate_hf_state_dict_to_smdistributed funzione per convertirlo in un formato leggibile dasmp.DistributedModel. Questo può essere utile nei casi d'uso di apprendimento del trasferimento, in cui un modello pre-addestrato viene caricato in un smp.DistributedModel per l'ottimizzazione in parallelo del modello:

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