View a markdown version of this page

Dukungan untuk Model Transformer Wajah Memeluk - Amazon SageMaker AI
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.

Dukungan untuk Model Transformer Wajah Memeluk

Paralelisme tensor perpustakaan paralelisme SageMaker model menawarkan dukungan out-of-the-box 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 pustaka paralelisme SageMaker model v1.8.0 dan yang lebih baru)

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

catatan

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

catatan

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

Model yang Didukung di Luar Kotak

Untuk model transformator Hugging Face yang didukung oleh pustaka di luar kotak, Anda tidak perlu menerapkan kait secara manual untuk menerjemahkan API Transformer ke lapisan smdistributed transformator. Anda dapat mengaktifkan paralelisme tensor dengan menggunakan pengelola 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 dan smdistributed.modelparallel 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 pustaka 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 pustaka 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 pustaka 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 pustaka paralelisme SageMaker model v1.10.0 dan yang lebih baru)

Contoh penggunaan fungsi ter GPT-2 jemahan

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 a state_dict dari DistributedModel objek, Anda dapat memuat bobot ke GPT-2 model 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 pra-terlatih dimuat ke dalam penyetelan 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...