Neben SFT kann das Training von Large Language Models auch Verstärkendes Lernen (Reinforcement Learning, RL) verwenden. Im Gegensatz zu SFT, das direkt Standardantworten liefert, bewertet verstärkendes Lernen hauptsächlich mit Belohnungssignalen die Qualität der modellgenerierten Ergebnisse und passt das Ausgabeverhalten des Modells basierend auf Belohnungsergebnissen kontinuierlich an. SFT und verstärkendes Lernen gehören beide zur Nachschulungsphase von Large Language Models. Nachschulung bezeichnet eine Reihe von Schulungen, die durchgeführt werden, nachdem das Modell die Großverarbeitungsvorabgeschult abgeschlossen hat, mit dem Ziel, die Instruction-Following-, Reasoning- und spezifische Aufgabenfähigkeiten weiter zu verbessern. Das Training von Large Language Models verwendet normalerweise zuerst SFT, um zu lernen, wie Aufgaben gemäß Anweisungen ausgeführt werden, und kombiniert dann verstärkendes Lernen und andere Methoden, um die Antwortqualität und das Verhaltensverhalten des Modells weiter zu optimieren.

Volle Parameter, LoRA und QLoRA — was ist der Unterschied?

Je nach Trainingsmethode und Hardware-Ressourcen können Sie zwischen LoRA, QLoRA oder Full-Parameter-Feinabstimmung wählen. Die verschiedenen Methoden unterscheiden sich in der Anzahl der Trainingsparameter, dem GPU-Speicherverbrauch und den Rechenkosten.

1. Full-Parameter-Feinabstimmung: Beim Training werden alle Parameter des Modells aktualisiert, sodas das Modell umfassendere Anpassungen vornehmen kann. Full-Parameter-Feinabstimmung erfordert deutlich mehr GPU-Speicher und Rechenressourcen, was zu höheren Trainingskosten führt.

2. LoRA-Feinabstimmung (Low-Rank Adaptation): Um die Hardware-Ressourcenanforderungen für die Feinabstimmung von Large Language Models zu reduzieren, besteht LoRA's Kernidee darin, die Gewichte des vortrainierten Modells einzufrieren und trainierbare Rangzerlegungsmatrizen in jede Schicht der Transformer-Architektur zu injizieren, wodurch die Anzahl der trainierbaren Parameter für Downstream-Aufgaben erheblich reduziert wird. Beim Training müssen nur die ursprünglichen Modellparameter eingefroren werden, und die Dimensionsreduktionsmatrix A und Dimensionserhöhungsmatrix B werden trainiert. Ein schematisches Diagramm von LoRA ist unten zu sehen.

Genauer gesagt, angenommen die vortrainierte Matrix ist $W_0 \in \mathbb{R}^{d \times k}$, kann ihre Aktualisierung ausgedrückt werden als:

W = W_0 + \Delta W = W_0 + BA

Wobei $\Delta W$ die Gewichtsänderungen repräsentiert, die während der Feinabstimmung gelernt werden müssen:

B \in \mathbb{R}^{d \times r}, \quad
A \in \mathbb{R}^{r \times k}, \quad
r \ll \min(d,k)

A und B sind neue Parameter, die von LoRA hinzugefügt werden und am Training teilnehmen. Nach dem Modelltraining erhalten Sie eine separate LoRA-Adapter-Datei, die die Parameter dieser Feinabstimmung speichert. Bei der Verwendung müssen Sie sowohl das Basismodell als auch den entsprechenden Adapter laden.

3. QLoRA-Feinabstimmung (Quantized LoRA): LoRA reduziert hauptsächlich den Ressourcenaufwand durch Trainingsparameter, aber das Basismodell selbst muss weiterhin in den GPU-Speicher geladen werden. Wenn das Modell groß ist, kann das Laden des Basismodells weiterhin viel GPU-Speicher verbrauchen. Um den GPU-Speicherbedarf weiter zu reduzieren, können Sie QLoRA-Feinabstimmung verwenden.

Die zugehörige Modellarchitektur ist unten dargestellt. Wie zu sehen ist, ist QLoRA eine Verbesserung von LoRA, und die Hauptidee der Verbesserung besteht darin, 4-Bit-Genauigkeit und paginierte Optimierung gemeinsam zu verwenden, um den GPU-Speicherverbrauch zu reduzieren.

QLoRA kann einfach als Kombination aus Quantisierung und LoRA verstanden werden. Es quantisiert das Basismodell mit geringerer Genauigkeit. QLoRA's Hauptinnovationen umfassen:

1. 4-Bit NormalFloat (NF4): NF4 ist ein neuer Datentyp, der für normalverteilte Gewichte informationstheoretisch optimal ist;

2. Doppelquantisierung: Doppelquantisierung reduziert die durchschnittliche Speichernutzung durch Re-Quantisierung bereits quantisierter Konstanten;

3. Paginierte Optimierer: Paginierte Optimierer helfen, Speacherspitzen zu verwalten und Speicherfehler beim Gradienten-Checkpointing zu verhindern.

Wie wählt man eine Feinabstimmungsmethode: beginnen Sie mit Aufgabe und GPU

Die Wahl der Feinabstimmungsmethode erfordert hauptsächlich die Berücksichtigung der Modellskala, der Aufgabenanforderungen, der GPU-Ressourcen und der Trainingskosten. Verschiedene Methoden haben ihre eigenen Anwendungsszenarien — es stimmt nicht unbedingt, dass das Aktualisieren mehrerer Modellparameter zu besseren Feinabstimmungsergebnissen führt. Für die meisten Feinabstimmungsaufgaben können Sie zuerst LoRA ausprobieren. LoRA erfordert nur das Training einer kleinen Anzahl neuer Parameter, hat relativ geringe Anforderungen an GPU-Speicher und Rechenressourcen, und die resultierenden Adapter-Dateien sind ebenfalls relativ klein, was die Speicherung erleichtert.

Wenn das Basismodell groß ist, kann selbst bei LoRA-Verwendung nach dem Laden des Modells nicht genügend GPU-Speicher für das Training vorhanden sein. In diesem Fall können Sie QLoRA in Betracht ziehen. QLoRA reduziert den GPU-Speicherverbrauch des Basismodells durch Quantisierung, sodass größere Modelle mit begrenzten GPU-Ressourcen feinabgestimmt werden können. QLoRA ist besser für Szenarien mit großer Modellskala und begrenzten GPU-Ressourcen geeignet.

Wenn die GPU-Ressourcen relativ ausreichend sind und die Aufgabe umfassendere Modellanpassungen erfordert, können Sie Full-Parameter-Feinabstimmung in Betracht ziehen. Da alle Modellparameter während des Trainings aktualisiert werden müssen, hat Full-Parameter-Feinabstimmung höhere Anforderungen an GPU-Speicher, Rechenressourcen und Trainingsdaten, und die Kosten für das Training und Speichern von Modellen sind ebenfalls höher. Sie müssen daher basierend auf der tatsächlichen Aufgabe entscheiden, ob dies notwendig ist.

In tatsächlichen Projekten können wir zuerst die Wirkung zu geringeren Kosten überprüfen und dann basierend auf den tatsächlichen Bedürfnissen entscheiden, ob die Trainingskosten erhöht werden sollen. Wenn LoRA bereits die erwarteten Ergebnisse erzielen kann, ist es normalerweise nicht notwendig, Full-Parameter-Feinabstimmung nur zur Aktualisierung weiterer Parameter zu wählen.

ms-swift verwenden, um eine Feinabstimmung durchzuführen

Welche Arbeit kann ms-swift uns ersparen?

ms-swift (SWIFT, Scalable lightWeight Infrastructure for Fine-Tuning) ist ein Open-Source-Modelltrainings- und Bereitstellungsframework der ModelScope-Community. Es richtet sich hauptsächlich an Large Language Models und multimodale Large Language Models und bietet ein vollständiges Werkzeugset von Modelltraining und Feinabstimmung bis hin zu Inferenz, Bewertung und Bereitstellung.

Derzeit unterstützt es Mainstream-Large-Language-Models wie Qwen, DeepSeek, Llama, GLM und InternLM sowie multimodale Modelle wie Qwen-VL und InternVL. Es unterstützt auch das Training für Aufgaben wie Embedding, Reranker und Textklassifikation.

Weitere Verwendungsmethoden finden Sie unter ms-swift.

Neben dem Training bietet ms-swift auch einen relativ vollständigen Modellverwendungsablauf. Nach dem Training können Sie direkt swift infer zur Modellinferenz verwenden oder das Modell als OpenAI-kompatiblen API-Dienst über swift deploy bereitstellen. Für Inferenz und Bereitstellung können Sie auch Inferenzmaschinen wie vLLM, SGLang und LMDeploy zur Beschleunigung kombinieren.

Für Anfänger ist eines der Merkmale von ms-swift, dass es viele komplexe Konfigurationen im Large-Model-Trainingsprozess kapselt. Sie können eine Modellfeinabstimmung durchgeben des Basismodells, der Trainingsdaten, der Feinabstimmungsmethode und der Trainingsparameter über Kommandozeilenargumente abschließen. Im folgenden Experiment verwenden wir ms-swift, um einen vollständigen Modellfeinabstimmungsablauf durchzuführen, einschließlich der Vorbereitung der Trainingsdaten, des Starts des LoRA-Trainings, der Überprüfung der Trainingsergebnisse, der Zusammenführung der LoRA-Gewichte und des Ladens des feinabgestimmten Modells für Inferenz und Bereitstellung.

Praktisches Training mit einer Entity-Erkennungsaufgabe

Nachfolgend verwenden wir eine Entity-Erkennungsaufgabe als Beispiel, um den vollständigen Modellfeinabstimmungsablauf in der ModelScope-Notebook-Ugebung zu demonstrieren, einschließlich Datenvorbereitung, Modelltraining und Inferenz nach der Feinabstimmung. Durch dieses Beispiel können Sie lernen, wie man ms-swift verwendet, um Large-Model-Feinabstimmung von Grund auf durchzuführen. Dieses Experiment verwendet weiterhin das ubuntu22.04-cuda12.8.1-py312-torch2.10.0-1.39.0-Image als Laufzeitumgebung.

1) Überprüfen Sie, ob ms-swift bereits in der Umgebung installiert ist. Beachten Sie, dass der Paketname ms_swift lautet.

!pip3 list |grep ms_swift

Wenn Sie eine Ausgabe im folgenden Format sehen, ist ms-swift bereits installiert:

Wenn nicht installiert, führen Sie aus:

!pip3 install ms-swift

2. Datenvorbereitung. Dieses Experiment verwendet Open-Source-Daten zur Entity-Erkennung im E-Commerce. Der Datensatz enthält vier Entity-Typen: HCCX (Produktname), HPPX (Markenname), XH (Produktmodell) und MISC (andere Entities einschließlich Land, Größe/Kapazität, Person, Werk und Aktivitätsnamen).

3) Erstellen Sie zunächst ein Verzeichnis mit dem Namen data, laden Sie dann die Daten per Rechtsklick in den Ordner hoch. Das Datenformat ist wie folgt. Diese Aufgabe erfordert nur, dass das Modell Entity-Kategorien, Entities und deren Startpositionen im Text ausgibt. Die Daten werden in Trainings- und Testsets aufgeteilt, wobei train.jsonl 5.400 Einträge und val.jsonl 600 Einträge enthält.

{"messages":[{"role":"system","content":"Sie sind ein Entity-Erkennungsmodell. Bitte identifizieren Sie Entities im Text des Benutzers. Geben Sie Entities streng in ihrer Reihenfolge des Auftretens im Originaltext aus, jede Entity auf einer separaten Zeile im Format: (Typ, Entity-Text, Startposition). Die Startposition beginnt bei 0; der Typ kann nur HCCX, HPPX, MISC oder XH sein. Wenn keine Entities vorhanden sind, geben Sie nur aus: Keine Entities. Geben Sie keine Erklärungen, Markdown oder anderen Inhalt aus."},{"role":"user","content":"Push bb skincare guasha l back therapy Olivenkoerper-Massageoel Kuel-Massageoel Massageoel-Massageoel Massage-00"},{"role":"assistant","content":"(HCCX,Olivenoel,10)\n(HCCX,Massageoel,20)\n(HCCX,Oel,24)\n(HCCX,Oel,27)"}]}

Verzeichnisstruktur wie folgt:

4. Modelltraining. Dieser Abschnitt verwendet Qwen/Qwen3-0.6B zur Feinabstimmung. Geben Sie den folgenden Befehl direkt im Terminal ein, um das Training zu starten:

!CUDA_VISIBLE_DEVICES=0 swift sft \
  --model Qwen/Qwen3-0.6B \
  --dataset data/train.jsonl \
  --val_dataset data/val.jsonl \
  --tuner_type lora \
  --target_modules all-linear \
  --lora_rank 16 \
  --lora_alpha 32 \
  --lora_dropout 0.05 \
  --torch_dtype bfloat16 \
  --num_train_epochs 2 \
  --per_device_train_batch_size 4 \
  --per_device_eval_batch_size 4 \
  --gradient_accumulation_steps 4 \
  --learning_rate 1e-4 \
  --warmup_ratio 0.05 \
  --max_length 512 \
  --eval_strategy steps \
  --eval_steps 100 \
  --save_strategy steps \
  --save_steps 100 \
  --save_total_limit 3 \
  --logging_steps 10 \
  --load_from_cache_file true \
  --dataset_num_proc 4 \
  --dataloader_num_workers 4 \
  --output_dir output/qwen3_0_6b_ner_lora

Beschreibungen der Ker parameter:

Nach dem Start des Trainings gibt ms-swift kontinuierlich die aktuellen Trainingsinformationen aus, wie unten gezeigt:

Das Training ist abgeschlossen — wie verwenden wir das Modell?

LoRA-Gewichte in das Basismodell zurückführen

Nach Abschluss des LoRA-Trainings wird der entsprechende LoRA-Adapter gespeichert. Der Adapter ist kein vollständiges Large Language Model, daher müssen Sie weiterhin das ursprüngliche Basismodell laden, wenn Sie es verwenden. Über das output_dir im Trainingskrippel können Sie die Checkpoints und entsprechenden Adapter-Dateien im Verzeichnis sehen. Bei der tatsächlichen Bereitstellung können Sie den LoRA-Adapter in das Basismodell zusammenführen, um ein vollständiges Modell zu erzeugen, was für Offline-Bereitstellung oder Modellmigration bequemer ist. Die Verzeichnisstruktur nach dem Modelltraining lautet wie folgt:

Modellzusammenführungsbefehl:

!CUDA_VISIBLE_DEVICES=0 swift export \
  --adapters output/qwen3_0_6b_ner_lora/v2-20260903-172616/checkpoint-676 \
  --merge_lora true \
  --output_dir output/qwen3_0_6b_ner_merged

Wobei --adapters den Pfad zum trainierten LoRA-Checkpoint angibt, --merge_lora true die Zusammenführung der LoRA-Parameter in das Basismodell anzeigt und --output_dir das Speicherverzeichnis für das zusammengeführte Modell angibt.

Ausführungsergebnis:

Das feinabgestimmte Modell laden und den Effekt testen

Nach der Zusammenführung können Sie das erzeugte vollständige Modell direkt für Inferenz laden. Zur Bequemlichkeit der Anwendungsaufrufe können Sie das Modell auch als OpenAI-kompatible Schnittstelle starten, auf die über API zugegriffen wird. Dies ist auch ein dauerhafter Dienst, der im Terminal gestartet werden muss. Sie können Kapitel 7 konsultieren, wie man Befehle im Terminal startet. Der Startbefehl lautet wie folgt:

CUDA_VISIBLE_DEVICES=0 swift deploy \
  --model output/qwen3_0_6b_ner_merged \
  --load_args false \
  --infer_backend vllm \
  --enable_thinking false \
  --host 0.0.0.0 \
  --port 8000 \
  --served_model_name qwen3-0.6b-ner \
  --api_key 123 \
  --vllm_gpu_memory_utilization 0.7 \
  --vllm_max_model_len 1024 \
  --max_new_tokens 128

Parameterbeschreibungen:

Nach dem Start des Modells lautet das Ergebnis wie folgt:

Nach dem Start des Modells können Sie die Konnektivität über die Schnittstelle testen. Code wie folgt:

import json
import requests

url = "http://127.0.0.1:8000/v1/chat/completions"

headers = {
    "Authorization": "Bearer 123",
    "Content-Type": "application/json"
}

payload = {
    "model": "qwen3-0.6b-ner",
    "messages": [
        {
            "role": "system",
            "content": "Sie sind ein Entity-Erkennungsmodell. Bitte identifizieren Sie Entities im Text des Benutzers. Geben Sie Entities streng in ihrer Reihenfolge des Auftretens im Originaltext aus, jede Entity auf einer separaten Zeile im Format: (Typ, Entity-Text, Startposition). Die Startposition beginnt bei 0; der Typ kann nur HCCX, HPPX, MISC oder XH sein. Wenn keine Entities vorhanden sind, geben Sie nur aus: Keine Entities. Geben Sie keine Erklärungen, Markdown, Think-Tags oder anderen Inhalt aus."
        },
        {
            "role": "user",
            "content": "3539,2017 Feuerloeschkugel rutschfeste verschleissfeste hohe Stiefel fuer Katastrophenhilfe und Rettung"
        }
    ],
    "temperature": 0,
    "max_tokens": 128
}

try:
    response = requests.post(url, headers=headers, json=payload, timeout=30)
    response.raise_for_status()

    result = response.json()

    output_text = result["choices"][0]["message"]["content"]
    print("Erkennungsergebnis:")
    print(output_text)

except requests.exceptions.RequestException as e:
    print(f"Anfrage fehlgeschlagen: {e}")

Modellausgabe. Wir können auch reguläre Ausdrücke verwenden, um die Think-Tags zu entfernen:

Alle Experimentdaten und Code dieses Kapitels finden Sie unter: https://modelscope.cn/gallery/liucong/ab458cbd-b47f-4830-91b6-314ea2036fc6