# Feinabstimmung vom letzten Checkpoint

Sie müssen zuerst den `Trainer` bearbeiten, um `save_strategy` und `save_steps`hinzuzufügen. Unten wird alle 50 Schritte ein Checkpoint im Ordner gespeichert `outputs`.

```python
trainer = SFTTrainer(
    ....
    args = TrainingArguments(
        ....
        output_dir = "outputs",
        save_strategy = "steps",
        save_steps = 50,
    ),
)
```

Dann machen Sie im Trainer Folgendes:

```python
trainer_stats = trainer.train(resume_from_checkpoint = True)
```

Dies beginnt beim neuesten Checkpoint und setzt das Training fort.

### Wandb-Integration

```
# Bibliothek installieren
!pip install wandb --upgrade

# Wandb einrichten
!wandb login <token>

import os

os.environ["WANDB_PROJECT"] = "<name>"
os.environ["WANDB_LOG_MODEL"] = "checkpoint"
```

Dann in `TrainingArguments()` setzen

```
report_to = "wandb",
logging_steps = 1, # Bei Bedarf ändern
save_steps = 100 # Bei Bedarf ändern
run_name = "<name>" # (Optional)
```

Um das Modell zu trainieren, machen Sie `trainer.train()`; um das Training fortzusetzen, machen Sie

```
import wandb
run = wandb.init()
artifact = run.use_artifact('<username>/<Wandb-project-name>/<run-id>', type='model')
artifact_dir = artifact.download()
trainer.train(resume_from_checkpoint=artifact_dir)
```

## :question:Wie führe ich Early Stopping durch?

Wenn Sie den Finetuning-/Trainingslauf stoppen oder pausieren möchten, weil der Evaluierungsverlust nicht sinkt, dann können Sie Early Stopping verwenden, das den Trainingsprozess beendet. Verwenden Sie `EarlyStoppingCallback`.

Wie üblich richten Sie Ihren Trainer und Ihren Evaluierungsdatensatz ein. Das Folgende wird verwendet, um den Trainingslauf zu stoppen, wenn der `eval_loss` (der Evaluierungsverlust) nach etwa 3 Schritten nicht sinkt.

```python
from trl import SFTConfig, SFTTrainer
trainer = SFTTrainer(
    args = SFTConfig(
        fp16_full_eval = True,
        per_device_eval_batch_size = 2,
        eval_accumulation_steps = 4,
        output_dir = "training_checkpoints", # Speicherort der gespeicherten Checkpoints für Early Stopping
        save_strategy = "steps",             # Modell alle N Schritte speichern
        save_steps = 10,                     # wie viele Schritte, bis wir das Modell speichern
        save_total_limit = 3,                # nur 3 gespeicherte Checkpoints behalten, um Speicherplatz zu sparen
        eval_strategy = "steps",             # alle N Schritte evaluieren
        eval_steps = 10,                     # wie viele Schritte, bis wir die Evaluation durchführen
        load_best_model_at_end = True,       # MUSS für Early Stopping verwendet werden
        metric_for_best_model = "eval_loss", # Metrik, auf der wir Early Stopping anwenden möchten
        greater_is_better = False,           # je niedriger der Evaluierungsverlust, desto besser
    ),
    model = model,
    tokenizer = tokenizer,
    train_dataset = new_dataset["train"],
    eval_dataset = new_dataset["test"],
)
```

Dann fügen wir den Callback hinzu, der ebenfalls angepasst werden kann:

```python
from transformers import EarlyStoppingCallback
early_stopping_callback = EarlyStoppingCallback(
    early_stopping_patience = 3,     # Wie viele Schritte wir warten, wenn der Evaluierungsverlust nicht sinkt
                                     # Zum Beispiel könnte der Verlust steigen, aber nach 3 Schritten sinken
    early_stopping_threshold = 0.0,  # Kann höher gesetzt werden - legt fest, um wie viel der Verlust sinken soll, bis
                                     # wir Early Stopping in Betracht ziehen. Z. B. bedeutet 0.01, wenn der Verlust
                                     # 0.02 und dann 0.01 war, betrachten wir den Lauf als frühzeitig zu stoppen.
)
trainer.add_callback(early_stopping_callback)
```

Dann trainieren Sie das Modell wie üblich über `trainer.train() .`


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://unsloth.ai/docs/de/grundlagen/finetuning-from-last-checkpoint.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.