👁️Fine-tuning Vision

Apprenez à fine-tuner des LLM vision/multimodaux avec Unsloth

L'affinage des modèles visuels permet au modèle d'exceller dans certaines tâches pour lesquelles les LLM normaux ne sont pas aussi performants, comme la détection d'objets/mouvements. Vous pouvez également entraîner des VLM avec RL. Nous disposons de nombreux notebooks gratuits pour l'affinage en vision :

• Qwen3-VL (8B) Vision : Notebook

• Ministral 3 : affinage en vision pour Q&R générale : Notebook On peut concaténer des jeux de données de Q&R générale avec des jeux de données plus spécialisés pour éviter que l'ajustement n'oublie les compétences du modèle de base.

• Gemma 3 (4B) Vision : Notebook

• Llama 3.2 Vision affinage pour la radiographie : Notebook Comment pouvons-nous aider les professionnels de santé à analyser plus rapidement les radiographies, scanners et échographies.

• Qwen2.5 VL affinage pour convertir l'écriture manuscrite en LaTeX : Notebook Cela permet de transcrire facilement des formules mathématiques complexes en LaTeX sans les écrire manuellement.

Il est préférable de s'assurer que votre jeu de données contient des images de toutes les mêmes tailles/dimensions. Utilisez des dimensions de 300 à 1000 px pour garantir que votre entraînement ne prenne pas trop de temps ou n'utilise pas trop de ressources.

Désactivation de la vision / Affinage uniquement texte

Pour affiner les modèles de vision, nous vous permettons maintenant de sélectionner quelles parties du modèle affiner. Vous pouvez choisir d'affiner uniquement les couches de vision, ou les couches de langage, ou les couches d'attention / MLP ! Nous les activons toutes par défaut !

model = FastVisionModel.get_peft_model(
    model,
    finetune_vision_layers     = True, # False si vous n'affinez pas les couches de vision
    finetune_language_layers   = True, # False si vous n'affinez pas les couches de langage
    finetune_attention_modules = True, # False si vous n'affinez pas les couches d'attention
    finetune_mlp_modules       = True, # False si vous n'affinez pas les couches MLP

    r = 16,                           # Plus grand = plus de précision, mais peut sur-apprendre
    lora_alpha = 16,                  # Alpha recommandé == r au minimum
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
    use_rslora = False,               # Nous supportons LoRA stabilisé en rang
    loftq_config = None,               # Et LoftQ
    target_modules = "all-linear",    # Optionnel maintenant ! Peut spécifier une liste si nécessaire
    modules_to_save=[
        "lm_head",
        "embed_tokens",
    ],
)

Collecteur de données Vision

Nous avons un collecteur de données spécial juste pour les jeux de données vision :

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

Et les arguments pour le collecteur de données sont :

class UnslothVisionDataCollator :
def __init__(
self,
model,
processor,
max_seq_length  = None, # [Optionnel] Nous récupérons automatiquement ceci depuis `FastVisionModel.from_pretrained(max_seq_length = ...)
formatting_func = None, # Fonction pour transformer le texte
resize = "min", # Peut être (10, 10) ou "min" pour redimensionner afin d'adapter la image_size par défaut du modèle ou "max"
                # pour ne pas redimensionner et laisser l'image intacte
ignore_index = -100, # [Optionnel] Par défaut -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 à train_on_responses_only pour les LLMs
instruction_part = None, # ÉQUIVALENT à train_on_responses_only(instruction_part = ...)
response_part    = None, # ÉQUIVALENT à train_on_responses_only(response_part = ...)
force_match      = True, # Faire correspondre aussi les sauts de ligne !

num_proc         = None, # [Optionnel] Sélectionnera automatiquement le nombre de GPU
completion_only_loss = True, # [Optionnel] Ignore les tokens de vision de remplissage - doit toujours être True !
pad_to_multiple_of = None, # [Optionnel] Pour le padding du collecteur de données
resize_dimension = 0, # peut être 0, 1, 'max' ou 'min'
                      # (max redimensionne selon le maximum entre hauteur et largeur, min selon le minimum, 0 la première dimension, etc)
snap_to_patch_size = False, # [Optionnel] Forcer l'image à être un multiple de la taille de patch
)

Jeu de données pour l'affinage en vision

Le jeu de données pour affiner un modèle vision ou multimodal est similaire à une paire question & réponse standard – Nous pouvons charger le jeu de données Elise en utilisant la , mais cette fois, ils incluent également des entrées d'image. Par exemple, le Notebook Vision Llama 3.2 utilise un cas de radiographie pour montrer comment l'IA peut aider les professionnels médicaux à analyser les radiographies, les scanners et les échographies plus efficacement.

Nous utiliserons une version échantillonnée du jeu de données de radiographie ROCO. Vous pouvez accéder au jeu de données ici. Le jeu de données inclut des radiographies, des scanners et des échographies montrant des conditions et maladies médicales. Chaque image a une légende rédigée par des experts la décrivant. L'objectif est d'affiner un VLM pour en faire un outil d'analyse utile pour les professionnels médicaux.

Jetons un œil au jeu de données et vérifions ce que montre le 1er exemple :

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

Image	Légende
	La radiographie panoramique montre une lésion ostéolytique dans la maxillaire postérieure droite avec résorption du plancher du sinus maxillaire (flèches).

Pour formater le jeu de données, toutes les tâches d'ajustement fin vision doivent être formatées comme suit :

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

Nous rédigerons une instruction personnalisée demandant au VLM d'être un expert en radiographie. Remarquez aussi qu'au lieu d'une seule instruction, vous pouvez ajouter plusieurs tours pour en faire une conversation dynamique.

instruction = "Vous êtes un expert en radiographie. Décrivez avec précision ce que vous voyez sur cette image."

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

Convertissons le jeu de données dans le format « correct » pour l'ajustement fin :

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

Le premier exemple est maintenant structuré comme ci-dessous :

converted_dataset[0]

{'messages': [{'role': 'user',
   'content': [{'type': 'text',
     'text': 'Vous êtes un expert en radiographie. Décrivez avec précision ce que vous voyez sur cette image.'},
    {'type': 'image',
     'image': <PIL.PngImagePlugin.PngImageFile image mode=L size=657x442>}]},
  {'role': 'assistant',
   'content': [{'type': 'text',
     'text': 'La radiographie panoramique montre une lésion ostéolytique dans la maxillaire postérieure droite avec résorption du plancher du sinus maxillaire (flèches).'}]}]}

Avant de faire un quelconque ajustement fin, peut-être que le modèle vision sait déjà analyser les images ? Vérifions si c'est le cas !

FastVisionModel.for_inference(model) # Activer pour l'inférence !

image = dataset[0]["image"]
instruction = "Vous êtes un expert en radiographie. Décrivez avec précision ce que vous voyez sur cette image."

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)

Et le résultat :

Cette radiographie semble être une vue panoramique de la dentition supérieure et inférieure, spécifiquement un orthopantomogramme (OPG).

* La radiographie panoramique montre des structures dentaires normales.
* Il existe une zone anormale en haut à droite, représentée par une zone d'os radiotransparent, correspondant à l'antre.

**Observations clés**

* L'os entre les dents supérieures gauches est relativement radio-opaque.
* Il y a deux grandes flèches au-dessus de l'image, suggérant la nécessité d'un examen plus approfondi de cette zone. Une des flèches est située à gauche et l'autre à droite. Cependant, uniquement

Pour plus de détails, consultez notre section jeux de données dans le notebook ici.

guide VLM GRPO

Pour affiner ou entraîner un VLM comme Qwen3-VL avec plusieurs images, le changement le plus simple est d'échanger

Afin d'affiner ou d'entraîner Qwen3-VL avec plusieurs images, le changement le plus simple consiste à remplacer
    ds_converted = ds.map(
)

convert_to_conversation,

par :

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

🔎Entraînement uniquement sur les réponses de l'assistant pour les modèles de vision, VLMs

Pour les modèles de langage, nous pouvons utiliser from unsloth.chat_templates import train_on_responses_only comme décrit précédemment. Pour les modèles de vision, utilisez les arguments supplémentaires dans UnslothVisionDataCollator tout comme avant ! Voir Fine-tuning Vision pour plus de détails sur l'utilisation du collecteur de données vision.

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 à train_on_responses_only pour les LLMs
    instruction_part = None, # ÉQUIVALENT à train_on_responses_only(instruction_part = ...)
    response_part    = None, # ÉQUIVALENT à train_on_responses_only(response_part = ...)
    force_match      = True, # Faire correspondre aussi les sauts de ligne !
)

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