📈Guide des jeux de données

Apprenez comment créer et préparer un jeu de données pour l'ajustement.

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

Pour les LLM, les jeux 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 jeux de données dans Unsloth.

L'un des éléments clés de la création d'un jeu de données est votre modèle de chat et la façon dont vous allez le concevoir. La tokenisation est également importante car elle découpe 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 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)
Instruct	Instructions pour que le modèle les suive et un exemple de sortie visée.	Ajustement supervisé (SFT)
Conversation	Conversation à plusieurs tours entre un utilisateur et un assistant IA.	Ajustement 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.

Prise en main

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

1

But du jeu de données

Connaître le but du jeu de données nous aidera à déterminer quelles données nous devons utiliser et le format à adopter.

Le but peut être d'adapter un modèle à une nouvelle tâche comme 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 (questions/réponses, apprendre une nouvelle langue, support client, conversations).

• Tâches structurées (classification, résumés, 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 pourrait être JSON, HTML, texte ou code. Ou peut-être souhaitez-vous qu'il soit en espagnol, anglais ou allemand, etc.

3

Source des données

Lorsque nous connaissons le but et le style des données nécessaires, nous devons analyser la qualité et la quantité des données. Hugging Face et Wikipedia sont d'excellentes sources de jeux de données et Wikipedia 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 de manière synthétique des données mais une attention supplémentaire est requise 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 est de le combiner avec un jeu de données plus généraliste 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.

Formatage des données

Lorsque nous avons identifié les critères pertinents et collecté les données nécessaires, nous pouvons ensuite 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 carbonara est un plat de pâtes traditionnel romain. La sauce est faite 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 à une croyance répandue, 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 attendons du modèle qu'il produise du texte en un seul tour basé sur un ensemble d'instructions spécifique, nous pouvons utiliser Format d'instruction dans le style Alpaca

"Instruction": "Tâche que nous voulons que le modèle effectue."

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

Quand 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": "Préférez-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 utilise seulement 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 de 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 des modèles de conversation 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 :

• Vérifiez les modèles de conversation 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 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 conversation à votre tokenizer :\

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

  \

• 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 jeu de données en appliquant le modèle de conversation que vous avez défini à chaque échantillon.\

• 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
  #token = "hf_...", # en utiliser un si vous utilisez des modèles régulés comme meta-llama/Llama-2-7b-hf
  dataset = load_dataset("repo_name/dataset_name", split = "train")
  
  # Appliquer la fonction de formatage à votre jeu de données en utilisant 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 à ce qui suit : \

  # Importer le jeu de données
  #token = "hf_...", # en utiliser un si vous utilisez des modèles régulés comme meta-llama/Llama-2-7b-hf
  dataset = load_dataset("mlabonne/FineTome-100k", split = "train")
  
  # Convertir votre jeu 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 jeu de données en utilisant la méthode map
  dataset = dataset.map(formatting_prompts_func, batched = True,)

Formatage des données Q&A

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

R : Si votre jeu de données est déjà formaté au format Alpaca, suivez alors les étapes de formatage comme indiqué dans le 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 formaté au format sharegpt, mais que votre modèle attend plutôt un format ChatML.

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échargé 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échargeons les versions quantifiées dans nos référentiels. 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. Comme 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 plus 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 trop spécifique

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

Notebook de jeu de données synthétiques

Nous avons collaboré avec Meta pour lancer un notebook gratuit pour créer automatiquement des jeux de données synthétiques en utilisant des modèles locaux comme Llama 3.2. Accédez au notebook ici.

Ce que fait le notebook :

• Analyse automatique des PDF, sites web, vidéos YouTube et plus

• Utilise le Synthetic Data Kit de Meta + Llama 3.2 (3B) pour générer des paires Q&A

• Nettoie et filtre automatiquement les données

• Ajuste finement le jeu de données avec Unsloth + Llama

• Le notebook s'exécute entièrement localement sans appel API nécessaire

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 Q&A 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à. Exemples de prompts :

• Prompt pour générer davantage de dialogues sur 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.

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

  {% code overflow="wrap" %}

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

  {% endcode %}

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

  {% code overflow="wrap" %}

  Structurez mon jeu de données afin qu'il soit au format QA ChatML pour l'ajustement fin. 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 jeu de données, il peut également être nécessaire de l'équilibrer dans de nombreux domaines 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, maintenant avec encore plus d'orientations.

FAQ et conseils sur les jeux de données

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

Nous recommandons généralement d'utiliser un minimum d'au moins 100 lignes de données pour l'ajustement fin afin d'obtenir des résultats raisonnables. Pour une performance optimale, un jeu de données de plus de 1 000 lignes est préférable, et dans ce cas, plus 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 intégrer un jeu de données depuis Hugging Face pour le diversifier. Toutefois, l'efficacité de votre modèle ajusté dépend fortement de la qualité du jeu de données, donc assurez-vous de nettoyer et préparer soigneusement vos données.

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

Si vous souhaitez 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 la modifier 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 ultérieurement 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.

Jeux de données multiples

Si vous avez plusieurs jeux de données pour l'ajustement fin, vous pouvez soit :

• Standardiser le format de tous les jeux de données, les combiner en un seul jeu de données, et effectuer l'ajustement sur ce jeu unifié.

• Utiliser le Jeux de données multiples notebook pour ajuster finement sur plusieurs jeux de données directement.

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 jeux de données et d'effectuer l'ajustement en une seule opération. Entraîner un modèle déjà affiné peut potentiellement altérer la qualité et les connaissances acquises lors du précédent ajustement.

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. 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 permis à l'affinage d'un LLM de base d'être compétitif avec ChatGPT lui-même.

Vous pouvez accéder à la version GPT4 du jeu de données Alpaca ici. Ci-dessous 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 1 grande invite 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 affinage supervisé par instruction.

Colonnes multiples pour l'ajustement fin

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

Cela signifie essentiellement que nous devons "fusionner" plusieurs colonnes en 1 grande invite pour que l'affinage fonctionne réellement !

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

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

D'autres bibliothèques d'affinage exigent que vous prépariez manuellement votre jeu de données pour l'affinage, en fusionnant toutes vos colonnes en 1 invite. Dans Unsloth, nous fournissons simplement la fonction appelée to_sharegpt qui fait cela en une seule fois !

Ceci est un peu plus compliqué, car nous autorisons beaucoup de personnalisations, 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 de texte 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. C'est utile pour les jeux de données avec 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 / morceau de texte devient optionnel.

Par exemple, imaginez que le jeu de données ressemble à ceci avec beaucoup de données manquantes :

Embarked	Age	Fare
S	23
	18	7.25

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

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

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

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

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

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

devient :

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

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

Conversations à tours multiples

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

Ainsi nous avons 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 1 conversation ! Par exemple, si vous le réglez à 3, nous sélectionnons au hasard 3 lignes et les fusionnons en 1 ! Les définir trop longs peut ralentir l'entraînement, mais peut améliorer considérablement votre chatbot et l'affinage final !

Ensuite, définissez output_column_name sur la colonne de prédiction / sortie. Pour le jeu de données Alpaca, ce serait la colonne output.

Nous utilisons ensuite la standardize_sharegpt fonction pour simplement mettre le jeu de données dans un format correct pour l'affinage ! Appelez toujours ceci !

Ajustement fin vision

Le jeu de données pour l'ajustement fin d'un modèle vision ou multimodal inclut é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.