La referencia de la biblioteca paralela de SageMaker modelos v2

• 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, vuelve a la PyTorch implementación nativa y API al 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 volver a los casos de PyTorch FSDP uso nativos, si FULL_SHARD es la estrategia que utilizas, se divide en todo el grupo de. GPUs Si HYBRID_SHARD o _HYBRID_SHARD_ZERO2 fue la estrategia, equivale a hybrid_shard_degree 8. Cuando el paralelismo tensorial está habilitado, se fragmenta según lo revisado. hybrid_shard_degree

  • Si se establece en1, vuelve a la PyTorch implementación nativa y, NO_SHARD en el script, API cuando es 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. GPUs Si no lo configuras sharding_strategy en el FSDP script, se anula en. HYBRID_SHARD Si lo estableces_HYBRID_SHARD_ZERO2, se usará sharding_strategy lo que especifiques.

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

• activation_loading_horizon(Entero): un entero que especifica el tipo de horizonte de descarga de activación para. FSDP Es el número máximo de capas descargadas o con puntos de control cuyas entradas pueden estar en la memoria simultáneamente. 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. Tenga en cuenta que al pasar un valor superior a 1 no se habilita automáticamente el paralelismo del contexto; también debe usarlo para incluir el torch.sagemaker.transform API modelo en su guion de entrenamiento. Para obtener más información, consulte Paralelismo de tensores.

• context_parallel_degree(Entero): especifica el grado de paralelismo del contexto. El valor debe estar comprendido entre 1 y y world_size debe estar. <= hybrid_shard_degree El valor predeterminado es 1. Tenga en cuenta que al pasar un valor superior a 1 no se habilita automáticamente el paralelismo de contexto; también debe usarlo para incluir el torch.sagemaker.transform API modelo en su guion de entrenamiento. Para obtener más información, consulte Paralelismo de contexto.

• 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. Tenga en cuenta que pasar un valor superior a 1 no habilita el paralelismo de contexto automáticamente; también debe usarlo para incluir el torch.sagemaker.transform API modelo en su guion de entrenamiento. Para obtener más información, consulte Paralelismo experto.

• random_seed(Entero): un número inicial para las operaciones aleatorias en módulos distribuidos mediante paralelismo SMP tensorial o paralelismo experto. Esta semilla se agrega 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. SMPv2 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

• model(nn.Module): un PyTorch modelo para empaquetar y aplicar la funcionalidad de inicialización retardada de parámetros de la SMP versión 2.

• init_method_using_config(Llamable): si usa la implementación tensor parallel de SMP v2 o es compatibleModelos de Hugging Face Transformer compatibles con el paralelismo SMP tensorial, mantenga este parámetro en el valor predeterminado, que es. None De forma predeterminada, 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 a su script. El siguiente fragmento de código es la init_method_using_config función predeterminada que la SMP versión 2 implementó para. Modelos de Hugging Face Transformer compatibles con el paralelismo SMP tensorial 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. init_method_using_config SMP DelayedParamIniter API

  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 torch.sagemaker.module_util 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.

• 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 PyTorch FSDP clase contenedora. 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 los dispositivos y no en GPU los 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.

• state_dict(dict): obligatorio. El decreto estatal de ahorrar.

• checkpoint_id(str): obligatorio. La ruta de almacenamiento en la que se guardan los puntos de control.

• storage_writer(StorageWriter) - Opcional. Una instancia de StorageWriterin PyTorch para realizar operaciones de escritura. Si no se especifica, se utiliza la configuración predeterminada StorageWriterde.

• planner(SavePlanner) - Opcional. Una instancia de SavePlannerentrada PyTorch. Si no se especifica, se utiliza la configuración por defecto SavePlannerde.

• process_group(ProcessGroup) - Opcional. El grupo de procesos en el que se va a trabajar. SiNone, se utiliza el grupo de procesos predeterminado (global).

• coordinator_rank(int): opcional. El rango del coordinador cuando se desempeñan operadores de comunicación colectiva comoAllReduce.

• 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 fragmentada que se utilizará para guardar los puntos de control. Si no se especifica, se torch.sagemaker.distributed.checkpoint.state_dict_saver.PyTorchDistSaveShardedStrategy utiliza de forma predeterminada.

• wait_error_handling(bool): opcional. Un indicador 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 por la fuerza los planes de todos los rangos, incluso en el caso de un ataque de caché. El valor predeterminado es True.

• s3_region(str): opcional. La región en la que se encuentra el depósito S3. Si no se especifica, la región se deduce decheckpoint_id.

• s3client_config(S3ClientConfig): opcional. La clase de datos que expone los parámetros configurables para el cliente S3. Si no se proporciona, se utiliza la configuración predeterminada de S3 ClientConfig. El part_size parámetro está establecido en 64 MB de forma predeterminada.

• blocking(bool): opcional. SiTrue, esperará 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() - OpcionalProcessGroup. El grupo de procesos en el que se va a operar. Si se establece enNone, se utiliza el grupo de procesos (global) predeterminado.

• Se ha finalizado correctamente una lista que contiene los índices de las llamadas asíncronas.

• state_dict(dict): obligatorio. El decreto estatal de ahorrar.

• checkpoint_id(str): obligatorio. La ruta de almacenamiento en la que se guardan los puntos de control.

• storage_writer(StorageWriter) - Opcional. Una instancia de StorageWriterin PyTorch para realizar operaciones de escritura. Si no se especifica, se utiliza la configuración predeterminada StorageWriterde.

• planner(SavePlanner) - Opcional. Una instancia de SavePlannerentrada PyTorch. Si no se especifica, se utiliza la configuración por defecto SavePlannerde.

• process_group(ProcessGroup) - Opcional. El grupo de procesos en el que se va a trabajar. SiNone, se utiliza el grupo de procesos predeterminado (global).

• coordinator_rank(int): opcional. El rango del coordinador cuando se desempeñan operadores de comunicación colectiva comoAllReduce.

• wait_error_handling(bool): opcional. Un indicador 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 por la fuerza los planes de todos los rangos, incluso en el caso de un ataque de caché. El valor predeterminado es True.

• s3_region(str): opcional. La región en la que se encuentra el depósito S3. Si no se especifica, la región se deduce decheckpoint_id.

• s3client_config(S3ClientConfig): opcional. La clase de datos que expone los parámetros configurables para el cliente S3. Si no se proporciona, se utiliza la configuración predeterminada de S3 ClientConfig. El part_size parámetro está establecido en 64 MB de forma predeterminada.

• state_dict(dict): obligatorio. La state_dict carga superior.

• checkpoint_id(str) - Necesario. El ID de un punto de control. 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 valores clave.

• storage_reader(StorageReader) - Opcional. Una instancia de StorageReaderin PyTorch para realizar operaciones de lectura. Si no se especifica, los puntos de control distribuidos deducirán automáticamente el lector en función del. checkpoint_id Si también checkpoint_id lo esNone, se generará un error de excepción.

• planner(StorageReader) - Opcional. Una instancia de LoadPlannerentrada PyTorch. Si no se especifica, se utiliza la configuración predeterminada LoadPlannerde.

• check_keys_matched(bool): opcional. Si está activado, comprueba si las state_dict claves de todos los rangos coinciden utilizandoAllGather.

• s3_region(str): opcional. La región en la que se encuentra el depósito S3. Si no se especifica, la región se deduce decheckpoint_id.

• s3client_config(S3ClientConfig): opcional. La clase de datos que expone los parámetros configurables para el cliente S3. Si no se proporciona, se utiliza la configuración predeterminada de S3 ClientConfig. El part_size parámetro está establecido en 64 MB de forma predeterminada.

• smp_moe(Booleano): si se debe utilizar la SMP implementación -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ñade al rango paralelo 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.

• 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 en None (que también es el valor por defecto), el factor de escala es1 / sqrt(attention_head_size). El valor predeterminado es None.

• triton_flash_attention(bool): si se aprueba, se utiliza la implementación Triton de la atención flash. Esto es necesario para admitir Attention with Linear Biases (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, activa Attention with Linear Biases (ALiBi) con la máscara proporcionada. Cuando se usaALiBi, 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

• forward(self, qkv, attn_mask=None, causal=False, cast_dtype=None, layout="b h s d")— Una función PyTorch modular normal. Cuando module(x) se 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 en función de la posición dtype anteriorattn. Esto es útil para implementaciones como el modelo Hugging Face Transformer GPT -NeoX, que tiene q y k con incrustaciones rotativas posteriores. 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.

• 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.

• forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d")— Una función PyTorch de módulo normal. Cuando module(x) se 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 al diseño de los qkv tensores pasados, de modo que se puedan aplicar las transformaciones adecuadas. attn El valor predeterminado es "b h s d".

• config— Una FlashAttention configuración para el modelo Llama.

• 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.

• model(torch.nn.Module): un modelo Modelos de Hugging Face Transformer compatibles con el paralelismo SMP tensorial 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 SMP transformador. 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 el 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 configurarlo True en el FSDP contenedor sync_module_states para obtener estos pesos del primer grupo de tensores paralelos a todos los demás procesos. Con esta opción activada, la SMP biblioteca carga el diccionario de estados del modelo original. La SMP biblioteca 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.

funciones de utilidad torch.sagemaker

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

• 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 se inicializa el trabajoSMP, algunas de las propiedades no son relevantes y pasan a serNone, 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 with. SMP 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 a la que se ha pasado. SMP torch.sagemaker.init() Para obtener más información, consulte Utilice 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 a la SMP que se ha pasado. torch.sagemaker.init() Para obtener más información, consulte Utilice 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.