La referencia de la biblioteca paralela de SageMaker modelos v2 - Amazon SageMaker
Parámetros de configuración de las funciones principales del SMP v2Referencia para el paquete SMP v2 torch.sagemakerActualización de SMP v1 a SMP v2

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

La referencia de la biblioteca paralela de SageMaker modelos v2

Las siguientes son referencias para la biblioteca paralela de SageMaker modelos v2 (SMP v2).

Parámetros de configuración de las funciones principales del SMP v2

La siguiente es una lista completa de los parámetros para activar y configurar elCaracterísticas principales de la biblioteca de paralelismo de SageMaker modelos v2. Deben escribirse en formato JSON y pasarse al PyTorch estimador del SDK de SageMaker Python o guardarse como un archivo 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(Entero): especifica un grado de paralelismo fragmentado. El valor debe ser un número entero comprendido entre y. 0 world_size El valor predeterminado es 0.

    • Si se establece en0, recurre a la PyTorch implementación nativa y a la API del script cuando tensor_parallel_degree es 1. De lo contrario, calcula el mayor tamaño posible en hybrid_shard_degree función de tensor_parallel_degree yworld_size. Al recurrir a los casos de uso nativos del PyTorch FSDP, si FULL_SHARD es la estrategia que utilizas, se divide en todo el clúster de GPU. Si HYBRID_SHARD o _HYBRID_SHARD_ZERO2 fue la estrategia, equivale a 8. hybrid_shard_degree Cuando el paralelismo tensorial está habilitado, se fragmenta según lo revisado. hybrid_shard_degree

    • Si se establece en1, recurre a la PyTorch implementación nativa y a la API del script cuando es NO_SHARD 1. tensor_parallel_degree De lo contrario, es equivalente a NO_SHARD dentro de cualquier grupo tensor paralelo dado.

    • Si se establece en un número entero entre 2 yworld_size, la fragmentación se produce en el número especificado de GPU. Si no lo configuras sharding_strategy en el script del FSDP, se anula a. HYBRID_SHARD Si lo estableces_HYBRID_SHARD_ZERO2, se usará el sharding_strategy que especifiques.

  • sm_activation_offloading(Boolean): especifica si se debe habilitar la implementación de descarga y activación de SMP. SiFalse, la descarga utiliza la implementación nativa. PyTorch SiTrue, utiliza la implementación de descarga y activación de SMP. También debe usar la PyTorch activación offload wrapper () en su script. torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper Para obtener más información, consulte Descarga de activación. El valor predeterminado es True.

  • activation_loading_horizon(Entero): un número entero que especifica el tipo de horizonte de descarga de activación para el FSDP. Es el número máximo de capas descargadas o con puntos de control cuyas entradas pueden estar simultáneamente en la memoria de la GPU. Para obtener más información, consulte Descarga de activación. El valor de entrada debe ser un número entero positivo. El valor predeterminado es 2.

  • fsdp_cache_flush_warnings(Booleano): detecta y advierte si se producen descargas de caché en el administrador de PyTorch memoria, ya que pueden reducir el rendimiento computacional. El valor predeterminado es True.

  • allow_empty_shards(Booleano): si se deben permitir fragmentos vacíos al fragmentar tensores si el tensor no es divisible. Se trata de una solución experimental para evitar que se produzcan bloqueos durante los puntos de control en determinadas situaciones. Al deshabilitar esto, se vuelve al comportamiento original PyTorch . El valor predeterminado es False.

  • tensor_parallel_degree(Entero): especifica el grado de paralelismo del tensor. El valor debe estar comprendido entre y. 1 world_size El valor predeterminado es 1. Pasar un valor mayor que 1 no habilita el paralelismo tensorial automáticamente. También necesitas usar la torch.sagemaker.transform API para incluir el modelo en tu script de entrenamiento. Para obtener más información, consulte Paralelismo de tensores.

  • expert_parallel_degree(Entero): especifica un grado de paralelismo experto. El valor debe estar comprendido entre 1 y. world_size El valor predeterminado es 1. Pasar un valor superior a 1 no habilita automáticamente el paralelismo experto; asegúrese de incluir el modelo MoE con la torch.sagemaker.transform API en su guion de entrenamiento.

  • random_seed(Entero): un número inicial para las operaciones aleatorias en módulos distribuidos mediante paralelismo tensorial SMP o paralelismo experto. Esta semilla se añadirá a los rangos tensor-paralelo o experto-paralelo para establecer la semilla real de cada rango. Es único para cada rango tensor-paralelo y experto-paralelo. SMP v2 se asegura de que el número aleatorio generado en los rangos tensor-paralelo y experto-paralelo coincida con los casos y, respectivamente. non-tensor-parallelism non-expert-parallelism

Referencia para el paquete SMP v2 torch.sagemaker

Esta sección es una referencia para el torch.sagemaker paquete proporcionado por SMP v2.

torch.sagemaker.delayed_param.DelayedParamIniter

Una API para aplicarla Inicialización retrasada de los parámetros a un 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): un PyTorch modelo para empaquetar y aplicar la funcionalidad de inicialización diferida de parámetros de SMP v2.

  • init_method_using_config(Llamable): si usa la implementación tensorial paralela de SMP v2 o es compatibleModelos de Hugging Face Transformer compatibles con el paralelismo tensorial SMP, mantenga este parámetro en el valor predeterminado, que es. None De forma predeterminada, la DelayedParamIniter API descubre cómo inicializar correctamente el modelo dado. Para cualquier otro modelo, debe crear una función de inicialización de parámetros personalizada y añadirla al script. El siguiente fragmento de código es la init_method_using_config función predeterminada que SMP v2 implementó para. Modelos de Hugging Face Transformer compatibles con el paralelismo tensorial SMP Utilice el siguiente fragmento de código como referencia para crear su propia función de configuración de inicialización, añadirla al script y pasarla al parámetro de la init_method_using_config 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 obtener más información sobre torch.sagemaker.module_util las funciones del fragmento de código anterior, consulte. torch.sagemakerFunciones y propiedades de util

  • verbose(Booleano): si se debe permitir un registro más detallado durante la inicialización y la validación. El valor predeterminado es False.

Métodos

  • get_param_init_fn()— Devuelve la función de inicialización de parámetros que se puede pasar al param_init_fn argumento de la clase contenedora FSDP. PyTorch

  • get_post_param_init_fn()— Devuelve la función de inicialización de parámetros que se puede pasar al post_param_init_fn argumento de la clase contenedora del FSDP. PyTorch Esto es necesario cuando se han vinculado pesas en el modelo. El modelo debe implementar el métodotie_weights. Para obtener más información, consulte las notas sobre el peso atado enInicialización retrasada de los parámetros.

  • count_num_params(module: nn.Module, *args: Tuple[nn.Parameter]) — Realiza un seguimiento del número de parámetros que está inicializando la función de inicialización de parámetros. Esto ayuda a implementar el siguiente validate_params_and_buffers_inited método. Por lo general, no es necesario llamar a esta función de forma explícita, ya que el validate_params_and_buffers_inited método llama implícitamente a este método en el backend.

  • validate_params_and_buffers_inited(enabled: bool=True): se trata de un administrador de contexto que ayuda a validar que el número de parámetros inicializados coincide con el número total de parámetros del modelo. También valida que todos los parámetros y búferes estén ahora en dispositivos GPU y no en metadispositivos. Surge AssertionErrors si no se cumplen estas condiciones. Este administrador de contexto solo es opcional y no es necesario que lo utilice para inicializar los parámetros.

torch.sagemaker.moe.moe_config.MoEConfig

Una clase de configuración para configurar la implementación SMP de Mixture-of-Experts (MoE). Puede especificar los valores de configuración del MoE mediante esta clase y pasarlos a la llamada a la API. torch.sagemaker.transform Para obtener más información sobre el uso de esta clase para entrenar modelos de MoE, consulteParalelismo experto.

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(Booleano): si se debe utilizar la implementación SMP del MoE. El valor predeterminado es True.

  • random_seed(Entero): un número inicial para las operaciones aleatorias en módulos distribuidos en paralelo experto. Esta semilla se añadirá al rango paralelo de experto para establecer la semilla real de cada rango. Es único para cada rango de experto en parallel. El valor predeterminado es 12345.

  • moe_load_balancing(Cadena): especifique el tipo de equilibrio de carga del router MoE. Las opciones válidas son aux_losssinkhorn,balanced, ynone. El valor predeterminado es sinkhorn.

  • global_token_shuffle(Booleano): si se deben mezclar fichas entre los rangos de EP del mismo grupo de EP. El valor predeterminado es False.

  • moe_all_to_all_dispatcher(Boolean): si se debe usar el all-to-all despachador para las comunicaciones en el MoE. El valor predeterminado es True.

  • moe_aux_loss_coeff(Flotar): coeficiente de pérdida por balanceo de carga auxiliar. El valor predeterminado es 0.001.

  • moe_z_loss_coeff(Flotar): coeficiente de pérdida z. El valor predeterminado es 0.001.

torch.sagemaker.nn.attn.FlashSelfAttention

Una API para usar FlashAttention con 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(flotante): la probabilidad de abandono que se aplica a la atención. El valor predeterminado es 0.0.

  • scale(flotante): si se aprueba, este factor de escala se aplicará a softmax. Si se establece en None (que también es el valor predeterminado), el factor de escala es1 / sqrt(attention_head_size). El valor predeterminado es None.

  • triton_flash_attention(bool): si se aprueba, se utilizará la implementación Triton de flash attention. Esto es necesario para apoyar la atención con sesgos lineales (ALiBi) (consulte el siguiente use_alibi parámetro). Esta versión del núcleo no admite el abandono. El valor predeterminado es False.

  • use_alibi(bool): si se aprueba, se activa la función Atención con sesgos lineales (ALiBi) con la máscara proporcionada. Cuando se usa ALiBi, necesita una máscara de atención preparada de la siguiente manera. El valor predeterminado es 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")— Una función PyTorch modular normal. Cuando se module(x) llama a, SMP ejecuta esta función automáticamente.

    • qkv— torch.Tensor de la siguiente forma: (batch_size x seqlen x (3 x num_heads) x head_size) o(batch_size, (3 x num_heads) x seqlen x head_size), una tupla de torch.Tensors cada una de las cuales puede tener forma(batch_size x seqlen x num_heads x head_size), o. (batch_size x num_heads x seqlen x head_size) Se debe pasar un diseño de diseño adecuado en función de la forma.

    • attn_mask— torch.Tensor de la siguiente forma. (batch_size x 1 x 1 x seqlen) Para activar este parámetro de máscara de atención, se requieren triton_flash_attention=True yuse_alibi=True. Para aprender a generar una máscara de atención con este método, consulte los ejemplos de código enFlashAttention. El valor predeterminado es None.

    • causal— Si se establece enFalse, que es el valor por defecto del argumento, no se aplica ninguna máscara. Si se establece enTrue, el forward método utiliza la máscara triangular inferior estándar. El valor predeterminado es False.

    • cast_dtype— Cuando se establece en una determinadadtype, proyecta los qkv tensores hacia esa posición dtype anteriorattn. Esto es útil para implementaciones como el modelo Hugging Face Transformer GPT-Neox, que tiene q y con incrustaciones rotativas posteriores. k fp32 Si se establece en, no se aplica ningún molde. None El valor predeterminado es None.

    • layout(cadena): los valores disponibles son b h s d ob s h d. Debe ajustarse a la disposición de los qkv tensores pasados, de modo que se puedan aplicar las transformaciones adecuadas. attn El valor predeterminado es b h s d.

Devuelve

Un sencillo torch.Tensor con forma. (batch_size x num_heads x seq_len x head_size)

torch.sagemaker.nn.attn.FlashGroupedQueryAttention

Una API para usar FlashGroupedQueryAttention con SMP v2. Para obtener más información sobre el uso de esta API, consulteUsa los FlashAttention núcleos para la atención de las consultas agrupadas.

class torch.sagemaker.nn.attn.FlashGroupedQueryAttention(
    attention_dropout_prob: float = 0.0,
    scale: Optional[float] = None,
)

Parámetros

  • attention_dropout_prob(flotante): la probabilidad de abandono que se aplica a la atención. El valor predeterminado es 0.0.

  • scale(flotante): si se aprueba, este factor de escala se aplica a softmax. Si se establece enNone, 1 / sqrt(attention_head_size) se utiliza como factor de escala. El valor predeterminado es None.

Métodos

  • forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d")— Una función PyTorch de módulo normal. Cuando se module(x) llama a, SMP ejecuta esta función automáticamente.

    • q— torch.Tensor de la siguiente forma (batch_size x seqlen x num_heads x head_size) o(batch_size x num_heads x seqlen x head_size). Se debe aprobar el arg de diseño adecuado en función de la forma.

    • kv— torch.Tensor de la siguiente forma (batch_size x seqlen x (2 x num_heads) x head_size) o(batch_size, (2 x num_heads) x seqlen x head_size), o una tupla de dos torch.Tensor s, cada una de las cuales puede tener la forma (batch_size x seqlen x num_heads x head_size) o. (batch_size x num_heads x seqlen x head_size) También se debe pasar el layout argumento apropiado en función de la forma.

    • causal— Cuando se establece enFalse, que es el valor por defecto del argumento, no se aplica ninguna máscara. Si se establece enTrue, el forward método utiliza la máscara triangular inferior estándar. El valor predeterminado es False.

    • cast_dtype— Cuando se establece en un tipo d en particular, proyecta los qkv tensores a ese tipo d anterior. attn Esto es útil para implementaciones como Hugging Face Transformers GPT-Neox, que tiene incrustaciones posteriores a la rotación. q,k fp32 Si se establece en, no se aplica ningún molde. None El valor predeterminado es None.

    • diseño (cadena): los valores disponibles son "b h s d" o"b s h d". Debe ajustarse a la disposición de los qkv tensores pasados, de modo que se puedan aplicar las transformaciones adecuadas. attn El valor predeterminado es "b h s d".

Devuelve

Devuelve un sencillo torch.Tensor (batch_size x num_heads x seq_len x head_size) que representa el resultado del cálculo de la atención.

torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention

Una API compatible con FlashAttention el modelo Llama. Esta API usa la torch.sagemaker.nn.attn.FlashGroupedQueryAttention API a un nivel bajo. Para obtener información sobre cómo utilizarla, consulteUsa los FlashAttention núcleos para la atención de las consultas agrupadas.

class torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention(
    config: LlamaConfig
)

Parámetros

  • config— Una FlashAttention configuración para el 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 un tensor en forma de(batch_size x seq_len x num_heads x head_size).

    • attention_mask(torch.LongTensor) — Máscara para evitar prestar atención a rellenar los índices simbólicos en forma de. (batch_size x seqlen) El valor predeterminado es None.

    • position_ids(torch.LongTensor) — Cuando no lo estáNone, tiene la forma de (batch_size x seqlen) indicar los índices de posición de cada token de secuencia de entrada en las incrustaciones de posiciones. El valor predeterminado es None.

    • past_key_value(Caché): estados ocultos precalculados (clave y valores en los bloques de autoatención y en los bloques de atención cruzada). El valor predeterminado es None.

    • output_attentions(bool): indica si se deben devolver los tensores de atención de todas las capas de atención. El valor predeterminado es False.

    • use_cache(bool): indica si se deben devolver past_key_values los estados de los valores clave. El valor predeterminado es False.

Devuelve

Devuelve un valor único torch.Tensor (batch_size x num_heads x seq_len x head_size) que representa el resultado del cálculo de la atención.

torch.sagemaker.transform

SMP v2 proporciona esta torch.sagemaker.transform() API para transformar los modelos de Hugging Face Transformer en implementaciones de modelos SMP y habilitar el paralelismo tensorial 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
)

SMP v2 mantiene políticas de transformación para el Modelos de Hugging Face Transformer compatibles con el paralelismo tensorial SMP al convertir la configuración de los modelos Hugging Face Transformer en la configuración del transformador SMP.

Parámetros

  • model(torch.nn.Module): un modelo Modelos de Hugging Face Transformer compatibles con el paralelismo tensorial SMP para transformar y aplicar la función de paralelismo tensorial de la biblioteca SMP.

  • device(torch.device) — Si se aprueba, se crea un nuevo modelo en este dispositivo. Si el módulo original tiene algún parámetro en el metadispositivo (consulteInicialización retrasada de los parámetros), el módulo transformado también se creará en el metadispositivo, ignorando el argumento incluido aquí. El valor predeterminado es None.

  • dtype(torch.dtype) — Si se aprueba, lo establece como el administrador de contexto de dtype para la creación del modelo y crea un modelo con este dtype. Por lo general, esto no es necesario, ya que queremos crear el modelo fp32 cuando lo usamosMixedPrecision, y fp32 es el dtype predeterminado. PyTorch El valor predeterminado es None.

  • config(dict): este es un diccionario para configurar el transformador SMP. El valor predeterminado es None.

  • load_state_dict_from_rank0(Boolean): de forma predeterminada, este módulo crea una nueva instancia del modelo con nuevos pesos. Cuando este argumento se establece enTrue, SMP intenta cargar el diccionario de estados del PyTorch modelo original desde el rango 0 en un modelo transformado para el grupo paralelo de tensores del que forma parte el rango 0. Cuando se establece enTrue, el rango 0 no puede tener ningún parámetro en el metadispositivo. Solo el primer grupo de tensores paralelos completa los pesos del rango 0 después de esta llamada a la transformación. Debe sync_module_states configurarlo True en el contenedor FSDP para obtener estos pesos del primer grupo de tensores paralelos a todos los demás procesos. Con esta opción activada, la biblioteca SMP carga el diccionario de estados del modelo original. La biblioteca SMP toma el modelo antes state_dict de la transformación, lo convierte para que coincida con la estructura del modelo transformado, lo fragmenta para cada rango paralelo de tensores, comunica este estado del rango 0 a otros rangos del grupo de tensores paralelos del que forma parte el rango 0 y lo carga. El valor predeterminado es False.

Devuelve

Devuelve un modelo transformado que se puede empaquetar con PyTorch FSDP. Cuando load_state_dict_from_rank0 se establece enTrue, el grupo paralelo de tensores que implica el rango 0 tiene pesos cargados del diccionario de estados original en el rango 0. Cuando se utilizan Inicialización retrasada de los parámetros en el modelo original, solo estos rangos tienen los tensores reales en las CPU para los parámetros y los búferes del modelo transformado. El resto de los rangos siguen teniendo los parámetros y los búferes en el metadispositivo para ahorrar memoria.

torch.sagemakerFunciones y propiedades de util

funciones de utilidad torch.sagemaker

  • torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None— Inicializa el trabajo de entrenamiento con SMP. PyTorch

  • torch.sagemaker.is_initialized() -> bool— Comprueba si el trabajo de formación se inicializa con SMP. Al volver a la versión nativa PyTorch mientras el trabajo se inicializa con SMP, algunas de las propiedades no son relevantes y pasan a serloNone, tal y como se indica en la siguiente lista de propiedades.

  • torch.sagemaker.utils.module_utils.empty_module_params(module: nn.Module, device: Optional[torch.device] = None, recurse: bool = False) -> nn.Module— Crea parámetros vacíos en lo dado, device si los hay, y puede ser recursivo para todos los módulos anidados si se especifica.

  • torch.sagemaker.utils.module_utils.move_buffers_to_device(module: nn.Module, device: torch.device, recurse: bool = False) -> nn.Module— Mueve los búferes de los módulos a un valor determinado ydevice, si se especifica, puede ser recursivo para todos los módulos anidados.

Propiedades

torch.sagemaker.statecontiene varias propiedades útiles después de la inicialización de SMP con. torch.sagemaker.init

  • torch.sagemaker.state.hybrid_shard_degree(int): el grado de paralelismo de los datos fragmentados, una copia de la entrada del usuario en la configuración de SMP a la que se ha pasado. torch.sagemaker.init() Para obtener más información, consulte Comience con la biblioteca de paralelismo de SageMaker modelos v2.

  • torch.sagemaker.state.rank(int): la clasificación global del dispositivo, en el rango de. [0, world_size)

  • torch.sagemaker.state.rep_rank_process_group(torch.distributed.ProcessGroup): el grupo de procesos que incluye todos los dispositivos con el mismo rango de replicación. Observe la diferencia sutil pero fundamental contorch.sagemaker.state.tp_process_group. Cuando vuelve a ser nativo PyTorch, regresaNone.

  • torch.sagemaker.state.tensor_parallel_degree(int): el grado de paralelismo del tensor, una copia de la entrada del usuario en la configuración SMP a la que se pasó. torch.sagemaker.init() Para obtener más información, consulte Comience con la biblioteca de paralelismo de SageMaker modelos v2.

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

  • torch.sagemaker.state.tp_rank(int) — El rango de paralelismo del tensor para el dispositivo en el rango de[0, tp_size), determinado por el grado de paralelismo del tensor y el mecanismo de clasificación.

  • torch.sagemaker.state.tp_process_group(torch.distributed.ProcessGroup): el grupo de procesos tensoriales paralelos que incluye todos los dispositivos con el mismo rango en otras dimensiones (por ejemplo, paralelismo y replicación de datos fragmentados) pero con rangos tensoriales paralelos únicos. Al volver al modo nativo, vuelve. PyTorch None

  • torch.sagemaker.state.world_size(int): la cantidad total de dispositivos utilizados en el entrenamiento.

Actualización de SMP v1 a SMP v2

Para pasar de SMP v1 a SMP v2, debe realizar cambios en el script para eliminar las API de SMP v1 y aplicar las API de SMP v2. En lugar de empezar con el script SMP v1, le recomendamos que empiece con un script PyTorch FSDP y siga las instrucciones que se indican en. Comience con la biblioteca de paralelismo de SageMaker modelos v2

Para llevar los modelos SMP v1 a SMP v2, en SMP v1 debes recopilar el diccionario de estados del modelo completo y aplicar las funciones de traducción del diccionario de estados del modelo para convertirlo al formato de punto de control del modelo Hugging Face Transformers. Luego, en SMP v2, como se explica enGuarde y cargue los puntos de control mientras usa SMP, puedes cargar los puntos de control del modelo Hugging Face Transformers y luego continuar usando las API de puntos de PyTorch control con SMP v2. Para usar el SMP con tu modelo de PyTorch FSDP, asegúrate de pasarte al SMP v2 y de realizar cambios en el guion de entrenamiento para usar el FSDP y otras funciones más recientes. PyTorch 

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 ver las funciones de traducción disponibles en SMP v1, consulte. Soporte listo para usar para modelos Hugging Face Transformer

Para obtener instrucciones sobre cómo guardar y cargar puntos de control de modelos en SMP v2, consulte. Guarde y cargue los puntos de control mientras usa SMP