Riferimento della libreria di parallelizzazione dei modelli SageMaker v2

• 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’implementazione nativa di PyTorch e all’API nello script quando tensor_parallel_degree è 1. 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 di PyTorch FSDP nativi, se la strategia utilizzata è FULL_SHARD, lo sharding avviene nell’intero cluster di GPU. 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, torna all’implementazione nativa di PyTorch e all’API per NO_SHARD nello script quando tensor_parallel_degree è 1. 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 di GPU specificato. 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’offload utilizza l’implementazione nativa di PyTorch. Se è True, utilizza l’implementazione di offload di attivazione SMP. È inoltre necessario utilizzare il wrapper dell’offload di attivazione di PyTorch (torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper) nello script. Per ulteriori informazioni, consulta Offload di attivazione. 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. Il valore di input deve essere un numero intero positivo. Il valore predefinito è 2.

• fsdp_cache_flush_warnings (Boolean): rileva e segnala eventuali svuotamenti della cache nel gestore di memoria di PyTorch, che potrebbero 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 disabilitazione di questa opzione riporta al comportamento di PyTorch originale. 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. Per ulteriori informazioni, consulta Parallelizzazione tensoriale.

• 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. Per ulteriori informazioni, consulta Parallelizzazione del contesto.

• 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. Per ulteriori informazioni, consulta Parallelizzazione degli esperti.

• 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 verifica che il numero casuale generato tra le classificazioni dei tensori o degli esperti parallele corrisponda ai casi di parallelizzazione non tensoriale e non di esperti, rispettivamente.

• model (nn.Module): un modello PyTorch per il wrapping e l’applicazione della 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 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. 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.

• verbose (Boolean): indica se abilitare una registrazione di log più dettagliata durante l’inizializzazione e la convalida. Il valore predefinito è False.

• get_param_init_fn(): restituisce la funzione di inizializzazione dei parametri che è possibile passare all’argomento param_init_fndella classe wrapper PyTorch FSDP.

• get_post_param_init_fn(): restituisce la funzione di inizializzazione dei parametri che è possibile passare all’argomento post_param_init_fndella classe wrapper PyTorch FSDP. 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.

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

• 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 StorageWriter in PyTorch per eseguire operazioni di scrittura. Se non specificata, viene utilizzata la configurazione predefinita di StorageWriter.

• planner (SavePlanner): facoltativo. Un’istanza di SavePlanner in PyTorch. Se non specificata, viene utilizzata la configurazione predefinita di 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 comeAllReduce.

• 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 fornita, viene utilizzata la configurazione predefinita di S3ClientConfig. Per impostazione predefinita, il parametro part_size è impostato su 64 MB.

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

• Un elenco contenente gli indici delle chiamate asincrone correttamente finalizzate.

• 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 StorageWriter in PyTorch per eseguire operazioni di scrittura. Se non specificata, viene utilizzata la configurazione predefinita di StorageWriter.

• planner (SavePlanner): facoltativo. Un’istanza di SavePlanner in PyTorch. Se non specificata, viene utilizzata la configurazione predefinita di 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 comeAllReduce.

• 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 fornita, viene utilizzata la configurazione predefinita di S3ClientConfig. Per impostazione predefinita, il parametro part_size è impostato su 64 MB.

• 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 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 LoadPlanner in PyTorch. Se non specificata, viene utilizzata la configurazione predefinita di 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 fornita, viene utilizzata la configurazione predefinita di S3ClientConfig. Per impostazione predefinita, il parametro part_size è impostato su 64 MB.

• 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 utilizzare un dispatcher all-to-all 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.

• 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. È necessario per supportare Attention with Linear Biases (ALiBi) (vedi il seguente parametro use_alibi). Questa versione del kernel non supporta il dropout. Il valore predefinito è False.

• use_alibi (bool): se passato, abilita Attention with Linear Biases (ALiBi) utilizzando la maschera fornita. Quando si utilizza ALiBi, è necessaria una maschera di attenzione preparata come indicato di seguito. 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

• forward(self, qkv, attn_mask=None, causal=False, cast_dtype=None, layout="b h s d"): una normale funzione del modulo PyTorch. 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. 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.

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

• forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d"): una normale funzione del modulo PyTorch. 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".

• config: una configurazione FlashAttention per il modello Llama.

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

• model (torch.nn.Module): uno dei Modelli di Hugging Face Transformers compatibili con la parallelizzazione tensoriale SMP 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), 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 questo non è necessario, poiché il nostro obiettivo è creare il modello con fp32 quando utilizziamo MixedPrecision e 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 degli stati del modello PyTorch originale dalla classificazione 0 al modello trasformato per il gruppo tensoriale parallelo di cui la classificazione 0 fa parte. 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’implementazione p2p utilizza chiamate di invio e ricezione peer-to-peer per l’accumulo di tensori chiave-valore (KV) durante il calcolo dell’attenzione e viene eseguita in modo asincrono, consentendo sovrapposizioni 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".

funzioni torch.sagemaker utili

• torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None: inizializza il job di addestramento PyTorch con SMP.

• torch.sagemaker.is_initialized() -> bool: verifica se il job di addestramento è inizializzato con SMP. Quando si torna al PyTorch nativo mentre il job è inizializzato con SMP, alcune proprietà non sono rilevanti e 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 edevice, se specificato, può essere ricorsivo per tutti i moduli annidati.

Proprietà

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 Utilizzo della libreria SageMaker Model Parallelism v2.

• 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 al PyTorch nativo, restituisce 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 Utilizzo della libreria SageMaker Model Parallelism v2.

• 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 si ritorna al PyTorch nativo, restituisce None.

• torch.sagemaker.state.world_size (int): il numero totale di dispositivi utilizzati durante l’addestramento.