👁️Vision-Feinabstimmung

Lerne, wie man Vision-/Multimodal-LLMs mit Unsloth feinabstimmt

Durch Feinabstimmung von Vision-Modellen kann das Modell bei bestimmten Aufgaben glänzen, bei denen normale LLMs nicht so gut sind, wie z. B. bei der Objekterkennungs-/Bewegungserkennung. Sie können auch trainieren VLMs mit RL. Wir haben viele kostenlose Notebooks für Vision-Fine-Tuning:

• Qwen3-VL (8B) Vision: Notebook

• Ministral 3: Vision-Fine-Tuning für allgemeines Frage-und-Antworten: Notebook Man kann allgemeine Frage-und-Antworten-Datensätze mit spezielleren Datensätzen zusammenführen, damit das Fine-Tuning die Fähigkeiten des Basismodells nicht vergisst.

• Gemma 3 (4B) Vision: Notebook

• Llama 3.2 Vision Fine-Tuning für Röntgenbildgebung: Notebook Wie können wir medizinische Fachkräfte dabei unterstützen, Röntgenaufnahmen, CT-Scans und Ultraschalluntersuchungen schneller zu analysieren.

• Qwen2.5 VL Fine-Tuning zum Umwandeln von Handschrift in LaTeX: Notebook Dadurch können komplexe mathematische Formeln ohne manuelles Abtippen leicht als LaTeX transkribiert werden.

Es ist am besten sicherzustellen, dass Ihr Datensatz Bilder alle in derselben Größe/mit denselben Abmessungen enthält. Verwenden Sie Abmessungen von 300–1000 px, damit Ihr Training nicht zu lange dauert und nicht zu viele Ressourcen verbraucht.

Vision-/Nur-Text-Fine-Tuning deaktivieren

Um Vision-Modelle feinabzustimmen, können Sie jetzt auswählen, welche Teile des Modells feinabgestimmt werden sollen. Sie können nur die Vision-Schichten, nur die Sprachschichten oder die Attention-/MLP-Schichten auswählen! Standardmäßig aktivieren wir alle!

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True, # False, wenn keine Vision-Layer feinabgestimmt werden
    finetune_language_layers   = True, # False, wenn keine Sprach-Layer feinabgestimmt werden
    finetune_attention_modules = True, # False, wenn keine Attention-Layer feinabgestimmt werden
    finetune_mlp_modules       = True, # False, wenn keine MLP-Layer feinabgestimmt werden

    r = 16,                           # Je größer, desto höher die Genauigkeit, aber möglicherweise Overfitting
    lora_alpha = 16,                  # Empfohlene Alpha mindestens == r
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
    use_rslora = False,               # Wir unterstützen rank-stabilisiertes LoRA
    loftq_config = None,               # Und LoftQ
    target_modules = "all-linear",    # Jetzt optional! Kann bei Bedarf eine Liste angegeben werden
    modules_to_save=[
        "lm_head",
        "embed_tokens",
    ],
)

Vision-Daten-Collator

Wir haben einen speziellen Daten-Collator nur für Vision-Datensätze:

from unsloth.trainer import UnslothVisionDataCollator
from trl import SFTTrainer, SFTConfig
trainer = SFTTrainer(
    model = model,
    tokenizer = tokenizer,
    data_collator = UnslothVisionDataCollator(model, tokenizer),
    train_dataset = dataset,
    args = SFTConfig(...),
)

Und die Argumente für den Daten-Collator sind:

class UnslothVisionDataCollator:
def __init__(
self,
model,
processor,
max_seq_length  = None, # [Optional] Wir ermitteln dies automatisch aus `FastVisionModel.from_pretrained(max_seq_length = ...)`
formatting_func = None, # Funktion zum Transformieren des Textes
resize = "min", # Kann (10, 10) oder "min" sein, um die Größe an die Standard-image_size des Modells anzupassen, oder "max"
                # für keine Größenänderung und das Bild unverändert lassen
ignore_index = -100, # [Optional] Standard ist -100

# from unsloth.chat_templates import train_on_responses_only
# trainer = train_on_responses_only(
#     trainer,
#     instruction_part = "<|start_header_id|>user<|end_header_id|>\n\n",
#     response_part = "<|start_header_id|>assistant<|end_header_id|>\n\n",
# )
train_on_responses_only = False, # ENTSPRICHT train_on_responses_only für LLMs
instruction_part = None, # ENTSPRICHT train_on_responses_only(instruction_part = ...)
response_part    = None, # ENTSPRICHT train_on_responses_only(response_part = ...)
force_match      = True, # Neue Zeilen ebenfalls abgleichen!

num_proc         = None, # [Optional] Wählt automatisch die Anzahl der GPUs aus
completion_only_loss = True, # [Optional] Ignoriert Padding-Vision-Tokens - sollte immer True sein!
pad_to_multiple_of = None, # [Optional] Für das Padding des Daten-Collators
resize_dimension = 0, # kann 0, 1, 'max' oder 'min' sein
                      # (max passt sich an das Maximum von Höhe und Breite an, min an die minimale Größe, 0 an die erste Dimension usw.)
snap_to_patch_size = False, # [Optional] Erzwingt, dass das Bild ein Vielfaches der Patch-Größe ist
)

Training mit mehreren Bildern

Um Modelle mit mehreren Bildern feinabzustimmen oder zu trainieren, ist die naheliegendste Änderung, Folgendes auszutauschen:

ds_converted = ds.map(
    convert_to_conversation,
)

gegen:

ds_converted = [convert_to_conversation(sample) for sample in dataset]

Die Verwendung von map löst eine Standardisierung des Datensatzes und Arrow-Verarbeitungsregeln aus, die streng und komplizierter zu definieren sein können.

Datensatz für Vision-Fine-Tuning

Der Datensatz für die Feinabstimmung eines Vision- oder multimodalen Modells ähnelt einem Standard-Frage-und-Antwort-Paar datasets , enthält diesmal aber auch Bildeingaben. Zum Beispiel verwendet das Llama 3.2 Vision Notebook einen Röntgenfall, um zu zeigen, wie KI medizinische Fachkräfte dabei unterstützen kann, Röntgenaufnahmen, CT-Scans und Ultraschalluntersuchungen effizienter zu analysieren.

Wir verwenden eine gekürzte Version des ROCO-Röntgendatensatzes. Sie können auf den Datensatz zugreifen hier. Der Datensatz enthält Röntgenaufnahmen, CT-Scans und Ultraschallbilder, die medizinische Zustände und Krankheiten zeigen. Jedes Bild hat eine von Experten verfasste Bildunterschrift, die es beschreibt. Ziel ist es, ein VLM so feinabzustimmen, dass es zu einem nützlichen Analysewerkzeug für medizinische Fachkräfte wird.

Werfen wir einen Blick auf den Datensatz und prüfen wir, was das erste Beispiel zeigt:

Dataset({
    features: ['image', 'image_id', 'caption', 'cui'],
    num_rows: 1978
})

Bild	Bildunterschrift
	Panoramaröntgen zeigt eine osteolytische Läsion im rechten hinteren Oberkiefer mit Resorption des Bodens der Kieferhöhle (Pfeile).

Um den Datensatz zu formatieren, sollten alle Vision-Fine-Tuning-Aufgaben wie folgt formatiert werden:

[
{ "role": "user",
  "content": [{"type": "text",  "text": instruction}, {"type": "image", "image": image} ]
},
{ "role": "assistant",
  "content": [{"type": "text",  "text": answer} ]
},
]

Wir erstellen eine eigene Anweisung, in der das VLM gebeten wird, ein Experte für Radiologie zu sein. Beachten Sie außerdem, dass Sie anstelle von nur einer Anweisung mehrere Gesprächsrunden hinzufügen können, um eine dynamische Unterhaltung zu erzeugen.

instruction = "Sie sind ein Experte für Radiologie. Beschreiben Sie präzise, was Sie in diesem Bild sehen."

def convert_to_conversation(sample):
    conversation = [
        { "role": "user",
          "content" : [
            {"type" : "text",  "text"  : instruction},
            {"type" : "image", "image" : sample["image"]} ]
        },
        { "role" : "assistant",
          "content" : [
            {"type" : "text",  "text"  : sample["caption"]} ]
        },
    ]
    return { "messages" : conversation }
pass

Lassen Sie uns den Datensatz in das „richtige“ Format für das Fine-Tuning umwandeln:

converted_dataset = [convert_to_conversation(sample) for sample in dataset]

Das erste Beispiel ist nun wie unten strukturiert:

converted_dataset[0]

{'messages': [{'role': 'user',
   'content': [{'type': 'text',
     'text': 'Sie sind ein Experte für Radiologie. Beschreiben Sie präzise, was Sie in diesem Bild sehen.'},
    {'type': 'image',
     'image': <PIL.PngImagePlugin.PngImageFile image mode=L size=657x442>}]},
  {'role': 'assistant',
   'content': [{'type': 'text',
     'text': 'Panoramaröntgen zeigt eine osteolytische Läsion im rechten hinteren Oberkiefer mit Resorption des Bodens der Kieferhöhle (Pfeile).'}]}]}

Bevor wir irgendein Fine-Tuning durchführen, kennt das Vision-Modell vielleicht bereits, wie man die Bilder analysiert? Lassen Sie uns prüfen, ob das der Fall ist!

FastVisionModel.for_inference(model) # Für Inferenz aktivieren!

image = dataset[0]["image"]
instruction = "Sie sind ein Experte für Radiologie. Beschreiben Sie präzise, was Sie in diesem Bild sehen."

messages = [
    {"role": "user", "content": [
        {"type": "image"},
        {"type": "text", "text": instruction}
    ]}
]
input_text = tokenizer.apply_chat_template(messages, add_generation_prompt = True)
inputs = tokenizer(
    image,
    input_text,
    add_special_tokens = False,
    return_tensors = "pt",
).to("cuda")

from transformers import TextStreamer
text_streamer = TextStreamer(tokenizer, skip_prompt = True)
_ = model.generate(**inputs, streamer = text_streamer, max_new_tokens = 128,
                   use_cache = True, temperature = 1.5, min_p = 0.1)

Und das Ergebnis:

Dieses Röntgenbild scheint eine Panoramaaufnahme des oberen und unteren Gebisses zu sein, genauer gesagt ein Orthopantomogramm (OPG).

* Das Panoramaröntgen zeigt normale Zahnstrukturen.
* Es gibt einen auffälligen Bereich oben rechts, dargestellt durch einen Bereich radioluzenten Knochens, der dem Antrum entspricht.

**Wichtige Beobachtungen**

* Der Knochen zwischen den linken oberen Zähnen ist relativ radiopak.
* Über dem Bild befinden sich zwei große Pfeile, die auf die Notwendigkeit einer genaueren Untersuchung dieses Bereichs hinweisen. Einer der Pfeile befindet sich links, der andere rechts. Allerdings nur

Weitere Details finden Sie in unserem Datensatzabschnitt im Notebook hier.

🔎Training nur auf Assistentenantworten für Vision-Modelle, VLMs

Für Sprachmodelle können wir from unsloth.chat_templates import train_on_responses_only wie zuvor beschrieben verwenden. Für Vision-Modelle verwenden Sie die zusätzlichen Argumente als Teil von UnslothVisionDataCollator genau wie zuvor! Siehe Vision-Feinabstimmung für weitere Details zur Verwendung des Vision-Daten-Collators.

class UnslothVisionDataCollator:
def __init__(
    self,
    ...
    # from unsloth.chat_templates import train_on_responses_only
    # trainer = train_on_responses_only(
    #     trainer,
    #     instruction_part = "<|start_header_id|>user<|end_header_id|>\n\n",
    #     response_part = "<|start_header_id|>assistant<|end_header_id|>\n\n",
    # )
    train_on_responses_only = False, # ENTSPRICHT train_on_responses_only für LLMs
    instruction_part = None, # ENTSPRICHT train_on_responses_only(instruction_part = ...)
    response_part    = None, # ENTSPRICHT train_on_responses_only(response_part = ...)
    force_match      = True, # Neue Zeilen ebenfalls abgleichen!
)

Zum Beispiel für Llama 3.2 Vision:

UnslothVisionDataCollator(
    model, tokenizer,
    ...
    train_on_responses_only = True,
    instruction_part = "<|start_header_id|>user<|end_header_id|>\n\n",
    response_part = "<|start_header_id|>assistant<|end_header_id|>\n\n", 
    ...
)