As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # A referência da biblioteca paralela do SageMaker modelo v2 A seguir estão referências para o SageMaker modelo parallel library v2 (SMP v2). **Topics** + [Parâmetros de configuração do atributo principal do SMP v2](#distributed-model-parallel-v2-reference-init-config) + [Referência ao pacote SMP v2 `torch.sagemaker`](#model-parallel-v2-torch-sagemaker-reference) + [Atualização do SMP v1 para o SMP v2](#model-parallel-v2-upgrade-from-v1) ## Parâmetros de configuração do atributo principal do SMP v2 A seguir encontra-se uma lista completa de parâmetros para ativar e configurar o [Principais características da biblioteca de paralelismo de SageMaker modelos v2](model-parallel-core-features-v2.md). Eles devem ser escritos no formato JSON e passados para o PyTorch estimador no SDK do SageMaker Python ou salvos como um arquivo JSON para. SageMaker HyperPod ``` { "hybrid_shard_degree": Integer, "sm_activation_offloading": Boolean, "activation_loading_horizon": Integer, "fsdp_cache_flush_warnings": Boolean, "allow_empty_shards": Boolean, "tensor_parallel_degree": Integer, "context_parallel_degree": Integer, "expert_parallel_degree": Integer, "random_seed": Integer } ``` + `hybrid_shard_degree` (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 PyTorch implementação nativa e 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 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` 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 PyTorch implementação nativa e a API do script quando `tensor_parallel_degree` é 1. `NO_SHARD` 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 especificado 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 PyTorch . Se `True`, ele usa a implementação de descarregamento de ativação do 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](model-parallel-core-features-v2-pytorch-activation-offloading.md). 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](model-parallel-core-features-v2-pytorch-activation-offloading.md). O valor da entrada deve ser um 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` (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. Desativar isso remonta ao PyTorch comportamento original. 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`](#model-parallel-v2-torch-sagemaker-reference-transform) para incluir o modelo no script de treinamento. Para saber mais, consulte [Paralelismo de tensores](model-parallel-core-features-v2-tensor-parallelism.md). + `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`](#model-parallel-v2-torch-sagemaker-reference-transform) para incluir o modelo no script de treinamento. Para saber mais, consulte [Paralelismo de contexto](model-parallel-core-features-v2-context-parallelism.md). + `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`](#model-parallel-v2-torch-sagemaker-reference-transform) para incluir o modelo no script de treinamento. Para saber mais, consulte [Paralelismo especializado](model-parallel-core-features-v2-expert-parallelism.md). + `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 tensor-parallel e expert-parallel corresponda aos casos e, respectivamente. non-tensor-parallelism non-expert-parallelism ## Referência ao pacote SMP v2 `torch.sagemaker` Esta seção é uma referência ao pacote `torch.sagemaker` fornecido pelo SMP v2. **Topics** + [`torch.sagemaker.delayed_param.DelayedParamIniter`](#model-parallel-v2-torch-sagemaker-reference-delayed-param-init) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-async-save) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-state-dict-saver) + [`torch.sagemaker.distributed.checkpoint.state_dict_saver.save`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-save) + [`torch.sagemaker.distributed.checkpoint.state_dict_loader.load`](#model-parallel-v2-torch-sagemaker-reference-checkpoint-load) + [`torch.sagemaker.moe.moe_config.MoEConfig`](#model-parallel-v2-torch-sagemaker-reference-moe) + [`torch.sagemaker.nn.attn.FlashSelfAttention`](#model-parallel-v2-torch-sagemaker-reference-flashselfattention) + [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) + [`torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention`](#model-parallel-v2-torch-sagemaker-reference-llamaFlashAttn) + [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform) + [`torch.sagemaker` funções e propriedades do utilitário](#model-parallel-v2-torch-sagemaker-reference-utils) ### `torch.sagemaker.delayed_param.DelayedParamIniter` Uma API [Inicialização do parâmetro atrasada](model-parallel-core-features-v2-delayed-param-init.md) para aplicação em um PyTorch modelo. ``` class torch.sagemaker.delayed_param.DelayedParamIniter( model: nn.Module, init_method_using_config : Callable = None, verbose: bool = False, ) ``` **Parâmetros** + `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` (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](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) 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](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models). 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](#model-parallel-v2-torch-sagemaker-reference-utils). + `verbose` (booleano): se for necessário ativar um registro mais detalhado durante a inicialização e a validação. O valor padrão é `False`. **Métodos** + `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ê 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](model-parallel-core-features-v2-delayed-param-init.md). + `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. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save` API de entrada para salvamento assíncrono. Use esse método para salvar um `state_dict` de forma assíncrona em um `checkpoint_id` definido. ``` def async_save( state_dict: STATE_DICT_TYPE, *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_writer: Optional[StorageWriter] = None, planner: Optional[SavePlanner] = None, process_group: Optional[dist.ProcessGroup] = None, coordinator_rank: int = 0, queue : AsyncCallsQueue = None, sharded_strategy: Union[SaveShardedStrategy, Tuple[str, int], None] = None, wait_error_handling: bool = True, force_check_all_plans: bool = True, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **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 de [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)in PyTorch para realizar operações de gravação. Se ela não for definida, será usada a configuração padrão do [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter). + `planner`(SavePlanner) - Opcional. Uma instância de [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)entrada PyTorch. Se ela não for definida, será usada a configuração padrão do [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner). + `process_group`(ProcessGroup) - 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, a configuração padrão do [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) será usada. O parâmetro `part_size` é definido como 64 MB por padrão. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls` Essa função permite que um processo de treinamento monitore várias solicitações assíncronas a serem feitas. ``` def maybe_finalize_async_calls( blocking=True, process_group=None ) -> List[int]: ``` **Parâmetros** + `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). **Devoluções** + Uma lista contendo os índices de chamadas assíncronas foi finalizada com sucesso. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.save` Use esse método para salvar um `state_dict` de forma síncrona em um `checkpoint_id` definido. ``` def save( state_dict: STATE_DICT_TYPE, *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_writer: Optional[StorageWriter] = None, planner: Optional[SavePlanner] = None, process_group: Optional[dist.ProcessGroup] = None, coordinator_rank: int = 0, wait_error_handling: bool = True, force_check_all_plans: bool = True, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **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 de [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter)in PyTorch para realizar operações de gravação. Se ela não for definida, será usada a configuração padrão do [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter). + `planner`(SavePlanner) - Opcional. Uma instância de [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)entrada PyTorch. Se ela não for definida, será usada a configuração padrão do [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner). + `process_group`(ProcessGroup) - 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, a configuração padrão do [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) será usada. O parâmetro `part_size` é definido como 64 MB por padrão. ### `torch.sagemaker.distributed.checkpoint.state_dict_loader.load` Carregue o dicionário de estado de um modelo distribuído (`state_dict`). ``` def load( state_dict: Dict[str, Any], *, checkpoint_id: Union[str, os.PathLike, None] = None, storage_reader: Optional[StorageReader] = None, planner: Optional[LoadPlanner] = None, process_group: Optional[dist.ProcessGroup] = None, check_keys_matched: bool = True, coordinator_rank: int = 0, s3_region: Optional[str] = None, s3client_config: Optional[S3ClientConfig] = None ) -> None: ``` **Parâmetros** + `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 de [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageReader](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageReader)in PyTorch 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 de [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner)entrada PyTorch. Se não for especificada, será usada a configuração padrão de [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner). + `check_keys_matched` (bool): 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, a configuração padrão do [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) será usada. O parâmetro `part_size` é definido como 64 MB por padrão. ### `torch.sagemaker.moe.moe_config.MoEConfig` Uma classe de configuração para configurar a implementação SMP do Mixture-of-Experts (MoE). Você pode especificar os valores de configuração da MoE por meio dessa função e passá-los para a chamada de API do [https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-model-parallel-v2-reference.html#model-parallel-v2-torch-sagemaker-reference-transform](https://docs.aws.amazon.com/sagemaker/latest/dg/distributed-model-parallel-v2-reference.html#model-parallel-v2-torch-sagemaker-reference-transform). Para saber mais sobre o uso dessa função para treinar modelos da MoE, consulte [Paralelismo especializado](model-parallel-core-features-v2-expert-parallelism.md). ``` class torch.sagemaker.moe.moe_config.MoEConfig( smp_moe=True, random_seed=12345, moe_load_balancing="sinkhorn", global_token_shuffle=False, moe_all_to_all_dispatcher=True, moe_aux_loss_coeff=0.001, moe_z_loss_coeff=0.001 ) ``` **Parâmetros** + `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`(Boolean) - Se deve usar o all-to-all dispatcher para as comunicações no 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`. ### `torch.sagemaker.nn.attn.FlashSelfAttention` Uma API para usar [FlashAttention](model-parallel-core-features-v2-flashattention.md) com o SMP v2. ``` class torch.sagemaker.nn.attn.FlashSelfAttention( attention_dropout_prob: float = 0.0, scale: Optional[float] = None, triton_flash_attention: bool = False, use_alibi: bool = False, ) ``` **Parâmetros** + `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 `use_alibi` parâmetro 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 o ALi Bi, 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 ``` **Métodos** + `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 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](model-parallel-core-features-v2-flashattention.md). 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 `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`. **Devoluções** Um único `torch.Tensor` com a forma `(batch_size x num_heads x seq_len x head_size)`. ### `torch.sagemaker.nn.attn.FlashGroupedQueryAttention` Uma API para usar `FlashGroupedQueryAttention` com o SMP v2. Para saber mais sobre o uso dessa API, consulte [Use FlashAttention kernels para atenção de consultas agrupadas](model-parallel-core-features-v2-flashattention.md#model-parallel-core-features-v2-flashattention-grouped-query). ``` class torch.sagemaker.nn.attn.FlashGroupedQueryAttention( attention_dropout_prob: float = 0.0, scale: Optional[float] = None, ) ``` **Parâmetros** + `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`. **Métodos** + `forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d")`— Uma função regular PyTorch do módulo. 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"`. **Devoluções** Retorna um único `torch.Tensor (batch_size x num_heads x seq_len x head_size)`, que representa a saída do cálculo da atenção. ### `torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention` Uma API compatível com FlashAttention o modelo Llama. Essa API usa a API [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) em baixo nível. Para saber como usá-la, consulte [Use FlashAttention kernels para atenção de consultas agrupadas](model-parallel-core-features-v2-flashattention.md#model-parallel-core-features-v2-flashattention-grouped-query). ``` class torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention( config: LlamaConfig ) ``` **Parâmetros** + `config`— Uma FlashAttention configuração para o modelo Llama. **Métodos** + `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`. **Devoluções** Retorna um único `torch.Tensor (batch_size x num_heads x seq_len x head_size)`, que representa a saída do cálculo da atenção. ### `torch.sagemaker.transform` O SMP v2 fornece essa API `torch.sagemaker.transform()` para transformar modelos tipo transformador do Hugging Face em implementações de modelos de SMP e habilitar o paralelismo de tensores do SMP. ``` torch.sagemaker.transform( model: nn.Module, device: Optional[torch.device] = None, dtype: Optional[torch.dtype] = None, config: Optional[Dict] = None, load_state_dict_from_rank0: bool = False, cp_comm_type: str = "p2p" ) ``` O SMP v2 mantém as políticas de transformação para o [Modelos tipo transformador da Hugging Face compatíveis com o paralelismo de tensores no SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models), ao converter a configuração dos modelos Hugging Face Transformer na configuração do modelo tipo transformador do SMP. **Parâmetros** + `model` (`torch.nn.Module`): um modelo de [Modelos tipo transformador da Hugging Face compatíveis com o paralelismo de tensores no SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) 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](model-parallel-core-features-v2-delayed-param-init.md)), 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, 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 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 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 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 `p2p` implementação utiliza chamadas de peer-to-peer envio-recebimento para acúmulo de tensores key-and-value (KV) durante o cálculo da atenção, sendo executada 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"`. **Devoluções ** Retorna um modelo transformado que você pode empacotar com o PyTorch FSDP. Quando `load_state_dict_from_rank0` for definido como `True`, o grupo de paralelismo de tensores que envolve a 0ª classificação tem pesos carregados do dicionário de estado original na 0ª classificação. Ao usar [Inicialização do parâmetro atrasada](model-parallel-core-features-v2-delayed-param-init.md) no modelo original, somente essas classificações têm os tensores reais ativados CPUs para os parâmetros e buffers do modelo transformado. O restante das classificações continua com os parâmetros e buffers no dispositivo meta para economizar memória. ### `torch.sagemaker` funções e propriedades do utilitário **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 tornam`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 [Use a biblioteca de paralelismo de SageMaker modelos v2](model-parallel-use-api-v2.md). + `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 voltar para o nativo PyTorch, ele retorna`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 [Use a biblioteca de paralelismo de SageMaker modelos v2](model-parallel-use-api-v2.md). + `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 voltar para o nativo PyTorch, ele retorna`None`. + `torch.sagemaker.state.world_size` (int): o número total de dispositivos usados no treinamento. ## Atualização do SMP v1 para o SMP v2 Para passar do SMP v1 para o SMP v2, você deve fazer alterações no script para remover o SMP v1 e aplicar o SMP APIs v2. APIs Em vez de começar com seu script SMP v1, recomendamos que você comece com um script PyTorch FSDP e siga as instruções em. [Use a biblioteca de paralelismo de SageMaker modelos v2](model-parallel-use-api-v2.md) Para trazer *modelos* do SMP v1 para o SMP v2, no SMP v1, você deve coletar o dicionário de estado do modelo completo e aplicar as funções de conversão no dicionário de estado do modelo para convertê-lo no formato de ponto de verificação do modelo Hugging Face Transformers. Em seguida, no SMP v2, conforme discutido em[Ponto de verificação com uso do SMP](model-parallel-core-features-v2-checkpoints.md), você pode carregar os pontos de verificação do modelo Hugging Face Transformers e continuar usando o ponto de verificação com o SMP v2. PyTorch APIs Para usar o SMP com seu modelo de PyTorch FSDP, certifique-se de migrar para o SMP v2 e fazer alterações em seu script de treinamento para usar o PyTorch FSDP e outros recursos mais recentes. ``` import smdistributed.modelparallel.torch as smp # Create model model = ... model = smp.DistributedModel(model) # Run training ... # Save v1 full checkpoint if smp.rdp_rank() == 0: model_dict = model.state_dict(gather_to_rank0=True) # save the full model # Get the corresponding translation function in smp v1 and translate if model_type == "gpt_neox": from smdistributed.modelparallel.torch.nn.huggingface.gptneox import translate_state_dict_to_hf_gptneox translated_state_dict = translate_state_dict_to_hf_gptneox(state_dict, max_seq_len=None) # Save the checkpoint checkpoint_path = "checkpoint.pt" if smp.rank() == 0: smp.save( {"model_state_dict": translated_state_dict}, checkpoint_path, partial=False, ) ``` Para encontrar as funções de conversão disponíveis no SMP v1, consulte [Ajuda para modelos tipo transformador Hugging Face](model-parallel-extended-features-pytorch-hugging-face.md). Para obter instruções sobre como salvar e carregar pontos de verificação de modelos no SMP v2, consulte [Ponto de verificação com uso do SMP](model-parallel-core-features-v2-checkpoints.md).