Ajuste fino - Amazon SageMaker

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 )