A biblioteca de paralelismo de modelos do SageMaker v2 de referência

• hybrid_shard_degree (inteiro): determina um grau de paralelismo fragmentado. O valor deve ser um número inteiro entre 0 e world_size. O valor padrão é 0.

  • Se definido como 0, ele volta para a implementação nativa do PyTorch e para a API no script quando tensor_parallel_degree é 1. Caso contrário, ele calcula o maior hybrid_shard_degree possível com base em tensor_parallel_degree e world_size. Ao recorrer aos casos de uso nativos do FSDP do PyTorch, se FULL_SHARD for a estratégia usada, ela fragmenta-se em todo o cluster de GPUs. Se HYBRID_SHARD ou _HYBRID_SHARD_ZERO2 foi a estratégia, é equivalente hybrid_shard_degree de 8. Quando o paralelismo de tensores está ativado, ele fragmenta-se com base na versão revisada de hybrid_shard_degree.

  • Se definido como 1, ele volta para a implementação nativa do PyTorch e para a API NO_SHARD no script quando tensor_parallel_degree é 1. Caso contrário, é equivalente a NO_SHARD em qualquer grupo de paralelismo de tensores.

  • Se definido como um número inteiro entre 2 e world_size, a fragmentação ocorre no número definido de GPUs. Se você não configurar sharding_strategy no script do FSDP, ele será substituído por HYBRID_SHARD. Se você definir _HYBRID_SHARD_ZERO2, será usado o sharding_strategy que você definir.

• sm_activation_offloading (booleano): define se deve ser ativada a implementação de descarregamento de ativação do SMP. Se False, o descarregamento usa a implementação nativa do PyTorch. Se True, ele usa a implementação de descarregamento de ativação do SMP. Você também precisa usar o wrapper de descarregamento de ativação (torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper) do PyTorch no script. Para saber mais, consulte Ativação e descarregamento. O valor padrão é True.

• activation_loading_horizon (inteiro): um número inteiro que especifica o tipo de horizonte de descarga de ativação para o FSDP. Esse é o número máximo de camadas com pontos de verificação ou descarregadas cujas entradas podem estar na memória da GPU simultaneamente. Para saber mais, consulte Ativação e descarregamento. O valor da entrada deve ser um inteiro positivo. O valor padrão é 2.

• fsdp_cache_flush_warnings (booleano): detecta e avisa se as liberações de cache ocorrem no gerenciador de memória PyTorch, pois elas podem prejudicar o desempenho computacional. O valor padrão é True.

• allow_empty_shards (booleano): se deve permitir fragmentos vazios ao fragmentar tensores, se o tensor não for divisível. Essa é uma correção experimental para falhas durante o checkpoint em determinados cenários. Desabilitá-la retorna ao comportamento original do PyTorch. O valor padrão é False.

• tensor_parallel_degree (inteiro): determina um grau de paralelismo de tensores. O valor deve estar entre 1 e world_size. O valor padrão é 1. Observe que passar um valor maior que 1 não ativa automaticamente o paralelismo de contexto. Você também precisa usar a API torch.sagemaker.transform para incluir o modelo no script de treinamento. Para saber mais, consulte Paralelismo de tensores.

• context_parallel_degree (inteiro): determina o grau de paralelismo do contexto. O valor deve estar entre 1 e world_size, e deve ser <= hybrid_shard_degree. O valor padrão é 1. Observe que passar um valor maior que 1 não ativa automaticamente o paralelismo de contexto. Você também precisa usar a API torch.sagemaker.transform para incluir o modelo no script de treinamento. Para saber mais, consulte Paralelismo de contexto.

• expert_parallel_degree (inteiro): determina um grau de paralelismo especializado. O valor deve estar entre 1 e world_size. O valor padrão é 1. Observe que passar um valor maior que 1 não ativa automaticamente o paralelismo de contexto. Você também precisa usar a API torch.sagemaker.transform para incluir o modelo no script de treinamento. Para saber mais, consulte Paralelismo especializado.

• random_seed (inteiro): um número inicial para as operações randomizadas em módulos distribuídos por paralelismo de tensores ou paralelismo especializado do SMP. Esse número inicial é adicionado às classificações de paralelismo de tensores ou de paralelismo especializado para definir o número inicial real para cada classificação. É exclusivo para cada classificação de paralelismo de tensores ou de paralelismo especializado. O SMP v2 garante que o número aleatório gerado nas classificações de paralelismo de tensores ou de paralelismo especializado corresponda aos casos de paralelismo sem tensor e casos de paralelismo não especializado, respectivamente.

• model (nn.Module): um modelo PyTorch para envolver e aplicar a funcionalidade de inicialização atrasada de parâmetros do SMP v2.

• init_method_using_config (chamável): se você usar a implementação de paralelismo de tensores do SMP v2 ou Modelos tipo transformador da Hugging Face compatíveis com o paralelismo de tensores no SMP compatível, mantenha esse parâmetro no valor padrão, que é de None. Por padrão, a API DelayedParamIniter descobre como inicializar o modelo fornecido corretamente. Para qualquer outro modelo, você precisa criar uma função de inicialização de parâmetros personalizada e adicioná-la ao script. O trecho de código a seguir é a função init_method_using_config padrão que o SMP v2 implementou para o Modelos tipo transformador da Hugging Face compatíveis com o paralelismo de tensores no SMP. Use o seguinte trecho de código como referência para criar sua própria função de configuração de inicialização, adicioná-la ao script e passá-la para o parâmetro init_method_using_config da API DelayedParamIniter do 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)

  Para obter mais informações sobre as funções torch.sagemaker.module_util no trecho de código anterior, consulte torch.sagemaker funções e propriedades do utilitário.

• verbose (booleano): se for necessário ativar um registro mais detalhado durante a inicialização e a validação. O valor padrão é False.

• get_param_init_fn(): retorna à função de inicialização do parâmetro que você pode passar para o argumento param_init_fn da função wrapper do FSDP do PyTorch.

• get_post_param_init_fn(): retorna à função de inicialização do parâmetro que você pode passar para o argumento post_param_init_fn da função wrapper do FSDP do PyTorch. Isso é necessário quando você iguala pesos no modelo. O modelo deve implementar o método tie_weights. Para obter mais informações, consulte as Notas sobre pesos iguais em Inicialização do parâmetro atrasada.

• count_num_params (module: nn.Module, *args: Tuple[nn.Parameter]): rastreia quantos parâmetros estão sendo inicializados pela função de inicialização de parâmetros. Isso ajuda a implementar o método validate_params_and_buffers_inited a seguir. Normalmente, não é necessário chamar essa função explicitamente, porque o método validate_params_and_buffers_inited chama implicitamente esse método no backend.

• validate_params_and_buffers_inited (enabled: bool=True): este é um gerenciador de contexto que ajuda a validar se o número de parâmetros inicializados corresponde ao número total de parâmetros no modelo. Ele também valida para que todos os parâmetros e buffers agora estejam em dispositivos de GPU, em vez de dispositivos meta. Isso aumenta AssertionErrors, se essas condições não forem atendidas. Esse gerenciador de contexto é apenas opcional e não é necessário o usar para inicializar parâmetros.

• state_dict (dict): obrigatório. O dicionário de estado para salvar.

• checkpoint_id (str): obrigatório. O caminho de armazenamento onde salvar os pontos de verificação.

• storage_writer (StorageWriter): opcional. Uma instância do StorageWriter, no PyTorch, para realizar operações de gravação. Se ela não for definida, será usada a configuração padrão do StorageWriter.

• planner (SavePlanner): opcional. Uma instância do SavePlanner no PyTorch. Se ela não for definida, será usada a configuração padrão do SavePlanner.

• process_group (ProcessGroup): opcional. O grupo de processos no qual trabalhar. Se None, será usado o grupo de processos padrão (global).

• coordinator_rank (int): opcional. A classificação do coordenador ao realizar operadores de comunicação coletiva, como AllReduce.

• queue (AsyncRequestQueue): opcional. O programador assíncrono a ser usado. Por padrão, ele usa o parâmetro global DEFAULT_ASYNC_REQUEST_QUEUE.

• sharded_strategy (PyTorchDistSaveShardedStrategy): opcional. A estratégia fragmentada a ser usada para salvar pontos de verificação. Se não for especificado, torch.sagemaker.distributed.checkpoint.state_dict_saver.PyTorchDistSaveShardedStrategy é usado como padrão.

• wait_error_handling (bool): opcional. Um sinalizador que especifica se deve esperar que todas as classificações concluam o tratamento de erros. O valor padrão é True.

• force_check_all_plans (bool): opcional. Um sinalizador que determina se os planos devem ser sincronizados à força em todos os níveis, mesmo no caso de uma falha no cache. O valor padrão é True.

• s3_region (str): opcional. A região em que o bucket do S3 está localizado. Se não for especificada, a região será inferida do checkpoint_id.

• s3client_config (S3ClientConfig): opcional. A classe de dados que expõe parâmetros configuráveis para o cliente S3. Se não for fornecida, será usada a configuração padrão do S3ClientConfig. O parâmetro part_size é definido como 64 MB por padrão.

• blocking (bool): opcional. Se True, será esperado até que sejam concluídas todas as solicitações ativas. Caso contrário, ele finaliza somente as solicitações assíncronas que já foram concluídas. O valor padrão é True.

• process_group (ProcessGroup): opcional. O grupo de processos no qual operar. Se definido como None, será utilizado o grupo de processos padrão (global).

• Uma lista contendo os índices de chamadas assíncronas foi finalizada com sucesso.

• state_dict (dict): obrigatório. O dicionário de estado para salvar.

• checkpoint_id (str): obrigatório. O caminho de armazenamento onde salvar os pontos de verificação.

• storage_writer (StorageWriter): opcional. Uma instância do StorageWriter, no PyTorch, para realizar operações de gravação. Se ela não for definida, será usada a configuração padrão do StorageWriter.

• planner (SavePlanner): opcional. Uma instância do SavePlanner no PyTorch. Se ela não for definida, será usada a configuração padrão do SavePlanner.

• process_group (ProcessGroup): opcional. O grupo de processos no qual trabalhar. Se None, será usado o grupo de processos padrão (global).

• coordinator_rank (int): opcional. A classificação do coordenador ao realizar operadores de comunicação coletiva, como AllReduce.

• wait_error_handling (bool): opcional. Um sinalizador que especifica se deve esperar que todas as classificações concluam o tratamento de erros. O valor padrão é True.

• force_check_all_plans (bool): opcional. Um sinalizador que determina se os planos devem ser sincronizados à força em todos os níveis, mesmo no caso de uma falha no cache. O valor padrão é True.

• s3_region (str): opcional. A região em que o bucket do S3 está localizado. Se não for especificada, a região será inferida do checkpoint_id.

• s3client_config (S3ClientConfig): opcional. A classe de dados que expõe parâmetros configuráveis para o cliente S3. Se não for fornecida, será usada a configuração padrão do S3ClientConfig. O parâmetro part_size é definido como 64 MB por padrão.

• state_dict (dict): obrigatório. O state_dict para carregar.

• checkpoint_id (str): obrigatório. O ID de um ponto de verificação. O significado do checkpoint_id depende do armazenamento. Pode ser um caminho para uma pasta ou para um arquivo. Também pode ser uma chave, se o armazenamento for um armazenamento de valores-chave.

• storage_reader (StorageReader): opcional. Uma instância do StorageReader, no PyTorch, para realizar operações de leitura. Se não for especificado, o ponto de verificação distribuído inferirá automaticamente o leitor com base no checkpoint_id. Se o checkpoint_id também for None, será gerado um erro de exceção.

• planner (StorageReader): opcional. Uma instância do LoadPlanner no PyTorch. Se não for especificada, será usada a configuração padrão de LoadPlanner.

• check_keys_matched (bool): opcional. Se ativado, verifica se as chaves state_dict de todas as classificações são combinadas usando AllGather.

• s3_region (str): opcional. A região em que o bucket do S3 está localizado. Se não for especificada, a região será inferida do checkpoint_id.

• s3client_config (S3ClientConfig): opcional. A classe de dados que expõe parâmetros configuráveis para o cliente S3. Se não for fornecida, será usada a configuração padrão do S3ClientConfig. O parâmetro part_size é definido como 64 MB por padrão.

• smp_moe (booleano): se deve usar a implementação do SMP da MoE. O valor padrão é True.

• random_seed (inteiro): um número inicial para as operações randomizadas em módulos distribuídos de paralelismo especializado. Esse número inicial é adicionado à classificação de paralelismo especializado para definir o número inicial real para cada classificação. É exclusivo para cada classificação de paralelismo especializado. O valor padrão é 12345.

• moe_load_balancing (String): especifica o tipo de balanceador de carga do roteador da MoE. As opções válidas são: aux_loss, sinkhorn, balanced e none. O valor padrão é sinkhorn.

• global_token_shuffle (booleano): se os tokens devem ser misturados entre as classificações de EP dentro do mesmo grupo de EP. O valor padrão é False.

• moe_all_to_all_dispatcher (booleano): se deve usar o dispatcher completo para as comunicações na MoE. O valor padrão é True.

• moe_aux_loss_coeff (float): um coeficiente para perda de balanceador de carga auxiliar. O valor padrão é 0.001.

• moe_z_loss_coeff (float): coeficiente de perda z. O valor padrão é 0.001.

• attention_dropout_prob (float): a probabilidade de dropout a ser aplicada à atenção. O valor padrão é 0.0.

• scale (float): se aprovado, esse fator de escala é aplicado para softmax. Se definido como None (que também é o valor padrão), o fator de escala é 1 / sqrt(attention_head_size). O valor padrão é None.

• triton_flash_attention (bool): se aprovada, é usada a implementação de atenção instantânea do Triton. Isso é necessário para apoiar a atenção com vieses lineares (ALiBi) (consulte o parâmetro use_alibi a seguir). Essa versão do kernel não é compatível com o dropout. O valor padrão é False.

• use_alibi (bool): se aprovado, ele ativa a atenção com vieses lineares (ALiBi) usando a máscara fornecida. Ao usar a ALiBi, ela precisa de uma máscara de atenção preparada da seguinte forma: O valor padrão é 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"): uma função normal do módulo PyTorch. Quando o module(x) é chamado, o SMP executa essa função automaticamente.

  • qkv: torch.Tensor da seguinte forma: (batch_size x seqlen x (3 x num_heads) x head_size) ou (batch_size, (3 x num_heads) x seqlen x head_size), uma tupla de torch.Tensors, cada uma podendo ter a forma (batch_size x seqlen x num_heads x head_size) ou (batch_size x num_heads x seqlen x head_size). Um argumento de layout apropriado deve ser passado com base na forma.

  • attn_mask: torch.Tensor da seguinte forma (batch_size x 1 x 1 x seqlen). Para ativar esse parâmetro de máscara de atenção, é necessário triton_flash_attention=True e use_alibi=True. Para saber como gerar uma máscara de atenção com esse método, consulte os exemplos de código em FlashAttention. O valor padrão é None.

  • causal: quando definido como False, que é o valor padrão do argumento, nenhuma máscara é aplicada. Quando definido como True, o método forward usa a máscara triangular inferior padrão. O valor padrão é False.

  • cast_dtype: quando configurado para um determinado dtype, ele converte os tensores qkv para o dtype antes de attn. É útil para implementações como o modelo Hugging Face Transformer GPT-NeoX, que tem q e kcom fp32 após as incorporações rotativas. Se definido como None, nenhum molde será aplicado. O valor padrão é None.

  • layout (string): os valores disponíveis são b h s d ou b s h d. Deve ser definido para o layout dos tensores qkv passados, para que as transformações apropriadas possam ser aplicadas no attn. O valor padrão é b h s d.

• attention_dropout_prob (float): a probabilidade de dropout a ser aplicada à atenção. O valor padrão é 0.0.

• scale (float): se aprovado, esse fator de escala é aplicado para softmax. Se definido como None, é usado 1 / sqrt(attention_head_size) como fator de escala. O valor padrão é None.

• forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d"): uma função normal do módulo PyTorch. Quando o module(x) é chamado, o SMP executa essa função automaticamente.

  • q: torch.Tensor da seguinte forma (batch_size x seqlen x num_heads x head_size) ou (batch_size x num_heads x seqlen x head_size). Argumento de layout apropriado deve ser passado com base na forma.

  • kv: torch.Tensor da seguinte forma: (batch_size x seqlen x (2 x num_heads) x head_size) ou (batch_size, (2 x num_heads) x seqlen x head_size), ou uma tupla de dois torch.Tensor, cada uma podendo ter a forma (batch_size x seqlen x num_heads x head_size) ou (batch_size x num_heads x seqlen x head_size). O argumento layout apropriado deve ser passado com base na forma.

  • causal: quando definido como False, que é o valor padrão do argumento, nenhuma máscara é aplicada. Quando definido como True, o método forward usa a máscara triangular inferior padrão. O valor padrão é False.

  • cast_dtype: quando configurado para um determinado dtype, ele converte os tensores qkv para o dtype antes de attn. É útil para implementações como o modelo Hugging Face Transformers GPT-NeoX, que tem q,k com fp32 após as incorporações rotativas. Se definido como None, nenhum molde será aplicado. O valor padrão é None.

  • layout (string): os valores disponíveis são "b h s d" ou "b s h d". Deve ser definido para o layout dos tensores qkv passados, para que as transformações apropriadas possam ser aplicadas no attn. O valor padrão é "b h s d".

• config: uma configuração FlashAttention para o modelo Llama.

• forward(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)

  • hidden_states (torch.Tensor): estados ocultos de um tensor na forma de (batch_size x seq_len x num_heads x head_size).

  • attention_mask (torch.LongTensor): máscara para evitar executar a atenção no preenchimento de índices de tokens na forma de (batch_size x seqlen). O valor padrão é None.

  • position_ids (torch.LongTensor): quando não está None, está na forma de (batch_size x seqlen), indicando os índices das posições de cada token de sequência de entrada nas incorporações da posição. O valor padrão é None.

  • past_key_value (Cache): estados ocultos pré-computados (chave e valores nos blocos de autoatenção e nos blocos de atenção cruzada). O valor padrão é None.

  • output_attentions (bool): indica se devem ser retornados os tensores de atenção de todas as camadas de atenção. O valor padrão é False.

  • use_cache (bool): indica se devem ser retornados os estados do valor chave past_key_values. O valor padrão é False.

• model (torch.nn.Module): um modelo de Modelos tipo transformador da Hugging Face compatíveis com o paralelismo de tensores no SMP para transformar e aplicar o atributo de paralelismo de tensores da biblioteca de SMP.

• device (torch.device): se aprovado, é criado um novo modelo neste dispositivo. Se o módulo original tiver algum parâmetro no dispositivo meta (consulte Inicialização do parâmetro atrasada), o módulo transformado também será criado no dispositivo meta, ignorando o argumento passado aqui. O valor padrão é None.

• dtype (torch.dtype): se aprovado, o define como o gerenciador de contexto dtype para a criação do modelo e cria um modelo com esse dtype. Normalmente, é desnecessário, pois queremos criar o modelo com fp32 ao usar MixedPrecision, e fp32 é o dtype padrão no PyTorch. O valor padrão é None.

• config (dict): este é um dicionário para configurar o transformador do SMP. O valor padrão é None.

• load_state_dict_from_rank0 (booleano): por padrão, esse módulo cria uma nova instância do modelo com novos pesos. Quando esse argumento é definido como True, o SMP tenta carregar o dicionário de estado do modelo PyTorch original da 0ª classificação em um modelo tipo transformador para o grupo paralelo de tensores do qual a 0ª classificação faz parte. Quando definido como True, a 0ª classificação não pode ter nenhum parâmetro no dispositivo meta. Somente o primeiro grupo paralelo de tensores preenche os pesos da 0ª classificação após essa chamada de transformador. Você precisa definir sync_module_states para True, no wrapper do FSDP, para obter esses pesos do primeiro grupo de paralelismo de tensores para todos os outros processos. Com essa ativação, a biblioteca de SMP carrega o dicionário de estado do modelo original. A biblioteca de SMP pega o state_dict do modelo antes da transformação, o converte para corresponder à estrutura do modelo tipo transformador, o fragmenta para cada classificação de paralelismo de tensores, comunica esse estado da 0ª classificação para outras classificações no grupo de paralelismo de tensores do qual a 0ª classificação faz parte e o carrega. O valor padrão é False.

• cp_comm_type (str): determina a implementação do paralelismo de contexto e é aplicável apenas quando context_parallel_degree for maior que 1. Os valores disponíveis para esse parâmetro são p2p e all_gather. A implementação de p2p utiliza chamadas de envio e recebimento ponto a ponto para acúmulo de tensores de chave e valor (KV) durante o cálculo da atenção, funcionando de forma assíncrona e permitindo que a comunicação se sobreponha à computação. Por outro lado, a implementação de all_gather utiliza a operação coletiva de comunicação AllGather para o acúmulo de tensores de KV. O valor padrão é "p2p".

funções do utilitário torch.sagemaker

• torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None: inicializa o trabalho de treinamento do PyTorch com o SMP.

• torch.sagemaker.is_initialized() -> bool: verifica se o trabalho de treinamento foi inicializado com o SMP. Ao retornar ao PyTorch nativo enquanto o trabalho é inicializado com o SMP, algumas propriedades não são relevantes e viram None, conforme indicado na lista de Propriedades a seguir.

• torch.sagemaker.utils.module_utils.empty_module_params(module: nn.Module, device: Optional[torch.device] = None, recurse: bool = False) -> nn.Module: cria parâmetros vazios em um determinado device, se houver, e pode ser recursivo para todos os módulos aninhados, se especificado.

• torch.sagemaker.utils.module_utils.move_buffers_to_device(module: nn.Module, device: torch.device, recurse: bool = False) -> nn.Module: move os buffers do módulo para o determinado device e pode ser recursivo para todos os módulos aninhados, se especificado.

Propriedades

torch.sagemaker.state contém várias propriedades úteis após a inicialização do SMP com torch.sagemaker.init.

• torch.sagemaker.state.hybrid_shard_degree (int): o grau de paralelismo de dados fragmentados, uma cópia da entrada do usuário na configuração do SMP passada para torch.sagemaker.init(). Para saber mais, consulte Utilize a biblioteca de paralelismo de modelos do SageMaker v2.

• torch.sagemaker.state.rank (int): a classificação global do dispositivo, na faixa de [0, world_size).

• torch.sagemaker.state.rep_rank_process_group (torch.distributed.ProcessGroup): o grupo de processos que inclui todos os dispositivos com a mesma classificação de replicação. Observe a diferença sutil, porém fundamental, com torch.sagemaker.state.tp_process_group. Ao retornar ao PyTorch nativo, ele volta como None.

• torch.sagemaker.state.tensor_parallel_degree (int): o grau de paralelismo de tensores, uma cópia da entrada do usuário na configuração do SMP passada para torch.sagemaker.init(). Para saber mais, consulte Utilize a biblioteca de paralelismo de modelos do SageMaker v2.

• torch.sagemaker.state.tp_size (int): um alias para torch.sagemaker.state.tensor_parallel_degree.

• torch.sagemaker.state.tp_rank (int): a classificação do paralelismo do tensor para o dispositivo na faixa de [0, tp_size), determinada pelo grau do paralelismo de tensores e pelo mecanismo de classificação.

• torch.sagemaker.state.tp_process_group (torch.distributed.ProcessGroup): o grupo de processos de paralelismo de tensores, incluindo todos os dispositivos com a mesma classificação em outras dimensões (por exemplo, paralelismo e replicação de dados fragmentados), mas classificações de paralelismo de tensores exclusivos. Ao retornar ao PyTorch nativo, ele volta como None.

• torch.sagemaker.state.world_size (int): o número total de dispositivos usados no treinamento.