As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

Ajuste fino

O ajuste fino é um processo de treinamento contínuo de modelos pré-treinados para melhorar o desempenho em casos de uso específicos.

Ajustar modelos pequenos que cabem totalmente em um único GPU modelo ou aqueles que cabem totalmente em 8 cópias do modelo CPUs é simples. Não requer nenhuma mudança especial no FSDP treinamento regular. No campo de modelos maiores do que isso, você precisa considerar o uso da funcionalidade de inicialização retardada de parâmetros, o que pode ser complicado.

Para resolver isso, a SMP biblioteca carrega o modelo completo em uma das classificações, enquanto o resto das classificações cria modelos com pesos vazios em um meta-dispositivo. Em seguida, PyTorch FSDP inicializa os pesos em classificações diferentes de zero usando a init_weights função e sincroniza os pesos em todas as classificações com os pesos na 0ª classificação com definido como. sync_module_states True O trecho de código a seguir mostra como você deve configurá-lo em seu script de treinamento.

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
)

Ajustando um modelo pré-treinado do Hugging Face Transformer com paralelismo tensorial SMP

Esta seção discute o carregamento de modelos de transformadores para dois casos de uso: ajuste fino de modelos pequenos de transformadores e ajuste fino de modelos de transformadores grandes. Para modelos menores sem atraso na inicialização dos parâmetros, envolva o modelo com o torch.sagemaker.transform API antes de envolvê-lo com. 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,
)

Para modelos maiores, a abordagem anterior faz com que a memória fique sem CPU memória. Recomendamos que você use a inicialização atrasada dos parâmetros para evitar esses problemas de CPU memória. Nesse caso, você pode aplicar o torch.sagemaker.transform API e o torch.sagemaker.delayed_param.DelayedParamIniter API conforme mostrado no exemplo de código a seguir.

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
    )