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
<a name="model-parallel-extended-features-pytorch-hugging-face"></a>

Paralelisme tensor perpustakaan paralelisme SageMaker model menawarkan out-of-the-box dukungan untuk model Hugging Face Transformer berikut:
+ GPT-2, BERT, dan Ro BERTa (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\$1register\$1with\$1module () API untuk menerapkan paralelisme tensor](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tp_register_with_module).

**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](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html).

## Model yang Didukung Di Luar Kotak
<a name="model-parallel-extended-features-pytorch-hugging-face-out-of-the-box"></a>

Untuk model transformator Hugging Face yang didukung oleh perpustakaan di luar kotak, Anda tidak perlu mengimplementasikan kait secara manual untuk menerjemahkan APIs Transformer `smdistributed` ke lapisan transformator. [Anda dapat mengaktifkan paralelisme tensor dengan menggunakan manajer konteks smdistributed.modelparallel.torch.tensor\$1parallelism () dan membungkus model dengan [smdistributed.modelparallel.torch](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch_tensor_parallel.html#smdistributed.modelparallel.torch.tensor_parallelism). DistributedModel()](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#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 BERTa terjemahan Ro**

Demikian pula, dengan HuggingFace model yang didukung`state_dict`, Anda dapat menggunakan `translate_hf_state_dict_to_smdistributed` fungsi untuk mengubahnya menjadi format yang dapat dibaca oleh`smp.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...
```