Ajuda para modelos tipo transformador Hugging Face - SageMaker IA 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 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 Ro BERTa (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 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 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 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 BERTa tradução Ro

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