Référence de la bibliothèque SageMaker de parallélisme des modèles v2

• hybrid_shard_degree (nombre entier) : spécifie un degré de parallélisme partitionné. La valeur doit être un nombre entier compris entre 0 et world_size. La valeur par défaut est 0.

  • S’il est défini sur 0, il revient à l’implémentation native de PyTorch et à l’API dans le script lorsque la valeur de tensor_parallel_degree est 1. Sinon, il calcule la valeur hybrid_shard_degree la plus grande possible sur la base de tensor_parallel_degree et de world_size. En cas de retour aux cas d’utilisation natifs de PyTorch FSDP, si FULL_SHARD est la stratégie que vous utilisez, elle se partitionne sur l’ensemble du cluster de GPU. Si HYBRID_SHARD ou _HYBRID_SHARD_ZERO2 était la stratégie, cela équivaut à un hybrid_shard_degree de 8. Lorsque le parallélisme de tenseur est activé, il se partitionne en fonction du hybrid_shard_degree révisé.

  • S’il est défini sur 1, il revient à l’implémentation native de PyTorch et à l’API pour NO_SHARD dans le script lorsque tensor_parallel_degree est défini sur 1. Sinon, cela équivaut à NO_SHARD dans n’importe quel groupe de parallélisme de tenseur donné.

  • S’il est défini sur un entier compris entre 2 et world_size, le partitionnement s’effectue entre le nombre de GPU spécifié. Si vous ne configurez pas le paramètre sharding_strategy dans le script FSDP, il est remplacé par HYBRID_SHARD. Si vous configurez _HYBRID_SHARD_ZERO2, le paramètre sharding_strategy que vous spécifiez est utilisé.

• sm_activation_offloading (booléen) : spécifie s’il faut activer l’implémentation du déchargement d’activation SMP. Si la valeur est False, le déchargement utilise l’implémentation native de PyTorch. Si la valeur est True, il utilise l’implémentation de déchargement d’activation SMP. Vous devez également utiliser le wrapper de déchargement d’activation PyTorch (torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper) dans votre script. Pour en savoir plus, consultez Déchargement d’activation. La valeur par défaut est True.

• activation_loading_horizon (nombre entier) : nombre entier spécifiant le type d’horizon de déchargement d’activation pour FSDP. Il s’agit du nombre maximum de couches contrôlées ou déchargées dont les entrées peuvent se trouver simultanément dans la mémoire du GPU. Pour en savoir plus, consultez Déchargement d’activation. La valeur d’entrée doit être un nombre entier positif. La valeur par défaut est 2.

• fsdp_cache_flush_warnings (booléen) : détecte et avertit en cas de vidage du cache dans le gestionnaire de mémoire PyTorch, car cela peut dégrader les performances de calcul. La valeur par défaut est True.

• allow_empty_shards (booléen) : s’il faut autoriser les partitions vides lors du partitionnement des tenseurs si le tenseur n’est pas divisible. Il s’agit d’un correctif expérimental en cas de crash aux points de contrôle dans certains scénarios. La désactivation de cette option revient au comportement original de PyTorch. La valeur par défaut est False.

• tensor_parallel_degree (nombre entier) : spécifie un degré de parallélisme de tenseur. La valeur doit être comprise entre 1 et world_size. La valeur par défaut est 1. Notez que le fait de transmettre une valeur supérieure à 1 n’active pas automatiquement le parallélisme de contexte. Vous devez également utiliser l’API torch.sagemaker.transform pour encapsuler le modèle dans votre script d’entraînement. Pour en savoir plus, consultez Parallélisme de tenseur.

• context_parallel_degree (nombre entier) : spécifie le degré de parallélisme de contexte. La valeur doit être comprise entre 1 et world_size, et doit être <= hybrid_shard_degree. La valeur par défaut est 1. Notez que le fait de transmettre une valeur supérieure à 1 n’active pas automatiquement le parallélisme de contexte. Vous devez également utiliser l’API torch.sagemaker.transform pour encapsuler le modèle dans votre script d’entraînement. Pour en savoir plus, consultez Parallélisme de contexte.

• expert_parallel_degree (nombre entier) : spécifie un degré de parallélisme expert. La valeur doit être comprise entre 1 et world_size. La valeur par défaut est 1. Notez que le fait de transmettre une valeur supérieure à 1 n’active pas automatiquement le parallélisme de contexte. Vous devez également utiliser l’API torch.sagemaker.transform pour encapsuler le modèle dans votre script d’entraînement. Pour en savoir plus, consultez Parallélisme expert.

• random_seed (nombre entier) : valeur initiale pour les opérations aléatoires dans les modules distribués par le parallélisme de tenseur ou le parallélisme expert SMP. Cette graine est ajoutée aux rangs de parallélisme de tenseur ou expert pour définir la graine réelle de chaque rang. Celle-ci est unique pour chaque rang de parallélisme de tenseur ou expert. SMP v2 garantit que le nombre aléatoire généré entre les rangs de parallélisme de tenseur et expert correspond respectivement aux cas de non-parallélisme de tenseur et expert.

• model (nn.Module) : modèle PyTorch pour encapsuler et appliquer la fonctionnalité d’initialisation différée des paramètres de SMP v2.

• init_method_using_config (appelable) : si vous utilisez l’implémentation du parallélisme de tenseur SMP v2 ou les Modèles de transformeur Hugging Face compatibles avec le parallélisme de contexte SMP pris en charge, conservez la valeur None, qui est celle par défaut pour ce paramètre. Par défaut, l’API DelayedParamIniter découvre comment initialiser correctement le modèle donné. Pour tous les autres modèles, vous devez créer une fonction personnalisée d’initialisation de paramètres et l’ajouter à votre script. L’extrait de code suivant est la fonction init_method_using_config par défaut implémentée par SMP v2 pour les Modèles de transformeur Hugging Face compatibles avec le parallélisme de contexte SMP. Utilisez l’extrait de code suivant comme référence pour créer votre propre fonction de configuration d’initialisation, l’ajouter à votre script et la transmettre au paramètre init_method_using_config de l’API DelayedParamIniter 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)

  Pour plus d’informations sur les fonctions torch.sagemaker.module_util de l’extrait de code précédent, consultez Propriétés et fonctions utilitaires torch.sagemaker.

• verbose (booléen) : s’il faut activer une journalisation plus détaillée lors de l’initialisation et de la validation. La valeur par défaut est False.

• get_param_init_fn() : renvoie la fonction d’initialisation des paramètres que vous pouvez transmettre à l’argument param_init_fn de la classe de wrapper PyTorch FSDP.

• get_post_param_init_fn() : renvoie la fonction d’initialisation des paramètres que vous pouvez transmettre à l’argument post_param_init_fn de la classe de wrapper PyTorch FSDP. Cela est nécessaire lorsqu’il existe des poids liés dans le modèle. Le modèle doit implémenter la méthode tie_weights. Pour plus d’informations, consultez les notes sur les poids liés dans Initialisation différée des paramètres.

• count_num_params (module: nn.Module, *args: Tuple[nn.Parameter]) : suit le nombre de paramètres initialisés par la fonction d’initialisation des paramètres. Cela permet d’implémenter la méthode validate_params_and_buffers_inited suivante. Il n’est généralement pas nécessaire d’appeler cette fonction de manière explicite, car la méthode validate_params_and_buffers_inited appelle implicitement cette méthode dans le système dorsal.

• validate_params_and_buffers_inited (enabled: bool=True) : il s’agit d’un gestionnaire de contexte qui permet de valider que le nombre de paramètres initialisés correspond au nombre total de paramètres du modèle. Cela confirme également que tous les paramètres et tampons se trouvent désormais sur des dispositifs GPU plutôt que sur des méta-dispositifs. Il génère des AssertionErrors si ces conditions ne sont pas satisfaites. Ce gestionnaire de contexte est uniquement facultatif et vous n’êtes pas obligé de l’utiliser pour initialiser les paramètres.

• state_dict (dict) : obligatoire. Le dictionnaire d’état vers lequel enregistrer.

• checkpoint_id (str) : obligatoire. Le chemin de stockage où enregistrer les points de contrôle.

• storage_writer (StorageWriter) : facultatif. Instance StorageWriter dans PyTorch pour effectuer des opérations d’écriture. Si aucune n’est spécifiée, la configuration par défaut StorageWriter est utilisée.

• planner (SavePlanner) : facultatif. Instance SavePlanner dans PyTorch. Si aucune n’est spécifiée, la configuration par défaut SavePlanner est utilisée.

• process_group (ProcessGroup) : facultatif. Le groupe de processus sur lequel travailler. Si la valeur None est spécifiée, le groupe de processus (global) est utilisé par défaut.

• coordinator_rank (int) : facultatif. Le rang du coordinateur lors de l’exécution d’opérateurs de communication collective tels que AllReduce.

• queue (AsyncRequestQueue) : facultatif. Le planificateur asynchrone à utiliser. Par défaut, il prend le paramètre global DEFAULT_ASYNC_REQUEST_QUEUE.

• sharded_strategy (PyTorchDistSaveShardedStrategy) : facultatif. La stratégie partitionnée à utiliser pour enregistrer les points de contrôle. Si vous n’en spécifiez aucune, torch.sagemaker.distributed.checkpoint.state_dict_saver.PyTorchDistSaveShardedStrategy est utilisée par défaut.

• wait_error_handling (booléen) : facultatif. Indicateur spécifiant s’il faut attendre que tous les rangs aient terminé de traiter les erreurs. La valeur par défaut est True.

• force_check_all_plans (booléen) : facultatif. Indicateur qui détermine s’il convient de synchroniser de force les plans entre les rangs, même en cas d’accès au cache. La valeur par défaut est True.

• s3_region (str) : facultatif. Région où se trouve le compartiment S3. Si ce paramètre n’est pas spécifié, la région est déterminée à partir du checkpoint_id.

• s3client_config (S3ClientConfig) : facultatif. Classe de données exposant les paramètres configurables pour le client S3. Si la classe n’est pas fournie, la configuration par défaut de S3ClientConfig est utilisée. Par défaut, le paramètre part_size est défini sur 64 Mo.

• blocking (booléen) : facultatif. Si la valeur est True, il attendra que toutes les demandes actives soient terminées. Dans le cas contraire, il ne finalise que les demandes asynchrones déjà terminées. La valeur par défaut est True.

• process_group (ProcessGroup) : facultatif. Groupe de processus sur lequel travailler. Si la valeur None est spécifiée, le groupe de processus (global) est utilisé par défaut.

• Une liste contenant les indices des appels asynchrones finalisés avec succès.

• state_dict (dict) : obligatoire. Le dictionnaire d’état vers lequel enregistrer.

• checkpoint_id (str) : obligatoire. Le chemin de stockage où enregistrer les points de contrôle.

• storage_writer (StorageWriter) : facultatif. Instance StorageWriter dans PyTorch pour effectuer des opérations d’écriture. Si aucune n’est spécifiée, la configuration par défaut StorageWriter est utilisée.

• planner (SavePlanner) : facultatif. Instance SavePlanner dans PyTorch. Si aucune n’est spécifiée, la configuration par défaut SavePlanner est utilisée.

• process_group (ProcessGroup) : facultatif. Le groupe de processus sur lequel travailler. Si la valeur None est spécifiée, le groupe de processus (global) est utilisé par défaut.

• coordinator_rank (int) : facultatif. Le rang du coordinateur lors de l’exécution d’opérateurs de communication collective tels que AllReduce.

• wait_error_handling (booléen) : facultatif. Indicateur spécifiant s’il faut attendre que tous les rangs aient terminé de traiter les erreurs. La valeur par défaut est True.

• force_check_all_plans (booléen) : facultatif. Indicateur qui détermine s’il convient de synchroniser de force les plans entre les rangs, même en cas d’accès au cache. La valeur par défaut est True.

• s3_region (str) : facultatif. Région où se trouve le compartiment S3. Si ce paramètre n’est pas spécifié, la région est déterminée à partir du checkpoint_id.

• s3client_config (S3ClientConfig) : facultatif. Classe de données exposant les paramètres configurables pour le client S3. Si la classe n’est pas fournie, la configuration par défaut de S3ClientConfig est utilisée. Par défaut, le paramètre part_size est défini sur 64 Mo.

• state_dict (dict) : obligatoire. Le state_dict à charger.

• checkpoint_id (str) : obligatoire. L’ID d’un point de contrôle. La signification du checkpoint_id dépend du stockage. Il peut s’agir d’un chemin d’accès à un dossier ou à un fichier. Il peut également s’agir d’une clé si le stockage est un stockage clé-valeur.

• storage_reader (StorageReader) : facultatif. Instance StorageReader dans PyTorch pour effectuer des opérations de lecture. Si aucune n’est spécifié, le point de contrôle distribué déterminera automatiquement le lecteur en fonction du checkpoint_id. Si la valeur du checkpoint_id est également None, une erreur d’exception est générée.

• planner (StorageReader) : facultatif. Instance LoadPlanner dans PyTorch. Si aucune n’est spécifiée, la configuration par défaut LoadPlanner est utilisée.

• check_keys_matched (booléen) : facultatif. S’il est activé, ce paramètre vérifie à l’aide de AllGather si les clés state_dict de tous les rangs correspondent.

• s3_region (str) : facultatif. Région où se trouve le compartiment S3. Si ce paramètre n’est pas spécifié, la région est déterminée à partir du checkpoint_id.

• s3client_config (S3ClientConfig) : facultatif. Classe de données exposant les paramètres configurables pour le client S3. Si la classe n’est pas fournie, la configuration par défaut de S3ClientConfig est utilisée. Par défaut, le paramètre part_size est défini sur 64 Mo.

• smp_moe (booléen) : s’il faut utiliser l’implémentation SMP d’un MoE. La valeur par défaut est True.

• random_seed (nombre entier) : nombre graine pour les opérations aléatoires dans les modules distribués par le parallélisme expert. Cette graine est ajoutée au rang de parallélisme expert pour définir la graine réelle de chaque rang. Celle-ci est unique pour chaque rang de parallélisme expert. La valeur par défaut est 12345.

• moe_load_balancing (chaîne) : spécifiez le type d’équilibrage de charge du routeur MoE. Les options valides sont aux_loss, sinkhorn, balanced et none. La valeur par défaut est sinkhorn.

• global_token_shuffle (booléen) : s’il faut répartir les jetons entre les rangs EP au sein d’un même groupe EP. La valeur par défaut est False.

• moe_all_to_all_dispatcher (booléen) : s’il faut utiliser un répartiteur tous à tous pour les communications MoE. La valeur par défaut est True.

• moe_aux_loss_coeff (valeur flottante) : coefficient de perte d’équilibrage de charge auxiliaire. La valeur par défaut est 0.001.

• moe_z_loss_coeff (valeur flottante) : coefficient de perte z. La valeur par défaut est 0.001.

• attention_dropout_prob (valeur flottante) : probabilité d’abandon à appliquer à l’attention. La valeur par défaut est 0.0.

• scale (valeur flottante) : si transmis, ce facteur de mise à l’échelle est appliqué pour softmax. S’il est défini sur None (qui est aussi la valeur par défaut), le facteur de mise à l’échelle est 1 / sqrt(attention_head_size). La valeur par défaut est None.

• triton_flash_attention (booléen) : si transmis, l’implémentation de FlashAttention par Triton est utilisée. Cela est nécessaire pour soutenir Attention with Linear Biases (ALiBi) (voir le paramètre use_alibi suivant). Cette version du noyau ne prend pas en charge l’abandon. La valeur par défaut est False.

• use_alibi (booléen) : si transmis, active Attention with Linear Biases (ALiBi) à l’aide du masque fourni. Lors de l’utilisation d’ALiBi, un masque d’attention doit être préparé comme suit. La valeur par défaut est 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") : fonction standard du module PyTorch. Lorsqu’un module(x) est appelé, SMP exécute automatiquement cette fonction.

  • qkv : torch.Tensor de forme (batch_size x seqlen x (3 x num_heads) x head_size) ou (batch_size, (3 x num_heads) x seqlen x head_size), un tuple de torch.Tensors, dont la forme de chacun peut être (batch_size x seqlen x num_heads x head_size) ou (batch_size x num_heads x seqlen x head_size). Un argument de mise en page approprié doit être transmis en fonction de la forme.

  • attn_mask : torch.Tensor du formulaire suivant (batch_size x 1 x 1 x seqlen). Pour activer ce paramètre de masque d’attention, la configuration triton_flash_attention=True et use_alibi=True est nécessaire. Pour découvrir comment générer un masque d’attention à l’aide de cette méthode, consultez les exemples de code dans FlashAttention. La valeur par défaut est None.

  • causal : lorsque ce paramètre est défini sur False, qui est la valeur par défaut de l’argument, aucun masque n’est appliqué. Lorsqu’il est défini sur True, la méthode forward utilise le masque triangulaire inférieur standard. La valeur par défaut est False.

  • cast_dtype : lorsque défini sur un dtype particulier, convertit les tenseurs qkv sur ce dtype avant attn. Cela est utile pour des implémentations telles que le modèle de transformeur Hugging Face GPT-NeoX, qui a q et k avec fp32 après des vectorisations rotatives. Si ce paramètre est défini sur None, aucune conversion n’est appliquée. La valeur par défaut est None.

  • layout (chaîne) : les valeurs disponibles sont b h s d ou b s h d. Ce paramètre doit être défini sur la disposition des tenseurs qkv transmis, afin que les transformations appropriées puissent être appliquées pour attn. La valeur par défaut est b h s d.

• attention_dropout_prob (valeur flottante) : probabilité d’abandon à appliquer à l’attention. La valeur par défaut est 0.0.

• scale (valeur flottante) : si transmis, ce facteur de mise à l’échelle est appliqué pour softmax. Si défini sur None, 1 / sqrt(attention_head_size) est utilisé comme facteur de mise à l’échelle. La valeur par défaut est None.

• forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d") : fonction standard du module PyTorch. Lorsqu’un module(x) est appelé, SMP exécute automatiquement cette fonction.

  • q : torch.Tensor du formulaire suivant (batch_size x seqlen x num_heads x head_size) ou (batch_size x num_heads x seqlen x head_size). Un argument de mise en page approprié doit être transmis en fonction de la forme.

  • kv : torch.Tensor de forme (batch_size x seqlen x (2 x num_heads) x head_size) ou (batch_size, (2 x num_heads) x seqlen x head_size), ou un tuple de deux torch.Tensor, dont la forme de chacun peut être (batch_size x seqlen x num_heads x head_size) ou (batch_size x num_heads x seqlen x head_size). Un argument layout approprié doit aussi être transmis en fonction de la forme.

  • causal : lorsque ce paramètre est défini sur False, qui est la valeur par défaut de l’argument, aucun masque n’est appliqué. Lorsqu’il est défini sur True, la méthode forward utilise le masque triangulaire inférieur standard. La valeur par défaut est False.

  • cast_dtype : lorsque défini sur un dtype particulier, convertit les tenseurs qkv sur ce dtype avant attn. Cela est utile pour des implémentations telles que le modèle de transformeur Hugging Face GPT-NeoX, qui a q,k et fp32 après des vectorisations rotatives. Si ce paramètre est défini sur None, aucune conversion n’est appliquée. La valeur par défaut est None.

  • layout (chaîne) : les valeurs disponibles sont "b h s d" ou "b s h d". Ce paramètre doit être défini sur la disposition des tenseurs qkv transmis, afin que les transformations appropriées puissent être appliquées pour attn. La valeur par défaut est "b h s d".

• config : configuration FlashAttention pour le modèle Llama.

• forward(self, hidden_states, attention_mask, position_ids, past_key_value, output_attentions, use_cache)

  • hidden_states (torch.Tensor) : états cachés d’un tenseur sous la forme (batch_size x seq_len x num_heads x head_size).

  • attention_mask (torch.LongTensor) : masque pour éviter de calculer l’attention sur les indices de jetons de remplissage sous la forme (batch_size x seqlen). La valeur par défaut est None.

  • position_ids (torch.LongTensor) : lorsque ce paramètre n’est pas défini sur None, il l’est sous la forme (batch_size x seqlen), ce qui montre les indices de position de chaque jeton de séquence d’entrée dans les vectorisations de position. La valeur par défaut est None.

  • past_key_value (cache) : états masqués précalculés (clé et valeurs dans les blocs d’auto-attention et dans les blocs d’attention croisée). La valeur par défaut est None.

  • output_attentions (booléen) : indique s’il faut renvoyer les tenseurs d’attention de toutes les couches d’attention. La valeur par défaut est False.

  • use_cache (booléen) : indique s’il faut renvoyer les états past_key_values des valeurs clés. La valeur par défaut est False.

• model (torch.nn.Module) : un des Modèles de transformeur Hugging Face compatibles avec le parallélisme de contexte SMP pour transformer et appliquer la caractéristique de parallélisme de tenseur de la bibliothèque SMP.

• device (torch.device) : si transmis, un nouveau modèle est créé sur ce dispositif. Si le module d’origine possède un paramètre sur le méta-dispositif (consultez Initialisation différée des paramètres), le module transformé sera également créé sur le méta-dispositif, en ignorant l’argument transmis ici. La valeur par défaut est None.

• dtype (torch.dtype) : si transmis, définit ceci comme gestionnaire de contexte dtype pour la création du modèle, et crée un modèle avec ce dtype. Cela n’est généralement pas nécessaire, car nous voulons créer le modèle avec fp32 lors de l’utilisation de MixedPrecision, et fp32 est le dtype par défaut dans PyTorch. La valeur par défaut est None.

• config (dict) : dictionnaire pour configurer le transformeur SMP. La valeur par défaut est None.

• load_state_dict_from_rank0 (booléen) : par défaut, ce module crée une nouvelle instance du modèle avec de nouveaux poids. Lorsque cet argument est défini sur True, SMP essaie de charger le dictionnaire d’état du modèle PyTorch original depuis le rang 0 vers le modèle transformé pour le groupe de parallélisme de tenseur dont fait partie le rang 0. Lorsque ce paramètre est défini sur True, le rang 0 ne peut avoir aucun paramètre sur le méta-dispositif. Seul le premier groupe de parallélisme de tenseur renseigne les poids à partir du rang 0 après cet appel de transformation. Vous devez définir sync_module_states sur True dans le wrapper FSDP pour obtenir ces poids du premier groupe de parallélisme de tenseur pour tous les autres processus. Lorsque ceci est activé, la bibliothèque SMP charge le dictionnaire d’état à partir du modèle d’origine. La bibliothèque SMP prend le state_dict du modèle avant la transformation, le convertit pour qu’il corresponde à la structure du modèle transformé, le partitionne pour chaque rang de parallélisme de tenseur, communique cet état du rang 0 aux autres rangs du groupe de parallélisme de tenseur dont fait partie le rang 0, puis le charge. La valeur par défaut est False.

• cp_comm_type (str) : détermine l’implémentation du parallélisme de contexte et n’est applicable que lorsque context_parallel_degree est supérieur à 1. Les valeurs disponibles pour ce paramètre sont p2p et all_gather. L’implémentation p2p utilise des appels d’envoi/de réception peer-to-peer pour l’accumulation de tenseurs clé-valeur (KV) pendant le calcul de l’attention, qui s’exécutent de façon asynchrone et permettent à la communication de chevaucher le calcul. D’autre part, l’implémentation all_gather utilise l’opération de communication collective AllGather pour l’accumulation de tenseurs KV. La valeur par défaut est "p2p".

Fonctions utilitaires torch.sagemaker

• torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None : initialise la tâche d’entraînement PyTorch avec SMP.

• torch.sagemaker.is_initialized() -> bool : vérifie si la tâche d’entraînement est initialisée avec SMP. Lorsque vous revenez à PyTorch natif alors que la tâche est initialisée avec SMP, certaines propriétés ne sont pas pertinentes et indiquent None, comme illustré dans la liste des propriétés suivante.

• torch.sagemaker.utils.module_utils.empty_module_params(module: nn.Module, device: Optional[torch.device] = None, recurse: bool = False) -> nn.Module : crée des paramètres vides sur les device donnés, le cas échéant, et peut être récursif pour tous les modules imbriqués si spécifié.

• torch.sagemaker.utils.module_utils.move_buffers_to_device(module: nn.Module, device: torch.device, recurse: bool = False) -> nn.Module : déplace les tampons des modules vers le device spécifié, et peut être récursif pour tous les modules imbriqués si spécifié.

Propriétés

torch.sagemaker.state possède plusieurs propriétés utiles après l’initialisation de SMP avec torch.sagemaker.init.

• torch.sagemaker.state.hybrid_shard_degree (int) : degré de parallélisme partitionné des données, une copie de l’entrée utilisateur dans la configuration SMP transmise à torch.sagemaker.init(). Pour en savoir plus, consultez Utilisation de la bibliothèque SageMaker de parallélisme des modèles v2.

• torch.sagemaker.state.rank(int) : rang global du dispositif, dans la plage [0, world_size).

• torch.sagemaker.state.rep_rank_process_group (torch.distributed.ProcessGroup) : groupe de processus comprenant tous les appareils avec le même rang de réplication. Notez la différence subtile, mais fondamentale, avec torch.sagemaker.state.tp_process_group. En cas de retour à PyTorch natif, il renvoie None.

• torch.sagemaker.state.tensor_parallel_degree (int) : degré de parallélisme de tenseur, une copie de l’entrée utilisateur dans la configuration SMP transmise à torch.sagemaker.init(). Pour en savoir plus, consultez Utilisation de la bibliothèque SageMaker de parallélisme des modèles v2.

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

• torch.sagemaker.state.tp_rank (int) : rang de parallélisme de tenseur pour le dispositif dans la plage [0, tp_size), déterminé par le degré de parallélisme de tenseur et le mécanisme de classement.

• torch.sagemaker.state.tp_process_group (torch.distributed.ProcessGroup) : groupe de processus de parallélisme de tenseur comprenant tous les dispositifs ayant le même rang dans d’autres dimensions (par exemple, réplication et parallélisme partitionné des données), mais des rangs de parallélisme de tenseur uniques. En cas de retour à PyTorch natif, il renvoie None.

• torch.sagemaker.state.world_size (int) : nombre total de dispositifs utilisés pendant l’entraînement.