Support untuk Model Trafo Hugging Face - Amazon SageMaker
Model yang Didukung Di Luar Kotak

Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

Support untuk Model Trafo Hugging Face

Paralelisme tensor perpustakaan paralelisme SageMaker model menawarkan out-of-the-box dukungan untuk model Hugging Face Transformer berikut:

  • GPT-2, BERT, dan RoberTA (Tersedia di perpustakaan paralelisme SageMaker model v1.7.0 dan yang lebih baru)

  • GPT-J (Tersedia di perpustakaan paralelisme SageMaker model v1.8.0 dan yang lebih baru)

  • GPT-neo (Tersedia di perpustakaan paralelisme SageMaker model v1.10.0 dan yang lebih baru)

catatan

Untuk model Transformers lainnya, Anda perlu menggunakan smdistributed.modelparallel.torch.tp_register_with_module () API untuk menerapkan paralelisme tensor.

catatan

Untuk menggunakan paralelisme tensor untuk melatih model Hugging Face Transformer, pastikan Anda menggunakan Hugging Face Deep Learning Containers untuk yang SageMaker memiliki pustaka paralelisme model PyTorch v1.7.0 dan yang lebih baru. Untuk informasi selengkapnya, lihat catatan rilis perpustakaan paralelisme SageMaker model.

Model yang Didukung Di Luar Kotak

Untuk model transformator Hugging Face yang didukung oleh pustaka di luar kotak, Anda tidak perlu mengimplementasikan kait secara manual untuk menerjemahkan API smdistributed Transformer ke lapisan transformator. Anda dapat mengaktifkan paralelisme tensor dengan menggunakan manajer konteks smdistributed.modelparallel.torch.tensor_parallelism () dan membungkus model dengan smdistributed.modelparallel.torch. DistributedModel(). Anda tidak perlu mendaftarkan kait secara manual untuk paralelisme tensor menggunakan API. smp.tp_register

Fungsi state_dict terjemahan antara Hugging Face Transformers smdistributed.modelparallel dan dapat diakses sebagai berikut.

  • 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)(Tersedia di perpustakaan paralelisme SageMaker model v1.8.0 dan yang lebih baru)

  • smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj(Tersedia di perpustakaan paralelisme SageMaker model v1.8.0 dan yang lebih baru)

  • smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)(Tersedia di perpustakaan paralelisme SageMaker model v1.10.0 dan yang lebih baru)

  • smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)(Tersedia di perpustakaan paralelisme SageMaker model v1.10.0 dan yang lebih baru)

Contoh penggunaan fungsi terjemahan GPT-2

Mulailah dengan membungkus model seperti yang ditunjukkan pada kode berikut.

from transformers import AutoModelForCausalLM

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

model = smp.DistributedModel(model)

Diberikan state_dict dari DistributedModel objek, Anda dapat memuat bobot ke dalam model GPT-2 Hugging Face asli menggunakan translate_state_dict_to_hf_gpt2 fungsi seperti yang ditunjukkan pada kode berikut.

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

Contoh penggunaan fungsi terjemahan RoberTA

Demikian pula, dengan HuggingFace model yang didukungstate_dict, Anda dapat menggunakan translate_hf_state_dict_to_smdistributed fungsi untuk mengubahnya menjadi format yang dapat dibaca olehsmp.DistributedModel. Ini dapat berguna dalam kasus penggunaan pembelajaran transfer, di mana model yang telah dilatih sebelumnya dimuat ke dalam fine-tuning paralel smp.DistributedModel untuk model-paralel:

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