Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Penyetelan halus
<a name="model-parallel-core-features-v2-fine-tuning"></a>

Fine-tuning adalah proses pelatihan terus menerus model pra-terlatih untuk meningkatkan kinerja untuk kasus penggunaan tertentu.

Menyesuaikan model kecil yang sepenuhnya pas pada satu GPU, atau yang sesuai dengan 8 salinan model sepenuhnya sangat mudah. CPUs Tidak memerlukan perubahan khusus pada pelatihan FSDP reguler. Di ranah model yang lebih besar dari ini, Anda perlu mempertimbangkan untuk menggunakan fungsionalitas inisialisasi parameter tertunda, yang bisa jadi rumit.

Untuk mengatasi hal ini, pustaka SMP memuat model lengkap di salah satu peringkat sementara peringkat lainnya membuat model dengan bobot kosong pada perangkat meta. Kemudian, PyTorch FSDP menginisialisasi bobot pada peringkat bukan nol menggunakan `init_weights` fungsi, dan menyinkronkan bobot pada semua peringkat ke bobot pada peringkat ke-0 dengan set ke. `sync_module_states` `True` Cuplikan kode berikut menunjukkan bagaimana Anda harus mengaturnya dalam skrip pelatihan Anda.

```
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
)
```

## Menyetel model Hugging Face Transformer yang telah dilatih sebelumnya dengan paralelisme tensor SMP
<a name="model-parallel-core-features-v2-tensor-parallelism-fine-tuning-hf-transformer-with-tp"></a>

Bagian ini membahas pemuatan model Transformer untuk dua kasus penggunaan: fine-tuning model Transformer kecil dan fine-tuning model Transformer besar. Untuk model yang lebih kecil tanpa inisialisasi parameter yang tertunda, bungkus model dengan `torch.sagemaker.transform` API sebelum membungkusnya dengan 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,
)
```

Untuk model yang lebih besar, pendekatan sebelumnya menyebabkan kehabisan memori CPU. Kami menyarankan Anda menggunakan inisialisasi parameter tertunda untuk menghindari masalah memori CPU tersebut. Dalam hal ini, Anda dapat menerapkan `torch.sagemaker.transform` API dan `torch.sagemaker.delayed_param.DelayedParamIniter` API seperti yang ditunjukkan pada contoh kode berikut.

```
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
    )
```