Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Support für Hugging Face Transformator-Modelle
<a name="model-parallel-extended-features-pytorch-hugging-face"></a>

Die Tensorparallelität der SageMaker Modellparallelitätsbibliothek bietet sofort einsatzbereite Unterstützung für die folgenden Hugging Face Transformer-Modelle:
+ GPT-2, BERT und RobertA (verfügbar in der Modellparallelitätsbibliothek v1.7.0 und höher) SageMaker 
+ GPT-J (Verfügbar in der SageMaker Modellparallelismus-Bibliothek v1.8.0 und höher)
+ GPT-Neo (Verfügbar in der SageMaker Modellparallelismus-Bibliothek v1.10.0 und höher)

**Anmerkung**  
Für alle anderen Transformer-Modelle müssen Sie die API [smdistributed.modelparallel.torch.tp\_register\_with\_module()](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) verwenden, um die Tensor-Parallelität anzuwenden.

**Anmerkung**  
Um Tensorparallelität für das Training von Hugging Face Transformer-Modellen zu verwenden, stellen Sie sicher, dass Sie Hugging Face Deep Learning Containers verwenden, für die die Modellparallelismusbibliothek v1.7.0 und PyTorch höher verfügbar ist. SageMaker [Weitere Informationen finden Sie in den Versionshinweisen zur Modellparallelismus-Bibliothek. SageMaker ](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html)

## Ab Werk unterstützte Modelle
<a name="model-parallel-extended-features-pytorch-hugging-face-out-of-the-box"></a>

Für die Hugging Face Face-Transformer-Modelle, die von der Bibliothek standardmäßig unterstützt werden, brauchen Sie keine Hooks manuell zu implementieren, um Transformer-APIs in `smdistributed` Transformer-Layers zu übersetzen. [Sie können die Tensorparallelität aktivieren, indem Sie den Kontextmanager [smdistributed.modelparallel.torch.tensor\_parallelism () verwenden und das Modell mit 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) umschließen. DistributedModel().](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smp_versions/latest/smd_model_parallel_pytorch.html#smdistributed.modelparallel.torch.DistributedModel) Sie brauchen für die Tensor-Parallelität keine Hooks mit Hilfe der `smp.tp_register` API manuell zu registrieren.

Die `state_dict` Übersetzung funktioniert zwischen Hugging Face Transformers und `smdistributed.modelparallel` kann wie folgt aufgerufen werden.
+  `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)`(Verfügbar in der SageMaker Modellparallelismus-Bibliothek v1.8.0 und höher)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj`(Verfügbar in der SageMaker Modellparallelismus-Bibliothek v1.8.0 und höher)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)`(Verfügbar in der SageMaker Modellparallelismus-Bibliothek v1.10.0 und höher)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)`(Verfügbar in der SageMaker Modellparallelismus-Bibliothek v1.10.0 und höher)

**Beispiel für die Verwendung der Übersetzungsfunktion GPT-2 **

Beginnen Sie damit, das Modell wie im folgenden Code gezeigt zu umschließen:

```
from transformers import AutoModelForCausalLM

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

model = smp.DistributedModel(model)
```

Ausgehend `state_dict` von einem `DistributedModel` Objekt können Sie die Gewichte mithilfe der `translate_state_dict_to_hf_gpt2` Funktion, wie im folgenden Code gezeigt, in das ursprüngliche Hugging Face GPT-2 Face-Modell laden.

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

**Beispiel für die Verwendung der Übersetzungsfunktion RoBERTa**

Auf ähnliche Weise können Sie ein HuggingFace `state_dict` unterstütztes Modell mithilfe der `translate_hf_state_dict_to_smdistributed` Funktion in ein Format konvertieren, das von gelesen werden kann. `smp.DistributedModel` Dies kann bei Anwendungsfällen für Transfer Learning nützlich sein, wo ein vortrainiertes Modell zur parallelen Feinabstimmung des Modells in ein `smp.DistributedModel` geladen wird:

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