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à.
# Il riferimento alla libreria parallela del SageMaker modello v2
Di seguito sono riportati i riferimenti per la SageMaker model parallel library v2 (SMP v2).
**Topics**
+ [Parametri di configurazione delle funzionalità principali di SMP v2](#distributed-model-parallel-v2-reference-init-config)
+ [Riferimento per il pacchetto `torch.sagemaker` di SMP v2](#model-parallel-v2-torch-sagemaker-reference)
+ [Aggiornamento da SMP v1 a SMP v2](#model-parallel-v2-upgrade-from-v1)
## Parametri di configurazione delle funzionalità principali di SMP v2
Di seguito è riportato un elenco completo dei parametri per l’attivazione e la configurazione di [Caratteristiche principali della libreria di parallelismo dei SageMaker modelli v2](model-parallel-core-features-v2.md). Questi devono essere scritti in formato JSON e passati allo PyTorch stimatore nell'SDK SageMaker Python o salvati come file JSON per. SageMaker HyperPod
```
{
"hybrid_shard_degree": Integer,
"sm_activation_offloading": Boolean,
"activation_loading_horizon": Integer,
"fsdp_cache_flush_warnings": Boolean,
"allow_empty_shards": Boolean,
"tensor_parallel_degree": Integer,
"context_parallel_degree": Integer,
"expert_parallel_degree": Integer,
"random_seed": Integer
}
```
+ `hybrid_shard_degree` (Integer): specifica un grado di parallelizzazione sottoposta a sharding. Il valore deve essere un numero intero compreso tra `0` e `world_size`. Il valore predefinito è `0`.
+ Se impostato su`0`, torna all' PyTorchimplementazione nativa e all'API nello script quando è 1. `tensor_parallel_degree` Altrimenti, calcola il `hybrid_shard_degree` più grande possibile in base a `tensor_parallel_degree` e `world_size`. Quando si torna ai casi d'uso nativi di PyTorch FSDP, se `FULL_SHARD` è la strategia che si utilizza, si divide in tutto il cluster di. GPUs Se la strategia era `HYBRID_SHARD` o `_HYBRID_SHARD_ZERO2`, equivale a `hybrid_shard_degree` su 8. Quando la parallelizzazione è abilitata, lo shard viene eseguito in base al `hybrid_shard_degree` rivisto.
+ Se impostato su`1`, ritorna all' PyTorchimplementazione e all'API native dello script quando `tensor_parallel_degree` è 1. `NO_SHARD` Altrimenti, è equivalente a `NO_SHARD` all’interno di un qualsiasi gruppo parallelo di tensori.
+ Se impostato su un numero intero compreso tra 2 e`world_size`, lo sharding avviene sul numero specificato di. GPUs Se non imposti `sharding_strategy` nello script FSDP, viene sovrascritto da `HYBRID_SHARD`. Se imposti `_HYBRID_SHARD_ZERO2`, viene utilizzata la `sharding_strategy` specificata.
+ `sm_activation_offloading` (Boolean): specifica se abilitare l’implementazione dell’offload di attivazione SMP. Se`False`, l'offloading utilizza l'implementazione nativa. PyTorch Se è `True`, utilizza l’implementazione di offload di attivazione SMP. È inoltre necessario utilizzare l'offload di PyTorch attivazione wrapper (`torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper`) nello script. Per ulteriori informazioni, consulta [Offload di attivazione](model-parallel-core-features-v2-pytorch-activation-offloading.md). Il valore predefinito è `True`.
+ `activation_loading_horizon` (Integer): specifica il tipo di orizzonte dell’offload di attivazione per FSDP. Si tratta del numero massimo di livelli sottoposti a checkpoint o offload i cui input possono trovarsi contemporaneamente nella memoria della GPU. Per ulteriori informazioni, consulta [Offload di attivazione](model-parallel-core-features-v2-pytorch-activation-offloading.md). Il valore di input deve essere un numero intero positivo. Il valore predefinito è `2`.
+ `fsdp_cache_flush_warnings`(Boolean) — Rileva e avvisa se si verificano svuotamenti della cache nel gestore della PyTorch memoria, poiché possono ridurre le prestazioni di calcolo. Il valore predefinito è `True`.
+ `allow_empty_shards` (Boolean): indica se consentire shard vuoti durante lo sharding dei tensori se il tensore non è divisibile. Questa è una soluzione sperimentale per gli arresti anomali durante il checkpoint in determinati scenari. La disattivazione di questa funzionalità ritorna al comportamento originale. PyTorch Il valore predefinito è `False`.
+ `tensor_parallel_degree` (Integer): specifica un grado di parallelizzazione tensoriale. Il valore deve essere compreso tra `1` e `world_size`. Il valore predefinito è `1`. Tieni presente che il passaggio di un valore maggiore di 1 non abilita automaticamente la parallelizzazione del contesto; per eseguire il wrapping del modello nello script di addestramento, devi utilizzare anche l’API [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform). Per ulteriori informazioni, consulta [Parallelizzazione tensoriale](model-parallel-core-features-v2-tensor-parallelism.md).
+ `context_parallel_degree` (Integer): specifica il grado di parallelizzazione del contesto. Il valore deve essere compreso tra `1` e `world_size` e deve essere `<= hybrid_shard_degree`. Il valore predefinito è `1`. Tieni presente che il passaggio di un valore maggiore di 1 non abilita automaticamente la parallelizzazione del contesto; per eseguire il wrapping del modello nello script di addestramento, devi utilizzare anche l’API [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform). Per ulteriori informazioni, consulta [Parallelizzazione del contesto](model-parallel-core-features-v2-context-parallelism.md).
+ `expert_parallel_degree` (Integer): specifica un grado di parallelizzazione degli esperti. Il valore deve essere compreso tra 1 e `world_size`. Il valore predefinito è `1`. Tieni presente che il passaggio di un valore maggiore di 1 non abilita automaticamente la parallelizzazione del contesto; per eseguire il wrapping del modello nello script di addestramento, devi utilizzare anche l’API [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform). Per ulteriori informazioni, consulta [Parallelizzazione degli esperti](model-parallel-core-features-v2-expert-parallelism.md).
+ `random_seed` (Integer): un numero di seed per le operazioni casuali nei moduli distribuiti mediante la parallelizzazione degli esperti o la parallelizzazione tensoriale di SMP. Questo seed viene aggiunto alle classificazioni dei tensori o degli esperti parallele per impostare il seed effettivo per ogni classificazione. Si tratta di un valore univoco per ogni classificazione dei tensori o degli esperti parallela. SMP v2 assicura che il numero casuale generato tra i ranghi tensor-parallel e expert-parallel corrisponda rispettivamente ai casi e. non-tensor-parallelism non-expert-parallelism
## Riferimento per il pacchetto `torch.sagemaker` di SMP v2
Questa sezione è un riferimento per il pacchetto `torch.sagemaker` fornito da SMP v2.
**Topics**
+ [`torch.sagemaker.delayed_param.DelayedParamIniter`](#model-parallel-v2-torch-sagemaker-reference-delayed-param-init)
+ [`torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-async-save)
+ [`torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-state-dict-saver)
+ [`torch.sagemaker.distributed.checkpoint.state_dict_saver.save`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-save)
+ [`torch.sagemaker.distributed.checkpoint.state_dict_loader.load`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-load)
+ [`torch.sagemaker.moe.moe_config.MoEConfig`](#model-parallel-v2-torch-sagemaker-reference-moe)
+ [`torch.sagemaker.nn.attn.FlashSelfAttention`](#model-parallel-v2-torch-sagemaker-reference-flashselfattention)
+ [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn)
+ [`torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention`](#model-parallel-v2-torch-sagemaker-reference-llamaFlashAttn)
+ [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform)
+ [Proprietà e funzioni `torch.sagemaker` utili](#model-parallel-v2-torch-sagemaker-reference-utils)
### `torch.sagemaker.delayed_param.DelayedParamIniter`
Un'API per l'applicazione a un modello. [Inizializzazione ritardata dei parametri](model-parallel-core-features-v2-delayed-param-init.md) PyTorch
```
class torch.sagemaker.delayed_param.DelayedParamIniter(
model: nn.Module,
init_method_using_config : Callable = None,
verbose: bool = False,
)
```
**Parametri**
+ `model`(`nn.Module`) — Un PyTorch modello per avvolgere e applicare la funzionalità di inizializzazione ritardata dei parametri di SMP v2.
+ `init_method_using_config` (Callable): se utilizzi l’implementazione della parallelizzazione tensoriale di SMP v2 o dei [Modelli di Hugging Face Transformers compatibili con la parallelizzazione tensoriale SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) supportati, mantieni questo parametro sul valore predefinito, ovvero `None`. Per impostazione predefinita, l’API `DelayedParamIniter` rileva come inizializzare correttamente il modello specificato. Per tutti gli altri modelli, è necessario creare una funzione di inizializzazione dei parametri personalizzata e aggiungerla allo script. Il seguente frammento di codice è la funzione `init_method_using_config` predefinita implementata da SMP v2 per [Modelli di Hugging Face Transformers compatibili con la parallelizzazione tensoriale SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models). Utilizza il seguente frammento di codice come riferimento per creare la tua funzione di configurazione dell’inizializzazione, aggiungerla allo script e passarla al parametro `init_method_using_config` dell’API `DelayedParamIniter` SMP.
```
from torch.sagemaker.utils.module_utils import empty_module_params, move_buffers_to_device
# Define a custom init config function.
def custom_init_method_using_config(module):
d = torch.cuda.current_device()
empty_module_params(module, device=d)
if isinstance(module, (nn.Linear, Conv1D)):
module.weight.data.normal_(mean=0.0, std=config.initializer_range)
if module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.Embedding):
module.weight.data.normal_(mean=0.0, std=config.initializer_range)
if module.padding_idx is not None:
module.weight.data[module.padding_idx].zero_()
elif isinstance(module, nn.LayerNorm):
module.weight.data.fill_(1.0)
module.bias.data.zero_()
elif isinstance(module, LlamaRMSNorm):
module.weight.data.fill_(1.0)
move_buffers_to_device(module, device=d)
delayed_initer = DelayedParamIniter(model, init_method_using_config=custom_init_method_using_config)
```
Per ulteriori informazioni sulle funzioni `torch.sagemaker.module_util` relative al frammento di codice precedente, consulta [Proprietà e funzioni `torch.sagemaker` utili](#model-parallel-v2-torch-sagemaker-reference-utils).
+ `verbose` (Boolean): indica se abilitare una registrazione di log più dettagliata durante l’inizializzazione e la convalida. Il valore predefinito è `False`.
**Metodi**
+ `get_param_init_fn()`— Restituisce la funzione di inizializzazione dei parametri che è possibile passare all'`param_init_fn`argomento della classe wrapper FSDP. PyTorch
+ `get_post_param_init_fn()`— Restituisce la funzione di inizializzazione dei parametri che è possibile passare all'`post_param_init_fn`argomento della classe wrapper FSDP. PyTorch Ciò è necessario quando nel modello sono presenti pesi condivisi. Il modello deve implementare il metodo `tie_weights`. Per ulteriori informazioni, consulta **Note sui pesi condivisi** in [Inizializzazione ritardata dei parametri](model-parallel-core-features-v2-delayed-param-init.md).
+ `count_num_params` (`module: nn.Module, *args: Tuple[nn.Parameter]`): traccia il numero di parametri inizializzati dalla funzione di inizializzazione dei parametri. Questo aiuta a implementare il seguente metodo `validate_params_and_buffers_inited`. Di solito non è necessario chiamare questa funzione in modo esplicito, perché il metodo `validate_params_and_buffers_inited` chiama implicitamente questo metodo nel backend.
+ `validate_params_and_buffers_inited` (`enabled: bool=True`): si tratta di un gestore di contesto che aiuta a controllare se il numero di parametri inizializzati corrisponde al numero totale di parametri nel modello. Verifica inoltre che tutti i parametri e i buffer si trovino ora su dispositivi GPU anziché su metadispositivi. Se queste condizioni non sono soddisfatte, genera `AssertionErrors`. Questo gestore di contesto è solo facoltativo e non è necessario utilizzarlo per inizializzare i parametri.
### `torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save`
API di input per il salvataggio asincrono. Utilizza questo metodo per salvare un `state_dict` in modo asincrono su un `checkpoint_id` specificato.
```
def async_save(
state_dict: STATE_DICT_TYPE,
*,
checkpoint_id: Union[str, os.PathLike, None] = None,
storage_writer: Optional[StorageWriter] = None,
planner: Optional[SavePlanner] = None,
process_group: Optional[dist.ProcessGroup] = None,
coordinator_rank: int = 0,
queue : AsyncCallsQueue = None,
sharded_strategy: Union[SaveShardedStrategy, Tuple[str, int], None] = None,
wait_error_handling: bool = True,
force_check_all_plans: bool = True,
s3_region: Optional[str] = None,
s3client_config: Optional[S3ClientConfig] = None
) -> None:
```
**Parametri**
+ `state_dict` (dict): obbligatorio. Il dizionario degli stati da salvare.
+ `checkpoint_id` (str): obbligatorio. Il percorso di archiviazione in cui salvare i checkpoint.
+ `storage_writer`() - Facoltativo. StorageWriter Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)in PyTorch per eseguire operazioni di scrittura. Se non specificata, viene utilizzata la configurazione predefinita di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter).
+ `planner`(SavePlanner) - Facoltativo. Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)in PyTorch. Se non specificata, viene utilizzata la configurazione predefinita di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner).
+ `process_group`(ProcessGroup) - Facoltativo. Il gruppo di processi su cui intervenire. Se è `None`, viene utilizzato il gruppo di processi (globale) predefinito.
+ `coordinator_rank` (int): facoltativo. La classificazione del coordinatore durante l’esecuzione di operatori di comunicazione collettiva come`AllReduce`.
+ `queue`(AsyncRequestQueue) - Facoltativo. Il pianificatore asincrono da utilizzare. Per impostazione predefinita, utilizza il parametro globale `DEFAULT_ASYNC_REQUEST_QUEUE`.
+ `sharded_strategy`(PyTorchDistSaveShardedStrategy) - Facoltativo. La strategia sottoposta a sharding da utilizzare per salvare i checkpoint. Se non specificata, si utilizza `torch.sagemaker.distributed.checkpoint.state_dict_saver.PyTorchDistSaveShardedStrategy` per impostazione predefinita.
+ `wait_error_handling` (bool): facoltativo. Un flag che specifica se attendere che tutte le classificazioni completino la gestione degli errori. Il valore predefinito è `True`.
+ `force_check_all_plans` (bool): facoltativo. Un flag che determina se forzare la sincronizzazione dei piani tra le classificazioni, anche in caso di riscontro nella cache. Il valore predefinito è `True`.
+ `s3_region` (str): facoltativo. La Regione in cui si trova il bucket S3. Se non specificata, la Regione viene dedotta da `checkpoint_id`.
+ `s3client_config`(S3ClientConfig) - Facoltativo. La classe di dati che espone i parametri configurabili per il client S3. Se non viene fornita, viene utilizzata la configurazione predefinita di [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7). Per impostazione predefinita, il parametro `part_size` è impostato su 64 MB.
### `torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls`
Questa funzione consente di eseguire un job di addestramento per monitorare più richieste asincrone.
```
def maybe_finalize_async_calls(
blocking=True,
process_group=None
) -> List[int]:
```
**Parametri**
+ `blocking` (bool): facoltativo. Se `True`, attende il completamento di tutte le richieste attive. Altrimenti, finalizza solo le richieste asincrone che sono già state completate. Il valore predefinito è `True`.
+ `process_group`(ProcessGroup) - Facoltativo. Il gruppo di processi su cui intervenire. Se impostato su `None`, viene utilizzato il gruppo di processi (globale) predefinito.
**Valori restituiti**
+ Un elenco contenente gli indici delle chiamate asincrone correttamente finalizzate.
### `torch.sagemaker.distributed.checkpoint.state_dict_saver.save`
Utilizza questo metodo per salvare un `state_dict` in modo sincrono su un `checkpoint_id` specificato.
```
def save(
state_dict: STATE_DICT_TYPE,
*,
checkpoint_id: Union[str, os.PathLike, None] = None,
storage_writer: Optional[StorageWriter] = None,
planner: Optional[SavePlanner] = None,
process_group: Optional[dist.ProcessGroup] = None,
coordinator_rank: int = 0,
wait_error_handling: bool = True,
force_check_all_plans: bool = True,
s3_region: Optional[str] = None,
s3client_config: Optional[S3ClientConfig] = None
) -> None:
```
**Parametri**
+ `state_dict` (dict): obbligatorio. Il dizionario degli stati da salvare.
+ `checkpoint_id` (str): obbligatorio. Il percorso di archiviazione in cui salvare i checkpoint.
+ `storage_writer`(StorageWriter) - Facoltativo. Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)in PyTorch per eseguire operazioni di scrittura. Se non specificata, viene utilizzata la configurazione predefinita di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter).
+ `planner`(SavePlanner) - Facoltativo. Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)in PyTorch. Se non specificata, viene utilizzata la configurazione predefinita di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner).
+ `process_group`(ProcessGroup) - Facoltativo. Il gruppo di processi su cui intervenire. Se è `None`, viene utilizzato il gruppo di processi (globale) predefinito.
+ `coordinator_rank` (int): facoltativo. La classificazione del coordinatore durante l’esecuzione di operatori di comunicazione collettiva come`AllReduce`.
+ `wait_error_handling` (bool): facoltativo. Un flag che specifica se attendere che tutte le classificazioni completino la gestione degli errori. Il valore predefinito è `True`.
+ `force_check_all_plans` (bool): facoltativo. Un flag che determina se forzare la sincronizzazione dei piani tra le classificazioni, anche in caso di riscontro nella cache. Il valore predefinito è `True`.
+ `s3_region` (str): facoltativo. La Regione in cui si trova il bucket S3. Se non specificata, la Regione viene dedotta da `checkpoint_id`.
+ `s3client_config`(S3ClientConfig) - Facoltativo. La classe di dati che espone i parametri configurabili per il client S3. Se non viene fornita, viene utilizzata la configurazione predefinita di [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7). Per impostazione predefinita, il parametro `part_size` è impostato su 64 MB.
### `torch.sagemaker.distributed.checkpoint.state_dict_loader.load`
Carica il dizionario di stato di un modello distribuito (`state_dict`).
```
def load(
state_dict: Dict[str, Any],
*,
checkpoint_id: Union[str, os.PathLike, None] = None,
storage_reader: Optional[StorageReader] = None,
planner: Optional[LoadPlanner] = None,
process_group: Optional[dist.ProcessGroup] = None,
check_keys_matched: bool = True,
coordinator_rank: int = 0,
s3_region: Optional[str] = None,
s3client_config: Optional[S3ClientConfig] = None
) -> None:
```
**Parametri**
+ `state_dict` (dict): obbligatorio. Il `state_dict` da caricare.
+ `checkpoint_id` (str): obbligatorio. L’ID di un checkpoint. Il significato di `checkpoint_id` dipende dallo spazio di archiviazione. Può essere il percorso di una cartella o un file. Può anche essere una chiave, se lo strumento di archiviazione è un archivio chiave-valore.
+ `storage_reader`(StorageReader) - Facoltativo. Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageReader](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageReader)in PyTorch per eseguire operazioni di lettura. Se non specificato, il checkpoint distribuito dedurrà automaticamente il lettore in base a `checkpoint_id`. Se `checkpoint_id` è anche `None`, viene generato un errore di eccezione.
+ `planner`(StorageReader) - Facoltativo. Un'istanza di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner)in PyTorch. Se non specificata, viene utilizzata la configurazione predefinita di [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner).
+ `check_keys_matched` (bool): facoltativo. Se abilitato, controlla la corrispondenza delle chiavi `state_dict` di tutte le classificazioni utilizzando `AllGather`.
+ `s3_region` (str): facoltativo. La Regione in cui si trova il bucket S3. Se non specificata, la Regione viene dedotta da `checkpoint_id`.
+ `s3client_config`(S3ClientConfig) - Facoltativo. La classe di dati che espone i parametri configurabili per il client S3. Se non viene fornita, viene utilizzata la configurazione predefinita di [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7). Per impostazione predefinita, il parametro `part_size` è impostato su 64 MB.
### `torch.sagemaker.moe.moe_config.MoEConfig`
Una classe di configurazione per configurare l'implementazione SMP di Mixture-of-Experts (MoE). È possibile specificare i valori di configurazione di MoE tramite questa classe e passarli alla chiamata API [https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-model-parallel-v2-reference.html#model-parallel-v2-torch-sagemaker-reference-transform](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-model-parallel-v2-reference.html#model-parallel-v2-torch-sagemaker-reference-transform). Per ulteriori informazioni sull’utilizzo di questa classe per l’addestramento dei modelli MoE, consulta [Parallelizzazione degli esperti](model-parallel-core-features-v2-expert-parallelism.md).
```
class torch.sagemaker.moe.moe_config.MoEConfig(
smp_moe=True,
random_seed=12345,
moe_load_balancing="sinkhorn",
global_token_shuffle=False,
moe_all_to_all_dispatcher=True,
moe_aux_loss_coeff=0.001,
moe_z_loss_coeff=0.001
)
```
**Parametri**
+ `smp_moe` (Boolean): indica se utilizzare l’implementazione SMP di MoE. Il valore predefinito è `True`.
+ `random_seed` (Integer): un numero di seed per le operazioni casuali nei moduli distribuiti mediante la parallelizzazione degli esperti. Questo seed viene aggiunto alla classificazione degli esperti parallela per impostare il seed effettivo per ogni classificazione. Si tratta di un valore univoco per ogni classificazione degli esperti parallela. Il valore predefinito è `12345`.
+ `moe_load_balancing` (String): specifica il tipo di bilanciatore del carico del router MoE. Le opzioni valide sono `aux_loss`, `sinkhorn`, `balanced` e `none`. Il valore predefinito è `sinkhorn`.
+ `global_token_shuffle` (Boolean): indica se eseguire lo shuffling dei token tra le classificazioni EP all’interno dello stesso gruppo EP. Il valore predefinito è `False`.
+ `moe_all_to_all_dispatcher`(Boolean) - Indica se usare il all-to-all dispatcher per le comunicazioni in MoE. Il valore predefinito è `True`.
+ `moe_aux_loss_coeff` (Float): un coefficiente per la perdita ausiliaria di bilanciamento del carico. Il valore predefinito è `0.001`.
+ `moe_z_loss_coeff` (Float): coefficiente per z-loss. Il valore predefinito è `0.001`.
### `torch.sagemaker.nn.attn.FlashSelfAttention`
Un’API per l’utilizzo di [FlashAttention](model-parallel-core-features-v2-flashattention.md) con SMP v2.
```
class torch.sagemaker.nn.attn.FlashSelfAttention(
attention_dropout_prob: float = 0.0,
scale: Optional[float] = None,
triton_flash_attention: bool = False,
use_alibi: bool = False,
)
```
**Parametri**
+ `attention_dropout_prob` (float): la probabilità di abbandono da applicare all’attenzione. Il valore predefinito è `0.0`.
+ `scale` (float): se passato, questo fattore di scala viene applicato per softmax. Se impostato su `None` (che è anche il valore predefinito), il fattore di scala è `1 / sqrt(attention_head_size)`. Il valore predefinito è `None`.
+ `triton_flash_attention` (bool): se passato, viene utilizzata l’implementazione Triton dell’attenzione flash. Ciò è necessario per supportare Attention with Linear Biases (ALiBi) (si veda il seguente parametro). `use_alibi` Questa versione del kernel non supporta il dropout. Il valore predefinito è `False`.
+ `use_alibi`(bool) — Se superato, abilita l'opzione Attention with Linear Biases (ALiBi) utilizzando la maschera fornita. Quando si usa ALi Bi, è necessaria una maschera di attenzione preparata come segue. Il valore predefinito è `False`.
```
def generate_alibi_attn_mask(attention_mask, batch_size, seq_length,
num_attention_heads, alibi_bias_max=8):
device, dtype = attention_mask.device, attention_mask.dtype
alibi_attention_mask = torch.zeros(
1, num_attention_heads, 1, seq_length, dtype=dtype, device=device
)
alibi_bias = torch.arange(1 - seq_length, 1, dtype=dtype, device=device).view(
1, 1, 1, seq_length
)
m = torch.arange(1, num_attention_heads + 1, dtype=dtype, device=device)
m.mul_(alibi_bias_max / num_attention_heads)
alibi_bias = alibi_bias * (1.0 / (2 ** m.view(1, num_attention_heads, 1, 1)))
alibi_attention_mask.add_(alibi_bias)
alibi_attention_mask = alibi_attention_mask[..., :seq_length, :seq_length]
if attention_mask is not None and attention_mask.bool().any():
alibi_attention_mask.masked_fill(
attention_mask.bool().view(batch_size, 1, 1, seq_length), float("-inf")
)
return alibi_attention_mask
```
**Metodi**
+ `forward(self, qkv, attn_mask=None, causal=False, cast_dtype=None, layout="b h s d")`— Una normale funzione PyTorch del modulo. Quando viene chiamato un `module(x)`, SMP esegue questa funzione automaticamente.
+ `qkv`: `torch.Tensor` con la forma `(batch_size x seqlen x (3 x num_heads) x head_size)` o `(batch_size, (3 x num_heads) x seqlen x head_size)` seguente, una tupla che include `torch.Tensors`, ciascuno dei quali potrebbe avere una forma `(batch_size x seqlen x num_heads x head_size)` oppure `(batch_size x num_heads x seqlen x head_size)`. È necessario passare un argomento di layout appropriato in base alla forma.
+ `attn_mask`: `torch.Tensor` con la forma `(batch_size x 1 x 1 x seqlen)` seguente. L’abilitazione di questo parametro della maschera di attenzione richiede `triton_flash_attention=True` e `use_alibi=True`. Per informazioni su come generare una maschera di attenzione utilizzando questo metodo, consulta gli esempi di codice disponibili in [FlashAttention](model-parallel-core-features-v2-flashattention.md). Il valore predefinito è `None`.
+ `causal`: quando è impostato su `False`, ovvero il valore predefinito dell’argomento, non viene applicata alcuna maschera. Quando è impostato su `True`, il metodo `forward` utilizza la maschera triangolare inferiore standard. Il valore predefinito è `False`.
+ `cast_dtype`: quando è impostato su un `dtype` particolare, esegue il casting dei tensori `qkv` su tale `dtype` prima che su `attn`. Questo risulta utile per le implementazioni come il modello Hugging Face Transformers GPT-NeoX, che presenta `q` e `k` con `fp32` dopo gli embedding rotativi. Se è impostato su `None`, non viene applicato alcun cast. Il valore predefinito è `None`.
+ `layout` (string): i valori disponibili sono `b h s d` o `b s h d`. Dovrebbe essere impostato sul layout dei tensori `qkv` passati, in modo da poter applicare le trasformazioni appropriate per `attn`. Il valore predefinito è `b h s d`.
**Valori restituiti**
Un solo `torch.Tensor` con forma `(batch_size x num_heads x seq_len x head_size)`.
### `torch.sagemaker.nn.attn.FlashGroupedQueryAttention`
Un’API per l’utilizzo di `FlashGroupedQueryAttention` con SMP v2. Per ulteriori informazioni sull’utilizzo di questa API, consulta [Usa i FlashAttention kernel per attirare l'attenzione sulle query raggruppate](model-parallel-core-features-v2-flashattention.md#model-parallel-core-features-v2-flashattention-grouped-query).
```
class torch.sagemaker.nn.attn.FlashGroupedQueryAttention(
attention_dropout_prob: float = 0.0,
scale: Optional[float] = None,
)
```
**Parametri**
+ `attention_dropout_prob` (float): la probabilità di abbandono da applicare all’attenzione. Il valore predefinito è `0.0`.
+ `scale` (float): se passato, questo fattore di scala viene applicato per softmax. Se impostato su `None`, come fattore di scala viene utilizzato `1 / sqrt(attention_head_size)`. Il valore predefinito è `None`.
**Metodi**
+ `forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d")`— Una normale funzione PyTorch del modulo. Quando viene chiamato un `module(x)`, SMP esegue questa funzione automaticamente.
+ `q`: `torch.Tensor` con la forma `(batch_size x seqlen x num_heads x head_size)` o `(batch_size x num_heads x seqlen x head_size)` seguente. È necessario passare un argomento di layout appropriato in base alla forma.
+ `kv`: `torch.Tensor` con la forma `(batch_size x seqlen x (2 x num_heads) x head_size)` o `(batch_size, (2 x num_heads) x seqlen x head_size)` seguente, una tupla che include due `torch.Tensor`, ciascuno dei quali potrebbe avere una forma `(batch_size x seqlen x num_heads x head_size)` oppure `(batch_size x num_heads x seqlen x head_size)`. È inoltre necessario passare un argomento `layout` appropriato in base alla forma.
+ `causal`: quando è impostato su `False`, ovvero il valore predefinito dell’argomento, non viene applicata alcuna maschera. Quando è impostato su `True`, il metodo `forward` utilizza la maschera triangolare inferiore standard. Il valore predefinito è `False`.
+ `cast_dtype`: quando è impostato su un dtype particolare, esegue il casting dei tensori `qkv` su tale dtype prima che su `attn`. Questo risulta utile per le implementazioni come Hugging Face Transformer GPT-NeoX, che presenta `q,k` con `fp32` dopo gli embedding rotativi. Se è impostato su `None`, non viene applicato alcun cast. Il valore predefinito è `None`.
+ layout (string): i valori disponibili sono `"b h s d"` o `"b s h d"`. Dovrebbe essere impostato sul layout dei tensori `qkv` passati, in modo da poter applicare le trasformazioni appropriate per `attn`. Il valore predefinito è `"b h s d"`.
**Valori restituiti**
Restituisce un solo `torch.Tensor (batch_size x num_heads x seq_len x head_size)`, che rappresenta l’output del calcolo dell’attenzione.
### `torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention`
Un'API che supporta FlashAttention il modello Llama. Questa API utilizza l’API [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) a basso livello. Per informazioni su come utilizzarla, consulta [Usa i FlashAttention kernel per attirare l'attenzione sulle query raggruppate](model-parallel-core-features-v2-flashattention.md#model-parallel-core-features-v2-flashattention-grouped-query).
```
class torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention(
config: LlamaConfig
)
```
**Parametri**
+ `config`— Una FlashAttention configurazione per il modello Llama.
**Metodi**
+ `forward(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)`
+ `hidden_states` (`torch.Tensor`): stati nascosti di un tensore sotto forma di `(batch_size x seq_len x num_heads x head_size)`.
+ `attention_mask` (`torch.LongTensor`): maschera per evitare di applicare l’attenzione agli indici dei token di padding sotto forma di `(batch_size x seqlen)`. Il valore predefinito è `None`.
+ `position_ids` (`torch.LongTensor`): quando non è `None`, si presenta sotto forma di `(batch_size x seqlen)`, a segnalare gli indici di posizione di ogni token della sequenza di input negli embedding di posizione. Il valore predefinito è `None`.
+ `past_key_value` (Cache): stati nascosti pre-calcolati (chiave e valori nei blocchi di auto-attenzione e nei blocchi di attenzione incrociata). Il valore predefinito è `None`.
+ `output_attentions` (bool): indica se restituire i tensori di attenzione di tutti i livelli di attenzione. Il valore predefinito è `False`.
+ `use_cache` (bool): indica se restituire gli stati chiave-valore `past_key_values`. Il valore predefinito è `False`.
**Valori restituiti**
Restituisce un solo `torch.Tensor (batch_size x num_heads x seq_len x head_size)`, che rappresenta l’output del calcolo dell’attenzione.
### `torch.sagemaker.transform`
SMP v2 fornisce questa API `torch.sagemaker.transform()` per trasformare i modelli di Hugging Face Transformer in implementazioni di modelli SMP e abilitare la parallelizzazione tensoriale SMP.
```
torch.sagemaker.transform(
model: nn.Module,
device: Optional[torch.device] = None,
dtype: Optional[torch.dtype] = None,
config: Optional[Dict] = None,
load_state_dict_from_rank0: bool = False,
cp_comm_type: str = "p2p"
)
```
SMP v2 mantiene le policy di trasformazione per i [Modelli di Hugging Face Transformers compatibili con la parallelizzazione tensoriale SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) convertendo la configurazione dei modelli di Hugging Face Transformer in configurazione del trasformatore SMP.
**Parametri**
+ `model` (`torch.nn.Module`): uno dei [Modelli di Hugging Face Transformers compatibili con la parallelizzazione tensoriale SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) per trasformare e applicare la funzionalità di parallelizzazione tensoriale della libreria SMP.
+ `device` (`torch.device`): se passato, viene creato un nuovo modello su questo dispositivo. Se il modulo originale dispone di qualche parametro su metadispositivo (vedi [Inizializzazione ritardata dei parametri](model-parallel-core-features-v2-delayed-param-init.md)), allora il modulo trasformato verrà creato anche sul metadispositivo, ignorando l’argomento passato qui. Il valore predefinito è `None`.
+ `dtype` (`torch.dtype`): se passato, lo imposta come gestore di contesto dtype per la creazione del modello e crea un modello utilizzando questo dtype. In genere non è necessario, poiché vogliamo creare il modello con `fp32` cui lo utilizziamo `MixedPrecision` ed `fp32` è il dtype predefinito in. PyTorch Il valore predefinito è `None`.
+ `config` (dict): dizionario per la configurazione del trasformatore SMP. Il valore predefinito è `None`.
+ `load_state_dict_from_rank0` (Boolean): per impostazione predefinita, questo modulo crea una nuova istanza del modello con nuovi pesi. Quando questo argomento è impostato su`True`, SMP tenta di caricare il dizionario di stato del PyTorch modello originale dal rango 0 al modello trasformato per il gruppo parallelo tensoriale di cui fa parte il rango 0. Quando è impostato su `True`, la classificazione 0 non può avere alcun parametro su metadispositivi. Dopo questa chiamata di trasformazione, solo il primo gruppo tensoriale parallelo popola i pesi ricavandoli dalla classificazione 0. Per estendere questi pesi dal primo gruppo tensoriale parallelo a tutti gli altri processi, è necessario impostare `sync_module_states` su `True` nel wrapper FSDP. Con questa opzione attivata, la libreria SMP carica il dizionario degli stati dal modello originale. La libreria SMP prende il `state_dict` del modello prima della trasformazione, lo converte in modo che corrisponda alla struttura del modello trasformato, ne esegue lo sharding per ogni classificazione tensoriale parallela, comunica questo stato dalla classificazione 0 ad altre classificazioni nel gruppo tensoriale parallelo di cui fa parte la classificazione 0 e lo carica. Il valore predefinito è `False`.
+ `cp_comm_type` (str): determina l’implementazione della parallelizzazione del contesto ed è applicabile solo quando `context_parallel_degree` è maggiore di 1. I valori disponibili per questo parametro sono `p2p` e `all_gather`. L'`p2p`implementazione utilizza chiamate di peer-to-peer invio e ricezione per l'accumulo del tensore key-and-value (KV) durante il calcolo dell'attenzione, eseguite in modo asincrono e consentono la sovrapposizione della comunicazione con il calcolo. L’implementazione `all_gather` utilizza invece l’operazione collettiva di comunicazione `AllGather` per l’accumulo di tensori KV. Il valore predefinito è `"p2p"`.
**Valori restituiti**
Restituisce un modello PyTorch trasformato che puoi avvolgere con FSDP. Quando `load_state_dict_from_rank0` è impostato su `True`, il gruppo tensoriale parallelo che coinvolge la classificazione 0 include pesi caricati dal dizionario degli stati originale della classificazione 0. Quando vengono utilizzati [Inizializzazione ritardata dei parametri](model-parallel-core-features-v2-delayed-param-init.md) sul modello originale, solo questi ranghi hanno i tensori effettivi attivi CPUs per i parametri e i buffer del modello trasformato. Il resto delle classificazioni continua ad avere i parametri e i buffer sul metadispositivo per risparmiare memoria.
### Proprietà e funzioni `torch.sagemaker` utili
**funzioni torch.sagemaker utili**
+ `torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None`— Inizializza il processo di formazione con SMP. PyTorch
+ `torch.sagemaker.is_initialized() -> bool`: verifica se il job di addestramento è inizializzato con SMP. **Quando si torna alla versione nativa PyTorch mentre il lavoro è inizializzato con SMP, alcune proprietà non sono pertinenti e lo diventano`None`, come indicato nel seguente elenco di proprietà.**
+ `torch.sagemaker.utils.module_utils.empty_module_params(module: nn.Module, device: Optional[torch.device] = None, recurse: bool = False) -> nn.Module`: crea parametri vuoti su un determinato `device`, se presente, e può essere ricorsivo per tutti i moduli annidati, se specificato.
+ `torch.sagemaker.utils.module_utils.move_buffers_to_device(module: nn.Module, device: torch.device, recurse: bool = False) -> nn.Module`— Sposta i buffer dei moduli nella posizione specificata e`device`, se specificato, può essere ricorsivo per tutti i moduli annidati.
**Properties**
`torch.sagemaker.state` contiene più proprietà utili dopo l’inizializzazione di SMP con `torch.sagemaker.init`.
+ `torch.sagemaker.state.hybrid_shard_degree` (int): il grado di parallelizzazione dei dati sottoposti a sharding, una copia dell’input dell’utente nella configurazione SMP passata a `torch.sagemaker.init()`. Per ulteriori informazioni, consulta [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md).
+ `torch.sagemaker.state.rank` (int): la classificazione globale del dispositivo, nell’intervallo di `[0, world_size)`.
+ `torch.sagemaker.state.rep_rank_process_group` (`torch.distributed.ProcessGroup`): il gruppo di job che include tutti i dispositivi con la stessa classificazione di replica. È importante notare la differenza lieve, ma fondamentale rispetto a `torch.sagemaker.state.tp_process_group`. Quando si ritorna alla modalità nativa PyTorch, viene restituita. `None`
+ `torch.sagemaker.state.tensor_parallel_degree` (int): il grado di parallelizzazione dei dati, una copia dell’input dell’utente nella configurazione SMP passata a `torch.sagemaker.init()`. Per ulteriori informazioni, consulta [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md).
+ `torch.sagemaker.state.tp_size` (int): un alias per `torch.sagemaker.state.tensor_parallel_degree`.
+ `torch.sagemaker.state.tp_rank` (int): il grado di parallelizzazione tensoriale per il dispositivo nell’intervallo di `[0, tp_size)`, determinato dal grado di parallelizzazione tensoriale e dal meccanismo di classificazione.
+ `torch.sagemaker.state.tp_process_group` (`torch.distributed.ProcessGroup`): il gruppo di processi tensoriali paralleli che include tutti i dispositivi con la stessa classificazione in altre dimensioni (ad esempio, replica e parallelizzazione dei dati sottoposti a sharding), ma classificazioni tensoriali parallele uniche. Quando ritorna al nativo PyTorch, ritorna`None`.
+ `torch.sagemaker.state.world_size` (int): il numero totale di dispositivi utilizzati durante l’addestramento.
## Aggiornamento da SMP v1 a SMP v2
Per passare da SMP v1 a SMP v2, è necessario apportare modifiche allo script per rimuovere l'SMP v1 e applicare l'SMP APIs v2. APIs Invece di iniziare dallo script SMP v1, si consiglia di iniziare da uno script FSDP e seguire le istruzioni riportate all'indirizzo. PyTorch [Usa la libreria di parallelismo dei SageMaker modelli v2](model-parallel-use-api-v2.md)
Per trasferire i *modelli* da SMP v1 a SMP v2, è necessario raccogliere il dizionario completo degli stati del modello in SMP v1 e applicarvi le funzioni di traduzione per convertirlo nel formato checkpoint del modello Hugging Face Transformers. Quindi in SMP v2, come discusso in[Checkpointing con SMP](model-parallel-core-features-v2-checkpoints.md), è possibile caricare i checkpoint del modello Hugging Face Transformers e quindi continuare a utilizzare il checkpoint con SMP v2. PyTorch APIs Per utilizzare SMP con il modello PyTorch FSDP, assicuratevi di passare a SMP v2 e di apportare modifiche allo script di addestramento per utilizzare FSDP e altre funzionalità più recenti. PyTorch
```
import smdistributed.modelparallel.torch as smp
# Create model
model = ...
model = smp.DistributedModel(model)
# Run training
...
# Save v1 full checkpoint
if smp.rdp_rank() == 0:
model_dict = model.state_dict(gather_to_rank0=True) # save the full model
# Get the corresponding translation function in smp v1 and translate
if model_type == "gpt_neox":
from smdistributed.modelparallel.torch.nn.huggingface.gptneox import translate_state_dict_to_hf_gptneox
translated_state_dict = translate_state_dict_to_hf_gptneox(state_dict, max_seq_len=None)
# Save the checkpoint
checkpoint_path = "checkpoint.pt"
if smp.rank() == 0:
smp.save(
{"model_state_dict": translated_state_dict},
checkpoint_path,
partial=False,
)
```
Per informazioni sulle funzioni di traduzione disponibili in SMP v1, consulta [Supporto per i modelli Hugging Face Transformer](model-parallel-extended-features-pytorch-hugging-face.md).
Per istruzioni sul salvataggio e il caricamento dei checkpoint dei modelli in SMP v2, consulta [Checkpointing con SMP](model-parallel-core-features-v2-checkpoints.md).