Il riferimento alla libreria parallela del SageMaker modello 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 su0, 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 su1, 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 eworld_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. SeFalse, 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. 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 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. 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 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

• 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 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'param_init_fnargomento della classe wrapper FSDP. PyTorch

• get_post_param_init_fn()— Restituisce la funzione di inizializzazione dei parametri che è possibile passare all'post_param_init_fnargomento 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.

• 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() - Facoltativo. StorageWriter Un'istanza di StorageWriterin PyTorch per eseguire operazioni di scrittura. Se non specificata, viene utilizzata la configurazione predefinita di StorageWriter.

• planner(SavePlanner) - Facoltativo. Un'istanza di SavePlannerin 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 viene fornita, viene utilizzata la configurazione predefinita di S3 ClientConfig. 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 StorageWriterin PyTorch per eseguire operazioni di scrittura. Se non specificata, viene utilizzata la configurazione predefinita di StorageWriter.

• planner(SavePlanner) - Facoltativo. Un'istanza di SavePlannerin 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 viene fornita, viene utilizzata la configurazione predefinita di S3 ClientConfig. 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 StorageReaderin 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 LoadPlannerin 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 viene fornita, viene utilizzata la configurazione predefinita di S3 ClientConfig. 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 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.

• 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

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

• config— Una FlashAttention configurazione 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 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 suTrue, 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'p2pimplementazione 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".

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 diventanoNone, 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.

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.

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

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

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