Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

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

Bei der Optimierung werden vortrainierte Modelle kontinuierlich trainiert, um ihre Leistung für bestimmte Anwendungsfälle zu verbessern.

Die Feinabstimmung kleiner Modelle, die vollständig auf eine einzelne GPU passen, oder solcher, auf die 8 Kopien des Modells vollständig passen, ist unkompliziert. CPUs Es ist keine besondere Änderung des regulären FSDP-Trainings erforderlich. Bei größeren Modellen sollten Sie die Verwendung der Funktion zur verzögerten Parameterinitialisierung in Betracht ziehen, was schwieriger sein kann.

Zu diesem Zweck lädt die SMP-Bibliothek das vollständige Modell in einen der Ränge, während die übrigen Ränge Modelle mit leeren Gewichtungen auf einem Metagerät erstellen. Anschließend initialisiert PyTorch FSDP mithilfe der `init_weights` Funktion die Gewichtungen auf Rängen ungleich Null und synchronisiert die Gewichtungen auf allen Rängen mit den Gewichtungen auf dem Rang 0 mit der Einstellung auf. `sync_module_states` `True` Der folgende Codeausschnitt veranschaulicht, wie Sie dies in Ihrem Trainingsskript einrichten sollten.

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

## Optimierung eines vortrainierten Transformer-Modells von Hugging Face mit SMP-Tensorparallelität
<a name="model-parallel-core-features-v2-tensor-parallelism-fine-tuning-hf-transformer-with-tp"></a>

In diesem Abschnitt wird das Laden von Transformer-Modellen für zwei Anwendungsfälle beschrieben: die Optimierung kleiner Transformer-Modelle und die Optimierung großer Transformer-Modelle. Bei kleineren Modellen ohne verzögerte Parameterinitialisierung umschließen Sie das Modell mit der API, bevor Sie es mit FSDP umschließen. `torch.sagemaker.transform` PyTorch

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

Bei größeren Modellen führt der vorherige Ansatz dazu, dass der CPU-Speicher knapp wird. Wir empfehlen, die verzögerte Parameterinitialisierung zu verwenden, um solche CPU-Speicherprobleme zu vermeiden. In diesem Fall können Sie die `torch.sagemaker.transform`-API und die `torch.sagemaker.delayed_param.DelayedParamIniter`-API wie im folgenden Codebeispiel gezeigt anwenden.

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