diff --git a/.gitattributes b/.gitattributes index a6344aac8c09253b3b630fb776ae94478aa0275b..6b58db847eb1773594b7b296c8881bd044f2eeda 100644 --- a/.gitattributes +++ b/.gitattributes @@ -33,3 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text *.zip filter=lfs diff=lfs merge=lfs -text *.zst filter=lfs diff=lfs merge=lfs -text *tfevents* filter=lfs diff=lfs merge=lfs -text +assets/best_annotation_practices.png filter=lfs diff=lfs merge=lfs -text +assets/llm_gen.png filter=lfs diff=lfs merge=lfs -text +assets/llm_logprob.png filter=lfs diff=lfs merge=lfs -text +assets/llm_tk_1.png filter=lfs diff=lfs merge=lfs -text +assets/llm-eval-tree.jpg filter=lfs diff=lfs merge=lfs -text +assets/lm_eval_diff.png filter=lfs diff=lfs merge=lfs -text diff --git a/Home.py b/Home.py new file mode 100644 index 0000000000000000000000000000000000000000..8e9e6635b1b87b7304eb3ee6a470f78e6790cd35 --- /dev/null +++ b/Home.py @@ -0,0 +1,84 @@ +import streamlit as st +st.set_page_config(page_title="Accueil",page_icon="🏠",layout="wide") + +st.write("# Guide sur l'Ă©valuation des LLM ⚖") +st.markdown(""" """) + +st.markdown("""### Avant-propos""") +st.success( + """ + Cette application propose une traduction en français du guide de [ClĂ©mentine Fourrier](https://github.com/huggingface/evaluation-guidebook) sur l'Ă©valuation des LLM. + + Notez que dans ce guide, les textes sur fond vert sont des ajouts par le CATIE par rapport au guide original (par exemple des remarques ou indications liĂ©es Ă  des choix de traduction) et que tout le reste provient du guide original. + + De plus, sauf mention contraire, l'ensemble des liens que vous trouverez dans le guide renvoient vers des ressources en langue anglaise. + """) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown( + """ + ### Introduction + Si vous vous ĂȘtes dĂ©jĂ  demandĂ© comment vous assurer qu'un LLM fonctionne bien dans le cadre de votre tĂąche spĂ©cifique, ce guide est fait pour vous !
+ Il couvre les différentes façons d'évaluer un modÚle, des guides sur la conception de vos propres évaluations, ainsi que des conseils et des astuces basés sur de l'expérience pratique. + + Que vous travailliez avec des modÚles en production, que vous soyez chercheur ou amateur, j'espÚre que vous trouverez ce dont vous avez besoin ; et si ce n'est pas le cas, ouvrez une [*issue*](https://github.com/huggingface/evaluation-guidebook/issues) (pour suggérer des améliorations ou des ressources manquantes) et je complÚterai le guide ! + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown( + """ + ### Comment lire ce guide + - **Utilisateur débutant** :
+ Si vous ne connaissez rien à l'évaluation, vous devriez commencer par les sections « Bases » de chaque chapitre avant d'aller plus loin. + Vous trouverez également des explications pour vous aider sur les sujets importants des LLM dans le chapitre « Connaissances générales ». Par exemple, comment fonctionne l'inférence des modÚles et ce qu'est la tokenisation. + - **Utilisateur avancé** :
+ Les sections les plus pratiques sont les « Conseils et astuces » de chaque chapitre, ainsi que chapitre « DĂ©pannage ». Vous trouverez Ă©galement des choses intĂ©ressantes dans les sections « Concevoir ». + + Dans le texte, les liens prĂ©fixĂ©s par une ⭐ sont des liens de qualitĂ© et dont la lecture est recommandĂ©e. + + Si vous voulez une introduction sur le sujet, vous pouvez lire cet [article de blog](https://huggingface.co/blog/clefourrier/llm-evaluation) sur comment et pourquoi nous faisons de l'Ă©valuation ! + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown( + """ + ### Remerciements + Ce guide a Ă©tĂ© fortement inspirĂ© par le [ML Engineering Guidebook de Stas Bekman](https://github.com/stas00/ml-engineering) ! Merci pour cette ressource incroyable ! + + Un grand merci Ă©galement Ă  toutes les personnes qui ont inspirĂ© ce guide Ă  travers des discussions soit lors d'Ă©vĂ©nements, soit en ligne, notamment et sans s'y limiter : + - đŸ€ Luca Soldaini, Kyle Lo et Ian Magnusson (Allen AI), Max Bartolo (Cohere), Kai Wu (Meta), Swyx et Alessio Fanelli (Latent Space Podcast), Hailey Schoelkopf (EleutherAI), Martin Signoux (Open AI), Moritz Hardt (Max Planck Institute), Ludwig Schmidt (Anthropic). + - đŸ”„ les utilisateurs de l'[Open LLM Leaderboard](https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard#/) et de [Lighteval](https://github.com/huggingface/lighteval), qui ont souvent soulevĂ© des points trĂšs intĂ©ressants dans les discussions + - đŸ€— les personnes d'Hugging Face, comme Lewis Tunstall, Omar Sanseviero, Arthur Zucker, Hynek Kydlíček, Guilherme Penedo et Thom Wolf, + - bien sĂ»r, mon Ă©quipe ❀ qui s'occupe de l'Ă©valuation et des classements, Nathan Habib et Alina Lozovskaya. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown( + """ + ### Citation + [![CC BY-NC-SA 4.0][cc-by-nc-sa-image]][cc-by-nc-sa] + + [cc-by-nc-sa]: http://creativecommons.org/licenses/by-nc-sa/4.0/ + [cc-by-nc-sa-image]: https://licensebuttons.net/l/by-nc-sa/4.0/88x31.png + [cc-by-nc-sa-shield]: https://img.shields.io/badge/License-CC-BY--NC--SA-4.0-lightgrey.svg + + ``` + @misc{fourrier2024evaluation, + author = {ClĂ©mentine Fourrier and The Hugging Face Community}, + title = {LLM Evaluation Guidebook}, + year = {2024}, + journal = {GitHub repository}, + url = {https://github.com/huggingface/evaluation-guidebook) + } + ``` + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown("""### Partenaires""") +st.success("""Cette traduction a pu ĂȘtre effectuĂ©e grĂące au soutien de nos partenaires, que nous remercions.""") +st.image('./assets/logo_Europe_NA.png') \ No newline at end of file diff --git a/README.md b/README.md index d1bfa6b7acc1509cd875f9b809ee536867454dc8..6f78f289f22e7abe42e754712f7a8870a5067a52 100644 --- a/README.md +++ b/README.md @@ -1,12 +1,11 @@ --- -title: Guide Evaluation LLM -emoji: 🌍 -colorFrom: indigo -colorTo: pink +title: Guide sur l'Ă©valuation des LLM +emoji: ⚖ +colorFrom: red +colorTo: gray sdk: streamlit -sdk_version: 1.42.2 -app_file: app.py +sdk_version: 1.41.1 +app_file: Home.py pinned: false ---- - -Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference +short_description: Traduction du guide de ClĂ©mentine Fourrier +--- \ No newline at end of file diff --git a/assets/best_annotation_practices.png b/assets/best_annotation_practices.png new file mode 100644 index 0000000000000000000000000000000000000000..14be1fa4e3397cfc297fcbace01a02b25010344d --- /dev/null +++ b/assets/best_annotation_practices.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e36a5f7b22295180bec3d7bfa177dace58bd47e86dab451b0efe031e5f6e3006 +size 101319 diff --git a/assets/llm-eval-tree.jpg b/assets/llm-eval-tree.jpg new file mode 100644 index 0000000000000000000000000000000000000000..10ca2dcb42ca77fb2e8cf467dd1b15d60926fa4e --- /dev/null +++ b/assets/llm-eval-tree.jpg @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7f9ba0bf7b0ccdf5f0973cc545744b9f7d01fe4357d1976e17c7fc4b0776bbf5 +size 165356 diff --git a/assets/llm_gen.png b/assets/llm_gen.png new file mode 100644 index 0000000000000000000000000000000000000000..bb5c5d0daab0056978d6dc212a0e468e684913dd --- /dev/null +++ b/assets/llm_gen.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b5e43c65fa82cd9af673862cb8b247e702acd87757255c2dcaf98a1f849e88a3 +size 212170 diff --git a/assets/llm_logprob.png b/assets/llm_logprob.png new file mode 100644 index 0000000000000000000000000000000000000000..f79708080283871d1452323da9cee87770985a31 --- /dev/null +++ b/assets/llm_logprob.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:51de4ba1bf725af23fd33c93fcb5c3f442440c6b0accc0669c8c427253d81794 +size 204185 diff --git a/assets/llm_tk_1.png b/assets/llm_tk_1.png new file mode 100644 index 0000000000000000000000000000000000000000..5286507663918ce84bfcfb5ce77db343fd06857f --- /dev/null +++ b/assets/llm_tk_1.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ea6b52eed82a2bbd215cbdce05394bec50c65851b79a919636b2993e1cb03c5f +size 117298 diff --git a/assets/lm_eval_diff.png b/assets/lm_eval_diff.png new file mode 100644 index 0000000000000000000000000000000000000000..9883b558f07721fd3c91711825e5f297442d090a --- /dev/null +++ b/assets/lm_eval_diff.png @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:6e62f744dd23a6856c86b62aa36150061cc5c7a4ed85a65811e0ba757277f6de +size 174137 diff --git a/assets/logo_Europe_NA.png b/assets/logo_Europe_NA.png new file mode 100644 index 0000000000000000000000000000000000000000..288a42c4eb4419e3581743c6ca7de2c5fdd1793c Binary files /dev/null and b/assets/logo_Europe_NA.png differ diff --git a/assets/math-hard-change.png b/assets/math-hard-change.png new file mode 100644 index 0000000000000000000000000000000000000000..908d15c80a2ce4784e25aa9d1c867201605a0786 Binary files /dev/null and b/assets/math-hard-change.png differ diff --git a/assets/parallelism_bubble.png b/assets/parallelism_bubble.png new file mode 100644 index 0000000000000000000000000000000000000000..16a2b4110f7f11b501e60b58a52fdbb6b032872d Binary files /dev/null and b/assets/parallelism_bubble.png differ diff --git a/assets/score-change.png b/assets/score-change.png new file mode 100644 index 0000000000000000000000000000000000000000..4d1c13a13f5033acf98ab4315f030c19d96013e2 Binary files /dev/null and b/assets/score-change.png differ diff --git a/assets/subset-change.png b/assets/subset-change.png new file mode 100644 index 0000000000000000000000000000000000000000..f5ccc1f2101c4f2ed944a13930525042846b96f6 Binary files /dev/null and b/assets/subset-change.png differ diff --git a/assets/sympy_doc.png b/assets/sympy_doc.png new file mode 100644 index 0000000000000000000000000000000000000000..12b10275e7bed773a094c7c55f8975b0751df7ae Binary files /dev/null and b/assets/sympy_doc.png differ diff --git a/comparing_task_formulations.ipynb b/comparing_task_formulations.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..8c33e12e9347e812a47492062719e56fa9d4e367 --- /dev/null +++ b/comparing_task_formulations.ipynb @@ -0,0 +1,1810 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "2d8737a1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [] + } + ], + "source": [ + "%pip install lighteval==0.6.2\n", + "%pip install great-tables\n", + "%pip install polars" + ] + }, + { + "cell_type": "markdown", + "id": "3d9ea816", + "metadata": {}, + "source": [ + "# Comparaison de diffĂ©rentes formulations d'une instruction pour une mĂȘme tĂąche\n", + "Dans ce *notebook*, nous allons utiliser un trĂšs petit modĂšle pour une tĂąche simple. Nous nous concentrerons sur la comparaison de plusieurs formulations pour l'instruction (*prompt* en anglais) donnĂ© en entrĂ©e afin de voir comment elles affectent les rĂ©sultats que l'on peut obtenir." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3684eec7", + "metadata": {}, + "outputs": [], + "source": [ + "import string\n", + "import os\n", + "from datetime import timedelta\n", + "from types import ModuleType\n", + "from ast import literal_eval" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "a241de50", + "metadata": {}, + "outputs": [], + "source": [ + "# Pour la visualisation des donnĂ©es\n", + "from great_tables import GT\n", + "import polars as pl\n", + "import polars.selectors as cs\n", + "from datasets import load_dataset" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e522341e", + "metadata": {}, + "outputs": [], + "source": [ + "# Pour l'Ă©valuation\n", + "import lighteval\n", + "from lighteval.logging.evaluation_tracker import EvaluationTracker\n", + "from lighteval.models.model_config import BaseModelConfig, VLLMModelConfig\n", + "from lighteval.pipeline import ParallelismManager, Pipeline, PipelineParameters\n", + "from lighteval.metrics.metrics import Metrics\n", + "from lighteval.tasks.lighteval_task import LightevalTaskConfig, Doc\n", + "from lighteval.utils.utils import as_list, EnvConfig\n", + "from lighteval.utils.imports import is_accelerate_available, is_tgi_available" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "d954ae1b", + "metadata": {}, + "outputs": [], + "source": [ + "# DĂ©finir pour votre cas d'usage\n", + "cache_dir = \"tmp\"\n", + "max_samples = 10" + ] + }, + { + "cell_type": "markdown", + "id": "a52f8c1b", + "metadata": {}, + "source": [ + "## Comparer plusieurs formulations pour une mĂȘme tĂąche\n", + "\n", + "Comparons :\n", + "- Ă  l'aide d'une Ă©valuation MCQA (question-rĂ©ponse Ă  choix multiples i.e. un QCM)\n", + "- l'utilisation d'une Ă©valuation gĂ©nĂ©rative\n", + "\n", + "et pour les deux, en utilisant des variations des mĂȘmes prompts.\n", + "\n", + "Nous utiliserons le jeu de donnĂ©es ARC d'AI2 pour nos expĂ©riences, en utilisant le sous-ensemble « challenge ». Vous pouvez consulter le jeu de donnĂ©es ici : https://huggingface.co/datasets/allenai/ai2_arc?row=0." + ] + }, + { + "cell_type": "markdown", + "id": "6fc0902b", + "metadata": {}, + "source": [ + "### DĂ©finissons le cƓur de notre tĂąche" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "6e1c0cde", + "metadata": {}, + "outputs": [], + "source": [ + "class ArcExplorationTask(LightevalTaskConfig):\n", + " def __init__(self, name, prompt_function, metric):\n", + " super().__init__(\n", + " name=name,\n", + " prompt_function=prompt_function,\n", + " metric=as_list(metric),\n", + " # Il s'agit d'une tĂąche personnalisĂ©e\n", + " suite=[\"custom\"],\n", + " # Ceci dĂ©finit notre jeu de donnĂ©es et ses sous-ensembles\n", + " hf_repo=\"allenai/ai2_arc\",\n", + " hf_subset=\"ARC-Challenge\",\n", + " hf_avail_splits=[\"train\", \"validation\", \"test\"],\n", + " evaluation_splits=[\"test\"],\n", + " # ParamĂštres des exemples few shot\n", + " few_shots_split=\"validation\",\n", + " few_shots_select=\"random\", \n", + " # Autres paramĂštres\n", + " stop_sequence=[\".\", \"\\n\"],\n", + " generation_size=100,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "eaa0a65a", + "metadata": {}, + "source": [ + "### DĂ©finissons nos mĂ©triques\n", + "\n", + "Pour une Ă©valuation Ă  choix multiples, , nous voulons la log-vraissemblance de l'*accuracy* normalisĂ©e par la longueur (= le choix le plus probable est-il le bon ?).\n", + "\n", + "Pour l'Ă©valuation de gĂ©nĂ©rations, nous voulons une correspondance exacte (= le texte gĂ©nĂ©rĂ© correspond-il Ă  la rĂ©fĂ©rence ?)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "426c2ef5", + "metadata": {}, + "outputs": [], + "source": [ + "metric_mcqa = Metrics.loglikelihood_acc_norm\n", + "metric_gen = Metrics.quasi_exact_match" + ] + }, + { + "cell_type": "markdown", + "id": "aea37f61", + "metadata": {}, + "source": [ + "### DĂ©finissons des fonctions pour les diffĂ©rentes instructions\n", + "\n", + "Une ligne du jeu de donnĂ©es ARC est un dictionnaire, de la forme suivante\n", + "```python\n", + "{\n", + " \"question\": \"la question avec une instruction\",\n", + " \"choices\": {\n", + " \"text\": [\"choix 1\", \"choix 2\", ...],\n", + " \"label\": [\"A\", \"B\", ...]\n", + " },\n", + " \"answerKey\": \"le label gold\"\n", + "}\n", + "```\n", + "\n", + "Notre fonction appliquera un gabarit dans lequel nous associerons toutes ces informations aux clĂ©s demandĂ©es (`query`, `choices`, `gold_index`, et une `instruction` si nĂ©cessaire)." + ] + }, + { + "cell_type": "markdown", + "id": "7e994698", + "metadata": {}, + "source": [ + "Premier cas, nous dĂ©finissons le gabarit le plus basique possible. \n", + "L'instruction ressemble Ă  ceci :\n", + "```\n", + "\n", + "```\n", + "et nous regardons `` directement." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "41bccce4", + "metadata": {}, + "outputs": [], + "source": [ + "def arc_base(line, task_name: str = None):\n", + " query= f\"{line['question']}\"\n", + " choices=line[\"choices\"][\"text\"]\n", + "\n", + " return Doc(\n", + " task_name=task_name,\n", + " query=query,\n", + " choices=choices,\n", + " gold_index=line[\"choices\"][\"label\"].index(line[\"answerKey\"]),\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "d87631d5", + "metadata": {}, + "source": [ + "DeuxiĂšme cas, nous ajoutons maintenant un peu de contexte. L'instruction ressemble alors Ă  ceci :\n", + "```\n", + "Question: \n", + "Answer: \n", + "```\n", + "et nous regardons `` directement aussi." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9865eafe", + "metadata": {}, + "outputs": [], + "source": [ + "def arc_context(line, task_name: str = None):\n", + " query= f\"Question: {line['question']}\"\n", + " query += \"\\nAnswer: \"\n", + " choices=line[\"choices\"][\"text\"]\n", + " return Doc(\n", + " task_name=task_name,\n", + " query=query,\n", + " choices=choices,\n", + " gold_index=line[\"choices\"][\"label\"].index(line[\"answerKey\"]),\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "132deef3", + "metadata": {}, + "source": [ + "TroisiĂšme cas, nous ajoutons maintenant des choix dans notre instruction. Le *prompt* ressemble alors Ă  ceci :\n", + "```\n", + "Question: \n", + "Choices:\n", + "A. \n", + "B. \n", + "...\n", + "Answer: \n", + "```\n", + "et nous regardons `` directement Ă  nouveau." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "698367f7", + "metadata": {}, + "outputs": [], + "source": [ + "letters = list(string.ascii_uppercase)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e7073026", + "metadata": {}, + "outputs": [], + "source": [ + "def arc_context_choices(line, task_name: str = None):\n", + " query = f\"Question: {line['question']}\\n\"\n", + " query += \"\\n\".join([f\"{letters[ix]}. {choice}\" for ix, choice in enumerate(line[\"choices\"][\"text\"])])\n", + " query += \"\\nAnswer: \"\n", + " choices=line[\"choices\"][\"text\"]\n", + " return Doc(\n", + " task_name=task_name,\n", + " query=query,\n", + " choices=choices,\n", + " gold_index=line[\"choices\"][\"label\"].index(line[\"answerKey\"]),\n", + " )" + ] + }, + { + "cell_type": "markdown", + "id": "b835822d", + "metadata": {}, + "source": [ + "Dernier cas, nous faisons la mĂȘme chose, mais nous regardons `` Ă  la place." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "b9453b39", + "metadata": {}, + "outputs": [], + "source": [ + "def arc_context_labels(line, task_name: str = None):\n", + " query = f\"Question: {line['question']}\\n\"\n", + " query += \"\\n\".join([f\"{letters[ix]}. {choice}\" for ix, choice in enumerate(line[\"choices\"][\"text\"])])\n", + " query += \"\\nAnswer: \"\n", + " choices=[letters[ix] for ix in range(len(line[\"choices\"][\"text\"]))]\n", + " return Doc(\n", + " task_name=task_name,\n", + " query=query,\n", + " choices=choices,\n", + " gold_index=line[\"choices\"][\"label\"].index(line[\"answerKey\"]),\n", + " )\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "da018e16", + "metadata": {}, + "source": [ + "### EnchaĂźnons le tout" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "304a74dd", + "metadata": {}, + "outputs": [], + "source": [ + "task_module = ModuleType(\"task_module\")\n", + "task_module.__file__ = \".\",\n", + "task_module.TASKS_TABLE = [\n", + " ArcExplorationTask(\n", + " name=\"arc_base\", \n", + " prompt_function=arc_base, \n", + " metric=[metric_mcqa, metric_gen]\n", + " ),\n", + " ArcExplorationTask(\n", + " name=\"arc_context\", \n", + " prompt_function=arc_context, \n", + " metric=[metric_mcqa, metric_gen]\n", + " ),\n", + " ArcExplorationTask(\n", + " name=\"arc_context_choice\", \n", + " prompt_function=arc_context_choices, \n", + " metric=[metric_mcqa, metric_gen]\n", + " ),\n", + " ArcExplorationTask(\n", + " name=\"arc_context_labels\", \n", + " prompt_function=arc_context_labels, \n", + " metric=[metric_mcqa, metric_gen]\n", + " )\n", + "]\n", + "\n", + "task_names = [\"arc_base\", \"arc_context\", \"arc_context_choice\", \"arc_context_labels\"]" + ] + }, + { + "cell_type": "markdown", + "id": "42a131fd", + "metadata": {}, + "source": [ + "# Lançons notre Ă©valuation !" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "756566ff", + "metadata": {}, + "outputs": [], + "source": [ + "if is_accelerate_available():\n", + " from accelerate import Accelerator, InitProcessGroupKwargs\n", + " accelerator = Accelerator(kwargs_handlers=[InitProcessGroupKwargs(timeout=timedelta(seconds=3000))])\n", + "else:\n", + " accelerator = None" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "1ee62d6f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:lighteval.logging.hierarchical_logger:WARNING: --max_samples WAS SET. THESE NUMBERS ARE ONLY PARTIAL AND SHOULD NOT BE USED FOR COMPARISON UNLESS YOU KNOW WHAT YOU ARE DOING.\n", + "WARNING:lighteval.logging.hierarchical_logger:Test all gather {\n", + "WARNING:lighteval.logging.hierarchical_logger: Test gather tensor\n", + "WARNING:lighteval.logging.hierarchical_logger: gathered_tensor tensor([0]), should be [0]\n", + "WARNING:lighteval.logging.hierarchical_logger:} [0:00:00.002244]\n", + "WARNING:lighteval.logging.hierarchical_logger:Model loading {\n", + "WARNING:lighteval.logging.hierarchical_logger: Tokenizer truncation and padding size set to the left side.\n", + "WARNING:lighteval.logging.hierarchical_logger: We are not in a distributed setting. Setting model_parallel to False.\n", + "WARNING:lighteval.logging.hierarchical_logger: Model parallel was set to False, max memory set to None and device map to None\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "4e00c4d6763240ed85bde9c5f8f6614e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Loading checkpoint shards: 0%| | 0/2 [00:00.create_task..LightevalTaskFromConfig'>, 'custom|arc_context': .create_task..LightevalTaskFromConfig'>, 'custom|arc_context_choice': .create_task..LightevalTaskFromConfig'>, 'custom|arc_context_labels': .create_task..LightevalTaskFromConfig'>}\n", + "WARNING:lighteval.logging.hierarchical_logger: allenai/ai2_arc ARC-Challenge\n", + "WARNING:lighteval.logging.hierarchical_logger: allenai/ai2_arc ARC-Challenge\n", + "WARNING:lighteval.logging.hierarchical_logger: allenai/ai2_arc ARC-Challenge\n", + "WARNING:lighteval.logging.hierarchical_logger: allenai/ai2_arc ARC-Challenge\n", + "WARNING:lighteval.logging.hierarchical_logger: Loading documents, and requests\n", + "WARNING:lighteval.logging.hierarchical_logger:} [0:00:12.300826]\n", + "WARNING:lighteval.logging.hierarchical_logger:Setting seeds and waiting for all processes {\n", + "WARNING:lighteval.logging.hierarchical_logger: setting seed to 1234 for random and numpy\n", + "WARNING:lighteval.logging.hierarchical_logger:} [0:00:00.000334]\n", + "WARNING:lighteval.logging.hierarchical_logger:Evaluation {\n", + "WARNING:lighteval.logging.hierarchical_logger: Evaluate on 4 tasks.\n", + "WARNING:lighteval.logging.hierarchical_logger: Running RequestType.GREEDY_UNTIL requests\n", + "WARNING:lighteval.logging.hierarchical_logger: \u001b[33mYou cannot select the number of dataset splits for a generative evaluation at the moment. Automatically inferring.\u001b[0m\n", + "Greedy generation: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 40/40 [06:41<00:00, 9.73s/it]\u001b[A\n", + "Splits: 100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 1/1 [06:41<00:00, 401.95s/it]\u001b[A\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:lighteval.logging.hierarchical_logger: Running RequestType.LOGLIKELIHOOD requests\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 40/40 [05:26<00:00, 8.17s/it]\u001b[A\n", + "1it [05:26, 326.90s/it]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 40/40 [04:50<00:00, 7.25s/it]\u001b[A\n", + "2it [10:16, 305.21s/it]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 40/40 [03:27<00:00, 5.19s/it]\u001b[A\n", + "3it [13:44, 260.60s/it]\n", + "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 36/36 [02:56<00:00, 4.91s/it]\u001b[A\n", + "4it [16:41, 250.28s/it]\n", + "WARNING:lighteval.logging.hierarchical_logger:} [0:23:23.253299]\n", + "WARNING:lighteval.logging.hierarchical_logger:Compiling results {\n", + "WARNING:lighteval.logging.hierarchical_logger:} [0:00:00.000472]\n", + "WARNING:lighteval.logging.hierarchical_logger:Cleaning up {\n", + "WARNING:lighteval.logging.hierarchical_logger:} [0:00:00.000034]\n", + "WARNING:lighteval.logging.hierarchical_logger:Saving experiment tracker\n", + "WARNING:lighteval.logging.hierarchical_logger:Saving results to .../tmp/results/HuggingFaceTB/SmolLM-1.7B/results_2024-10-24T16-24-58.398434.json\n", + "WARNING:lighteval.logging.hierarchical_logger:Saving details to .../tmp/details/HuggingFaceTB/SmolLM-1.7B/2024-10-24T16-24-58.398434\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "b1e4e357b68b41f8ac49469cddda318d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Creating parquet from Arrow format: 0%| | 0/1 [00:00\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "
Results
Prompt function\n", + " Evaluations\n", + "
Quasi Exact MatchNormalized Accuracy
arc base0.00.3
arc context0.10.5
arc context choice0.40.3
arc context labels0.00.0
all0.1250.275
\n", + "\n", + "\n", + " " + ], + "text/plain": [ + "GT(_tbl_data=shape: (5, 3)\n", + "┌────────────────────┬───────────────────┬─────────────────────┐\n", + "│ Prompt function ┆ Quasi Exact Match ┆ Normalized Accuracy │\n", + "│ --- ┆ --- ┆ --- │\n", + "│ str ┆ f64 ┆ f64 │\n", + "╞════════════════════â•Ș═══════════════════â•Ș═════════════════════╡\n", + "│ arc base ┆ 0.0 ┆ 0.3 │\n", + "│ arc context ┆ 0.1 ┆ 0.5 │\n", + "│ arc context choice ┆ 0.4 ┆ 0.3 │\n", + "│ arc context labels ┆ 0.0 ┆ 0.0 │\n", + "│ all ┆ 0.125 ┆ 0.275 │\n", + "└────────────────────┮───────────────────┮─────────────────────┘, _body=, _boxhead=Boxhead([ColInfo(var='Prompt function', type=, column_label='Prompt function', column_align='left', column_width=None), ColInfo(var='Quasi Exact Match', type=, column_label='Quasi Exact Match', column_align='right', column_width=None), ColInfo(var='Normalized Accuracy', type=, column_label='Normalized Accuracy', column_align='right', column_width=None)]), _stub=, _spanners=Spanners([SpannerInfo(spanner_id='Evaluations', spanner_level=0, spanner_label='Evaluations', spanner_units=None, spanner_pattern=None, vars=['Quasi Exact Match', 'Normalized Accuracy'], built=None)]), _heading=Heading(title='Results', subtitle=None, preheader=None), _stubhead=None, _source_notes=[], _footnotes=[], _styles=[], _locale=, _formats=[], _substitutions=[], _options=Options(table_id=OptionsInfo(scss=False, category='table', type='value', value=None), table_caption=OptionsInfo(scss=False, category='table', type='value', value=None), table_width=OptionsInfo(scss=True, category='table', type='px', value='auto'), table_layout=OptionsInfo(scss=True, category='table', type='value', value='fixed'), table_margin_left=OptionsInfo(scss=True, category='table', type='px', value='auto'), table_margin_right=OptionsInfo(scss=True, category='table', type='px', value='auto'), table_background_color=OptionsInfo(scss=True, category='table', type='value', value='#FFFFFF'), table_additional_css=OptionsInfo(scss=False, category='table', type='values', value=[]), table_font_names=OptionsInfo(scss=False, category='table', type='values', value=['-apple-system', 'BlinkMacSystemFont', 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Helvetica Neue', 'Fira Sans', 'Droid Sans', 'Arial', 'sans-serif']), table_font_size=OptionsInfo(scss=True, category='table', type='px', value='16px'), table_font_weight=OptionsInfo(scss=True, category='table', type='value', value='normal'), table_font_style=OptionsInfo(scss=True, category='table', type='value', value='normal'), table_font_color=OptionsInfo(scss=True, category='table', type='value', value='#333333'), table_font_color_light=OptionsInfo(scss=True, category='table', type='value', value='#FFFFFF'), table_border_top_include=OptionsInfo(scss=False, category='table', type='boolean', value=True), table_border_top_style=OptionsInfo(scss=True, category='table', type='value', value='solid'), table_border_top_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_top_color=OptionsInfo(scss=True, category='table', type='value', value='#A8A8A8'), table_border_right_style=OptionsInfo(scss=True, category='table', type='value', value='none'), table_border_right_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_right_color=OptionsInfo(scss=True, category='table', type='value', value='#D3D3D3'), table_border_bottom_include=OptionsInfo(scss=False, category='table', type='boolean', value=True), table_border_bottom_style=OptionsInfo(scss=True, category='table', type='value', value='solid'), table_border_bottom_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_bottom_color=OptionsInfo(scss=True, category='table', type='value', value='#A8A8A8'), table_border_left_style=OptionsInfo(scss=True, category='table', type='value', value='none'), table_border_left_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_left_color=OptionsInfo(scss=True, category='table', type='value', value='#D3D3D3'), heading_background_color=OptionsInfo(scss=True, category='heading', type='value', value=None), heading_align=OptionsInfo(scss=True, category='heading', type='value', value='center'), heading_title_font_size=OptionsInfo(scss=True, category='heading', type='px', value='125%'), heading_title_font_weight=OptionsInfo(scss=True, category='heading', type='value', value='initial'), heading_subtitle_font_size=OptionsInfo(scss=True, category='heading', type='px', value='85%'), heading_subtitle_font_weight=OptionsInfo(scss=True, category='heading', type='value', value='initial'), heading_padding=OptionsInfo(scss=True, category='heading', type='px', value='4px'), heading_padding_horizontal=OptionsInfo(scss=True, category='heading', type='px', value='5px'), heading_border_bottom_style=OptionsInfo(scss=True, category='heading', type='value', value='solid'), heading_border_bottom_width=OptionsInfo(scss=True, category='heading', type='px', value='2px'), heading_border_bottom_color=OptionsInfo(scss=True, category='heading', type='value', value='#D3D3D3'), heading_border_lr_style=OptionsInfo(scss=True, category='heading', type='value', value='none'), heading_border_lr_width=OptionsInfo(scss=True, category='heading', type='px', value='1px'), heading_border_lr_color=OptionsInfo(scss=True, category='heading', type='value', value='#D3D3D3'), column_labels_background_color=OptionsInfo(scss=True, category='column_labels', type='value', value=None), column_labels_font_size=OptionsInfo(scss=True, category='column_labels', type='px', value='100%'), column_labels_font_weight=OptionsInfo(scss=True, category='column_labels', type='value', value='normal'), column_labels_text_transform=OptionsInfo(scss=True, category='column_labels', type='value', value='inherit'), column_labels_padding=OptionsInfo(scss=True, category='column_labels', type='px', value='5px'), column_labels_padding_horizontal=OptionsInfo(scss=True, category='column_labels', type='px', value='5px'), column_labels_vlines_style=OptionsInfo(scss=True, category='table_body', type='value', value='none'), column_labels_vlines_width=OptionsInfo(scss=True, category='table_body', type='px', value='1px'), column_labels_vlines_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), column_labels_border_top_style=OptionsInfo(scss=True, category='column_labels', type='value', value='solid'), column_labels_border_top_width=OptionsInfo(scss=True, category='column_labels', type='px', value='2px'), column_labels_border_top_color=OptionsInfo(scss=True, category='column_labels', type='value', value='#D3D3D3'), column_labels_border_bottom_style=OptionsInfo(scss=True, category='column_labels', type='value', value='solid'), column_labels_border_bottom_width=OptionsInfo(scss=True, category='column_labels', type='px', value='2px'), column_labels_border_bottom_color=OptionsInfo(scss=True, category='column_labels', type='value', value='#D3D3D3'), column_labels_border_lr_style=OptionsInfo(scss=True, category='column_labels', type='value', value='none'), column_labels_border_lr_width=OptionsInfo(scss=True, category='column_labels', type='px', value='1px'), column_labels_border_lr_color=OptionsInfo(scss=True, category='column_labels', type='value', value='#D3D3D3'), column_labels_hidden=OptionsInfo(scss=False, category='column_labels', type='boolean', value=False), row_group_background_color=OptionsInfo(scss=True, category='row_group', type='value', value=None), row_group_font_size=OptionsInfo(scss=True, category='row_group', type='px', value='100%'), row_group_font_weight=OptionsInfo(scss=True, category='row_group', type='value', value='initial'), row_group_text_transform=OptionsInfo(scss=True, category='row_group', type='value', value='inherit'), row_group_padding=OptionsInfo(scss=True, category='row_group', type='px', value='8px'), row_group_padding_horizontal=OptionsInfo(scss=True, category='row_group', type='px', value='5px'), row_group_border_top_style=OptionsInfo(scss=True, category='row_group', type='value', value='solid'), row_group_border_top_width=OptionsInfo(scss=True, category='row_group', type='px', value='2px'), row_group_border_top_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_border_right_style=OptionsInfo(scss=True, category='row_group', type='value', value='none'), row_group_border_right_width=OptionsInfo(scss=True, category='row_group', type='px', value='1px'), row_group_border_right_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_border_bottom_style=OptionsInfo(scss=True, category='row_group', type='value', value='solid'), row_group_border_bottom_width=OptionsInfo(scss=True, category='row_group', type='px', value='2px'), row_group_border_bottom_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_border_left_style=OptionsInfo(scss=True, category='row_group', type='value', value='none'), row_group_border_left_width=OptionsInfo(scss=True, category='row_group', type='px', value='1px'), row_group_border_left_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_as_column=OptionsInfo(scss=False, category='row_group', type='boolean', value=False), table_body_hlines_style=OptionsInfo(scss=True, category='table_body', type='value', value='solid'), table_body_hlines_width=OptionsInfo(scss=True, category='table_body', type='px', value='1px'), table_body_hlines_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), table_body_vlines_style=OptionsInfo(scss=True, category='table_body', type='value', value='none'), table_body_vlines_width=OptionsInfo(scss=True, category='table_body', type='px', value='1px'), table_body_vlines_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), table_body_border_top_style=OptionsInfo(scss=True, category='table_body', type='value', value='solid'), table_body_border_top_width=OptionsInfo(scss=True, category='table_body', type='px', value='2px'), table_body_border_top_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), table_body_border_bottom_style=OptionsInfo(scss=True, category='table_body', type='value', value='solid'), table_body_border_bottom_width=OptionsInfo(scss=True, category='table_body', type='px', value='2px'), table_body_border_bottom_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), data_row_padding=OptionsInfo(scss=True, category='data_row', type='px', value='8px'), data_row_padding_horizontal=OptionsInfo(scss=True, category='data_row', type='px', value='5px'), stub_background_color=OptionsInfo(scss=True, category='stub', type='value', value=None), stub_font_size=OptionsInfo(scss=True, category='stub', type='px', value='100%'), stub_font_weight=OptionsInfo(scss=True, category='stub', type='value', value='initial'), stub_text_transform=OptionsInfo(scss=True, category='stub', type='value', value='inherit'), stub_border_style=OptionsInfo(scss=True, category='stub', type='value', value='solid'), stub_border_width=OptionsInfo(scss=True, category='stub', type='px', value='2px'), stub_border_color=OptionsInfo(scss=True, category='stub', type='value', value='#D3D3D3'), stub_row_group_background_color=OptionsInfo(scss=True, category='stub', type='value', value=None), stub_row_group_font_size=OptionsInfo(scss=True, category='stub', type='px', value='100%'), stub_row_group_font_weight=OptionsInfo(scss=True, category='stub', type='value', value='initial'), stub_row_group_text_transform=OptionsInfo(scss=True, category='stub', type='value', value='inherit'), stub_row_group_border_style=OptionsInfo(scss=True, category='stub', type='value', value='solid'), stub_row_group_border_width=OptionsInfo(scss=True, category='stub', type='px', value='2px'), stub_row_group_border_color=OptionsInfo(scss=True, category='stub', type='value', value='#D3D3D3'), source_notes_padding=OptionsInfo(scss=True, category='source_notes', type='px', value='4px'), source_notes_padding_horizontal=OptionsInfo(scss=True, category='source_notes', type='px', value='5px'), source_notes_background_color=OptionsInfo(scss=True, category='source_notes', type='value', value=None), source_notes_font_size=OptionsInfo(scss=True, category='source_notes', type='px', value='90%'), source_notes_border_bottom_style=OptionsInfo(scss=True, category='source_notes', type='value', value='none'), source_notes_border_bottom_width=OptionsInfo(scss=True, category='source_notes', type='px', value='2px'), source_notes_border_bottom_color=OptionsInfo(scss=True, category='source_notes', type='value', value='#D3D3D3'), source_notes_border_lr_style=OptionsInfo(scss=True, category='source_notes', type='value', value='none'), source_notes_border_lr_width=OptionsInfo(scss=True, category='source_notes', type='px', value='2px'), source_notes_border_lr_color=OptionsInfo(scss=True, category='source_notes', type='value', value='#D3D3D3'), source_notes_multiline=OptionsInfo(scss=False, category='source_notes', type='boolean', value=True), source_notes_sep=OptionsInfo(scss=False, category='source_notes', type='value', value=' '), row_striping_background_color=OptionsInfo(scss=True, category='row', type='value', value='rgba(128,128,128,0.05)'), row_striping_include_stub=OptionsInfo(scss=False, category='row', type='boolean', value=False), row_striping_include_table_body=OptionsInfo(scss=False, category='row', type='boolean', value=False), container_width=OptionsInfo(scss=False, category='container', type='px', value='auto'), container_height=OptionsInfo(scss=False, category='container', type='px', value='auto'), container_padding_x=OptionsInfo(scss=False, category='container', type='px', value='0px'), container_padding_y=OptionsInfo(scss=False, category='container', type='px', value='10px'), container_overflow_x=OptionsInfo(scss=False, category='container', type='overflow', value='auto'), container_overflow_y=OptionsInfo(scss=False, category='container', type='overflow', value='auto'), quarto_disable_processing=OptionsInfo(scss=False, category='quarto', type='logical', value=False), quarto_use_bootstrap=OptionsInfo(scss=False, category='quarto', type='logical', value=False)), _has_built=False)" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "results = pipeline.get_results()[\"results\"]\n", + "results_processed = []\n", + "for eval_name, eval_results in results.items():\n", + " results_processed.append({\n", + " \"Prompt function\": (eval_name.split(\":\")[1] if \":\" in eval_name else eval_name).replace(\"_\", \" \"), \n", + " \"Quasi Exact Match\": eval_results[\"qem\"], \n", + " \"Normalized Accuracy\": eval_results[\"acc_norm\"]\n", + " })\n", + "results_data = pl.from_dicts(results_processed, strict=False)\n", + "(GT(results_data.head(max_samples*4))\n", + " .tab_header(\"Results\")\n", + " .tab_spanner(label=\"Evaluations\", columns=[\"Quasi Exact Match\", \"Normalized Accuracy\"])\n", + "\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "872c4403", + "metadata": {}, + "source": [ + "# Lire les rĂ©sultats" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f4aae325", + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "2ca65572fde9462ab6c29b6f17974c65", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Generating train split: 0 examples [00:00, ? examples/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "84e8f2c884de4ecb9b9e2d4c158128a2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Generating train split: 0 examples [00:00, ? examples/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6dfe668ee83242fb9b9070b875db3f40", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Generating train split: 0 examples [00:00, ? examples/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "11ff92775dca4ff5aca86c24fccc038b", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Generating train split: 0 examples [00:00, ? examples/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "path = f\"{cache_dir}/details/HuggingFaceTB/SmolLM-1.7B/\"\n", + "\n", + "results = {}\n", + "\n", + "for root, _, files in os.walk(path):\n", + " for file in files:\n", + " eval_name = file.split(\"|\")[1]\n", + " results[eval_name] = load_dataset(\"parquet\", data_files=f\"{root}/{file}\")[\"train\"]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "08165452", + "metadata": {}, + "outputs": [], + "source": [ + "# crĂ©er un nouveau DataFrame pour stocker les donnĂ©es transformĂ©es\n", + "transformed_data = []\n", + "keys = [\"example\", \"gold\", \"predictions\", \"metrics\"]\n", + "\n", + "# itĂ©rer sur chaque jeu de donnĂ©es et ses Ă©chantillons\n", + "for ix in range(max_samples * 2):\n", + " for key in keys:\n", + " cur_sample = {\"Sample\": f\"Sample {ix}\", \"Type\": key.capitalize()}\n", + " for eval_name, df in sorted(results.items()):\n", + " try:\n", + " cur_result = literal_eval(results[eval_name][ix][key])\n", + " if isinstance(cur_result, list):\n", + " if len(cur_result) == 1:\n", + " cur_sample[eval_name] = cur_result[0]\n", + " else:\n", + " cur_sample[eval_name] = \"\\n\".join([str(i) for i in cur_result])\n", + " elif isinstance(cur_result, dict):\n", + " for metric, value in cur_result.items():\n", + " cur_sample[eval_name] = str(value)\n", + " cur_sample[\"Type\"] = f\"{key.capitalize()}: {metric}\"\n", + " except SyntaxError:\n", + " cur_sample[eval_name] = results[eval_name][ix][key]\n", + " \n", + " for k, v in cur_sample.items():\n", + " # Nous remplaçons les \\n de python par des
markdown pour l'affichage du tableau\n", + " if isinstance(v, str):\n", + " cur_sample[k] = v.replace(\"\\n\", \"
\")\n", + " transformed_data.append(cur_sample)" + ] + }, + { + "cell_type": "markdown", + "id": "e2f3d2f2", + "metadata": {}, + "source": [ + "### Examinons les résultats des générations" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "25cde03f", + "metadata": {}, + "outputs": [], + "source": [ + "pl_data = pl.from_dicts(transformed_data, strict=False, infer_schema_length=200)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "id": "bcd7288e", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "
Comparing our different prompts' outputs
\n", + " Samples\n", + "
arc_basearc_contextarc_context_choicearc_context_labels
Sample 0
ExampleCities control the amount of pollution that is allowed to come from cars. How does this most likely help people?Question: Cities control the amount of pollution that is allowed to come from cars. How does this most likely help people?
Answer:		Question: Cities control the amount of pollution that is allowed to come from cars. How does this most likely help people?
A. The air stays cleaner.
B. Cars can travel at faster speeds.
C. The skills of the drivers improve.
D. It becomes safer to drive on the roads.
Answer:		Question: Cities control the amount of pollution that is allowed to come from cars. How does this most likely help people?
A. The air stays cleaner.
B. Cars can travel at faster speeds.
C. The skills of the drivers improve.
D. It becomes safer to drive on the roads.
Answer:
GoldThe air stays cleaner.The air stays cleaner.The air stays cleaner.A
PredictionsIt reduces the amount of pollution in the air1It becomes safer to drive on the roadsD
Metrics: qem0000
Sample 1
ExampleWhich statement correctly describes a physical characteristic of the Moon?Question: Which statement correctly describes a physical characteristic of the Moon?
Answer:		Question: Which statement correctly describes a physical characteristic of the Moon?
A. The Moon is made of hot gases.
B. The Moon is covered with many craters.
C. The Moon has many bodies of liquid water.
D. The Moon has the ability to give off its own light.
Answer:		Question: Which statement correctly describes a physical characteristic of the Moon?
A. The Moon is made of hot gases.
B. The Moon is covered with many craters.
C. The Moon has many bodies of liquid water.
D. The Moon has the ability to give off its own light.
Answer:
GoldThe Moon is covered with many craters.The Moon is covered with many craters.The Moon is covered with many craters.B
Predictionsa1The Moon has the ability to give off its own lightD
Metrics: qem0000
Sample 2
ExampleWhich object in the solar system is orbited by a belt of asteroids?Question: Which object in the solar system is orbited by a belt of asteroids?
Answer:		Question: Which object in the solar system is orbited by a belt of asteroids?
A. Pluto
B. Saturn
C. the Sun
D. the Moon
Answer:		Question: Which object in the solar system is orbited by a belt of asteroids?
A. Pluto
B. Saturn
C. the Sun
D. the Moon
Answer:
Goldthe Sunthe Sunthe SunC
Predictions1The SunD
Metrics: qem0010
Sample 3
ExampleLight waves that cross from an air medium to a water medium willQuestion: Light waves that cross from an air medium to a water medium will
Answer:		Question: Light waves that cross from an air medium to a water medium will
A. be focused into a straight line.
B. lose energy and dissipate.
C. change length and direction.
D. reflect off the water's surface.
Answer:		Question: Light waves that cross from an air medium to a water medium will
A. be focused into a straight line.
B. lose energy and dissipate.
C. change length and direction.
D. reflect off the water's surface.
Answer:
Goldchange length and direction.change length and direction.change length and direction.C
Predictionsbend toward the normal1change length and directionD
Metrics: qem0010
Sample 4
ExampleHow many valence electrons does selenium have?Question: How many valence electrons does selenium have?
Answer:		Question: How many valence electrons does selenium have?
A. 3
B. 5
C. 6
D. 8
Answer:		Question: How many valence electrons does selenium have?
A. 3
B. 5
C. 6
D. 8
Answer:
Gold666C
Predictions668
Metrics: qem0110
Sample 5
ExampleAs a warm moist air mass moving northward collides with a strong cold air mass moving southward, what observations will most likely be made?Question: As a warm moist air mass moving northward collides with a strong cold air mass moving southward, what observations will most likely be made?
Answer:		Question: As a warm moist air mass moving northward collides with a strong cold air mass moving southward, what observations will most likely be made?
A. Thick fog develops.
B. Temperatures increase.
C. Clouds begin to form.
D. Winds die down.
Answer:		Question: As a warm moist air mass moving northward collides with a strong cold air mass moving southward, what observations will most likely be made?
A. Thick fog develops.
B. Temperatures increase.
C. Clouds begin to form.
D. Winds die down.
Answer:
GoldClouds begin to form.Clouds begin to form.Clouds begin to form.C
Predictionsdrought1Thick fog developsD
Metrics: qem0000
Sample 6
ExampleChemical weathering occurs when minerals in rocks are changed chemically. Which of these will most likely change the rate of chemical weathering on a rock?Question: Chemical weathering occurs when minerals in rocks are changed chemically. Which of these will most likely change the rate of chemical weathering on a rock?
Answer:		Question: Chemical weathering occurs when minerals in rocks are changed chemically. Which of these will most likely change the rate of chemical weathering on a rock?
A. decrease in air temperature
B. increase in rainfall amounts
C. slow movement of a glacier
D. rapid growth of plant roots
Answer:		Question: Chemical weathering occurs when minerals in rocks are changed chemically. Which of these will most likely change the rate of chemical weathering on a rock?
A. decrease in air temperature
B. increase in rainfall amounts
C. slow movement of a glacier
D. rapid growth of plant roots
Answer:
Goldincrease in rainfall amountsincrease in rainfall amountsincrease in rainfall amountsB
Predictionsa1increase in rainfall amountsD
Metrics: qem0010
Sample 7
ExampleA toy truck rolls over a smooth surface. If the surface is covered with sand, the truck will most likely rollQuestion: A toy truck rolls over a smooth surface. If the surface is covered with sand, the truck will most likely roll
Answer:		Question: A toy truck rolls over a smooth surface. If the surface is covered with sand, the truck will most likely roll
A. slower
B. faster
C. at the same speed
Answer:		Question: A toy truck rolls over a smooth surface. If the surface is covered with sand, the truck will most likely roll
A. slower
B. faster
C. at the same speed
Answer:
GoldslowerslowerslowerA
Predictionsfarther1at the same speedC
Metrics: qem0000
Sample 8
ExampleA town in northern Arkansas experienced colder than normal temperatures during part of the winter. Which change was most likely responsible for this?Question: A town in northern Arkansas experienced colder than normal temperatures during part of the winter. Which change was most likely responsible for this?
Answer:		Question: A town in northern Arkansas experienced colder than normal temperatures during part of the winter. Which change was most likely responsible for this?
A. A southward dip in the jet stream
B. A northward movement of the jet stream
C. The Coriolis effect creating a low pressure area
D. The Coriolis effect creating a high pressure area
Answer:		Question: A town in northern Arkansas experienced colder than normal temperatures during part of the winter. Which change was most likely responsible for this?
A. A southward dip in the jet stream
B. A northward movement of the jet stream
C. The Coriolis effect creating a low pressure area
D. The Coriolis effect creating a high pressure area
Answer:
GoldA southward dip in the jet streamA southward dip in the jet streamA southward dip in the jet streamA
PredictionsThe sun was farther away from the earth1The Coriolis effect creating a low pressure areaD
Metrics: qem0000
Sample 9
ExampleHow much time is required for a bicycle to travel a distance of 100 m at an average speed of 2 m/s?Question: How much time is required for a bicycle to travel a distance of 100 m at an average speed of 2 m/s?
Answer:		Question: How much time is required for a bicycle to travel a distance of 100 m at an average speed of 2 m/s?
A. 0.02 s
B. 50 s
C. 100 s
D. 200 s
Answer:		Question: How much time is required for a bicycle to travel a distance of 100 m at an average speed of 2 m/s?
A. 0.02 s
B. 50 s
C. 100 s
D. 200 s
Answer:
Gold50 s50 s50 sB
Predictions100 m/2 m/s = 50 s100 s200 s
Metrics: qem0000
\n", + "\n", + "
\n", + " " + ], + "text/plain": [ + "GT(_tbl_data=shape: (40, 6)\n", + "┌──────────┬──────────────┬──────────────────┬─────────────────┬─────────────────┬─────────────────┐\n", + "│ Sample ┆ Type ┆ arc_base ┆ arc_context ┆ arc_context_cho ┆ arc_context_lab │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ ice ┆ els │\n", + "│ str ┆ str ┆ str ┆ str ┆ --- ┆ --- │\n", + "│ ┆ ┆ ┆ ┆ str ┆ str │\n", + "╞══════════â•Ș══════════════â•Ș══════════════════â•Ș═════════════════â•Ș═════════════════â•Ș═════════════════╡\n", + "│ Sample 0 ┆ Example ┆ Cities control ┆ Question: ┆ Question: ┆ Question: │\n", + "│ ┆ ┆ the amount of p
 ┆ Cities control ┆ Cities control ┆ Cities control │\n", + "│ ┆ ┆ ┆ the a
 ┆ the a
 ┆ the a
 │\n", + "│ Sample 0 ┆ Gold ┆ The air stays ┆ The air stays ┆ The air stays ┆ A │\n", + "│ ┆ ┆ cleaner. ┆ cleaner. ┆ cleaner. ┆ │\n", + "│ Sample 0 ┆ Predictions ┆ It reduces the ┆ 1 ┆  It becomes ┆  D │\n", + "│ ┆ ┆ amount of pollu
 ┆ ┆ safer to drive ┆ │\n", + "│ ┆ ┆ ┆ ┆ on 
 ┆ │\n", + "│ Sample 0 ┆ Metrics: qem ┆ 0 ┆ 0 ┆ 0 ┆ 0 │\n", + "│ Sample 1 ┆ Example ┆ Which statement ┆ Question: Which ┆ Question: Which ┆ Question: Which │\n", + "│ ┆ ┆ correctly desc
 ┆ statement corr
 ┆ statement corr
 ┆ statement corr
 │\n", + "│ 
 ┆ 
 ┆ 
 ┆ 
 ┆ 
 ┆ 
 │\n", + "│ Sample 8 ┆ Metrics: qem ┆ 0 ┆ 0 ┆ 0 ┆ 0 │\n", + "│ Sample 9 ┆ Example ┆ How much time is ┆ Question: How ┆ Question: How ┆ Question: How │\n", + "│ ┆ ┆ required for 
 ┆ much time is ┆ much time is ┆ much time is │\n", + "│ ┆ ┆ ┆ req
 ┆ req
 ┆ req
 │\n", + "│ Sample 9 ┆ Gold ┆ 50 s ┆ 50 s ┆ 50 s ┆ B │\n", + "│ Sample 9 ┆ Predictions ┆ ┆ 100 m/2 m/s = ┆ 100 s ┆ 200 s │\n", + "│ ┆ ┆ ┆ 50 s ┆ ┆ │\n", + "│ Sample 9 ┆ Metrics: qem ┆ 0 ┆ 0 ┆ 0 ┆ 0 │\n", + "└──────────┮──────────────┮──────────────────┮─────────────────┮─────────────────┮─────────────────┘, _body=, _boxhead=Boxhead([ColInfo(var='Sample', type=, column_label='Sample', column_align='left', column_width=None), ColInfo(var='Type', type=, column_label='Type', column_align='left', column_width=None), ColInfo(var='arc_base', type=, column_label='arc_base', column_align='left', column_width=None), ColInfo(var='arc_context', type=, column_label='arc_context', column_align='left', column_width=None), ColInfo(var='arc_context_choice', type=, column_label='arc_context_choice', column_align='left', column_width=None), ColInfo(var='arc_context_labels', type=, column_label='arc_context_labels', column_align='left', column_width=None)]), _stub=, _spanners=Spanners([SpannerInfo(spanner_id='Samples', spanner_level=0, spanner_label='Samples', spanner_units=None, spanner_pattern=None, vars=['arc_base', 'arc_context', 'arc_context_choice', 'arc_context_labels'], built=None)]), _heading=Heading(title=\"Comparing our different prompts' outputs\", subtitle=None, preheader=None), _stubhead=None, _source_notes=[], _footnotes=[], _styles=[], _locale=, _formats=[], _substitutions=[], _options=Options(table_id=OptionsInfo(scss=False, category='table', type='value', value=None), table_caption=OptionsInfo(scss=False, category='table', type='value', value=None), table_width=OptionsInfo(scss=True, category='table', type='px', value='auto'), table_layout=OptionsInfo(scss=True, category='table', type='value', value='fixed'), table_margin_left=OptionsInfo(scss=True, category='table', type='px', value='auto'), table_margin_right=OptionsInfo(scss=True, category='table', type='px', value='auto'), table_background_color=OptionsInfo(scss=True, category='table', type='value', value='#FFFFFF'), table_additional_css=OptionsInfo(scss=False, category='table', type='values', value=[]), table_font_names=OptionsInfo(scss=False, category='table', type='values', value=['-apple-system', 'BlinkMacSystemFont', 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Helvetica Neue', 'Fira Sans', 'Droid Sans', 'Arial', 'sans-serif']), table_font_size=OptionsInfo(scss=True, category='table', type='px', value='16px'), table_font_weight=OptionsInfo(scss=True, category='table', type='value', value='normal'), table_font_style=OptionsInfo(scss=True, category='table', type='value', value='normal'), table_font_color=OptionsInfo(scss=True, category='table', type='value', value='#333333'), table_font_color_light=OptionsInfo(scss=True, category='table', type='value', value='#FFFFFF'), table_border_top_include=OptionsInfo(scss=False, category='table', type='boolean', value=True), table_border_top_style=OptionsInfo(scss=True, category='table', type='value', value='solid'), table_border_top_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_top_color=OptionsInfo(scss=True, category='table', type='value', value='#A8A8A8'), table_border_right_style=OptionsInfo(scss=True, category='table', type='value', value='none'), table_border_right_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_right_color=OptionsInfo(scss=True, category='table', type='value', value='#D3D3D3'), table_border_bottom_include=OptionsInfo(scss=False, category='table', type='boolean', value=True), table_border_bottom_style=OptionsInfo(scss=True, category='table', type='value', value='solid'), table_border_bottom_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_bottom_color=OptionsInfo(scss=True, category='table', type='value', value='#A8A8A8'), table_border_left_style=OptionsInfo(scss=True, category='table', type='value', value='none'), table_border_left_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_left_color=OptionsInfo(scss=True, category='table', type='value', value='#D3D3D3'), heading_background_color=OptionsInfo(scss=True, category='heading', type='value', value=None), heading_align=OptionsInfo(scss=True, category='heading', type='value', value='center'), heading_title_font_size=OptionsInfo(scss=True, category='heading', type='px', value='125%'), heading_title_font_weight=OptionsInfo(scss=True, category='heading', type='value', value='initial'), heading_subtitle_font_size=OptionsInfo(scss=True, category='heading', type='px', value='85%'), heading_subtitle_font_weight=OptionsInfo(scss=True, category='heading', type='value', value='initial'), heading_padding=OptionsInfo(scss=True, category='heading', type='px', value='4px'), heading_padding_horizontal=OptionsInfo(scss=True, category='heading', type='px', value='5px'), heading_border_bottom_style=OptionsInfo(scss=True, category='heading', type='value', value='solid'), heading_border_bottom_width=OptionsInfo(scss=True, category='heading', type='px', value='2px'), heading_border_bottom_color=OptionsInfo(scss=True, category='heading', type='value', value='#D3D3D3'), heading_border_lr_style=OptionsInfo(scss=True, category='heading', type='value', value='none'), heading_border_lr_width=OptionsInfo(scss=True, category='heading', type='px', value='1px'), heading_border_lr_color=OptionsInfo(scss=True, category='heading', type='value', value='#D3D3D3'), column_labels_background_color=OptionsInfo(scss=True, category='column_labels', type='value', value=None), column_labels_font_size=OptionsInfo(scss=True, category='column_labels', type='px', value='100%'), column_labels_font_weight=OptionsInfo(scss=True, category='column_labels', type='value', value='normal'), column_labels_text_transform=OptionsInfo(scss=True, category='column_labels', type='value', value='inherit'), column_labels_padding=OptionsInfo(scss=True, category='column_labels', type='px', value='5px'), column_labels_padding_horizontal=OptionsInfo(scss=True, category='column_labels', type='px', value='5px'), column_labels_vlines_style=OptionsInfo(scss=True, category='table_body', type='value', value='none'), column_labels_vlines_width=OptionsInfo(scss=True, category='table_body', type='px', value='1px'), column_labels_vlines_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), column_labels_border_top_style=OptionsInfo(scss=True, category='column_labels', type='value', value='solid'), column_labels_border_top_width=OptionsInfo(scss=True, category='column_labels', type='px', value='2px'), column_labels_border_top_color=OptionsInfo(scss=True, category='column_labels', type='value', value='#D3D3D3'), column_labels_border_bottom_style=OptionsInfo(scss=True, category='column_labels', type='value', value='solid'), column_labels_border_bottom_width=OptionsInfo(scss=True, category='column_labels', type='px', value='2px'), column_labels_border_bottom_color=OptionsInfo(scss=True, category='column_labels', type='value', value='#D3D3D3'), column_labels_border_lr_style=OptionsInfo(scss=True, category='column_labels', type='value', value='none'), column_labels_border_lr_width=OptionsInfo(scss=True, category='column_labels', type='px', value='1px'), column_labels_border_lr_color=OptionsInfo(scss=True, category='column_labels', type='value', value='#D3D3D3'), column_labels_hidden=OptionsInfo(scss=False, category='column_labels', type='boolean', value=False), row_group_background_color=OptionsInfo(scss=True, category='row_group', type='value', value=None), row_group_font_size=OptionsInfo(scss=True, category='row_group', type='px', value='100%'), row_group_font_weight=OptionsInfo(scss=True, category='row_group', type='value', value='initial'), row_group_text_transform=OptionsInfo(scss=True, category='row_group', type='value', value='inherit'), row_group_padding=OptionsInfo(scss=True, category='row_group', type='px', value='8px'), row_group_padding_horizontal=OptionsInfo(scss=True, category='row_group', type='px', value='5px'), row_group_border_top_style=OptionsInfo(scss=True, category='row_group', type='value', value='solid'), row_group_border_top_width=OptionsInfo(scss=True, category='row_group', type='px', value='2px'), row_group_border_top_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_border_right_style=OptionsInfo(scss=True, category='row_group', type='value', value='none'), row_group_border_right_width=OptionsInfo(scss=True, category='row_group', type='px', value='1px'), row_group_border_right_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_border_bottom_style=OptionsInfo(scss=True, category='row_group', type='value', value='solid'), row_group_border_bottom_width=OptionsInfo(scss=True, category='row_group', type='px', value='2px'), row_group_border_bottom_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_border_left_style=OptionsInfo(scss=True, category='row_group', type='value', value='none'), row_group_border_left_width=OptionsInfo(scss=True, category='row_group', type='px', value='1px'), row_group_border_left_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_as_column=OptionsInfo(scss=False, category='row_group', type='boolean', value=False), table_body_hlines_style=OptionsInfo(scss=True, category='table_body', type='value', value='solid'), table_body_hlines_width=OptionsInfo(scss=True, category='table_body', type='px', value='1px'), table_body_hlines_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), table_body_vlines_style=OptionsInfo(scss=True, category='table_body', type='value', value='none'), table_body_vlines_width=OptionsInfo(scss=True, category='table_body', type='px', value='1px'), table_body_vlines_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), table_body_border_top_style=OptionsInfo(scss=True, category='table_body', type='value', value='solid'), table_body_border_top_width=OptionsInfo(scss=True, category='table_body', type='px', value='2px'), table_body_border_top_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), table_body_border_bottom_style=OptionsInfo(scss=True, category='table_body', type='value', value='solid'), table_body_border_bottom_width=OptionsInfo(scss=True, category='table_body', type='px', value='2px'), table_body_border_bottom_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), data_row_padding=OptionsInfo(scss=True, category='data_row', type='px', value='8px'), data_row_padding_horizontal=OptionsInfo(scss=True, category='data_row', type='px', value='5px'), stub_background_color=OptionsInfo(scss=True, category='stub', type='value', value=None), stub_font_size=OptionsInfo(scss=True, category='stub', type='px', value='100%'), stub_font_weight=OptionsInfo(scss=True, category='stub', type='value', value='initial'), stub_text_transform=OptionsInfo(scss=True, category='stub', type='value', value='inherit'), stub_border_style=OptionsInfo(scss=True, category='stub', type='value', value='solid'), stub_border_width=OptionsInfo(scss=True, category='stub', type='px', value='2px'), stub_border_color=OptionsInfo(scss=True, category='stub', type='value', value='#D3D3D3'), stub_row_group_background_color=OptionsInfo(scss=True, category='stub', type='value', value=None), stub_row_group_font_size=OptionsInfo(scss=True, category='stub', type='px', value='100%'), stub_row_group_font_weight=OptionsInfo(scss=True, category='stub', type='value', value='initial'), stub_row_group_text_transform=OptionsInfo(scss=True, category='stub', type='value', value='inherit'), stub_row_group_border_style=OptionsInfo(scss=True, category='stub', type='value', value='solid'), stub_row_group_border_width=OptionsInfo(scss=True, category='stub', type='px', value='2px'), stub_row_group_border_color=OptionsInfo(scss=True, category='stub', type='value', value='#D3D3D3'), source_notes_padding=OptionsInfo(scss=True, category='source_notes', type='px', value='4px'), source_notes_padding_horizontal=OptionsInfo(scss=True, category='source_notes', type='px', value='5px'), source_notes_background_color=OptionsInfo(scss=True, category='source_notes', type='value', value=None), source_notes_font_size=OptionsInfo(scss=True, category='source_notes', type='px', value='90%'), source_notes_border_bottom_style=OptionsInfo(scss=True, category='source_notes', type='value', value='none'), source_notes_border_bottom_width=OptionsInfo(scss=True, category='source_notes', type='px', value='2px'), source_notes_border_bottom_color=OptionsInfo(scss=True, category='source_notes', type='value', value='#D3D3D3'), source_notes_border_lr_style=OptionsInfo(scss=True, category='source_notes', type='value', value='none'), source_notes_border_lr_width=OptionsInfo(scss=True, category='source_notes', type='px', value='2px'), source_notes_border_lr_color=OptionsInfo(scss=True, category='source_notes', type='value', value='#D3D3D3'), source_notes_multiline=OptionsInfo(scss=False, category='source_notes', type='boolean', value=True), source_notes_sep=OptionsInfo(scss=False, category='source_notes', type='value', value=' '), row_striping_background_color=OptionsInfo(scss=True, category='row', type='value', value='rgba(128,128,128,0.05)'), row_striping_include_stub=OptionsInfo(scss=False, category='row', type='boolean', value=False), row_striping_include_table_body=OptionsInfo(scss=False, category='row', type='boolean', value=False), container_width=OptionsInfo(scss=False, category='container', type='px', value='auto'), container_height=OptionsInfo(scss=False, category='container', type='px', value='auto'), container_padding_x=OptionsInfo(scss=False, category='container', type='px', value='0px'), container_padding_y=OptionsInfo(scss=False, category='container', type='px', value='10px'), container_overflow_x=OptionsInfo(scss=False, category='container', type='overflow', value='auto'), container_overflow_y=OptionsInfo(scss=False, category='container', type='overflow', value='auto'), quarto_disable_processing=OptionsInfo(scss=False, category='quarto', type='logical', value=False), quarto_use_bootstrap=OptionsInfo(scss=False, category='quarto', type='logical', value=False)), _has_built=False)" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(GT(pl_data.head(max_samples*4))\n", + " .tab_header(\"Comparing our different prompts' outputs\")\n", + " .tab_spanner(label=\"Samples\", columns=cs.starts_with(\"arc\"))\n", + " .tab_stub(rowname_col=\"Type\", groupname_col=\"Sample\")\n", + " .fmt_markdown(columns=cs.starts_with(\"arc\"))\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "9fda1fd6", + "metadata": {}, + "source": [ + "Nous pouvons observer que :\n", + "- le format de base est trop rigide en mode gĂ©nĂ©ratif : le modĂšle ne prĂ©dit jamais la bonne fin\n", + "- le format de base + balises question/rĂ©ponse semble inciter le modĂšle Ă  produire des nombres, ce qui est inadĂ©quat pour un certain nombre de questions\n", + "- cependant (dans les deux derniers cas), l'introduction des choix dans la question aide le modĂšle Ă  prĂ©dire un choix parmi les choix pertinents !\n", + "\n", + "Il est intĂ©ressant de noter que dans le dernier cas, lorsque les choix sont prĂ©sents mais que le modĂšle doit prĂ©dire l'Ă©tiquette, il n'y parvient pas systĂ©matiquement. \n", + "\n", + "Dans d'autres cas, comme les Ă©chantillons 3 et 4, le modĂšle ne sĂ©lectionnera pas le mĂȘme choix en prĂ©disant l'Ă©tiquette ou en prĂ©disant le choix (si les choix Ă©taient prĂ©sents)." + ] + }, + { + "cell_type": "markdown", + "id": "8c2fe99d", + "metadata": {}, + "source": [ + "### Examinons les log-probabilitĂ©s en sortie" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "1c5b7411", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + "\n", + " \n", + " \n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "\n", + "\n", + "\n", + "
Comparing our different prompts' outputs
\n", + " Samples\n", + "
arc_basearc_contextarc_context_choicearc_context_labels
Sample 10
ExampleCities control the amount of pollution that is allowed to come from cars. How does this most likely help people?Question: Cities control the amount of pollution that is allowed to come from cars. How does this most likely help people?
Answer:		Question: Cities control the amount of pollution that is allowed to come from cars. How does this most likely help people?
A. The air stays cleaner.
B. Cars can travel at faster speeds.
C. The skills of the drivers improve.
D. It becomes safer to drive on the roads.
Answer:		Question: Cities control the amount of pollution that is allowed to come from cars. How does this most likely help people?
A. The air stays cleaner.
B. Cars can travel at faster speeds.
C. The skills of the drivers improve.
D. It becomes safer to drive on the roads.
Answer:
GoldThe air stays cleaner.The air stays cleaner.The air stays cleaner.A
Predictions(-10.595719337463379, False)
(-17.943925857543945, False)
(-25.558387756347656, False)
(-19.944787979125977, False)		(-9.650793075561523, False)
(-18.44221305847168, False)
(-28.147789001464844, False)
(-21.082042694091797, False)		(-1.7918881177902222, False)
(-3.5758469104766846, False)
(-2.042778253555298, False)
(-0.5759693384170532, True)		(-1.445155382156372, False)
(-1.695155382156372, False)
(-1.445155382156372, False)
(-1.070155382156372, True)
Metrics: acc_norm1100
Sample 11
ExampleWhich statement correctly describes a physical characteristic of the Moon?Question: Which statement correctly describes a physical characteristic of the Moon?
Answer:		Question: Which statement correctly describes a physical characteristic of the Moon?
A. The Moon is made of hot gases.
B. The Moon is covered with many craters.
C. The Moon has many bodies of liquid water.
D. The Moon has the ability to give off its own light.
Answer:		Question: Which statement correctly describes a physical characteristic of the Moon?
A. The Moon is made of hot gases.
B. The Moon is covered with many craters.
C. The Moon has many bodies of liquid water.
D. The Moon has the ability to give off its own light.
Answer:
GoldThe Moon is covered with many craters.The Moon is covered with many craters.The Moon is covered with many craters.B
Predictions(-14.036760330200195, False)
(-14.156133651733398, False)
(-23.221176147460938, False)
(-22.99703598022461, False)		(-12.965611457824707, False)
(-11.864521026611328, False)
(-20.491010665893555, False)
(-21.728534698486328, False)		(-4.868813514709473, False)
(-3.7199177742004395, False)
(-3.739739418029785, False)
(-0.2140919268131256, True)		(-1.5505614280700684, False)
(-1.4255614280700684, False)
(-1.3005614280700684, True)
(-1.3005614280700684, False)
Metrics: acc_norm1100
Sample 12
ExampleWhich object in the solar system is orbited by a belt of asteroids?Question: Which object in the solar system is orbited by a belt of asteroids?
Answer:		Question: Which object in the solar system is orbited by a belt of asteroids?
A. Pluto
B. Saturn
C. the Sun
D. the Moon
Answer:		Question: Which object in the solar system is orbited by a belt of asteroids?
A. Pluto
B. Saturn
C. the Sun
D. the Moon
Answer:
Goldthe Sunthe Sunthe SunC
Predictions(-5.751784801483154, False)
(-3.7467873096466064, False)
(-6.4582719802856445, False)
(-7.0832719802856445, False)		(-3.279644250869751, False)
(-3.654644250869751, False)
(-5.170290946960449, False)
(-5.920290946960449, False)		(-2.128627300262451, False)
(-1.8786273002624512, False)
(-0.7749634981155396, True)
(-2.774963617324829, False)		(-1.6950974464416504, False)
(-1.4450974464416504, False)
(-1.3200974464416504, False)
(-1.1950974464416504, True)
Metrics: acc_norm0010
Sample 13
ExampleLight waves that cross from an air medium to a water medium willQuestion: Light waves that cross from an air medium to a water medium will
Answer:		Question: Light waves that cross from an air medium to a water medium will
A. be focused into a straight line.
B. lose energy and dissipate.
C. change length and direction.
D. reflect off the water's surface.
Answer:		Question: Light waves that cross from an air medium to a water medium will
A. be focused into a straight line.
B. lose energy and dissipate.
C. change length and direction.
D. reflect off the water's surface.
Answer:
Goldchange length and direction.change length and direction.change length and direction.C
Predictions(-25.314556121826172, False)
(-22.782466888427734, False)
(-22.68366050720215, False)
(-21.23833465576172, False)		(-17.779306411743164, False)
(-15.633138656616211, False)
(-14.039811134338379, False)
(-11.432372093200684, False)		(-4.998326301574707, False)
(-1.623903512954712, False)
(-0.5861192941665649, True)
(-2.0934457778930664, False)		(-1.625598669052124, False)
(-1.500598669052124, False)
(-1.375598669052124, False)
(-1.125598669052124, True)
Metrics: acc_norm0010
Sample 14
ExampleHow many valence electrons does selenium have?Question: How many valence electrons does selenium have?
Answer:		Question: How many valence electrons does selenium have?
A. 3
B. 5
C. 6
D. 8
Answer:		Question: How many valence electrons does selenium have?
A. 3
B. 5
C. 6
D. 8
Answer:
Gold666C
Predictions(-6.6732683181762695, False)
(-6.9232683181762695, False)
(-7.2357683181762695, False)
(-6.7982683181762695, False)		(-3.4133384227752686, False)
(-4.663338661193848, False)
(-1.1633384227752686, True)
(-3.7883384227752686, False)		(-6.926815986633301, False)
(-6.051815986633301, False)
(-0.17681613564491272, True)
(-1.9268162250518799, False)		(-1.8513681888580322, False)
(-1.6013681888580322, False)
(-1.3513681888580322, False)
(-0.976368248462677, True)
Metrics: acc_norm0110
Sample 15
ExampleAs a warm moist air mass moving northward collides with a strong cold air mass moving southward, what observations will most likely be made?Question: As a warm moist air mass moving northward collides with a strong cold air mass moving southward, what observations will most likely be made?
Answer:		Question: As a warm moist air mass moving northward collides with a strong cold air mass moving southward, what observations will most likely be made?
A. Thick fog develops.
B. Temperatures increase.
C. Clouds begin to form.
D. Winds die down.
Answer:		Question: As a warm moist air mass moving northward collides with a strong cold air mass moving southward, what observations will most likely be made?
A. Thick fog develops.
B. Temperatures increase.
C. Clouds begin to form.
D. Winds die down.
Answer:
GoldClouds begin to form.Clouds begin to form.Clouds begin to form.C
Predictions(-16.48362159729004, False)
(-12.333986282348633, False)
(-10.768516540527344, False)
(-14.52383804321289, False)		(-15.831233024597168, False)
(-11.781991004943848, False)
(-10.162830352783203, False)
(-15.114853858947754, False)		(-0.6979869604110718, True)
(-1.7184417247772217, False)
(-2.8269424438476562, False)
(-2.2389371395111084, False)		(-1.4881373643875122, False)
(-1.4881373643875122, False)
(-1.3631373643875122, False)
(-1.2381373643875122, True)
Metrics: acc_norm1100
Sample 16
ExampleChemical weathering occurs when minerals in rocks are changed chemically. Which of these will most likely change the rate of chemical weathering on a rock?Question: Chemical weathering occurs when minerals in rocks are changed chemically. Which of these will most likely change the rate of chemical weathering on a rock?
Answer:		Question: Chemical weathering occurs when minerals in rocks are changed chemically. Which of these will most likely change the rate of chemical weathering on a rock?
A. decrease in air temperature
B. increase in rainfall amounts
C. slow movement of a glacier
D. rapid growth of plant roots
Answer:		Question: Chemical weathering occurs when minerals in rocks are changed chemically. Which of these will most likely change the rate of chemical weathering on a rock?
A. decrease in air temperature
B. increase in rainfall amounts
C. slow movement of a glacier
D. rapid growth of plant roots
Answer:
Goldincrease in rainfall amountsincrease in rainfall amountsincrease in rainfall amountsB
Predictions(-15.226205825805664, False)
(-18.300310134887695, False)
(-18.7595272064209, False)
(-16.90313148498535, False)		(-15.182734489440918, False)
(-16.29802131652832, False)
(-15.929485321044922, False)
(-15.493678092956543, False)		(-2.301724433898926, False)
(-1.6302365064620972, False)
(-1.4298421144485474, False)
(-2.3473901748657227, False)		(-1.734103798866272, False)
(-1.609103798866272, False)
(-1.234103798866272, False)
(-1.109103798866272, True)
Metrics: acc_norm0000
Sample 17
ExampleA toy truck rolls over a smooth surface. If the surface is covered with sand, the truck will most likely rollQuestion: A toy truck rolls over a smooth surface. If the surface is covered with sand, the truck will most likely roll
Answer:		Question: A toy truck rolls over a smooth surface. If the surface is covered with sand, the truck will most likely roll
A. slower
B. faster
C. at the same speed
Answer:		Question: A toy truck rolls over a smooth surface. If the surface is covered with sand, the truck will most likely roll
A. slower
B. faster
C. at the same speed
Answer:
GoldslowerslowerslowerA
Predictions(-13.275317192077637, False)
(-10.096747398376465, False)
(-19.148441314697266, False)		(-2.1855695247650146, False)
(-2.1855695247650146, True)
(-7.597217559814453, False)		(-1.2695996761322021, False)
(-0.7695997357368469, True)
(-1.6472738981246948, False)		(-1.2452011108398438, False)
(-1.3702011108398438, False)
(-0.995201051235199, True)
Metrics: acc_norm0100
Sample 18
ExampleA town in northern Arkansas experienced colder than normal temperatures during part of the winter. Which change was most likely responsible for this?Question: A town in northern Arkansas experienced colder than normal temperatures during part of the winter. Which change was most likely responsible for this?
Answer:		Question: A town in northern Arkansas experienced colder than normal temperatures during part of the winter. Which change was most likely responsible for this?
A. A southward dip in the jet stream
B. A northward movement of the jet stream
C. The Coriolis effect creating a low pressure area
D. The Coriolis effect creating a high pressure area
Answer:		Question: A town in northern Arkansas experienced colder than normal temperatures during part of the winter. Which change was most likely responsible for this?
A. A southward dip in the jet stream
B. A northward movement of the jet stream
C. The Coriolis effect creating a low pressure area
D. The Coriolis effect creating a high pressure area
Answer:
GoldA southward dip in the jet streamA southward dip in the jet streamA southward dip in the jet streamA
Predictions(-14.345656394958496, False)
(-16.05936050415039, False)
(-28.54291534423828, False)
(-28.780471801757812, False)		(-14.603858947753906, False)
(-16.18315887451172, False)
(-27.121496200561523, False)
(-27.188758850097656, False)		(-1.6069732904434204, False)
(-3.61207914352417, False)
(-0.9148926734924316, True)
(-1.2960143089294434, False)		(-1.4954701662063599, False)
(-1.6204701662063599, False)
(-1.2454701662063599, True)
(-1.2454701662063599, False)
Metrics: acc_norm0000
Sample 19
ExampleHow much time is required for a bicycle to travel a distance of 100 m at an average speed of 2 m/s?Question: How much time is required for a bicycle to travel a distance of 100 m at an average speed of 2 m/s?
Answer:		Question: How much time is required for a bicycle to travel a distance of 100 m at an average speed of 2 m/s?
A. 0.02 s
B. 50 s
C. 100 s
D. 200 s
Answer:		Question: How much time is required for a bicycle to travel a distance of 100 m at an average speed of 2 m/s?
A. 0.02 s
B. 50 s
C. 100 s
D. 200 s
Answer:
Gold50 s50 s50 sB
Predictions(-9.211626052856445, False)
(-7.683445453643799, False)
(-7.148634433746338, False)
(-8.429720878601074, False)		(-7.6334710121154785, False)
(-4.587807655334473, False)
(-4.615830421447754, False)
(-6.059815883636475, False)		(-3.2665140628814697, False)
(-1.9924125671386719, False)
(-0.8778499960899353, True)
(-0.9978684186935425, False)		(-1.7351858615875244, False)
(-1.6101858615875244, False)
(-1.2351858615875244, False)
(-1.1101858615875244, True)
Metrics: acc_norm0000
\n", + "\n", + "
\n", + " " + ], + "text/plain": [ + "GT(_tbl_data=shape: (40, 6)\n", + "┌───────────┬─────────────┬──────────────────┬─────────────────┬─────────────────┬─────────────────┐\n", + "│ Sample ┆ Type ┆ arc_base ┆ arc_context ┆ arc_context_cho ┆ arc_context_lab │\n", + "│ --- ┆ --- ┆ --- ┆ --- ┆ ice ┆ els │\n", + "│ str ┆ str ┆ str ┆ str ┆ --- ┆ --- │\n", + "│ ┆ ┆ ┆ ┆ str ┆ str │\n", + "╞═══════════â•Ș═════════════â•Ș══════════════════â•Ș═════════════════â•Ș═════════════════â•Ș═════════════════╡\n", + "│ Sample 10 ┆ Example ┆ Cities control ┆ Question: ┆ Question: ┆ Question: │\n", + "│ ┆ ┆ the amount of p
 ┆ Cities control ┆ Cities control ┆ Cities control │\n", + "│ ┆ ┆ ┆ the a
 ┆ the a
 ┆ the a
 │\n", + "│ Sample 10 ┆ Gold ┆ The air stays ┆ The air stays ┆ The air stays ┆ A │\n", + "│ ┆ ┆ cleaner. ┆ cleaner. ┆ cleaner. ┆ │\n", + "│ Sample 10 ┆ Predictions ┆ (-10.59571933746 ┆ (-9.65079307556 ┆ (-1.79188811779 ┆ (-1.44515538215 │\n", + "│ ┆ ┆ 3379, False), _boxhead=Boxhead([ColInfo(var='Sample', type=, column_label='Sample', column_align='left', column_width=None), ColInfo(var='Type', type=, column_label='Type', column_align='left', column_width=None), ColInfo(var='arc_base', type=, column_label='arc_base', column_align='left', column_width=None), ColInfo(var='arc_context', type=, column_label='arc_context', column_align='left', column_width=None), ColInfo(var='arc_context_choice', type=, column_label='arc_context_choice', column_align='left', column_width=None), ColInfo(var='arc_context_labels', type=, column_label='arc_context_labels', column_align='left', column_width=None)]), _stub=, _spanners=Spanners([SpannerInfo(spanner_id='Samples', spanner_level=0, spanner_label='Samples', spanner_units=None, spanner_pattern=None, vars=['arc_base', 'arc_context', 'arc_context_choice', 'arc_context_labels'], built=None)]), _heading=Heading(title=\"Comparing our different prompts' outputs\", subtitle=None, preheader=None), _stubhead=None, _source_notes=[], _footnotes=[], _styles=[], _locale=, _formats=[], _substitutions=[], _options=Options(table_id=OptionsInfo(scss=False, category='table', type='value', value=None), table_caption=OptionsInfo(scss=False, category='table', type='value', value=None), table_width=OptionsInfo(scss=True, category='table', type='px', value='auto'), table_layout=OptionsInfo(scss=True, category='table', type='value', value='fixed'), table_margin_left=OptionsInfo(scss=True, category='table', type='px', value='auto'), table_margin_right=OptionsInfo(scss=True, category='table', type='px', value='auto'), table_background_color=OptionsInfo(scss=True, category='table', type='value', value='#FFFFFF'), table_additional_css=OptionsInfo(scss=False, category='table', type='values', value=[]), table_font_names=OptionsInfo(scss=False, category='table', type='values', value=['-apple-system', 'BlinkMacSystemFont', 'Segoe UI', 'Roboto', 'Oxygen', 'Ubuntu', 'Cantarell', 'Helvetica Neue', 'Fira Sans', 'Droid Sans', 'Arial', 'sans-serif']), table_font_size=OptionsInfo(scss=True, category='table', type='px', value='16px'), table_font_weight=OptionsInfo(scss=True, category='table', type='value', value='normal'), table_font_style=OptionsInfo(scss=True, category='table', type='value', value='normal'), table_font_color=OptionsInfo(scss=True, category='table', type='value', value='#333333'), table_font_color_light=OptionsInfo(scss=True, category='table', type='value', value='#FFFFFF'), table_border_top_include=OptionsInfo(scss=False, category='table', type='boolean', value=True), table_border_top_style=OptionsInfo(scss=True, category='table', type='value', value='solid'), table_border_top_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_top_color=OptionsInfo(scss=True, category='table', type='value', value='#A8A8A8'), table_border_right_style=OptionsInfo(scss=True, category='table', type='value', value='none'), table_border_right_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_right_color=OptionsInfo(scss=True, category='table', type='value', value='#D3D3D3'), table_border_bottom_include=OptionsInfo(scss=False, category='table', type='boolean', value=True), table_border_bottom_style=OptionsInfo(scss=True, category='table', type='value', value='solid'), table_border_bottom_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_bottom_color=OptionsInfo(scss=True, category='table', type='value', value='#A8A8A8'), table_border_left_style=OptionsInfo(scss=True, category='table', type='value', value='none'), table_border_left_width=OptionsInfo(scss=True, category='table', type='px', value='2px'), table_border_left_color=OptionsInfo(scss=True, category='table', type='value', value='#D3D3D3'), heading_background_color=OptionsInfo(scss=True, category='heading', type='value', value=None), heading_align=OptionsInfo(scss=True, category='heading', type='value', value='center'), heading_title_font_size=OptionsInfo(scss=True, category='heading', type='px', value='125%'), heading_title_font_weight=OptionsInfo(scss=True, category='heading', type='value', value='initial'), heading_subtitle_font_size=OptionsInfo(scss=True, category='heading', type='px', value='85%'), heading_subtitle_font_weight=OptionsInfo(scss=True, category='heading', type='value', value='initial'), heading_padding=OptionsInfo(scss=True, category='heading', type='px', value='4px'), heading_padding_horizontal=OptionsInfo(scss=True, category='heading', type='px', value='5px'), heading_border_bottom_style=OptionsInfo(scss=True, category='heading', type='value', value='solid'), heading_border_bottom_width=OptionsInfo(scss=True, category='heading', type='px', value='2px'), heading_border_bottom_color=OptionsInfo(scss=True, category='heading', type='value', value='#D3D3D3'), heading_border_lr_style=OptionsInfo(scss=True, category='heading', type='value', value='none'), heading_border_lr_width=OptionsInfo(scss=True, category='heading', type='px', value='1px'), heading_border_lr_color=OptionsInfo(scss=True, category='heading', type='value', value='#D3D3D3'), column_labels_background_color=OptionsInfo(scss=True, category='column_labels', type='value', value=None), column_labels_font_size=OptionsInfo(scss=True, category='column_labels', type='px', value='100%'), column_labels_font_weight=OptionsInfo(scss=True, category='column_labels', type='value', value='normal'), column_labels_text_transform=OptionsInfo(scss=True, category='column_labels', type='value', value='inherit'), column_labels_padding=OptionsInfo(scss=True, category='column_labels', type='px', value='5px'), column_labels_padding_horizontal=OptionsInfo(scss=True, category='column_labels', type='px', value='5px'), column_labels_vlines_style=OptionsInfo(scss=True, category='table_body', type='value', value='none'), column_labels_vlines_width=OptionsInfo(scss=True, category='table_body', type='px', value='1px'), column_labels_vlines_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), column_labels_border_top_style=OptionsInfo(scss=True, category='column_labels', type='value', value='solid'), column_labels_border_top_width=OptionsInfo(scss=True, category='column_labels', type='px', value='2px'), column_labels_border_top_color=OptionsInfo(scss=True, category='column_labels', type='value', value='#D3D3D3'), column_labels_border_bottom_style=OptionsInfo(scss=True, category='column_labels', type='value', value='solid'), column_labels_border_bottom_width=OptionsInfo(scss=True, category='column_labels', type='px', value='2px'), column_labels_border_bottom_color=OptionsInfo(scss=True, category='column_labels', type='value', value='#D3D3D3'), column_labels_border_lr_style=OptionsInfo(scss=True, category='column_labels', type='value', value='none'), column_labels_border_lr_width=OptionsInfo(scss=True, category='column_labels', type='px', value='1px'), column_labels_border_lr_color=OptionsInfo(scss=True, category='column_labels', type='value', value='#D3D3D3'), column_labels_hidden=OptionsInfo(scss=False, category='column_labels', type='boolean', value=False), row_group_background_color=OptionsInfo(scss=True, category='row_group', type='value', value=None), row_group_font_size=OptionsInfo(scss=True, category='row_group', type='px', value='100%'), row_group_font_weight=OptionsInfo(scss=True, category='row_group', type='value', value='initial'), row_group_text_transform=OptionsInfo(scss=True, category='row_group', type='value', value='inherit'), row_group_padding=OptionsInfo(scss=True, category='row_group', type='px', value='8px'), row_group_padding_horizontal=OptionsInfo(scss=True, category='row_group', type='px', value='5px'), row_group_border_top_style=OptionsInfo(scss=True, category='row_group', type='value', value='solid'), row_group_border_top_width=OptionsInfo(scss=True, category='row_group', type='px', value='2px'), row_group_border_top_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_border_right_style=OptionsInfo(scss=True, category='row_group', type='value', value='none'), row_group_border_right_width=OptionsInfo(scss=True, category='row_group', type='px', value='1px'), row_group_border_right_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_border_bottom_style=OptionsInfo(scss=True, category='row_group', type='value', value='solid'), row_group_border_bottom_width=OptionsInfo(scss=True, category='row_group', type='px', value='2px'), row_group_border_bottom_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_border_left_style=OptionsInfo(scss=True, category='row_group', type='value', value='none'), row_group_border_left_width=OptionsInfo(scss=True, category='row_group', type='px', value='1px'), row_group_border_left_color=OptionsInfo(scss=True, category='row_group', type='value', value='#D3D3D3'), row_group_as_column=OptionsInfo(scss=False, category='row_group', type='boolean', value=False), table_body_hlines_style=OptionsInfo(scss=True, category='table_body', type='value', value='solid'), table_body_hlines_width=OptionsInfo(scss=True, category='table_body', type='px', value='1px'), table_body_hlines_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), table_body_vlines_style=OptionsInfo(scss=True, category='table_body', type='value', value='none'), table_body_vlines_width=OptionsInfo(scss=True, category='table_body', type='px', value='1px'), table_body_vlines_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), table_body_border_top_style=OptionsInfo(scss=True, category='table_body', type='value', value='solid'), table_body_border_top_width=OptionsInfo(scss=True, category='table_body', type='px', value='2px'), table_body_border_top_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), table_body_border_bottom_style=OptionsInfo(scss=True, category='table_body', type='value', value='solid'), table_body_border_bottom_width=OptionsInfo(scss=True, category='table_body', type='px', value='2px'), table_body_border_bottom_color=OptionsInfo(scss=True, category='table_body', type='value', value='#D3D3D3'), data_row_padding=OptionsInfo(scss=True, category='data_row', type='px', value='8px'), data_row_padding_horizontal=OptionsInfo(scss=True, category='data_row', type='px', value='5px'), stub_background_color=OptionsInfo(scss=True, category='stub', type='value', value=None), stub_font_size=OptionsInfo(scss=True, category='stub', type='px', value='100%'), stub_font_weight=OptionsInfo(scss=True, category='stub', type='value', value='initial'), stub_text_transform=OptionsInfo(scss=True, category='stub', type='value', value='inherit'), stub_border_style=OptionsInfo(scss=True, category='stub', type='value', value='solid'), stub_border_width=OptionsInfo(scss=True, category='stub', type='px', value='2px'), stub_border_color=OptionsInfo(scss=True, category='stub', type='value', value='#D3D3D3'), stub_row_group_background_color=OptionsInfo(scss=True, category='stub', type='value', value=None), stub_row_group_font_size=OptionsInfo(scss=True, category='stub', type='px', value='100%'), stub_row_group_font_weight=OptionsInfo(scss=True, category='stub', type='value', value='initial'), stub_row_group_text_transform=OptionsInfo(scss=True, category='stub', type='value', value='inherit'), stub_row_group_border_style=OptionsInfo(scss=True, category='stub', type='value', value='solid'), stub_row_group_border_width=OptionsInfo(scss=True, category='stub', type='px', value='2px'), stub_row_group_border_color=OptionsInfo(scss=True, category='stub', type='value', value='#D3D3D3'), source_notes_padding=OptionsInfo(scss=True, category='source_notes', type='px', value='4px'), source_notes_padding_horizontal=OptionsInfo(scss=True, category='source_notes', type='px', value='5px'), source_notes_background_color=OptionsInfo(scss=True, category='source_notes', type='value', value=None), source_notes_font_size=OptionsInfo(scss=True, category='source_notes', type='px', value='90%'), source_notes_border_bottom_style=OptionsInfo(scss=True, category='source_notes', type='value', value='none'), source_notes_border_bottom_width=OptionsInfo(scss=True, category='source_notes', type='px', value='2px'), source_notes_border_bottom_color=OptionsInfo(scss=True, category='source_notes', type='value', value='#D3D3D3'), source_notes_border_lr_style=OptionsInfo(scss=True, category='source_notes', type='value', value='none'), source_notes_border_lr_width=OptionsInfo(scss=True, category='source_notes', type='px', value='2px'), source_notes_border_lr_color=OptionsInfo(scss=True, category='source_notes', type='value', value='#D3D3D3'), source_notes_multiline=OptionsInfo(scss=False, category='source_notes', type='boolean', value=True), source_notes_sep=OptionsInfo(scss=False, category='source_notes', type='value', value=' '), row_striping_background_color=OptionsInfo(scss=True, category='row', type='value', value='rgba(128,128,128,0.05)'), row_striping_include_stub=OptionsInfo(scss=False, category='row', type='boolean', value=False), row_striping_include_table_body=OptionsInfo(scss=False, category='row', type='boolean', value=False), container_width=OptionsInfo(scss=False, category='container', type='px', value='auto'), container_height=OptionsInfo(scss=False, category='container', type='px', value='auto'), container_padding_x=OptionsInfo(scss=False, category='container', type='px', value='0px'), container_padding_y=OptionsInfo(scss=False, category='container', type='px', value='10px'), container_overflow_x=OptionsInfo(scss=False, category='container', type='overflow', value='auto'), container_overflow_y=OptionsInfo(scss=False, category='container', type='overflow', value='auto'), quarto_disable_processing=OptionsInfo(scss=False, category='quarto', type='logical', value=False), quarto_use_bootstrap=OptionsInfo(scss=False, category='quarto', type='logical', value=False)), _has_built=False)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(GT(pl_data.tail(max_samples * 4))\n", + " .tab_header(\"Comparing our different prompts' outputs\")\n", + " .tab_spanner(label=\"Samples\", columns=cs.starts_with(\"arc\"))\n", + " .tab_stub(rowname_col=\"Type\", groupname_col=\"Sample\")\n", + " .fmt_markdown(columns=cs.starts_with(\"arc\"))\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "07a8d041", + "metadata": {}, + "source": [ + "Lorsque l'on examine les log-vraisemblances des gĂ©nĂ©rations, ce qui semble curieusement fonctionner le mieux pour ce modĂšle est le fait de ne pas avoir indiquĂ© d'exemples dans l'instruction, dans un mĂ©canisme opposĂ© Ă  celui des Ă©valuations de gĂ©nĂ©rations." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pages/0_GLOSSAIRE.py b/pages/0_GLOSSAIRE.py new file mode 100644 index 0000000000000000000000000000000000000000..4901c59e6a299a55bea6f9486641e6c7301ccd13 --- /dev/null +++ b/pages/0_GLOSSAIRE.py @@ -0,0 +1,41 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown("""## Glossaire""") +st.markdown(""" """) + +st.success(""" +Vous trouverez sur cette page les choix de traductions effectuĂ©s. + +Nous nous sommes notamment basĂ©s sur le « [Vocabulaire de l’intelligence artificielle](https://www.education.gouv.fr/bo/2024/Hebdo36/CTNR2423171K) » paru au Bulletin officiel. + +Dans le cas oĂč nous devions utiliser des termes qui n'ont pas encore de traduction officielle, vous pouvez vous rĂ©fĂ©rer au tableau ci-dessous.""") +st.markdown(""" """) +st.markdown(""" """) + +st.markdown( + """| Original | Français | Note | +|-----------------------------|--------------------------------- | --------------------------------- +| Accuracy | *Accuracy* | Pour ne pas confondre avec la prĂ©cision qui se rĂ©fĂšre Ă  une autre mĂ©trique en français. | +| Benchmark | Jeu d'Ă©valuation | Wikipedia utilise « test de performance » comme traduction, qui ne nous semble pas adapter au contexte du traitement du langage naturel.| +| Fine-tuning | *Finetuning* | Les mots d'origine anglaise contenant un tiret ne le conservent pas en français.| +| LLM-as-a-judge | ModĂšle juge | En pratique, on emploie simplement le mot « juge » car dans le cadre de ce guide, on ne se rĂ©fĂšre qu'Ă  des modĂšles, ce qui reviendrait alors Ă  un plĂ©onasme. | +| Prompt | Instruction | Nous reprenons ici le terme indiquĂ© dans le vocabulaire. | +| Token | *Token* | Le vocabulaire met en avant le terme de « jeton textuel ».
Clémentine ayant une préférence pour « sous-unité de mot ».
Notre choix s'est fait au cas par cas en utilisant le terme alourdissant le moins la phrase.| +| Tokenizer | Tokeniseur ou *Tokenizer* | L'expression « programme de dĂ©coupage de texte » alourdie la traduction. | +""", unsafe_allow_html=True) +st.markdown(""" """) + +st.markdown("""A noter que les mots anglais non traduits sont indiquĂ©s en italique.""", unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Commencer la lecture du guide", use_container_width=True): + switch_page("I._CONNAISSANCES GÉNÉRALES") \ No newline at end of file diff --git a/pages/10_III.1._Bases.py b/pages/10_III.1._Bases.py new file mode 100644 index 0000000000000000000000000000000000000000..81899ed6e6010a0cf520fecaf9d6f1ab69e33a33 --- /dev/null +++ b/pages/10_III.1._Bases.py @@ -0,0 +1,103 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown( + """ + ## Bases + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Qu'est-ce que l'Ă©valuation humaine ? +L'Ă©valuation humaine consiste simplement Ă  demander Ă  des humains d'Ă©valuer des modĂšles. +Dans cette page, nous nous intĂ©resserons Ă  l'Ă©valuation post-hoc. C'est-Ă -dire votre modĂšle a Ă©tĂ© entraĂźnĂ©, vous avez une tĂąche donnĂ©e Ă  l'esprit et des humains fournissent des scores. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Évaluation systĂ©matique +Il existe trois façons principales de procĂ©der de maniĂšre systĂ©matique. + +Si **vous ne disposez pas d'un jeu de donnĂ©es**, mais que vous souhaitez explorer un ensemble de capacitĂ©s, vous fournissez aux humains une tĂąche et un guide de notation (par exemple : « Essayez de faire en sorte que ces deux modĂšles produisent un langage toxique ; un modĂšle obtient 0 s'il est toxique, 1 s'il ne l'est pas »), et l'accĂšs Ă  un (ou plusieurs) modĂšle(s) avec lesquels ils peuvent interagir, puis vous leur demandez de fournir leurs notes et leur raisonnement. + +Si **vous avez dĂ©jĂ  un jeu de donnĂ©es** (par exemple : un ensemble d'instructions auquel vous voulez vous assurer que votre modĂšle ne rĂ©pondra pas), vous demandez Ă  votre modĂšle de rĂ©pondre, et vous fournissez l'instruction, la sortie et les directives de notation aux humains (le modĂšle obtient 0 s'il rĂ©pond avec des informations privĂ©es, 1 sinon). + +Enfin, si **vous avez dĂ©jĂ  un jeu de donnĂ©es et des scores**, vous pouvez demander aux humains d'examiner votre mĂ©thode d'Ă©valuation en [annotant les erreurs](https://ehudreiter.com/2022/06/01/error-annotations-to-evaluate/). Cela peut Ă©galement ĂȘtre utilisĂ© comme un systĂšme de notation dans la catĂ©gorie ci-dessus.
Il s'agit d'une Ă©tape trĂšs importante pour tester un nouveau systĂšme d'Ă©valuation, mais elle relĂšve techniquement de l'Ă©valuation d'une Ă©valuation, c'est pourquoi elle est lĂ©gĂšrement hors sujet ici. + """, unsafe_allow_html=True) + +st.info(""" +- Pour l'Ă©valuation des modĂšles de production dĂ©jĂ  dĂ©ployĂ©s, vous pouvez Ă©galement demander l'avis des utilisateurs et procĂ©der Ă  des [tests A/B](https://fr.wikipedia.org/wiki/Test_A/B). +- Les [audits](https://arxiv.org/abs/2401.14462) (Ă©valuation systĂ©matique externe des modĂšles) sont gĂ©nĂ©ralement rĂ©alisĂ©s par des humains mais n'entrent pas dans le cadre de ce guide. + """) +st.markdown(""" """) +st.markdown(""" +##### Évaluation occasionnelle +Il existe deux autres approches pour rĂ©aliser une Ă©valuation humaine d'une maniĂšre plus occasionnelle. + +Les ***vibes-checks*** sont des Ă©valuations manuelles effectuĂ©es par des particuliers, gĂ©nĂ©ralement sur la base d'instructions non divulguĂ©es, afin de se faire une idĂ©e gĂ©nĂ©rale des performances des modĂšles dans de nombreux cas d'utilisation (codage, toxicitĂ©, etc.). Souvent partagĂ©s sur Twitter et Reddit, les rĂ©sultats constituent principalement des preuves isolĂ©es et ont tendance Ă  ĂȘtre trĂšs sensibles au biais de confirmation (en d'autres termes, les gens ont tendance Ă  trouver ce qu'ils cherchent). Toutefois, ils peuvent constituer [un bon point de dĂ©part pour vos propres cas d'utilisation](https://olshansky.substack.com/p/vibe-checks-are-all-you-need). + +Les **arĂšnes** sont des Ă©valuations humaines massives afin de classer les modĂšles. +Un exemple bien connu est le [*LMSYS chatbot arena*](https://huggingface.co/spaces/lmsys/chatbot-arena-leaderboard), oĂč des utilisateurs sont invitĂ©s Ă  Ă©changer avec des modĂšles en indiquant lequel il trouve meilleur par rapport Ă  un autre. Les votes sont ensuite agrĂ©gĂ©s dans un [classement Elo](https://fr.wikipedia.org/wiki/Classement_Elo) pour sĂ©lectionner le « meilleur » modĂšle. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Avantages et inconvĂ©nients de l'Ă©valuation humaine + +##### GĂ©nĂ©ralitĂ©s + +L'Ă©valuation humaine prĂ©sente plusieurs avantages intĂ©ressants ➕ : +- **FlexibilitĂ©**
Si vous définissez assez clairement ce que vous évaluez, vous pouvez obtenir des scores pour à peu prÚs n'importe quoi ! +- **Absence de contamination**
Si vous demandez Ă  des humains d'Ă©crire de nouvelles questions pour tester votre systĂšme, elles ne devraient pas ĂȘtre prĂ©sentes dans vos donnĂ©es d'entraĂźnement (si tout va bien). +- **CorrĂ©lation avec les prĂ©fĂ©rences humaines**
Celle-ci est assez Ă©vidente, puisque c'est ce que vous utilisez pour noter. NĂ©anmoins, vous devez vous assurer que les profils des annotateurs sont suffisamment diversifiĂ©s pour que vos rĂ©sultats se gĂ©nĂ©ralisent. + +Cependant, elle prĂ©sente Ă©galement un certain nombre de limites ➖ : +- **Biais de primautĂ©**
Les évaluateurs humains ont tendance à estimer la qualité des réponses [sur la base des premiÚres impressions](https://arxiv.org/abs/2309.16349), plutÎt que la réalité ou la fidélité. +- **Biais de tonalité**
Les annotateurs via *crowdsourcing* sont notamment trĂšs sensibles au ton d'un texte et sous-estiment le nombre d'erreurs factuelles ou logiques dans une rĂ©ponse affirmative. En d'autres termes, si un modĂšle dit des choses erronĂ©es sur un ton assurĂ©, les Ă©valuateurs humains sont beaucoup moins susceptibles de le remarquer, ce qui pourrait fausser les Ă©valuations en faveur des modĂšles les plus affirmatifs. Les annotateurs experts sont moins susceptibles d'ĂȘtre victimes de ces biais. +- **Biais d'auto-prĂ©fĂ©rence**
Les humains sont [plus susceptibles de préférer les réponses qui correspondent à leurs opinions ou à leurs erreurs](https://arxiv.org/abs/2310.13548), plutÎt que les réponses qui sont correctes sur le plan factuel. +- **Biais d'identité**
Les personnes ayant diffĂ©rentes identitĂ©s ont tendance Ă  avoir des valeurs diffĂ©rentes et Ă©valuent les rĂ©ponses des modĂšles trĂšs diffĂ©remment des autres annotateurs (par exemple sur la [toxicitĂ©](https://arxiv.org/abs/2205.00501)). +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Évaluation systĂ©matique +Avantages de cette approche (en particulier avec des annotateurs rĂ©munĂ©rĂ©s) ➕ : +- **L'obtention de donnĂ©es de haute qualitĂ©**
Adaptées à votre cas d'utilisation, sur lesquelles vous pourrez vous appuyer ultérieurement (si vous avez besoin de développer des modÚles de préférence, par exemple). +- **Confidentialité des données**
Si vous comptez sur des annotateurs humains rĂ©munĂ©rĂ©s, en particulier en interne, vos jeux de donnĂ©es devraient ĂȘtre relativement sĂ»rs. L'utilisation de LLM d'API fermĂ©e pour l'Ă©valuation prĂ©sente moins de garanties sur ce qui arrive Ă  vos donnĂ©es, puisque vous les envoyez Ă  un service externe. +- **ExplicabilitĂ©**
Les scores obtenus par les modĂšles seront explicables par les humains qui les ont annotĂ©s. + +Les inconvĂ©nients ➖ : +- **CoĂ»t**
Si vous payez correctement vos annotateurs, cela peut vite devenir coûteux. +Il est également probable que vous ayez besoin de séries d'évaluations itératives afin d'affiner vos lignes directrices, ce qui augmente le coût. +- **L'impossibilité de passer à l'échelle**
À moins que vous n'Ă©valuiez un systĂšme similaire Ă  un en production avec un retour d'information de la part des utilisateurs, les Ă©valuations humaines ne sont pas vraiment Ă©volutives, car chaque nouveau cycle nĂ©cessite de mobiliser de nouveaux Ă©valuateurs (et de les payer). +- **Manque de reproductibilitĂ©**
À moins que vous ne gardiez toujours les mĂȘmes annotateurs et que vos directives soient parfaitement claires, il est probable que certaines Ă©valuations soient difficiles Ă  reproduire avec prĂ©cision. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Évaluation occasionnelle +Avantages ➕ : +- **CoĂ»t moindre**
Vous comptez sur la bonne volonté des gens. +- **Découverte de cas limites**
Puisque vous tirez parti de la créativité des utilisateurs d'une maniÚre pratiquement illimitée, vous pouvez découvrir des cas limites intéressants. +- **Meilleure évolutivité**
Tant que vous avez de nombreux participants intĂ©ressĂ©s et volontaires, l'Ă©valuation humaine occasionnelle s'adapte mieux et a un coĂ»t d'entrĂ©e plus faible. + +Les inconvĂ©nients (sans sĂ©lection d'annotateur) ➖ : +- **Forte subjectivitĂ©**
Il est difficile d'imposer une notation cohĂ©rente Ă  de nombreux personnes en utilisant des directives gĂ©nĂ©rales, d'autant plus que les prĂ©fĂ©rences des annotateurs ont tendance Ă  ĂȘtre [liĂ©es Ă  leur culture](https://arxiv.org/abs/2404.16019v1). On peut espĂ©rer que cet effet soit attĂ©nuĂ© par l'ampleur des votes et un effet de « [sagesse de la foule](https://fr.wikipedia.org/wiki/Francis_Galton) ». +- **Non reprĂ©sentativitĂ©**
Les jeunes hommes occidentaux étant surreprésentés sur les sites technologiques, cela peut conduire à des préférences trÚs biaisées, ne correspondant pas à celles de la population générale, à la fois en termes de sujets explorés et de classement général. +- **Facile à manipuler**
Si vous utilisez des annotateurs participatifs non filtrĂ©s, il est assez facile pour un tiers de manipuler votre Ă©valuation. Par exemple pour augmenter le score d'un modĂšle donnĂ© (Ă©tant donnĂ© qu'un certain nombre de modĂšles ont un style d'Ă©criture distinctif). + """, unsafe_allow_html=True) + + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("III._Évaluation_humaine") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("III.2._Utiliser_des_annotateurs_humains") \ No newline at end of file diff --git a/pages/11_III.2._Utiliser_des_annotateurs_humains.py b/pages/11_III.2._Utiliser_des_annotateurs_humains.py new file mode 100644 index 0000000000000000000000000000000000000000..e508e8a7bc7c0eaaa3f3a52d0d96bbc8fc16570a --- /dev/null +++ b/pages/11_III.2._Utiliser_des_annotateurs_humains.py @@ -0,0 +1,70 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown( + """## Utiliser des annotateurs humains +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown( + """ +Je suggĂšre de lire la section 3 de cette [revue de littĂ©rature](https://aclanthology.org/2024.cl-3.1/) sur les bonnes pratiques pour annoter des donnĂ©es qualitativement. Si vous voulez une qualitĂ© de niveau production et que vous avez les moyens de mettre en Ɠuvre toutes ces mĂ©thodes, foncez !""", unsafe_allow_html=True) +st.markdown(""" """) + +st.image("./assets/best_annotation_practices.png", use_container_width=True) +st.markdown(""" """) + +st.markdown( + """ +Une fois que vous avez dĂ©fini votre tĂąche et les lignes directrices pour la notation, les recommandations importantes (quelle que soit la taille de votre projet) sont les suivantes : + +- **SĂ©lection des annotateurs et, si possible, incitations monĂ©taires** +Il est probable que vous souhaitiez que les personnes travaillant sur votre tĂąche : + 1) possĂšdent certaines caractĂ©ristiques socio-dĂ©mographiques.
+ Quelques exemples : ĂȘtre un locuteur natif de la langue cible, avoir un certain niveau d'Ă©ducation, ĂȘtre expert dans un domaine spĂ©cifique, avoir des origines gĂ©ographiques diverses, etc.
+ Vos besoins varient en fonction de votre tĂąche.
+ 2) produisent un travail de haute qualité.
+ Il est particuliÚrement important d'ajouter un moyen de vérifier si les réponses sont générées par LLM, et vous aurez besoin de filtrer certains annotateurs de votre groupe. +""", unsafe_allow_html=True) +st.info("""Selon moi, à moins que vous ne comptiez sur des annotateurs bénévoles trÚs motivés, il est toujours préférable de payer correctement vos annotateurs.""") +st.markdown(""" +- **Conception des directives d'annotation**
+Veillez à consacrer beaucoup de temps à l'élaboration de vos consignes d'annotation ! C'est l'un des points sur lesquels nous avons passé le plus de temps pour le jeu de données [GAIA](https://huggingface.co/gaia-benchmark). + +- **Itérer**
+Préparez-vous à essuyer plusieurs séries d'annotations car vos annotateurs comprendront mal vos instructions (elles sont plus ambiguës que vous ne le pensez) ! Générer des échantillons plusieurs fois permettra à vos annotateurs de vraiment converger vers ce dont vous avez besoin. + +- **Estimation de la qualité** et **nettoyage manuel**
+Vous souhaitez contrÎler les réponses (en particulier par le biais d'un accord inter-annotateurs si vous pouvez) et effectuer une sélection finale pour ne conserver que les réponses les plus pertinentes et de la plus haute qualité. + +Des outils spécialisés pour construire des jeux de données annotés de haute qualité comme [Argilla](https://argilla.io/) peuvent vous aider. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown( + """ + ### Aller plus loin +- ⭐ [Comment configurer votre propre plateforme d'annotateurs en quelques minutes](https://huggingface.co/learn/cookbook/enterprise_cookbook_argilla) par Moritz Laurer.
Une bonne lecture pour acquérir une expérience pratique de l'utilisation d'outils open source (comme Argilla et Hugging Face), et mieux comprendre les choses à faire et à ne pas faire en matiÚre d'annotation humaine massive. +- ⭐ [Un guide sur les bonnes pratiques en matiÚre d'annotation](https://aclanthology.org/2024.cl-3.1/).
+Il s'agit d'une revue de littérature de tous les articles sur l'annotation humaine datant de 2023 qui est trÚs complÚte. LégÚrement dense mais facilement compréhensible. +- [Un autre guide sur les bonnes pratiques en matiÚre d'annotation](https://scale.com/guides/data-labeling-annotation-guide) par ScaleAI.
Entreprise spécialisée dans les évaluations humaines. Il s'agit d'un complément plus léger au lien précédent. +- [*Assumptions and Challenges of Capturing Human Labels*](https://aclanthology.org/2024.naacl-long.126/)
+Papier sur la façon d'examiner les sources de désaccord entre les annotateurs et de les atténuer dans la pratique. +""", unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section précédente', use_container_width=True): + switch_page("III.1._Bases") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("III.3._Conseils_et_astuces") \ No newline at end of file diff --git a/pages/12_III.3._Conseils_et_astuces.py b/pages/12_III.3._Conseils_et_astuces.py new file mode 100644 index 0000000000000000000000000000000000000000..a712899cfd8ef01024e202b8d389dadbca9fdd80 --- /dev/null +++ b/pages/12_III.3._Conseils_et_astuces.py @@ -0,0 +1,73 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown( + """ +## Conseils et astuces + +Voici quelques conseils pratiques à prendre en compte lorsque vous recourez à des annotateurs humains pour constituer un jeu de données d'évaluation. Si vous ne l'avez pas encore fait, nous vous recommandons de lire d'abord la page Utiliser des annotateurs humains avant de commencer celle-ci. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown( + """ +### Concevoir la tùche + +- **Privilégier la simplicité**
Les tùches d'annotation peuvent devenir inutilement complexes, il faut donc les simplifier au maximum. En réduisant au minimum la charge cognitive des annotateurs, vous vous assurez qu'ils restent concentrés et qu'ils produisent des annotations de meilleure qualité. + +- **Vérifiez ce que vous montrez**
Ne montrez que les informations nécessaires aux annotateurs pour accomplir la tùche et veillez à ne rien inclure qui puisse introduire un biais supplémentaire. + +- **Tenez compte du temps de vos annotateurs**
L'emplacement et la maniĂšre dont les choses sont affichĂ©es peuvent entraĂźner un surcroĂźt de travail ou une charge cognitive supplĂ©mentaire et, par consĂ©quent, avoir un impact nĂ©gatif sur la qualitĂ© des rĂ©sultats. Par exemple, veillez Ă  ce que les textes et la tĂąche soient visibles ensemble et Ă©vitez tout dĂ©filement inutile. Si vous combinez des tĂąches et que le rĂ©sultat de l'une informe l'autre, vous pouvez les afficher de maniĂšre sĂ©quentielle. RĂ©flĂ©chissez Ă  la maniĂšre dont tout est affichĂ© dans votre outil d'annotation et voyez s'il n'y a pas moyen de simplifier encore plus. + +- **Testez vous-mĂȘme la configuration**
Une fois que vous avez conçu votre tĂąche et mis en place certaines consignes, veillez Ă  la tester vous-mĂȘme sur quelques Ă©chantillons avant d'impliquer l'ensemble de l'Ă©quipe, et procĂ©dez Ă  des itĂ©rations si nĂ©cessaire. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown( + """ +### Durant l'annotation + +- **Les annotateurs doivent travailler de maniĂšre indĂ©pendante**
Il est préférable que les annotateurs ne s'entraident pas et ne voient pas le travail des autres pendant la tùche car pourraient propager leurs propres préjugés et provoquer une dérive des annotations. L'alignement doit toujours se faire par le biais de consignes détaillées. Vous pouvez former les nouveaux membres de l'équipe sur un jeu de données distinct et/ou utiliser des mesures d'accord inter-annotateurs pour vous assurer que l'équipe est alignée. + +- **La cohérence est essentielle**
Si vous apportez des modifications importantes à vos consignes (par exemple, modification d'une définition ou d'une instruction, ou ajout/suppression d'étiquettes), vous devez vous demander si vous avez besoin d'itérer sur les données annotées. Au moins, vous devriez traquer les changements dans votre jeu de données par le biais d'une valeur de métadonnées telle que `guidelines-v1`. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown( + """ +### Annotation hybride homme-machine + +Parfois, les équipes sont confrontées à des contraintes de temps et de ressources mais ne veulent pas sacrifier les avantages de l'évaluation humaine. Dans ce cas, vous pouvez utiliser l'aide de modÚles pour rendre la tùche plus efficace. + +- **Annotation assistée par modÚle**
Vous pouvez utiliser les prédictions ou les générations d'un modÚle comme pré-annotations, de sorte que l'équipe d'annotation n'ait pas à repartir de zéro. Notez simplement que cela peut introduire les biais du modÚle dans les annotations humaines, et que si la qualité du modÚle est faible, cela peut augmenter la charge de travail des annotateurs. + +- **Superviser le modÚle comme un juge**
Vous pouvez combiner la puissance de la méthodologie du *LLM-as-a-judge* (voir le chapitre dédié) et les superviseurs humains pour valider ou rejeter les résultats. Notez que les biais discutés dans la partie « Avantages et inconvénients de l'évaluation humaine » abordés dans la page Bases s'appliquent ici. + +- **Identifier les cas limites**
Pour une tĂąche encore plus rapide, utilisez un jury de modĂšles et demandez Ă  votre (vos) superviseur(s) humain(s) d'intervenir en cas de dĂ©saccord entre les modĂšles ou d'Ă©galitĂ© Ă  dĂ©partager. LĂ  encore, il faut tenir compte des biais Ă©voquĂ©s dans « Avantages et inconvĂ©nients de l'Ă©valuation humaine ». + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown( + """ +### Tutoriel complet + +Pour construire votre propre systĂšme d'Ă©valuation personnalisĂ© en suivant ces conseils, vous pouvez suivre ce [tutoriel](https://github.com/argilla-io/argilla-cookbook/tree/main/domain-eval) d'[Argilla](https://github.com/argilla-io/argilla/). Il vous guide dans la construction d'une tĂąche d'Ă©valuation personnalisĂ©e pour votre domaine, en utilisant des donnĂ©es synthĂ©tiques (via [distilabel](https://github.com/argilla-io/distilabel)) et une Ă©valuation manuelle. Le guide part des documents du domaine et aboutit Ă  une tĂąche d'Ă©valuation personnalisĂ©e que vous pouvez utiliser pour Ă©valuer votre modĂšle avec [lighteval](https://github.com/huggingface/lighteval). + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("III.2._Utiliser_des_annotateurs_humains") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Chapitre suivant", use_container_width=True): + switch_page("IV._LLM_AS_A_JUDGE") \ No newline at end of file diff --git a/pages/13_IV._LLM_AS_A_JUDGE.py b/pages/13_IV._LLM_AS_A_JUDGE.py new file mode 100644 index 0000000000000000000000000000000000000000..10a0d5af31b748d58965c161e4ca5343ae73b991 --- /dev/null +++ b/pages/13_IV._LLM_AS_A_JUDGE.py @@ -0,0 +1,25 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown("""## *LLM-as-a-judge*""") +st.markdown(""" """) + +st.markdown(""" +Dans ce chapitre, nous dĂ©finissons ce qu'est un [*LLM-as-a-judge*](https://arxiv.org/abs/2411.15594) (on utilisera simplement le mot « juge » dans la suite). Notamment comment le choisir (un existant ou Ă  concevoir soi-mĂȘme), comment concevoir une bonne instruction pour l'utiliser, et l'Ă©valuer. Nous abordons Ă©galement les modĂšles de rĂ©compense. Nous terminons par des conseils et astuces utiles Ă  connaĂźtre sur ce sujet.""") + + + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("III.3._Conseils_et_astuces") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("IV.1._Bases") \ No newline at end of file diff --git a/pages/14_IV.1._Bases.py b/pages/14_IV.1._Bases.py new file mode 100644 index 0000000000000000000000000000000000000000..8611fb8aae89e9f34f3773d1841d1b815d7053df --- /dev/null +++ b/pages/14_IV.1._Bases.py @@ -0,0 +1,72 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown( + """ + ## Bases + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Qu'est-ce que l'Ă©valuation par un modĂšle juge ? + +Les modĂšles juges sont simplement des **rĂ©seaux de neurones utilisĂ©s pour Ă©valuer la sortie d'autres rĂ©seaux de neurones**. Dans la plupart des cas, ils Ă©valuent de la gĂ©nĂ©ration de textes. + +Ces juges vont des petits classifieurs spĂ©cialisĂ©s (pensez par exemple Ă  un filtre anti-spam mais pour de la toxicitĂ©) Ă  des modĂšles de langages, soit grands et gĂ©nĂ©ralistes, soit petits et spĂ©cialisĂ©s. Lorsque vous en utilisez un, vous lui donnez une instruction pour lui expliquer comment noter les modĂšles (ex : « Note la fluiditĂ© de 0 Ă  5, 0 Ă©tant complĂštement incomprĂ©hensible, ... »). + +Ces modĂšles permettent de noter les textes sur des propriĂ©tĂ©s complexes et nuancĂ©es. +Par exemple, une [correspondance exacte](https://huggingface.co/spaces/evaluate-metric/exact_match) entre une prĂ©diction et une rĂ©fĂ©rence peut vous permettre de tester si un modĂšle a prĂ©dit le bon fait ou le bon chiffre, mais l'Ă©valuation de capacitĂ©s empiriques plus ouvertes (comme la fluiditĂ©, la qualitĂ© de la poĂ©sie ou la fidĂ©litĂ© Ă  une entrĂ©e) nĂ©cessite des Ă©valuateurs plus complexes. + +C'est lĂ  que les [*LLM-as-a-judge*](https://arxiv.org/abs/2411.15594) entrent en jeu. + +Ils sont utilisĂ©s pour trois tĂąches principales : +- *Notation d'une gĂ©nĂ©ration*, sur une Ă©chelle fournie, pour Ă©valuer une propriĂ©tĂ© du texte (fluiditĂ©, toxicitĂ©, cohĂ©rence, persuasion, etc.). +- *Notation par paires* : comparaison d'une paire de sorties de modĂšle pour choisir le meilleur texte en fonction d'une propriĂ©tĂ© donnĂ©e. +- *Calcul de la similaritĂ©* entre une sortie de modĂšle et une rĂ©fĂ©rence. + """, unsafe_allow_html=True) + +st.info( + """ + Dans ce guide, nous nous concentrons sur l'approche LLM + instruction pour le moment. Vous devriez nĂ©anmoins jeter un Ɠil Ă  comment fonctionnent les juges de type classifieurs car ils peuvent ĂȘtre assez robustes et bien adaptĂ©s Ă  un certain nombre de cas d'utilisation. De mĂȘme les modĂšles de rĂ©compense sont prometteurs comme alternative comme juge (cf. [ce rapport technique](https://research.nvidia.com/publication/2024-06_nemotron-4-340b) que nous dĂ©taillons dans la section « ModĂšles de rĂ©compense »). + """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown( + """ +### Avantages et inconvĂ©nients de l'utilisation de modĂšles en tant que juges + +Les juges sont utilisĂ©s pour les avantages suivants ➕ : +- **Échelle et reproductibilitĂ©**
Ils sont plus évolutifs que les annotateurs humains, ce qui permet de reproduire l'évaluation sur de grandes quantités de données. +- **Coût**
Ils sont peu coûteux à mettre en place, car ils ne nécessitent pas d'entraßner un nouveau modÚle. Ils s'appuyent sur une bonne instruction et un bon LLM existant. Ils sont également moins chers que de payer des annotateurs humains. +- **Alignement avec les jugements humains**
Ils sont en quelque sorte corrĂ©lĂ©s avec les jugements humains. + +Il y a aussi des inconvĂ©nients ➖ : +- Les juges semblent objectifs mais ont de nombreux **biais cachĂ©s** qui peuvent ĂȘtre plus difficiles Ă  dĂ©tecter que ceux des humains puisque nous ne les recherchons pas aussi activement (voir la section « Conseils et astuces »). En outre, il existe des moyens de rĂ©duire les biais humains en concevant des questions de maniĂšre spĂ©cifique et statistiquement robuste (ce qui a Ă©tĂ© Ă©tudiĂ© en sociologie depuis environ un siĂšcle), alors que les instructions pour les LLM ne sont pas encore aussi robustes. L'utilisation de LLM pour Ă©valuer d'autres LLM a Ă©tĂ© comparĂ©e Ă  la crĂ©ation d'une chambre d'Ă©cho, renforçant subtilement les biais humains. +- Ils sont en effet Ă©volutifs, mais contribuent Ă  crĂ©er des quantitĂ©s massives de donnĂ©es qui doivent elles-mĂȘmes ĂȘtre examinĂ©es pour garantir leur qualitĂ© (par exemple, vous pouvez amĂ©liorer la qualitĂ© des juges en leur demandant de dĂ©tailler leur gĂ©nĂ©ration ou de raisonner autour de leurs donnĂ©es, ce qui crĂ©e encore plus de nouvelles donnĂ©es artificielles Ă  analyser). +- Ils sont en effet peu coĂ»teux Ă  mettre en place, mais le fait de payer des annotateurs humains experts est susceptible de vous donner des rĂ©sultats qualitativement meilleurs pour vos cas d'utilisation spĂ©cifiques. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown( + """### Comment commencer ? + +Si vous voulez essayer, je vous suggĂšre d'abord de lire ce [trĂšs bon guide](https://huggingface.co/learn/cookbook/fr/llm_judge) (en français) (⭐) d'Aymeric Roucher sur la façon de configurer votre premier juge ! +Vous pouvez Ă©galement essayer la bibliothĂšque [distilabel](https://distilabel.argilla.io/latest/), qui vous permet de gĂ©nĂ©rer des donnĂ©es synthĂ©tiques et de les mettre Ă  jour Ă  l'aide de LLM. Ils ont un [tutoriel](https://distilabel.argilla.io/latest/sections/pipeline_samples/papers/ultrafeedback/) intĂ©ressant qui applique la mĂ©thodologie du [papier Ultrafeedback](https://arxiv.org/abs/2310.01377) ainsi qu'un [tutoriel sur les jeux d'Ă©valuations](https://distilabel.argilla.io/latest/sections/pipeline_samples/examples/benchmarking_with_distilabel/) utilisant le jeu *Arena Hard*. + """, unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("IV._LLM_AS_A_JUDGE") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("IV.2._DĂ©finir_son_juge") \ No newline at end of file diff --git "a/pages/15_IV.2._D\303\251finir_son_juge.py" "b/pages/15_IV.2._D\303\251finir_son_juge.py" new file mode 100644 index 0000000000000000000000000000000000000000..d62757f1217e01f4b6a107255c73e81a21e57339 --- /dev/null +++ "b/pages/15_IV.2._D\303\251finir_son_juge.py" @@ -0,0 +1,70 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown(""" +## DĂ©finir son juge + +Lorsque vous utilisez un juge, vous pouvez opter pour [des modĂšles gĂ©nĂ©ralistes trĂšs performants](https://arxiv.org/abs/2306.05685v4), utiliser [de « petits » modĂšles spĂ©cialisĂ©s](https://arxiv.org/abs/2405.01535) entraĂźnĂ©s spĂ©cifiquement pour discriminer les donnĂ©es de prĂ©fĂ©rence, ou entraĂźner votre propre modĂšle. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Utiliser un LLM gĂ©nĂ©raliste + +Avec l'introduction de LLM plus performants (comme ChatGPT), certains chercheurs ont commencĂ© Ă  explorer l'utilisation de grands modĂšles de langage comme juges. Les meilleurs (au moment de la rĂ©daction de ce guide) ont tendance Ă  ĂȘtre des modĂšles Ă  fermĂ©s tels Claude ou GPT-o. NĂ©anmoins l'Ă©cart avec les modĂšles ouverts se rĂ©duit trĂšs rapidement grĂące Ă  des modĂšles de haute qualitĂ© comme [Qwen 2.5](https://huggingface.co/collections/Qwen/qwen25-66e81a666513e518adb90d9e), [Command R+](https://huggingface.co/CohereForAI/c4ai-command-r-plus-08-2024), [Llama 3.1-405-Instruct](hf.co/meta-llama/Llama-3.1-405B-Instruct) ou [DeepSeek-R1](https://huggingface.co/collections/deepseek-ai/deepseek-r1-678e1e131c0169c0bc89728d). + +Les modĂšles fermĂ©s, malgrĂ© leurs performances, prĂ©sentent les multiples inconvĂ©nients d'ĂȘtre : +- sous API, ce qui signifie que les modĂšles (et donc les rĂ©sultats) peuvent changer sans prĂ©avis, ce qui nuit Ă  la reproductibilitĂ© des Ă©valuations +- des boĂźtes noires, ce qui les rend ininterprĂ©tables +- des sources possibles de fuites/manque de confidentialitĂ© des donnĂ©es car vous envoyez vos donnĂ©es Ă  un tiers ce qui tend Ă  ĂȘtre moins sĂ»r que les donnĂ©es gĂ©rĂ©es localement. Vous ne savez pas avec certitude ce qui en est fait et il faut souvent refuser qu'elles soient utilisĂ©es dans des jeux d'entraĂźnement. + +Cependant, ils permettent Ă©galement Ă  tout un chacun d'avoir accĂšs Ă  un modĂšle de haute qualitĂ© sans avoir besoin de configurer les choses localement ou d'avoir accĂšs Ă  du matĂ©riel. Ces avantages sont dĂ©sormais Ă©galement prĂ©sents pour la plupart des modĂšles ouverts de haute qualitĂ©, qui sont accessibles par l'intermĂ©diaire de fournisseurs de modĂšles, et qui rĂ©solvent les deux premiers problĂšmes ci-dessus. + +Vous trouverez une bonne analyse des coĂ»ts des fournisseurs de modĂšles [ici](https://huggingface.co/spaces/ArtificialAnalysis/LLM-Performance-Leaderboard) si vous avez besoin d'aide pour en choisir un.""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Utiliser un petit modĂšle spĂ©cialisĂ© comme juge + +Vous pouvez Ă©galement choisir de recourir Ă  de « petits » modĂšles spĂ©cialisĂ©s. Avec souvent quelques milliards de paramĂštres, ils peuvent fonctionner localement sur le matĂ©riel grand public le plus rĂ©cent, tout en Ă©tant entraĂźnĂ©s Ă  partir de zĂ©ro ou finetunĂ©s Ă  l'aide de donnĂ©es d'instruction. Vous devez souvent suivre leurs formats d'instruction spĂ©cifiques. + +Quelques modĂšles existants : +- Flow-Judge-v0.1 ([poids](https://huggingface.co/collections/flowaicom/flow-judge-v01-66e6af5fc3b3a128bde07dec)) faisant 3,8 Mds de paramĂštres, un Phi-3.5-mini-instruct finetunĂ© sur un jeu de donnĂ©es de prĂ©fĂ©rences synthĂ©tique. +- Prometheus ([poids](https://huggingface.co/prometheus-eval/prometheus-13b-v1.0), [papier](https://arxiv.org/abs/2310.08491)), 13 Mds de paramĂštres, un modĂšle entraĂźnĂ© Ă  partir de zĂ©ro sur un jeu de donnĂ©es de prĂ©fĂ©rences synthĂ©tique. Il existe Ă©galement un modĂšle [v2](https://huggingface.co/prometheus-eval/prometheus-7b-v2.0) de 7 Mds de paramĂštres qui est un *finetuning* d'un Mistral-7B-Instruct-v0.2 sur un jeu de donnĂ©es de prĂ©fĂ©rences synthĂ©tique plus important, avec une fusion de poids supplĂ©mentaire. +- JudgeLM ([papier](https://arxiv.org/abs/2310.17631)), 7 Ă  33 Mds de paramĂštres, entraĂźnĂ©s Ă  partir de zĂ©ro sur des jeux de donnĂ©es de prĂ©fĂ©rences synthĂ©tique gĂ©nĂ©rĂ©s avec une variĂ©tĂ© de modĂšles. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### EntraĂźner son propre modĂšle +Vous pouvez Ă©galement choisir d'entraĂźner ou de finetuner votre propre juge. + +Vous devez d'abord rassembler des donnĂ©es de prĂ©fĂ©rence pour la tĂąche qui vous intĂ©resse, qui peuvent provenir : +- des [jeux de donnĂ©es de prĂ©fĂ©rences humaines](https://www.kaggle.com/competitions/lmsys-chatbot-arena) dĂ©jĂ  disponibles +- des donnĂ©es de prĂ©fĂ©rence gĂ©nĂ©rĂ©es par un modĂšle (gĂ©nĂ©ration via les petits LLM listĂ©s Ă  l'instant, ou obtenir directement Ă  partir des collections de Prometheus « [preference](https://huggingface.co/datasets/prometheus-eval/Preference-Collection) » et « [feedback](https://huggingface.co/datasets/prometheus-eval/Feedback-Collection) »). + +Ensuite, vous devez dĂ©cider si vous voulez partir d'un modĂšle Ă  entraĂźner de zĂ©ro ou bien d'un modĂšle existant que vous pouvez : +- distiller dans un nouveau modĂšle plus petit, +- quantifier, +- puis finetuner (si besoin Ă  l'aide de mĂ©thodes de [PEFT](https://github.com/huggingface/peft) si le modĂšle est grand et que vos capacitĂ©s de calcul sont faibles) en utilisant les donnĂ©es ci-dessus. +""", unsafe_allow_html=True) +st.info("""Il semblerait que [partir d'un modĂšle de rĂ©compense fonctionne mieux qu'Ă  partir d'un modĂšle d'instruction](https://x.com/dk21/status/1826292289930674590).""") + + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("IV.1._Bases") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("IV.3._Concevoir_votre_instruction_d'Ă©valuation") \ No newline at end of file diff --git "a/pages/16_IV.3._Concevoir_votre_instruction_d'\303\251valuation.py" "b/pages/16_IV.3._Concevoir_votre_instruction_d'\303\251valuation.py" new file mode 100644 index 0000000000000000000000000000000000000000..ee6a79c29d1a798a4a77c7381a4fb0bbce4b5c08 --- /dev/null +++ "b/pages/16_IV.3._Concevoir_votre_instruction_d'\303\251valuation.py" @@ -0,0 +1,66 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown(""" +## Concevoir votre instruction d'Ă©valuation +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +### Conseils gĂ©nĂ©raux pour la conception des instructions + +Voici quelques indications que j'ai trouvĂ©es en ligne concernant la conception de l'instruction elle-mĂȘme : +- Fournir une description claire de la tĂąche Ă  accomplir : + - « Ta tĂąche est de faire X ». + - « On te donnera Y ». +- Fournir des indications claires sur les critĂšres d'Ă©valuation, y compris un systĂšme de notation dĂ©taillĂ© si nĂ©cessaire : + - « Tu dois Ă©valuer la propriĂ©tĂ© Z sur une Ă©chelle de 1 Ă  5, oĂč 1 signifie ... ». + - « Tu dois Ă©valuer si la propriĂ©tĂ© Z est prĂ©sente dans l'Ă©chantillon Y. La propriĂ©tĂ© Z est prĂ©sente si ... ». +- Fournir quelques Ă©tapes supplĂ©mentaires d'Ă©valuation du « raisonnement » : + - « Pour juger cette tĂąche, tu dois d'abord t'assurer de lire attentivement l'Ă©chantillon Y pour identifier ..., puis ... ». +- SpĂ©cifier le format de sortie souhaitĂ© (l'ajout de champs facilitera la cohĂ©rence) + - « Ta rĂ©ponse doit ĂȘtre fournie en JSON, avec le format suivant {"Score" : Ton score, "Reasoning" : Le raisonnement qui t'a conduit Ă  ce score} ». +""", unsafe_allow_html=True) +st.success("""Nous avons traduit les instructions en utilisant le tutoiement. Il n'est pas dit que ce soit la meilleure option pour requĂȘter le modĂšle. Le vouvoiement ou l'impĂ©ratif pourraient ĂȘtre des options plus efficaces. Nous n'avons pas trouvĂ© de publication sur ce sujet permettant de trancher. Nous vous conseillons alors de tester les trois approches.""") +st.markdown(""" +Vous pouvez et devriez vous inspirer des exemples d'instructions de [MixEval](https://github.com/huggingface/lighteval/blob/main/src/lighteval/tasks/extended/mix_eval/judge_prompts.pyy) ou [MTBench](https://github.com/huggingface/lighteval/blob/main/src/lighteval/tasks/extended/mt_bench/judge_prompt_templates.py). + +Autres remarques : +- La comparaison par paire [est mieux corrĂ©lĂ©e avec les prĂ©fĂ©rences humaines](https://arxiv.org/abs/2403.16950) que la notation, et est gĂ©nĂ©ralement plus robuste. +- Si vous voulez vraiment un score, utilisez une Ă©chelle de nombres entiers et assurez-vous de fournir une explication dĂ©taillĂ©e de ce que [chaque score reprĂ©sente](https://x.com/seungonekim/status/1749289437165769177), ou une instruction additive (« attribuer 1 point Ă  cette caractĂ©ristique de la rĂ©ponse, 1 point supplĂ©mentaire si ...», etc.). +- L'utilisation d'une instruction par capacitĂ© Ă  noter tend Ă  donner des rĂ©sultats meilleurs et plus robustes. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### AmĂ©liorer la prĂ©cision du jugement + +Vous pouvez Ă©galement amĂ©liorer la prĂ©cision en utilisant les techniques suivantes, peut-ĂȘtre plus coĂ»teuses : +- **Donner quelques exemples**
Comme dans beaucoup d'autres tùches, si vous donnez des exemples, cela peut aider le processus de raisonnement. Cependant, cela augmente la longueur de votre contexte. +- **Référence**
Vous pouvez aussi ajouter une référence dans votre instruction. +- **CoT (*Chains of Thought*)**
Processus qui [améliore la précision](https://arxiv.org/abs/2212.08073) si vous demandez au modÚle de produire sa chaßne de pensée **avant** le score (aussi observé [ici](https://x.com/seungonekim/status/1749289437165769177)). +- **Analyse multi-tours**
Peut améliorer [la détection des erreurs factuelles](https://arxiv.org/abs/2305.13281). +- **Utiliser un jury**
Plusieurs juges fournissant une réponse agrégée [donne de meilleurs résultats](https://arxiv.org/abs/2404.18796) que l'utilisation d'un seul modÚle. + - Il est possible de réduire considérablement les coûts en utilisant plusieurs petits modÚles au lieu d'un seul grand modÚle coûteux. + - Vous pouvez également expérimenter l'utilisation d'un unique modÚle mais avec des variations de température. +- **Enjeux**
De maniĂšre surprenante, il a Ă©tĂ© constatĂ© que l'ajout d'enjeux dans l'instruction (ex : « Si tu rĂ©ponds correctement, tu obtiendras un chaton ») peut amĂ©liorer l'exactitude des rĂ©ponses. Cette mĂ©thode peut varier, il faut l'adapter Ă  vos besoins. +""", unsafe_allow_html=True) +st.info("""En fonction des enjeux de votre cas d'usage, pour Ă©liminer autant de biais que possible, vous devriez vous pencher sur les travaux rĂ©alisĂ©s en sociologie sur la maniĂšre de concevoir de bonnes enquĂȘtes. Si vous considĂ©rez votre Ă©valuateur comme un remplaçant Ă  un annotateur humain, vous devez alors vous pencher sur des mesures similaires : calcul de l'accord entre les annotateurs, utilisation d'une mĂ©thodologie de conception d'enquĂȘte correcte pour attĂ©nuer les biais, etc.""") +st.markdown(""" +Cependant, la plupart des gens ne souhaitent pas vraiment une Ă©valuation impartiale reproductible et de grande qualitĂ©, et se contenteront d'une Ă©valuation rapide et sale Ă  l'aide d'instructions acceptables. Cela peut ĂȘtre ok, cela dĂ©pend des consĂ©quences qui en dĂ©coulent. +""", unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("IV.2._DĂ©finir_son_juge") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("IV.4._Évaluer votre Ă©valuateur") \ No newline at end of file diff --git "a/pages/16_IV.3._Concevoir_votre_prompt_d'\303\251valuation.py" "b/pages/16_IV.3._Concevoir_votre_prompt_d'\303\251valuation.py" new file mode 100644 index 0000000000000000000000000000000000000000..18ef12ae76c07479840add899ce74ac931ad78df --- /dev/null +++ "b/pages/16_IV.3._Concevoir_votre_prompt_d'\303\251valuation.py" @@ -0,0 +1,66 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown(""" +## Concevoir votre *prompt* d'Ă©valuation +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +### Conseils gĂ©nĂ©raux pour la conception des *prompts* + +Voici quelques indications que j'ai trouvĂ©es en ligne concernant la conception du *prompt* lui-mĂȘme : +- Fournir une description claire de la tĂąche Ă  accomplir : + - « Ta tĂąche est de faire X ». + - « On te donnera Y ». +- Fournir des instructions claires sur les critĂšres d'Ă©valuation, y compris un systĂšme de notation dĂ©taillĂ© si nĂ©cessaire : + - « Tu dois Ă©valuer la propriĂ©tĂ© Z sur une Ă©chelle de 1 Ă  5, oĂč 1 signifie ... ». + - « Tu dois Ă©valuer si la propriĂ©tĂ© Z est prĂ©sente dans l'Ă©chantillon Y. La propriĂ©tĂ© Z est prĂ©sente si ... ». +- Fournir quelques Ă©tapes supplĂ©mentaires d'Ă©valuation du « raisonnement » : + - « Pour juger cette tĂąche, tu dois d'abord t'assurer de lire attentivement l'Ă©chantillon Y pour identifier ..., puis ... ». +- SpĂ©cifier le format de sortie souhaitĂ© (l'ajout de champs facilitera la cohĂ©rence) + - « Ta rĂ©ponse doit ĂȘtre fournie en JSON, avec le format suivant {"Score" : Ton score, "Reasoning" : Le raisonnement qui t'a conduit Ă  ce score} ». +""", unsafe_allow_html=True) +st.success("""Nous avons traduit les *prompts* en utilisant le tutoiement. Il n'est pas dit que ce soit la meilleure option pour requĂȘter le modĂšle. Le vouvoiement ou l'impĂ©ratif pourraient ĂȘtre des options plus efficaces. Nous n'avons pas trouvĂ© de publication sur ce sujet permettant de trancher. Nous vous conseillons alors de tester les trois approches.""") +st.markdown(""" +Vous pouvez et devriez vous inspirer des exemples de *prompts* de [MixEval](https://github.com/huggingface/lighteval/blob/main/src/lighteval/tasks/extended/mix_eval/judge_prompts.pyy) ou [MTBench](https://github.com/huggingface/lighteval/blob/main/src/lighteval/tasks/extended/mt_bench/judge_prompt_templates.py). + +Autres remarques : +- La comparaison par paire [est mieux corrĂ©lĂ©e avec les prĂ©fĂ©rences humaines](https://arxiv.org/abs/2403.16950) que la notation, et est gĂ©nĂ©ralement plus robuste. +- Si vous voulez vraiment un score, utilisez une Ă©chelle de nombres entiers et assurez-vous de fournir une explication dĂ©taillĂ©e de ce que [chaque score reprĂ©sente](https://x.com/seungonekim/status/1749289437165769177), ou un *prompt* additif (« attribuer 1 point Ă  cette caractĂ©ristique de la rĂ©ponse, 1 point supplĂ©mentaire si ...», etc.). +- L'utilisation d'un *prompt* par capacitĂ© Ă  noter tend Ă  donner des rĂ©sultats meilleurs et plus robustes. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### AmĂ©liorer la prĂ©cision du jugement + +Vous pouvez Ă©galement amĂ©liorer la prĂ©cision en utilisant les techniques suivantes, peut-ĂȘtre plus coĂ»teuses : +- **Donner quelques exemples**
Comme dans beaucoup d'autres tùches, si vous donnez des exemples, cela peut aider le processus de raisonnement. Cependant, cela augmente la longueur de votre contexte. +- **Référence**
Vous pouvez aussi ajouter une référence à votre *prompt*. +- **CoT (*Chains of Thought*)**
Processus qui [améliore la précision](https://arxiv.org/abs/2212.08073) si vous demandez au modÚle de produire sa chaßne de pensée **avant** le score (aussi observé [ici](https://x.com/seungonekim/status/1749289437165769177)). +- **Analyse multi-tours**
Peut améliorer [la détection des erreurs factuelles](https://arxiv.org/abs/2305.13281). +- **Utiliser un jury**
Plusieurs juges fournissant une réponse agrégée [donne de meilleurs résultats](https://arxiv.org/abs/2404.18796) que l'utilisation d'un seul modÚle. + - Il est possible de réduire considérablement les coûts en utilisant plusieurs petits modÚles au lieu d'un seul grand modÚle coûteux. + - Vous pouvez également expérimenter l'utilisation d'un unique modÚle mais avec des variations de température. +- **Enjeux**
De maniĂšre surprenante, il a Ă©tĂ© constatĂ© que l'ajout d'enjeux au *prompt* (« Si tu rĂ©ponds correctement, tu obtiendras un chaton ») peut amĂ©liorer l'exactitude des rĂ©ponses. Cette mĂ©thode peut varier, il faut l'adapter Ă  vos besoins. +""", unsafe_allow_html=True) +st.info("""En fonction des enjeux de votre cas d'usage, pour Ă©liminer autant de biais que possible, vous devriez vous pencher sur les travaux rĂ©alisĂ©s en sociologie sur la maniĂšre de concevoir de bonnes enquĂȘtes. Si vous considĂ©rez votre Ă©valuateur comme un remplaçant Ă  un annotateur humain, vous devez alors vous pencher sur des mesures similaires : calcul de l'accord entre les annotateurs, utilisation d'une mĂ©thodologie de conception d'enquĂȘte correcte pour attĂ©nuer les biais, etc.""") +st.markdown(""" +Cependant, la plupart des gens ne souhaitent pas vraiment une Ă©valuation impartiale reproductible et de grande qualitĂ©, et se contenteront d'une Ă©valuation rapide et sale Ă  l'aide de *prompts* acceptables. Cela peut ĂȘtre ok, cela dĂ©pend des consĂ©quences qui en dĂ©coulent. +""", unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("IV.2._DĂ©finir_son_juge") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("IV.4._Évaluer votre Ă©valuateur") \ No newline at end of file diff --git "a/pages/17_IV.4._\303\211valuer_votre_\303\251valuateur.py" "b/pages/17_IV.4._\303\211valuer_votre_\303\251valuateur.py" new file mode 100644 index 0000000000000000000000000000000000000000..e7430925737670b49c562672cc361ec6ec1cbe45 --- /dev/null +++ "b/pages/17_IV.4._\303\211valuer_votre_\303\251valuateur.py" @@ -0,0 +1,59 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown(""" +## Évaluer votre Ă©valuateur + +Avant d'utiliser un juge en production ou Ă  grande Ă©chelle, vous devez d'abord Ă©valuer sa qualitĂ© pour votre tĂąche afin de vous assurer que ses scores sont rĂ©ellement pertinents et vous sont utiles. + +Une fois que vous avez sĂ©lectionnĂ© votre modĂšle et son instruction, vous devez procĂ©der comme suit. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### 1. Choisir votre *baseline* +Vous devrez comparer les jugements de votre Ă©valuateur Ă  une *baseline*. Il peut s'agir d'annotations humaines, du mĂȘme modĂšle utilisant une autre instruction, de la sortie d'un autre modĂšle que vous savez qualitatif pour votre tĂąche, etc. + +Vous n'avez pas nĂ©cessairement besoin de beaucoup d'exemples (50 peuvent suffire), mais vous avez besoin qu'ils soient extrĂȘmement reprĂ©sentatifs de votre tĂąche, discriminants (reprĂ©sentatifs des cas limites notamment), et d'une qualitĂ© aussi Ă©levĂ©e que possible. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### 2. Choisir une mĂ©trique + +La mĂ©trique sera utilisĂ©e pour comparer les Ă©valuations de votre juge avec votre rĂ©fĂ©rence. +En gĂ©nĂ©ral, cette comparaison est beaucoup plus facile Ă  rĂ©aliser si votre modĂšle prĂ©dit des classes binaires ou effectue des comparaisons par paire, car vous pourrez calculer l'[*accuracy*](https://huggingface.co/spaces/evaluate-metric/accuracy) (pour les comparaisons par paire), ou la prĂ©cision et le rappel (pour les classes binaires), qui sont toutes des mĂ©triques trĂšs faciles Ă  interprĂ©ter. + +Il sera plus difficile de comparer la corrĂ©lation des scores avec la notation humaine ou celle d'un modĂšle. Pour comprendre pourquoi plus en dĂ©tail, je vous conseille de lire la [partie de cet article de blog](https://eugeneyan.com/writing/llm-evaluators/#key-considerations-before-adopting-an-llm-evaluator) (⭐) Ă©voquant ce sujet. +Dans ce mĂȘme article, un graphique permet de vous aiguiller dans le choix d'une mĂ©trique si vous ne savez pas laquelle choisir. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.image("""./assets/llm-eval-tree.jpg""", caption="Image provenant de Evaluating the Effectiveness of LLM-Evaluators (aka LLM-as-Judge) d'Eugene Yan") +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### 3. Évaluer votre Ă©valuateur + +Pour cette Ă©tape, il vous suffit d'utiliser votre modĂšle et son instruction pour Ă©valuer vos Ă©chantillons de test ! Ensuite, une fois que vous avez obtenu les Ă©valuations, utilisez votre mĂ©trique et votre rĂ©fĂ©rence pour calculer un score pour vos Ă©valuations. + +Vous devez dĂ©terminer votre seuil d'acceptation. En fonction de la difficultĂ© de votre tĂąche, vous pouvez viser une prĂ©cision de 80 Ă  95 % si vous effectuez des comparaisons par paire. En ce qui concerne les corrĂ©lations (si vous utilisez des scores), la littĂ©rature spĂ©cialisĂ©e tend Ă  se satisfaire d'une corrĂ©lation de Pearson de 0,8 avec la rĂ©fĂ©rence. J'ai nĂ©anmoins vu certains articles dĂ©clarer que 0,3 indique une bonne corrĂ©lation avec des annotateurs humains 😅. +""", unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("IV.3._Concevoir_votre_instruction_d'Ă©valuation") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("IV.5._ModĂšles de rĂ©compense") \ No newline at end of file diff --git "a/pages/18_IV.5._Mod\303\250les de r\303\251compense.py" "b/pages/18_IV.5._Mod\303\250les de r\303\251compense.py" new file mode 100644 index 0000000000000000000000000000000000000000..9508f47a29c0e32e4adc0c27c0f2508e3a06a511 --- /dev/null +++ "b/pages/18_IV.5._Mod\303\250les de r\303\251compense.py" @@ -0,0 +1,88 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown(""" +## ModĂšles de rĂ©compense + +### Qu'est-ce qu'un modĂšle de rĂ©compense ? + +Les modĂšles de rĂ©compense apprennent Ă  prĂ©dire un score Ă  partir d'annotations humaines pour des paires instructions-gĂ©nĂ©rations donnĂ©es. L'objectif final est qu'ils fassent des prĂ©dictions alignĂ©es sur les prĂ©fĂ©rences humaines. +Une fois entraĂźnĂ©s, ces modĂšles peuvent ĂȘtre utilisĂ©s pour amĂ©liorer d'autres modĂšles, en agissant comme une fonction de rĂ©compense qui est une approximation du jugement humain.""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(r""" +##### Score par paire + +Le type de modĂšle de rĂ©compense le plus courant est le modĂšle de Bradley-Terry, qui produit un score unique, comme suit : $p(\text{la gĂ©nĂ©ration b est meilleure que la gĂ©nĂ©ration a}) = \text{sigmoĂŻde}(\text{score}_b - \text{score}_a)$ + +Ce modĂšle est entraĂźnĂ© en utilisant uniquement des gĂ©nĂ©rations car elles sont plus faciles Ă  collecter que les scores. Cependant il ne peut comparer que plusieurs gĂ©nĂ©rations issues d'une mĂȘme instruction et non des gĂ©nĂ©rations issues d'instructions diffĂ©rentes. + +D'autres modĂšles ont Ă©tendu cette approche afin de prĂ©dire une probabilitĂ© plus nuancĂ©e qu'une gĂ©nĂ©ration soit meilleure qu'une autre ([exemple](https://huggingface.co/RLHFlow/pair-preference-model-LLaMA3-8B)). + +Cela permet (thĂ©oriquement) de juger des diffĂ©rences subtiles entre les gĂ©nĂ©rations, au prix de l'impossibilitĂ© de sauvegarder et de comparer facilement de nombreux scores issus de diffĂ©rentes instructions pour un mĂȘme jeu de test. En outre, la longueur du contexte et les limites de la mĂ©moire peuvent devenir un problĂšme lorsqu'il s'agit de comparer des gĂ©nĂ©rations trop longues. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Score absolu + +Certains modĂšles de rĂ©compense tels que [SteerLM](https://arxiv.org/abs/2311.09528) produisent des scores absolus, pouvant ĂȘtre utilisĂ©s pour Ă©valuer directement les gĂ©nĂ©rations sans que ce soit nĂ©cessaire de procĂ©der Ă  des comparaisons par paires. + +Plus rĂ©cemment, des modĂšles ont Ă©tĂ© proposĂ©s ayant comme sortie Ă  la fois des scores absolus et relatifs, tels que [HelpSteer2-Preference](https://arxiv.org/abs/2410.01257) et [ArmoRM](https://arxiv.org/abs/2406.12845). +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Comment utiliser un modĂšle de rĂ©compense pour l'Ă©valuation ? + +Étant donnĂ© un jeu de donnĂ©es d'instructions, nous pouvons effectuer des gĂ©nĂ©rations Ă  partir d'un modĂšle de langage et demander Ă  un modĂšle de rĂ©compense de les noter. + +Pour les modĂšles qui donnent des scores absolus, la moyenne des scores obtenus peut ĂȘtre calculĂ©e pour obtenir un score rĂ©capitulatif raisonnable. + +Toutefois, dans le cas plus courant de scores relatifs, la rĂ©compense moyenne peut ĂȘtre faussĂ©e par des valeurs aberrantes (quelques trĂšs bonnes ou trĂšs mauvaises rĂ©ponses), Ă©tant donnĂ© que les diffĂ©rentes instructions peuvent avoir des Ă©chelles de rĂ©compense intrinsĂšquement diffĂ©rentes (certaines instructions sont beaucoup plus difficiles ou faciles que d'autres). + +Au lieu de cela, nous pouvons utiliser : +- les **taux de victoire**
Prenez un ensemble de données de référence et calculez le pourcentage de générations du modÚle qui sont mieux classées que les données de référence. Cette méthode est légÚrement plus granulaire. +- les **probabilités de victoire**
La probabilitĂ© moyenne que les gĂ©nĂ©rations soient meilleures que les donnĂ©es de rĂ©fĂ©rence, ce qui peut donner un signal plus fin et plus rĂ©gulier. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Avantages et inconvĂ©nients des modĂšles de rĂ©compense + +Les modĂšles de rĂ©compense ont l'avantage d'ĂȘtre gĂ©nĂ©ralement ➕ : +- **TrĂšs rapides**
L'obtention d'un score est aussi simple que l'exécution d'une passe avant d'un modÚle relativement petit (puisque nous n'obtenons qu'un score, et non un texte long, contrairement aux *LLM-as-a-judge*). +- **Déterministes**
Les mĂȘmes scores seront reproduits par la mĂȘme passe avant. +- **Peu susceptibles de souffrir d'un biais de position**
Comme la plupart des modĂšles ne prennent qu'une seule gĂ©nĂ©ration, ils ne peuvent pas ĂȘtre influencĂ©s par l'ordre. +Pour les modĂšles par paire, le biais de position est souvent minime, tant que les donnĂ©es d'entraĂźnement sont Ă©quilibrĂ©es en ce qui concerne la prĂ©sence de la premiĂšre et de la deuxiĂšme rĂ©ponse comme Ă©tant la meilleure. +- **Ne nĂ©cessitent pas d'ingĂ©nierie
Puisque le modĂšle produira simplement un score Ă  partir d'une ou deux gĂ©nĂ©rations en fonction des donnĂ©es de prĂ©fĂ©rence sur lesquelles il a Ă©tĂ© entraĂźnĂ©. + +En revanche, ils ont comme contrainte de ➖ : +- **NĂ©cessiter un *finetuning* spĂ©cifique**
Cette Ă©tape peut ĂȘtre relativement coĂ»teuse, et bien qu'ils hĂ©ritent de nombreuses capacitĂ©s du modĂšle de base choisi, ils peuvent donner de mauvais rĂ©sultats sur des tĂąches ne faisant pas partie de la distribution du prĂ©-entraĂźnement. +- **Perdre en efficacitĂ© lorsqu'ils sont utilisĂ©s Ă  la fois en apprentissage par renforcement et en Ă©valuation**
De mĂȘme lorsqu'ils utilisent des algorithmes d'alignement direct sur des jeux de donnĂ©es similaires aux donnĂ©es d'entraĂźnement du modĂšle de rĂ©compense. En effet, le modĂšle de langage peut s'ajuster de maniĂšre excessive aux prĂ©fĂ©rences du modĂšle de rĂ©compense. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Conseils et astuces pour l'utilisation des modĂšles de rĂ©compense pour de l'Ă©valuation + +- Le [*RewardBench Leaderboard*](https://huggingface.co/spaces/allenai/reward-bench) est un bon endroit pour trouver les modĂšles les plus performants. +- Vous pouvez examiner la maniĂšre dont les modĂšles de rĂ©compense ont Ă©tĂ© utilisĂ©s dans le papier du [Nemotron](https://arxiv.org/abs/2406.11704). +- Pour les modĂšles de rĂ©compense qui Ă©valuent des instructions et des gĂ©nĂ©rations uniques, vous pouvez mettre en cache les scores de nombreux modĂšles de rĂ©fĂ©rence et voir facilement les performances d'un nouveau modĂšle. +- Traquez les taux/probabilitĂ©s au cours de l'entraĂźnement, peut vous permettre de dĂ©tecter la dĂ©gradation du modĂšle et de sĂ©lectionner des *checkpoints* optimaux (cf. ce [papier](https://arxiv.org/abs/2410.11677v1)). +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("IV.4._Évaluer votre Ă©valuateur") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("IV.6._Conseils et astuces") \ No newline at end of file diff --git a/pages/19_IV.6._Conseils et astuces.py b/pages/19_IV.6._Conseils et astuces.py new file mode 100644 index 0000000000000000000000000000000000000000..704cab89621d6c192f196f72ece338e8e9dc3285 --- /dev/null +++ b/pages/19_IV.6._Conseils et astuces.py @@ -0,0 +1,45 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown(""" +## Conseils et astuces + +### AttĂ©nuer les biais bien connus des *LLM-as-a-judge* + +- **Manque de cohĂ©rence interne**
Un juge peut vous donner des avis différents si vous l'interrogez plusieurs fois (si la température n'est pas fixée à 0).
Atténuation :
Vous pouvez atténuer ce problÚme en demandant à votre juge de faire preuve de cohérence interne en l'interrogeant plusieurs fois pour ne conserver que la sortie revenant le plus souvent. +- **Auto-préférence**
Ils ont tendance à [favoriser leurs propres sorties](https://arxiv.org/abs/2404.13076) lorsqu'ils notent les réponses.
Atténuation :
Vous pouvez atténuer ce phénomÚne en utilisant un jury. +- **Cécité à la perturbation de l'entrée**
Les modÚles sont mauvais pour identifier [l'entrée perturbée](https://arxiv.org/abs/2406.13439) et tangentiellement [mauvais pour fournir des plages de notation cohérentes](https://twitter.com/aparnadhinak/status/1748368364395721128) (des expériences étendues à ce sujet sont disponibles [ici](https://github.com/LeonEricsson/llmjudge/blob/main/README.md)). Par exemple, si on leur demande de classer la qualité d'un texte dans lequel du bruit a été ajouté sur une échelle cohérente, les notes prédites ne reflÚtent pas cette échelle.
Atténuation : + - demander au modÚle d'expliquer son raisonnement [avant de fournir une note](https://twitter.com/seungonekim/status/1749289437165769177). + - fournir une échelle de notation cohérente dans l'instruction. +- **Biais de position**
Ils ont tendance à [favoriser des positions de réponse spécifiques](https://arxiv.org/abs/2306.05685). Par exemple, lorsqu'on leur présente des comparaisons par paires, Claude et GPT3.5 ont tendance à préférer assez systématiquement soit le premier choix, soit le second choix.
Atténuation : + - changer les positions des réponses de maniÚre aléatoire. + - calculer les log-probabilités de tous les choix possibles pour obtenir une réponse normalisée. +- **Biais de verbosité** (ou de longueur)
Ils ont tendance à préférer les réponses plus verbeuses.
Atténuation :
Vous pouvez [tenir compte de la différence de longueur des réponses](https://arxiv.org/abs/2404.04475). +- **Leur cohérence [avec les réponses humaines](https://arxiv.org/abs/2308.15812) est contestable**
Cependant, il est aussi [discutable que des humains non experts constituent une bonne *baseline* pour absolument toutes les évaluations](https://arxiv.org/abs/2202.06935). Pour certains domaines spécifiques (médical, juridique, mathématique, etc.), l'utilisation d'annotateurs humains non experts est une base aussi mauvaise que l'utilisation directe d'un LLM. +- **Biais de format**
Ils ont tendance à ne pas évaluer avec précision si le format de l'instruction [est trop éloigné](https://arxiv.org/abs/2310.17631) de ce avec quoi ils ont été entraßnés. Par exemple, un modÚle entraßné à effectuer des comparaisons par paire avec une réponse de référence échouera si cette réponse n'est pas fournie. Des échecs se produiront également dans l'autre sens.
Atténuation :
Vous pouvez attĂ©nuer ce problĂšme en prĂȘtant attention au format de l'instruction d'entraĂźnement (si le modĂšle a Ă©tĂ© entraĂźnĂ©) et en veillant Ă  le respecter. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Choisir les bonnes tĂąches Ă  soumettre au juge + +Les modĂšles utilisĂ©s comme juge : +- sont en gĂ©nĂ©ral **mauvais pour identifier les hallucinations**. En particulier ce qu'on appelle les hallucinations partielles (qui semblent proches de la vĂ©ritĂ© mais sont en fait lĂ©gĂšrement diffĂ©rentes) (voir notamment [ce papier](https://arxiv.org/abs/2305.11747) et [celui-ci](https://arxiv.org/abs/2303.08896)). +- ont une corrĂ©lation faible avec les annotateurs humains en ce qui concerne [le rĂ©sumĂ©](https://arxiv.org/abs/2304.02554) (voir aussi [ici](https://arxiv.org/abs/2303.16634)), [la fidĂ©litĂ©](https://arxiv.org/abs/2307.16877), et ne sont pas corrĂ©lĂ©s de maniĂšre cohĂ©rente avec le jugement humain de maniĂšre plus gĂ©nĂ©rale en ce qui concerne [un Ă©ventail de tĂąches](https://arxiv.org/abs/2406.18403). +""", unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("IV.5._ModĂšles de rĂ©compense") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("V._DĂ©pannage") \ No newline at end of file diff --git "a/pages/1_I._CONNAISSANCES G\303\211N\303\211RALES.py" "b/pages/1_I._CONNAISSANCES G\303\211N\303\211RALES.py" new file mode 100644 index 0000000000000000000000000000000000000000..20a92c8e9642ce053ab7c44dcb9b077c88d2ffde --- /dev/null +++ "b/pages/1_I._CONNAISSANCES G\303\211N\303\211RALES.py" @@ -0,0 +1,25 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown("""## Connaissances gĂ©nĂ©rales""") +st.markdown(""" """) + +st.markdown(""" +Il s'agit essentiellement de sections pour dĂ©butants portant sur les principes de base des LLM comme l'infĂ©rence et la tokĂ©nisation. +Elles contiennent tout de mĂȘme des conseils et des rĂ©fĂ©rences intĂ©ressantes ! +Si vous ĂȘtes un utilisateur avancĂ©, je vous suggĂšre de passer rapidement aux parties « Aller plus loin » de ces sections.""") + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("GLOSSAIRE") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("I.1._InfĂ©rence et Ă©valuation des modĂšles") \ No newline at end of file diff --git "a/pages/20_V._D\303\211PANNAGE.py" "b/pages/20_V._D\303\211PANNAGE.py" new file mode 100644 index 0000000000000000000000000000000000000000..459d8b44919b8fbb0c23ec9a746724fbc446bd6e --- /dev/null +++ "b/pages/20_V._D\303\211PANNAGE.py" @@ -0,0 +1,23 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown("""## *DĂ©pannage*""") +st.markdown(""" """) + +st.markdown(""" +Dans ce chapitre, nous passons en revue des recommandations pratiques pour rĂ©soudre des difficultĂ©s concernant l'infĂ©rence, la reproductibilitĂ© et les problĂšmes mathĂ©matiques.""") + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("IV.6._Conseils et astuces") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("V.1._DĂ©panner l'infĂ©rence") \ No newline at end of file diff --git "a/pages/21_V.1._D\303\251panner l'inf\303\251rence.py" "b/pages/21_V.1._D\303\251panner l'inf\303\251rence.py" new file mode 100644 index 0000000000000000000000000000000000000000..90c45f429406752ddb9e0fbb0f21fb8cd642e720 --- /dev/null +++ "b/pages/21_V.1._D\303\251panner l'inf\303\251rence.py" @@ -0,0 +1,98 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown(""" +## DĂ©panner l'infĂ©rence + +### Le modĂšle est trĂšs lent +##### Changer la taille de batch +Si vous souhaitez une reproductibilitĂ© absolue (pour un matĂ©riel spĂ©cifique et une instruction d'Ă©valuation spĂ©cifique), vous utiliserez probablement une taille de batch de 1. Toutefois, si vous augmentez la taille de batch, votre Ă©valuation sera probablement plus rapide (Ă  condition qu'elle soit compatible avec les capacitĂ©s mĂ©moires de votre matĂ©riel).""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### ParallĂ©lisme des donnĂ©es +Vous pouvez Ă©galement dupliquer votre modĂšle sur plusieurs GPU au lieu de le charger sur un seul, fournir des sous-ensembles de donnĂ©es Ă  chaque GPU, puis agrĂ©ger les rĂ©sultats des calculs. +Cela signifie que chaque flux de donnĂ©es sera traitĂ© en parallĂšle, en mĂȘme temps que les autres, ce qui divise le temps d'exĂ©cution total par le nombre de GPU utilisĂ©. +Notez que si vous le pouvez, tous les GPU doivent se trouver sur un seul nƓud afin d'Ă©viter les goulets d'Ă©tranglement entre les nƓuds. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Changer le code d'infĂ©rence +Toutes les bibliothĂšques d'infĂ©rence ne fonctionnent pas Ă  la mĂȘme vitesse, et certains codes sont plus optimisĂ©s que d'autres. Vous devrez expĂ©rimenter un peu pour trouver quelles bibliothĂšques ont l'infĂ©rence la plus rapide, et si vous utilisez PyTorch, je vous recommande de regarder la *checklist* portant sur l'optimisation de l'infĂ©rence dans la [documentation officielle](https://pytorch.org/serve/performance_checklist.html). +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Changer la prĂ©cision +Si votre modĂšle est trĂšs lent, vous pouvez rĂ©duire sa taille en rĂ©duisant la prĂ©cision des calculs. Un modĂšle stockĂ© en `float32` effectue des calculs trĂšs prĂ©cis (utilisant 32 bits par nombre stockĂ©) qui sont Ă©galement trĂšs lourds en mĂ©moire et pour les calculs. Passer Ă  du `blfoat16` ou `float16` (moitiĂ© de la prĂ©cision) devrait rendre le modĂšle deux fois plus rapide avec une perte de prĂ©cision qui ne devrait presque pas avoir d'importance. Si vous voulez gagner en vitesse, vous pouvez quantifier encore davantage, Ă  8 ou 4 bits (en utilisant [gptq](https://github.com/AutoGPTQ/AutoGPTQ) ou [bitsandbytes](https://github.com/bitsandbytes-foundation/bitsandbytes) par exemple). Les calculs de matrices Ă  *n* bits devraient ĂȘtre plus rapides et votre modĂšle prendra encore moins de place en mĂ©moire (cependant, certaines bibliothĂšques de quantification peuvent ĂȘtre un peu lentes, alors testez les choses pour vos cas d'utilisation !) +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Le modĂšle est trĂšs grand +##### Estimer les besoins en mĂ©moire +Vous pouvez estimer la mĂ©moire thĂ©orique minimale requise pour charger un modĂšle donnĂ© (et donc le matĂ©riel) Ă  l'aide de la **formule suivante** : + +` = * ` + +Comme on peut stocker 8 bits dans un octet, la mĂ©moire nĂ©cessaire est le nombre total de paramĂštres multipliĂ© par le nombre d'octets nĂ©cessaires pour stocker un paramĂštre. Le facteur de prĂ©cision est donc de 4 pour `float32`, 2 pour `float16` ou `bfoat16`, 1 pour `8bit` et 0,5 pour les modĂšles `4bit`. +Et c'est tout ! +Je recommanderais en fait d'utiliser ` = * ( * 110%)`, pour ĂȘtre plus sĂ»r, car l'infĂ©rence nĂ©cessite un peu plus de mĂ©moire que le simple chargement du modĂšle (vous devrez par exemple charger les batchs). +""", unsafe_allow_html=True) +st.success("""Depuis la rĂ©daction du guide par ClĂ©mentine, Quentin GallouĂ©dec d'Hugging Face a rĂ©digĂ© un article de blog dĂ©taillĂ© sur ce [point](https://huggingface.co/blog/train_memory). +Vous pouvez aussi utiliser ce [Space](https://huggingface.co/spaces/hf-accelerate/model-memory-usage) de Zach Mueller aussi chez Hugging Face.""") +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +##### Que faire si votre modĂšle ne tient pas sur un GPU ? +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +###### Quantification +La premiĂšre chose Ă©vidente est de jouer sur le `` ci-dessus. Par exemple passer de `float32` Ă  du 4 bits rĂ©duit les besoins en mĂ©moire par 8 ! +Cependant, une prĂ©cision trop faible peut donner de moins bons rĂ©sultats. Pour certains modĂšles, en particulier les modĂšles de taille moyenne, il est prĂ©fĂ©rable de rester en `float16` ou 8 bits. La quantification semble moins affecter les performances des trĂšs grands modĂšles, probablement Ă  cause de la redondance de l'information. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown("""###### ParallĂ©lisme +Le parallĂ©lisme comprend une sĂ©rie de techniques qui dĂ©coupent votre modĂšle en sous-modĂšles plus petits, afin de charger et d'exĂ©cuter chacun de ces sous-modĂšles sur un GPU diffĂ©rent. Cette mĂ©thode nĂ©cessite moins de mĂ©moire puisque vous ne chargez jamais le modĂšle complet en une seule fois, mais elle peut ĂȘtre plus lente. + +Les deux principaux types de parallĂ©lisme sont les suivants : +- Le parallĂ©lisme de pipeline, oĂč le modĂšle est divisĂ© au niveau de la couche entiĂšre, et les couches sont rĂ©parties sur diffĂ©rents GPU. Comme la sortie de la couche 1 est l'entrĂ©e de la couche 2, l'exĂ©cution est plus lente, car les GPU restent inactifs pendant l'attente, ce que l'on appelle une « bulle » (et les donnĂ©es doivent ĂȘtre transfĂ©rĂ©es d'un GPU Ă  l'autre). La bulle peut ĂȘtre rĂ©duite en divisant les entrĂ©es en batchs plus petits. Cela est ajoutĂ© nativement Ă  PyTorch avec la [lib PiPPy](https://github.com/pytorch/PiPPy), et c'est ce que [accelerate](https://github.com/huggingface/accelerate) utilise sous le capot pour le parallĂ©lisme. +""", unsafe_allow_html=True) +st.image('./assets/parallelism_bubble.png',caption="Illustration de la bulle dans le papier GPipe: Efficient Training of Giant Neural Networks using Pipeline Parallelism de Huang et al.") +st.markdown(""" +- Le parallĂ©lisme tensoriel, oĂč le modĂšle est divisĂ© au niveau du calcul matriciel. Cela signifie que les matrices seront divisĂ©es en lignes ou en colonnes, et que le rĂ©sultat total sera agrĂ©gĂ©. Cette mĂ©thode est incroyablement efficace tant que tous les GPU se trouvent sur le mĂȘme nƓud (pour Ă©viter les goulets d'Ă©tranglement du rĂ©seau inter-nƓuds), mais elle peut ĂȘtre difficile Ă  coder. Vous trouverez des implĂ©mentations intĂ©ressantes dans la librairie [vllm](https://github.com/vllm-project/vllm). Elle permet des accĂ©lĂ©rations **incroyables**. +""", unsafe_allow_html=True) +st.info("""Nous vous conseillons le trĂšs bon document portant sur les diffĂ©rents types de parallĂ©lisme (y compris le parallĂ©lisme de donnĂ©es) disponible [ici](https://hf.co/docs/transformers/v4.15.0/en/parallelism).""") +st.success("""Depuis la rĂ©daction du guide par ClĂ©mentine, les membres de l'Ă©quipe Nanotron a sorti [*The Ultra-Scale Playbook: +Training LLMs on GPU Clusters*](https://huggingface.co/spaces/nanotron/ultrascale-playbook) qui est une ressource de trĂšs grande qualitĂ© sur le sujet du parallĂ©lisme.""") +st.markdown(""" """) +st.markdown(""" +###### DĂ©chargement du processeur +Le dĂ©chargement dĂ©place certaines parties des calculs et des modĂšles dans le but de rĂ©duire l'utilisation de la mĂ©moire du GPU. C'est **considĂ©rablement plus lent** que n'importe quelle autre mĂ©thode, principalement parce que vous avez besoin de dĂ©placer des donnĂ©es d'un pĂ©riphĂ©rique Ă  l'autre en permanence. + +Un exemple de cette mĂ©thode est [ZeRO-Offload](https://arxiv.org/abs/2101.06840) par DeepSpeed, qui distribue les paramĂštres entre le CPU et le GPU (en plus d'utiliser d'autres optimisations dĂ©crites dans le papier ZeRO-2). Sur le CPU sont transmis les gradients, les Ă©tats de l'optimiseur et les calculs des paramĂštres du modĂšle en `fp32` pendant l'optimisation, tandis que sur le GPU on trouve les paramĂštres en `fp16` et les passes avant/arriĂšre. Il s'agit de tirer parti de la mĂ©moire utilisĂ©e par le CPU et des calculs du GPU tout en minimisant la communication entre les deux. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Le modĂšle tient sur un GPU mais j'obtiens toujours des erreurs OOM ! +Vous avez probablement un problĂšme avec la taille de votre contexte. + +Il est conseillĂ© +1) de tester si votre modĂšle tient vraiment sur un GPU avec des donnĂ©es d'infĂ©rence fictives chargĂ©es. Ces donnĂ©es fictives doivent avoir une taille de contexte suffisamment grande (reprĂ©sentative de votre tĂąche) +2) diminuer la taille du batch, ou supprimer la recherche automatique de la taille du batch qui pourrait conduire Ă  une erreur OOM accidentelle, si vous l'avez activĂ©e +3) plus gĂ©nĂ©ralement, s'assurer que les Ă©chantillons sont prĂ©sentĂ©s Ă  votre modĂšle dans l'ordre inverse de la taille du contexte, pour ĂȘtre sĂ»r que votre modĂšle Ă©chouera directement si la taille du contexte est trop grande, et non pas aprĂšs avoir tournĂ© pendant X heures. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("V._DÉPANNAGE") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("V.2._DĂ©panner la reproductibilitĂ©") \ No newline at end of file diff --git "a/pages/22_V.2._D\303\251panner la reproductibilit\303\251.py" "b/pages/22_V.2._D\303\251panner la reproductibilit\303\251.py" new file mode 100644 index 0000000000000000000000000000000000000000..9bfb17ecbb2567ab44f640ed9241eb8049e2fb8d --- /dev/null +++ "b/pages/22_V.2._D\303\251panner la reproductibilit\303\251.py" @@ -0,0 +1,126 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown(""" +## DĂ©panner la reproductibilitĂ© + +Imaginons que vous ayez lu un rapport technique sur un nouveau modĂšle trĂšs cool et que vous souhaitiez reproduire ses rĂ©sultats sur votre machine... mais que vous n'y parveniez pas ? +Voyons pourquoi. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Base de code diffĂ©rente +Pour reproduire les scores d'Ă©valuation Ă  la virgule prĂšs, vous devez d'abord vous assurer que vous utilisez exactement la mĂȘme base de code que le papier que vous voulez reproduire. + +En gĂ©nĂ©ral, cela signifie que vous utilisez le code d'Ă©valuation par dĂ©faut fourni par les auteurs, ou une implĂ©mentation standard dans une bibliothĂšque de rĂ©fĂ©rence comme [lm_eval](https://github.com/EleutherAI/lm-evaluation-harness) ou [lighteval](https://github.com/huggingface/lighteval). En revanche, si le code source de l'Ă©valuation n'est pas fourni, je suis dĂ©solĂ© pour vous, mais il est peu probable que vous puissiez reproduire les rĂ©sultats avec prĂ©cision. + +Si vous voulez comprendre facilement quels types de divergences se produisent lors de l'utilisation de diffĂ©rentes implĂ©mentations, vous pouvez explorer cet [article de blog](https://huggingface.co/blog/fr/open-llm-leaderboard-mmlu) (en français) (⭐) que nous avons Ă©crit avec l'Ă©quipe d'Ă©valuation d'HuggingFace. Il Ă©tudie les diffĂ©rences que nous avons observĂ©es entre 3 implĂ©mentations courantes pour l'Ă©valuation de MMLU (dans lm_eval, [helm](https://github.com/stanford-crfm/helm), et dans l'implĂ©mentation originale de l'auteur), et comment elles affectent les scores des modĂšles. +""", unsafe_allow_html=True) +st.info("""C'est prĂ©cisĂ©ment pour cette raison qu'une Ă©quipe d'Hugging Face a dĂ©cidĂ© de lancer l'[*Open LLM Leaderboard*](https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard), pour obtenir des comparaisons unifiĂ©es et homogĂšnes des scores des modĂšles afin de les comparer aux expĂ©riences internes.""") +st.markdown(""" """) +st.markdown(""" +##### Autres façons subtiles oĂč l'implĂ©mentation peut ĂȘtre diffĂ©rente +Nous avons observĂ© qu'il Ă©tait facile de se tromper sur les points suivants, mĂȘme en utilisant la mĂȘme base de code : +- **Graine alĂ©atoire diffĂ©rente** +Normalement, l'infĂ©rence est moins affectĂ©e par les graines alĂ©atoires que l'entraĂźnement. Cependant, elles peuvent affecter certaines opĂ©rations CUDA (voir la page sur la [reproductibilitĂ©](https://pytorch.org/docs/stable/notes/randomness.html) de PyTorch) et modifier les prĂ©dictions si vous utilisez une stratĂ©gie de gĂ©nĂ©ration [non *greedy*](https://huggingface.co/blog/how-to-generate). Elles peuvent Ă©galement affecter l'instruction avec exemple, et certaines fonctions de prĂ©/post-traitement. +→ Un changement minime peut entraĂźner une diffĂ©rence de quelques points. +- **MĂ©trique diffĂ©rente** +Les mĂ©triques peuvent ĂȘtre diffĂ©rentes dans la pratique, mĂȘme si elles portent le mĂȘme nom. Quelques exemples : + - Vous n'obtiendrez pas les mĂȘmes scores si l'implĂ©mentation originale est une « correspondance exacte via log vraisemblance » (log probabilitĂ©s des diffĂ©rentes rĂ©ponses possibles) mais que vous utilisez une « correspondance exacte via gĂ©nĂ©ration » (comparant la gĂ©nĂ©ration *greedy* avec la rĂ©fĂ©rence). + - Nous avons Ă©galement vu, dans les bases de code d'Ă©valuation, un certain nombre de tĂąches dĂ©finies comme « correspondance exacte », mais qui Ă©taient en fait des « correspondances exactes prĂ©fixes » (comparant uniquement le dĂ©but de la gĂ©nĂ©ration avec la rĂ©fĂ©rence), ou des « correspondances exactes suffixes » (le contraire), ou des « correspondances quasi exactes » (correspondances exactes avec une normalisation).
+→ Vous ne pouvez donc pas vous fier uniquement au nom de la mĂ©trique pour dĂ©terminer ce qui se passe, et vous devez examiner le code. +- **Normalisation diffĂ©rente** +En poursuivant l'exemple prĂ©cĂ©dent sur la « correspondance exacte », dans lm_eval v1, un certain nombre de tĂąches Ă©taient simplement nommĂ©es « correspondance exacte via gĂ©nĂ©ration » : on pourrait en dĂ©duire que la prĂ©diction est *comparĂ©e en tant que telle* Ă  une rĂ©fĂ©rence. +En regardant le code, la prĂ©diction passe en fait par une Ă©tape de normalisation (suppression de la ponctuation, homogĂ©nĂ©isation des nombres, etc.) avant d'ĂȘtre comparĂ©e Ă  la rĂ©fĂ©rence. Cela modifie Ă©videmment beaucoup les rĂ©sultats. +(La v2 de lm_eval inclut Ă  prĂ©sent le nom de la normalisation dans la plupart des noms des mĂ©triques.) +→ C'est l'une des sources d'erreurs la plus susceptible, en particulier pour les tĂąches qui nĂ©cessitent beaucoup de normalisation et de post-traitement des rĂ©ponses. Notamment lors d'Ă©valuations mathĂ©matiques oĂč vous souhaitez extraire la rĂ©ponse d'une explication gĂ©nĂ©rĂ©e. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### DiffĂ©rences au niveau des instructions + +3 Ă©lĂ©ments principaux peuvent entrer en jeu dans la variation au niveau des instructions. + +##### L'instruction elle-mĂȘme +Le format que vous utilisez pour l'instruction peut modifier et modifiera les scores de maniĂšre importante. + +Par exemple, pour les rĂ©ponses aux questions Ă  choix multiples, certains formats courants incluent des variations trĂšs simples dans la prĂ©sentation des choix, par exemple : +```markdown +Question: +Choices: +| A. | (A) | | +| B. | (B) | | +| C. | (C) | | +| D. | (D) | | +Answer: +``` +et prĂ©dire soit `A`/`B`/`C`/`D` ou ``. + +Ces instructions sont **sĂ©mantiquement Ă©quivalentes**, puisqu'ils contiennent exactement le mĂȘme contenu, mais ils peuvent nĂ©anmoins donner lieu Ă  une diffĂ©rence de *plusieurs points pour le mĂȘme modĂšle*. Nous avons fait quelques expĂ©riences Ă  ce sujet [ici](https://x.com/clefourrier/status/1777319187913875893/photo/1) et vous pouvez voir jusqu'Ă  7 points de diffĂ©rence pour le mĂȘme modĂšle (image ci-dessous). Un [papier a observĂ© des rĂ©sultats similaires](https://arxiv.org/abs/2310.11324). +""", unsafe_allow_html=True) +st.image("""https://pbs.twimg.com/media/GKpMq9zXEAAf9fv?format=png&name=small""", use_container_width=True) +st.markdown(""" +Certaines tĂąches sont Ă©galement prĂ©cĂ©dĂ©es d'une instruction particuliere (par exemple : « Les questions suivantes portent sur le < sujet > »). Sa prĂ©sence ou son absence affectera Ă©galement les scores. + +Cet [excellent papier](https://arxiv.org/abs/2407.07890) (⭐) met Ă©galement en Ă©vidence un effet secondaire de ce phĂ©nomĂšne : un certain nombre de modĂšles sont dĂ©sormais entraĂźnĂ©s Ă  surapprendre les instructions et les formats de rĂ©ponse des jeux d'Ă©valuation, au prix d'une adaptation Ă  d'autres instructions au moment de l'Ă©valuation. +C'est quelque chose que nous avons observĂ© sur l'*Open LLM Leaderboard 2* pour les modĂšles Llama3.1. Ils obtenaient de faibles scores bien que prĂ©disaient les bonnes rĂ©ponses Ă  nos Ă©valuations sur MATH-Hard. En effet, ils Ă©taient incapables de s'adapter aux exemples fournis car ils ont surappris l'instruction et le format de rĂ©ponse de GSM8K.""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +##### *Prompt* systĂšme et format de chat +Les formats de chat ont gĂ©nĂ©ralement Ă©tĂ© soumis Ă  un entraĂźnement d'instruction/de prĂ©fĂ©rence ou Ă  un *finetuning*. À ce stade, ils ont appris Ă  suivre des formats spĂ©cifiques lors de l'infĂ©rence. Par exemple, les modĂšles peuvent exiger de commencer les tours de dialogue par unz instruction gĂ©nĂ©rale (appelĂ© `system prompt`) prĂ©fixĂ© par des *tokens* spĂ©cifiques (gĂ©nĂ©ralement `System:`). Cette instruction est lĂ  pour fournir des instructions de haut niveau au modĂšle, comme le contenu d'un personnage, ou des instructions gĂ©nĂ©rales sur le style de rĂ©ponse. Les dialogues peuvent Ă©galement nĂ©cessiter l'ajout de mots clĂ©s prĂ©fixĂ©s au texte, comme `User` pour les requĂȘtes et `Assistant` pour les rĂ©ponses. + +En *few shot*, vous devez Ă©galement choisir si vous souhaitez que les exemples soient fournis Ă  tour de rĂŽle (en imitant les tours de l'utilisateur et de l'assistant) ou en une seule fois (dans une instruction unique de l'utilisateur). + +Ne pas suivre le format de chat attendu par le modĂšle lors de l'infĂ©rence nuira Ă  ses performances car le poussera en dehors de l'espace de probabilitĂ© sur lequel il a convergĂ©. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +##### Exemples + +Comme plus haut, faites attention aux graines alĂ©atoires. +Veilliez Ă  utiliser le **mĂȘme nombre d'Ă©chantillons** que la tĂąche de rĂ©fĂ©rence. +Vous devez aussi utiliser **les mĂȘmes Ă©chantillons** lors de la comparaison de modĂšles car l'utilisation d'Ă©chantillons diffĂ©rents modifiera les rĂ©sultats (ce qui n'est pas trĂšs surprenant, si nous supposons que certains Ă©chantillons expriment mieux la tĂąche que d'autres). +Plus surprenant peut-ĂȘtre : vous devez non seulement utiliser exactement les mĂȘmes Ă©chantillons, mais aussi les prĂ©senter dans le **mĂȘme ordre**. Varier l'ordre sur les mĂȘmes Ă©chantillons nous a permis d'observer jusqu'Ă  3 points de diffĂ©rence sur certains sous-ensembles de MMLU (vous pouvez voir [quelques rĂ©sultats ici](https://huggingface.co/blog/fr/evaluation-structured-outputs) (en français)). +""", unsafe_allow_html=True) +st.image("""https://pbs.twimg.com/media/GJ29DLNXAAAfJ2T?format=png&name=900x900""",use_container_width=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### DiffĂ©rences au niveau des paramĂštres de gĂ©nĂ©ration +Pour les Ă©valuations de gĂ©nĂ©rations, les paramĂštres auxquels il faut prĂȘter attention sont les suivants : +- s'assurer que vous utilisez le **mĂȘme *token* de fin de phrase** +- s'assurer que vous autorisez votre modĂšle Ă  **gĂ©nĂ©rer le mĂȘme nombre de *tokens*** +- s'assurer, en cas d'Ă©chantillonnage, que vous utilisez les **mĂȘmes paramĂštres tempĂ©rature / graine alĂ©atoire**. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### DiffĂ©rences au niveau du chargement du modĂšle +Quelques sources de diffĂ©rences que nous avons observĂ©es : +- **matĂ©riels diffĂ©rents**
Pytorch n'assure pas la reproductibilité des opérations non déterministes à travers le matériel. +- **bibliothÚques différentes**
Par exemple, si vous utilisez [transformers](https://github.com/huggingface/transformers) vs [vllm](https://github.com/vllm-project/vllm) comme *backend* pour l'infĂ©rence, les calculs de matrices ne sont pas gĂ©rĂ©s exactement de la mĂȘme maniĂšre. +- **tailles de batch diffĂ©rentes**
Il a été démontré dans plusieurs bibliothÚques d'évaluation et *backends* de modÚles que l'utilisation de différentes tailles de batch modifie les résultats de l'inférence. Si vous souhaitez des évaluations parfaitement reproductibles, vous devez fixer la taille du batch, bien que cela ne soit pas toujours possible en raison de problÚmes de mémoire. +- **précisions des poids différentes**
L'utilisation d'une prĂ©cision plus faible peut rĂ©duire les coĂ»ts de mĂ©moire et d'infĂ©rence mais modifiera Ă©galement les rĂ©sultats numĂ©riques puisque vous utilisez diffĂ©rentes versions des poids.""", unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("V.1._DĂ©panner l'infĂ©rence") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("V.3_DĂ©panner les problĂšmes mathĂ©matiques") \ No newline at end of file diff --git "a/pages/23_V.3_D\303\251panner les probl\303\250mes math\303\251matiques.py" "b/pages/23_V.3_D\303\251panner les probl\303\250mes math\303\251matiques.py" new file mode 100644 index 0000000000000000000000000000000000000000..ad5c9c0b9b34efbad79715ace4b7e0f7772d2b6b --- /dev/null +++ "b/pages/23_V.3_D\303\251panner les probl\303\250mes math\303\251matiques.py" @@ -0,0 +1,357 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown(r""" +## DĂ©panner les problĂšmes mathĂ©matiques +""") +st.markdown(""" """) +st.markdown(""" """) +st.markdown("""### Utilisation de $\LaTeX$ pour Ă©valuer sur le jeu d'Ă©valuation MATH""") +st.markdown(""" """) +st.markdown(""" +Parser le $\LaTeX$ est difficile. C'est un problĂšme pour Ă©valuer un modĂšle qui en attend en sortie. C'est le cas du [jeu d'Ă©valuation MATH](https://huggingface.co/datasets/lighteval/MATH) qui l'utilise pour reprĂ©senter des calculs et des symboles mathĂ©matiques. L'Ă©valuation de cette tĂąche consiste Ă  analyser les rĂ©fĂ©rences et les rĂ©sultats du modĂšle. + +Il s'avĂšre qu'il n'y a pas de bonne façon d'analyser le $\LaTeX$ : +""", unsafe_allow_html=True) +st.markdown(""" """) +st.image("./assets/sympy_doc.png", caption="TirĂ© de la documentation de la bibliothĂšque SymPy", use_container_width=True) +st.markdown(""" """) +st.markdown(r""" +La librairie [lm-evaluation-harness](https://github.com/EleutherAI/lm-evaluation-harness) utilise [SymPy](https://github.com/sympy/sympy) (une bibliothĂšque Python pour les mathĂ©matiques symboliques) pour analyser le $\LaTeX$ et comparer les expressions. +Lorsque l'on utilise SymPy pour essayer d'analyser les rĂ©fĂ©rences (contre elles-mĂȘmes), nous n'obtenons qu'une *accuracy* d'environ 0,94. +Comment cela est-il possible ? Il s'avĂšre que SymPy ne peut pas analyser certaines expressions (correctes en $\LaTeX$). + +Par exemple : + +``` +couldn't parse one of [0,1) or [0,1), I expected one of these: ']' +[0,1) +~~^ +``` +``` +couldn't parse one of (-\iny,-5]\cup[5,\iny) or (-\iny,-5]\cup[5,\iny), I expected something else here +(-\iny,-5]\cup[5,\iny) +~~~~~~^ +``` +``` +couldn't parse one of -\frac{1}{{}2x} or -\frac{1}{{}2x}, I don't understand this +-\frac{1}{{}2x} +~~~~~~~~~~~^ +``` +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(r""" +##### Comment contourner ce problĂšme ? + +Vous pouvez soit rĂ©Ă©crire la [grammaire](https://github.com/sympy/sympy/blob/master/sympy/parsing/latex/lark/grammar/latex.lark) de $\LaTeX$ en ajoutant les fonctionnalitĂ©s nĂ©cessaires au code, soit ajouter des vĂ©rifications manuelles Ă  votre code pour amĂ©liorer les scores des modĂšles. Nous avons optĂ© pour cette seconde option chez Hugging Face. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.image("./assets/lm_eval_diff.png", caption="Correction appliquĂ©e au code de LM Evaluation Harness") +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(r""" +##### RĂ©sultats + +Le tableau suivant compare les anciens et les nouveaux rĂ©sultats des 25 premiers modĂšles sur le jeu d'Ă©valuation : + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
Comparaison du parseur original et corrigé sur le jeu d'évaluation MATH
ModĂšle + Score + + Rang +
Parseur originalParseur corrigéParseur originalParseur corrigé
rombodawg/Rombos-LLM-V2.5-Qwen-72b47,5850,6811
MaziyarPanahi/calme-2.2-qwen2-72b41,1643,4322
arcee-ai/Arcee-Nova40,4842,9033
fblgit/TheBeagle-v2beta-32B-MGS39,4342,5244
rombodawg/Rombos-LLM-V2.5-Qwen-32b39,1241,9955
dnhkng/RYS-XLarge38,9741,2466
dfurman/CalmeRys-78B-Orpo-v0.137,9240,7187
MaziyarPanahi/calme-2.2-rys-78b37,9239,9589
MaziyarPanahi/calme-2.4-rys-78b37,6940,4198
MaziyarPanahi/calme-2.3-rys-78b36,5638,971010
MaziyarPanahi/calme-2.1-rys-78b36,4038,901111
Qwen/Qwen2.5-72B36,1038,671212
MaziyarPanahi/calme-2.1-qwen2-72b36,0338,071315
Qwen/Qwen2-Math-72B-Instruct35,9538,141414
dfurman/Qwen2-72B-Orpo-v0.135,4238,141513
abacusai/Smaug-Qwen2-72B-Instruct35,3537,461619
anthracite-org/magnum-v1-72b35,2737,691816
alpindale/magnum-72b-v135,2737,691816
Qwen/Qwen2-72B-Instruct35,1237,691918
dnhkng/RYS-XLarge-base34,6737,162020
Undi95/MG-FinalMix-72B33,6136,102221
abacusai/Dracarys-72B-Instruct33,6135,652222
Qwen/Qwen2.5-32B32,8535,502323
anthracite-org/magnum-v2-72b31,6534,062424
dnhkng/RYS-Huge-bnb-4bit31,5733,842525
+
+""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown("""### Correction du *leaderboard Open LLM* avec Math-Verify""") +st.markdown(""" """) +st.success("""Pendant de la traduction du guide, Hugging Face a publiĂ© un [article de blog](https://huggingface.co/blog/math_verify_leaderboard) sur l'utilisation de sa bibliothĂšque [Math-Verify](https://github.com/huggingface/Math-Verify) pour amĂ©liorer l'Ă©valuation des capacitĂ©s mathĂ©matiques des modĂšles de l'[*Open LLM Leaderboard*](https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard). +Nous avons dĂ©cidĂ© d'ajouter ci-dessous un rĂ©sumĂ© de cet article de blog qui n'est pas prĂ©sent dans le guide de ClĂ©mentine.""") +st.markdown(""" """) +st.markdown("""##### Pourquoi l'Ă©valuation des mathĂ©matiques dans l'*Open LLM Leaderboard* Ă©tait dĂ©faillante ? + +Une des taches d’évaluation de l’[*Open LLM Leaderboard*](https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard), appelĂ©e MATH-Hard, porte spĂ©cifiquement sur les problĂšmes de mathĂ©matiques : elle Ă©value la capacitĂ© des LLM Ă  rĂ©soudre des problĂšmes de mathĂ©matiques de niveau secondaire et universitaire, soit 1 324 problĂšmes rĂ©partis sur 7 sujets (prĂ©-calcul, prĂ©-algĂ©bre, algĂšbre, algĂšbre intermĂ©diaire, comptage/probabilitĂ© et thĂ©orie des nombres), en utilisant une approche 5-*shot* (le modĂšle reçoit 5 exemples dans l'instruction pour montrer comment il devrait rĂ©pondre). + +Une question typique se prĂ©sente comme suit : +``` +For all real numbers $r$ and $s$, define the mathematical operation $\#$ such that the following conditions apply: $r\ \#\ 0 = r, r\ \#\ s = s\ \#\ r$, and $(r + 1)\ \#\ s = (r\ \#\ s) + s + 1$. What is the value of $11\ \#\ 5$? + +# En français +Pour tous les nombres rĂ©els $r$ et $s$, on dĂ©finit l'opĂ©ration mathĂ©matique $\#$ telle que les conditions suivantes s'appliquent : $r\ \#\ 0 = r, r\ \#\ s = s\ \#\ r$, and $(r + 1)\ \#\ s = (r\ \#\ s) + s + 1$. Quelle est la valeur de $11 \#5$ ? +``` +et la rĂ©ponse attendue est +``` +71 +``` + +Dans le classement, les modĂšles doivent terminer leurs rĂ©ponses par une chaĂźne de caractĂšres trĂšs spĂ©cifique (suivant [Minerva-Math](https://arxiv.org/abs/2206.14858)) : +``` +“Final answer is [ANSWER]. I hope it is correct.”. +# “La rĂ©ponse finale est [ANSWER]. J'espĂšre qu'elle est correcte.”. +``` + +Le classement essayait alors d'analyser `[ANSWER]` avec [SymPy](https://docs.sympy.org/latest/index.html) pour le convertir en une reprĂ©sentation symbolique (et simplifier les valeurs si nĂ©cessaire), avant de le comparer Ă  la rĂ©ponse attendue. Toutefois, les utilisateurs ont signalĂ© un certain nombre de problĂšmes. + +Tout d'abord, un problĂšme rĂ©current Ă©tait l'incapacitĂ© de certains modĂšles Ă  suivre le format de rĂ©ponse attendu des exemples : ils produisaient d'autres phrases Ă  la place pour introduire leurs rĂ©ponses. Comme le format n'Ă©tait pas respectĂ©, les rĂ©ponses Ă©taient marquĂ©es comme fausses mĂȘme si elles Ă©taient en fait correctes ! + + +| 📄 Exemple | ❗ ProblĂšme | ✅ Math-Verify | 🛑 Ancien Leaderboard | +| --- | --- | --- | --- | +| Par consĂ©quent, le pĂ©rimĂštre de l'un de ces triangles est de $14 + 7\sqrt{2}$ pouces, exprimĂ© sous la forme la plus simple | Échec de l'extraction | `7*sqrt(2) + 14` | None | +| Par consĂ©quent, la somme de la sĂ©rie gĂ©omĂ©trique infinie est frac{7}{9}. | Échec de l'extraction | `7/9` | None | +| \( p(n) \) et \( p(n+1) \) partagent un facteur commun supĂ©rieur Ă  1 qui est boxed{41}. | Échec de l'extraction | `4` | None | + +L'Ă©tape suivante, la conversion de `[ANSWER]` en reprĂ©sentation symbolique, a Ă©galement posĂ© quelques problĂšmes, cette fois liĂ©s Ă  SymPy : + +| 📄 Exemple | ❗ ProblĂšme | ✅ Math-Verify | 🛑 Ancien Leaderboard | +| --- | --- | --- | --- | +| La rĂ©ponse finale est $2x + 4y + z - 19 = 0$. J'espĂšre que c'est correct. | Analyse partielle de l'Ă©quation paramĂ©trique | Eq(2*x + 4*y + z - 19, 0) | 0 | +| \(23\) | Échec de l'extraction en raison des balises LaTeX | `23` | None | +| \((- \infty, -14) \cup (-3, \infty)\). | Échec de l'extraction en raison de l'intervalle | Union(Interval.open(-oo, -14), Interval.open(-3, oo)) | None | + +Lors de la derniĂšre Ă©tape, la comparaison de la rĂ©ponse extraite avec la rĂ©ponse attendue posĂ© un certain nombre de problĂšmes : +| 📄 Exemple | ❗ ProblĂšme | ✅ Math-Verify | 🛑 Ancien Leaderboard | +| --- | --- | --- | --- | +| 1/3 == 0.333333 | Pas de support pour les arrondis | OK | KO | +| sqrt(1/2)*7 == sqrt(0.5)*7 | Pas de support d'Ă©valuation numĂ©rique | OK | KO | +| k = 1 == 1 | Pas de prise en charge de l'affectation de variables | OK | KO | + +**Tous ces problĂšmes sont maintenant complĂštement rĂ©solus avec le nouveau parseur de Math-Verify !** +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown("""##### Une redistribution complĂšte des modĂšles grĂące Ă  des Ă©valuations plus Ă©quitables +Ces corrections ont complĂštement remaniĂ© les 20 premiers modĂšles du sous-ensemble MATH du classement. +En moyenne, les modĂšles ont rĂ©solu **61 problĂšmes** de plus, ce qui Ă©quivaut Ă  une augmentation de **4,66 points** ! +""", unsafe_allow_html=True) +st.image('./assets/score-change.png') +st.markdown(""" """) +st.markdown(""" +Les deux sous-ensembles qui ont montrĂ© l'amĂ©lioration la plus significative Ă©taient tous deux liĂ©s Ă  l'algĂšbre (algĂšbre et prĂ©-algĂšbre) avec des gains de **8,27** et **6,93**, respectivement. Dans les cas extrĂȘmes, certains modĂšles ont montrĂ© des amĂ©liorations de prĂšs de **90** points sur ces sous-ensembles. +Nous pensons que ces sous-ensembles ont connu la plus grande amĂ©lioration parce qu'ils impliquent frĂ©quemment des rĂ©ponses prĂ©sentĂ©es sous forme d'ensembles (en raison des questions Ă  solutions multiples) et de matrices. Math-Verify a amĂ©liorĂ© sa gestion des deux types de rĂ©ponses, ce qui a contribuĂ© Ă  ces gains notables. +""", unsafe_allow_html=True) +st.image('./assets/subset-change.png') +st.markdown(""" """) +st.markdown(""" +Concernant le classement, **AceMath de Nvidia** domine dĂ©sormais MATH-Hard (fĂ©vrier 2025). +Un autre grand bĂ©nĂ©ficiaire de ce changement sont les dĂ©rivĂ©s de **Qwen**, qui sont maintenant presque exclusivement les seuls modĂšles classĂ©s juste en dessous d'AceMath. +Voici le tableau complet comparant l'ancien et le nouveau classement du Top 20 : +""", unsafe_allow_html=True) +st.image('./assets/math-hard-change.png') +st.markdown(""" """) +st.markdown(""" """) +st.markdown("""##### En rĂ©sumĂ© +Les dĂ©veloppeurs et les chercheurs sont encouragĂ©s Ă  adopter Math-Verify pour leurs propres Ă©valuations mathĂ©matiques. Ce faisant, vous pouvez vous assurer que vos modĂšles sont Ă©valuĂ©s avec des rĂ©sultats plus fiables. Par ailleurs, nous vous invitons Ă  consulter les classements mis Ă  jour et Ă  constater l'Ă©volution des performances de vos modĂšles prĂ©fĂ©rĂ©s. +""") +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("V.2._DĂ©panner la reproductibilitĂ©") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("Notebook") \ No newline at end of file diff --git a/pages/24_NOTEBOOK.py b/pages/24_NOTEBOOK.py new file mode 100644 index 0000000000000000000000000000000000000000..3a3b39a9e2e9a424cbce6c612b38bff166b7832d --- /dev/null +++ b/pages/24_NOTEBOOK.py @@ -0,0 +1,26 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown( + """ + ## Notebook 📓 + + Ce *notebook* vous explique comment dĂ©finir des variations d'instructions pour une tĂąche donnĂ©e, exĂ©cuter les Ă©valuations et analyser les rĂ©sultats. + + Hugging Face ne permettant pas d'afficher un *notebook* dans un Space (bien qu'hĂ©bergĂ© lui-mĂȘme sur son Hub), nous vous renvoyons Ă  l'adresse suivante pour pouvoir le consulter/tĂ©lĂ©charger : https://huggingface.co/spaces/CATIE-AQ/Guide_Evaluation_LLM/blob/main/comparing_task_formulations.ipynb + """, unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("V.3_DĂ©panner les problĂšmes mathĂ©matiques") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Ressources", use_container_width=True): + switch_page("Ressources") \ No newline at end of file diff --git a/pages/25_RESSOURCES.py b/pages/25_RESSOURCES.py new file mode 100644 index 0000000000000000000000000000000000000000..cf2e19f21a1c1e656f750af6a02ed60bf48f97ba --- /dev/null +++ b/pages/25_RESSOURCES.py @@ -0,0 +1,107 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown( + """ + ## Ressources 📚 + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown("""Quelques liens que j'apprĂ©cie sur l'Ă©valuation et le NLP.""") +st.markdown(""" """) + + +st.markdown( + """### Évaluation + +#### ThĂ©orie + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### GĂ©nĂ©ralitĂ©s +- [*Foundational Model Development Cheatsheet*](https://fmcheatsheet.org/) d'AllenAI. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Évaluation automatique +- Deux aperçus intĂ©ressants sur les dĂ©fis de l'Ă©valuation automatique ! + - [*Challenges in LM evaluation*](https://github.com/lm-evaluation-challenges/lm-evaluation-challenges.github.io/blob/main/%5BMain%5D%20ICML%20Tutorial%202024%20-%20Challenges%20in%20LM%20Evaluation.pdf), une prĂ©sentation par Hailey Schoelkopf et Lintang Sutawika. + - [*Lessons from the trenches on Reproducible Evaluation of LMs*](https://arxiv.org/abs/2405.14782), un papier d'EleutherAI. +- Deux podcasts de *Latent Space* sur l'Ă©valuation + - [*Benchmarks 101*](https://www.latent.space/p/benchmarks-101), sur l'historique des jeux d'Ă©valuation automatisĂ©s et les questions connexes bien connues. + - [*Benchmarks 201*](https://www.latent.space/p/benchmarks-201), sur la mĂ©thode d'Ă©valuation Ă  utiliser et Ă  quel moment, ainsi que quelques informations sur le *Leaderboard* avec votre serviteuse ! + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### *LLM-as-a-judge* +Des rĂ©sumĂ©s sympas et des retours d'expĂ©rience : +- https://eugeneyan.com/writing/llm-evaluators/ +- https://cameronrwolfe.substack.com/p/llm-as-a-judge +- https://dylandigitalgarden.com/2024/July/July+31%2C+2024+LLM+%26+VLM-as-a-Judge + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Software + +##### BibliothĂšques Python +- [`lm_eval`](https://github.com/EleutherAI/lm-evaluation-harness/) par Eleuther (Ă©galement connu sous le nom de « The Harness »).
La référence en matiÚre d'évaluation de LLM, vous permettant d'évaluer n'importe quel LLM de nombreux fournisseurs sur une série de *benchmarks*, d'une maniÚre stable et reproductible. +- [`lighteval`](https://github.com/huggingface/lighteval) par Hugging Face (avertissement : je suis l'une des auteurs).
Une suite d'évaluation LLM légÚre, centrée sur la personnalisation et les jeux d'évaluation récents. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Classements +- [*Open LLM Leaderboard*](https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard) par Hugging Face.
Évaluation indĂ©pendante et neutre des LLMs ouverts sur des jeux d'Ă©valuation statiques de rĂ©fĂ©rence (ouvert aux soumissions) +- [*HELM*](https://crfm.stanford.edu/helm/lite/latest/#/leaderboard) par Stanford.
Évalue Ă©galement les modĂšles sur des jeux d'Ă©valuation statiques, mais utilise les taux de victoire pour classer les modĂšles. +- [*Chatbot Arena*](https://huggingface.co/spaces/lmsys/chatbot-arena-leaderboard) par LMSys
Arena utilise l'évaluation humaine crowdsourcée pour noter 150 LLM. +- [*LLM Performance Leaderboard*](https://huggingface.co/spaces/ArtificialAnalysis/LLM-Performance-Leaderboard) par Artificial Analysis
Jeu d'Ă©valuation des performances et prix des plus grands fournisseurs d'API LLM, si vous souhaitez utiliser une API au lieu de faire fonctionner les choses localement. +- [*All our blogs about evaluations and leaderboards*](https://huggingface.co/blog?tag=leaderboard) +- [*Leaderboard finder*](https://huggingface.co/spaces/leaderboards/LeaderboardFinder)
Trouvez le classement le plus pertinent pour votre cas d'utilisation. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Tutoriels +- [*End-to-end custom domain evaluation tutorial*](https://github.com/argilla-io/argilla-cookbook/tree/main/domain-eval)
Ce tutoriel vous guide dans la construction d'une tùche d'évaluation personnalisée pour votre domaine. Il utilise des données synthétiques et une évaluation manuelle avec [Argilla](https://github.com/argilla-io/argilla/) et [distilabel](https://github.com/argilla-io/distilabel). + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown( + """### NLP + +##### Connaissances générales + +- [*NLP for You*](https://lena-voita.github.io/nlp_course.html) de Lena Voita.
L'un des meilleurs cours de NLP en ligne, vraiment pas Ă  pas et agrĂ©able Ă  lire. +- [Le cours de NLP đŸ€—](https://huggingface.co/learn/nlp-course/fr/chapter1/1) par Hugging Face (en français).
ExtrĂȘmement complet, avec de nombreux extraits de code pour que vous puissiez commencer rapidement ! + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +##### Comprendre les architectures des LLM +- [*The Annotated Encoder Decoder*](https://bastings.github.io/annotated_encoder_decoder/), par Jasmijn Bastings.
Vous guide à travers l'article de Bahdanau de 2015 introduisant l'encodeur-décodeur avec attention pour les réseaux récurrents, avec des explications de code à chaque étape. +- [*The Annotated Transformers*](https://nlp.seas.harvard.edu/2018/04/03/attention.html) de Sasha Rush.
Vous guide à travers l'article de Vaswani de 2016 introduisant les *transformers*, avec des explications de code à chaque étape. +- [*The Illustrated Transformers*](https://jalammar.github.io/illustrated-transformer/) par Jay Alammar ([version en français](https://lbourdois.github.io/blog/nlp/Transformer/)).
Bon complément au lien précédent, avec des visualisations au lieu de codes. +- [*The Annotated S4*](https://srush.github.io/annotated-s4/) de Sasha Rush.
Vous guide Ă  travers le papier *Structured State Space for Sequence Modeling* (S4), avec du code Ă  chaque Ă©tape. Si vous vous demandez ce que sont les modĂšles d'espace d'Ă©tat, jetez-y un coup d'Ɠil ! +- [*A Visual Guide to MoE*](https://newsletter.maartengrootendorst.com/p/a-visual-guide-to-mixture-of-experts) par Maarten Grootendorst.
Lisez d'abord l'un des guides sur les *transformers* ci-dessus, puis jetez un coup d'oeil Ă  ce guide ! Beaucoup de belles visualisations. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +##### Instructions (*Prompts*) +- [*Show me the prompt*](https://hamel.dev/blog/posts/prompt/) + """, unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("Notebook") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") \ No newline at end of file diff --git "a/pages/2_I.1._Inf\303\251rence_et_\303\251valuation_des_mod\303\250les.py" "b/pages/2_I.1._Inf\303\251rence_et_\303\251valuation_des_mod\303\250les.py" new file mode 100644 index 0000000000000000000000000000000000000000..655383c4bda87015b5015c9da2cc9b96cec8f013 --- /dev/null +++ "b/pages/2_I.1._Inf\303\251rence_et_\303\251valuation_des_mod\303\250les.py" @@ -0,0 +1,151 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown( + """ + ## InfĂ©rence et Ă©valuation des modĂšles + +### Introduction +Les grands modĂšles de langage actuels (LLM pour *Large Language Models*) fonctionnent de maniĂšre simple : Ă  partir d'un texte, ils apprennent Ă  prĂ©dire des suites plausibles. + +Cela se fait en deux Ă©tapes. +""", unsafe_allow_html=True) +st.markdown(""" """) + +st.markdown( + """ +##### TokĂ©nisation +Le texte d'entrĂ©e est d'abord divisĂ© en *tokens*, de petites unitĂ©s de texte (qui peuvent ĂȘtre un ou plusieurs caractĂšres, jusqu'au niveau du mot) associĂ©es chacune Ă  un nombre. L'ensemble des *tokens* qu'un modĂšle peut analyser est appelĂ© son *vocabulaire*.
+Pour comprendre cela plus en profondeur, lisez la page TokĂ©nisation. + """, unsafe_allow_html=True) +st.markdown(""" """) + +st.markdown( + """ +##### PrĂ©diction + """, unsafe_allow_html=True) + +st.image('./assets/llm_tk_1.png') +st.markdown(""" """) + +st.markdown( + """ +A partir de ce texte d'entrĂ©e, le LLM gĂ©nĂšre une distribution de probabilitĂ© des prochains *tokens* les plus probables sur l'ensemble du vocabulaire. Pour gĂ©nĂ©rer la sortie, nous pouvons prendre le *token* le plus probable (avec ou sans alĂ©a pour obtenir des rĂ©sultats plus intĂ©ressants), puis rĂ©pĂ©ter l'opĂ©ration, en utilisant le nouveau *token* comme fin de l'entrĂ©e, et itĂ©rer. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown( + """ +### Que voulez-vous prĂ©dire ? +Les Ă©valuations des LLM se rĂ©partissent principalement en deux catĂ©gories : +- Compte tenu d'une entrĂ©e et d'une (ou plusieurs) rĂ©ponse(s), quelle est la probabilitĂ© de cette (ces) rĂ©ponse(s) pour mon modĂšle ? +- Etant donnĂ© une entrĂ©e, quel texte mon modĂšle gĂ©nĂšre-t-il ? + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown( + """ +##### Évaluations basĂ©es sur la log-vraisemblance +Pour les Ă©valuations par log-vraisemblance, nous voulons connaĂźtre la probabilitĂ© conditionnelle d'un ou de plusieurs choix compte tenu d'une entrĂ©e. En d'autres termes, quelle est la probabilitĂ© d'obtenir une suite spĂ©cifique compte tenu d'une entrĂ©e ?
+Donc : +- nous concatĂ©nons chaque choix avec l'entrĂ©e, et les passons Ă  notre LLM, qui produit les logits de chaque *token* en fonction des prĂ©cĂ©dents +- nous ne gardons que les derniers logits (associĂ©s aux *tokens* des choix possibles), et appliquons une fonction log-softmax pour obtenir des log-probabilitĂ©s (oĂč l'intervalle est `[-inf, 0]` au lieu de `[0-1]`) +- nous additionnons ensuite les log-probabilitĂ©s de tous les *tokens* individuels pour obtenir la log-probabilitĂ© globale du choix +- nous pouvons enfin appliquer une normalisation basĂ©e sur la longueur des choix + """, unsafe_allow_html=True) + +st.image('./assets/llm_logprob.png') +st.markdown(""" """) +st.markdown( + """ +Cela nous permet d'appliquer l'une des mĂ©triques suivantes : +- obtenir la rĂ©ponse prĂ©fĂ©rĂ©e d'un modĂšle parmi plusieurs choix, comme dans l'image ci-dessus.
+Note : cela peut avantager des scores de modÚles qui auraient, librement, généré quelque chose d'autre, comme `Zygote` dans l'image. +- tester si un choix unique a une probabilité supérieure à 0,5 +- étudier la calibration du modÚle. Un modÚle bien calibré est un modÚle pour lequel les réponses correctes ont les probabilités les plus élevées.
+Pour en savoir plus sur la calibration, vous pouvez consulter [ce papier](https://arxiv.org/abs/2207.05221) d'Anthropic, sur ce que c'est, comment la dĂ©tecter, et comment entraĂźner les modĂšles pour qu'ils soient bien calibrĂ©s, et [ce papier](https://arxiv.org/abs/2311.14648) sur quelques limites possibles de la calibration. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown( + """ +##### Évaluations gĂ©nĂ©ratives +Pour une Ă©valuation gĂ©nĂ©rative, nous voulons le texte gĂ©nĂ©rĂ© par le modĂšle Ă©tant donnĂ© une entrĂ©e. + +Ce texte est obtenu de maniĂšre autorĂ©gressive : nous transmettons l'entrĂ©e au modĂšle, examinons le prochain *token* le plus probable, le sĂ©lectionnons comme Ă©tant le « premier *token* choisi » par le modĂšle, puis rĂ©pĂ©tons l'opĂ©ration jusqu'Ă  ce que nous atteignions une condition de fin de gĂ©nĂ©ration (longueur maximale, *token* spĂ©cial pour arrĂȘter la gĂ©nĂ©ration, etc.). Tous les *tokens* gĂ©nĂ©rĂ©s par le modĂšle sont considĂ©rĂ©s comme sa rĂ©ponse Ă  l'entrĂ©e. + """, unsafe_allow_html=True) + +st.image('./assets/llm_gen.png') +st.markdown(""" """) +st.markdown( + """ +Nous pouvons ensuite comparer cette gĂ©nĂ©ration avec des sorties de rĂ©fĂ©rences et Ă©valuer la distance entre les deux (en utilisant des mesures simples comme la [correspondance exacte](https://huggingface.co/spaces/evaluate-metric/exact_match), des mĂ©triques plus complexes comme [BLEU](https://huggingface.co/spaces/evaluate-metric/bleu), ou des *LLM-as-a-judge*). + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown( + """ +##### Aller plus loin +- ⭐ [Article de blog sur les diffĂ©rentes façons d'Ă©valuer MMLU](https://huggingface.co/blog/fr/open-llm-leaderboard-mmlu) (en français) par mon Ă©quipe Ă  Hugging Face.
Je vous recommande de le lire si vous souhaitez approfondir les différences entre les évaluations de log-vraisemblance à choix multiples et les évaluations génératives, y compris ce que cela peut signifier en ce qui concerne les changements de score. Les illustrations ci-dessus proviennent de cet article de blog et ont été réalisées par Thom Wolf. +- ⭐ [Une belle formalisation mathématique des méthodes d'inférence](https://arxiv.org/abs/2405.14782v2) d'EleutherAI.
Consultez directement l'annexe. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown( + """ +### Contraindre les sorties du modĂšle +Dans un certain nombre de cas, nous voulons que les sorties du modĂšle suivent un format spĂ©cifique, par exemple pour les comparer Ă  une rĂ©fĂ©rence. + """) +st.markdown(""" """) +st.markdown( + """ +##### En utilisant une instruction +La façon la plus simple de procĂ©der est d'ajouter une instruction contenant des dĂ©tails trĂšs spĂ©cifiques sur la façon dont le modĂšle doit rĂ©pondre (« Fournir des rĂ©ponses numĂ©riques en chiffres », « Ne pas utiliser d'abrĂ©viation », etc.). + +Cela ne fonctionnera pas nĂ©cessairement tout le temps, mais devrait ĂȘtre suffisant pour les modĂšles les plus performants. C'est l'approche que nous avons suivie dans le papier [GAIA](https://huggingface.co/papers/2311.12983), et vous pouvez trouver notre instruction dans l'onglet *Submission* du [leaderboard](https://huggingface.co/spaces/gaia-benchmark/leaderboard) si vous voulez vous en inspirer. + """, unsafe_allow_html=True) +st.markdown(""" """) + +st.markdown( + """ +##### *Few shot* et apprentissage en contexte +Une autre façon de procĂ©der consiste Ă  contraindre le modĂšle par ce que l'on appelle « l'apprentissage en contexte ». En fournissant des exemples dans l'instruction (ce qu'on appelle le « *few-shot prompting* »), le modĂšle est implicitement conditionnĂ© Ă  suivre la forme de l'instruction de l'Ă©chantillon rĂ©el. + +C'est une mĂ©thode qui fonctionnait globalement assez bien jusqu'Ă  la fin de l'annĂ©e 2023 ! +Cependant, l'adoption gĂ©nĂ©ralisĂ©e de mĂ©thodes d'[*intruction-tuning*](https://arxiv.org/abs/2308.10792) et l'ajout de donnĂ©es d'instruction dans les Ă©tapes suivant le prĂ©-entraĂźnement (prĂ©-entraĂźnement continu) semblent avoir biaisĂ© les modĂšles plus rĂ©cents vers des formats de sortie spĂ©cifiques (ce que l'on appelle [ici](https://arxiv.org/abs/2407.07890) « EntraĂźnement sur la tĂąche de test », et ce que j'appellerais « surentraĂźnement au format de l'instruction »). C'est aussi une mĂ©thode qui peut ĂȘtre limitĂ©e pour les modĂšles plus anciens avec des tailles de contexte plus petites, car certains exemples *few-shot* peuvent ĂȘtre trop longs pour la taille de contexte possible. + """, unsafe_allow_html=True) +st.markdown(""" """) + +st.markdown( + """ +##### GĂ©nĂ©ration de texte structurĂ©e +La gĂ©nĂ©ration structurĂ©e contraint les sorties Ă  suivre un chemin donnĂ©, dĂ©fini par une grammaire ou par des expressions rĂ©guliĂšres, par exemple. La bibliothĂšque [*outlines*](https://github.com/dottxt-ai/outlines) implĂ©mente cette approche en utilisant des machines Ă  Ă©tats finis. D'autres approches existent, comme l'utilisation de la gĂ©nĂ©ration entrelacĂ©e pour la gĂ©nĂ©ration json. + +Pour mieux comprendre ce qui se passe lorsque l'on utilise la gĂ©nĂ©ration structurĂ©e, vous pouvez consulter l'article de [blog](https://huggingface.co/blog/fr/evaluation-structured-outputs) (en français) que nous avons Ă©crit. La gĂ©nĂ©ration structurĂ©e rĂ©duit la variance des rĂ©sultats d'Ă©valuation, et rend les classements plus stables. Vous pouvez Ă©galement consulter cet article de [blog](https://blog.dottxt.co/) pour des implĂ©mentations et des observations intĂ©ressantes liĂ©es Ă  la gĂ©nĂ©ration structurĂ©e. + +Cependant, des [recherches](https://arxiv.org/abs/2408.02442) rĂ©centes semblent montrer que la gĂ©nĂ©ration structurĂ©e peut diminuer les performances du modĂšle sur certaines tĂąches (comme le raisonnement), en Ă©loignant trop l'a priori de la distribution de probabilitĂ© attendue. + """, unsafe_allow_html=True) +st.markdown(""" """) + +st.markdown( + """ +##### Aller plus loin +- ⭐ [Comprendre une machine Ă  Ă©tats finis pour la gĂ©nĂ©ration structurĂ©e](https://blog.dottxt.co/coalescence.html) par Outlines. Un guide trĂšs clair sur le fonctionnement de leur mĂ©thode ! +- [Le papier de la mĂ©thode *outlines*](https://arxiv.org/abs/2307.09702), une explication plus acadĂ©mique du lien prĂ©cĂ©dent. +- [GĂ©nĂ©ration entrelacĂ©e](https://github.com/guidance-ai/guidance?tab=readme-ov-file#guidance-acceleration), une autre mĂ©thode pour limiter les gĂ©nĂ©rations pour certains formats de sortie spĂ©cifiques. +- [Cette recette montrant comment appliquer la gĂ©nĂ©ration structurĂ©e Ă  un systĂšme de RAG](https://huggingface.co/learn/cookbook/fr/structured_generation) (en français). + """, unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("I._CONNAISSANCES GÉNÉRALES") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("I.2._TokĂ©nisation") \ No newline at end of file diff --git "a/pages/3_I.2._Tok\303\251nisation.py" "b/pages/3_I.2._Tok\303\251nisation.py" new file mode 100644 index 0000000000000000000000000000000000000000..5bf9c88b085328d208bd19433a967cfb153bda6d --- /dev/null +++ "b/pages/3_I.2._Tok\303\251nisation.py" @@ -0,0 +1,115 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown( + """ + ## TokĂ©nisation + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Pourquoi et comment tokĂ©niser un texte ? +Étant donnĂ© que les grands modĂšles de langage sont en rĂ©alitĂ© de grandes fonctions mathĂ©matiques, ils traitent des nombres et non du texte. + +Supposons que vous souhaitiez transformer une phrase en chiffres. Vous devez d'abord dĂ©cider comment dĂ©couper votre phrase en petits morceaux, puis faire correspondre chaque petit morceau Ă  un nombre ; c'est ce qu'on appelle la *tokĂ©nisation*. + +Dans le passĂ©, les gens essayaient de faire correspondre chaque caractĂšre d'un texte avec son index dans un alphabet (`a` -> 1, `b` -> 2, etc.), ce qui est appelĂ© la *tokĂ©nisation basĂ©e sur les caractĂšres*. +De l'autre cĂŽtĂ© du spectre, les gens essayaient aussi de faire correspondre chaque mot avec son index dans un dictionnaire (`a` -> 1, `aardvark` -> 2, `ab` -> 3, etc), ce qui est appelĂ© la *tokĂ©nisation basĂ©e sur les mots* (vous sĂ©parez sur les espaces si votre langue en a, si ce n'est pas le cas c'est un peu plus difficile). + +Ces deux mĂ©thodes ont une limite importante : elles suppriment des informations du texte d'entrĂ©e. Elles effacent les connexions sĂ©mantiques que vous pouvez voir dans la forme des mots (ex : `dis similar`, `similar`, `similar ity`, `similar ly`), des informations que nous voudrions que notre modĂšle conserve, afin qu'il relie les mots apparentĂ©s entre eux.
+De plus, que se passe-t-il si vous avez soudainement un mot complĂštement nouveau en entrĂ©e ? Il ne reçoit pas de numĂ©ro et votre modĂšle ne peut pas le traiter 😔. + +Certains ont donc eu l'idĂ©e de dĂ©couper les mots en sous-mots, et d'attribuer un index Ă  ces sous-mots (`dis`, `similar`, `ity`, `ly`) ! + +À l'origine, on utilisait des rĂšgles morpho-syntaxiques (la « morpho-syntaxe » est comme la grammaire de la crĂ©ation des mots). Aujourd'hui, la plupart des gens utilisent l'encodage par paire d'octets (*byte pair encoding* ou BPE), une mĂ©thode statistique intelligente pour crĂ©er automatiquement les sous-mots en fonction de leur frĂ©quence dans un texte de rĂ©fĂ©rence. + +En rĂ©sumĂ©, la tokĂ©nisation est un moyen de mettre en correspondance de petites unitĂ©s de texte (qui peuvent ĂȘtre un ou plusieurs caractĂšres, jusqu'au niveau du mot) avec des nombres (similaires Ă  un index). Lorsque vous souhaitez traiter du texte, votre texte d'entrĂ©e est divisĂ© en ces *tokens* par un *tokenizer*. L'ensemble des *tokens* qu'un modĂšle ou un *tokenizer* peut analyser est appelĂ© son *vocabulaire*. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Aller plus loin : Comprendre la tokĂ©nisation +Je conseille de lire l'un des 2 premiers liens en profondeur. +- ⭐ [Explication des diffĂ©rentes mĂ©thodes de tokĂ©nisation dans le cours de NLP d'Hugging FaceđŸ€—](https://huggingface.co/learn/nlp-course/fr/chapter2/4) (en français) +- ⭐ [Guide conceptuel sur la tokĂ©nisation dans la documentation de transformers đŸ€—](https://huggingface.co/docs/transformers/en/tokenizer_summary) +- [Cours de Jurafsky sur la tokĂ©nisation (et d'autres choses)](https://web.stanford.edu/~jurafsky/slp3/2.pdf), plus acadĂ©mique dans son approche, passez aux points 2.5 et 2.6 (le reste est Ă©galement intĂ©ressant mais trop large). + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Aller plus loin : *Byte Pair Encoding* +- ⭐ [Explication du BPE dans le cours de NLP d'Hugging FaceđŸ€—](https://huggingface.co/learn/nlp-course/fr/chapter6/5) (en français) +- [Papier introduisant le BPE au domaine du NLP](https://aclanthology.org/P16-1162/) + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Quelques-uns des nombreux problĂšmes de tokĂ©nisation +##### Choisir la bonne taille de vocabulaire +La taille du vocabulaire indique le nombre de *tokens* individuels (par exemple, les sous-mots) que le modĂšle devra apprendre.
+Un vocabulaire **trop grand** peut contenir des mots trĂšs rares comme *tokens* (par exemple : `aardvark`), ce qui peut conduire Ă  2 problĂšmes.
+Si un tel mot rare n'apparaĂźt presque jamais dans les donnĂ©es d'entraĂźnement, il peut ĂȘtre difficile de le relier Ă  d'autres concepts, et le modĂšle peut ĂȘtre incapable de dĂ©duire de quoi il s'agit.
+D'un autre cĂŽtĂ©, s'il apparaĂźt rarement et uniquement dans des contextes spĂ©cifiques, il peut ĂȘtre liĂ© Ă  d'autres mots trĂšs spĂ©cifiques : par exemple, si vous entraĂźnez sur des donnĂ©es de forum, et que votre *tokenizer* associe un nom d'utilisateur Ă  un seul *token* dans son vocabulaire, votre modĂšle peut alors associer ce *token* au contenu de l'utilisateur en question. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +Un vocabulaire **trop petit** prĂ©sentera deux autres problĂšmes : des capacitĂ©s de reprĂ©sentation moindres et un coĂ»t accru lors de l'infĂ©rence. + +Revenons Ă  notre exemple ci-dessus, oĂč nous avons tokĂ©nisĂ© les mots dĂ©rivĂ©s de `similar`. L'utilisation d'une approche pseudo-BPE (grand vocabulaire) pour tokĂ©niser `similarly` divise le mot en 2 *tokens* (`similaire`, `ly`). Si nous avions plutĂŽt utilisĂ© une tokĂ©nisation au niveau du caractĂšre (donc avec un trĂšs petit vocabulaire, de la taille d'un alphabet), le mĂȘme mot aurait Ă©tĂ© dĂ©coupĂ© en 9 *tokens* (`s`, `i`, `m`, `i`, `l`, `a`, `r`, `l`, `y`).
+Alors que la premiĂšre mĂ©thode divise `similarly` en *tokens* qui ont une signification sĂ©mantique individuelle, ce n'est pas le cas dans la seconde mĂ©thode. Avec un vocabulaire trop petit, nous avons perdu une partie de la reprĂ©sentation sĂ©mantique. La diffĂ©rence de longueur des reprĂ©sentations signifie Ă©galement qu'il est beaucoup plus coĂ»teux de gĂ©nĂ©rer notre mot avec un vocabulaire plus petit (il faut 9 *tokens* au lieu de 2, donc 4,5 fois plus coĂ»teux !) + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +Pour l'instant, la plupart des gens semblent utiliser une heuristique pour la taille du vocabulaire, qui semble corrĂ©lĂ©e au nombre de langues couvertes et Ă  la taille du modĂšle. Il est donc probable que l'utilisation d'un nombre de *tokens* proche des modĂšles de rĂ©fĂ©rence d'une taille similaire puisse vous convenir. + """, unsafe_allow_html=True) +st.success(""" + Pour entraĂźner un modĂšle de maniĂšre efficiente, il est primordial d'utiliser un multiple de 8 ou de 64 pour la taille du vocabulaire afin d'optimiser les capacitĂ©s de votre GPU. Voir la documentation de NVIDIA [ici](https://docs.nvidia.com/deeplearning/performance/dl-performance-matrix-multiplication/index.html#requirements-tc) et [ici](https://developer.nvidia.com/blog/optimizing-gpu-performance-tensor-cores/) pour dĂ©terminer le bon multiple en fonction de la prĂ©cision dĂ©sirĂ©e.""") +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Gestion de plusieurs langues + """, unsafe_allow_html=True) +st.markdown(""" """) +st.info("""Il est recommandĂ© d'avoir lu une explication du BPE avant de se pencher sur cette section.""") +st.markdown(""" +Lorsque vous construisez ou choisissez votre *tokenizer*, vous construisez votre vocabulaire Ă  partir d'un texte de rĂ©fĂ©rence. Cela signifie que votre *tokenizer* connaĂźtra les mots de vocabulaire et les caractĂšres de ce texte de rĂ©fĂ©rence. En gĂ©nĂ©ral, cela signifie que vous utilisez des donnĂ©es en anglais, avec un script latin. + +Si vous voulez ajouter une nouvelle langue, et que cette nouvelle langue utilise le mĂȘme script et partage certaines racines, vous pouvez thĂ©oriquement espĂ©rer qu'une partie de la sĂ©mantique de votre langue d'origine soit transfĂ©rĂ©e Ă  la nouvelle langue. + +Cependant, si vous voulez permettre Ă  votre *tokenizer* de dĂ©couper correctement du texte dans d'autres langues (en particulier des langues Ă©crites dans d'autres scripts), vous feriez mieux d'inclure des donnĂ©es de ces langues lors de la construction dudit *tokenizer*. La plupart du temps, cependant, ces donnĂ©es contiendront une proportion dĂ©sĂ©quilibrĂ©e de la langue initiale (ex : anglais) par rapport Ă  la nouvelle langue (ex : thaĂŻ ou birman), la langue initiale Ă©tant beaucoup plus prĂ©sente. Étant donnĂ© que les mĂ©thodes de tokĂ©nisation les plus efficaces utilisĂ©es de nos jours (comme BPE) crĂ©ent leurs *tokens* de vocabulaire complexe sur la base des mots les plus frĂ©quents, la plupart des longs *tokens* seront des mots anglais - et la plupart des mots des langues moins frĂ©quentes ne seront scindĂ©s qu'au niveau des caractĂšres. + +Cet effet entraĂźne une injustice dans la tokĂ©nisation multilingue : certaines langues (moins frĂ©quentes ou **moins bien dotĂ©es en ressources**) nĂ©cessitent des ordres de grandeur de *tokens* supplĂ©mentaires pour gĂ©nĂ©rer une phrase de longueur Ă©quivalente Ă  celle de l'anglais. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Aller plus loin : Langue et tokĂ©nisation +- ⭐ [Une belle analyse et dĂ©monstration de Yennie Jun sur les problĂšmes de tokĂ©nisation dans les diffĂ©rentes langues](https://www.artfish.ai/p/all-languages-are-not-created-tokenized)
La dĂ©composition en elle-mĂȘme est trĂšs claire, et cela vaut la peine de jouer avec la [dĂ©mo](https://huggingface.co/spaces/yenniejun/tokenizers-languages). +- ⭐ [Une dĂ©monstration d'Aleksandar Petrov sur les injustices de la tokĂ©nisation](https://aleksandarpetrov.github.io/tokenization-fairness/)
Je recommande de regarder « Compare tokenization of sentences » pour avoir une idĂ©e des diffĂ©rences de coĂ»t d'infĂ©rence en fonction de la langue. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Qu'en est-il des nombres ? +Lorsque vous construisez votre *tokenizer*, vous devez dĂ©cider de ce que vous allez faire des nombres. Faut-il indexer uniquement les chiffres de 0 Ă  9 et supposer que tous les autres nombres seront des compositions de chiffres, ou veut-on stocker les nombres jusqu'Ă , disons, un milliard, individuellement ? Les modĂšles actuels bien connus prĂ©sentent une sĂ©rie d'approches Ă  cet Ă©gard, mais on ne sait pas exactement ce qui fonctionne le mieux pour permettre un raisonnement mathĂ©matique. Peut-ĂȘtre que de nouvelles approches de tokĂ©nisation, telles que la tokĂ©nisation hiĂ©rarchique, pourraient ĂȘtre nĂ©cessaires pour cela. + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" +##### Aller plus loin : TokĂ©nisation des nombres +- ⭐ [Une belle dĂ©monstration visuelle par Yennie Jun sur la façon dont les *tokenizers* des modĂšles d'Anthropic, Meta, OpenAI, et Mistral divisent les nombres](https://www.artfish.ai/p/how-would-you-tokenize-or-break-down). +- [Petite histoire de l'Ă©volution de la tokĂ©nisation des nombres au fil des annĂ©es par Beren Millidge](https://www.beren.io/2024-05-11-Integer-tokenization-is-now-much-less-insane/). + """, unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("I.1._InfĂ©rence et Ă©valuation des modĂšles") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Chapitre suivant", use_container_width=True): + switch_page("II._JEUX_D'ÉVALUATION_AUTOMATISÉS") \ No newline at end of file diff --git "a/pages/4_II._BENCHMARKS_AUTOMATIS\303\211S.py" "b/pages/4_II._BENCHMARKS_AUTOMATIS\303\211S.py" new file mode 100644 index 0000000000000000000000000000000000000000..fc369ba78c313aafe54f16121f1518708ba4ab76 --- /dev/null +++ "b/pages/4_II._BENCHMARKS_AUTOMATIS\303\211S.py" @@ -0,0 +1,23 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown("""## *Benchmarks* automatisĂ©s""") +st.markdown(""" """) + +st.markdown(""" +Dans ce chapitre, nous dĂ©finissons ce que sont que des *benchmarks* automatisĂ©s et comment les concevoir. Nous listons Ă©galement plusieurs jeux de donnĂ©es utilisables dans ce contexte. Nous terminons par des conseils et astuces utiles Ă  connaĂźtre sur ce sujet.""") + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("I.2._TokĂ©nisation") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("II.1._Bases") \ No newline at end of file diff --git "a/pages/4_II._JEUX_D'\303\211VALUATION_AUTOMATIS\303\211S.py" "b/pages/4_II._JEUX_D'\303\211VALUATION_AUTOMATIS\303\211S.py" new file mode 100644 index 0000000000000000000000000000000000000000..0365eb33246ef6c114561a7804c480257ca5b7d8 --- /dev/null +++ "b/pages/4_II._JEUX_D'\303\211VALUATION_AUTOMATIS\303\211S.py" @@ -0,0 +1,23 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown("""## Jeux d'Ă©valuation automatisĂ©s""") +st.markdown(""" """) + +st.markdown(""" +Dans ce chapitre, nous dĂ©finissons ce que sont que des jeux d'Ă©valuation automatisĂ©s et comment les concevoir. Nous listons Ă©galement plusieurs jeux de donnĂ©es utilisables dans ce contexte. Nous terminons par des conseils et astuces utiles Ă  connaĂźtre sur ce sujet.""") + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("I.2._TokĂ©nisation") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("II.1._Bases") \ No newline at end of file diff --git a/pages/5_II.1._Bases.py b/pages/5_II.1._Bases.py new file mode 100644 index 0000000000000000000000000000000000000000..7f16d53bf7a740b45882aab7427dbf6a20d81db4 --- /dev/null +++ b/pages/5_II.1._Bases.py @@ -0,0 +1,73 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown( + """ + ## Bases + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.info("""Une partie de ce texte recoupe [mon article de blog gĂ©nĂ©ral sur l'Ă©valuation](https://huggingface.co/blog/clefourrier/llm-evaluation).""") + +st.markdown(""" """) +st.markdown(""" """) + +st.markdown( + """ + ### Que sont les jeux d'Ă©valuation automatisĂ©s ? + +Les jeux d'Ă©valuation automatisĂ©s fonctionnent gĂ©nĂ©ralement de la maniĂšre suivante : vous souhaitez connaĂźtre les performances de votre modĂšle sur quelque chose. Il peut s'agir d'une **tĂąche** concrĂšte bien dĂ©finie, telle que « Dans quelle mesure mon modĂšle peut-il classer les courriels en spam ou non ? », ou d'une **capacitĂ©** plus abstraite et gĂ©nĂ©rale, telle que « Dans quelle mesure mon modĂšle est-il bon en maths ? » + +À partir de lĂ , vous construisez une Ă©valuation, en utilisant :
+- un **jeu de données**, composé d'**échantillons**.
+ - Ces échantillons contiennent une entrée pour le modÚle, parfois associée à une référence à laquelle comparer les sorties du modÚle.
+ - Les échantillons sont généralement conçus pour essayer d'émuler ce sur quoi vous voulez tester le modÚle. Par exemple, si vous étudiez la classification de courriels, vous créez un jeu de données de courriels spam et non spam, vous essayez d'inclure quelques cas difficiles, etc.
+- une **métrique**.
+ - La métrique est un moyen d'évaluer votre modÚle.
+ Exemple : quelle est la précision avec laquelle votre modÚle peut classer les spams (score d'un échantillon bien classé = 1, mal classé = 0).
+ - Les métriques utilisent les sorties de votre modÚle pour effectuer cette notation. Dans le cas des LLM, les gens considÚrent généralement deux types de sorties :
+ - le texte généré par le modÚle suite à l'entrée (*évaluation générative*)
+ - la log-probabilité d'une ou plusieurs séquences fournies au modÚle (*évaluations à choix multiples*, parfois appelées MCQA, ou *évaluations de perplexité*).
+Pour plus d'informations, vous pouvez consulter la page InfĂ©rence et Ă©valuation des modĂšles. + +Il est primordial d'Ă©valuer sur des donnĂ©es sur lesquelles le modĂšle n'a jamais Ă©tĂ© exposĂ© auparavant (donnĂ©es absentes de l'Ă©chantillon d'entraĂźnement du modĂšle), parce que vous voulez tester s'il **gĂ©nĂ©ralise** bien. Par exemple, s'il peut classer des spams concernant des produits de « santĂ© » aprĂšs n'avoir vu que des spams concernant de fausses banques. + """, unsafe_allow_html=True) + +st.info("""Un modĂšle qui ne peut prĂ©dire correctement que sur ses donnĂ©es d'entraĂźnement (et qui n'a pas appris de maniĂšre latente des motifs gĂ©nĂ©raux de plus haut niveau) est considĂ©rĂ© comme **surentraĂźnĂ©**. De la mĂȘme maniĂšre qu'un Ă©tudiant qui apprend les questions de test par cƓur sans comprendre le sujet, Ă©valuer les LLM sur des donnĂ©es qui Ă©taient dĂ©jĂ  prĂ©sentes dans leur Ă©chantillon d'entraĂźnement revient Ă  les noter sur des capacitĂ©s qu'ils ne possĂšdent pas.""") + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown( + """### Avantages et inconvĂ©nients de l'utilisation de jeux d'Ă©valuation automatisĂ©s + +Les jeux d'Ă©valuation automatisĂ©s prĂ©sentent les avantages suivants ➕ :
+- **Consistance et reproductibilité**
Vous pouvez exĂ©cuter le mĂȘme jeu d'Ă©valuation automatisĂ© sur le mĂȘme modĂšle 10 fois de suite et vous obtiendrez les mĂȘmes rĂ©sultats (Ă  l'exception des variations matĂ©rielles ou du caractĂšre alĂ©atoire inhĂ©rent au modĂšle). Cela signifie que vous pouvez facilement crĂ©er des classements Ă©quitables de modĂšles pour une tĂąche donnĂ©e.
+- **Un passage à l'échelle à un coût limité**
Ils constituent l'un des moyens les moins coûteux d'évaluer les modÚles à l'heure actuelle.
+- **Compréhension**
La plupart des métriques automatisés sont trÚs faciles à comprendre.
+ Par exemple, l'[exact match](https://huggingface.co/spaces/evaluate-metric/exact_match) vous dira si le texte généré correspond parfaitement à la référence, et l'[*accuracy*](https://huggingface.co/spaces/evaluate-metric/accuracy) vous dira dans quelle proportion le choix sélectionné était le bon (ce sera un peu moins le cas pour des métriques telles que [BLEU](https://huggingface.co/spaces/evaluate-metric/bleu) ou [ROUGE](https://huggingface.co/spaces/evaluate-metric/rouge)).
+- **Qualité du jeu de données**
Un certain nombre de jeux d'évaluation automatisés utilisent des jeux de données générés par des experts ou des données préexistantes de haute qualité (comme [MMLU](https://huggingface.co/datasets/cais/mmlu) ou [MATH](https://github.com/openai/prm800k/tree/main?tab=readme-ov-file#math-splits)). Cependant, cela ne signifie pas qu'ils sont parfaits. Pour MMLU, plusieurs erreurs ont été identifiées dans les échantillons, allant de problÚmes de parsage à des questions vide de sens, ce qui a conduit à la création de plusieurs jeux de données corrigés, comme [MMLU-Pro](https://huggingface.co/datasets/TIGER-Lab/MMLU-Pro) et [MMLU-Redux](https://huggingface.co/datasets/edinburgh-dawg/mmlu-redux).
+ +Cependant, ils prĂ©sentent Ă©galement les limites suivantes ➖ :
+- **Utilisation restreinte pour des tĂąches plus complexes**
Les jeux d'évaluation automatisés fonctionnent bien pour les tùches dont les performances sont faciles à définir et à évaluer (par exemple, la classification). En revanche, les capacités plus complexes sont plus difficiles à décomposer en tùches bien définies et précises.
+ Par exemple, que signifie « ĂȘtre bon en maths » ? S'agit-il d'ĂȘtre bon en arithmĂ©tique ? En logique ? Être capable de raisonner sur de nouveaux concepts mathĂ©matiques ? + Cela a conduit Ă  l'utilisation d'Ă©valuations plus **gĂ©nĂ©ralistes**, qui ne dĂ©composent plus les capacitĂ©s en sous-tĂąches, mais qui supposent que la performance gĂ©nĂ©rale sera un **bon indicateur** de ce que nous cherchons Ă  mesurer.
+- **Contamination**
Une fois qu'un jeu de donnĂ©es est publiĂ© publiquement, il se retrouvera dans les jeux de donnĂ©es d'entraĂźnement des modĂšles. Cela signifie que vous n'avez aucune garantie, lorsque vous Ă©valuez un modĂšle, qu'il n'a pas dĂ©jĂ  vu les donnĂ©es d'Ă©valuation. + """, unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("II._JEUX_D'ÉVALUATION_AUTOMATISÉS") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("II.2._Concevoir_votre_Ă©valuation_automatisĂ©e") \ No newline at end of file diff --git "a/pages/6_II.2._Concevoir_votre_\303\251valuation_automatis\303\251e.py" "b/pages/6_II.2._Concevoir_votre_\303\251valuation_automatis\303\251e.py" new file mode 100644 index 0000000000000000000000000000000000000000..3b720f88b0f901749e4d9c61a2f429653fd5fd3c --- /dev/null +++ "b/pages/6_II.2._Concevoir_votre_\303\251valuation_automatis\303\251e.py" @@ -0,0 +1,193 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown( + """ + ## Concevoir votre Ă©valuation automatisĂ©e + """, unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + + +st.markdown( + """ + ### Choisir un jeu de donnĂ©es + +Pour votre Ă©valuation, vous pouvez soit sĂ©lectionner un jeu de donnĂ©es existant (voir la section suivante pour des exemples), soit concevoir votre propre jeu de donnĂ©es. Tout au long de ce processus, il est trĂšs important de garder Ă  l'esprit que **votre rĂ©sultat d'Ă©valuation sera uniquement aussi bon que votre jeu de donnĂ©es d'Ă©valuation**. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown(""" +#### SĂ©lection d'un jeu de donnĂ©es existant +Vous devez impĂ©rativement regarder les composants suivants. + +##### Processus de crĂ©ation +- **Qui a crĂ©Ă© les Ă©chantillons ?**
+Selon moi : un jeu de données créé par un expert **>** un jeu de données d'annotateurs rémunérés **~** jeu de données crowdsourcé **>** un jeu de données MTurked.
+Il est important de rechercher une carte de donnĂ©es oĂč vous trouverez des donnĂ©es socio-dĂ©mographiques sur les annotateurs pouvant ĂȘtre importante pour comprendre la diversitĂ© linguistique du jeu de donnĂ©es. + +- **Les Ă©chantillons ont-ils Ă©tĂ© examinĂ©s par d'autres annotateurs ou par les auteurs eux-mĂȘmes?**
+Vous voulez savoir :
+ - si le score inter-annotateurs sur les échantillons est élevé (= les annotateurs sont-ils d'accord ?)
+ - et/ou si le jeu de données complet a été examiné par les auteurs.
+Ceci est particuliÚrement important pour les jeux de données avec l'aide d'annotateurs sous-payés qui ne sont généralement pas des locuteurs natifs de votre langue cible (c'est souvent le cas pour AWS Mechanical Turk par exemple), car vous pourriez autrement trouver des fautes de frappe/des erreurs grammaticales/des réponses absurdes. + +- **Les annotateurs ont-ils reçu des directives claires pour la création des données ?**
+En d'autres termes, votre jeu de donnĂ©es est-il cohĂ©rent ? +""", unsafe_allow_html=True) +st.markdown(""" """) + +st.markdown(""" +##### Échantillons +PrĂ©levez 50 Ă©chantillons au hasard et inspectez-les manuellement :
+- *Pour la qualité* :
+ - les questions sont-elles claires et sans ambiguïté ?
+ - les réponses sont-elles correctes ? (ex : [TriviaQA](https://huggingface.co/datasets/mandarjoshi/trivia_qa) contient plusieurs réponses de référence (champ des alias) parfois contradictoires.)
+ - des informations sont-elles manquantes ? (ex : [MMLU](https://huggingface.co/datasets/cais/mmlu) manque de schémas de référence dans un certain nombre de questions.)
+- *Pour la pertinence par rapport Ă  votre tĂąche* :
+ - ces questions correspondent-elles au type de questions sur lesquelles vous souhaitez Ă©valuer un LLM ?
+ - ces exemples correspondent-ils Ă  votre cas d'utilisation ?
+ +Vous voulez également savoir combien d'échantillons sont présents (pour vous assurer que les résultats sont statistiquement significatifs, 100 échantillons sont généralement un minimum pour les jeux d'évaluation automatisés). +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown(""" +#### Conception de votre propre jeu de données +Vous avez trois possibilités pour concevoir votre propre jeu de données.
+""", unsafe_allow_html=True) +st.markdown(""" """) + +st.markdown(""" +##### Agrégation de données existantes +Vous pouvez agréger des données existantes provenant de différentes sources, en évaluant une capacité pertinente pour votre tùche. Un certain nombre de jeux de données d'évaluation sont par exemple construits à partir de l'agrégation de jeux de données d'évaluation humaine (tels que MATH, LSAT, etc.). Dans ce cas, suivez les étapes ci-dessus. +""", unsafe_allow_html=True) +st.markdown(""" """) + +st.markdown(""" +##### Utilisation d'annotateurs humains + +Il y a toute une section consacrée à ce point dans la section Utiliser des annotateurs humains. +""", unsafe_allow_html=True) +st.markdown(""" """) + +st.markdown(""" +##### Utilisation de données synthétiques +- **Utilisation de LLM**
+À ce sujet, vous pouvez consulter l'article de blog sur [Cosmopedia](https://huggingface.co/blog/cosmopedia) de mes collĂšgues d'Hugging Face ! Il traite principalement de la crĂ©ation d'un jeu de donnĂ©es d'entraĂźnement synthĂ©tique, mais des techniques similaires peuvent ĂȘtre utilisĂ©es pour l'Ă©valuation. +Assurez-vous de vĂ©rifier/filtrer/inspecter manuellement votre jeu de donnĂ©es par la suite (en suivant les Ă©tapes ci-dessus).
+- **Utilisation de techniques basées sur des rÚgles**
+Si votre tĂąche le permet, c'est un trĂšs bon moyen d'obtenir un nombre pratiquement infini d'Ă©chantillons et d'Ă©viter la contamination !
+Pour quelques exemples, vous pouvez consulter [NPHardEval](https://arxiv.org/abs/2312.14890), [DyVal](https://arxiv.org/abs/2309.17167), [MuSR](https://arxiv.org/abs/2310.16049), [BabiQA](https://arxiv.org/abs/1502.05698), etc. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown(""" +### Choisir une méthode d'inférence +Vous devez choisir le type de méthode d'inférence dont vous avez besoin. + +L'utilisation des log-probabilités (MCQA pour *multi-choice question answer*) est trÚs utile pour les réponses à des QCM (généralement pour tester la connaissance du modÚle ou la capacité de désambiguïsation).
+- Avantages ➕ :
+ - Permet de s'assurer que tous les modÚles ont accÚs à la bonne réponse.
+ - Fournit une approximation de la « confiance » du modÚle (et de la calibration).
+ - Rapide à évaluer, en particulier lorsque nous demandons au modÚle de prédire un seul élément (A/B/C/D les indices des choix, ou Oui/Non, etc.).
+ - Permet d'obtenir un signal sur les performances des petits modĂšles.
+- InconvĂ©nients ➖ :
+ - Les petits modÚles, qui auraient généré quelque chose en dehors de l'éventail des choix disponibles si on leur avait donné carte blanche, sont légÚrement surévalués.
+ - Certains modĂšles [favorisent des choix spĂ©cifiques en fonction de l'ordre dans lequel ils ont Ă©tĂ© prĂ©sentĂ©s](https://arxiv.org/abs/2309.03882), ce qui pourrait conduire Ă  des Ă©valuations non reprĂ©sentatives. + +L'utilisation de gĂ©nĂ©rations (QA, *question answering*) est trĂšs utile pour toutes les tĂąches oĂč vous souhaitez tester la fluiditĂ©, le raisonnement ou la capacitĂ© de votre modĂšle Ă  rĂ©pondre Ă  des questions.
+- Avantages ➕ :
+ - Devrait ĂȘtre corrĂ©lĂ© avec la capacitĂ© du LLM Ă  gĂ©nĂ©rer du texte fluide, sera la plupart du temps ce qui intĂ©resse les gens.
+- InconvĂ©nients ➖ :
+ - Peut ĂȘtre plus difficile Ă  Ă©valuer (voir la partie « MĂ©triques » ci-dessous)
+ - Généralement un peu plus cher que les évaluations par log-vraisemblance, surtout si elles incluent l'échantillonnage. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown(""" +### Choisir une instruction (*prompt* en anglais) +L'instruction va définir : +- la quantité d'informations données à votre modÚle sur la tùche +- la maniÚre dont ces informations sont présentées à votre modÚle.
+ +Une instruction pour du QCM ou du QA est généralement composée de certains des éléments suivants : +- une description de la tùche (facultatif) : présente votre tùche. +- un contexte : fournit un contexte supplémentaire pour votre question.
Par exemple pour une tĂąche de rĂ©sumĂ© ou d'extraction d'informations, vous pouvez fournir une source de contenu. +- une question : le cƓur de votre instruction. +- dans le cas d'une Ă©valuation Ă  choix multiples, vous pouvez ajouter des options +- des mots connecteurs (`Question`, `Contexte`, `Choix`, ...)
+ +Lorsque vous dĂ©finissez votre instruction, vous devez ĂȘtre conscient que :
+- mĂȘme de petits changements sĂ©mantiquement Ă©quivalents dedans peuvent faire varier les rĂ©sultats de maniĂšre significative (voir la section DĂ©panner la reproductibilitĂ©), et les formats utilisĂ©s peuvent avantager ou dĂ©savantager des modĂšles spĂ©cifiques.
+ - Comment atténuer ce problÚme :
+ - Una approche coûteuse est de refaire l'évaluation plusieurs fois avec des variations de l'instruction.
+ - Une solution moins coûteuse consiste à effectuer l'évaluation une seule fois en utilisant une série de formats d'instruction attribués à différents échantillons de difficulté équivalente.
+- vous pouvez fournir des exemples à votre modÚle pour l'aider à suivre le format attendu (appelés exemples *few-shot*) ainsi que de mots connecteurs qui ont tendance à aider.
+- mais les modĂšles ont maintenant tendance Ă  ĂȘtre surentraĂźnĂ©s Ă  des formats d'instruction spĂ©cifiques.
+ - [Ce papier](https://arxiv.org/abs/2407.07890) est excellent sur le sujet, montrant notamment comment certains modĂšles peuvent ĂȘtre surĂ©valuĂ©s parce qu'ils sont surentraĂźnĂ©s sur le **format** du jeu de test.
+ - Sur l'[*Open LLM Leaderboard 2*](https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard), nous avons notamment observé que Llama 3.2 et Qwen 2.5 ne suivent plus le format de l'instruction fournie dans les exemples *few-shot* à cause de ce point.
+- pour un certain nombre de métriques, vous souhaitez une génération ou une sortie contrainte.
+ Vous pouvez en apprendre plus à ce sujet dans la partie « Contraindre les sorties du modÚle » de la section Inférence et évaluation des modÚles. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown(""" +### Choisir une métrique + +Si vous étudiez les **log-probabilités**, le choix est simple : regardez l'*accuracy* (combien de fois le choix le plus probable est le meilleur choix). Il est important de la normaliser en fonction de la longueur (de caractÚre, de *tokens*, etc.). +Vous pouvez également considérer la [perplexité](https://huggingface.co/spaces/evaluate-metric/perplexity), le [rappel](https://huggingface.co/spaces/evaluate-metric/recall) ou le [score f1](https://huggingface.co/spaces/evaluate-metric/f1). + +Pour les évaluations **génératives**, l'éventail des métriques est plus large.
+Vous devrez :
+1. décider si vous comparez les générations telles quelles ou si vous les normalisez préalablement.
+ - Les normalisations peuvent facilement [ĂȘtre injustes si elles ne sont pas bien conçues](https://huggingface.co/blog/fr/open-llm-leaderboard-drop) (en français), mais dans l'ensemble, elles fournissent toujours un signal au niveau de la tĂąche.
+ - Elles sont trÚs importantes pour des tùches spécifiques, telles que les évaluations mathématiques, pour lesquelles vous pourriez vouloir extraire vos résultats à partir de sorties formatées.
+ - Elles seront également importantes si vous souhaitez évaluer avec des mécanismes supplémentaires, tels que la chaßne de pensée (*Chain of Thought*), car vous devrez retirer la trace du raisonnement du résultat réel.
+2. décider de la maniÚre dont vous comparez la génération avec la référence.
+ Vous pouvez utiliser n'importe quelles métriques basées sur les correspondances ([correspondance exacte](https://huggingface.co/spaces/evaluate-metric/exact_match), correspondance par préfixe, etc.) ou des métriques de résumé et de traduction ([ROUGE](https://huggingface.co/spaces/evaluate-metric/rouge), [BLEU](https://huggingface.co/spaces/evaluate-metric/bleu), comparaisons de caractÚres/n-grammes). Pour une liste des métriques existantes, vous pouvez regarder [ici](https://github.com/huggingface/lighteval/wiki/Metric-List). + +Plus généralement, lorsque vous choisissez votre métrique, vous devez garder à l'esprit l'objectif réel de votre tùche. Pour certains domaines (ex : médical, chatbots avec interaction publique, etc.), vous ne voulez pas mesurer la performance moyenne mais avez besoin d'un moyen d'évaluer la **plus mauvaise performance** que vous obtiendrez (sur la qualité médicale de la sortie, sur la toxicité, etc.).
+Pour aller plus loin, jetez un coup d'Ɠil Ă  cet article de [blog](https://ehudreiter.com/2024/07/10/challenges-in-evaluating-llms/). +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown(""" +### Nouvelles tĂąches intelligentes : qu'en est-il des tests fonctionnels ? + +Dans le domaine du code, vous souhaitez Ă©valuer les programmes gĂ©nĂ©rĂ©s non seulement sur leur sĂ©mantique, mais aussi sur leur fonctionnalitĂ© rĂ©elle. Une bonne façon de le faire est donc de vĂ©rifier si le code gĂ©nĂ©rĂ© Ă  la suite d'une instruction passe correctement une suite de tests unitaires conçus pour s'adapter Ă  la tĂąche. + +Cette approche fonctionnelle est extrĂȘmement prometteuse, car elle
+- permet de générer des cas de test plus facilement (c'est assez facile d'en générer à base de rÚgles)
+- de réduire ainsi le surentraßnement
+- de tester les modĂšles sur des capacitĂ©s actives spĂ©cifiques + +Il s'agit toutefois d'une approche qui requiert de la crĂ©ativitĂ© pour ĂȘtre traduite en texte ! + +Un bon exemple est [IFEval](https://huggingface.co/datasets/google/IFEval), un jeu d'Ă©valuation qui teste si les modĂšles peuvent suivre des instructions. Il s'agit de crĂ©er un certain nombre d'instructions de formatage (« Ajouter tel nombre de puces », « Mettre une seule phrase en majuscule », etc.), et de tester strictement si le format est respectĂ©. Un travail supplĂ©mentaire est clairement nĂ©cessaire pour Ă©tendre cette idĂ©e Ă  d'autres caractĂ©ristiques Ă  analyser dans un texte ! +""", unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("II.1._Bases") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("II.3._Quelques_jeux_de_donnĂ©es_d'Ă©valuation") \ No newline at end of file diff --git "a/pages/7_II.3._Quelques_jeux_de_donn\303\251es_d'\303\251valuation.py" "b/pages/7_II.3._Quelques_jeux_de_donn\303\251es_d'\303\251valuation.py" new file mode 100644 index 0000000000000000000000000000000000000000..fd7ab27788c6983d66125e27b2ec313225f3f1e2 --- /dev/null +++ "b/pages/7_II.3._Quelques_jeux_de_donn\303\251es_d'\303\251valuation.py" @@ -0,0 +1,188 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + + +st.markdown( + """ + ## Quelques jeux de donnĂ©es d'Ă©valuation + +Si la tĂąche qui vous intĂ©resse est dĂ©jĂ  bien Ă©tudiĂ©e, il y a de fortes chances qu'un jeu de donnĂ©es existe pour elle. + +Vous trouverez ci-dessous un certain nombre de jeux de donnĂ©es d'Ă©valuation qui ont Ă©tĂ© dĂ©veloppĂ©s ces derniĂšres annĂ©es. + +Attention toutefois :
+- Certains d'entre eux peuvent ĂȘtre obsolĂštes, car ils ont Ă©tĂ© conçus avant le dĂ©veloppement des LLM et sont maintenant facilement rĂ©solus : ils visaient Ă  Ă©tudier une propriĂ©tĂ© spĂ©cifique du texte (traduction, rĂ©sumĂ©), ce qui n'est plus vraiment la façon dont nous Ă©valuons les modĂšles (les Ă©valuations sont maintenant plus gĂ©nĂ©rales/holistiques).
+Note : Ce qui suit serait à actualiser en ajoutant les dates de publication ainsi que des évaluations post LLM à un moment donné.
+- Il est probable qu'ils soient contaminés, étant donné qu'ils sont publiés sur le web depuis un certain nombre d'années. Cependant, cela ne signifie pas qu'ils ne seront pas utiles pour votre tùche ! +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown( + """### Jeux de données spécifiques aux mathématiques + +| Nom | Type de tùche | Taille des données | Type des données | Contenu de la tùche/du papier | Commentaires | +|--------|-------- |---------- |--------|-------- |---------- | +| [AGIEval (SATMath)](https://huggingface.co/datasets/hails/agieval-sat-math) (2023) | Examen +
jeux de données existants | 220 | ProblÚmes de mathématiques tirés du SAT
Le papier est en fait une compilation d'un certain nombre d'examens relatifs à l'homme à utiliser comme données d'évaluation. | [Papier](https://arxiv.org/abs/2304.06364) | - Attention, ce papier inclut aussi des jeux de données provenant d'autres travaux ! Pour les mathématiques, ils utilisent AIME & AMC à travers MATH ; GRE & GMAT à travers AQuA-Rat ; et GaoKao.
- Métriques : acc/em/f1 | +| [AIME (all)](https://artofproblemsolving.com/wiki/index.php/AIME_Problems_and_Solutions) (1983 - mtn) | Olympiades | 15 x 2 par an | ProblÚmes mathématiques nécessitant une combinaison d'arithmétique, d'algÚbre, de comptage, de géométrie, de théorie des nombres, de probabilité et d'autres sujets mathématiques de l'enseignement secondaire. | 2Úme examen pour choisir l'équipe américaine pour les Olympiades internationales de mathématiques

[Blog](https://artofproblemsolving.com/wiki/index.php/American_Invitational_Mathematics_Examination) | La réponse est systématiquement un nombre entier entre 0 et 999. | +| [AIME (22, 23 and 24)](https://huggingface.co/datasets/AI-MO/aimo-validation-aime) (2024) | Olympiades | 90 | Voir AIME (all) | [Papier](https://artofproblemsolving.com/wiki/index.php/American_Invitational_Mathematics_Examination) | Utilisé dans le cadre du concours AIMO | +| [ALGES (SingleEQ)](https://gitlab.cs.washington.edu/ALGES/TACL2015/-/blob/master/questions.json?ref_type=heads) (2015) | Compilations de sources en ligne | 508 | ProblÚmes d'algÚbre de niveau primaire extraits de sources sur le web | Le papier porte sur l'apprentissage implicite et la résolution de l'équation simple qui se cache derriÚre le problÚme.

[Papier](https://aclanthology.org/Q15-1042/) | - Sources : [math-aids.com](http://math-aids.com), [k5learning.com](http://k5learning.com) et [ixl.com](http://ixl.com)
- Papier pré-LLM - les sources de données sont probablement OK | +| [ALG514 ou AllEq](https://groups.csail.mit.edu/rbg/code/wordprobs/questions.json) (2014) | Forum en ligne | 514 | ProblÚmes d'algÚbre extraits d'un site web de tutorat, nettoyés avec le turking et vérifiés manuellement | Le papier porte sur l'extraction du modÚle d'équation du problÚme pour le résoudre.

[Papier](https://aclanthology.org/P14-1026/) | - Source : [algebra.com](https://www.algebra.com/) | +| [AMC 12](https://artofproblemsolving.com/wiki/index.php/AMC_12_Problems_and_Solutions) (2000 - mtn) | Olympiades | 25 par an | ProblÚmes mathématiques à résoudre en arithmétique, algÚbre, comptage, géométrie, théorie des nombres, probabilités et autres sujets mathématiques de l'enseignement secondaire. | 1er examen de sélection de l'équipe américaine pour les Olympiades internationales de mathématiques, anciennement l'examen de mathématiques de l'Americal High School.

[Blog](https://artofproblemsolving.com/wiki/index.php/AMC_12) | - Les problĂšmes sont conçus de maniĂšre Ă  pouvoir ĂȘtre rĂ©solus par des Ă©tudiants n'ayant aucune connaissance en calcul. | +| [Ape210K](https://huggingface.co/datasets/MU-NLPC/Calc-ape210k) (2020) | Examen | 210K problĂšmes, 56K modĂšles | ProblĂšmes mathĂ©matiques chinois de niveau Ă©lĂ©mentaire rĂ©digĂ©s par des professeurs de mathĂ©matiques | RĂ©soudre les problĂšmes

[Papier](https://arxiv.org/abs/2009.11506) (retirĂ©, mais v1 toujours accessible) | - Certains problĂšmes sont modĂ©lisĂ©s, ce qui peut ĂȘtre intĂ©ressant pour les questions de contamination.
- Le jeu de données initial est de 900K lignes et a été filtré manuellement.
- Fournit aussi des « équations intermédiaires » (utiles pour tester les CoT si nécessaire)
- DestinĂ© Ă  ĂȘtre partiellement utilisĂ© pour l'entraĂźnement | +| [AQUA ou AQUA-Rat](https://huggingface.co/datasets/deepmind/aqua_rat) (2017) | Examen + jeu de donnĂ©es turkĂ©| 100K | ProblĂšmes algĂ©briques construits Ă  partir d'une base de 34 000 problĂšmes provenant de GMAT et GRE, et Ă©tendus via turking. | RĂ©soudre le problĂšme

[Papier](https://arxiv.org/abs/1705.04146) | - DestinĂ© Ă  ĂȘtre partiellement utilisĂ© pour l'entraĂźnement
- Inclut la justification des problĂšmes
- Utilise la précision, BLEU et la perplexité pour l'évaluation. | +| [ASDiv-A](https://github.com/chaochun/nlu-asdiv-dataset) (2020) | Compilation de sources en ligne | 2,3K | ProblÚmes de mathématiques niveau école primaire collectés sur différents sites web et normalisés | Résoudre le problÚme

[Papier](https://aclanthology.org/2020.acl-main.92/) | - Contient des annotations par un Ă©tudiant en master sur le type de problĂšme et le niveau scolaire.
- Axé sur une grande diversité lexicale
- Utilisé 28 sites | +| CHAMP (2024) | Olympiades | 270 | ProblÚmes mathématiques extraits d'un livre d'exemples de compétitions d'Olympiades, réécrits pour rendre les solutions analysables, et annotés. | Introduit un benchmark de mathématiques. Les problÚmes sont enrichis de conseils et étiquetés avec des concepts, afin de permettre des études d'ablation sur les performances.

[Papier](https://arxiv.org/abs/2406.18321) | - Source : Le livre "Problem-Solving strategies" (Engel, 2008)
| +| [DeepMind Math](https://huggingface.co/datasets/deepmind/math_dataset) (2019) | Examen + jeu synthétique | 10K ? | ProblÚmes de mathématiques bruts synthétiques en algÚbre, arithmétique, calcul, comparaisons, conversions entre unités, polynÎmes, probabilités, etc. | Résoudre le problÚme

[Papier](https://arxiv.org/abs/1904.01557) | - Liste complĂšte des domaines dans l'annexe B
- La premiÚre section du papier est trÚs intéressante
- Fournir un code de génération pour générer plus d'exemples
- Fournit un échantillon d'entraßnement supplémentaire
- Jeu de donnĂ©es synthĂ©tiques (inspirĂ© de/Ă  Ă©tendre ? jeu de donnĂ©es d'examens scolaires) | +| [DocMath-Eval](https://github.com/yale-nlp/docmath-eval) (2023) | Rapports financiers annotĂ©s + jeux de donnĂ©es finance/maths existants | 3,2K | Combine des rapports financiers et des jeux de donnĂ©es existants, lus par des annotateurs pour gĂ©nĂ©rer (ou valider) des questions, et fournir des rĂ©ponses sous forme de programmes Python, puis Ă©valuĂ©s avec des annotateurs experts du domaine. | Les solutions doivent ĂȘtre prĂ©sentĂ©es sous la forme de programmes Python qui seront exĂ©cutĂ©s pour tester leur validitĂ©.

[Papier](https://arxiv.org/abs/2311.09805) | - RĂ©utilisation de TAT-QA, FinQA, MultiHiertt, TAT-HQA
- La qualité des données semble assez élevée !
- Fournit un échantillon d'entraßnement supplémentaire | +| Dolphin1878 (2015) | Compilations de sources en ligne | 1,5K | ProblÚmes de maths sur les nombres tirés de sources en ligne et réannotés si nécessaire | Le papier porte sur l'extraction de l'arbre d'équation (DOL) du problÚme à l'aide de l'analyse sémantique.

[Papier](https://aclanthology.org/D15-1135.pdf) | - Sources : [algebra.com](https://www.algebra.com/) et [answers.yahoo.com](https://answers.yahoo.com)
| +| [Dolphin18K](https://www.kaggle.com/datasets/saurabhshahane/sigmadolphin) (2016) | Compilations de sources en ligne | 18K | ProblÚmes de maths extraits semi-automatiquement de sources en ligne | [Papier](https://aclanthology.org/P16-1084.pdf) | - Sources : Catégorie Mathématiques des réponses Yahoo depuis 2008
- MĂ©thode : annoter manuellement 6K problĂšmes puis utiliser un classifieur. EntraĂźner un modĂšle pour extraire les golds
- Je ne suis pas sûr que la qualité y soit incroyable compte tenu de la quantité d'extraction automatique (élevée) vs vérification manuelle (faible) | +| [Draw-1K](https://www.microsoft.com/en-us/download/details.aspx?id=52628) (2016) | Compilations de sources en ligne | 1K | ProblÚmes généraux d'algÚbre extraits de sources en ligne | Le papier porte sur l'évaluation des solveurs (systÚmes générant des équations à partir de problÚmes mathématiques du monde), et sur l'équivalence des modÚles de test et des équations.

[Papier](https://arxiv.org/abs/1609.07197) | - Étiqueter chaque problĂšme avec le modĂšle qu'il suit, ce qui peut ĂȘtre utile pour l'analyse des contaminations.
- Source : [algebra.com](https://www.algebra.com/) | +| [FinQA](https://huggingface.co/datasets/ibm/finqa) (2021) | Rapports financiers annotés par des experts | 1,1K | Questions financiÚres liées à des tableaux tirés de rapports sur les bénéfices. Les annotateurs fournissent une question + un processus étape par étape + des annotations pour chaque page. | Le papier présente le jeu de données ainsi qu'une méthode composée d'un récupérateur qui extrait d'abord les faits pertinents pour accueillir des modÚles de contexte courts, puis un générateur de processus.

[Papier](https://arxiv.org/abs/2109.00122) | - Qualité élevée probable : utilisation d'annotateurs experts rémunérés + annotateurs experts externes ayant un accord élevé sur la tùche.
- L'ensemble est de 8,2K
- Le papier ne permet pas de savoir comment les tableaux sont formatĂ©s - markdown peut-ĂȘtre ?
- Source des donnĂ©es : rapports sur les bĂ©nĂ©fices des entreprises du S&P 500 (1999-2019) | +| FrontierMath (2024) | Jeu de donnĂ©es crĂ©Ă© par des experts | 100+ (nombre prĂ©cis inconnu) | ProblĂšmes mathĂ©matiques entiĂšrement nouveaux crĂ©Ă©s pour l'article dans la plupart des domaines mathĂ©matiques. Les solutions sont soit des entiers, soit des objets SymPy pour ĂȘtre automatiquement vĂ©rifiables par des tests unitaires comme des programmes Python. Les problĂšmes sont Ă©tiquetĂ©s. | Introduit le jeu de donnĂ©es

[Papier](https://arxiv.org/abs/2411.04872) | - Une bonne discussion sur la contamination dans le document
- Experts : 60 mathématiciens de 12 pays
- Tous les problÚmes sont examinés par des pairs
- Il s'agit probablement du jeu de données le plus qualitatif actuellement disponible
- Les donnĂ©es ne sont pas publiques ; toutefois, Ă©tant donnĂ© que des modĂšles Ă  source fermĂ©e ont Ă©tĂ© Ă©valuĂ©s, il est probable qu'ils seront contaminĂ©s Ă  l'avenir â˜č | +| [GAOKAO-Bench](https://github.com/OpenLMLab/GAOKAO-Bench?tab=readme-ov-file) ([MathCloze](https://huggingface.co/datasets/hails/agieval-gaokao-mathcloze), [MathQA](https://huggingface.co/datasets/hails/agieval-gaokao-mathqa)) (2023) | Examen | ~500 | ProblĂšmes de mathĂ©matiques de niveau secondaire tirĂ©s des examens d'entrĂ©e Ă  l'universitĂ© en Chine | [Papier](https://arxiv.org/abs/2305.12474) | - Les formules mathĂ©matiques sont converties en LaTeX
- Les problĂšmes sont en chinois
- Le jeu de données est mis à jour chaque année
- Le papier explore un certain nombre de méthodes de notation, y compris des LLM comme juge.
- Le papier contient étonnamment peu d'informations sur le jeu de données | +| [GAOKAO 2023](https://huggingface.co/datasets/MARIO-Math-Reasoning/Gaokao2023-Math-En) (MathEn) (2023) | Examen/Competition | 385 | ProblÚmes mathématiques de niveau secondaire | Compile les questions de l'examen national d'entrée à l'université de Chine 2023, des concours de mathématiques américains 2023 et des tests d'entrée à l'université américains 2023. | +| GSM1K (2024) | Jeu de données créé manuellement dans le style d'un autre jeu de données | 1,2K | Divers problÚmes mathématiques de type « école primaire », suivant la distribution de résolution de GSM8K | Le papier fait une analyse de contamination des modÚles sur GSM8K vs GSM1K

[Papier](https://arxiv.org/abs/2405.00332) | - Le papier semble aussi suggérer que l'analyse de perplexité n'est pas trÚs efficace pour détecter la contamination | +| [GSM8K](https://huggingface.co/datasets/gsm8k) (2021) | Jeu de données créé manuellement dans le style d'un jeu de données d'examen | 8,5K | ProblÚmes mathématiques de divers niveaux scolaires | Le papier porte sur l'entraßnement des vérificateurs pour résoudre des problÚmes mathématiques.

[Papier](https://arxiv.org/abs/2110.14168v2) | - Meilleurs résultats avec l'ajout d'une calculatrice externe
- Toutes les réponses sont des entiers positifs, 50% des réponses sont comprises entre 0 et 8
- L'annotation a utilisé Upwork pour 1K problÚmes, puis Scale pour le suivant. Les auteurs des problÚmes ont reçu des questions de base provenant d'un modÚle GPT3 175B | +| [iGSM](https://huggingface.co/datasets/YangZhoumill/infini_igsm_4k_noise_close) (2024) | Jeu de données synthétique | 20K | Les problÚmes sont générés en utilisant une combinaison de graphes de dépendance entre les objets et les catégories (avec des dépendances directes et implicites) et le nombre d'opérations pour générer de nouveaux problÚmes | Le papier porte sur l'étude du raisonnement mathématique réel sur une extension de GSM8K, y compris le sondage des états internes du modÚle

[Papier](https://arxiv.org/pdf/2407.20311) | - L'idée est théoriquement intéressante mais les problÚmes générés sont trÚs irréalistes avec un grand nombre d'opérations
- Le papier se concentre sur le « processus mental » du modÚle, ce que je trouve douteux (bien que la section sur l'analyse soit intéressante !).
- Beaucoup d'anthropomorphisme -_- | +| [GSMHard](https://huggingface.co/datasets/reasoning-machines/gsm-hard) (2022) | Adaptation d'un jeu de données existant, nombres remplacés | 8,5K | GSM8K avec des nombres plus grands/moins courants pour rendre les problÚmes plus difficiles. Cependant, le changement a été effectué automatiquement par des programmes générés, et seulement 25 modifications ont été vérifiées (+ 50 cas ont été faits manuellement). | Le papier porte sur l'utilisation de LMs assistés par programme (= génération de CoT alternant équations et étapes de raisonnement, et calcul de la solution sur la derniÚre équation avec Python)

[Papier](https://arxiv.org/abs/2211.10435) | - DĂ©crit dans l'annexe H1
- Bonne idée, mais pas sûr de la qualité. | +| [GSM-IC](https://huggingface.co/datasets/voidful/GSM-IC) (2023) | Adaptation d'un jeu de données existant avec des perturbations | 58K | 100 échantillons de GSM8K avec un contexte non pertinent ajouté (à l'aide d'un gabarit pour la phrase non pertinente, plus des rÎles/chiffres de remplissage) | Le papier teste la sensibilité des LLM à un contexte non pertinent lorsqu'ils raisonnent sur des tùches mathématiques

[Papier](https://arxiv.org/abs/2302.00093) | | +| [GSM-Plus](https://huggingface.co/datasets/qintongli/GSM-Plus) (2024) | Adaptation d'un jeu de données existant avec des perturbations | 10K | GSM8K avec 8 variations par question, ajoutées par GPT4 et annotées manuellement par des humains sélectionnés (accord entre les annotateurs vérifié) | Le papier introduit le jeu de données et compare les résultats sur plusieurs variantes de GSM8K à travers les modÚles et les formats des prompts

[Papier](https://aclanthology.org/2024.acl-long.163/) | - Les changements comprennent : le remplacement des nombres par d'autres nombres, la modification des opĂ©rations, la modification de la question, l'ajout de distracteurs, etc. (belle typologie des changements, je pense qu'elle pourrait ĂȘtre Ă©largie) | +| GSM-Symbolic (2024) | Adaptation d'un jeu de donnĂ©es existant | 8,5K | Gabaris de problĂšmes GSM8K, permettant de gĂ©nĂ©rer de nouvelles Ă©valuations Ă  volontĂ© | Le papier crĂ©e des modĂšles analysables Ă  partir de GSM8K afin de pouvoir gĂ©nĂ©rer de nouveaux problĂšmes Ă  volontĂ© et d'analyser la contamination sur GSM8K

[Papier](https://arxiv.org/abs/2410.05229) | - Contient d'autres sous-ensembles spécifiques (M1, P1, P2, qui sont des niveaux de difficulté, ainsi que NoOp, avec des informations apparemment pertinentes mais en fait infos non pertinentes ajoutées), et certaines expériences sont réalisées en *few shot*
- Manque un tableau de description du jeu de données avec tous les sous-ensembles selon moi | +| [Hungarian HighSchool National Finals Exam](https://huggingface.co/datasets/keirp/hungarian_national_hs_finals_exam) (2023) | Examen | 33 | ProblÚmes des finales lycéennes nationales hongroises en mathématiques en 2023 | [Source](https://dload-oktatas.educatio.hu/erettsegi/feladatok_2023tavasz_kozep/k_matang_23maj_fl.pdf) | - Nécessité d'un classement à la main actuellement | +| [HMWP](https://huggingface.co/datasets/Gxg/HWMP) (2020) | Examen | 5,4K | ProblÚmes de mathématiques annotés provenant d'une banque de problÚmes de l'école chinoise (K-12) | Introduit un nouveau formalisme pour représenter les équations de maniÚre uniforme

[Papier](https://arxiv.org/abs/2010.06823) | - Jeu en chinois
- Sources : ProblÚmes chinois niveau K12 | +| [Math23K](https://huggingface.co/datasets/Gxg/Math23K) (2017) | Compilation de sources en ligne | 23K | Extraction automatique de problÚmes mathématiques du niveau de l'école primaire. | Introduction d'un RNN pour résoudre les problÚmes

[Papier](https://aclanthology.org/D17-1088/) | - Sources : ProblÚmes de mathématiques en chinois tirés de sites éducatifs en ligne pour les élÚves de l'école primaire.
- Jeu en chinois
- L'extraction est basée sur des rÚgles, mais la part de validation manuelle n'est pas claire. | +| [Math401-LLM](https://github.com/GanjinZero/math401-llm) (2023) | Jeu de données synthétique | 401 | Expressions arithmétiques combinant des additions, des soustractions, des multiplications, des exponentiations, des logarithmes, etc. | Le papier veut mesurer la capacité arithmétique stricte des modÚles
[Papier](https://arxiv.org/abs/2304.02015) | - Les modÚles ne sont pas trÚs performants actuellement pour les problÚmes de logarithme et de trigonométrie ou pour les grands nombres | +| [MATH](https://huggingface.co/datasets/lighteval/MATH) (2021) | Olympiades | 12,5K | ProblÚmes mathématiques issus de concours réels en langage naturel et en LaTeX, annotés avec des niveaux de difficulté | [Papier](https://arxiv.org/abs/2103.03874) | - Sources : AMC 10, AMC12, AOME, "et plus"
- Présente également un jeu d'entraßnement créé à partir du scrapping de la Khan academy et de AMPS | +| [MathQA](https://huggingface.co/datasets/allenai/math_qa) (2019) | Adaptation d'un jeu de données existant, annoté | 37K | Annotation des problÚmes résolvables du jeu de données AQuA à l'aide de programmes d'annotation formels (en utilisant des humains comme annotateurs et en testant leur accord). | Vise à introduire un langage de représentation pour les problÚmes mathématiques, applique la méthode à AQuA

[Papier](https://arxiv.org/abs/1905.13319) | - Source : AQuA | +| [MAWPS](https://github.com/sroy9/mawps) (2016) | Compilation de jeux de données existants | 3,3K | ProblÚmes mathématiques à partir de jeux de données existants | Cadre pour créer de nouveaux problÚmes mathématiques, notamment pour supprimer les chevauchements lexicaux ou de gabarits lors de l'ajout de nouveaux jeux de données.

[Papier](https://aclanthology.org/N16-1136/) | - Sources : ALG514, ALGES, et autres jeux de données pré-LLM | +| [MiniF2F](https://huggingface.co/datasets/cat-searcher/minif2f-lean4) (2022) | Olympiades | 244 | ProblÚmes mathématiques des Olympiades formalisés avec des prouveurs de théorÚmes lorsque cela est possible (Lean, Methamath, Isabelle) | Le papier porte sur le test de la capacité des résolveurs de preuves mathématiques à raisonner sur la logique formelle

[Papier](https://arxiv.org/abs/2109.00110) | - Sources : AIME, AMC, IMO | +| [NPHardEval](https://github.com/casmlab/NPHardEval) (2023) | Jeu de données synthétique | 900 | ProblÚmes mathématiques complexes de niveaux de difficulté variés construits à partir de données graph/linéaires synthétiques. | Le papier présente le benchmark et l'utilise pour évaluer la capacité de raisonnement des modÚles. Il explore également la robustesse du benchmark

[Papier](https://arxiv.org/abs/2312.14890) | - ProblÚmes : recherche de tableaux triés, distance d'édition, chemin le plus court, voyageur de commerce, coloration de graphes, problÚme du sac à dos, problÚme de planification de réunions
- Peut ĂȘtre rĂ©gĂ©nĂ©rĂ© selon les besoins | +| [NuminaMATH CoT](https://huggingface.co/datasets/AI-MO/NuminaMath-CoT) (2024) | Compilation de jeux de donnĂ©es existants | 860K | ProblĂšmes mathĂ©matiques (niveaux K12 + olympiades) combinant des jeux de donnĂ©es existants | | - Sources : AOPS, AMC, AIME, CN-K12, GSM8K, MATH, ORCA_math, donnĂ©es synthĂ©tiques AMC et MATH, et autres sĂ©ries d'Olympiades
- attention si vous utilisez ce jeu comme entraĂźnement, vous serez contaminĂ© sur tous les principaux benchmarks de maths | +| [NuminaMATH TiR](https://huggingface.co/datasets/AI-MO/NuminaMath-TiR) (2024) | | 72K | Sous-ensemble de NuminaMATH CoT axĂ© sur les problĂšmes pouvant ĂȘtre rĂ©solus Ă  l'aide d'un outil de raisonnement intĂ©grĂ© | | - Sources : AOPS, AMC, AIME, CN-K12, GSM8K, MATH, ORCA_math, donnĂ©es synthĂ©tiques AMC et MATH, et autres sĂ©ries d'Olympiades
- attention si vous utilisez ce jeu comme entraßnement, vous serez contaminé sur tous les principaux benchmarks de maths | +| [OmniMath](https://huggingface.co/datasets/KbsdJames/Omni-MATH) (2024) | Olympiades| 2,2K | ProblÚmes mathématiques des Olympiades. Les problÚmes sont extraits de forums ou de sites web des olympiades (à l'aide d'une reformulation basée sur des rÚgles + LLM), puis annotés et vérifiés par des humains | Le papier présente le benchmark et un juge entraßné à évaluer les réponses (puisqu'il s'agit d'un format libre)

[Papier](https://arxiv.org/abs/2410.07985) | - Sources: IMO, IMC, AoPS forum et wiki
- L'étiquetage des domaines est réalisé avec des LLM | +| OlympiadBench (2024) | Olympiades | 8,4K | ProblÚmes Olympiades/maths/physiques. Les réponses sont automatiquement évaluées - soit des nombres, soit des équations (évaluées avec SymPy) | [Papier](https://arxiv.org/pdf/2402.14008) | - Sources : ProblÚmes des Olympiades mondiales de mathématiques et de physique, concours régionaux et nationaux de mathématiques en Chine et questions simulées pour le Gaokao en mathématiques et en physique.
- Comprend un sous-ensemble de physique
- évaluation de VLM ! | +| OlympicArena (2024) | Olympiades | 11K | | [Papier](https://arxiv.org/pdf/2406.12753) | | +| [PRM800K](https://huggingface.co/datasets/tasksource/PRM800K) (2023)| Données synthétiques | 800K | Données de préférence d'annotateurs sur 800K solutions générées par un modÚle | Papier introduisant la supervision des processus pour améliorer les modÚles de récompense (compare la sortie et la supervision des processus)

[Papier](https://arxiv.org/abs/2305.20050) | - Davantage un jeu d'entraßnement qu'une évaluation | +| [SVAMP](https://github.com/arkilpatel/SVAMP/blob/main/SVAMP.json) (2021) | Adaptation d'un jeu de données existant | 1K | ProblÚmes arithmétiques à une inconnue d'un niveau allant jusqu'à 4, créés par des experts appliquant des variations à ASDiv-A. | Le papier veut évaluer la sensibilité aux questions, la capacité de raisonnement et l'invariance de la structure dans les modÚles pour les évaluations en mathématiques.

[Papier](https://aclanthology.org/2021.naacl-main.168/) | - Variations : mĂȘme objet et structure diffĂ©rente, opposĂ©, tous deux diffĂ©rents, ajout d'informations pertinentes ou non pertinentes, modification des informations, inversion des opĂ©rations, modification de l'ordre des phrases ou des objets | +| [TabMWP](https://huggingface.co/datasets/Arietem/tabmwp) (2022) | Adaptation de sources en ligne | 38K | TDes problĂšmes mathĂ©matiques particuliers nĂ©cessitant un raisonnement Ă  plusieurs sauts, extraits d'un site web Ă©ducatif en ligne et annotĂ©s manuellement | Le papier veut tester le raisonnement mathĂ©matique tabulaire

[Papier](https://arxiv.org/abs/2209.14610) | - Source : IXL
- Les données tabulaires sont fournies sous forme d'image, de texte semi-structuré et de tableau.
- Les réponses sont génératives ou MCQA
- Le jeu de données est testé contre des turkers | +| [TAL-SCQ5K-En](https://huggingface.co/datasets/math-eval/TAL-SCQ5K) (2023) | Compétitions | 4K | ProblÚmes mathématiques sous forme de QCM, avec des expressions mathématiques en LaTeX | | | - Contient de l'anglais et du chinois
- Contient également 6K échantillons d'entraßnement et de CoT | +| [TemplateGSM](https://huggingface.co/datasets/math-ai/TemplateGSM) (2024) | Données générées par LLM| 7M | ProblÚmes mathématiques générés par GPT4 et inspirés par la forme de GSM8K | Le papier utilise des méta-gabarit généré par GPT4 pour générer des problÚmes en modifiant les paramÚtres. Utilise un vérificateur pour s'assurer de la facilité d'utilisation

[Papier](https://templatemath.github.io/TemplateMath_Part_I.pdf)| - Puisque tout est généré par LLM, je m'attendrais à des preuves de qualité plus solides | +| [TheoremQA](https://huggingface.co/datasets/TIGER-Lab/TheoremQA) (2023) | Adaptations de sources en ligne | 800 | QA sur les théorÚmes de niveau universitaire | Protocole : Utilise GPT4 pour énumérer les sous-domaines des domaines pertinents, puis des listes de théorÚmes plausibles, puis fait appel à des experts du domaine pour rechercher ces théorÚmes, puis QA sur le web concernant ces théorÚmes.

[Papier](https://arxiv.org/abs/2305.12524) | | +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown(""" +### Jeux de données pré-LLM + +| Nom | Type de tùche | Type des données | Contenu de la tùche/du papier | Commentaires | +|--- |--- |--- |--- |--- | +| DeepFix | Code, Code-to-code, Correction | 7K programmes en C erronés écrits par des étudiants | Corriger les programmes en C

[Papier](https://ojs.aaai.org/index.php/AAAI/article/view/10742) | | +| [MLSum](https://huggingface.co/datasets/mlsum) | GĂ©neration, Multilingue, RĂ©sumĂ©s | 1,5 million de paires rĂ©sumĂ©/article du DailyMail, Le Monde, SĂŒddeutsche Zeitung, El Pais, Moskovskij Komsomolets et Internet Haber (en, fr, de, es, ru, tr) | RĂ©sumer les articles

[Papier](https://arxiv.org/abs/2004.14900) | Palm : Préfixé avec une instruction, article tronqué à 2048 tokens | +| [TransCoder](https://github.com/facebookresearch/CodeGen/blob/main/docs/transcoder.md) | Code, Code-to-code | 852 fonctions parallÚles en Python/Java/C++ | Traduire d'un langage informatique à un autre

[Papier](https://arxiv.org/pdf/2006.03511.pdf) | +| WMT | Multilingue, traduction | Jeux de données de la conférence WMT sur la traduction automatique - les jeux de données disponibles dépendent de l'année | Traduire d'une langue à une autre | [Conference](https://www.statmt.org/wmt20/)
Remplacer les 2 chiffres par l'année de la conférence | | +| [Adversarial NLI](https://dl.fbaipublicfiles.com/anli/anli_v1.0.zip) | Inférence linguistique | 10K jeu de données d'implication généré à l'aide d'attaques adverses humaines dans la boucle, à la recherche de prédicats qui forcent les modÚles à prédire des étiquettes d'implication erronées (utilise des contextes provenant de StoryCloze, CommonCrawl, Wikipedia, l'Open Annotated National Corpus, WikiHow et GLUE) | Prévoir l'implication

[Papier](https://arxiv.org/abs/1910.14599) | R1 à R3 = tours de génération de données | +| [APPS](https://people.eecs.berkeley.edu/~hendrycks/APPS.tar.gz) | Text-to-code| 10K ProblÚmes de code en Python en langues naturelles, récupérés sur des sites de leetcode, avec une suite de cas de test. | Résoudre le problÚme Python

[Papier](https://arxiv.org/abs/2105.09938) | | +|[AQuA](https://github.com/deepmind/AQuA) | Arithmétique, raisonnement | 100K problÚmes à choix multiples (GMAT, GRE, autres sources) avec questions/options/justification | Sélectionnez la bonne réponse

[Papier](https://arxiv.org/abs/1705.04146) | Meilleurs résultats obtenus avec une calculatrice externe ajoutée | +| [ARC](https://allenai.org/data/arc) | Bon sens, raisonnement | 8K questions de sciences de l'école primaire : e = facile (easy), c = difficile (challenge) | Sélectionnez la bonne réponse

[Papier](https://arxiv.org/abs/1803.05457) | Attention, il s'agit du défi de raisonnement AI2, et non du corpus d'abstraction et de raisonnement. | +| [bAbI](https://research.facebook.com/downloads/babi/) | Raisonnement | 20 tùches comprenant chacune 2 000 questions générées automatiquement + des scénarios courts (actions successives générées à l'aide d'un jeu d'aventure textuel simulé) | Raisonnez sur la phrase pour choisir la bonne conclusion

[Papier](https://arxiv.org/abs/1502.05698) | Voir la partie 4 pour l'environnement de simulation et ses contraintes, c'est une idée assez amusante. Il n'est probablement pas trop difficile de la reproduire pour d'autres types de raisonnement | +| [BBQ](https://github.com/nyu-mll/BBQ/tree/main/data) | Détection de biais | 58K exemples avec deux contextes (ambigu et explicite à propos d'un biais), deux questions (négative et non négative) et des réponses possibles, construits à partir de modÚles manuels et vérifiés par crowdsourcing | Prédire la réponse correcte et non biaisée. La différence entre les précisions en fonction du contexte/de la question permet d'établir un score de partialité.

[Papier](https://aclanthology.org/2022.findings-acl.165/) | | +| [BLiMP](https://github.com/alexwarstadt/blimp/tree/master/data) | Compréhension de la langue | 67 jeux de données de chaque 1K paires minimales générées artificiellement testant les connaissances syntaxiques, morphologiques et sémantiques, validées avec MTurking | Accuracy mesurée en regardant si la probabilité logarithmique que le modÚle attribue à la phrase correcte est plus élevée

[Papier](https://aclanthology.org/2020.tacl-1.25/) | ÉlĂ©ments testĂ©s : accord anaphorique, structure des arguments, liaison, contrĂŽle/raisonnement, accord dĂ©terminant-nom, ellipse, espace de remplissage, formes irrĂ©guliĂšres, effets d'Ăźle, licence NPI, quantificateurs, accord sujet-verbe | +| [BOLD](https://github.com/amazon-science/bold/tree/main/prompts) | GĂ©nĂ©ration, dĂ©tection de la toxicitĂ© | 23K prompts extraits du dĂ©but des phrases de Wikipedia contenant un membre du groupe couleur de peau/religion/politique/sexe/profession (ex : femme artiste pour genre=femme).
| Tùche : générer des fins de phrases, et la toxicité est évaluée à l'aide d'une série de métriques (analyse de sentiment, utilisation de classifieurs, ...). Dans HELM, la toxicité est mesurée à l'aide de l'API Perspective

[Papier](https://arxiv.org/abs/2101.11718) | | +| [BooksCorpus](https://huggingface.co/datasets/bookcorpus) | | 11K livres inédits de plus de 20K mots récupérés sur le web (de 16 genres différents) | Dans le papier original, il est utilisé pour entraßner un modÚle d'enchùssement de phrases, il est souvent utilisé pour évaluer la contamination ou la perplexité.

[Papier](https://arxiv.org/pdf/1506.06724.pdf)| | +| [BooksCorpus_HELM](https://drive.google.com/file/d/10uC4jM6tgI1pgtq--07FFHQ2Te7-SXGA/view) | Génération, mémorisation | 1K livres échantillonnés de maniÚre aléatoire à partir de BooksCorpus | Tùche : à partir d'un nombre aléatoire de tokens commençant un paragraphe, le modÚle doit générer une suite - mesurer la reproduction exacte et quasi-exacte.

[Papier](https://arxiv.org/abs/2211.09110) | | +| BoolQ | Inférence linguistique, compréhension du langage | 16K phrases d'origine naturelle oui/non QA, à partir de la question + contexte de Wikipedia | Répondre au QCM

[Papier](https://arxiv.org/abs/1905.10044) | [Site](https://super.gluebenchmark.com/tasks) | +| CB | Compréhension du langage | 1,2K discours (news du Wall Street Journal, fiction du British National Corpus, dialogue du Switchboard), contenant le contexte + la phrase cible | Prédire l'implication de l'engagement

[Papier](https://semanticsarchive.net/Archive/Tg3ZGI2M/Marneffe.pdf) | [Site](https://super.gluebenchmark.com/tasks) | +| [Civil comments](https://huggingface.co/datasets/civil_comments) | Détection de la toxicité | 1,8 million de commentaires en ligne, avec des étiquettes humaines crowdsourcées pour la toxicité, conformément aux consignes de l'API Perspective, et parmi ceux-ci, 450 000 étiquetés avec des termes d'identité (provenant de la foule, à piocher dans une liste). | Tùche : prédiction de la toxicité, les étiquettes sont utilisées pour identifier les zones de biais dans les modÚles.

[Papier](https://arxiv.org/pdf/1903.04561.pdf) | Le papier original contenait un jeu de données synthétique (77 000 exemples générés à partir de modÚles utilisant 50 termes d'identité, 50/50 sur la toxicité) et un jeu de données étiqueté par des humains (description dans la colonne Contenu de la tùche) - je suppose que le jeu de données disponible est ce dernier. | +| [Clean E2E NLG](https://huggingface.co/datasets/e2e_nlg_cleaned) | Description, Géneration | 50K descriptions de restaurants à partir de clés et de valeurs (type de nourriture = X, budget = Y, ...). | [Papier](https://arxiv.org/abs/1706.09254) | Palm : Préfixé par une instruction, article tronqué à 2048 tokens | +| [CNN/DailyMail](https://huggingface.co/datasets/cnn_dailymail) | Cloze/Complétion, Résumés | Jeu de données original : 200K articles de presse (CNN/DailyMail entre 2007 et 2015) convertis au format Cloze en supprimant certaines entités nommées du texte et en les utilisant comme clés. | Dans HELM : utilise les documents susmentionnés (dans leur forme complÚte) comme texte à résumer, et leurs introduction comme résumés or.

[Papier](https://arxiv.org/pdf/1506.03340.pdf) | Je soupçonne que cette mĂ©thode ne produit pas de trĂšs bons rĂ©sumĂ©s | +| CommonsenseQA | Bon sens, raisonnement | 12K questions/rĂ©ponses (initialisĂ©es Ă  partir des associations de ConceptNet), puis filtrĂ©es par qualitĂ©, avec un contexte ajoutĂ© Ă  partir d'une requĂȘte Google Search > Certains textes recoupent probablement des donnĂ©es CC | RĂ©pondre au QCM

[Papier](https://aclanthology.org/N19-1421/) | Meilleurs résultats avec l'ajout d'une calculatrice externe | +| [Contrast Sets](https://allenai.org/data/contrast-sets) | Génération, Robustesse | 10 jeux de contraste de jusqu'à 1K exemples, pour leurs jeux de données (voir commentaires) faits par les chercheurs (souvent ceux de l'article original) (augmenter les étapes de raisonnement dans les questions, remplacer les mots par leurs opposés, changer les décomptes ...). | Suivre la configuration de la tùche originale avec de nouveaux exemples, et voir si/comment les performances diminuent.

[Papier](https://aclanthology.org/2020.findings-emnlp.117/) | Les 10 jeux de données : NLVR2, IMDb sentiment analysis, MATRES Temporal RE, English UD parsing, PERSPECTRUM, DROP, Quoref, ROPES, BoolQ, MC-TACO.

La construction est dĂ©taillĂ© dans l'annexe du papier | +| COPA | Bon sens, comprĂ©hension de la langue | 1K hypothĂšses + questions causales avec alternatives (sens commun) | [Papier](https://people.ict.usc.edu/~gordon/publications/AAAI-SPRING11A.PDF) | [Site](https://super.gluebenchmark.com/tasks) | +| [CoQA](https://stanfordnlp.github.io/coqa/) | ComprĂ©hension de la lecture en contexte | 127K QA conversationnel, Ă  partir d'un contexte donnĂ© (la justification doit Ă©galement ĂȘtre fournie) - rĂ©digĂ© par des annotateurs | [Papier](https://arxiv.org/abs/1808.07042) | | +| DataImputation ([restaurant](https://www.cs.utexas.edu/users/ml/riddle/data/restaurant.tar.gz) & [buy](https://dbs.uni-leipzig.de/file/Abt-Buy.zip)) | TĂąche rĂ©elle, raisonnement, donnĂ©es structurĂ©es | 8 jeux de donnĂ©es structurĂ©s provenant de plusieurs sources. | TĂąche : Ă  partir d'une sĂ©rie d'attributs prĂ©sentant des lacunes, le modĂšle doit combler ces lacunes (ex : extrapoler la ville Ă  partir du numĂ©ro de tĂ©lĂ©phone, la marque du tĂ©lĂ©phone Ă  partir de ses caractĂ©ristiques).

[Papier](https://sxsong.github.io/doc/21icde-imputation.pdf) | Voir le tableau 2 pour toutes les sources.
Dans HELM : utiliser les sous-ensembles Buy et Restaurant, convertir l'entrée en langage naturel, tester la précision.| +| [Digits arithmetics (2D+, 2D-, 3D+, 3D-, 
)](https://raw.githubusercontent.com/openai/gpt-3/master/data/) | Arithmétique | Tùches d'arithmétique de base pour l'addition à n chiffres, la soustraction, les opérations composées avec 2K exemples chacune | Tùche : résoudre les problÚmes mathématiques

[Papier](https://arxiv.org/pdf/2005.14165.pdf) | Tous les liens proviennent de cette [page](https://github.com/EleutherAI/lm-evaluation-harness/blob/main/lm_eval/tasks/arithmetic/README.md) | +| [DROP](https://allenai.org/data/drop) | Arithmétique, Compréhension écrite en contexte | 55K questions contradictoires qui requiÚrent 1) de sélectionner des éléments pertinents du texte et 2) de calculer sur ces éléments (trier/compter/...) pour obtenir la bonne réponse | Tùche : sélectionner et compter pour fournir la bonne réponse

[Papier](https://aclanthology.org/N19-1246/) | | +| [Dyck language_HELM](https://github.com/stanford-crfm/helm/blob/main/src/helm/benchmark/scenarios/dyck_language_scenario.py) | Manipulation symbolique | 500 D_n mots entre 52 et 100 caractÚres (« mot » composé de parenthÚses imbriquées) dont les i derniers caractÚres ont été supprimés. | Tùche : Prédire la séquence unique de fermeture des parenthÚses.

[Papier](https://arxiv.org/abs/2211.09110) | A également une version différente dans BigBench | +| [HellaSwag](https://github.com/rowanz/hellaswag/tree/master/data) | Cloze/Complétion | 60K QA à choix multiples avec filtrage contradictoire | Choisir la phrase suivante correcte (à partir des légendes ou de WikiHow)

[Papier](https://aclanthology.org/P19-1472/) | | +| [HumanEval](https://huggingface.co/datasets/openai_humaneval) | Code, Text-to-code | 164 problÚmes de programmation écrits à la main avec signature de fonction, docstring, body + tests unitaires | Le but est de compléter la fonction pour qu'elle passe les tests unitaires

[Papier](https://arxiv.org/abs/2107.03374) | | +| [IMDB](https://ai.stanford.edu/~amaas/data/sentiment/) | Analyse de sentiments | 50K avis d'IMDB, avec des avis positifs (note ≄ 7) / nĂ©gatifs (note ≀ 4) (pas de neutre). | Classer les critiques positives/nĂ©gatives

[Papier](https://aclanthology.org/P11-1015/) | | +| [LAMBADA](https://zenodo.org/record/2630551#.YFJVaWT7S_w) | Cloze/ComplĂ©tion | 10K contextes narratifs (issus du BookCorpus) suivis d'une phrase dont le dernier mot est masquĂ© et doit ĂȘtre prĂ©dit. Construit spĂ©cifiquement pour forcer l'utilisation du contexte | PrĂ©dire le dernier mot

[Papier](https://aclanthology.org/P16-1144/) | | +| Language Modeling Evaluation_HELM | Modélisation du langage | Compilation dans HELM de plusieurs jeux de données : WikiText-103, ThePile (en particulier arXiv, BooksCorpus2, Enron Emails, PubMed Central, Wikipedia), TwitterAAE, ICE. | Tùche : obtenir la probabilité logarithmique conditionnelle de la séquence complÚte (= la perplexité)

[Papier](https://arxiv.org/abs/2211.09110) | [The pile](https://pile.eleuther.ai/ )
[BLIMP](https://github.com/alexwarstadt/blimp )
[Wikitext](https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-raw-v1.zip )
[Twitter AAE](http://slanglab.cs.umass.edu/TwitterAAE/ )
[ICE](https://www.ice-corpora.uzh.ch/en/access.htm) | +| [LegalSupport](https://docs.google.com/uc?export=download&id=1PVoyddrCHChMxYrLhsI-zu7Xzs5S8N77) | Implication, Tùche réelle, Raisonnement | 20K scénarios d'implication juridique, construits à partir d'avis juridiques nationaux/fédéraux (l'affirmation est utilisée comme contexte, et 2 sources d'appui (« voir X, rÚgle ») sont sélectionnées de maniÚre aléatoire). | [Papier](https://arxiv.org/abs/2211.09110) | | +| [LinuxKernel_HELM](https://drive.google.com/file/d/1Y5piYwil7T6n8toT_-d7NWqVZHh9NVxJ/view) | Génération, mémorisation | 2K fonctions échantillonnées aléatoirement à partir du noyau Linux.| Tùche : à partir d'un nombre aléatoire de lignes commençant une fonction, le modÚle doit générer une suite - mesurer la reproduction exacte et quasi-exacte.

[Papier](https://arxiv.org/abs/2211.09110) | | +| [LSAT](https://github.com/zhongwanjun/AR-LSAT/tree/main/data) | Raisonnement analytique, compréhension de lecture en contexte, raisonnement logique | 10K questions du *Law School Admission Test* (raisonnement analytique, logique et compréhension de lecture), avec contexte.| Répondre correctement aux QCM

[Papier](https://arxiv.org/pdf/2108.00648.pdf) | | +| [Magellan Benchmark](https://github.com/anhaidgroup/deepmatcher/blob/master/Datasets.md) | Tùche réelle, raisonnement, données structurées | 23 jeux de données provenant de plusieurs sources et contenant des entités avec des attributs. Les jeux de données sales contiennent des erreurs délibérées, telles que des attributs figurant dans la mauvaise colonne, des fautes d'orthographe, etc. | Tùche : étant donné deux entités provenant de deux tables différentes, déterminez si elles sont identiques ou non.

[Papier](https://pages.cs.wisc.edu/~anhai/papers1/deepmatcher-sigmod18.pdf) | Il est probable qu'Abt-Buy et Buy soient le mĂȘme jeu de donnĂ©es.| +| [MBPP](https://huggingface.co/datasets/mbpp) | Code, Text-to-code | 1K problĂšmes de programmation Python crwdsourcĂ©s de niveau dĂ©butant (description, solution, 3 cas de tests unitaires) - (58% mathĂ©matiques, 43% traitement de listes, 19% traitement de chaĂźnes de caractĂšres, 9% sĂ©quences d'entiers, et 2% autres). | RĂ©soudre le programme Python

[Papier](https://arxiv.org/abs/2108.07732) | Contient Ă©galement une version Ă©ditĂ©e (400 Ă©lĂ©ments) avec des prompts non ambiguĂ«s et de bonnes signatures (il peut ĂȘtre intĂ©ressant d'examiner ultĂ©rieurement l'impact des prompts sur la gĂ©nĂ©ration de code) + un jeu de donnĂ©es MathQA-Python (adaptation du jeu de donnĂ©es MathQA). | +| [MMLU](https://huggingface.co/datasets/lukaemon/mmlu) | ComprĂ©hension linguistique | 15K QA Ă  choix multiples collectĂ©s manuellement Ă  partir de diverses sources en ligne, sur de nombreux sujets (juridique, philosophie, Ă©conomie, psychologie, STEM, mĂ©decine, etc, - du niveau secondaire au niveau professionnel) | RĂ©pondez au QCM

[Papier](https://arxiv.org/abs/2009.03300) | Il semble qu'il s'agisse d'une base solide/de haute qualitĂ© | +| [MRF (Misinfo Reaction Frames)](https://github.com/skgabriel/mrf-modeling) | GĂ©nĂ©ration, capacitĂ©s de dĂ©sinformation | 200K paires d'affirmations tirĂ©es de titres de presse (changement climatique, covid 19, maladie cancĂ©reuse, sources dĂ©taillĂ©es dans les commentaires) + Ă©tiquette (rĂ©el/dĂ©sinformation), les premiĂšres Ă©tant annotĂ©es sur la vĂ©racitĂ©, la probabilitĂ© de propagation, l'intention de l'auteur, par des travailleurs MTurk. | [Papier](https://aclanthology.org/2022.acl-long.222/) | Contient des donnĂ©es de NELA-GT-2018-2020, SciDCC, Climate-FEVER, CoAID, CoronaVirusFacts/DatosCoronaVirusAlliance Database, ESOC Covid-19 Misinformation Dataset et DETERRENT | +| [MS MARCO](https://microsoft.github.io/msmarco/) | QA, Retrieval | 1M de questions anonymisĂ©es avec des rĂ©ponses libres gĂ©nĂ©rĂ©es par des humains (Ă  partir d'extraits de documents web pertinents), certaines avec une rĂ©Ă©criture ajoutĂ©e. | Le papier original contient 3 tĂąches : 1) gĂ©nĂ©rer la bonne rĂ©ponse, si possible, 2) mĂȘme chose mais la rĂ©ponse doit avoir un sens mĂȘme sans contexte, 3) classer 1000 passages en fonction de leur pertinence par rapport Ă  la question.

[Papier](https://arxiv.org/abs/1611.09268) | Contient des descriptions dĂ©taillĂ©es de jeux de donnĂ©es de QA dans une revue dĂ©taillĂ©e. Dans HELM, seule la tĂąche de classement est prise en compte, et la pertinence est estimĂ©e en fonction de la log-vraisemblance de la prĂ©diction Ă  la question « Le passage rĂ©pond-il Ă  la requĂȘte ? » | +| [MS MARCO TREC, aka TREC 2019](https://trec.nist.gov/data/deep2019.html) | Retrieval | Jeux de donnĂ©es dĂ©rivĂ©s de MS MARCO, Ă©ditĂ©s pour des tĂąches de recherche de passages ou de documents, soit en effectuant une recherche complĂšte, soit en effectuant un reclassement top-n (100 pour les documents, 1000 pour les passages). Voir MS MARCO. | [Papier](https://arxiv.org/abs/2003.07820) | | +| [MultiRC](https://super.gluebenchmark.com/tasks) | ComprĂ©hension linguistique, QA | 6K questions Ă  choix multiples sur une variĂ©tĂ© de sujets | [Papier](https://aclanthology.org/N18-1023.pdf) | | +| [NarrativeQA](https://github.com/deepmind/narrativeqa) | QA, Retrieval | 47K questions et rĂ©ponses de forme libre gĂ©nĂ©rĂ©es par des humains, liĂ©es Ă  1,5K livres (projet Gutemberg) et scripts de films (scrappĂ©s) assortis de rĂ©sumĂ©s de l'intrigue. | TĂąche : Ă  partir du rĂ©sumĂ© ou de l'histoire, rĂ©pondre ou sĂ©lectionner la bonne rĂ©ponse.

[Papier](https://arxiv.org/abs/1712.07040) | Pour des tests de longs contextes, nous pourrions utiliser ce jeu de donnĂ©es pour du QA. Cela pourrait ĂȘtre intĂ©ressant pour tout ce qui est conversationnel. | +| [Natural Questions](https://ai.google.com/research/NaturalQuestions/download) | Domaine ouvert/livre fermĂ©, QA | 207K requĂȘtes de recherche agrĂ©gĂ©es de Google + exemple de rĂ©ponse annotĂ©e de WikipĂ©dia | [Papier](https://aclanthology.org/Q19-1026/) | | +| [NewsQA](https://github.com/Maluuba/newsqa) | QA | 100K paires de QA gĂ©nĂ©rĂ©es par des humains Ă  partir de 12K articles de presse (CNN). Les questions ont Ă©tĂ© gĂ©nĂ©rĂ©es Ă  partir du titre et du rĂ©sumĂ©, les rĂ©ponses Ă  partir de la question et de l'article, puis conservĂ©es par le biais d'un mĂ©canisme de validation. Vraisemblablement en intersection avec CNN/DailyMail, car le script d'extraction des donnĂ©es est le mĂȘme. | [Papier](https://aclanthology.org/W17-2623/) | | +| [OpenBookQA](https://allenai.org/data/open-book-qa) | Bon sens, raisonnement | 6K phrases, raisonnement scientifique nĂ©cessitant des connaissances de bon sens pour extrapoler Ă  de nouvelles situations. | [Papier](https://arxiv.org/abs/1809.02789) | | +| [PIQA](https://yonatanbisk.com/piqa/data/)| Raisonnement et bon sens | 20K situations physiques de raisonnement et de bon sens | Choisir la bonne action Ă  faire Ă  partir d'un contexte et de rĂ©ponses.

[Papier](https://arxiv.org/abs/1911.11641) | | +| [PopularBooksCorpus_HELM](https://drive.google.com/file/d/1RT29rRKNNXKgZBhXNbqevLwR440g44it/view) | Génération, mémorisation | 20 livres de BooksCorpus qui apparaissent dans une liste de best-sellers. | Tùche : à partir d'un nombre aléatoire de tokens commençant par le premier paragraphe du livre, le modÚle doit générer une suite - mesurer la reproduction exacte et quasi-exacte.

[Papier](https://arxiv.org/abs/2211.09110) | | +| [QuAC](https://quac.ai/) | Compréhension de la lecture en contexte | 100K questions de QA à la recherche d'informations (Wikipédia a été utilisé pour générer le jeu de données) | [Papier](https://aclanthology.org/D18-1241/) | | +| [RACE](https://www.cs.cmu.edu/~glai1/data/race/) | Compréhension de la lecture en contexte | 100K questions de l'examen de compréhension écrite en anglais pour les élÚves chinois du collÚge et du lycée | [Papier](https://aclanthology.org/D17-1082/) | | +| [RAFT](https://huggingface.co/datasets/ought/raft) | Tùche réelle, classification de textes | Compilation de 11 jeux de données de tùches de classification naturelles, comprenant entre 150 et 5 000 éléments de test.| Tùche : en quelques clics à partir de 50 exemples étiquetés, fournir des étiquettes significatives.
Domaines : médical, finance, recherche, langue anglaise, droit, physique, sécurité de l'IA, réseaux sociaux.

[Papier](https://arxiv.org/abs/2109.14076) | Corpus : ADE Corpus v2, Banking77, NeurIPS 2020 impact statement risks, OneStopEnglish, Overrruling, Systematic review inclusion, TAI safety research, Terms of Service, TweetEval Hate, Twitter complaints, + Semiconductor org types | +| [RealToxicityPrompts](https://allenai.org/data/real-toxicity-prompts) | Génération, Détection de toxicité | 100K phrases naturelles (sélectionnées dans le corpus OpenWebText, en gros reddit, et notées pour leur toxicité avec PerspectiveAPI) divisées en deux pour créer une instruction et une suite. | Tùche : générer la suite depuis le début de la phrase, puis la toxicité évaluée avec PerspectiveAPI

[Papier](https://arxiv.org/abs/2009.11462) | | +| [ReCoRD](https://super.gluebenchmark.com/tasks) | ComprĂ©hension du langage | 120K exemples de requĂȘtes/rĂ©ponses de passage/cloze provenant de la presse (CNN, DailyMail) avec filtrage humain| [Papier](https://arxiv.org/abs/1810.12885) | | +| [RTE](https://super.gluebenchmark.com/tasks) | ComprĂ©hension du langage| 3K compilations de donnĂ©es de compĂ©tition sur l'implication | [Papier](https://w4ngatang.github.io/static/papers/superglue.pdf) | | +| SAT analogies ([dev](https://goo.gl/XWjas1) & [test](https://goo.gl/BcTtB4)) | ComprĂ©hension du langage | 374 problĂšmes d'analogie SAT avant 2005 (a est Ă  b ce que c est aux questions Ă  choix multiples ; les mots ne sont pas les plus frĂ©quents) | [Papier](https://arxiv.org/pdf/2005.14165.pdf) | | +| [SQuADv2](https://rajpurkar.github.io/SQuAD-explorer/) | ComprĂ©hension Ă©crite en contexte | Combine SQuAD avec 50K questions sans rĂ©ponse | A partir d'un contexte, donner une rĂ©ponse, mais seulement si possible

[Papier](https://arxiv.org/abs/1806.03822) | | +| [StoryCloze](https://huggingface.co/datasets/story_cloze) | Cloze/Complétion, Bon Sens | 50K histoires de bon sens en 5 phrases | Choisir la bonne fin

[Papier](https://aclanthology.org/N16-1098/) | | +| StrategyQA | Bon sens, raisonnement | 2,8K questions nĂ©cessitant un raisonnement Ă  partir de connaissances implicites | [Papier](https://arxiv.org/abs/2101.02235) | Meilleurs rĂ©sultats avec une calculatrice externe ajoutĂ©e | +| [Synthetic reasoning (natural)](https://github.com/stanford-crfm/helm/blob/main/src/helm/benchmark/scenarios/synthetic_reasoning_natural_scenario.py) | Raisonnement logique | DonnĂ©es synthĂ©tiques gĂ©nĂ©rĂ©es Ă  la volĂ©e, contenant un ensemble de rĂšgles synthĂ©tiques (dĂ©clarations conditionnelles), des faits (attributs) et la sortie logique | [Papier](https://arxiv.org/abs/2211.09110) | Également appelĂ© rule_induct dans HELM | +| [Synthetic reasoning (symbolic)_HELM](https://github.com/stanford-crfm/helm/blob/main/src/helm/benchmark/scenarios/synthetic_reasoning_scenario.py) | Raisonnement logique, manipulation symbolique | DonnĂ©es synthĂ©tiques gĂ©nĂ©rĂ©es Ă  la volĂ©e Ă  l'aide d'un modĂšle. | Soit tester si le modĂšle est capable d'identifier des motifs (« plage + plage - poire » a pour motif « A + A - B ») ou si le modĂšle peut substituer des chaĂźnes de caractĂšres dans un motif donnĂ©

[Papier](https://arxiv.org/abs/2211.09110) | | +| [TriviaQA](https://nlp.cs.washington.edu/triviaqa/) | Domaine ouvert/livre fermé, QA| 95K trivia QA (questions de composition, variabilité syntaxique)| [Papier](https://aclanthology.org/P17-1147/) | | +| [TruthfulQA](https://github.com/sylinrl/TruthfulQA) | QA | 817 questions sur des affirmations factuelles délicates (idées fausses, mensonges, ...) réparties en 38 catégories, avec des réponses de référence vraies et fausses + une source pour étayer les réponses vraies (+ 380 questions supplémentaires) | [Papier](https://arxiv.org/abs/2109.07958) | | +| [TyDiQA-GoldP](https://github.com/google-research-datasets/tydiqa) | Multilingue, QA | 204K paires multilingues de QA (formulation de questions sans contrainte à partir de prompts, puis recherche d'articles dans Wikipédia et sélection de réponses spécifiques dans l'article si possible) (en, ar, bn, fi, id, ja, ko, ru, te, th and sw). | QCM

[Papier](https://aclanthology.org/2020.tacl-1.30/) | Le jeu de donnĂ©es gĂ©nĂ©rĂ© peut prĂ©senter une sous-spĂ©cification intĂ©ressante des questions et une inadĂ©quation entre le niveau de langue des questions et des rĂ©ponses. Peut ĂȘtre plus difficile que d'autres jeux de donnĂ©es. | +| Web Questions | Domaine ouvert/livre fermĂ©, QA| Extraction de 100K questions commençant par « Wh ? » Ă  partir de l'API de recherche Google, puis annotation par MTurkers - je soupçonne que les rĂ©ponses sont en partie obsolĂštes | QCM

[Papier](https://aclanthology.org/D13-1160/) | [Site](https://nlp.stanford.edu/software/sempre/)| +| [WebNLG](https://huggingface.co/datasets/web_nlg) | GĂ©nĂ©ration, verbalisation | 13K correspondances entre les triplets (sujet, propriĂ©tĂ©, objet, construits Ă  partir de DBPedia, qui est une KB de Wikipedia) et la verbalisation de phrases (par des travailleurs de foule), sur des sujets spĂ©cifiques (astronautes, universitĂ©s, monuments, bĂątiments, personnages de bandes dessinĂ©es, nourriture, aĂ©roports, Ă©quipes sportives, Ɠuvres Ă©crites) | TĂąche : verbaliser de maniĂšre grammaticale

[Papier](https://aclanthology.org/P17-1017.pdf) | Il y a eu une sĂ©lection de phrases pour la fluiditĂ© et les phrases gĂ©nĂ©rĂ©es sont relativement simples, mais il n'y a pas de description des origines des annotateurs/crowdsourcers -> peut-ĂȘtre que certaines donnĂ©es ne sont pas en « anglais standard » | +| WiC | ComprĂ©hension linguistique | 7K, classification permettant de dĂ©terminer si un mot apparaissant dans deux contextes diffĂ©rents a le mĂȘme sens ou non | [Papier](https://aclanthology.org/N19-1128/) | [Site](https://super.gluebenchmark.com/tasks) | +| [WikiFact_HELM](https://github.com/stanford-crfm/helm/blob/main/src/helm/benchmark/scenarios/wikifact_scenario.py) | Cloze/ComplĂ©tion | 12 domaines avec 1K triples (sujet, relation, objet) Ă©chantillonnĂ©s Ă  partir de Wikipedia et nettoyĂ©s | TĂąche : prĂ©dire l'Ă©lĂ©ment manquant dans la phrase composĂ©e de la relation

[Papier](https://arxiv.org/abs/2211.09110) | | +| [WikiLingua](https://github.com/esdurmus/Wikilingua) | Génération, multilingue, résumé | 43K paires article/résumé construites à partir de WikiHow en 18 langues (sur le site, les articles sont rédigés avec une phrase de résumé + un paragraphe détaillé par étape : dans le jeu de données, les résumés sont la concaténation des phrases de résumé, et les articles des paragraphes détaillés)| Résumé

[Papier](https://aclanthology.org/2020.findings-emnlp.360/) | Palm : PrĂ©fixĂ© par une instruction, article tronquĂ© Ă  2048 tokens. Je soupçonne que la crĂ©ation des donnĂ©es peut conduire Ă  un langage trĂšs « robotique » pour la ligne de base du rĂ©sumĂ©, ce qui pourrait mettre en Ă©vidence des rĂ©sumĂ©s plus fluides - bien que ROUGE ne devrait pas ĂȘtre trop enclin Ă  cela. | +| Winogender | DĂ©tection de biais | | | | +| [Winograd](https://cs.nyu.edu/~davise/papers/WinogradSchemas/WSCollection.xml) | Raisonnement, Winograd | 273 Ă  285 exemples oĂč il faut dĂ©sambiguĂŻser qui/Ă  quoi se rĂ©fĂšre un pronom dans une phrase spĂ©cialement construite pour ĂȘtre ambiguĂ« pour les statistiques et non pour les humains | DĂ©sambiguĂŻsation du pronom

[Papier](https://dl.acm.org/doi/10.5555/3031843.3031909) | Je ne sais pas si GPT3 a été évalué sur celui-ci ou sur le SuperGLUE. | +| [WinoGrande](https://super.gluebenchmark.com/tasks) | Raisonnement, Winograd | 43K phrases Adversarial Winograd | [Papier](https://arxiv.org/abs/1907.10641) | [Site](https://winogrande.allenai.org/) | +| WSC | Compréhension linguistique, Winograd | WinoGrad Schema Challenge (voir Winograd) | [Papier](https://w4ngatang.github.io/static/papers/superglue.pdf) | | +| [XSUM](https://github.com/EdinburghNLP/XSum) | Résumé | 226K articles (BBC de 2010 à 2017) correspondant à leur résumé en une seule phrase (tirée de l'article) | Tùche : Résumer.
Domaines : Actualités, politique, sports, météo, affaires, technologie, science, santé, famille, éducation, divertissement et arts.

[Papier](https://aclanthology.org/D18-1206/) | | +| [XSum](https://huggingface.co/datasets/xsum) | GĂ©nĂ©ration, rĂ©sumĂ© | 226K paires de rĂ©sumĂ©s/articles de la BBC (2010 - 2017) extraites de WayBack machine | [Papier](https://aclanthology.org/D18-1206/) | Il pourrait ĂȘtre intĂ©ressant de vĂ©rifier manuellement si les connaissances rĂ©centes du modĂšle crĂ©ent des divergences dans les rĂ©sumĂ©s des anciennes dĂ©pĂȘches. | +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown(""" +### IdĂ©es de jeu de donnĂ©es Ă  reproduire manuellement + +| Nom | Type de tĂąche | Contenu de la tĂąche | Papier | Commentaires | +| --- | --- |--- |--- |--- | +| ✍ GSM8K-Python | Code, Text-to-code | Version Python du jeu de donnĂ©es GSM8K (8,5K problĂšmes de mathĂ©matiques de l'Ă©cole primaire) | [Papier](https://arxiv.org/abs/2204.02311) | | | +| [✍ MRF](https://drive.google.com/uc?export=download&id=1uVJbsgPCHFAvH43I6SVvU3Ayo8dh-y_N) | GĂ©nĂ©ration, Ă©valuation manuelle, capacitĂ©s de dĂ©sinformation | 250 titres extraits du jeu de donnĂ©es MRF, regroupĂ©s en 80 clusters par thĂšse. TĂąche : Ă  partir de la thĂšse + 5 titres, le modĂšle doit gĂ©nĂ©rer des titres plausibles qui soutiennent la thĂšse. Les annotateurs Ă©valuent si 1) le titre soutient la thĂšse et 2) semble rĂ©el. | [Papier](https://arxiv.org/abs/2211.09110) | Voir [page 6](https://cset.georgetown.edu/publication/truth-lies-and-automation/) pour une explication dĂ©taillĂ©e du processus original, ainsi que les sections 8.5.2, E.5 et 5.5 du papier HELM. | +| ✍ GĂ©nĂ©ration d'articles de presse | GĂ©neration | GĂ©nĂ©ration de 25 articles Ă  partir de titres et de sous-titres, 80 humains devant dĂ©terminer s'ils sont gĂ©nĂ©rĂ©s ou originaux. | [Papier](https://arxiv.org/abs/2005.14165)| | | +| [✍ PrĂ©diction en matiĂšre de calcul](https://github.com/stanford-crfm/helm/blob/main/src/helm/benchmark/scenarios/numeracy_scenario.py)) | Manipulation symbolique | Le modĂšle doit effectuer une rĂ©gression symbolique Ă  partir de quelques exemples et appliquer la relation entre les nombres Ă  une nouvelle donnĂ©e. | [Papier](https://arxiv.org/abs/2211.09110) | | +| [✍ Jeux de donnĂ©es SVG](https://twitter.com/zswitten/status/1631178997508997120) | | PossibilitĂ© de construire un jeu de donnĂ©es SVG pour voir si les modĂšles peuvent effectivement gĂ©nĂ©rer ou interprĂ©ter des dessins SVG | | | +| ✍ Jeux de donnĂ©es sur la thĂ©orie de l'esprit | | Pourrait probablement ĂȘtre facile Ă  gĂ©nĂ©rer | [Papier](https://arxiv.org/abs/2302.08399)| | +| [✍ *Wedging prompts*](https://drive.google.com/uc?export=download&id=1kWB3_F4Tobc_oVGC_T-a5DHEh-AB4GTc) | GĂ©nĂ©ration, Ă©valuation manuelle, capacitĂ©s de dĂ©sinformation | 11 prompts avec des intentions spĂ©cifiques (ex : influencer les comportements de vote, cibler des groupes spĂ©cifiques en gĂ©nĂ©rant une rhĂ©torique pro/anti X) augmentĂ©s de 3 exemples.
Tùche : générer des exemples de suivi. | [Papier](https://cset.georgetown.edu/wp-content/uploads/CSET-Truth-Lies-and-Automation.pdf) | Dans HELM : utiliser l'évaluation manuelle pour déterminer si le message généré
1) s'adresse au groupe ciblé ;
2) soutient le message souhaité ;
3) est source de discorde. | +| ✍ Mots mĂȘlĂ©s | Manipulation symbolique | 10K exemples pour 5 tĂąches de 5 tĂąches de manipulation de caractĂšres (mot avec lettres cycliques, anagramme, insertions alĂ©atoires, inversĂ©).
Le modÚle doit retrouver le mot original | [Papier](https://arxiv.org/abs/2005.14165) | Facile à générer/automatiser, voir section 3.9.2 du papier de GPT3 | +""", unsafe_allow_html=True) + + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section précédente', use_container_width=True): + switch_page("II.2._Concevoir_votre_évaluation_automatisée") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("II.4._Conseils et astuces") \ No newline at end of file diff --git a/pages/8_II.4._Conseils et astuces.py b/pages/8_II.4._Conseils et astuces.py new file mode 100644 index 0000000000000000000000000000000000000000..63a793e1b159e0e800f40ad6d60671b1c5154c0e --- /dev/null +++ b/pages/8_II.4._Conseils et astuces.py @@ -0,0 +1,101 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown( + """ + ## Conseils et astuces + +### Gestion de la contamination +En général, vous devez partir du principe qu'un jeu de données accessible au public sur l'internet est ou sera contaminé. + +Les solutions pour y remédier sont les suivantes :
+- fournir une « ***canary string*** » dans l'échantillon d'évaluation (comme dans [BigBench](https://github.com/google/BIG-bench)) : il s'agit d'une combinaison de caractÚres spécifique que les créateurs de modÚles peuvent rechercher dans leurs échantillons d'entraßnement, ce qui indiquerait qu'ils contiennent une fuite.
+- fournir des Ă©chantillons d'Ă©valuation sous forme **[cryptĂ©e](https://arxiv.org/abs/2309.16575) ou [fermĂ©e](https://huggingface.co/datasets/Idavidrein/gpqa)** afin qu'ils ne puissent pas ĂȘtre analysĂ©s facilement par les bots d'indexation et ne se retrouvent donc pas accidentellement dans les donnĂ©es d'entraĂźnement.
+- l'exĂ©cution de [jeux d'Ă©valuation dynamiques](https://arxiv.org/abs/2104.14337) : les jeux d'Ă©valuation sont rĂ©guliĂšrement mis Ă  jour au fil du temps afin que les modĂšles ne puissent pas « apprendre les rĂ©ponses par cƓur » (cela augmente nĂ©anmoins le coĂ»t de la conception des jeux de donnĂ©es).
+- si vous exécutez un jeu d'évaluation, essayez de [détecter la contamination](https://arxiv.org/abs/2311.06233) post-hoc (par exemple, en examinant la perplexité de la génération ou en concevant des versions contradictoires des *prompts* ; cependant, aucune méthode n'est infaillible pour détecter la contamination). + +Toutefois, ce n'est pas parce qu'un jeu de données est contaminé qu'il ne sera pas intéressant et qu'il n'aura pas de signal pendant l'entraßnement. +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) + +st.markdown( + """ +### Problématiques pratiques que vous pourriez rencontrer + +##### ModÚles finetunés, instruction systÚme et gabarits de chat +Un certain nombre de modÚles finetunés sur des instructions vont donner de trÚs mauvais résultats si vous ne veillez pas à :
+- ajouter leur instruction systÚme au tout début de l'inférence
+- utiliser une instruction suivant un gabarit de chat (en général en ajoutant les préfixes `Assistant` et `User` aux différents tours du dialogue). Pour en savoir plus, consultez [ce guide](https://huggingface.co/docs/transformers/main/en/chat_templating).
+ +Il est Ă©galement trĂšs important de ne pas supposer que les diffĂ©rents *tokenizers* se comporteront de la mĂȘme maniĂšre, en particulier en ce qui concerne les gabarits de chat, comme vous pouvez le voir dans cette image tirĂ©e de [ce tweet](https://x.com/danielhanchen/status/1796952220619157694). +""", unsafe_allow_html=True) +st.markdown(""" """) + +st.image("https://pbs.twimg.com/media/GPANfpiasAA9b6F?format=png&name=medium", caption='Espacement, tokenisation et gabarit', use_container_width=True) + +st.markdown(""" """) +st.markdown( + """ + ##### TokĂ©nisation + +1. **TokĂ©niser le contexte et les choix ensemble ou sĂ©parĂ©ment** + +Lorsque l'on regarde une Ă©valuation MCQA, en gĂ©nĂ©ral, on veut tokĂ©niser le contexte en mĂȘme temps que les choix possibles, car cela crĂ©e une succession de *tokens* qui est probable/naturelle pour le modĂšle. + +Cependant, certains *tokenizers* (comme celui du [Llama 1](https://github.com/EleutherAI/lm-evaluation-harness/pull/531#issuecomment-1595586257)) ne satisfont pas `enc(contexte + choix) = enc(contexte) + enc(choix)` (et ajoutent ou enlĂšvent l'espacement). Cela signifie que la comparaison des log-probabilitĂ©s des choix n'est pas aisĂ©e car les *tokens* de contexte peuvent « dĂ©border » dans ces log-probabilitĂ©s, ce qui perturbe la comparaison. + +Donc, si c'est le cas pour votre modĂšle, vous pourriez vouloir calculer les *tokens* de contexte et de choix sĂ©parĂ©ment, puis les concatĂ©ner aprĂšs avoir supprimĂ© les *tokens* spĂ©ciaux de dĂ©but et de fin de phrase qui auraient pu ĂȘtre ajoutĂ©s. + +2. **Attention aux *tokens* de dĂ©but et de fin de phrase** + +Certains modĂšles, comme les [Gemma](https://huggingface.co/collections/google/googles-gemma-models-family-675bfd70e574a62dd0e406bd), sont extrĂȘmement sensibles Ă  l'[inclusion des *tokens* de dĂ©but de phrase](https://github.com/EleutherAI/lm-evaluation-harness/pull/1465) lors de l'infĂ©rence. Vous pourriez avoir besoin de faire quelques expĂ©riences pour voir si cela se produit pour vous, et ajouter ces *tokens* manuellement lors de l'Ă©valuation. + +Vous pouvez Ă©galement rencontrer des problĂšmes oĂč votre modĂšle ne s'arrĂȘtera pas sur un *token* de fin de phrase comme vous l'attendez (par exemple, sur `\\n`). En effet, votre modĂšle peut ne pas prĂ©dire ce *token* seul mais faisant parti d'un *token* de niveau supĂ©rieur (par exemple, `\\n\\n`, qui peut ĂȘtre un unique *token*, en particulier pour les modĂšles de code). Dans ce cas, vous pourriez avoir besoin d'ajouter une vĂ©rification spĂ©cifique pour « revenir en arriĂšre » sur le texte gĂ©nĂ©rĂ© afin de vous assurer que vous coupez votre phrase gĂ©nĂ©rĂ©e au bon endroit avant de calculer les mĂ©triques. + +3. **Multilinguisme et tokĂ©nisation** + +Dans le cadre d'Ă©valuations multilingues, vous devrez Ă©galement dĂ©terminer la façon de tokĂ©niser votre texte, en fonction de votre tĂąche d'Ă©valuation et de vos mĂ©triques. Comme certaines langues n'utilisent pas toujours l'espacement comme sĂ©parateur de mots (corĂ©en, thaĂŻlandais, japonais, chinois, pour n'en citer que quelques-unes), elles nĂ©cessiteront des *tokenizers* spĂ©cifiques Ă  la langue pour ĂȘtre scindĂ©es correctement, sinon cela affectera leurs scores sur des mĂ©triques telles que [BLEU](https://github.com/EleutherAI/lm-evaluation-harness/issues/212). + +4. **Évaluation du code et *tokens* de fin de phrase** + +Les modĂšles de code ont gĂ©nĂ©ralement Ă©tĂ© entraĂźnĂ©s avec `\\n\\t` comme *token* unique. Cela signifie que lorsqu'ils gĂ©nĂšrent du texte, ils gĂ©nĂšrent souvent `\\n\\t` en une seule Ă©tape. Une tĂąche qui dĂ©finit `\\n` comme *token* de fin de phrase (= pour arrĂȘter la gĂ©nĂ©ration) laissera le modĂšle continuer Ă  gĂ©nĂ©rer aprĂšs un `\\n\\t` puisque c'est un *token* diffĂ©rent de `\\n` alors que vous souhaitez que le modĂšle s'arrĂȘte. Dans ce cas, vous devez soit mettre Ă  jour vos *tokens* de fin de phrase, soit dĂ©finir un mĂ©canisme permettant de revenir sur la reprĂ©sentation des caractĂšres des derniers *tokens* gĂ©nĂ©rĂ©s pour arrĂȘter (et couper) la gĂ©nĂ©ration a posteriori. +""", unsafe_allow_html=True) +st.markdown(""" """) + +st.markdown(""" +##### AccĂ©lĂ©rer facilement les Ă©valuations des QCM +Vous pouvez accĂ©lĂ©rer considĂ©rablement vos prĂ©dictions de cette tĂąche si vous vous assurez que votre modĂšle n'a besoin de prĂ©dire qu'un seul *token* pour la tĂąche. + +De cette façon, au lieu d'exĂ©cuter vos prĂ©dictions sur le nombre de choix (`contexte + choix 1`, `contexte + choix 2`, etc.), vous pouvez simplement exĂ©cuter l'infĂ©rence sur le `contexte` et calculer la distribution de probabilitĂ© sur le vocabulaire complet pour obtenir vos log-probabilitĂ©s d'intĂ©rĂȘt, et faire cette Ă©tape en une seule passe.
+C'est ainsi que nous procédons dans [lighteval](https://github.com/huggingface/lighteval). +""", unsafe_allow_html=True) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" +### Mauvais résultats lors d'une évaluation générative + +La premiÚre chose à faire est de toujours inspecter en détail les générations de votre modÚle. Les éléments les plus fréquents à rechercher lors du diagnostic d'erreurs sont les suivants :
+- une analyse trop stricte de la sortie du modÚle (avant le calcul de la métrique) qui entraßne la perte de la réponse.
+ - RĂ©solution : adaptez votre analyse.
+- incapacité des modÚles à suivre le format de sortie donné dans les exemples (fréquent dans les modÚles récents entraßnés avec des données d'instructions, comme Llama 3.2 ou Qwen 2.5)
+ - RĂ©solution : soit vous adaptez le format de votre instruction, soit vous supposez que les modĂšles devraient ĂȘtre capables de le suivre.
+- modÚle excessivement verbeux qui n'arrive jamais à la bonne réponse (plus fréquent dans les modÚles à long contexte, que nous avons observé avec les modÚles Qwen et CommandR)
+ - RĂ©solution : soit augmenter la longueur autorisĂ©e du contexte, soit ajouter des dĂ©tails dans l'instruction afin d'ĂȘtre concis, soit simplement supposer que les modĂšles devraient ĂȘtre capables de rĂ©pondre succinctement. +""", unsafe_allow_html=True) + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("II.3._Quelques_jeux_de_donnĂ©es_d'Ă©valuation") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Chapitre suivant", use_container_width=True): + switch_page("III._Évaluation_humaine") \ No newline at end of file diff --git "a/pages/9_III._\303\211VALUATION_HUMAINE.py" "b/pages/9_III._\303\211VALUATION_HUMAINE.py" new file mode 100644 index 0000000000000000000000000000000000000000..82685181dbbde5b8fdba08a0bb740e004403b8d1 --- /dev/null +++ "b/pages/9_III._\303\211VALUATION_HUMAINE.py" @@ -0,0 +1,24 @@ +import streamlit as st +st.set_page_config(layout="wide") +from streamlit_extras.switch_page_button import switch_page + +st.markdown("""## Évaluation humaine""") +st.markdown(""" """) + +st.markdown(""" +Dans ce chapitre, nous dĂ©finissons le concept d'Ă©valuation humaine en donnant notamment des indications sur la maniĂšre de recourir Ă  des annotateurs humains. Nous terminons par des conseils et astuces utiles Ă  connaĂźtre sur ce sujet.""") + + +st.markdown(""" """) +st.markdown(""" """) +st.markdown(""" """) +col1, col2, col3= st.columns(3) +with col1: + if st.button('Section prĂ©cĂ©dente', use_container_width=True): + switch_page("II.4._Conseils et astuces") +with col2: + if st.button("Accueil", use_container_width=True): + switch_page("Home") +with col3: + if st.button("Section suivante", use_container_width=True): + switch_page("III.1._Bases") \ No newline at end of file diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..07aec85c48f5f456bae61c72a2608594f342ae9d --- /dev/null +++ b/requirements.txt @@ -0,0 +1 @@ +streamlit-extras \ No newline at end of file