Modelltrainingsleitfaden 3: PT-Trainingsleitfaden

Kontinuierliches Vortraining (Continual Pre-training / PT) besteht darin, ein großes Modell, das bereits über allgemeine Fähigkeiten verfügt, mit einer großen Menge an Branchen-Dokumenten, Büchern oder Code (Raw Text) zu füttern und das Modell durch die Aufgabe der **Next Token Prediction** neues Wissen aufnehmen zu lassen.

Als Techniker sollten Sie sich merken: PT dient dazu, das Modell auf **reinem Text ohne Frage-Antwort-Format** die **Sprachverteilung, Fachterminologie und den logischen Hintergrund** eines bestimmten Bereichs zu lernen.

## PT-Datenvorbereitung (die grundlegendste Grundlage)

- **Datenform**: Reiner Text (Raw Text). Es werden keine `instruction` oder `output`-Labels benötigt.
- **Dateiformat**: In der Regel `.txt` oder `.jsonl` (jede Zeile ein `{"text": "..."}`).
- **Verarbeitungslogik**: Das Modell lernt diese Inhalte durch die "Vorhersage des nächsten Tokens".

## Zwei praktische Umsetzungsschritte

### 1. LLaMA-Factory

**Anwendungsbereich**: Verfügt über eine GPU-Umgebung und strebt höchste Effizienz an.

**Schritte**:

1. **Datenregistrierung**: Legen Sie den Text in `data/` ab und fügen Sie ihn in `data/dataset_info.json` hinzu:

```JSON
"my_corpus": {
  "file_name": "your_data.jsonl",
  "columns": {
    "prompt": "text"
  }
}
```

2. **Schreiben Sie `pt_config.yaml`**:

```YAML
stage: pt # Wichtig: Auf Vortrainingsphase festlegen
model_name_or_path: qwen/Qwen2.5-7B
dataset: my_corpus
finetuning_type: lora # oder full (Full-Training erfordert extrem viel GPU-Speicher)
lora_target: all # Auf alle linearen Schichten abzielen, PT empfiehlt vollständige Abdeckung
cutoff_len: 1024 # Kontext-Abschneidelänge
learning_rate: 1e-5 # Die PT-Lernrate muss klein sein
num_train_epochs: 1.0
output_dir: ./pt_output
```

3. **Führen Sie den Befehl aus**:

```Bash
llamafactory-cli train pt_config.yaml
```

### 2. Schreiben Sie Ihren eigenen Code

Basierend auf der Transformers-Bibliothek

**Anwendungsbereich**: Tiefgreifende Anpassung von Loss oder Tokenizer.

**Schritte**:

1. **Laden Sie das Modell**: Verwenden Sie `AutoModelForCausalLM`.
2. **Kerncode-Logik**:

```Python
from transformers import Trainer, TrainingArguments, DataCollatorForLanguageModeling

# 1. Daten-Collator vorbereiten (für PT)
# mlm=False steht für kausales Sprachmodellierungs-Task (Next Token Prediction)
data_collator = DataCollatorForLanguageModeling(tokenizer, mlm=False)

# 2. Trainingskonfiguration
training_args = TrainingArguments(
    output_dir="./output",
    per_device_train_batch_size=4,
    learning_rate=1e-5,
    weight_decay=0.01,
    num_train_epochs=1,
    save_steps=500
)

# 3. Training starten
trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_dataset,
    data_collator=data_collator,
)
trainer.train()
```

## PT-Trainings-Technikdetails – häufige Fehler

1. **Lernrate (Learning Rate)**: Die Lernrate für PT muss um eine **Größenordnung niedriger** sein als bei SFT (in der Regel $10^{-5}$ oder $10^{-6}$). Da das Basismodell bereits sehr stark ist, würde eine hohe Lernrate seine ursprünglichen logischen Fähigkeiten zerstören.
2. **Datenqualität**: PT ist extrem empfindlich gegenüber der Datenqualität. Wenn Ihr Korpus eine große Menge an Duplikaten, Müll oder minderwertigen Webdaten enthält, wird das Modell schnell "dümmer".
3. **Bezüglich Ollama**: Nochmals betont: **Ollama dient zum "Ausführen" von Modellen, nicht zum "Trainieren" von Modellen**. Die Gewichte, die Sie mit den oben genannten Schritten 2 oder 3 trainiert haben, können erst dann für Ollama verwendet werden, wenn Sie sie im GGUF-Format exportiert haben.

**Zusammenfassende Empfehlung**: Verwenden Sie zuerst **LLaMA-Factory**, um PT erfolgreich durchzuführen, da es Datenslicing, Modellladen und LoRA-Konfiguration integriert und die fehlerfreiste Methode ist.