📈Guide des jeux de données

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

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. Pour être utiles à l'entraînement, les données textuelles doivent être dans un format qui peut être tokenisé. Vous apprendrez également 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 conversation 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 tokeniseur.

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)
Instruction	Des instructions que le modèle doit suivre et un exemple de sortie visée.	Ajustement supervisé (SFT)
Conversation	Conversation à tours multiples 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 qu'il existe différents styles de format pour chacun de ces types.

Commencer

Avant de formater nos données, 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 et quel 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 (questions/réponses, 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 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, en anglais ou 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 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 synthétiquement des données mais une attention particulière 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 également ajouter des données générées de manière synthétique.

Formatage des données

Lorsque nous avons identifié les critères pertinents et collecté les données nécessaires, nous pouvons alors 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 de LLM

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

  "text": "Les pâtes carbonara sont un plat de pâtes traditionnel 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 à une croyance répandue, la carbonara authentique ne contient jamais de crème ni d'ail. Le plat a probablement été inventé à Rome au milieu du XXe siècle, bien que ses origines exactes soient débattues..."

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 avons l'intention que le modèle génère du texte en un seul tour basé sur un ensemble d'instructions spécifique, nous pouvons utiliser le format d'instruction en style Alpaca

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

"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 des tours de conversation multiples, nous pouvons utiliser le format ShareGPT :

{
  "conversations": [
    {
      "from": "human",
      "value": "Pouvez-vous m'aider à faire des pâtes 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 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 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 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 l'affinement se compose de 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 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", # 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 jeu de données en appliquant le modèle de chat 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
  from datasets import load_dataset
  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 des 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 le jeu de données
  from datasets import load_dataset
  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&R

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

R : Si votre jeu de données est déjà formaté au format Alpaca, suivez alors les étapes de formatage 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 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 : L' chat_template attribut lorsqu'un modèle est initialement 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 conversation page.

Q : Que faire 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 tels que 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 solliciter 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 trop spécifique

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

Notebook de jeu de données synthétique

Nous avons collaboré avec Meta pour lancer un notebook gratuit permettant de 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 les données automatiquement

• Affine le jeu de données avec Unsloth + Llama

• Le notebook fonctionne entièrement en local sans appel d'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, 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 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 en positif, négatif ou neutre.

  {% endcode %}

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

  {% code overflow="wrap" %}

  Structurez mon jeu de données pour 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 afin de supprimer ou d'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, désormais avec encore plus d'orientations.

FAQ + Conseils sur les jeux de données

Quelle taille devrait avoir mon jeu de données ?

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 jeu 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 jeu de données est trop petit, vous pouvez également ajouter des données synthétiques ou ajouter un jeu de données de Hugging Face pour le diversifier. Cependant, l'efficacité de votre modèle affiné dépend fortement de la qualité du jeu de données, veillez donc à 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 exemple 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/chaîne de pensée et les étapes 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 intègre plus tard 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 le fine-tuning, vous pouvez soit :

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

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

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

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 le fine-tuning en un seul processus. L'entraînement d'un modèle déjà affiné peut potentiellement altérer la qualité et les connaissances acquises lors du processus d'affinage précédent.

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 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 du jeu de données Alpaca ici. Ci-dessous sont montrés 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 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 affinage 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 / entrées. Par exemple, dans ChatGPT, vous devez soumettre 1 prompt, et non 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 jeu de données Titanic comporte de nombreuses colonnes. Votre tâche é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 grand prompt.

Par exemple, si nous demandons à ChatGPT avec notre unique "prompt fusionné" 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 de fine-tuning exigent que vous prépariez manuellement votre jeu 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 le sautera. Ceci 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 de prompt fusionné comme ci-dessous, où chaque colonne/élément 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 est parti de S. Son âge est de 23 ans. Son tarif est VIDE.

2. Le passager est parti de VIDE. Son âge est de 18 ans. Son tarif est de 7,25 $.

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

1. [[Le passager est parti de S.]] [[Son âge est de 23 ans.]] [[Son tarif est VIDE.]]

2. [[Le passager est parti de VIDE.]] [[Son âge est de 18 ans.]] [[Son tarif est de 7,25 $.]]

devient :

1. Le passager est parti de S. Son âge est de 23 ans.

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

Conversations multi-tours

Un problème, si vous ne l'avez pas remarqué, est que le jeu de données Alpaca est à tour unique, tandis que se souvenir de l'utilisation de ChatGPT était interactif et vous pouvez lui parler sur 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.

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 1 conversation ! Par exemple, si vous le réglez sur 3, nous sélectionnons au hasard 3 lignes et les fusionnons en 1 ! Les régler trop longs peut ralentir l'entraînement, mais pourrait rendre votre chatbot et l'affinement final bien meilleurs !

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

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

Affinage vision

Le jeu de données pour affiner un modèle de 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 de manière plus efficace.

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 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 coup d'œ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'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 rédigerons 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 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'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 fine-tuning, 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 y a 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 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 située à gauche, et l'autre à droite. Cependant, seulement

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