📈Guide des jeux de données

Apprenez à créer et préparer un jeu de données pour le fine-tuning.

Qu'est-ce qu'un ensemble de données ?

Pour les LLM, les ensembles de données sont des collections de données pouvant être utilisées pour entraîner nos modèles. Pour être utiles à l'entraînement, les données textuelles doivent être dans un format pouvant être tokenisé. Vous apprendrez aussi comment utiliser des ensembles de données dans Unsloth.

Une des parties clés de la création d'un ensemble de données est votre modèle de chat et comment vous allez le concevoir. La tokenisation est également importante car elle divise le texte en tokens, qui peuvent être des mots, des sous-mots ou des caractères afin que les LLM puissent le traiter efficacement. Ces tokens sont ensuite transformés en embeddings et ajustés pour aider le modèle à comprendre le sens et le contexte.

Format des données

Pour permettre le processus de tokenisation, les ensembles de données doivent être dans un format pouvant être lu par un tokenizer.

Format	Description	Type d'entraînement
Corpus brut	Texte brut provenant d'une source telle qu'un site web, un livre ou un article.	Pré-entraînement continu (CPT)
Instruct	Instructions pour que le modèle les suive et un exemple de sortie visé.	Fine-tuning supervisé (SFT)
Conversation	Conversation à multiples tours entre un utilisateur et un assistant IA.	Fine-tuning supervisé (SFT)
RLHF	Conversation entre un utilisateur et un assistant IA, avec les réponses de l'assistant classées par un script, un autre modèle ou un évaluateur humain.	Apprentissage par renforcement (RL)

Il convient de noter que différents styles de format existent pour chacun de ces types.

Commencer

Avant de formater nos données, nous voulons identifier les éléments suivants :

1

Objectif de l'ensemble de données

Connaître l'objectif de l'ensemble de données nous aidera à déterminer quelles données nous faut-il et le format à utiliser.

L'objectif pourrait être d'adapter un modèle à une nouvelle tâche telle que la synthèse ou d'améliorer la capacité d'un modèle à jouer un rôle spécifique. Par exemple :

• Dialogues basés sur le chat (Q&R, apprendre une nouvelle langue, support client, conversations).

• Tâches structurées (classification, résumé, tâches de génération).

• Données spécifiques à un domaine (médical, finance, technique).

2

Style de sortie

Le style de sortie nous indiquera quelles sources de données nous utiliserons pour atteindre le résultat souhaité.

Par exemple, le type de sortie que vous souhaitez obtenir pourrait être JSON, HTML, texte ou code. Ou peut-être voulez-vous que ce soit en espagnol, anglais ou allemand, etc.

3

Source des données

Lorsque nous connaissons l'objectif et le style des données dont nous avons besoin, nous devons analyser la qualité et quantité des données. Hugging Face et Wikipédia sont d'excellentes sources d'ensembles de données et Wikipédia est particulièrement utile si vous cherchez à entraîner un modèle à apprendre une langue.

La source des données peut être un fichier CSV, un PDF ou même un site web. Vous pouvez aussi générer synthétiquement des données mais il faut une attention supplémentaire pour s'assurer que chaque exemple soit de haute qualité et pertinent.

Une des meilleures façons de créer un meilleur ensemble de données est de le combiner avec un ensemble de données plus généralisé de Hugging Face comme ShareGPT pour rendre votre modèle plus intelligent et diversifié. Vous pouvez aussi ajouter des données générées synthétiquement.

🦥 Recettes de données Unsloth

Recettes de données Unsloth vous permet de téléverser des documents comme des fichiers PDF ou CSV et les transforme en ensembles de données utilisables. Créez et éditez des ensembles de données visuellement via un flux de travail par nœuds graphique.

La page des recettes est le point d'entrée principal. Les recettes sont stockées localement dans le navigateur, vous pouvez donc revenir à votre travail enregistré plus tard. Depuis ici, vous pouvez créer une recette vide ou ouvrir une recette d'apprentissage guidée.

Data Recipes suit le même chemin de base. Vous ouvrez la page des recettes, créez ou choisissez une recette, construisez le flux de travail dans l'éditeur, validez et exécutez un aperçu, puis lancez l'ensemble de données complet une fois que la sortie semble correcte. Ajoutez des données de départ et des blocs de génération, validez le flux de travail, prévisualisez un échantillon de sortie, puis lancez une construction complète de l'ensemble de données.

En un coup d'œil, un flux de travail habituel devrait ressembler à ceci :

1. Ouvrez la page des recettes.

2. Créez une nouvelle recette ou ouvrez-en une existante.

3. Ajoutez des blocs pour définir votre flux de travail de jeu de données.

4. Cliquez Valider pour détecter les problèmes de configuration tôt.

5. Exécutez un aperçu pour inspecter rapidement des lignes d'exemple.

6. Lancez une construction complète du jeu de données lorsque la recette est prête.

7. Consultez la progression et la sortie en direct dans le graphe ou dans Exécutions pour plus de détails.

8. Sélectionnez le jeu de données résultant dans Studio et affiner un modèle. En savoir plus :

Data Recipes

Formatage des données

Une fois que nous avons identifié les critères pertinents et collecté les données nécessaires, nous pouvons formater nos données dans un format lisible par machine prêt pour l'entraînement.

Formats de données courants pour l'entraînement des LLM

Pour pré-entraînement continu, nous utilisons le format texte brut sans structure spécifique :

  "text": "La pasta alla carbonara est un plat traditionnel de pâtes romain. La sauce est préparée en mélangeant des œufs crus avec du pecorino romano râpé et du poivre noir. Les pâtes chaudes sont ensuite mélangées avec du guanciale croustillant (joue de porc salée) et le mélange d'œufs, créant une sauce crémeuse grâce à la chaleur résiduelle. Contrairement à la croyance populaire, la carbonara authentique ne contient jamais de crème ni d'ail. Le plat est probablement originaire de Rome au milieu du XXe siècle, bien que ses origines exactes fassent l'objet de débats..."

Ce format préserve le flux du langage naturel et permet au modèle d'apprendre à partir d'un texte continu.

Si nous adaptons un modèle à une nouvelle tâche et que nous voulons que le modèle génère du texte en un seul tour basé sur un ensemble d'instructions spécifique, nous pouvons utiliser Format d'instruction en style Alpaca

"Instruction" : "Tâche que nous voulons que le modèle exécute."

"Input" : "Optionnel, mais utile, ce sera essentiellement la requête de l'utilisateur."

"Output" : "Le résultat attendu de la tâche et la sortie du modèle."

Lorsque nous voulons plusieurs tours de conversation, nous pouvons utiliser le format ShareGPT :

{
  "conversations" : [
    {
      "from" : "human",
      "value" : "Pouvez-vous m'aider à préparer une pasta carbonara ?"
    },
    {
      "from" : "gpt",
      "value" : "Voulez-vous la recette romaine traditionnelle ou une version plus simple ?"
    },
    {
      "from" : "human",
      "value" : "La version traditionnelle s'il vous plaît"
    },
    {
      "from" : "gpt",
      "value" : "La carbonara romaine authentique n'utilise que quelques ingrédients : pâtes, guanciale, œufs, pecorino romano et poivre noir. Voulez-vous la recette détaillée ?"
    }
  ]
}

Le format de modèle utilise les clés d'attribut "from"/"value" et les messages alternent entre humainet gpt, permettant un flux de dialogue naturel.

L'autre format courant est le format ChatML d'OpenAI et c'est celui par défaut sur Hugging Face. C'est probablement le format le plus utilisé, et il alterne entre utilisateur et assistant

{
  "messages" : [
    {
      "role" : "user",
      "content" : "Quel est 1+1 ?"
    },
    {
      "role" : "assistant",
      "content" : "C'est 2 !"
    },
  ]
}

Application de modèles de chat avec Unsloth

Pour les ensembles de données qui suivent généralement le format chatml courant, le processus de préparation de l'ensemble de données pour l'entraînement ou le fine-tuning consiste en quatre étapes simples :

• Vérifiez les modèles de chat que Unsloth prend actuellement en charge:\

  from unsloth.chat_templates import CHAT_TEMPLATES
  print(list(CHAT_TEMPLATES.keys()))

  Cela affichera la liste des modèles pris en charge actuellement par Unsloth. Voici un exemple de sortie :\

  ['unsloth', 'zephyr', 'chatml', 'mistral', 'llama', 'vicuna', 'vicuna_old', 'vicuna old', 'alpaca', 'gemma', 'gemma_chatml', 'gemma2', 'gemma2_chatml', 'llama-3', 'llama3', 'phi-3', 'phi-35', 'phi-3.5', 'llama-3.1', 'llama-31', 'llama-3.2', 'llama-3.3', 'llama-32', 'llama-33', 'qwen-2.5', 'qwen-25', 'qwen25', 'qwen2.5', 'phi-4', 'gemma-3', 'gemma3']

  \

• Utiliser get_chat_template pour appliquer le bon modèle de chat à votre tokenizer :\

  from unsloth.chat_templates import get_chat_template
  
  tokenizer = get_chat_template(
      tokenizer,
      chat_template = "gemma-3", # changez ceci pour le nom du chat_template approprié
  )

  \

• Définissez votre fonction de formatage. Voici un exemple :\

  def formatting_prompts_func(examples):
     convos = examples["conversations"]
     texts = [tokenizer.apply_chat_template(convo, tokenize = False, add_generation_prompt = False) for convo in convos]
     return { "text" : texts, }

  Cette fonction parcourt votre ensemble de données en appliquant le modèle de chat que vous avez défini à chaque échantillon.\

• Enfin, chargeons l'ensemble de données et appliquons les modifications requises à notre ensemble de données : \

  # Importer et charger l'ensemble de données
  from datasets import load_dataset
  dataset = load_dataset("repo_name/dataset_name", split = "train")
  
  # Appliquer la fonction de formatage à votre ensemble de données en utilisant la méthode map
  dataset = dataset.map(formatting_prompts_func, batched = True,)

  Si votre ensemble de données utilise le format ShareGPT avec les clés "from"/"value" au lieu du format ChatML "role"/"content", vous pouvez utiliser la standardize_sharegpt fonction pour le convertir d'abord. Le code révisé ressemblera maintenant à ce qui suit : \

  # Importer l'ensemble de données
  from datasets import load_dataset
  dataset = load_dataset("mlabonne/FineTome-100k", split = "train")
  
  # Convertir votre ensemble de données au format "role"/"content" si nécessaire
  from unsloth.chat_templates import standardize_sharegpt
  dataset = standardize_sharegpt(dataset)
  
  # Appliquer la fonction de formatage à votre ensemble de données en utilisant la méthode map
  dataset = dataset.map(formatting_prompts_func, batched = True,)

Questions/réponses sur le formatage des données

Q : Comment puis-je utiliser le format Alpaca instruct ?

R : Si votre ensemble de données est déjà formaté dans le format Alpaca, suivez alors les étapes de formatage comme indiqué dans Llama3.1 notebook . Si vous devez convertir vos données au format Alpaca, une approche consiste à créer un script Python pour traiter vos données brutes. Si vous travaillez sur une tâche de résumé, vous pouvez utiliser un LLM local pour générer des instructions et des sorties pour chaque exemple.

Q : Dois-je toujours utiliser la méthode standardize_sharegpt ?

R : N'utilisez la méthode standardize_sharegpt que si votre ensemble de données cible est formaté au format sharegpt, mais que votre modèle attend un format ChatML à la place.

Q : Pourquoi ne pas utiliser la fonction apply_chat_template fournie avec le tokenizer.

R : Le chat_template l'attribut lorsqu'un modèle est d'abord téléversé par les propriétaires originaux du modèle contient parfois des erreurs et peut prendre du temps à être mis à jour. En revanche, chez Unsloth, nous vérifions et corrigeons minutieusement toutes les erreurs dans le chat_template pour chaque modèle lorsque nous téléversons les versions quantifiées dans nos dépôts. De plus, nos get_chat_template et apply_chat_template méthodes offrent des fonctionnalités avancées de manipulation des données, qui sont entièrement documentées sur notre documentation des modèles de chat page.

Q : Que se passe-t-il si mon modèle n'est pas actuellement pris en charge par Unsloth ?

R : Soumettez une demande de fonctionnalité sur les issues GitHub d'unsloth forum. En solution temporaire, vous pouvez également utiliser la fonction apply_chat_template du tokenizer jusqu'à ce que votre demande de fonctionnalité soit approuvée et fusionnée.

Génération de données synthétiques

Vous pouvez également utiliser n'importe quel LLM local comme Llama 3.3 (70B) ou GPT-4.5 d'OpenAI pour générer des données synthétiques. En général, il est préférable d'utiliser un modèle plus grand comme Llama 3.3 (70B) pour garantir des sorties de la plus haute qualité. Vous pouvez utiliser directement des moteurs d'inférence comme vLLM, Ollama ou llama.cpp pour générer des données synthétiques, mais cela nécessitera un travail manuel pour les collecter et demander davantage de données. Il y a 3 objectifs pour les données synthétiques :

• Produire des données entièrement nouvelles - soit à partir de zéro soit à partir de votre ensemble de données existant

• Diversifier votre ensemble de données afin que votre modèle ne surapprenne et ne devienne trop spécifique

• Augmenter les données existantes p. ex. structurer automatiquement votre ensemble de données dans le format choisi correct

Utilisation d'Unsloth pour les données synthétiques

Vous pouvez facilement téléverser des données non structurées ou structurées dans Unsloth Studio's Recettes de données et il les convertira automatiquement en un ensemble de données utilisable / synthétique. Plus de détails dans notre guide.

Utiliser un LLM local ou ChatGPT pour des données synthétiques

Votre objectif est d'inciter le modèle à générer et traiter des données QA qui sont dans le format que vous avez spécifié. Le modèle devra apprendre la structure que vous avez fournie ainsi que le contexte, donc assurez-vous d'avoir au moins 10 exemples de données déjà. Exemples de prompts :

• Prompt pour générer plus de dialogues sur un ensemble de données existant:

  En utilisant l'exemple d'ensemble de données que j'ai fourni, suivez la structure et générez des conversations basées sur les exemples.

• Prompt si vous n'avez pas d'ensemble de données:

  {% code overflow="wrap" %}

  Créez 10 exemples d'avis produits pour Coca-Cola classés comme positifs, négatifs ou neutres.

  {% endcode %}

• Prompt pour un ensemble de données sans formatage:

  {% code overflow="wrap" %}

  Structurez mon ensemble de données afin qu'il soit au format QA ChatML pour le fine-tuning. Ensuite, générez 5 exemples de données synthétiques avec le même sujet et format.

  {% endcode %}

Il est recommandé de vérifier la qualité des données générées pour supprimer ou améliorer les réponses non pertinentes ou de mauvaise qualité. Selon votre ensemble de données, il peut aussi être nécessaire de l'équilibrer dans plusieurs domaines afin que votre modèle ne surapprenne pas. Vous pouvez ensuite réinjecter cet ensemble de données nettoyé dans votre LLM pour régénérer des données, maintenant avec encore plus d'orientations.

FAQ et conseils sur les ensembles de données

Quelle taille mon ensemble de données devrait-il avoir ?

Nous recommandons généralement d'utiliser un minimum d'au moins 100 lignes de données pour le fine-tuning afin d'obtenir des résultats raisonnables. Pour des performances optimales, un ensemble de données de plus de 1 000 lignes est préférable, et dans ce cas, plus de données conduisent généralement à de meilleurs résultats. Si votre ensemble de données est trop petit, vous pouvez également ajouter des données synthétiques ou ajouter un ensemble de données depuis Hugging Face pour le diversifier. Cependant, l'efficacité de votre modèle affiné dépend fortement de la qualité de l'ensemble de données, alors assurez-vous de nettoyer et préparer soigneusement vos données.

Comment devrais-je structurer mon ensemble de données si je veux affiner un modèle de raisonnement ?

Si vous voulez affiner un modèle qui possède déjà des capacités de raisonnement comme les versions distillées de DeepSeek-R1 (par ex. DeepSeek-R1-Distill-Llama-8B), vous devrez toujours suivre des paires question/tâche et réponse ; cependant, pour votre réponse vous devrez modifier la réponse afin qu'elle inclue le raisonnement/processus de chaîne de pensée et les étapes qu'il a suivies pour obtenir la réponse. Pour un modèle qui n'a pas de raisonnement et que vous voulez entraîner pour qu'il acquière plus tard des capacités de raisonnement, vous devrez utiliser un ensemble de données standard mais cette fois sans raisonnement dans ses réponses. Ce processus d'entraînement est connu sous le nom de Apprentissage par renforcement et GRPO.

Ensembles de données multiples

Si vous avez plusieurs ensembles de données pour le fine-tuning, vous pouvez soit :

• Standardiser le format de tous les ensembles de données, les combiner en un seul ensemble de données, et affiner sur cet ensemble unifié.

• Utiliser le Jeux de données multiples notebook pour affiner directement sur plusieurs ensembles de données.

Puis-je affiner plusieurs fois le même modèle ?

Vous pouvez affiner un modèle déjà affiné plusieurs fois, mais il est préférable de combiner tous les ensembles de données et d'effectuer le fine-tuning en un seul processus. Entraîner un modèle déjà affiné peut potentiellement altérer la qualité et les connaissances acquises lors du fine-tuning précédent.

Utilisation des ensembles de données dans Unsloth

Ensemble de données Alpaca

Voir un exemple d'utilisation de l'ensemble de données Alpaca dans Unsloth sur Google Colab :

Nous allons maintenant utiliser l'ensemble de données Alpaca créé en appelant GPT-4 lui-même. C'est une liste de 52 000 instructions et sorties qui a été très populaire lors de la sortie de Llama-1, car elle a rendu le fine-tuning d'un LLM de base compétitif avec ChatGPT lui-même.

Vous pouvez accéder à la version GPT4 de l'ensemble de données Alpaca ici. Ci-dessous sont montrés quelques exemples de l'ensemble de données :

Vous pouvez voir qu'il y a 3 colonnes dans chaque ligne - une instruction, un input et une sortie. Nous combinons essentiellement chaque ligne en 1 grand prompt comme ci-dessous. Nous utilisons ensuite cela pour affiner le modèle de langage, et cela l'a rendu très similaire à ChatGPT. Nous appelons ce processus fine-tuning supervisé par instruction.

Plusieurs colonnes pour le fine-tuning

Mais un gros problème pour les assistants de style ChatGPT est que nous n'autorisons qu'1 instruction / 1 prompt, et pas plusieurs colonnes / inputs. Par exemple dans ChatGPT, vous devez soumettre 1 prompt, et pas plusieurs prompts.

Cela signifie essentiellement que nous devons "fusionner" plusieurs colonnes en 1 grand prompt pour que le fine-tuning fonctionne réellement !

Par exemple le très célèbre ensemble de données Titanic a de nombreuses colonnes. Votre tâche était de prédire si un passager a survécu ou est mort en fonction de son âge, sa classe de passager, le prix du billet, etc. Nous ne pouvons pas simplement transmettre cela à ChatGPT, mais plutôt, nous devons "fusionner" ces informations en 1 grand prompt.

Par exemple, si nous demandons à ChatGPT avec notre prompt "fusionné" unique qui inclut toutes les informations pour ce passager, nous pouvons alors lui demander de deviner ou prédire si le passager est décédé ou a survécu.

D'autres bibliothèques de fine-tuning exigent que vous prépariez manuellement votre ensemble de données pour le fine-tuning, en fusionnant toutes vos colonnes en 1 prompt. Dans Unsloth, nous fournissons simplement la fonction appelée to_sharegpt qui fait cela en une seule fois !

Maintenant, c'est un peu plus compliqué, puisque nous permettons beaucoup de personnalisation, mais il y a quelques points :

• Vous devez entourer toutes les colonnes avec des accolades {}. Ce sont les noms de colonnes dans le fichier CSV / Excel réel.

• Les composants textuels optionnels doivent être entourés de [[]]. Par exemple si la colonne "input" est vide, la fonction de fusion n'affichera pas le texte et l'ignorera. Ceci est utile pour les ensembles de données avec des valeurs manquantes.

• Sélectionnez la colonne de sortie ou la colonne cible / prédiction dans output_column_name. Pour l'ensemble de données Alpaca, ce sera output.

Par exemple dans l'ensemble de données Titanic, nous pouvons créer un grand format de prompt fusionné comme ci-dessous, où chaque colonne / morceau de texte devient optionnel.

Par exemple, supposons que l'ensemble de données ressemble à ceci avec beaucoup de données manquantes :

Embarqué	Âge	Tarif
S	23
	18	7.25

Alors, nous ne voulons pas que le résultat soit :

1. Le passager a embarqué de S. Son âge est 23. Son tarif est VIDE.

2. Le passager a embarqué de VIDE. Son âge est 18. Son tarif est 7,25 $.

Au lieu de cela, en entourant éventuellement les colonnes à l'aide de [[]], nous pouvons exclure complètement cette information.

1. [[Le passager a embarqué de S.]] [[Son âge est 23.]] [[Son tarif est VIDE.]]

2. [[Le passager a embarqué de VIDE.]] [[Son âge est 18.]] [[Son tarif est 7,25 $.]]

devient :

1. Le passager a embarqué de S. Son âge est 23.

2. Son âge est 18. Son tarif est 7,25 $.

Conversations à plusieurs tours

Un problème, si vous ne l'avez pas remarqué, est que l'ensemble de données Alpaca est mono-tour, tandis que l'utilisation de ChatGPT était interactive et vous pouvez lui parler à plusieurs tours. Par exemple, à gauche est ce que nous voulons, mais à droite, l'ensemble de données Alpaca ne fournit que des conversations singulières. Nous voulons que le modèle affiné apprenne d'une manière ou d'une autre à faire des conversations à plusieurs tours comme ChatGPT.

Nous avons donc introduit le paramètre conversation_extension qui sélectionne essentiellement quelques lignes aléatoires de votre ensemble de données mono-tour et les fusionne en 1 conversation ! Par exemple, si vous le réglez sur 3, nous sélectionnons aléatoirement 3 lignes et les fusionnons en 1 ! Les définir trop long peut ralentir l'entraînement, mais cela peut rendre votre chatbot et le fine-tuning final bien meilleurs !

Puis définissez output_column_name sur la colonne de prédiction / sortie. Pour l'ensemble de données Alpaca, ce serait la colonne output.

Nous utilisons alors la fonction standardize_sharegpt pour simplement mettre l'ensemble de données dans un format correct pour le fine-tuning ! Appelez toujours ceci !

Fine-tuning Vision

L'ensemble de données pour l'affinement d'un modèle vision ou multimodal inclut é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 CT et les échographies.

Nous utiliserons une version échantillonnée de l'ensemble de données de radiographie ROCO. Vous pouvez accéder à l'ensemble de données ici. L'ensemble de données inclut des radiographies, des scanners CT 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.

Jetons un œil à l'ensemble 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 l'ensemble de données, toutes les tâches d'affinement 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 radiographe expert. Remarquez 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 l'ensemble 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 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 fine-tuning, peut-être que le modèle 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 montre des structures dentaires normales.
* Il y a 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. L'une des flèches est positionnée à gauche, l'autre à droite. Cependant, seulement

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