Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra. # La référence de la librairie SageMaker model parallel v2 Les références suivantes concernent la bibliothèque SageMaker model parallel library v2 (SMP v2). **Topics** + [Paramètres de configuration des caractéristiques principales de SMP v2](#distributed-model-parallel-v2-reference-init-config) + [Référence pour le package `torch.sagemaker` SMP v2](#model-parallel-v2-torch-sagemaker-reference) + [Mise à niveau de SMP v1 vers SMP v2](#model-parallel-v2-upgrade-from-v1) ## Paramètres de configuration des caractéristiques principales de SMP v2 Vous trouverez ci-dessous la liste complète des paramètres permettant d’activer et de configurer les [Principales fonctionnalités de la bibliothèque de parallélisme de SageMaker modèles v2](model-parallel-core-features-v2.md). Ils doivent être écrits au format JSON et transmis à l' PyTorch estimateur dans le SDK SageMaker Python ou enregistrés sous forme de fichier JSON pour. 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` (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' PyTorchimplémentation native et à l'API du script lorsque la valeur `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`. Lorsque vous revenez aux cas d'utilisation natifs du PyTorch FSDP, si `FULL_SHARD` c'est la stratégie que vous utilisez, elle se répercute sur l'ensemble du cluster de. GPUs 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' PyTorchimplémentation native et `NO_SHARD` à l'API pour le script, quand `tensor_parallel_degree` est égal à 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 se produit sur le nombre spécifié de GPUs. 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`False`, le déchargement utilise l' PyTorch implémentation native. Si la valeur est `True`, il utilise l’implémentation de déchargement d’activation SMP. Vous devez également utiliser le wrapper PyTorch d'activation (`torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper`) dans votre script. Pour en savoir plus, veuillez consulter la section [Déchargement d’activation](model-parallel-core-features-v2-pytorch-activation-offloading.md). 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](model-parallel-core-features-v2-pytorch-activation-offloading.md). 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 PyTorch mémoire, 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 PyTorch comportement d'origine. 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`](#model-parallel-v2-torch-sagemaker-reference-transform) pour encapsuler le modèle dans votre script d’entraînement. Pour en savoir plus, consultez [Parallélisme de tenseur](model-parallel-core-features-v2-tensor-parallelism.md). + `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`](#model-parallel-v2-torch-sagemaker-reference-transform) pour encapsuler le modèle dans votre script d’entraînement. Pour en savoir plus, consultez [Parallélisme de contexte](model-parallel-core-features-v2-context-parallelism.md). + `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`](#model-parallel-v2-torch-sagemaker-reference-transform) pour encapsuler le modèle dans votre script d’entraînement. Pour en savoir plus, consultez [Parallélisme expert](model-parallel-core-features-v2-expert-parallelism.md). + `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 parallèle aux tenseurs et parallèles aux experts correspond respectivement aux cas et. non-tensor-parallelism non-expert-parallelism ## Référence pour le package `torch.sagemaker` SMP v2 Cette section est une référence pour le package `torch.sagemaker` fourni par 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) + [Propriétés et fonctions utilitaires `torch.sagemaker`](#model-parallel-v2-torch-sagemaker-reference-utils) ### `torch.sagemaker.delayed_param.DelayedParamIniter` Une API à appliquer [Initialisation différée des paramètres](model-parallel-core-features-v2-delayed-param-init.md) à un PyTorch modèle. ``` class torch.sagemaker.delayed_param.DelayedParamIniter( model: nn.Module, init_method_using_config : Callable = None, verbose: bool = False, ) ``` **Paramètres** + `model`(`nn.Module`) — Un PyTorch modèle 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](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) 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](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models). 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`](#model-parallel-v2-torch-sagemaker-reference-utils). + `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`. **Méthodes** + `get_param_init_fn()`— Renvoie la fonction d'initialisation des paramètres que vous pouvez transmettre à l'`param_init_fn`argument de la classe wrapper PyTorch FSDP. + `get_post_param_init_fn()`— Renvoie la fonction d'initialisation des paramètres que vous pouvez transmettre à l'`post_param_init_fn`argument de la classe 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](model-parallel-core-features-v2-delayed-param-init.md). + `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. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save` API d’entrée pour l’enregistrement asynchrone. Utilisez cette méthode pour enregistrer un `state_dict` de façon asynchrone vers le `checkpoint_id` spécifié. ``` 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: ``` **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. Une instance 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 pour effectuer des opérations d'écriture. Si aucune n’est spécifiée, la configuration par défaut [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter) est utilisée. + `planner`(SavePlanner) - Facultatif. Un exemple d'[https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)in PyTorch. Si aucune n’est spécifiée, la configuration par défaut [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.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 elle n'est pas fournie, la configuration par défaut de [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) est utilisée. Par défaut, le paramètre `part_size` est défini sur 64 Mo. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls` Cette fonction permet à un processus d’entraînement de surveiller plusieurs demandes asynchrones à effectuer. ``` def maybe_finalize_async_calls( blocking=True, process_group=None ) -> List[int]: ``` **Paramètres** + `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. **Renvoie** + Une liste contenant les indices des appels asynchrones finalisés avec succès. ### `torch.sagemaker.distributed.checkpoint.state_dict_saver.save` Utilisez cette méthode pour enregistrer un `state_dict` de façon synchrone vers le `checkpoint_id` spécifié. ``` 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: ``` **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. Une instance 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 pour effectuer des opérations d'écriture. Si aucune n’est spécifiée, la configuration par défaut [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.StorageWriter) est utilisée. + `planner`(SavePlanner) - Facultatif. Un exemple d'[https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner)in PyTorch. Si aucune n’est spécifiée, la configuration par défaut [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.SavePlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.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 elle n'est pas fournie, la configuration par défaut de [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) est utilisée. Par défaut, le paramètre `part_size` est défini sur 64 Mo. ### `torch.sagemaker.distributed.checkpoint.state_dict_loader.load` Chargez le dictionnaire d’état d’un modèle distribué (`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: ``` **Paramètres** + `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. Une instance 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 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. Un exemple d'[https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner)in PyTorch. Si aucune n’est spécifiée, la configuration par défaut [https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.LoadPlanner](https://pytorch.org/docs/stable/distributed.checkpoint.html#torch.distributed.checkpoint.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 elle n'est pas fournie, la configuration par défaut de [S3 ClientConfig](https://github.com/awslabs/s3-connector-for-pytorch/blob/main/s3torchconnector/src/s3torchconnector/_s3client/s3client_config.py#L7) est utilisée. Par défaut, le paramètre `part_size` est défini sur 64 Mo. ### `torch.sagemaker.moe.moe_config.MoEConfig` Une classe de configuration pour configurer l'implémentation SMP de Mixture-of-Experts (MoE). Vous pouvez spécifier les valeurs de configuration MoE par le biais de cette classe et les transmettre à l’appel d’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). Pour en savoir plus sur l’utilisation de cette classe pour l’entraînement des modèles MoE, consultez [Parallélisme expert](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 ) ``` **Paramètres** + `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`(Boolean) - S'il faut utiliser le all-to-all répartiteur pour les communications dans 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`. ### `torch.sagemaker.nn.attn.FlashSelfAttention` API pour utiliser [FlashAttention](model-parallel-core-features-v2-flashattention.md) avec 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, ) ``` **Paramètres** + `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 `use_alibi` paramètre suivant). Cette version du noyau ne prend pas en charge l’abandon. La valeur par défaut est `False`. + `use_alibi`(bool) — S'il est passé, il active Attention with Linear Biases (ALiBi) à l'aide du masque fourni. Lors de l'utilisation de ALi Bi, il faut un masque d'attention 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 ``` **Méthodes** + `forward(self, qkv, attn_mask=None, causal=False, cast_dtype=None, layout="b h s d")`— Une fonction de PyTorch module normale. 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](model-parallel-core-features-v2-flashattention.md). 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`. **Renvoie** Un seul `torch.Tensor` sous la forme `(batch_size x num_heads x seq_len x head_size)`. ### `torch.sagemaker.nn.attn.FlashGroupedQueryAttention` API pour utiliser `FlashGroupedQueryAttention` avec SMP v2. Pour découvrir cette API, consultez [Utiliser des FlashAttention noyaux pour attirer l'attention sur les requêtes groupées](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, ) ``` **Paramètres** + `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`. **Méthodes** + `forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d")`— Une fonction de PyTorch module normale. 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"`. **Renvoie** Renvoie un seul `torch.Tensor (batch_size x num_heads x seq_len x head_size)` qui représente la sortie du calcul de l’attention. ### `torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention` Une API compatible avec FlashAttention le modèle Llama. Cette API utilise l’API [`torch.sagemaker.nn.attn.FlashGroupedQueryAttention`](#model-parallel-v2-torch-sagemaker-reference-flashGroupedQueryAttn) à un niveau inférieur. Pour découvrir comment utiliser ceci, consultez [Utiliser des FlashAttention noyaux pour attirer l'attention sur les requêtes groupées](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 ) ``` **Paramètres** + `config`— Une FlashAttention configuration pour le modèle Llama. **Méthodes** + `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`. **Renvoie** Renvoie un seul `torch.Tensor (batch_size x num_heads x seq_len x head_size)` qui représente la sortie du calcul de l’attention. ### `torch.sagemaker.transform` SMP v2 fournit cette API `torch.sagemaker.transform()` pour transformer les modèles de transformeur Hugging Face en implémentations de modèles SMP et activer le parallélisme de tenseur 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 maintient les politiques de transformation pour les [Modèles de transformeur Hugging Face compatibles avec le parallélisme de contexte SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) en convertissant la configuration des modèles de transformeur Hugging Face en configuration de transformeur SMP. **Paramètres** + `model` (`torch.nn.Module`) : un des [Modèles de transformeur Hugging Face compatibles avec le parallélisme de contexte SMP](model-parallel-core-features-v2-tensor-parallelism.md#model-parallel-core-features-v2-tensor-parallelism-supported-models) 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](model-parallel-core-features-v2-delayed-param-init.md)), 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`MixedPrecision`, et `fp32` c'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 PyTorch modèle d'origine depuis le 0e rang vers le modèle transformé pour le groupe de tenseurs parallèles dont fait partie le 0e rang. 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'`p2p`implémentation utilise des appels d' peer-to-peerenvoi/réception pour l'accumulation de tenseurs key-and-value (KV) pendant le calcul de l'attention, s'exécutant de manière asynchrone et permettant à la communication de se chevaucher avec 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"`. **Retours** Renvoie un modèle transformé que vous pouvez encapsuler avec PyTorch FSDP. Lorsque `load_state_dict_from_rank0` est défini sur `True`, le groupe de parallélisme de tenseur qui implique le rang 0 a des poids chargés à partir du dictionnaire d’état d’origine au rang 0. Lors de l'utilisation [Initialisation différée des paramètres](model-parallel-core-features-v2-delayed-param-init.md) sur le modèle d'origine, seuls ces rangs comportent les tenseurs réels CPUs pour les paramètres et les tampons du modèle transformé. Les autres rangs continuent d’avoir les paramètres et les tampons sur le méta-dispositif pour économiser de la mémoire. ### Propriétés et fonctions utilitaires `torch.sagemaker` **Fonctions utilitaires torch.sagemaker** + `torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None`— Initialise la tâche de PyTorch formation avec SMP. + `torch.sagemaker.is_initialized() -> bool` : vérifie si la tâche d’entraînement est initialisée avec SMP. Lorsque vous revenez au mode natif PyTorch alors que la tâche est initialisée avec SMP, certaines propriétés ne sont pas pertinentes et le deviennent`None`, comme indiqué 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 [Utiliser la bibliothèque de parallélisme des SageMaker modèles v2](model-parallel-use-api-v2.md). + `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`. Lorsqu'il revient au mode natif PyTorch, il revient`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 [Utiliser la bibliothèque de parallélisme des SageMaker modèles v2](model-parallel-use-api-v2.md). + `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. Lorsqu'il revient au mode natif PyTorch, il revient`None`. + `torch.sagemaker.state.world_size` (int) : nombre total de dispositifs utilisés pendant l’entraînement. ## Mise à niveau de SMP v1 vers SMP v2 Pour passer de SMP v1 à SMP v2, vous devez modifier le script pour supprimer le SMP v1 APIs et appliquer le SMP v2. APIs Au lieu de démarrer à partir de votre script SMP v1, nous vous recommandons de démarrer à partir d'un script PyTorch FSDP et de suivre les instructions indiquées sur. [Utiliser la bibliothèque de parallélisme des SageMaker modèles v2](model-parallel-use-api-v2.md) Pour transférer les *modèles* SMP v1 vers SMP v2, vous devez collecter le dictionnaire d’état du modèle complet dans SMP v1, et appliquer les fonctions de traduction du dictionnaire d’état du modèle pour le convertir au format de point de contrôle du modèle de transformeur Hugging Face. Ensuite, dans SMP v2, comme indiqué dans la section[Points de contrôle à l’aide de la SMP](model-parallel-core-features-v2-checkpoints.md), vous pouvez charger les points de contrôle du modèle Hugging Face Transformers, puis continuer à utiliser le PyTorch point de contrôle avec SMP v2. APIs Pour utiliser SMP avec votre modèle PyTorch FSDP, assurez-vous de passer à SMP v2 et d'apporter des modifications à votre script d'entraînement afin d'utiliser le PyTorch FSDP et les autres fonctionnalités les plus récentes. ``` 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, ) ``` Pour trouver les fonctions de traduction disponibles dans SMP v1, consultez [Prise en charge des modèles Transformer Hugging Face](model-parallel-extended-features-pytorch-hugging-face.md). Pour obtenir des instructions sur l’enregistrement et le chargement des points de contrôle du modèle dans SMP v2, consultez [Points de contrôle à l’aide de la SMP](model-parallel-core-features-v2-checkpoints.md).