Suporte para modelos Hugging Face Transformer

O paralelismo tensorial da biblioteca de paralelismo de SageMaker modelos oferece suporte para os seguintes modelos do Hugging Face out-of-the-box Transformer:

• GPT-2, BERT e RobERTA (disponíveis na biblioteca de paralelismo de SageMaker modelos v1.7.0 e versões posteriores)

• GPT-J (disponível na biblioteca de paralelismo de SageMaker modelos v1.8.0 e posterior)

• GPT-Neo (disponível na biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)

nota

Para qualquer outro modelo de Transformers, você precisa usar a API smdistributed.modelparallel.torch.tp_register_with_module() para aplicar o paralelismo de tensores.

nota

Para usar o paralelismo de tensores para treinar modelos do Hugging Face Transformer, certifique-se de usar os Hugging Face Deep Learning Containers, pois eles têm a biblioteca de paralelismo de modelos v1.7.0 e versões posteriores. PyTorch SageMaker Para obter mais informações, consulte as notas de lançamento da biblioteca de paralelismo de SageMaker modelos.

Modelos compatíveis prontos para uso

Para os modelos de transformadores Hugging Face compatíveis com a biblioteca pronta para uso, você não precisa implementar manualmente ganchos para traduzir as APIs do Transformer em camadas do transformador smdistributed. Você pode ativar o paralelismo do tensor usando o gerenciador de contexto smdistributed.modelparallel.torch.tensor_parallelism () e agrupando o modelo com smdistributed.modelparallel.torch. DistributedModel(). Você não precisa registrar manualmente os ganchos para paralelismo de tensores usando a API smp.tp_register.

A tradução state_dict funciona entre Hugging Face Transformers e smdistributed.modelparallel pode ser acessada da seguinte forma.

• 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)(Disponível na biblioteca de paralelismo de SageMaker modelos v1.8.0 e posterior)

• smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj(Disponível na biblioteca de paralelismo de SageMaker modelos v1.8.0 e posterior)

• smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)(Disponível na biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)

• smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)(Disponível na biblioteca de paralelismo de SageMaker modelos v1.10.0 e posterior)

Exemplo de uso da função de tradução GPT-2

Comece com o encapsulamento do modelo conforme mostrado no código a seguir.

from transformers import AutoModelForCausalLM

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

model = smp.DistributedModel(model)

Com base state_dict no objeto DistributedModel, você pode carregar os pesos no modelo Hugging Face GPT-2 original usando a função translate_state_dict_to_hf_gpt2 mostrada no código a seguir.

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

Exemplo de uso da função de tradução RoBERTa

Da mesma forma, dado um HuggingFace modelo compatívelstate_dict, você pode usar a translate_hf_state_dict_to_smdistributed função para convertê-la em um formato legível porsmp.DistributedModel. Isso pode ser útil em casos de uso de aprendizagem por transferência, em que um modelo pré-treinado é carregado em um smp.DistributedModel para ajuste fino paralelo ao modelo:

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