Sélectionner vos préférences de cookies

Nous utilisons des cookies essentiels et des outils similaires qui sont nécessaires au fonctionnement de notre site et à la fourniture de nos services. Nous utilisons des cookies de performance pour collecter des statistiques anonymes afin de comprendre comment les clients utilisent notre site et d’apporter des améliorations. Les cookies essentiels ne peuvent pas être désactivés, mais vous pouvez cliquer sur « Personnaliser » ou « Refuser » pour refuser les cookies de performance.

Si vous êtes d’accord, AWS et les tiers approuvés utiliseront également des cookies pour fournir des fonctionnalités utiles au site, mémoriser vos préférences et afficher du contenu pertinent, y compris des publicités pertinentes. Pour accepter ou refuser tous les cookies non essentiels, cliquez sur « Accepter » ou « Refuser ». Pour effectuer des choix plus détaillés, cliquez sur « Personnaliser ».

Affinement

Mode de mise au point
Affinement - Amazon SageMaker AI

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.

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.

Le peaufinage est un processus de formation continue de modèles préentraînés afin d'améliorer les performances dans des cas d'utilisation spécifiques.

CPUs Il est très simple de peaufiner les petits modèles qui s'adaptent entièrement à un seul GPU ou ceux qui s'adaptent entièrement à 8 copies du modèle. Il ne nécessite aucune modification particulière par rapport à la formation FSDP régulière. Dans le domaine des modèles plus grands, vous devez envisager d'utiliser la fonctionnalité d'initialisation différée des paramètres, qui peut s'avérer délicate.

Pour résoudre ce problème, la bibliothèque SMP charge le modèle complet sur l'un des rangs tandis que les autres rangs créent des modèles avec des poids vides sur un méta-périphérique. Ensuite, PyTorch FSDP initialise les poids sur les rangs non nuls à l'aide de la init_weights fonction, et synchronise les poids sur tous les rangs avec les poids sur le 0e rang avec défini sur. sync_module_states True L'extrait de code suivant montre comment le configurer dans votre script d'entraînement.

import torch.distributed as dist from transformers import AutoModelForCasalLM from accelerate import init_empty_weights from torch.sagemaker.delayed_param import DelayedParamIniter if dist.get_rank() == 0: model = AutoModelForCasalLM.from_pretrained(..., low_cpu_mem_usage=True) else: with init_empty_weights(): model = AutoModelForCasalLM.from_config(AutoConfig.from_pretrained(...)) delayed_initer = DelayedParamIniter(model) model = FSDP( model, ..., sync_module_states=True, param_init_fn=delayed_initer.get_param_init_fn() if dist.get_rank() > 0 else None )

Réglage précis d'un modèle de transformateur Hugging Face préentraîné avec le parallélisme des tenseurs SMP

Cette section décrit le chargement des modèles de transformateurs pour deux cas d'utilisation : le réglage précis des petits modèles de transformateurs et le réglage fin des grands modèles de transformateurs. Pour les modèles plus petits sans initialisation différée des paramètres, encapsulez le modèle avec l'torch.sagemaker.transformAPI avant de l'encapsuler avec PyTorch FSDP.

import functools from transformers import AutoModelForCausalLM from torch.distributed.fsdp import FullyShardedDataParallel as FSDP from torch.distributed.fsdp.wrap import transformer_auto_wrap_policy from torch.sagemaker import transform model = AutoModelForCausalLM.from_pretrained("meta-llama/Llama-2-7b-hf", low_cpu_mem_usage=True) # Transform model while loading state dictionary from rank 0. tp_model = transform(model, load_state_dict_from_rank0=True) # Wrap with FSDP. model = FSDP( tp_model, ... sync_module_states=True, )

Pour les modèles plus grands, l'approche précédente entraîne un épuisement de la mémoire du processeur. Nous vous recommandons d'utiliser l'initialisation différée des paramètres pour éviter de tels problèmes de mémoire du processeur. Dans ce cas, vous pouvez appliquer l'torch.sagemaker.transformAPI et l'torch.sagemaker.delayed_param.DelayedParamIniterAPI comme indiqué dans l'exemple de code suivant.

from transformers import AutoModelForCausalLM from torch.sagemaker import transform from torch.sagemaker.delayed_param import DelayedParamIniter # Create one instance of model without delayed param # on CPU, on one rank. if dist.get_rank() == 0: model = AutoModelForCasalLM.from_pretrained(...,low_cpu_mem_usage=True) else: with init_empty_weights(): model = AutoModelForCasalLM.from_config(AutoConfig.from_pretrained(...)) # Transform model while loading state dictionary from rank 0 model = transform(model, load_state_dict_from_rank0=True) if dist.get_rank() != 0: # For fine-tuning, delayed parameter on non-zero ranks delayed_initer = DelayedParamIniter(model) else: delayed_initer = None with ( delayed_initer.validate_params_and_buffers_inited() if delayed_initer else nullcontext() ): # Wrap the model with FSDP model = FSDP( model, ..., sync_module_states=True, param_init_fn=delayed_initer.get_param_init_fn() if delayed_initer else None )

Rubrique suivante :

FlashAttention

Rubrique précédente :

Parallélisme de tenseur
ConfidentialitéConditions d'utilisation du sitePréférences de cookies
© 2025, Amazon Web Services, Inc. ou ses affiliés. Tous droits réservés.