View a markdown version of this page

Ajuda para modelos tipo transformador Hugging Face - SageMaker Inteligência Artificial da Amazon
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á.

Ajuda para modelos tipo transformador Hugging Face

O paralelismo de tensores da biblioteca de paralelismo de SageMaker modelos oferece suporte pronto para uso para os seguintes modelos do Hugging Face Transformer:

  • GPT-2, BERT e RoberTA (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 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 tipo transformador Hugging Face compatíveis com a biblioteca pronta para uso, você não precisa implementar manualmente hooks para traduzir as APIs do transformador 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 hooks 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 GPT-2 tradução

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 original do Hugging GPT-2 Face usando a função, conforme mostrado 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 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 aprendizado 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...