👁️Affinage en vision

Apprenez à affiner des LLM vision/multimodaux avec Unsloth

L'affinage (fine-tuning) des modèles de vision permet au modèle d'exceller dans certaines tâches pour lesquelles les LLM classiques ne sont pas aussi performants, telles que la détection d'objets/mouvements. Vous pouvez également entraîner des VLMs avec RL. Nous avons de nombreux notebooks gratuits pour l'affinage en vision :

• Qwen3-VL (8B) Vision : Notebook

• Ministral 3 : affinage vision pour Q&R général : Notebook On peut concaténer des ensembles de données de Q&R général avec des ensembles de données plus spécialisés pour empêcher l'affinage d'oublier les compétences du modèle de base.

• Gemma 3 (4B) Vision : Notebook

• Llama 3.2 Vision affinage pour radiographie : Notebook Comment pouvons-nous aider les professionnels de la santé à analyser plus rapidement les radiographies, les scanners et les é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 toutes de la même taille/dimensions. Utilisez des dimensions de 300 à 1000 px pour garantir que l'entraînement ne prenne pas trop de temps ni n'utilise trop de ressources.

Désactivation de la vision / affinage texte uniquement

Pour affiner les modèles de vision, nous vous permettons désormais 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 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 = meilleure précision, mais peut suradapter
    lora_alpha = 16,                  # Alpha recommandé == r au moins
    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",
    ],
)

Vision Data Collator

Nous avons un data collator spécial uniquement pour les jeux de données vision :

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

Et les arguments pour le data collator 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 les sauts de ligne également !

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

Entraînement multi-image

Pour affiner ou entraîner des modèles avec plusieurs images, le changement le plus simple est de remplacer :

ds_converted = ds.map(
    convert_to_conversation,
)

par :

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

L'utilisation de map déclenche la standardisation du jeu de données et les règles de traitement arrow qui peuvent être strictes et plus compliquées à définir.

Jeu de données pour l'affinage en vision

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

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 présentant des conditions et des 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.

Examinons le 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'affinage 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 allons créer une instruction personnalisée demandant au VLM d'être un radiographe expert. Notez aussi qu'au lieu d'une seule instruction, vous pouvez ajouter plusieurs tours pour en faire une conversation dynamique.

instruction = "Vous êtes un radiographe expert. 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 au format "correct" pour l'affinage :

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 radiographe expert. 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 tout affinage, peut-être que le modèle de vision sait déjà comment 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 radiographe expert. 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 démontre des structures dentaires normales.
* Il existe une zone anormale en haut à droite, représentée par une zone d'os radiotranslucide, 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. L'une des flèches est positionnée à gauche, et l'autre à droite. Cependant, seulement

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

🔎Entraîner 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 comme précédemment ! Voir Vision Data Collator pour plus de détails sur la façon d'utiliser le vision data collator.

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 les sauts de ligne également !
)

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