Soporte listo para usar para modelos Hugging Face Transformer

El paralelismo tensorial de la biblioteca de paralelismo de SageMaker modelos es compatible con los siguientes modelos de Hugging Face out-of-the-box Transformer:

• GPT-2, BERT y Ro BERTa (disponibles en la biblioteca de paralelismo de modelos v1.7.0 y versiones posteriores) SageMaker

• GPT-J (disponible en la biblioteca de paralelismo de modelos v1.8.0 y versiones posteriores) SageMaker

• GPT-neo (disponible en la biblioteca de paralelismo de modelos v1.10.0 y versiones posteriores) SageMaker

nota

Para cualquier otro modelo de Transformers, debe usar la API smdistributed.modelparallel.torch.tp_register_with_module () para aplicar el paralelismo de tensores.

nota

Para usar el paralelismo tensorial para entrenar modelos de Hugging Face Transformer, asegúrate de usar Hugging Face Deep Learning Containers, que tengan la biblioteca de paralelismo de modelos PyTorch v1.7.0 y versiones posteriores. SageMaker Para obtener más información, consulte las notas de versión de la biblioteca de paralelismo de modelos. SageMaker

Modelos compatibles listos para usar

Para los modelos de transformadores Hugging Face compatibles con la biblioteca listos para usar, no es necesario implementar ganchos manualmente para traducir APIs Transformer smdistributed a capas de transformadores. Puedes activar el paralelismo tensorial usando el administrador de contexto smdistributed.modelparallel.torch.tensor_parallelism () y empaquetando el modelo con smdistributed.modelparallel.torch. DistributedModel(). No necesita registrar manualmente los enlaces para el paralelismo de los tensores mediante la API smp.tp_register.

Es posible acceder a las funciones de traducción state_dict entre Hugging Face Transformers y smdistributed.modelparallel de la siguiente manera.

• 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)(Disponible en la biblioteca de paralelismo de SageMaker modelos v1.8.0 y versiones posteriores)

• smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj(Disponible en la biblioteca de paralelismo de SageMaker modelos v1.8.0 y versiones posteriores)

• smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)(Disponible en la biblioteca de paralelismo de SageMaker modelos v1.10.0 y versiones posteriores)

• smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)(Disponible en la biblioteca de paralelismo de SageMaker modelos v1.10.0 y versiones posteriores)

Ejemplo de uso de la característica de traducción GPT-2

Comience por encapsular el modelo tal y como se muestra en el siguiente código.

from transformers import AutoModelForCausalLM

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

model = smp.DistributedModel(model)

Dado un state_dict del objeto DistributedModel, puede cargar las ponderaciones en el modelo original de Hugging Face GPT-2 usando la característica translate_state_dict_to_hf_gpt2 como se muestra en el siguiente código.

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

Ejemplo de uso de la función de traducción Ro BERTa

Del mismo modo, dado un HuggingFace modelo compatiblestate_dict, puede utilizar la translate_hf_state_dict_to_smdistributed función para convertirla a un formato legiblesmp.DistributedModel. Esto puede ser útil en casos de uso de transferencia de aprendizaje, donde un modelo preentrenado se carga en un smp.DistributedModel para un ajuste paralelo 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...