Soporte listo para usar para modelos Hugging Face Transformer - Amazon SageMaker AI
Modelos compatibles listos para usar

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Soporte listo para usar para modelos Hugging Face Transformer

El paralelismo de tensores de la biblioteca de modelos de SageMaker ofrece compatibilidad inmediata con los siguientes modelos de Hugging Face Transformer:

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

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

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

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 de tensores para entrenar modelos de Hugging Face Transformer, asegúrese de usar contenderos de aprendizaje profundo de Hugging Face para PyTorch que tengan la biblioteca de paralelismo de modelos de SageMaker v1.7.0 y versiones posteriores. Para obtener más información, consulte las notas de la versión de la biblioteca de paralelismo de modelos de SageMaker.

Modelos compatibles listos para usar

Para los modelos de Hugging Face Transformer compatibles con la biblioteca lista para usar, no es necesario implementar enlaces manualmente para traducir las API Transformer a capas de transformadores smdistributed. Puedes activar el paralelismo de tensores utilizando el administrador de contexto smdistributed.modelparallel.torch.tensor_parallelism() y encapsulando 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 modelos de SageMaker 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 modelos de SageMaker 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 modelos de SageMaker 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 modelos de SageMaker 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 característica de traducción RoBERTa

Del mismo modo, dado que el modelo state_dict de Hugging Face es compatible, puede usar la característica translate_hf_state_dict_to_smdistributed para convertirla a un formato legible por smp.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...