Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Ajuste

El afinamiento es un proceso de entrenamiento continuo de modelos previamente entrenados para mejorar el rendimiento en casos de uso específicos.

Es muy sencillo ajustar los modelos pequeños que caben completamente en un solo GPU modelo o aquellos en los que caben 8 copias del modelo por completo. CPUs No requiere ningún cambio especial con respecto al entrenamiento regularFSDP. En el caso de modelos de mayor tamaño, hay que considerar la posibilidad de utilizar la función de inicialización diferida de parámetros, que puede resultar complicada.

Para solucionar este problema, la SMP biblioteca carga el modelo completo en uno de los rangos, mientras que el resto de los rangos crea modelos con pesos vacíos en un metadispositivo. A continuación, PyTorch FSDP inicializa las ponderaciones de los rangos distintos de cero mediante la init_weights función y sincroniza las ponderaciones de todos los rangos con las ponderaciones del rango 0 con el valor establecido en. sync_module_states True En el siguiente fragmento de código se muestra cómo debe configurarlo en su script de entrenamiento.

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
)

Ajuste preciso de un modelo de Hugging Face Transformer previamente entrenado con paralelismo tensorial SMP

En esta sección se analiza la carga de modelos de transformador para dos casos de uso: afinamiento de los modelos de transformador pequeños y ajuste de modelos de transformador grandes. Para modelos más pequeños sin demorar la inicialización de los parámetros, envuelva el modelo con el antes de envolverlo con. torch.sagemaker.transform API 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,
)

En el caso de los modelos más grandes, el enfoque anterior provoca que se agote la CPU memoria. Se recomienda utilizar la inicialización retardada de los parámetros para evitar este tipo de problemas de CPU memoria. En este caso, puede aplicar las torch.sagemaker.transform API y las tal y torch.sagemaker.delayed_param.DelayedParamIniter API como se muestra en el siguiente ejemplo de código.

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
    )