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). **Topics** + [Parámetros de configuración de las características esenciales de SMP v2](#distributed-model-parallel-v2-reference-init-config) + [Referencia para el paquete `torch.sagemaker` de SMP v2](#model-parallel-v2-torch-sagemaker-reference) + [Actualización de SMP v1 a SMP v2](#model-parallel-v2-upgrade-from-v1) ## Parámetros de configuración de las características esenciales de SMP v2 A continuación se ofrece una lista completa de los parámetros para activar y configurar [Características principales de la biblioteca de paralelismo de SageMaker modelos v2](model-parallel-core-features-v2.md). 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, "context_parallel_degree": Integer, "expert_parallel_degree": Integer, "random_seed": Integer } ``` + `hybrid_shard_degree` (entero): especifica un grado de paralelismo particionado. El valor debe ser un número entero entre `0` y `world_size`. El valor predeterminado es `0`. + Si se establece en`0`, vuelve a la PyTorch implementación nativa y a la API del script cuando `tensor_parallel_degree` es 1. De lo contrario, calcula el mayor `hybrid_shard_degree` posible en función de `tensor_parallel_degree` y `world_size`. Al volver 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. GPUs Si `HYBRID_SHARD` o `_HYBRID_SHARD_ZERO2` es la estrategia, equivale a `hybrid_shard_degree` de 8. Cuando el paralelismo de tensores está habilitado, se particiona según el `hybrid_shard_degree` revisado. + Si se establece en`1`, recurre a la PyTorch implementación nativa y a la API del script cuando `tensor_parallel_degree` es 1. `NO_SHARD` De lo contrario, es equivalente a `NO_SHARD` en cualquiera de los grupos de paralelismo de tensores dados. + Si se establece en un número entero entre 2 y`world_size`, la fragmentación se produce en el número especificado de GPUs. Si no configura `sharding_strategy` en el script de FSDP, se sustituye por `HYBRID_SHARD`. Si establece `_HYBRID_SHARD_ZERO2`, se usa la `sharding_strategy` que especifique. + `sm_activation_offloading` (booleano): especifica si se debe habilitar la implementación de descarga de activaciones de SMP. Si`False`, la descarga usa la implementación nativa. PyTorch Si es `True`, utiliza la implementación de descarga de activaciones de SMP. También debe usar la PyTorch activación offload wrapper () `torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper` en su script. Para obtener más información, consulte [Descarga de activación](model-parallel-core-features-v2-pytorch-activation-offloading.md). El valor predeterminado es `True`. + `activation_loading_horizon` (entero): número entero que especifica el tipo de horizonte de descarga de activaciones para FSDP. Es el número máximo de capas descargadas o con puntos de comprobación cuyas entradas pueden estar simultáneamente en la memoria de la GPU. Para obtener más información, consulte [Descarga de activación](model-parallel-core-features-v2-pytorch-activation-offloading.md). El valor debe ser un número entero positivo. El valor predeterminado es `2`. + `fsdp_cache_flush_warnings`(Boolean): detecta y advierte si se producen descargas de caché en el administrador de PyTorch memoria, ya que pueden degradar el rendimiento computacional. El valor predeterminado es `True`. + `allow_empty_shards` (booleano): indica si se deben permitir particiones vacías al particionar los tensores si el tensor no es divisible. Se trata de una corrección experimental de bloqueos durante los puntos de comprobación en determinadas situaciones. Si se desactiva esta opción, se vuelve al comportamiento original. PyTorch El valor predeterminado es `False`. + `tensor_parallel_degree` (entero): especifica un grado de paralelismo de tensores. El valor debe estar entre `1` y `world_size`. El valor predeterminado es `1`. Tenga en cuenta que al pasar un valor superior a 1 no se habilita el paralelismo de contexto automáticamente; también debe usar la API de [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform) para encapsular el modelo en el script de entrenamiento. Para obtener más información, consulte [Paralelismo de tensores](model-parallel-core-features-v2-tensor-parallelism.md). + `context_parallel_degree` (entero): especifica el grado de paralelismo de contexto. El valor debe estar comprendido entre `1` y `world_size` y debe ser `<= hybrid_shard_degree`. El valor predeterminado es `1`. Tenga en cuenta que al pasar un valor superior a 1 no se habilita el paralelismo de contexto automáticamente; también debe usar la API de [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform) para encapsular el modelo en el script de entrenamiento. Para obtener más información, consulte [Paralelismo de contexto](model-parallel-core-features-v2-context-parallelism.md). + `expert_parallel_degree` (entero): especifica un grado de paralelismo experto. El valor debe estar entre 1 y `world_size`. El valor predeterminado es `1`. Tenga en cuenta que al pasar un valor superior a 1 no se habilita el paralelismo de contexto automáticamente; también debe usar la API de [`torch.sagemaker.transform`](#model-parallel-v2-torch-sagemaker-reference-transform) para encapsular el modelo en el script de entrenamiento. Para obtener más información, consulte [Paralelismo experto](model-parallel-core-features-v2-expert-parallelism.md). + `random_seed` (entero): un número de inicialización para las operaciones aleatorias en módulos distribuidos mediante paralelismo de tensores SMP o paralelismo experto. Este valor de inicialización se agrega a los rangos de paralelismo de tensores o paralelismo experto para establecer el valor de inicialización real de cada rango. Es único para cada rango de paralelismo de tensores y paralelismo experto. 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 `torch.sagemaker` de SMP v2 Esta sección ofrece una referencia para el paquete `torch.sagemaker` que suministra 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) + [Funciones y propiedades util de `torch.sagemaker`](#model-parallel-v2-torch-sagemaker-reference-utils) ### `torch.sagemaker.delayed_param.DelayedParamIniter` Una API para aplicarla a un modelo. [Inicialización diferida de parámetros](model-parallel-core-features-v2-delayed-param-init.md) PyTorch ``` 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` (invocable): si usa la implementación de paralelismo de tensores de SMP v2 o los [Modelos de Hugging Face Transformer compatibles con el paralelismo de tensores de SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models), compatibles, mantenga este parámetro en el valor predeterminado, que es `None`. De forma predeterminada, la API de `DelayedParamIniter` 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 función `init_method_using_config` predeterminada que SMP v2 implementó para [Modelos de Hugging Face Transformer compatibles con el paralelismo de tensores de SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models). 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 `init_method_using_config` de la API `DelayedParamIniter` de 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 obtener más información sobre las funciones de `torch.sagemaker.module_util` del fragmento de código anterior, consulte [Funciones y propiedades util de `torch.sagemaker`](#model-parallel-v2-torch-sagemaker-reference-utils). + `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 PyTorch FSDP. + `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 ponderaciones en el modelo. El modelo debe implementar el método `tie_weights`. Para obtener más información, consulte **Notes on tied weight** en [Inicialización diferida de parámetros](model-parallel-core-features-v2-delayed-param-init.md). + `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 método `validate_params_and_buffers_inited`. Por lo general, no es necesario llamar a esta función de forma explícita, ya que el método `validate_params_and_buffers_inited` 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. Aumenta `AssertionErrors` si no se cumplen estas condiciones. Este administrador de contexto solo es opcional y no es necesario que lo utilice para inicializar parámetros. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save` API de entrada para guardar de forma asíncrona. Utilice este método para guardar un `state_dict` de forma asíncrona en un `checkpoint_id` especificado. ``` 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): obligatorio. El dict de estado que se va a guardar. + `checkpoint_id` (str): obligatorio. La ruta de almacenamiento en la que se van a guardar los puntos de comprobación. + `storage_writer`() - OpcionalStorageWriter. Una instancia 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 operaciones de escritura. Si no se especifica, se utiliza la configuración predeterminada 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). + `planner`(SavePlanner) - Opcional. Una instancia 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. Si no se especifica, se utiliza la configuración predeterminada 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). + `process_group`(ProcessGroup) - Opcional. El grupo de procesos en el que se va a trabajar. Si es `None`, se utiliza el grupo de procesos (global) predeterminado. + `coordinator_rank` (int): opcional. El rango del coordinador cuando se ejecutan operadores de comunicación colectiva, como`AllReduce`. + `queue`(AsyncRequestQueue) - Opcional. El programador asíncrono que se va a utilizar. De forma predeterminada, toma el parámetro global `DEFAULT_ASYNC_REQUEST_QUEUE`. + `sharded_strategy`(PyTorchDistSaveShardedStrategy) - Opcional. La estrategia particionada que se utilizará para guardar los puntos de comprobación. Si no se especifica, se utiliza `torch.sagemaker.distributed.checkpoint.state_dict_saver.PyTorchDistSaveShardedStrategy` de forma predeterminada. + `wait_error_handling` (bool): opcional. Una marca que especifica si se debe esperar a que todos los rangos terminen de gestionar los errores. El valor predeterminado es `True`. + `force_check_all_plans` (bool): opcional. Un indicador que determina si se deben sincronizar forzosamente los planes de todos los rangos, incluso en el caso de que se produzca un acierto de caché. El valor predeterminado es `True`. + `s3_region` (str): opcional. La región donde está ubicado el bucket de S3. Si no se especifica, la región se deduce del `checkpoint_id`. + `s3client_config`(S3ClientConfig): opcional. La clase de datos que expone los parámetros configurables del cliente S3. Si no se proporciona, se ClientConfig utiliza la configuración predeterminada de [S3](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7). El parámetro `part_size` se establece en 64 MB de forma predeterminada. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls` Esta función permite que un proceso de entrenamiento supervise las múltiples solicitudes asincrónicas que se van a realizar. ``` def maybe_finalize_async_calls( blocking=True, process_group=None ) -> List[int]: ``` **Parámetros** + `blocking` (bool): opcional. Si es `True`, espera hasta que se completen todas las solicitudes activas. De lo contrario, finaliza solo las solicitudes asincrónicas que ya han finalizado. El valor predeterminado es `True`. + `process_group`(ProcessGroup) - Opcional. El grupo de procesos en el que se va a trabajar. Si se establece en `None`, se utiliza el grupo de procesos (global) predeterminado. **Devuelve** + Ha finalizado correctamente una lista que contiene los índices de las llamadas asíncronas. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.save` Utilice este método para guardar un `state_dict` de forma asíncrona en un `checkpoint_id` especificado. ``` 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): obligatorio. El dict de estado que se va a guardar. + `checkpoint_id` (str): obligatorio. La ruta de almacenamiento en la que se van a guardar los puntos de comprobación. + `storage_writer`(StorageWriter) - Opcional. Una instancia 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 operaciones de escritura. Si no se especifica, se utiliza la configuración predeterminada 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). + `planner`(SavePlanner) - Opcional. Una instancia 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. Si no se especifica, se utiliza la configuración predeterminada 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). + `process_group`(ProcessGroup) - Opcional. El grupo de procesos en el que se va a trabajar. Si es `None`, se utiliza el grupo de procesos (global) predeterminado. + `coordinator_rank` (int): opcional. El rango del coordinador cuando se ejecutan operadores de comunicación colectiva, como`AllReduce`. + `wait_error_handling` (bool): opcional. Una marca que especifica si se debe esperar a que todos los rangos terminen de gestionar los errores. El valor predeterminado es `True`. + `force_check_all_plans` (bool): opcional. Un indicador que determina si se deben sincronizar forzosamente los planes de todos los rangos, incluso en el caso de que se produzca un acierto de caché. El valor predeterminado es `True`. + `s3_region` (str): opcional. La región donde está ubicado el bucket de S3. Si no se especifica, la región se deduce del `checkpoint_id`. + `s3client_config`(S3ClientConfig): opcional. La clase de datos que expone los parámetros configurables del cliente S3. Si no se proporciona, se ClientConfig utiliza la configuración predeterminada de [S3](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7). El parámetro `part_size` se establece en 64 MB de forma predeterminada. ### `torch.sagemaker.distributed.checkpoint.state_dict_loader.load` Cargue el diccionario de estados de un modelo distribuido (`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): obligatorio. El `state_dict` que se va a cargar. + `checkpoint_id` (str): obligatorio. El ID de un punto de comprobación. El significado de `checkpoint_id` depende del almacenamiento. Puede ser una ruta a una carpeta o a un archivo. También puede ser una clave si el almacenamiento es un almacén de claves-valores. + `storage_reader`(StorageReader) - Opcional. Una instancia 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 operaciones de lectura. Si no se especifica, los puntos de comprobación distribuidos deducirán automáticamente el lector en función del `checkpoint_id`. Si el `checkpoint_id` también es `None`, se produce un error de excepción. + `planner`(StorageReader) - Opcional. Una instancia 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. Si no se especifica, se utiliza la configuración predeterminada 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. Si está habilitada, comprueba si las claves `state_dict` de todos los rangos coinciden mediante`AllGather`. + `s3_region` (str): opcional. La región donde está ubicado el bucket de S3. Si no se especifica, la región se deduce del `checkpoint_id`. + `s3client_config`(S3ClientConfig): opcional. La clase de datos que expone los parámetros configurables del cliente S3. Si no se proporciona, se ClientConfig utiliza la configuración predeterminada de [S3](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7). El parámetro `part_size` se establece en 64 MB de forma predeterminada. ### `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 de MoE mediante esta clase y pasarlos a la llamada a la API [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 obtener más información acerca del uso de esta clase para entrenar modelos de MoE, consulte [Paralelismo experto](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): si se debe utilizar la implementación SMP de MoE. El valor predeterminado es `True`. + `random_seed` (entero): un número de inicialización para las operaciones aleatorias en módulos distribuidos de paralelismo experto. Este valor de inicialización se agrega al rango de paralelismo experto para establecer el valor de inicialización real de cada rango. Es único para cada rango de paralelismo experto. El valor predeterminado es `12345`. + `moe_load_balancing` (cadena): especifique el tipo de equilibrio de carga del router de MoE. Las opciones válidas son: `aux_loss`, `sinkhorn`, `balanced` y `none`. El valor predeterminado es `sinkhorn`. + `global_token_shuffle` (booleano): si se deben mezclar tokens entre rangos de EP dentro del mismo grupo de EP. El valor predeterminado es `False`. + `moe_all_to_all_dispatcher`(Booleano): si se debe utilizar el all-to-all despachador para las comunicaciones en el MoE. El valor predeterminado es `True`. + `moe_aux_loss_coeff` (flotante): coeficiente de pérdida por equilibrio de carga auxiliar. El valor predeterminado es `0.001`. + `moe_z_loss_coeff` (flotante): coeficiente de pérdida z. El valor predeterminado es `0.001`. ### `torch.sagemaker.nn.attn.FlashSelfAttention` Una API para utilizar [FlashAttention](model-parallel-core-features-v2-flashattention.md) 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 atención. El valor predeterminado es `0.0`. + `scale` (flotante): si se pasa, este factor de escala se aplica a softmax. Si se establece en `None` (que también es el valor predeterminado), el factor de escala es`1 / sqrt(attention_head_size)`. El valor predeterminado es `None`. + `triton_flash_attention` (bool): si se pasa, se utiliza la implementación de Triton de Flash Attention. Esto es necesario para apoyar la atención con sesgos lineales (ALiBi) (consulte el siguiente parámetro). `use_alibi` Esta versión del kernel no admite abandono. El valor predeterminado es `False`. + `use_alibi`(bool): si se aprueba, se habilita la atención con sesgos lineales (ALiBi) con la máscara proporcionada. Cuando se usa ALi Bi, se 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 llama a un `module(x)`, SMP ejecuta esta función automáticamente. + `qkv`: `torch.Tensor` con la forma siguiente: `(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 arg de diseño adecuado en función de la forma. + `attn_mask`: `torch.Tensor` con de la siguiente forma. `(batch_size x 1 x 1 x seqlen)` Para habilitar este parámetro de máscara de atención, se requieren `triton_flash_attention=True` y `use_alibi=True`. Para aprender a generar una máscara de atención con este método, consulte los ejemplos de código en [FlashAttention](model-parallel-core-features-v2-flashattention.md). El valor predeterminado es `None`. + `causal`: si se establece en `False`, que es el valor predeterminado del argumento, no se aplica ninguna máscara. Si se establece en `True`, el método `forward` utiliza la máscara triangular inferior estándar. El valor predeterminado es `False`. + `cast_dtype`: cuando se establece en un `dtype` determinado, proyecta los tensores de `qkv` a ese `dtype` delante de `attn`. Esto es útil para implementaciones como el modelo de Hugging Face Transformer GPT-NeoX, que tiene `q` y `k` con `fp32` después de incrustaciones rotatorias. Si se establece en `None`, no se aplica proyección. El valor predeterminado es `None`. + `layout` (cadena): los valores disponibles son `b h s d` o `b s h d`. Debe establecerse en el diseño de los tensores de `qkv` pasados, de modo que se puedan aplicar las transformaciones adecuadas para `attn`. El valor predeterminado es `b h s d`. **Devuelve** Un `torch.Tensor` individual con forma `(batch_size x num_heads x seq_len x head_size)`. ### `torch.sagemaker.nn.attn.FlashGroupedQueryAttention` Una API para utilizar `FlashGroupedQueryAttention` con SMP v2. Para obtener más información sobre el uso de esta API, consulte [Utilice los FlashAttention núcleos para la atención de las 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` (flotante): la probabilidad de abandono que se aplica a atención. El valor predeterminado es `0.0`. + `scale` (flotante): si se pasa, este factor de escala se aplica a softmax. Si se establece en `None`, se utiliza `1 / sqrt(attention_head_size)` 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 modular normal. Cuando se llama a un `module(x)`, SMP ejecuta esta función automáticamente. + `q`: `torch.Tensor` con 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 pasar un arg de diseño adecuado en función de la forma. + `kv`: `torch.Tensor` con la forma siguiente `(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`, 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 argumento de `layout` adecuado en función de la forma. + `causal`: si se establece en `False`, que es el valor predeterminado del argumento, no se aplica ninguna máscara. Si se establece en `True`, el método `forward` utiliza la máscara triangular inferior estándar. El valor predeterminado es `False`. + `cast_dtype`: cuando se establece en un dtype determinado, proyecta los tensores de `qkv` a ese dtype delante de `attn`. Esto es útil para implementaciones como Hugging Face Transformer GPT-NeoX, que tiene `q,k` con `fp32` después de incrustaciones rotatorias. Si se establece en `None`, no se aplica proyección. El valor predeterminado es `None`. + layout (cadena): los valores disponibles son `"b h s d"` o `"b s h d"`. Debe establecerse en el diseño de los tensores de `qkv` pasados, de modo que se puedan aplicar las transformaciones adecuadas para `attn`. El valor predeterminado es `"b h s d"`. **Devuelve** Devuelve un `torch.Tensor (batch_size x num_heads x seq_len x head_size)` individual que representa la salida de la computación de atención. ### `torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention` Una API compatible con FlashAttention el modelo Llama. Esta API usa la API [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) en un nivel bajo. Para obtener información sobre su uso, consulte [Utilice los FlashAttention núcleos para la atención de las 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`— 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 con forma de `(batch_size x seq_len x num_heads x head_size)`. + `attention_mask` (`torch.LongTensor`): máscara para evitar prestar atención al rellenar índices de token con forma de `(batch_size x seqlen)`. El valor predeterminado es `None`. + `position_ids` (`torch.LongTensor`): cuando no es `None`, tiene forma de `(batch_size x seqlen)`, lo que indica los índices de posiciones de cada token de secuencia de entrada en las incrustaciones de posición. 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 los estados de valores de claves de `past_key_values`. El valor predeterminado es `False`. **Devuelve** Devuelve un `torch.Tensor (batch_size x num_heads x seq_len x head_size)` individual que representa la salida de la computación de atención. ### `torch.sagemaker.transform` SMP v2 proporciona esta API `torch.sagemaker.transform()` para transformar los modelos de Hugging Face Transformer en implementaciones de modelos SMP y habilitar el paralelismo de tensores de 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" ) ``` SMP v2 mantiene políticas de transformación para los [Modelos de Hugging Face Transformer compatibles con el paralelismo de tensores de SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) convirtiendo la configuración de los modelos de Hugging Face Transformer en la configuración del transformador de SMP. **Parámetros** + `model` (`torch.nn.Module`): modelo de [Modelos de Hugging Face Transformer compatibles con el paralelismo de tensores de SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) para transformar y aplicar la característica de paralelismo de tensores de la biblioteca de SMP. + `device` (`torch.device`): si se pasa, se crea un nuevo modelo en este dispositivo. Si el módulo original tiene algún parámetro en un metadispositivo (consulte [Inicialización diferida de parámetros](model-parallel-core-features-v2-delayed-param-init.md)), también se creará el módulo transformado en el metadispositivo, sin tener en cuenta el argumento pasado aquí. El valor predeterminado es `None`. + `dtype` (`torch.dtype`): si se pasa, lo establece como 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` con el que `MixedPrecision` lo usamos y `fp32` es el dtype predeterminado. PyTorch El valor predeterminado es `None`. + `config` (dict): es un diccionario para configurar el transformador de SMP. El valor predeterminado es `None`. + `load_state_dict_from_rank0` (booleano): de forma predeterminada, este módulo crea una nueva instancia del modelo con nuevas ponderaciones. Cuando este argumento se establece en`True`, 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 en `True`, el rango 0 no puede tener ningún parámetro en el metadispositivo. Solo el primer grupo de paralelismo de tensores completa las ponderaciones del rango 0 después de esta llamada de la transformación. Debe establecer `sync_module_states` en `True` en el encapsulador de FSDP para obtener estas ponderaciones del primer grupo de paralelismo de tensores a todos los demás procesos. Con esta opción activada, la biblioteca de SMP carga el diccionario de estados del modelo original. La biblioteca de SMP toma el `state_dict` del modelo antes de la transformación, lo convierte para que coincida con la estructura del modelo transformado, lo particiona para cada rango de paralelismo de tensores, comunica este estado del rango 0 a otros rangos del grupo de paralelismo de tensores del que forma parte el rango 0 y lo carga. El valor predeterminado es `False`. + `cp_comm_type` (str): determina la implementación de paralelismo contextual y solo se aplica cuando `context_parallel_degree` es mayor que 1. Los valores disponibles para este parámetro son `p2p` y `all_gather`. La `p2p` implementación utiliza llamadas de peer-to-peer envío y recepción para acumular el tensor key-and-value (KV) durante el cálculo de la atención, ejecutándose de forma asíncrona y permitiendo que la comunicación se superponga con el cálculo. Por otro lado, la implementación de `all_gather` emplea la operación colectiva de comunicación de `AllGather` para la acumulación de tensores de KV. El valor predeterminado es `"p2p"`. **Devuelve ** Devuelve un modelo transformado que se puede ajustar con el FSDP. PyTorch Cuando `load_state_dict_from_rank0` se establece en `True`, el grupo de paralelismo de tensores que implica el rango 0 tiene ponderaciones cargadas del diccionario de estados original en el rango 0. Cuando se usa [Inicialización diferida de parámetros](model-parallel-core-features-v2-delayed-param-init.md) en el modelo original, solo estos rangos tienen los tensores reales activados CPUs 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. ### Funciones y propiedades util de `torch.sagemaker` **Funciones util de torch.sagemaker** + `torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None`— Inicializa el trabajo de PyTorch entrenamiento con SMP. + `torch.sagemaker.is_initialized() -> bool`: comprueba si el trabajo de entrenamiento 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 serlo`None`, 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 el `device` determinado, si lo 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 módulos al `device` determinado y puede ser recursivo para todos los módulos anidados si se especifica. **Propiedades** `torch.sagemaker.state` contiene 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 particionados, una copia de la entrada del usuario en la configuración de SMP pasada a `torch.sagemaker.init()`. Para obtener más información, consulte [Utilice la biblioteca de paralelismo de SageMaker modelos v2](model-parallel-use-api-v2.md). + `torch.sagemaker.state.rank` (int): rango global para el 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 con `torch.sagemaker.state.tp_process_group`. Al volver a ser nativo PyTorch, vuelve. `None` + `torch.sagemaker.state.tensor_parallel_degree` (int): el grado de paralelismo de tensores, una copia de la entrada del usuario en la configuración de SMP pasada a `torch.sagemaker.init()`. Para obtener más información, consulte [Utilice la biblioteca de paralelismo de SageMaker modelos v2](model-parallel-use-api-v2.md). + `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 de tensores para el dispositivo en el rango de `[0, tp_size)`, determinado por el grado de paralelismo de tensores y el mecanismo de clasificación. + `torch.sagemaker.state.tp_process_group` (`torch.distributed.ProcessGroup`): el grupo de proceso de paralelismo de tensores que incluye todos los dispositivos con el mismo rango en otras dimensiones (por ejemplo, paralelismo y replicación de datos particionados) pero con rangos únicos de paralelismo de tensores. Cuando vuelve a ser nativo PyTorch, regresa`None`. + `torch.sagemaker.state.world_size` (int): el número 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 el SMP v1 APIs y aplicar el SMP v2. APIs 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. [Utilice la biblioteca de paralelismo de SageMaker modelos v2](model-parallel-use-api-v2.md) Para llevar los *modelos* de SMP v1 a SMP v2, en SMP v1 debe 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 comprobación del modelo de Hugging Face Transformers. Luego, en SMP v2, como se explica en[Puntos de comprobación mediante SMP](model-parallel-core-features-v2-checkpoints.md), puedes cargar los puntos de control del modelo Hugging Face Transformers y luego continuar usando el PyTorch punto de control con SMP v2. APIs 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 buscar funciones de traducción disponibles en SMP v1, consulte [Soporte listo para usar para modelos Hugging Face Transformer](model-parallel-extended-features-pytorch-hugging-face.md). Para obtener instrucciones sobre cómo guardar y cargar puntos de comprobación de modelos en SMP v2, consulte [Puntos de comprobación mediante SMP](model-parallel-core-features-v2-checkpoints.md).