Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

# Supporto per i modelli Hugging Face Transformer
<a name="model-parallel-extended-features-pytorch-hugging-face"></a>

Il parallelismo tensoriale della libreria di parallelismo dei SageMaker modelli offre supporto per i seguenti modelli Hugging out-of-the-box Face Transformer:
+ GPT-2, BERT e Ro (disponibili nella libreria di parallelismo dei modelli v1.7.0 e successiveBERTa ) SageMaker 
+ GPT-J (disponibile nella libreria di parallelismo dei modelli v1.8.0 e successive) SageMaker 
+ GPT-Neo (disponibile nella libreria di parallelismo dei modelli v1.10.0 e successive) SageMaker 

**Nota**  
[Per qualsiasi altro modello Transformers, è necessario utilizzare l'API smdistributed.modelparallel.torch.tp\$1register\$1with\$1module()](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) per applicare il parallelismo tensoriale.

**Nota**  
Per utilizzare il parallelismo tensoriale per addestrare i modelli Hugging Face Transformer, assicurati di utilizzare Hugging Face Deep Learning Containers perché ha la libreria di parallelismo dei modelli v1.7.0 e successive. PyTorch SageMaker Per ulteriori informazioni[, SageMaker consulta le](https://sagemaker.readthedocs.io/en/v2.199.0/api/training/smd_model_parallel_release_notes/smd_model_parallel_change_log.html) note di rilascio della libreria Model Parallelism.

## Modelli supportati pronti all'uso
<a name="model-parallel-extended-features-pytorch-hugging-face-out-of-the-box"></a>

Per i modelli di trasformatori Hugging Face supportati dalla libreria pronti all'uso, non è necessario implementare manualmente gli hook per tradurre Transformer in livelli di trasformatore. APIs `smdistributed` [È possibile attivare il parallelismo tensoriale utilizzando il gestore di contesto smdistributed.modelparallel.torch.tensor\$1parallelism () e avvolgendo il modello con 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) Non è necessario registrare manualmente gli hook per il parallelismo tensoriale utilizzando l'API `smp.tp_register`.

È possibile accedere alle funzioni di traduzione `state_dict` tra Hugging Face Transformers e `smdistributed.modelparallel` come segue.
+  `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)`(Disponibile nella libreria di parallelismo dei SageMaker modelli v1.8.0 e successive)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptj.translate_hf_gptj_state_dict_to_smdistributed_gptj`(Disponibile nella libreria di parallelismo dei SageMaker modelli v1.8.0 e successive)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_state_dict_to_hf_gptneo(state_dict, max_seq_len=None)`(Disponibile nella libreria di parallelismo dei SageMaker modelli v1.10.0 e successive)
+ `smdistributed.modelparallel.torch.nn.huggingface.gptneo.translate_hf_state_dict_to_smdistributed_gptneo(state_dict)`(Disponibile nella libreria di parallelismo dei SageMaker modelli v1.10.0 e successive)

**Esempio di utilizzo della funzione di traduzione GPT-2**

Inizia effettuando il wrapping del modello come mostrato nel codice seguente.

```
from transformers import AutoModelForCausalLM

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

model = smp.DistributedModel(model)
```

Dato un `state_dict` dall'oggetto `DistributedModel`, puoi caricare i pesi nel modello Hugging Face GPT-2 originale usando la funzione `translate_state_dict_to_hf_gpt2` mostrata nel codice seguente.

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

**Esempio di utilizzo della funzione di traduzione Ro BERTa **

Allo stesso modo, dato un HuggingFace modello supportato`state_dict`, è possibile utilizzare la `translate_hf_state_dict_to_smdistributed` funzione per convertirlo in un formato leggibile da`smp.DistributedModel`. Questo può essere utile nei casi d'uso di apprendimento del trasferimento, in cui un modello pre-addestrato viene caricato in un `smp.DistributedModel` per l'ottimizzazione in parallelo del modello:

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