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
Vous trouverez ci-dessous des références pour la bibliothèque SageMaker model parallel v2 (SMPv2).
Rubriques
SMPparamètres de configuration des fonctionnalités principales de la v2
Vous trouverez ci-dessous la liste complète des paramètres permettant d'activer et de configurer lePrincipales fonctionnalités de la bibliothèque de parallélisme de SageMaker modèles v2. Ils doivent être écrits au JSON format et transmis à l' PyTorch estimateur dans le SageMaker Python SDK ou enregistrés sous forme de JSON fichier 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
(Entier) — Spécifie un degré de parallélisme fragmenté. La valeur doit être un entier compris entre0
etworld_size
. La valeur par défaut est0
.-
S'il est défini sur
0
, il revient à l' PyTorchimplémentation native et API dans le script, quandtensor_parallel_degree
est égal à 1. Sinon, il calcule la plus grande valeur possible sur lahybrid_shard_degree
base detensor_parallel_degree
etworld_size
. Lorsque vous revenez aux cas d' PyTorch FSDPutilisation natifs, siFULL_SHARD
c'est la stratégie que vous utilisez, elle se répercute sur l'ensemble du cluster deGPUs. Si_HYBRID_SHARD_ZERO2
c'étaitHYBRID_SHARD
ou était la stratégie, cela équivauthybrid_shard_degree
à 8. Lorsque le parallélisme des tenseurs est activé, il se divise en fonction de la version révisée.hybrid_shard_degree
-
S'il est défini sur
1
, il revient à l' PyTorchimplémentation native et API pourNO_SHARD
dans le script, quandtensor_parallel_degree
est égal à 1. Sinon, c'est équivalent à l'NO_SHARD
intérieur de n'importe quel groupe tensor parallel donné. -
S'il est défini sur un entier compris entre 2 et
world_size
, le partitionnement se produit sur le nombre spécifié deGPUs. Si vous ne le configurez passharding_strategy
dans le FSDP script, il est remplacé par.HYBRID_SHARD
Si vous définissez_HYBRID_SHARD_ZERO2
, le paramètresharding_strategy
que vous spécifiez est utilisé.
-
-
sm_activation_offloading
(Boolean) — Spécifie s'il faut activer l'implémentation du déchargement par SMP activation. SiFalse
, le déchargement utilise l' PyTorch implémentation native. SiTrue
, il utilise l'implémentation de déchargement par SMP activation. Vous devez également utiliser le wrapper PyTorch d'activation (torch.distributed.algorithms._checkpoint.checkpoint_wrapper.offload_wrapper
) dans votre script. Pour en savoir plus, consultez Déchargement de l'activation. La valeur par défaut estTrue
. -
activation_loading_horizon
(Entier) — Un entier spécifiant le type d'horizon de déchargement d'activation pourFSDP. 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 GPU mémoire. Pour en savoir plus, consultez Déchargement de l'activation. La valeur d'entrée doit être un entier positif. La valeur par défaut est2
. -
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 estTrue
. -
allow_empty_shards
(Boolean) — S'il faut autoriser les fragments 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 lors du point de contrôle dans certains scénarios. La désactivation de cette option revient au PyTorch comportement d'origine. La valeur par défaut estFalse
. -
tensor_parallel_degree
(Entier) — Spécifie un degré de parallélisme tensoriel. La valeur doit être comprise entre1
etworld_size
. La valeur par défaut est1
. Notez que le fait de transmettre une valeur supérieure à 1 n'active pas automatiquement le parallélisme du contexte ; vous devez également utiliser le torch.sagemaker.transform API pour intégrer le modèle dans votre script d'entraînement. Pour en savoir plus, consultez Parallélisme de tenseur. -
context_parallel_degree
(Entier) — Spécifie le degré de parallélisme du contexte. La valeur doit être comprise entre1
world_size
et et doit être<= hybrid_shard_degree
. La valeur par défaut est1
. Notez que le fait de transmettre une valeur supérieure à 1 n'active pas automatiquement le parallélisme du contexte ; vous devez également utiliser le torch.sagemaker.transform API pour intégrer le modèle dans votre script d'entraînement. Pour en savoir plus, consultez Parallélisme du contexte. -
expert_parallel_degree
(Entier) — Spécifie un degré de parallélisme expert. La valeur doit être comprise entre 1 etworld_size
. La valeur par défaut est1
. Notez que le fait de transmettre une valeur supérieure à 1 n'active pas automatiquement le parallélisme du contexte ; vous devez également utiliser le torch.sagemaker.transform API pour intégrer le modèle dans votre script d'entraînement. Pour en savoir plus, consultez Parallélisme expert. -
random_seed
(Entier) — Nombre initial pour les opérations aléatoires dans les modules distribués par parallélisme SMP tensoriel ou parallélisme expert. Cette graine est ajoutée aux rangs parallèles aux tenseurs ou aux rangs parallèles aux experts pour définir la valeur initiale réelle de chaque rang. Il est unique pour chaque rang parallèle au tenseur et au parallèle expert. SMPv2 s'assure 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 torch.sagemaker
package SMP v2
Cette section est une référence pour le torch.sagemaker
package fourni par la SMP v2.
Rubriques
- torch.sagemaker.delayed_param.DelayedParamIniter
- torch.sagemaker.distributed.checkpoint.state_dict_saver.async_save
- torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls
- torch.sagemaker.distributed.checkpoint.state_dict_saver.save
- torch.sagemaker.distributed.checkpoint.state_dict_loader.load
- torch.sagemaker.moe.moe_config.MoEConfig
- torch.sagemaker.nn.attn.FlashSelfAttention
- torch.sagemaker.nn.attn.FlashGroupedQueryAttention
- torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention
- torch.sagemaker.transform
- torch.sagemakerfonctions et propriétés utilitaires
torch.sagemaker.delayed_param.DelayedParamIniter
Et API pour postuler Initialisation différée des paramètres à 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 la SMP v2. -
init_method_using_config
(Appelable) — Si vous utilisez l'implémentation tensor parallel de SMP v2 ou supportéeModèles Hugging Face Transformer compatibles avec le parallélisme SMP des tenseurs, conservez ce paramètre à la valeur par défaut, qui est.None
Par défaut,DelayedParamIniter
API il découvre comment initialiser correctement le modèle donné. Pour tous les autres modèles, vous devez créer une fonction d'initialisation de paramètres personnalisée et l'ajouter à votre script. L'extrait de code suivant est lainit_method_using_config
fonction par défaut implémentée par la SMP v2 pour. Modèles Hugging Face Transformer compatibles avec le parallélisme SMP des tenseurs 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 auinit_method_using_config
paramètre du. SMPDelayedParamIniter
APIfrom 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
torch.sagemaker.module_util
fonctions de l'extrait de code précédent, consultez. torch.sagemakerfonctions et propriétés utilitaires -
verbose
(Boolean) — S'il faut activer une journalisation plus détaillée lors de l'initialisation et de la validation. La valeur par défaut estFalse
.
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 PyTorch FSDP wrapper. -
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 PyTorch FSDP wrapper. Cela est nécessaire lorsque vous avez lié des poids dans le modèle. Le modèle doit implémenter la méthodetie_weights
. Pour plus d'informations, consultez les remarques sur le poids lié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 de mettre en œuvre lavalidate_params_and_buffers_inited
méthode suivante. Il n'est généralement pas nécessaire d'appeler cette fonction de manière explicite, car lavalidate_params_and_buffers_inited
méthode appelle implicitement cette méthode dans le backend. -
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 GPU appareils plutôt que sur des méta-appareils. Elle se poseAssertionErrors
si ces conditions ne sont pas remplies. 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
Entrée API pour une sauvegarde asynchrone. Utilisez cette méthode pour enregistrer un fichier de state_dict
manière asynchrone dans un fichier spécifié. checkpoint_id
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 dicton de l'État de sauver. -
checkpoint_id
(str) - Obligatoire. Le chemin de stockage dans lequel enregistrer les points de contrôle. -
storage_writer
(StorageWriter) - Facultatif. Une instance deStorageWriter
in PyTorch pour effectuer des opérations d'écriture. Si cela n'est pas spécifié, la configuration par défaut de StorageWriter
est utilisée. -
planner
(SavePlanner) - Facultatif. Un exemple d'SavePlanner
in PyTorch. Si cela n'est pas spécifié, la configuration par défaut de SavePlanner
est utilisée. -
process_group
(ProcessGroup) - Facultatif. Le groupe de processus sur lequel travailler. SiNone
, le groupe de processus (global) par défaut est utilisé. -
coordinator_rank
(int) - Facultatif. Le rang du coordinateur lors de l'exécution d'opérateurs de communication collective tels queAllReduce
. -
queue
(AsyncRequestQueue) - Facultatif. Le planificateur asynchrone à utiliser. Par défaut, il prend le paramètre globalDEFAULT_ASYNC_REQUEST_QUEUE
. -
sharded_strategy
(PyTorchDistSaveShardedStrategy) - Facultatif. La stratégie fragmentée à utiliser pour sauver les points de contrôle. Si ce n'est pas spécifié,torch.sagemaker.distributed.checkpoint.state_dict_saver.PyTorchDistSaveShardedStrategy
il est utilisé par défaut. -
wait_error_handling
(bool) - Facultatif. Un indicateur indiquant s'il faut attendre que tous les grades aient terminé de traiter les erreurs. La valeur par défaut estTrue
. -
force_check_all_plans
(bool) - Facultatif. Un indicateur qui détermine s'il convient de synchroniser de force les plans entre les grades, même en cas d'accès au cache. La valeur par défaut estTrue
. -
s3_region
(str) - Facultatif. Région dans laquelle se trouve le compartiment S3. Si elle n'est pas spécifiée, la région est déduite ducheckpoint_id
. -
s3client_config
(S3ClientConfig) - Facultatif. La 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 ClientConfigest utilisée. Le part_size
paramètre est défini sur 64 Mo par défaut.
torch.sagemaker.distributed.checkpoint.state_dict_saver.maybe_finalize_async_calls
Cette fonction permet à un processus de formation de surveiller plusieurs demandes asynchrones à effectuer.
def maybe_finalize_async_calls( blocking=True, process_group=None ) -> List[int]:
Paramètres
-
blocking
(bool) - Facultatif. SiTrue
, 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 estTrue
. -
process_group
(ProcessGroup) - Facultatif. Le groupe de processus sur lequel opérer. S'il est défini surNone
, le groupe de processus (global) par défaut est utilisé.
Renvoie
-
Une liste contenant les indices des appels asynchrones est finalisée avec succès.
torch.sagemaker.distributed.checkpoint.state_dict_saver.save
Utilisez cette méthode pour enregistrer un fichier de state_dict
manière synchrone dans un fichier spécifiécheckpoint_id
.
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 dicton de l'État de sauver. -
checkpoint_id
(str) - Obligatoire. Le chemin de stockage dans lequel enregistrer les points de contrôle. -
storage_writer
(StorageWriter) - Facultatif. Une instance deStorageWriter
in PyTorch pour effectuer des opérations d'écriture. Si cela n'est pas spécifié, la configuration par défaut de StorageWriter
est utilisée. -
planner
(SavePlanner) - Facultatif. Un exemple d'SavePlanner
in PyTorch. Si cela n'est pas spécifié, la configuration par défaut de SavePlanner
est utilisée. -
process_group
(ProcessGroup) - Facultatif. Le groupe de processus sur lequel travailler. SiNone
, le groupe de processus (global) par défaut est utilisé. -
coordinator_rank
(int) - Facultatif. Le rang du coordinateur lors de l'exécution d'opérateurs de communication collective tels queAllReduce
. -
wait_error_handling
(bool) - Facultatif. Un indicateur indiquant s'il faut attendre que tous les grades aient terminé de traiter les erreurs. La valeur par défaut estTrue
. -
force_check_all_plans
(bool) - Facultatif. Un indicateur qui détermine s'il convient de synchroniser de force les plans entre les grades, même en cas d'accès au cache. La valeur par défaut estTrue
. -
s3_region
(str) - Facultatif. Région dans laquelle se trouve le compartiment S3. Si elle n'est pas spécifiée, la région est déduite ducheckpoint_id
. -
s3client_config
(S3ClientConfig) - Facultatif. La 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 ClientConfigest utilisée. Le part_size
paramètre est défini sur 64 Mo par défaut.
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. Lestate_dict
à charger. -
checkpoint_id
(str) - Obligatoire. L'identifiant d'un point de contrôle. La signification decheckpoint_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 deStorageReader
in PyTorch pour effectuer des opérations de lecture. S'il n'est pas spécifié, le point de contrôle distribué déduira automatiquement le lecteur en fonction du. checkpoint_id
Sicheckpoint_id
c'est égalementNone
le cas, une erreur d'exception est déclenchée. -
planner
(StorageReader) - Facultatif. Un exemple d'LoadPlanner
in PyTorch. Si elle n'est pas spécifiée, la configuration par défaut de LoadPlanner
est utilisée. -
check_keys_matched
(bool) - Facultatif. Si cette option est activée, vérifie si lesstate_dict
clés de tous les grades correspondent à l'aide deAllGather
. -
s3_region
(str) - Facultatif. Région dans laquelle se trouve le compartiment S3. Si elle n'est pas spécifiée, la région est déduite ducheckpoint_id
. -
s3client_config
(S3ClientConfig) - Facultatif. La 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 ClientConfigest utilisée. Le part_size
paramètre est défini sur 64 Mo par défaut.
torch.sagemaker.moe.moe_config.MoEConfig
Une classe de configuration pour configurer l'SMPimplémentation de Mixture-of-Experts (MoE). Vous pouvez spécifier les valeurs de configuration MoE par le biais de cette classe et les transmettre à l'torch.sagemaker.transform
APIappel. Pour en savoir plus sur l'utilisation de cette classe pour l'entraînement des modèles MoE, voirParallélisme expert.
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
(Boolean) - S'il faut utiliser l'SMPimplémentation de MoE. La valeur par défaut estTrue
. -
random_seed
(Entier) - Numéro initial pour les opérations aléatoires dans les modules distribués parallèles par des experts. Cette graine est ajoutée au rang parallèle expert pour définir la valeur initiale réelle de chaque rang. Il est unique pour chaque grade d'expert parallel. La valeur par défaut est12345
. -
moe_load_balancing
(String) - Spécifiez le type d'équilibrage de charge du routeur MoE. Les options valides sontaux_loss
sinkhorn
,balanced
, etnone
. La valeur par défaut estsinkhorn
. -
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 estFalse
. -
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 estTrue
. -
moe_aux_loss_coeff
(Float) - Coefficient de perte d'équilibrage de charge auxiliaire. La valeur par défaut est0.001
. -
moe_z_loss_coeff
(Float) - Coefficient de perte z. La valeur par défaut est0.001
.
torch.sagemaker.nn.attn.FlashSelfAttention
Et API pour une utilisation FlashAttention avec la 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
(float) — Probabilité d'abandon à appliquer à l'attention. La valeur par défaut est0.0
. -
scale
(float) — S'il est passé, ce facteur d'échelle est appliqué pour softmax. S'il est défini surNone
(qui est également la valeur par défaut), le facteur d'échelle est1 / sqrt(attention_head_size)
. La valeur par défaut estNone
. -
triton_flash_attention
(bool) — En cas de réussite, l'implémentation de Flash Attention par Triton est utilisée. Cela est nécessaire pour soutenir Attention with Linear Biases (ALiBi) (voir leuse_alibi
paramètre suivant). Cette version du noyau ne supporte pas le dropout. La valeur par défaut estFalse
. -
use_alibi
(bool) — S'il est passé, il active Attention with Linear Biases (ALiBi) à l'aide du masque fourni. Lors de son utilisationALiBi, il faut un masque d'attention préparé comme suit. La valeur par défaut estFalse
.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. Lorsque amodule(x)
est appelé, SMP exécute cette fonction automatiquement.-
qkv
—torch.Tensor
de la forme suivante :(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 donttorch.Tensors
chacun peut avoir une forme(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, il nécessitetriton_flash_attention=True
etuse_alibi=True
. Pour savoir comment générer un masque d'attention à l'aide de cette méthode, consultez les exemples de code surFlashAttention. La valeur par défaut estNone
. -
causal
— Lorsque ce paramètre est défini surFalse
, qui est la valeur par défaut de l'argument, aucun masque n'est appliqué. Lorsqu'elle est définie surTrue
, laforward
méthode utilise le masque triangulaire inférieur standard. La valeur par défaut estFalse
. -
cast_dtype
— Lorsqu'il est défini sur une valeur particulièredtype
, il convertit lesqkv
tenseurs sur le tenseurdtype
précédentattn
. Cela est utile pour des implémentations telles que le modèle Hugging Face Transformer GPT -NeOx, qui aq
etk
avec des intégrations rotatives.fp32
Si ce paramètre est défini surNone
, aucun casting n'est appliqué. La valeur par défaut estNone
. -
layout
(chaîne) — Les valeurs disponibles sontb h s d
oub s h d
. Cela doit être défini sur la disposition desqkv
tenseurs transmis, afin que les transformations appropriées puissent être appliquées.attn
La valeur par défaut estb h s d
.
-
Renvoie
Un single plein torch.Tensor
de forme(batch_size x num_heads x
seq_len x head_size)
.
torch.sagemaker.nn.attn.FlashGroupedQueryAttention
Et API pour une utilisation FlashGroupedQueryAttention
avec la SMP v2. Pour en savoir plus sur son utilisationAPI, consultezUtiliser des FlashAttention noyaux pour attirer l'attention sur les requêtes groupées.
class torch.sagemaker.nn.attn.FlashGroupedQueryAttention( attention_dropout_prob: float = 0.0, scale: Optional[float] = None, )
Paramètres
-
attention_dropout_prob
(float) — Probabilité d'abandon à appliquer à l'attention. La valeur par défaut est0.0
. -
scale
(float) — S'il est passé, ce facteur d'échelle est appliqué pour softmax. S'il est défini surNone
,1 / sqrt(attention_head_size)
est utilisé comme facteur d'échelle. La valeur par défaut estNone
.
Méthodes
-
forward(self, q, kv, causal=False, cast_dtype=None, layout="b s h d")
— Une fonction de PyTorch module normale. Lorsque amodule(x)
est appelé, SMP exécute cette fonction automatiquement.-
q
—torch.Tensor
de la forme suivante(batch_size x seqlen x num_heads x head_size)
ou(batch_size x num_heads x seqlen x head_size)
. L'argument de mise en page approprié doit être transmis en fonction de la forme. -
kv
—torch.Tensor
de la forme suivante(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 deuxtorch.Tensor
s, dont chacun peut avoir la forme(batch_size x seqlen x num_heads x head_size)
ou(batch_size x num_heads x seqlen x head_size)
.layout
L'argument approprié doit également être transmis en fonction de la forme. -
causal
— Lorsque ce paramètre est défini surFalse
, qui est la valeur par défaut de l'argument, aucun masque n'est appliqué. Lorsqu'elle est définie surTrue
, laforward
méthode utilise le masque triangulaire inférieur standard. La valeur par défaut estFalse
. -
cast_dtype
— Lorsqu'il est défini sur un dtype particulier, il convertit lesqkv
tenseurs en ce dtype auparavant.attn
Cela est utile pour des implémentations telles que Hugging Face Transformers GPT -NeOx, qui comporte des intégrations rotatives.q,k
fp32
Si ce paramètre est défini surNone
, aucun casting n'est appliqué. La valeur par défaut estNone
. -
layout (string) — Les valeurs disponibles sont
"b h s d"
ou"b s h d"
. Cela doit être défini sur la disposition desqkv
tenseurs transmis, afin que les transformations appropriées puissent être appliquées.attn
La valeur par défaut est"b h s d"
.
-
Renvoie
Renvoie un single torch.Tensor (batch_size x num_heads x seq_len x
head_size)
qui représente le résultat du calcul de l'attention.
torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention
Et API cela soutient FlashAttention le modèle Lama. Cela API utilise le torch.sagemaker.nn.attn.FlashGroupedQueryAttention API à bas niveau. Pour savoir comment l'utiliser, voirUtiliser des FlashAttention noyaux pour attirer l'attention sur les requêtes groupées.
class torch.sagemaker.nn.huggingface.llama_flashattn.LlamaFlashAttention( config: LlamaConfig )
Paramètres
-
config
— Une FlashAttention configuration pour le modèle Lama.
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 forme de(batch_size x seq_len x num_heads x head_size)
. -
attention_mask
(torch.LongTensor
) — Masque pour éviter de faire attention au remplissage d'indices de jetons sous forme de(batch_size x seqlen)
. La valeur par défaut estNone
. -
position_ids
(torch.LongTensor
) — Lorsqu'il ne l'est pasNone
, il s'agit d'(batch_size x seqlen)
indiquer les indices de position de chaque jeton de séquence d'entrée dans les intégrations de position. La valeur par défaut estNone
. -
past_key_value
(Cache) — États cachés précalculés (clé et valeurs dans les blocs d'attention personnelle et dans les blocs d'attention croisée). La valeur par défaut estNone
. -
output_attentions
(bool) — Indique s'il faut renvoyer les tenseurs d'attention de toutes les couches d'attention. La valeur par défaut estFalse
. -
use_cache
(bool) — Indique s'il faut renvoyer les étatspast_key_values
des valeurs clés. La valeur par défaut estFalse
.
-
Renvoie
Renvoie un single torch.Tensor (batch_size x num_heads x seq_len x
head_size)
qui représente le résultat du calcul de l'attention.
torch.sagemaker.transform
SMPLa v2 fournit cela torch.sagemaker.transform()
API pour transformer les modèles Hugging Face Transformer en implémentations de modèles SMP et activer le parallélisme SMP des tenseurs.
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 )
SMPLa v2 maintient les politiques de transformation pour le Modèles Hugging Face Transformer compatibles avec le parallélisme SMP des tenseurs en convertissant la configuration des modèles Hugging Face Transformer en configuration SMP de transformateur.
Paramètres
-
model
(torch.nn.Module
) — Un modèle Modèles Hugging Face Transformer compatibles avec le parallélisme SMP des tenseurs à partir duquel transformer et appliquer la fonction de parallélisme tensoriel de la bibliothèque. SMP -
device
(torch.device
) — En cas de réussite, un nouveau modèle est créé sur cet appareil. Si le module d'origine possède un paramètre sur le méta-périphérique (voirInitialisation différée des paramètres), le module transformé sera également créé sur le méta-périphérique, en ignorant l'argument passé ici. La valeur par défaut estNone
. -
dtype
(torch.dtype
) — En cas de réussite, définit ce paramètre 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 avecfp32
lors de l'utilisationMixedPrecision
, etfp32
c'est le dtype par défaut dans PyTorch. La valeur par défaut estNone
. -
config
(dict) — Il s'agit d'un dictionnaire pour configurer le SMP transformateur. La valeur par défaut estNone
. -
load_state_dict_from_rank0
(Booléen) — Par défaut, ce module crée une nouvelle instance du modèle avec de nouvelles pondérations. Lorsque cet argument est défini surTrue
, SMP essaie de charger le dictionnaire d'état du PyTorch modèle d'origine du 0e rang dans le modèle transformé pour le groupe de tenseurs parallèles dont fait partie le 0e rang. Lorsque ce paramètre est défini surTrue
, le rang 0 ne peut avoir aucun paramètre sur le méta-appareil. Seul le premier groupe tensoriel parallel renseigne les poids à partir du 0e rang après cet appel de transformation. Vous devez définirsync_module_states
toTrue
dans le FSDP wrapper pour obtenir ces poids du premier groupe parallèle de tenseurs vers tous les autres processus. Lorsque cette option est activée, la SMP bibliothèque charge le dictionnaire d'état à partir du modèle d'origine. La SMP bibliothèque prend le modèle avantstate_dict
la transformation, le convertit pour qu'il corresponde à la structure du modèle transformé, le divise pour chaque rang de tenseur parallèle, communique cet état du 0e rang aux autres rangs du groupe de tenseurs parallèles dont fait partie le 0e rang, et le charge. La valeur par défaut estFalse
.
Retours
Renvoie un modèle transformé que vous pouvez utiliser pour l'encapsuler PyTorch FSDP. Lorsqu'il load_state_dict_from_rank0
est défini surTrue
, le groupe tensoriel parallèle 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 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 grades continuent d'avoir les paramètres et les tampons sur le méta-périphérique pour économiser de la mémoire.
torch.sagemaker
fonctions et propriétés utilitaires
Fonctionnalités de l'utilitaire torch.sagemaker
-
torch.sagemaker.init(config: Optional[Union[str, Dict[str, Any]]] = None) -> None
— Initialise la tâche de PyTorch formation avecSMP. -
torch.sagemaker.is_initialized() -> bool
— Vérifie si la tâche de formation est initialisée avecSMP. Lorsque vous revenez à la version native PyTorch alors que la tâche est initialisée avecSMP, certaines propriétés ne sont pas pertinentes et le deviennentNone
, 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 paramètres donnés, ledevice
cas échéant, et il peut être récursif pour tous les modules imbriqués s'ils sont spécifiés. -
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 la valeur spécifiéedevice
, et cela peut être récursif pour tous les modules imbriqués si cela est spécifié.
Propriétés
torch.sagemaker.state
possède plusieurs propriétés utiles après l'initialisation de SMP withtorch.sagemaker.init
.
-
torch.sagemaker.state.hybrid_shard_degree
(int) — Le degré de parallélisme des données fragmentées, une copie des données saisies par l'utilisateur dans la SMP configuration transmise à.torch.sagemaker.init()
Pour en savoir plus, consultez Utiliser la bibliothèque de parallélisme des SageMaker modèles v2. -
torch.sagemaker.state.rank
(int) — Le classement global de l'appareil, dans la plage de[0, world_size)
. -
torch.sagemaker.state.rep_rank_process_group
(torch.distributed.ProcessGroup
) — Le groupe de processus comprenant tous les appareils ayant le même rang de réplication. Notez la différence subtile mais fondamentale avectorch.sagemaker.state.tp_process_group
. Lorsqu'il revient au mode natif PyTorch, il revientNone
. -
torch.sagemaker.state.tensor_parallel_degree
(int) — Le degré de parallélisme du tenseur, une copie de l'entrée utilisateur dans la SMP configuration transmise à.torch.sagemaker.init()
Pour en savoir plus, consultez Utiliser la bibliothèque de parallélisme des SageMaker modèles v2. -
torch.sagemaker.state.tp_size
(int) — Un alias pourtorch.sagemaker.state.tensor_parallel_degree
. -
torch.sagemaker.state.tp_rank
(int) — Le rang de parallélisme des tenseurs pour le dispositif dans la plage de[0, tp_size)
, déterminé par le degré de parallélisme des tenseurs et le mécanisme de classement. -
torch.sagemaker.state.tp_process_group
(torch.distributed.ProcessGroup
) — Le groupe de processus tensor parallel comprenant tous les appareils ayant le même rang dans d'autres dimensions (par exemple, parallélisme et réplication de données partitionnées) mais des rangs tensoriels parallèles uniques. Lorsqu'il revient au mode natif PyTorch, il revientNone
. -
torch.sagemaker.state.world_size
(int) — Le nombre total d'appareils utilisés pendant l'entraînement.
Passez de la SMP v1 à la SMP v2
Pour passer de la SMP v1 à la SMP v2, vous devez modifier le script pour supprimer la SMP v1 APIs et appliquer la SMP v2APIs. Au lieu de partir de votre script SMP v1, nous vous recommandons de démarrer à partir d'un PyTorch FSDP script et de suivre les instructions de l'adresseUtiliser la bibliothèque de parallélisme des SageMaker modèles v2.
Pour transférer les modèles SMP v1 vers la SMP v2, dans la version SMP v1, vous devez collecter le dictionnaire d'état du modèle complet 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 Hugging Face Transformers. Ensuite, dans la SMP version v2, comme indiqué dans la Point de contrôle à l'aide de SMP section, vous pouvez charger les points de contrôle du modèle Hugging Face Transformers, puis continuer à utiliser PyTorch le point de contrôle avec la APIs version v2. SMP Pour l'utiliser SMP avec votre PyTorch FSDP modèle, assurez-vous de passer à la SMP version 2 et d'apporter des modifications à votre script d'entraînement pour l'utiliser PyTorch FSDP et aux 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 la SMP version 1, voirPrise en charge des modèles Transformer Hugging Face.
Pour obtenir des instructions sur la sauvegarde et le chargement des points de contrôle du modèle dans la SMP version 2, reportez-vous Point de contrôle à l'aide de SMP à.