Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# Prise en charge des modèles Transformer Hugging Face
<a name="model-parallel-extended-features-pytorch-hugging-face"></a>

Le parallélisme tensoriel de la bibliothèque de parallélisme des SageMaker modèles offre une prise en charge prête à l'emploi pour les modèles Hugging Face Transformer suivants :
+ GPT-2, BERT et Roberta (disponible dans la bibliothèque de parallélisme des SageMaker modèles v1.7.0 et versions ultérieures)
+ GPT-J (Disponible dans la bibliothèque de parallélisme des SageMaker modèles v1.8.0 et versions ultérieures)
+ GPT-Neo (Disponible dans la bibliothèque de parallélisme des SageMaker modèles v1.10.0 et versions ultérieures)

**Note**  
Pour tous les autres modèles de transformateurs, vous devez utiliser l'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) pour appliquer le parallélisme de tenseur.

**Note**  
Pour utiliser le parallélisme tensoriel pour entraîner les modèles Hugging Face Transformer, assurez-vous d'utiliser les conteneurs Hugging Face Deep Learning pour lesquels la bibliothèque de parallélisme des modèles PyTorch v1.7.0 et versions ultérieures est SageMaker disponible. Pour plus d'informations, consultez les notes de publication de la bibliothèque de parallélisme des [ SageMaker modèles. ](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html)

## Modèles pris en charge prêts à l'emploi
<a name="model-parallel-extended-features-pytorch-hugging-face-out-of-the-box"></a>

Si vous utilisez l'un des modèles de transformateurs Hugging Face, vous n'avez pas besoin d'implémenter manuellement de hook pour traduire les API des Transformers en couches de transformateurs `smdistributed`. Vous pouvez activer le parallélisme tensoriel en utilisant le gestionnaire de contexte smdistributed.modelparallel.torch.tensor\_parallelism () et en encapsulant le modèle par [ 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). Vous n'avez pas non plus besoin d'enregistrer manuellement les crochets pour le parallélisme de tenseur à l'aide de l'API `smp.tp_register`.

Il est possible d'accéder aux fonctions de traduction `state_dict` entre les transformateurs Hugging Face et `smdistributed.modelparallel` comme suit.
+  `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 dans la bibliothèque de parallélisme des SageMaker modèles v1.8.0 et versions ultérieures)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj`(Disponible dans la bibliothèque de parallélisme des SageMaker modèles v1.8.0 et versions ultérieures)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)`(Disponible dans la bibliothèque de parallélisme des SageMaker modèles v1.10.0 et versions ultérieures)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)`(Disponible dans la bibliothèque de parallélisme des SageMaker modèles v1.10.0 et versions ultérieures)

**Exemple d'utilisation de la fonction GPT-2 de traduction **

Commencez par envelopper le modèle, comme indiqué dans le code suivant.

```
from transformers import AutoModelForCausalLM

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

model = smp.DistributedModel(model)
```

`state_dict`À partir de l'`DistributedModel`objet, vous pouvez charger les poids dans le GPT-2 modèle Hugging Face original à l'aide de la `translate_state_dict_to_hf_gpt2` fonction indiquée dans le code suivant.

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

**Exemple d'utilisation de la fonction de traduction RoBERTa**

De même, étant donné un HuggingFace modèle pris en charge`state_dict`, vous pouvez utiliser la `translate_hf_state_dict_to_smdistributed` fonction pour le convertir dans un format lisible par`smp.DistributedModel`. Cela peut être utile dans les cas d'utilisation d'apprentissage par transfert, où un modèle préentraîné est chargé dans un `smp.DistributedModel` pour le réglage fin du parallélisme de modèles :

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