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 as referências para a biblioteca paralela de SageMaker modelos v2 (SMP v2).
Tópicos
Parâmetros de configuração do recurso principal do SMP v2
A seguir está uma lista completa de parâmetros para ativar e configurar Principais características da biblioteca de paralelismo de SageMaker modelos v2 o. 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
, "expert_parallel_degree":Integer
, "random_seed":Integer
}
-
hybrid_shard_degree
(Inteiro) — Especifica um grau de paralelismo fragmentado. O valor deve ser um número inteiro entre0
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 quandotensor_parallel_degree
é 1. Caso contrário, ele calcula o maior possívelhybrid_shard_degree
com base emtensor_parallel_degree
e.world_size
Ao recorrer aos casos de uso nativos do PyTorch FSDP, seFULL_SHARD
for a estratégia que você usa, ela se fragmenta em todo o cluster de GPUs. SeHYBRID_SHARD
ou_HYBRID_SHARD_ZERO2
foi a estratégia, é equivalentehybrid_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 como
1
, ele volta para a PyTorch implementação nativa e a API do script quandotensor_parallel_degree
é 1.NO_SHARD
Caso contrário, é equivalente a qualquerNO_SHARD
grupo paralelo 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 configurarsharding_strategy
no script FSDP, ele será substituído por.HYBRID_SHARD
Se você definir_HYBRID_SHARD_ZERO2
, osharding_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 entre1
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 1world_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
Referência para o pacote SMP v2 torch.sagemaker
Esta seção é uma referência para o torch.sagemaker
pacote fornecido pelo SMP v2.
Tópicos
- torch.sagemaker.delayed_param.DelayedParamIniter
- torch.sagemaker.moe.moe_config.MoEConfig
- torch.sagemaker.nn.attn.FlashSelfAttention
- torch.sagemaker.nn.attn.FlashGroupedQueryAttention
- torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention
- torch.sagemaker.transform
- torch.sagemakerfunções e propriedades do utilitário
torch.sagemaker.delayed_param.DelayedParamIniter
Uma API Inicialização atrasada de parâmetros 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
(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, aDelayedParamIniter
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 é ainit_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 oinit_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
.
Métodos
-
get_param_init_fn()
— Retorna a função de inicialização do parâmetro que você pode passar para oparam_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 opost_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 ovalidate_params_and_buffers_inited
método a seguir. Normalmente, você não precisa chamar essa função explicitamente, porque ovalidate_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 aumentaAssertionErrors
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.
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 do MoE por meio dessa classe e passá-los para a chamada da torch.sagemaker.transform
API. Para saber mais sobre o uso dessa classe para treinar modelos MoE, consulteParalelismo especializado.
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 )
-
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ãoaux_loss
sinkhorn
balanced
,,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
.
torch.sagemaker.nn.attn.FlashSelfAttention
Uma API para usar FlashAttention 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 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 comoNone
(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 ouse_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
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 amodule(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 detorch.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áriotriton_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
, oforward
método usa a máscara triangular inferior padrão. O valor padrão éFalse
. -
cast_dtype
— Quando configurado para um determinadodtype
, ele converte osqkv
tensores para aqueledtype
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ãob h s d
oub s h d
. Isso deve ser definido para o layout dosqkv
tensores passados, para que as transformações apropriadas possam ser aplicadas.attn
O valor padrão éb h s d
.
-
Devoluções
Um single torch.Tensor
com 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, consulteUse FlashAttention kernels para atenção de consultas agrupadas.
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 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
.
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 amodule(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 doistorch.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)
.layout
O 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
, oforward
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 osqkv
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 dosqkv
tensores passados, para que as transformações apropriadas possam ser aplicadas.attn
O valor padrão é"b h s d"
.
-
Devoluções
Retorna um single 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 torch.sagemaker.nn.attn.FlashGroupedQueryAttention API em baixo nível. Para saber como usar isso, consulteUse FlashAttention kernels para atenção de consultas agrupadas.
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 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 dapast_key_values
chave devem ser retornados. O valor padrão éFalse
.
-
Devoluções
Retorna um single 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 torch.sagemaker.transform()
API para transformar modelos do Hugging Face Transformer em implementações de modelos SMP e habilitar o paralelismo do tensor 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 )
O SMP v2 mantém as políticas de transformação para o Modelos Hugging Face Transformer compatíveis com o paralelismo do tensor SMP convertendo a configuração dos modelos Hugging Face Transformer na configuração do transformador SMP.
Parâmetros
-
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 modelofp32
ao usarMixedPrecision
efp32
é 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 definirsync_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 ostate_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
.
Devoluções
Retorna um modelo transformado que você pode empacotar com o PyTorch FSDP. Quando load_state_dict_from_rank0
definido comoTrue
, o grupo paralelo de tensores que envolve a classificação 0 tem pesos carregados do dicionário de estado original na classificação 0. Ao usar Inicialização atrasada de parâmetros no modelo original, somente essas classificações têm os tensores reais nas CPUs para os parâmetros e buffers do modelo transformado. O resto das classificações continuam com os parâmetros e buffers no meta-dispositivo 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 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 determinadodevice
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 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.
Atualização do SMP v1 para o SMP v2
Para migrar do SMP v1 para o SMP v2, você deve fazer alterações no script para remover as APIs do SMP v1 e aplicar as APIs do SMP v2. 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. Comece com a biblioteca de paralelismo de SageMaker modelos v2
Para trazer os modelos 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 traduçã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 emSalve e carregue pontos de verificação ao usar o SMP, você pode carregar os pontos de verificação do modelo Hugging Face Transformers e continuar usando as APIs de pontos de verificação com PyTorch o SMP v2. 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 tradução disponíveis no SMP v1, consulte. Suporte para modelos Hugging Face Transformer
Para obter instruções sobre como salvar e carregar pontos de verificação de modelos no SMP v2, consulte. Salve e carregue pontos de verificação ao usar o SMP