A referência da biblioteca paralela do SageMaker modelo v2

• hybrid_shard_degree(Inteiro) — Especifica 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 como0, ele volta para a PyTorch implementação nativa e a API no script quando tensor_parallel_degree é 1. Caso contrário, ele calcula o maior possível hybrid_shard_degree com base em tensor_parallel_degree e. world_size Ao recorrer aos casos de uso nativos do PyTorch FSDP, se FULL_SHARD for a estratégia que você usa, ela se fragmenta em todo o cluster de GPUs. Se HYBRID_SHARD ou _HYBRID_SHARD_ZERO2 foi a estratégia, é equivalente hybrid_shard_degree a 8. Quando o paralelismo de tensores está ativado, ele se fragmenta com base na versão revisada. hybrid_shard_degree

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

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

• sm_activation_offloading(Boolean) — Especifica se a implementação de descarregamento de ativação do SMP deve ser ativada. SeFalse, o descarregamento usa a implementação nativa PyTorch . SeTrue, ele usa a implementação de descarregamento de ativação SMP. Você também precisa usar a PyTorch ativação offload wrapper (torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper) em seu script. Para saber mais, consulte Ativação e descarregamento. O valor padrão é True.

• activation_loading_horizon(Integer) — Um número inteiro que especifica o tipo de horizonte de descarga de ativação para 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 de entrada deve ser um número inteiro positivo. O valor padrão é 2.

• fsdp_cache_flush_warnings(Boolean) — Detecta e avisa se as descargas de cache ocorrem no gerenciador de PyTorch memória, pois elas podem degradar o desempenho computacional. O valor padrão é True.

• allow_empty_shards(Boolean) — 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. Desativar isso remonta ao PyTorch comportamento original. O valor padrão é False.

• tensor_parallel_degree(Integer) — Especifica um grau de paralelismo do tensor. O valor deve estar entre 1 world_size e. O valor padrão é 1. Passar um valor maior que 1 não ativa automaticamente o paralelismo do tensor. Você também precisa usar a torch.sagemaker.transform API para incluir o modelo em seu script de treinamento. Para saber mais, consulte Paralelismo de tensores.

• expert_parallel_degree(Integer) — Especifica um grau de paralelismo especializado. O valor deve estar entre 1 world_size e. O valor padrão é 1. Passar um valor maior que 1 não ativa automaticamente o paralelismo especializado; certifique-se de incluir o modelo MoE com a torch.sagemaker.transform API em seu script de treinamento.

• random_seed(Integer) — Um número inicial para as operações aleatórias em módulos distribuídos por paralelismo de tensores SMP ou paralelismo especializado. Essa semente será adicionada às classificações tensor-parallel ou expert-parallel para definir a semente real para cada classificação. É exclusivo para cada classificação tensor-paralela e expert-parallel. O SMP v2 garante que o número aleatório gerado nas classificações tensor-parallel e expert-parallel corresponda aos casos e, respectivamente. non-tensor-parallelism non-expert-parallelism

• model(nn.Module) — Um PyTorch modelo para empacotar e aplicar a funcionalidade de inicialização retardada de parâmetros do SMP v2.

• init_method_using_config(Callable) — Se você usar a implementação paralela de tensor do SMP v2 ou suportadaModelos Hugging Face Transformer compatíveis com o paralelismo do tensor SMP, mantenha esse parâmetro no valor padrão, que é. None Por padrão, a DelayedParamIniter API 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 seu script. O trecho de código a seguir é a init_method_using_config função padrão que o SMP v2 implementou para o. Modelos Hugging Face Transformer compatíveis com o paralelismo do tensor 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 seu script e passá-la para o init_method_using_config parâmetro da API SMP. DelayedParamIniter

  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 torch.sagemaker.module_util funções no trecho de código anterior, consulte. torch.sagemakerfunções e propriedades do utilitário

• verbose(Boolean) — Se é 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 a função de inicialização do parâmetro que você pode passar para o param_init_fn argumento da classe wrapper PyTorch FSDP.

• get_post_param_init_fn()— Retorna a função de inicialização do parâmetro que você pode passar para o post_param_init_fn argumento da classe wrapper PyTorch FSDP. Isso é necessário quando você amarra pesos no modelo. O modelo deve implementar o métodotie_weights. Para obter mais informações, consulte as Notas sobre peso vinculadoInicialização atrasada de parâmetros.

• 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 validate_params_and_buffers_inited método a seguir. Normalmente, você não precisa chamar essa função explicitamente, porque o validate_params_and_buffers_inited método chama esse método implicitamente no back-end.

• 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 que todos os parâmetros e buffers agora estão em dispositivos de GPU em vez de meta-dispositivos. Isso aumenta AssertionErrors se essas condições não forem atendidas. Esse gerenciador de contexto é apenas opcional e você não precisa usá-lo para inicializar parâmetros.

• smp_moe(Boolean) - Se deve usar a implementação SMP do MoE. O valor padrão é True.

• random_seed(Integer) - Um número inicial para as operações aleatórias em módulos distribuídos paralelos especializados. Essa semente será adicionada à classificação paralela de especialistas para definir a semente real para cada classificação. É exclusivo para cada classificação paralela de especialistas. O valor padrão é 12345.

• moe_load_balancing(String) - Especifique o tipo de balanceamento de carga do roteador MoE. As opções válidas são aux_loss sinkhornbalanced,, none e. O valor padrão é sinkhorn.

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

• moe_all_to_all_dispatcher(Boolean) - Se deve usar o all-to-all dispatcher para as comunicações no MoE. O valor padrão é True.

• moe_aux_loss_coeff(Flutuar) - Um coeficiente para perda de balanceamento 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 abandono escolar a ser aplicada à atenção. O valor padrão é 0.0.

• scale(float) — Se aprovado, esse fator de escala será 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, a implementação de atenção instantânea do Triton será usada. Isso é necessário para apoiar a atenção com vieses lineares (ALiBi) (consulte o use_alibi parâmetro a seguir). Essa versão do kernel não suporta 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 ALiBi, ele 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 regular PyTorch do módulo. Quando a 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 das quais pode 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 do seguinte formulário(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 use_alibi=True e. Para saber como gerar uma máscara de atenção usando esse método, consulte os exemplos de código emFlashAttention. O valor padrão é None.

  • causal— Quando definido comoFalse, que é o valor padrão do argumento, nenhuma máscara é aplicada. Quando definido comoTrue, o forward método usa a máscara triangular inferior padrão. O valor padrão é False.

  • cast_dtype— Quando configurado para um determinadodtype, ele converte os qkv tensores para aquele dtype anteriorattn. Isso é útil para implementações como o modelo Hugging Face Transformer GPT-Neox, que tem e com incorporações rotativas posteriores. q k fp32 Se definido comoNone, nenhum molde será aplicado. O valor padrão é None.

  • layout(string) — Os valores disponíveis são b h s d oub s h d. Isso deve ser definido para o layout dos qkv tensores passados, para que as transformações apropriadas possam ser aplicadas. attn O valor padrão é b h s d.

• attention_dropout_prob(float) — A probabilidade de abandono escolar a ser aplicada à atenção. O valor padrão é 0.0.

• scale(float) — Se aprovado, esse fator de escala é aplicado para softmax. Se definido comoNone, 1 / sqrt(attention_head_size) é usado 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 regular PyTorch do módulo. Quando a 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). O 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 s, cada um dos quais pode ter a forma (batch_size x seqlen x num_heads x head_size) ou(batch_size x num_heads x seqlen x head_size). layoutO argumento apropriado também deve ser passado com base na forma.

  • causal— Quando definido comoFalse, que é o valor padrão do argumento, nenhuma máscara é aplicada. Quando definido comoTrue, o forward método usa a máscara triangular inferior padrão. O valor padrão é False.

  • cast_dtype— Quando definido para um determinado dtype, ele converte os qkv tensores para esse dtype antes. attn Isso é útil para implementações como o Hugging Face Transformers GPT-Neox, que tem incorporações rotativas posteriores. q,k fp32 Se definido comoNone, 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". Isso deve ser definido para o layout dos qkv tensores passados, para que as transformações apropriadas possam ser aplicadas. attn O valor padrão é "b h s d".

• config— Uma FlashAttention configuração 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 prestar atenção ao 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 os tensores de atenção de todas as camadas de atenção devem ser retornados. O valor padrão é False.

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

• model(torch.nn.Module) — Um modelo Modelos Hugging Face Transformer compatíveis com o paralelismo do tensor SMP para transformar e aplicar o recurso de paralelismo de tensores da biblioteca SMP.

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

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

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

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

Funções do utilitário torch.sagemaker

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

• torch.sagemaker.is_initialized() -> bool— Verifica se o trabalho de treinamento foi inicializado com o SMP. Ao voltar para o nativo PyTorch enquanto o trabalho é inicializado com o SMP, algumas das propriedades não são relevantes e se tornamNone, 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 no dado, 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.stateconté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 SMP passada para. torch.sagemaker.init() Para saber mais, consulte Comece com a biblioteca de paralelismo de SageMaker modelos 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, mas fundamental, comtorch.sagemaker.state.tp_process_group. Ao voltar para o nativo PyTorch, ele retornaNone.

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

• torch.sagemaker.state.tp_size(int) — Um alias paratorch.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 de paralelismo do tensor e pelo mecanismo de classificação.

• torch.sagemaker.state.tp_process_group(torch.distributed.ProcessGroup) — O grupo de processos paralelos 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 paralelas de tensores exclusivos. Ao voltar para o nativo PyTorch, ele retornaNone.

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