📈Guide des jeux de données

Découvrez comment créer et préparer un jeu de données pour le fine-tuning.

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

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

L'une des parties clés de la création d'un jeu de données est votre modèle de chat et la manière dont vous allez le concevoir. La tokenisation est également importante car elle découpe le texte en jetons, qui peuvent être des mots, des sous-mots ou des caractères, afin que les LLM puissent le traiter efficacement. Ces jetons sont ensuite convertis 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 jeux de données doivent être dans un format lisible 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)
Consigne	Instructions à suivre pour le modèle et un exemple de la sortie visée.	Ajustement fin supervisé (SFT)
Conversation	Conversation à plusieurs tours entre un utilisateur et un assistant IA.	Ajustement fin supervisé (SFT)
RLHF	Conversation entre un utilisateur et un assistant IA, les réponses de l'assistant étant classées par un script, un autre modèle ou un évaluateur humain.	Apprentissage par renforcement (RL)

Il convient de noter qu'il existe différents styles de format pour chacun de ces types.

Pour commencer

Avant de mettre nos données en forme, nous voulons identifier les éléments suivants :

1

Objectif du jeu de données

Connaître l'objectif du jeu de données nous aidera à déterminer quelles données nous devons utiliser et quel format adopter.

L'objectif peut être d'adapter un modèle à une nouvelle tâche, comme le résumé, ou d'améliorer la capacité d'un modèle à jouer le rôle d'un personnage spécifique. Par exemple :

• Dialogues basés sur le chat (Q&R, apprentissage d'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 la sortie souhaitée.

Par exemple, le type de sortie que vous souhaitez obtenir peut être du JSON, du HTML, du texte ou du code. Ou peut-être souhaitez-vous qu'il soit en espagnol, en anglais, en 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 la quantité des données. Hugging Face et Wikipédia sont d'excellentes sources de jeux 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 également générer de manière synthétique des données, mais un soin particulier est nécessaire pour s'assurer que chaque exemple est de haute qualité et pertinent.

L'une des meilleures façons de créer un meilleur jeu de données consiste à le combiner avec un jeu de données plus général issu de Hugging Face, comme ShareGPT, afin de rendre votre modèle plus intelligent et plus diversifié. Vous pourriez également 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 PDF ou des fichiers CSV et de les transformer en jeux de données utilisables. Créez et modifiez visuellement des jeux de données via un workflow de graphe de nœuds.

La page des recettes est le point d’entrée principal. Les recettes sont stockées localement dans le navigateur, ce qui vous permet de retrouver plus tard votre travail enregistré. À partir de là, vous pouvez créer une recette vierge 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, le validez, exécutez un aperçu, puis lancez le jeu 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 exemple de sortie, puis lancez la création complète du jeu de données.

À première vue, 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 le flux de travail de votre jeu de données.

4. Cliquez sur Validez pour détecter rapidement les problèmes de configuration.

5. Lancez un aperçu pour examiner rapidement des lignes d’exemple.

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

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

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

Data Recipes

Mise en forme des données

Lorsque nous avons identifié les critères pertinents et collecté les données nécessaires, nous pouvons alors mettre nos données en forme 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 un format de texte brut sans structure spécifique :

  "text": "Les pâtes carbonara sont un plat traditionnel romain. La sauce est préparée en mélangeant des œufs crus avec du fromage 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. Malgré l'idée reçue, la vraie carbonara 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 soient débattues..."

Ce format préserve le flux naturel du langage 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 en se basant sur un ensemble précis d'instructions, nous pouvons utiliser Instruction format en style Alpaca

"Instruction": "Tâche que nous voulons que le modèle réalise."

"Input": "Optionnel, mais utile ; il s'agira essentiellement de 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 à faire des pâtes carbonara ?"
    },
    {
      "from": "gpt",
      "value": "Souhaitez-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 vraie carbonara romaine utilise seulement quelques ingrédients : pâtes, guanciale, œufs, Pecorino Romano et poivre noir. Souhaitez-vous la recette détaillée ?"
    }
  ]
}

Le format modèle utilise les clés d'attributs « from »/« value » et les messages alternent entre humainet gpt, ce qui permet un flux naturel du dialogue.

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

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

Application des modèles de chat avec Unsloth

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

• Consultez les modèles de chat actuellement pris en charge par Unsloth :\

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

  Cela affichera la liste des modèles actuellement pris en charge 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']

  \

• Utilisez 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", # remplacez ceci par le bon nom de chat_template
  )

  \

• Définissez votre fonction de mise en forme. 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 jeu de données en appliquant le modèle de chat que vous avez défini à chaque exemple.\

• Enfin, chargeons le jeu de données et appliquons les modifications requises à notre jeu de données : \

  # Importer et charger le jeu de données
  from datasets import load_dataset
  dataset = load_dataset("repo_name/dataset_name", split = "train")
  
  # Appliquez la fonction de mise en forme à votre jeu de données à l'aide de la méthode map
  dataset = dataset.map(formatting_prompts_func, batched = True,)

  Si votre jeu 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 désormais à ceci : \

  # Importer le jeu de données
  from datasets import load_dataset
  dataset = load_dataset("mlabonne/FineTome-100k", split = "train")
  
  # Convertissez votre jeu de données au format « role »/« content » si nécessaire
  from unsloth.chat_templates import standardize_sharegpt
  dataset = standardize_sharegpt(dataset)
  
  # Appliquez la fonction de mise en forme à votre jeu de données à l'aide de la méthode map
  dataset = dataset.map(formatting_prompts_func, batched = True,)

Mise en forme des données Q&R

Q : Comment puis-je utiliser le format d'instruction Alpaca ?

R : Si votre jeu de données est déjà formaté au format Alpaca, suivez alors les étapes de mise en forme comme indiqué dans le notebook 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 jeu de données cible est au format sharegpt, mais que votre modèle attend à la place un format ChatML.

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

R : Le chat_template de l'attribut lorsqu'un modèle est d'abord téléversé par les propriétaires initiaux 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 toute erreur 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 : Et si mon modèle n'est actuellement pas pris en charge par Unsloth ?

R : Soumettez une demande de fonctionnalité sur le forum des issues GitHub d'Unsloth forum. Comme solution temporaire, vous pouvez aussi 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 vaut mieux utiliser un modèle plus grand comme Llama 3.3 (70B) afin de garantir la meilleure qualité de sortie. 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 demandera un peu de 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 jeu de données existant

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

• Compléter les données existantes, par exemple structurer automatiquement votre jeu de données dans le bon format choisi

Utiliser Unsloth pour les données synthétiques

Vous pouvez facilement téléverser n'importe quelles données non structurées ou structurées dans Recettes de données et il les convertira automatiquement en un jeu de données exploitable / synthétique. Plus de détails dans notre guide.

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

Votre objectif est de demander au modèle de générer et de traiter des données Q&R dans le format que vous avez spécifié. Le modèle devra apprendre la structure que vous avez fournie ainsi que le contexte ; veillez donc à disposer d'au moins 10 exemples de données déjà existants. Exemples d'invites :

• Invite pour générer davantage de dialogues à partir d'un jeu de données existant:

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

• Invite si vous n'avez pas de jeu 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 %}

• Invite pour un jeu de données sans mise en forme:

  {% code overflow="wrap" %}

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

  {% endcode %}

Il est recommandé de vérifier la qualité des données générées afin de supprimer ou d'améliorer les réponses hors sujet ou de mauvaise qualité. Selon votre jeu de données, il peut également être nécessaire de l'équilibrer sur de nombreux aspects afin que votre modèle ne surapprenne pas. Vous pouvez ensuite réinjecter ce jeu de données nettoyé dans votre LLM pour régénérer des données, cette fois avec encore plus de guidance.

FAQ + conseils sur les jeux de données

Quelle taille devrait avoir mon jeu de données ?

Nous recommandons généralement d'utiliser au minimum absolu 100 lignes de données pour le fine-tuning afin d'obtenir des résultats raisonnables. Pour des performances optimales, un jeu de données de plus de 1 000 lignes est préférable ; dans ce cas, davantage de données conduit généralement à de meilleurs résultats. Si votre jeu de données est trop petit, vous pouvez également ajouter des données synthétiques ou ajouter un jeu de données provenant de Hugging Face pour le diversifier. Cependant, l'efficacité de votre modèle ajusté dépend fortement de la qualité du jeu de données ; veillez donc à nettoyer et préparer vos données de manière approfondie.

Comment dois-je structurer mon jeu de données si je veux ajuster finement un modèle de raisonnement ?

Si vous voulez ajuster finement 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 tout de même suivre des paires question/tâche et réponse ; cependant, pour votre réponse, vous devrez la modifier afin qu'elle inclue un processus de raisonnement/chaîne de pensée et les étapes suivies pour dériver la réponse. Pour un modèle qui ne possède pas de raisonnement et que vous voulez entraîner afin qu'il acquière ensuite des capacités de raisonnement, vous devrez utiliser un jeu 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.

Plusieurs jeux de données

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

• Uniformiser le format de tous les jeux de données, les combiner en un seul jeu de données et effectuer le fine-tuning sur ce jeu de données unifié.

• Utilisez le Jeux de données multiples notebook pour effectuer directement le fine-tuning sur plusieurs jeux de données.

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

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

Utilisation des jeux de données dans Unsloth

Jeu de données Alpaca

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

Nous allons maintenant utiliser le jeu de données Alpaca créé en appelant GPT-4 lui-même. Il s'agit d'une liste de 52 000 instructions et sorties qui était très populaire lors de la sortie de Llama-1, car elle permettait de faire du fine-tuning d'un LLM de base pour rivaliser avec ChatGPT lui-même.

Vous pouvez accéder à la version GPT-4 du jeu de données Alpaca ici. Ci-dessous figurent quelques exemples du jeu de données :

Vous pouvez voir qu'il y a 3 colonnes dans chaque ligne - une instruction, une entrée et une sortie. Nous combinons essentiellement chaque ligne en une grande invite comme ci-dessous. Nous l'utilisons ensuite pour ajuster finement le modèle de langage, ce qui l'a rendu très similaire à ChatGPT. Nous appelons ce processus le fine-tuning supervisé par instructions.

Plusieurs colonnes pour le fine-tuning

Mais un gros problème est que, pour les assistants de style ChatGPT, nous n'autorisons qu'une seule instruction / une seule invite, et non plusieurs colonnes / entrées. Par exemple, dans ChatGPT, vous pouvez voir que nous devons soumettre une seule invite, et non plusieurs invites.

Cela signifie essentiellement que nous devons « fusionner » plusieurs colonnes en une seule grande invite pour que le fine-tuning fonctionne réellement !

Par exemple, le très célèbre jeu de données Titanic comporte énormément de colonnes. Votre travail consistait à prédire si un passager avait survécu ou péri en fonction de son âge, de sa classe de passager, du prix du billet, etc. Nous ne pouvons pas simplement transmettre cela à ChatGPT ; nous devons plutôt « fusionner » ces informations en une seule grande invite.

Par exemple, si nous interrogeons ChatGPT avec notre unique invite « fusionnée » qui inclut toutes les informations sur ce passager, nous pouvons alors lui demander de deviner ou de prédire si le passager est mort ou a survécu.

D'autres bibliothèques de fine-tuning vous obligent à préparer manuellement votre jeu de données pour le fine-tuning, en fusionnant toutes vos colonnes en une seule invite. 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é, car nous permettons beaucoup de personnalisation, mais il y a quelques points :

• Vous devez entourer toutes les colonnes d'accolades {}. Ce sont les noms de colonnes dans le vrai fichier CSV / Excel.

• 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. Cela est utile pour les jeux de données comportant des valeurs manquantes.

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

Par exemple, dans le jeu de données Titanic, nous pouvons créer un grand format d'invite fusionnée comme ci-dessous, où chaque colonne / fragment de texte devient optionnel.

Par exemple, imaginez que le jeu 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é à S. Son âge est 23. Son tarif est VIDE.

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

Au lieu de cela, en entourant les colonnes de façon optionnelle avec [[]], nous pouvons exclure entièrement cette information.

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

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

devient :

1. Le passager a embarqué à 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 le jeu de données Alpaca est à tour unique, alors que rappelez-vous, l'utilisation de ChatGPT était interactive et vous pouviez lui parler en plusieurs tours. Par exemple, la partie gauche est ce que nous voulons, mais la partie droite, qui est le jeu de données Alpaca, ne fournit que des conversations uniques. Nous voulons que le modèle de langage ajusté apprenne d'une manière ou d'une autre à faire des conversations à plusieurs tours, tout comme ChatGPT.

Nous avons donc introduit le conversation_extension paramètre, qui sélectionne essentiellement quelques lignes aléatoires dans votre jeu de données à tour unique et les fusionne en une seule conversation ! Par exemple, si vous le réglez sur 3, nous sélectionnons aléatoirement 3 lignes et les fusionnons en 1 ! Le régler trop haut peut rendre l'entraînement plus lent, mais pourrait rendre votre chatbot et votre fine-tuning final bien meilleurs !

Puis définissez output_column_name à la colonne de prédiction / sortie. Pour le jeu de données Alpaca dataset, ce serait la colonne de sortie.

Nous utilisons ensuite la standardize_sharegpt fonction pour simplement mettre le jeu de données dans un format correct pour le fine-tuning ! Appelez toujours cette fonction !

Fine-tuning vision

Le jeu de données destiné au fine-tuning d'un modèle de vision ou multimodal comprend é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 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 comprend des radiographies, des scanners et des échographies montrant des affections et des maladies médicales. Chaque image possède une légende rédigée par des experts qui la décrit. L'objectif est d'ajuster finement un VLM pour en faire un outil d'analyse utile aux professionnels de santé.

Regardons le jeu de données et voyons ce que montre le premier 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 mettre le jeu de données en forme, toutes les tâches de fine-tuning 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 rédiger une consigne 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 avec précision 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 « bon » format pour le fine-tuning :

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

Le premier exemple est désormais 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 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, le modèle de vision sait peut-être 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 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 radiotransparente, correspondant à l'antre.

**Observations clés**

* L'os entre les dents supérieures gauche 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, seulement

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