> For the complete documentation index, see [llms.txt](https://unsloth.ai/docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://unsloth.ai/docs/de/grundlagen/finetuning-from-last-checkpoint.md).

# 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 im Trainer Folgendes ausführen:

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

Dadurch wird vom neuesten Checkpoint aus gestartet und das Training fortgesetzt.

### 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, tun Sie `trainer.train()`; um das Training fortzusetzen, tun 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 mache ich Early Stopping?

Wenn Sie den Finetuning-/Trainingslauf stoppen oder pausieren möchten, weil der Evaluierungsverlust nicht sinkt, können Sie Early Stopping verwenden, das den Trainingsprozess stoppt. 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 zum Speichern des Modells
        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 zur Evaluation
        load_best_model_at_end = True,       # MUSS für Early Stopping verwendet werden
        metric_for_best_model = "eval_loss", # Metrik, bei der wir Early Stopping anwenden wollen
        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 wieder sinken
    early_stopping_threshold = 0.0,  # Kann höher gesetzt werden - legt fest, um wie viel der Verlust sinken muss, bis
                                     # wir Early Stopping in Betracht ziehen. Z. B. bedeutet 0.01, dass wenn der Verlust war
                                     # 0.02 dann 0.01, betrachten wir den Lauf als frühzeitig gestoppt.
)
trainer.add_callback(early_stopping_callback)
```

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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.