Suporte para modelos Hugging Face Transformer - Amazon SageMaker
Modelos compatíveis prontos para uso

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

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 R oBERTa (disponível na biblioteca de paralelismo de SageMaker modelos v1.7.0 e posterior)

  • 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 o smdistributed.modelparallel.torch.tp_register_with_module () para aplicar o paralelismo de tensores. API

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 suportados pela biblioteca prontos para uso, você não precisa implementar manualmente ganchos para traduzir o Transformer em camadas de transformador. APIs 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 o. smp.tp_register API

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)

Dado a state_dict partir do DistributedModel objeto, você pode carregar os pesos no modelo Hugging GPT Face -2 original usando a função mostrada translate_state_dict_to_hf_gpt2 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 oBERTa tradução R

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