👁️Fine-tuning vision

Découvrez comment fine-tuner des LLM vision/multimodaux avec Unsloth

Le fine-tuning des modèles de vision permet au modèle d’exceller dans certaines tâches, là où les LLM classiques ne seront pas aussi performants, comme la détection d’objets/de mouvements. Vous pouvez également entraîner des VLM avec RL. Nous avons de nombreux notebooks gratuits pour le fine-tuning de la vision :

• Qwen3-VL (8B) Vision : Notebook

• Ministral 3: fine-tuning de la vision pour les questions-réponses générales : Notebook On peut concaténer des jeux de données de questions-réponses générales avec des jeux de données plus spécialisés afin que le fine-tuning n’oublie pas les compétences du modèle de base.

• Gemma 3 (4B) Vision : Notebook

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

• Qwen2.5 VL fine-tuning 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 vous assurer que votre entraînement ne prenne pas trop de temps ou n’utilise pas trop de ressources.

Désactivation du fine-tuning vision / texte uniquement

Pour fine-tuner des modèles de vision, nous vous permettons désormais de sélectionner quelles parties du modèle fine-tuner. Vous pouvez choisir de fine-tuner 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 la valeur est élevée, plus la précision est grande, mais risque de surapprentissage
    lora_alpha = 16,                  # Alpha recommandé == r au minimum
    lora_dropout = 0,
    bias = "none",
    random_state = 3407,
    use_rslora = False,               # Nous prenons en charge LoRA stabilisé en rang
    loftq_config = None,               # Et LoftQ
    target_modules = "all-linear",    # Désormais facultatif ! Peut spécifier une liste si nécessaire
    modules_to_save=[
        "lm_head",
        "embed_tokens",
    ],
)

Data collator pour la vision

Nous avons un collator de données spécial rien que pour les jeux de données de 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 du collator de données sont :

class UnslothVisionDataCollator:
def __init__(
self,
model,
processor,
max_seq_length  = None, # [Facultatif] Nous le récupérons automatiquement depuis `FastVisionModel.from_pretrained(max_seq_length = ...)
formatting_func = None, # Fonction de transformation du texte
resize = "min", # Peut être (10, 10) ou "min" pour redimensionner afin de s’adapter à la taille d’image par défaut du modèle, ou "max"
                # pour ne pas redimensionner et laisser l’image intacte
ignore_index = -100, # [Facultatif] La valeur par défaut est -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, # [Facultatif] Sélectionnera automatiquement le nombre de GPU
completion_only_loss = True, # [Facultatif] Ignore les tokens de vision de remplissage - devrait toujours être True !
pad_to_multiple_of = None, # [Facultatif] Pour le remplissage du collator de données
resize_dimension = 0, # peut être 0, 1, 'max' ou 'min'
                      # (max redimensionne selon le maximum entre la hauteur et la largeur, min selon la plus petite taille, 0 selon la première dimension, etc.)
snap_to_patch_size = False, # [Facultatif] Force l’image à être un multiple de la taille du patch
)

Entraînement multi-images

Pour fine-tuner ou entraîner des modèles avec plusieurs images, le changement le plus simple consiste à remplacer :

ds_converted = ds.map(
    convert_to_conversation,
)

par :

ds_converted = [convert_to_conversation(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 complexes à définir.

Jeu de données pour le fine-tuning de la vision

Le jeu de données pour fine-tuner un modèle de vision ou multimodal est similaire à une paire standard question-réponse bibliothèque datasets , mais cette fois, il inclut aussi des entrées d’image. Par exemple, le Notebook Llama 3.2 Vision utilise un cas de radiographie pour montrer comment l’IA peut aider les professionnels de santé à 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 illustrant des affections et des maladies médicales. Chaque image possède une légende rédigée par des experts la décrivant. L’objectif est de fine-tuner un VLM pour en faire un outil d’analyse utile aux professionnels de santé.

Voyons le jeu de données et vérifions ce que montre le 1er exemple :

Jeu de données({
    features: ['image', 'image_id', 'caption', 'cui'],
    num_rows: 1978
})

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

Pour formater le jeu de données, toutes les tâches de fine-tuning de 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 également 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 précisément ce que vous voyez dans 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 le fine-tuning :

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 précisément ce que vous voyez dans 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 partie postérieure droite du maxillaire avec résorption du plancher du sinus maxillaire (flèches).'}]}]}

Avant de faire du fine-tuning, peut-être que le modèle de 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 radiographe expert. Décrivez précisément ce que vous voyez dans 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, plus précisément un orthopantomogramme (OPG).

* La radiographie panoramique montre des structures dentaires normales.
* Il y a une zone anormale en haut à droite, représentée par une zone d’os radiotransparent, correspondant au sinus maxillaire.

**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 du côté gauche, et l’autre du côté droit. Cependant, seul

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

🔎Entraînement sur les réponses de l’assistant uniquement 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 auparavant ! Voir Fine-tuning vision pour plus de détails sur l’utilisation du collator de données de 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",
    ...
)