Affinement

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
    )