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
<a name="model-parallel-core-features-v2-fine-tuning"></a>

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

É simples ajustar modelos pequenos que cabem totalmente em uma única GPU ou aqueles que cabem 8 cópias do modelo totalmente em CPUs uma única GPU. Não exige nenhuma mudança especial no treinamento regular do FSDP. No campo de modelos maiores do que esses, você precisa considerar o uso da funcionalidade de inicialização atrasada de parâmetros, o que pode ser complicado.

Para resolver isso, a biblioteca de SMP carrega o modelo completo em uma das classificações, enquanto o restante das classificações cria modelos com pesos vazios em um dispositivo meta. Em seguida, o 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 demonstra como você deve configurá-lo no 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
)
```

## Ajuste de um modelo tipo transformador do Hugging Face pré-treinado com paralelismo de tensores do SMP
<a name="model-parallel-core-features-v2-tensor-parallelism-fine-tuning-hf-transformer-with-tp"></a>

Esta seção discute o carregamento de modelos tipo transformador para dois casos de uso: ajuste de pequenos modelos tipo transformador e ajuste de grandes modelos tipo transformador. Para modelos menores sem atraso na inicialização dos parâmetros, envolva o modelo com a `torch.sagemaker.transform` API antes de agrupá-lo com PyTorch o 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 deixa a memória da CPU sem espaço. Recomendamos que use a inicialização atrasada dos parâmetros para evitar esses problemas de memória da CPU. Nesse caso, você pode aplicar a API `torch.sagemaker.transform` e a API `torch.sagemaker.delayed_param.DelayedParamIniter`, conforme apresentado 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
    )
```