👁️Vision-Feinabstimmung

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

Feinabstimmung von Vision-Modellen ermöglicht es dem Modell, bei bestimmten Aufgaben zu glänzen, 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-Feinabstimmungen:

• Qwen3-VL (8B) Vision: Notebook

• Ministral 3: Vision-Feinabstimmung für allgemeine Q&A: Notebook Man kann allgemeine Q&A-Datensätze mit spezialisierteren 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 medizinisches Fachpersonal 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, komplexe mathematische Formeln leicht als LaTeX zu transkribieren, ohne sie manuell schreiben zu müssen.

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

Deaktivieren von Vision- / Nur-Text-Feinabstimmung

Um Vision-Modelle zu finetunen, 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 zu finetunen! Standardmäßig haben wir sie alle aktiviert!

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

    r = 16,                           # Je größer, desto höher die Genauigkeit, kann aber overfitten
    lora_alpha = 16,                  # Empfohlen: 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:

class UnslothVisionDataCollator:
def __init__(
self,
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 standardmäßige image_size des Modells zu skalieren, oder "max"
                # für kein Skalieren und 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, # Ä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, # Gleiche auch Zeilenumbrüche ab!

num_proc         = None, # [Optional] Wählt automatisch die Anzahl der GPUs
completion_only_loss = True, # [Optional] Ignoriert Padding-Vision-Tokens - sollte immer True sein!
pad_to_multiple_of = None, # [Optional] Für Padding im Data Collator
resize_dimension = 0, # kann 0, 1, 'max' oder 'min' sein
                      # (max skaliert basierend auf dem Maximum aus Höhe und Breite, min auf das Minimum, 0 nimmt 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 zu finetunen oder zu trainieren, ist die einfachste Änderung, Folgendes auszutauschen:

ds_converted = ds.map(
    convert_to_conversation,
)

mit:

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

Die Verwendung von map aktiviert Datensatz-Standardisierung und Arrow-Verarbeitungsregeln, die streng sein und schwerer zu definieren sein können.

Datensatz für Vision-Feinabstimmung

Der Datensatz für die Feinabstimmung eines Vision- oder multimodalen Modells ähnelt dem Standard Frage-&-Antwort-Paar Datensätzen , aber diesmal enthalten sie auch Bild-Eingaben. Zum Beispiel das Llama 3.2 Vision Notebook verwendet einen Radiographie-Fall, um zu zeigen, wie KI medizinischen Fachkräften helfen kann, Röntgenaufnahmen, CT-Scans und Ultraschall effizienter zu analysieren.

Wir werden eine stichprobenartige Version des ROCO-Radiographie-Datensatzes verwenden. 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 geschriebene Bildunterschrift, die es beschreibt. Das Ziel ist, einen VLM zu finetunen, um ihn zu einem nützlichen Analysewerkzeug für medizinisches Fachpersonal zu machen.

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

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

Bild	Bildunterschrift
	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-Feinabstimmungsaufgaben 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, die den VLM auffordert, ein erfahrener Radiograph zu sein. Beachten Sie auch, dass Sie statt nur einer Anweisung mehrere Durchläufe hinzufügen können, um es zu einem dynamischen Gespräch zu machen.

instruction = "Sie sind ein erfahrener Radiograph. 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 }
pass

Konvertieren wir den Datensatz in das "richtige" Format für die Feinabstimmung:

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 Radiograph. 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 irgendwelche Feinabstimmungen vornehmen: Weiß das Vision-Modell vielleicht bereits, wie man die Bilder analysiert? Prüfen wir, ob das der Fall ist!

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

image = dataset[0]["image"]
instruction = "Sie sind ein erfahrener Radiograph. Beschreiben Sie genau, 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:

Dieser Röntgenbefund scheint eine Panoramaaufnahme des Ober- und Untergebisses zu sein, genauer ein Orthopantomogramm (OPG).

* Die Panoramaaufnahme zeigt normale Zahnstrukturen.
* Es gibt einen abnormen Bereich oben rechts, dargestellt durch einen Bereich mit strahlendurchlässigem Knochen, entsprechend dem Antrum.

**Wesentliche Beobachtungen**

* Der Knochen zwischen den linken oberen Zähnen ist relativ strahlendicht.
* Es gibt zwei große Pfeile über dem Bild, die eine genauere Untersuchung dieses Bereichs nahelegen. Einer der Pfeile befindet sich auf der linken Seite und der andere auf der rechten Seite. Allerdings nur

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

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

Für Sprachmodelle können wir verwenden from unsloth.chat_templates import train_on_responses_only wie zuvor beschrieben. Für Vision-Modelle verwenden Sie die zusätzlichen Argumente als Teil von UnslothVisionDataCollator genau wie zuvor! Siehe Vision Data Collator für weitere Details zur Verwendung des Vision Data 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, # Ä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, # Gleiche auch Zeilenumbrüche ab!
)

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",
    ...
)