👁️Vision-Finetuning

Lerne, wie man Vision-/multimodale LLMs mit Unsloth finetunt

Das Feinabstimmen von Vision-Modellen ermöglicht dem Modell, in bestimmten Aufgaben zu brillieren, bei denen normale LLMs nicht so gut sind, wie z. B. Objekt-/Bewegungserkennung. Sie können auch trainieren VLMs mit RL. Wir haben viele kostenlose Notebooks für Vision-Feinabstimmung:

• Qwen3-VL (8B) Vision: Notebook

• Ministral 3: Vision-Feinabstimmung für allgemeine Q&A: Notebook Man kann allgemeine Q&A-Datensätze mit spezielleren Datensätzen verketten, damit die Feinabstimmung die Fähigkeiten des Basismodells nicht vergisst.

• Gemma 3 (4B) Vision: Notebook

• Llama 3.2 Vision Feinabstimmung für Radiographie: Notebook Wie können wir medizinische Fachkräfte dabei unterstützen, Röntgenaufnahmen, CT-Scans und Ultraschall schneller zu analysieren?

• Qwen2.5 VL Feinabstimmung zur Umwandlung von Handschrift in LaTeX: Notebook Dies ermöglicht es, komplexe mathematische Formeln einfach als LaTeX zu transkribieren, ohne sie manuell schreiben zu müssen.

Es ist am besten sicherzustellen, dass Ihr Datensatz Bilder aller gleichen Größe/Dimensionen enthält. Verwenden Sie Dimensionen von 300–1000 px, um sicherzustellen, dass Ihr Training nicht zu lange dauert oder zu viele Ressourcen verbraucht.

Deaktivierung von Vision- / Nur-Text-Feinabstimmung

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

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True, # False, wenn die Vision-Schichten nicht feinabgestimmt werden
    finetune_language_layers   = True, # False, wenn die Sprachschichten nicht feinabgestimmt werden
    finetune_attention_modules = True, # False, wenn die Attention-Schichten nicht feinabgestimmt werden
    finetune_mlp_modules       = True, # False, wenn die MLP-Schichten nicht feinabgestimmt werden

    r = 16,                           # Je größer, desto höher die Genauigkeit, kann aber überanpassen
    lora_alpha = 16,                  # Empfohlene Alpha == r mindestens
    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 angeben
    modules_to_save=[
        "lm_head",
        "embed_tokens",
    ],
)

Vision Data Collator

Wir haben einen speziellen Data 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 Data Collator sind:

genau wie zuvor!
class UnslothVisionDataCollator:
def __init__(
model,
processor,
max_seq_length  = None, # [Optional] Wir holen dies automatisch von `FastVisionModel.from_pretrained(max_seq_length = ...)
formatting_func = None, # Funktion zur Transformation des Textes
resize = "min", # Kann (10, 10) oder "min" sein, um auf die Standard-image_size des Modells zu skalieren oder "max"
                # für kein Skalieren und Beibehalten des Bildes
ignore_index = -100, # [Optional] Standard ist -100

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, # ÄQUIVALENT zu train_on_responses_only für LLMs
instruction_part = None, # ÄQUIVALENT zu train_on_responses_only(instruction_part = ...)
response_part    = None, # ÄQUIVALENT zu train_on_responses_only(response_part = ...)

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

Vision-Feinabstimmungs-Datensatz

Der Datensatz zur Feinabstimmung eines Vision- oder multimodalen Modells ähnelt dem standardmäßigen Frage-&-Antwort-Paar datasets , aber dieses Mal enthalten sie auch Bild-Eingaben. Zum Beispiel, die Llama 3.2 Vision Notebook verwendet einen radiologischen Fall, um zu zeigen, wie KI medizinischen Fachkräften helfen kann, Röntgenaufnahmen, CT-Scans und Ultraschalluntersuchungen effizienter zu analysieren.

Wir verwenden eine Stichprobe des ROCO-Radiographie-Datensatzes. 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 Bildbeschreibung. Ziel ist es, ein VLM zu fine-tunen, um es zu einem nützlichen Analysetool für medizinische Fachkräfte zu machen.

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

Dataset({
    Features: ['image', 'image_id', 'caption', 'cui'],
    Anzahl_Zeilen: 1978
})

Bild	Bildbeschreibung
	Panoramische Radiographie 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-Finetuning-Aufgaben wie folgt formatiert werden:

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

Wir werden eine benutzerdefinierte Anweisung erstellen, in der das VLM gebeten wird, ein expertenhafter Radiologe zu sein. Beachten Sie auch, dass Sie anstelle nur einer Anweisung mehrere Runden hinzufügen können, um es zu einem dynamischen Gespräch zu machen.

instruction = "Sie sind ein erfahrener Radiologe. Beschreiben Sie genau, 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 }
return { "text" : texts, }

Lassen Sie uns den Datensatz in das "korrekte" Format für das Fine-Tuning konvertieren:

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

Das erste Beispiel ist jetzt wie unten strukturiert:

converted_dataset[0]

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

Bevor wir mit dem Fine-Tuning beginnen: Weiß das Vision-Modell vielleicht bereits, wie man die Bilder analysiert? Lassen Sie es uns überprüfen!

FastVisionModel.for_inference(model) # Aktivieren für Inferenz!

image = dataset[0]["image"]
instruction = "Sie sind ein erfahrener Radiologe. Beschreiben Sie genau, was Sie in diesem Bild sehen."

Inference: Führen Sie Ihr trainiertes Modell aus
    {"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,
    add_generation_prompt = True,
).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:

Diese Röntgenaufnahme scheint eine Panoramaansicht des Ober- und Untergebisses zu sein, genauer ein Orthopantomogramm (OPG).

* Die Panoramaaufnahme zeigt normale Zahnstrukturen.
* Es gibt einen abnormen Bereich im oberen rechten Bereich, dargestellt durch eine radioluzente Knochenregion, die dem Antrum entspricht.

**Wesentliche Beobachtungen**

* Der Knochen zwischen den oberen linken Zähnen ist relativ radiopak.
* Es befinden sich zwei große Pfeile oberhalb des Bildes, die darauf hinweisen, dass dieser Bereich näher untersucht werden sollte. Einer der Pfeile befindet sich links, der andere rechts. Allerdings nur

Für weitere Details sehen Sie unseren Datensatzabschnitt in der Notebook hier.

Multi-Bild-Training

Um ein VLM wie Qwen3-VL mit Mehrfachbildern feinabzustimmen oder zu trainieren, ist die einfachste Änderung, zu tauschen

ds_converted = ds.map(
    convert_to_conversation,
)

durch:

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

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

🔎response_part = "<start_of_turn>model\n",

Training nur auf Assistentenantworten für Vision-Modelle, VLMs Für Llama 3, 3.1, 3.2, 3.3 und 4-Modelle definieren Sie die Teile wie folgt: Für Sprachmodelle können wir wie zuvor beschrieben verwenden. Für Vision-Modelle verwenden Sie die zusätzlichen Argumente als Teil von genau wie zuvor! Siehe Vision Data Collator für weitere Details zur Verwendung des Vision Data Collators.

genau wie zuvor!
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, # ÄQUIVALENT zu train_on_responses_only für LLMs
    instruction_part = None, # ÄQUIVALENT zu train_on_responses_only(instruction_part = ...)
    response_part    = None, # ÄQUIVALENT zu train_on_responses_only(response_part = ...)
)

force_match = True, # Übereinstimmung von Newlines ebenfalls!

Zum Beispiel für Llama 3.2 Vision:
    UnslothVisionDataCollator(
    ...
    model, tokenizer,
    trainer,
    instruction_part = "<|start_header_id|>user<|end_header_id|>\n\n",
    ...
)