Upload 44 files

.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

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 !<br> 
+    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** :<br>
+      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 « <a href='I._CONNAISSANCES_GÉNÉRALES' target='_self'>Connaissances générales</a> ». Par exemple, comment fonctionne l'inférence des modèles et ce qu'est la tokenisation.
+    - **Utilisateur avancé** :<br>
+      Les sections les plus pratiques sont les « Conseils et astuces » de chaque chapitre, ainsi que chapitre « <a href='V._DÉPANNAGE' target='_self'>Dépannage</a> ». 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')

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
+---

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 ».<br>Clémentine ayant une préférence pour « sous-unité de mot ».<br>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")

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.<br>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é**<br>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**<br>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**<br>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é**<br>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é**<br>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**<br>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é**<br>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é**<br>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**<br> 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é**<br>Les scores obtenus par les modèles seront explicables par les humains qui les ont annotés.
+
+Les inconvénients ➖ :
+- **Coût**<br>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**<br>À 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é**<br>À 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**<br>Vous comptez sur la bonne volonté des gens.
+- **Découverte de cas limites**<br>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é**<br>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é**<br>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é**<br>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**<br>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")

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.<br>
+    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.<br>
+	 Vos besoins varient en fonction de votre tâche.<br>
+  2) produisent un travail de haute qualité.<br>
+	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**<br>
+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**<br>
+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**<br>
+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.<br> 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/).<br>
+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.<br>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/)<br>
+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")

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 <a href='III.2._Utiliser_des_annotateurs_humains' target='_self'>Utiliser des annotateurs humains</a> 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é**<br>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**<br>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**<br>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**<br>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**<br>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**<br>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**<br>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**<br>Vous pouvez combiner la puissance de la méthodologie du *LLM-as-a-judge* (voir le chapitre <a href='IV._LLM_AS_A_JUDGE' target='_self'>dédié</a>) 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 <a href='III.1._Bases' target='_self'>Bases</a> s'appliquent ici.
+
+- **Identifier les cas limites**<br>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")

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

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é**<br>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**<br>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**<br>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 <a href='IV.6._Conseils et astuces' target='_self'>« Conseils et astuces »</a>). 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")

pages/15_IV.2._Définir_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")

pages/16_IV.3._Concevoir_votre_instruction_d'évaluation.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**<br>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**<br>Vous pouvez aussi ajouter une référence dans votre instruction.
+- **CoT (*Chains of Thought*)**<br>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**<br>Peut améliorer [la détection des erreurs factuelles](https://arxiv.org/abs/2305.13281).
+- **Utiliser un jury**<br>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**<br>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")

pages/16_IV.3._Concevoir_votre_prompt_d'évaluation.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**<br>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**<br>Vous pouvez aussi ajouter une référence à votre *prompt*.
+- **CoT (*Chains of Thought*)**<br>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**<br>Peut améliorer [la détection des erreurs factuelles](https://arxiv.org/abs/2305.13281).
+- **Utiliser un jury**<br>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**<br>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")

pages/17_IV.4._Évaluer_votre_évaluateur.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")

pages/18_IV.5._Modèles de récompense.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**<br>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**<br>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**<br>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**<br>Les mêmes scores seront reproduits par la même passe avant.
+- **Peu susceptibles de souffrir d'un biais de position**<br>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<br>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**<br>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**<br>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")

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**<br>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).<br><u>Atténuation</u> :<br>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**<br>Ils ont tendance à [favoriser leurs propres sorties](https://arxiv.org/abs/2404.13076) lorsqu'ils notent les réponses.<br><u>Atténuation</u>  :<br>Vous pouvez atténuer ce phénomène en utilisant un jury.
+- **Cécité à la perturbation de l'entrée**<br>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.<br><u>Atténuation</u> : 
+	- 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**<br>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.<br><u>Atténuation</u> : 
+	- 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)<br>Ils ont tendance à préférer les réponses plus verbeuses.<br><u>Atténuation</u> :<br>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**<br>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**<br>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.<br><u>Atténuation</u> :<br>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")

pages/1_I._CONNAISSANCES GÉNÉRALES.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")

pages/20_V._DÉPANNAGE.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")

pages/21_V.1._Dépanner l'inférence.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** :
+
+`<mémoire (en GB)> = <nombre de paramètres (en G)> * <facteur de précision>`
+
+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 `<mémoire (en GB)> = <nombre de paramètres (en G)> * (<facteur de précision> * 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 `<facteur de précision>` 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é")

pages/22_V.2._Dépanner la reproductibilité.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).<br>
+→ 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: <texte de la question>
+Choices:
+| A. <Choice A> | (A) <Choice A> | <Choice A> | 
+| B. <Choice B> | (B) <Choice B> | <Choice B> | 
+| C. <Choice C> | (C) <Choice C> | <Choice C> | 
+| D. <Choice D> | (D) <Choice D> | <Choice D> | 
+Answer: 
+```
+et prédire soit `A`/`B`/`C`/`D` ou `<Choice A/B/C/D>`.
+
+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**<br>Pytorch n'assure pas la reproductibilité des opérations non déterministes à travers le matériel.
+- **bibliothèques différentes**<br>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**<br>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**<br>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")

pages/23_V.3_Dépanner les problèmes mathématiques.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 :
+
+<div id="xdihwljbql" style="padding-left:0px;padding-right:0px;padding-top:10px;padding-bottom:10px;overflow-x:auto;overflow-y:auto;width:auto;height:auto;">
+<table class="gt_table" data-quarto-disable-processing="false" data-quarto-bootstrap="false">
+<thead>
+  <tr class="gt_heading">
+    <td colspan="5" class="gt_heading gt_title gt_font_normal">Comparaison du parseur original et corrigé sur le jeu d'évaluation MATH</td>
+  </tr>
+<tr class="gt_col_headings gt_spanner_row">
+  <th class="gt_col_heading gt_columns_bottom_border gt_left" rowspan="2" colspan="1" scope="col" id="Modèle">Modèle</th>
+  <th class="gt_center gt_columns_top_border gt_column_spanner_outer" rowspan="1" colspan="2" scope="colgroup" id="Score">
+    <span class="gt_column_spanner">Score</span>
+  </th>
+  <th class="gt_center gt_columns_top_border gt_column_spanner_outer" rowspan="1" colspan="2" scope="colgroup" id="Rang">
+    <span class="gt_column_spanner">Rang</span>
+  </th>
+</tr>
+<tr class="gt_col_headings">
+  <th class="gt_col_heading gt_columns_bottom_border gt_right" rowspan="1" colspan="1" scope="col" id="Parseur original">Parseur original</th>
+  <th class="gt_col_heading gt_columns_bottom_border gt_right" rowspan="1" colspan="1" scope="col" id="Parseur corrigé">Parseur corrigé</th>
+  <th class="gt_col_heading gt_columns_bottom_border gt_right" rowspan="1" colspan="1" scope="col" id="Parseur original">Parseur original</th>
+  <th class="gt_col_heading gt_columns_bottom_border gt_right" rowspan="1" colspan="1" scope="col" id="Parseur corrigé">Parseur corrigé</th>
+</tr>
+</thead>
+<tbody class="gt_table_body">
+  <tr>
+    <td class="gt_row gt_left">rombodawg/Rombos-LLM-V2.5-Qwen-72b</td>
+    <td class="gt_row gt_right">47,58</td>
+    <td class="gt_row gt_right">50,68</td>
+    <td style="color: #FFFFFF; background-color: #000000;" class="gt_row gt_right">1</td>
+    <td style="color: #FFFFFF; background-color: #000000;" class="gt_row gt_right">1</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">MaziyarPanahi/calme-2.2-qwen2-72b</td>
+    <td class="gt_row gt_right">41,16</td>
+    <td class="gt_row gt_right">43,43</td>
+    <td style="color: #FFFFFF; background-color: #41181f;" class="gt_row gt_right">2</td>
+    <td style="color: #FFFFFF; background-color: #41181f;" class="gt_row gt_right">2</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">arcee-ai/Arcee-Nova</td>
+    <td class="gt_row gt_right">40,48</td>
+    <td class="gt_row gt_right">42,90</td>
+    <td style="color: #FFFFFF; background-color: #82303e;" class="gt_row gt_right">3</td>
+    <td style="color: #FFFFFF; background-color: #82303e;" class="gt_row gt_right">3</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">fblgit/TheBeagle-v2beta-32B-MGS</td>
+    <td class="gt_row gt_right">39,43</td>
+    <td class="gt_row gt_right">42,52</td>
+    <td style="color: #FFFFFF; background-color: #c3495e;" class="gt_row gt_right">4</td>
+    <td style="color: #FFFFFF; background-color: #c3495e;" class="gt_row gt_right">4</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">rombodawg/Rombos-LLM-V2.5-Qwen-32b</td>
+    <td class="gt_row gt_right">39,12</td>
+    <td class="gt_row gt_right">41,99</td>
+    <td style="color: #000000; background-color: #ca6866;" class="gt_row gt_right">5</td>
+    <td style="color: #000000; background-color: #ca6866;" class="gt_row gt_right">5</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">dnhkng/RYS-XLarge</td>
+    <td class="gt_row gt_right">38,97</td>
+    <td class="gt_row gt_right">41,24</td>
+    <td style="color: #000000; background-color: #a58c5e;" class="gt_row gt_right">6</td>
+    <td style="color: #000000; background-color: #a58c5e;" class="gt_row gt_right">6</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">dfurman/CalmeRys-78B-Orpo-v0.1</td>
+    <td class="gt_row gt_right">37,92</td>
+    <td class="gt_row gt_right">40,71</td>
+    <td style="color: #000000; background-color: #6ec352;" class="gt_row gt_right">8</td>
+    <td style="color: #000000; background-color: #80b156;" class="gt_row gt_right">7</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">MaziyarPanahi/calme-2.2-rys-78b</td>
+    <td class="gt_row gt_right">37,92</td>
+    <td class="gt_row gt_right">39,95</td>
+    <td style="color: #000000; background-color: #6ec352;" class="gt_row gt_right">8</td>
+    <td style="color: #000000; background-color: #4cbd81;" class="gt_row gt_right">9</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">MaziyarPanahi/calme-2.4-rys-78b</td>
+    <td class="gt_row gt_right">37,69</td>
+    <td class="gt_row gt_right">40,41</td>
+    <td style="color: #000000; background-color: #4cbd81;" class="gt_row gt_right">9</td>
+    <td style="color: #000000; background-color: #5ece55;" class="gt_row gt_right">8</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">MaziyarPanahi/calme-2.3-rys-78b</td>
+    <td class="gt_row gt_right">36,56</td>
+    <td class="gt_row gt_right">38,97</td>
+    <td style="color: #000000; background-color: #3aacad;" class="gt_row gt_right">10</td>
+    <td style="color: #000000; background-color: #3aacad;" class="gt_row gt_right">10</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">MaziyarPanahi/calme-2.1-rys-78b</td>
+    <td class="gt_row gt_right">36,40</td>
+    <td class="gt_row gt_right">38,90</td>
+    <td style="color: #000000; background-color: #279cd9;" class="gt_row gt_right">11</td>
+    <td style="color: #000000; background-color: #279cd9;" class="gt_row gt_right">11</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">Qwen/Qwen2.5-72B</td>
+    <td class="gt_row gt_right">36,10</td>
+    <td class="gt_row gt_right">38,67</td>
+    <td style="color: #000000; background-color: #23a7e6;" class="gt_row gt_right">12</td>
+    <td style="color: #000000; background-color: #23a7e6;" class="gt_row gt_right">12</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">MaziyarPanahi/calme-2.1-qwen2-72b</td>
+    <td class="gt_row gt_right">36,03</td>
+    <td class="gt_row gt_right">38,07</td>
+    <td style="color: #000000; background-color: #25bce6;" class="gt_row gt_right">13</td>
+    <td style="color: #000000; background-color: #36d0e2;" class="gt_row gt_right">15</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">Qwen/Qwen2-Math-72B-Instruct</td>
+    <td class="gt_row gt_right">35,95</td>
+    <td class="gt_row gt_right">38,14</td>
+    <td style="color: #000000; background-color: #27d2e5;" class="gt_row gt_right">14</td>
+    <td style="color: #000000; background-color: #27d2e5;" class="gt_row gt_right">14</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">dfurman/Qwen2-72B-Orpo-v0.1</td>
+    <td class="gt_row gt_right">35,42</td>
+    <td class="gt_row gt_right">38,14</td>
+    <td style="color: #000000; background-color: #36d0e2;" class="gt_row gt_right">15</td>
+    <td style="color: #000000; background-color: #25bce6;" class="gt_row gt_right">13</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">abacusai/Smaug-Qwen2-72B-Instruct</td>
+    <td class="gt_row gt_right">35,35</td>
+    <td class="gt_row gt_right">37,46</td>
+    <td style="color: #000000; background-color: #6691d6;" class="gt_row gt_right">16</td>
+    <td style="color: #000000; background-color: #d73a91;" class="gt_row gt_right">19</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">anthracite-org/magnum-v1-72b</td>
+    <td class="gt_row gt_right">35,27</td>
+    <td class="gt_row gt_right">37,69</td>
+    <td style="color: #FFFFFF; background-color: #ae33c4;" class="gt_row gt_right">18</td>
+    <td style="color: #000000; background-color: #7e72d0;" class="gt_row gt_right">16</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">alpindale/magnum-72b-v1</td>
+    <td class="gt_row gt_right">35,27</td>
+    <td class="gt_row gt_right">37,69</td>
+    <td style="color: #FFFFFF; background-color: #ae33c4;" class="gt_row gt_right">18</td>
+    <td style="color: #000000; background-color: #7e72d0;" class="gt_row gt_right">16</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">Qwen/Qwen2-72B-Instruct</td>
+    <td class="gt_row gt_right">35,12</td>
+    <td class="gt_row gt_right">37,69</td>
+    <td style="color: #000000; background-color: #d73a91;" class="gt_row gt_right">19</td>
+    <td style="color: #FFFFFF; background-color: #c614be;" class="gt_row gt_right">18</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">dnhkng/RYS-XLarge-base</td>
+    <td class="gt_row gt_right">34,67</td>
+    <td class="gt_row gt_right">37,16</td>
+    <td style="color: #000000; background-color: #e3715f;" class="gt_row gt_right">20</td>
+    <td style="color: #000000; background-color: #e3715f;" class="gt_row gt_right">20</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">Undi95/MG-FinalMix-72B</td>
+    <td class="gt_row gt_right">33,61</td>
+    <td class="gt_row gt_right">36,10</td>
+    <td style="color: #000000; background-color: #f4c314;" class="gt_row gt_right">22</td>
+    <td style="color: #000000; background-color: #eea82d;" class="gt_row gt_right">21</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">abacusai/Dracarys-72B-Instruct</td>
+    <td class="gt_row gt_right">33,61</td>
+    <td class="gt_row gt_right">35,65</td>
+    <td style="color: #000000; background-color: #f4c314;" class="gt_row gt_right">22</td>
+    <td style="color: #000000; background-color: #eac222;" class="gt_row gt_right">22</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">Qwen/Qwen2.5-32B</td>
+    <td class="gt_row gt_right">32,85</td>
+    <td class="gt_row gt_right">35,50</td>
+    <td style="color: #000000; background-color: #d1b64b;" class="gt_row gt_right">23</td>
+    <td style="color: #000000; background-color: #d1b64b;" class="gt_row gt_right">23</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">anthracite-org/magnum-v2-72b</td>
+    <td class="gt_row gt_right">31,65</td>
+    <td class="gt_row gt_right">34,06</td>
+    <td style="color: #000000; background-color: #b7aa75;" class="gt_row gt_right">24</td>
+    <td style="color: #000000; background-color: #b7aa75;" class="gt_row gt_right">24</td>
+  </tr>
+  <tr>
+    <td class="gt_row gt_left">dnhkng/RYS-Huge-bnb-4bit</td>
+    <td class="gt_row gt_right">31,57</td>
+    <td class="gt_row gt_right">33,84</td>
+    <td style="color: #000000; background-color: #9e9e9e;" class="gt_row gt_right">25</td>
+    <td style="color: #000000; background-color: #9e9e9e;" class="gt_row gt_right">25</td>
+  </tr>
+</tbody>
+</table>
+</div>
+""", 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")

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

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 »).<br> 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).<br> 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.<br>É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.<br>É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 <br>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<br>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)<br>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)<br>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.<br>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).<br>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.<br>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.<br>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/)).<br>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.<br>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.<br>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")

pages/2_I.1._Inférence_et_évaluation_des_modèles.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*.<br>
+Pour comprendre cela plus en profondeur, lisez la page <a href='I.2._Tokénisation' target='_self'>Tokénisation</a>.
+    """, 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 ?<br>
+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. <br>
+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. <br>
+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 <a href='IV._LLM_AS_A_JUDGE' target='_self'>*LLM-as-a-judge*</a>). 
+    """, 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.<br>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.<br> 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")

pages/3_I.2._Tokénisation.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.<br>
+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.<br>
+Un vocabulaire **trop grand** peut contenir des mots très rares comme *tokens* (par exemple : `aardvark`), ce qui peut conduire à 2 problèmes.<br>
+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.<br>
+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`).<br>
+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)<br>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/)<br>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")

pages/4_II._BENCHMARKS_AUTOMATISÉS.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")

pages/4_II._JEUX_D'ÉVALUATION_AUTOMATISÉS.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")

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 :<br>
+- un **jeu de données**, composé d'**échantillons**. <br>
+	- Ces échantillons contiennent une entrée pour le modèle, parfois associée à une référence à laquelle comparer les sorties du modèle.<br> 
+	- 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. <br>
+- une **métrique**. <br>
+	- La métrique est un moyen d'évaluer votre modèle.<br>
+	  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).<br>
+	- 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 :<br>
+		- le texte généré par le modèle suite à l'entrée (*évaluation générative*)<br>
+		- la log-probabilité d'une ou plusieurs séquences fournies au modèle (*évaluations à choix multiples*, parfois appelées MCQA, ou *évaluations de perplexité*).<br>
+Pour plus d'informations, vous pouvez consulter la page <a href='I.1._Inférence_et_évaluation_des_modèles' target='_self'>Inférence et évaluation des modèles</a>.
+
+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 ➕ :<br>
+- **Consistance et reproductibilité**<br> 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. <br>
+- **Un passage à l'échelle à un coût limité**<br> Ils constituent l'un des moyens les moins coûteux d'évaluer les modèles à l'heure actuelle.<br>
+- **Compréhension**<br> La plupart des métriques automatisés sont très faciles à comprendre. <br>
+  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)).<br>
+- **Qualité du jeu de données**<br> 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).<br>
+
+Cependant, ils présentent également les limites suivantes ➖ :<br>
+- **Utilisation restreinte pour des tâches plus complexes**<br> 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. <br>
+  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.<br>  
+- **Contamination**<br> 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")

pages/6_II.2._Concevoir_votre_évaluation_automatisée.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 ?**<br>
+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.<br>
+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?**<br>
+Vous voulez savoir :<br>
+	- si le score inter-annotateurs sur les échantillons est élevé (= les annotateurs sont-ils d'accord ?)<br>
+	- et/ou si le jeu de données complet a été examiné par les auteurs.<br>
+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 ?**<br>
+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 :<br>
+- *Pour la qualité* :<br>
+	- les questions sont-elles claires et sans ambiguïté ? <br>
+	- 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.)<br>
+	- 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.)<br>
+- *Pour la pertinence par rapport à votre tâche* :<br>
+	- ces questions correspondent-elles au type de questions sur lesquelles vous souhaitez évaluer un LLM ?<br>
+	- ces exemples correspondent-ils à votre cas d'utilisation ?<br>
+
+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.<br>
+""", 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 <a href="III.2._Utiliser_des_annotateurs_humains" target='_self'>Utiliser des annotateurs humains</a>.
+""", unsafe_allow_html=True)
+st.markdown(""" """)
+
+st.markdown("""
+##### Utilisation de données synthétiques
+- **Utilisation de LLM**<br>
+À 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).<br>
+- **Utilisation de techniques basées sur des règles**<br>
+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 !<br>
+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). <br>
+- Avantages ➕ : <br>
+	- Permet de s'assurer que tous les modèles ont accès à la bonne réponse.<br>
+	- Fournit une approximation de la « confiance » du modèle (et de la calibration).<br>
+	- 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.).<br>
+	- Permet d'obtenir un signal sur les performances des petits modèles. <br>
+- Inconvénients ➖ : <br>
+	- 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.<br>
+	- 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.<br>
+- Avantages ➕ :<br>
+	- 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.<br>
+- Inconvénients ➖ :<br>
+	- Peut être plus difficile à évaluer (voir la partie « Métriques » ci-dessous)<br>
+	- 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.<br>
+
+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.<br>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`, ...)<br>
+ 
+Lorsque vous définissez votre instruction, vous devez être conscient que :<br>
+- même de petits changements sémantiquement équivalents dedans peuvent faire varier les résultats de manière significative (voir la section <a href='V.2._Dépanner la reproductibilité' target='_self'>Dépanner la reproductibilité</a>), et les formats utilisés peuvent avantager ou désavantager des modèles spécifiques.<br>
+	- Comment atténuer ce problème : <br>
+		- Una approche coûteuse est de refaire l'évaluation plusieurs fois avec des variations de l'instruction.<br>
+		- 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.<br>
+- 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.<br>
+- mais les modèles ont maintenant tendance à être surentraînés à des formats d'instruction spécifiques.<br> 
+	- [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.<br>
+	- 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.<br>
+- pour un certain nombre de métriques, vous souhaitez une génération ou une sortie contrainte.<br> 
+  Vous pouvez en apprendre plus à ce sujet dans la partie « Contraindre les sorties du modèle » de la section <a href='I.1._Inférence_et_évaluation_des_modèles.' target='_self'>Inférence et évaluation des modèles</a>.
+""", 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. <br>
+Vous devrez :<br>
+1. décider si vous comparez les générations telles quelles ou si vous les normalisez préalablement. <br>
+	- 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.<br>
+	- 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.<br>
+	- 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.<br>
+2. décider de la manière dont vous comparez la génération avec la référence.<br>
+   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.).<br>
+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<br>
+- permet de générer des cas de test plus facilement (c'est assez facile d'en générer à base de règles)<br>
+- de réduire ainsi le surentraînement<br>
+- 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")

pages/7_II.3._Quelques_jeux_de_données_d'évaluation.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 :<br>
+- 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).<br>
+Note : Ce qui suit serait à actualiser en ajoutant les dates de publication ainsi que des évaluations post LLM à un moment donné.<br>
+- 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 +<br> jeux de données existants | 220 | Problèmes de mathématiques tirés du SAT <br> 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.<br>- 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 <br><br> [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. <br><br> [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)<br>- 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.  <br><br> [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. <br><br> [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   <br><br> [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.<br>- Le jeu de données initial est de 900K lignes et a été filtré manuellement.<br>- Fournit aussi des « équations intermédiaires » (utiles pour tester les CoT si nécessaire)<br>- 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 <br><br> [Papier](https://arxiv.org/abs/1705.04146) | - Destiné à être partiellement utilisé pour l'entraînement<br>- Inclut la justification des problèmes<br>- 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 <br><br> [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.<br>- Axé sur une grande diversité lexicale<br>- 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. <br><br> [Papier](https://arxiv.org/abs/2406.18321)  | - Source : Le livre "Problem-Solving strategies" (Engel, 2008)<br> |
+| [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 <br><br> [Papier](https://arxiv.org/abs/1904.01557) | - Liste complète des domaines dans l'annexe B<br>- La première section du papier est très intéressante<br>- Fournir un code de génération pour générer plus d'exemples<br>- Fournit un échantillon d'entraînement supplémentaire<br>- 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é. <br><br> [Papier](https://arxiv.org/abs/2311.09805) | - Réutilisation de TAT-QA, FinQA, MultiHiertt, TAT-HQA<br>- La qualité des données semble assez élevée !<br>- 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. <br><br> [Papier](https://aclanthology.org/D15-1135.pdf) | - Sources : [algebra.com](https://www.algebra.com/) et [answers.yahoo.com](https://answers.yahoo.com)<br>  |
+| [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<br>- Méthode : annoter manuellement 6K problèmes puis utiliser un classifieur. Entraîner un modèle pour extraire les golds<br>- 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. <br><br> [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.<br>- 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.  <br><br> [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.<br>- L'ensemble est de 8,2K<br>- Le papier ne permet pas de savoir comment les tableaux sont formatés - markdown peut-être ?<br>- 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  <br><br> [Papier](https://arxiv.org/abs/2411.04872) | - Une bonne discussion sur la contamination dans le document<br>- Experts : 60 mathématiciens de 12 pays<br>- Tous les problèmes sont examinés par des pairs<br>- Il s'agit probablement du jeu de données le plus qualitatif actuellement disponible<br>- 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<br>- Les problèmes sont en chinois<br>- Le jeu de données est mis à jour chaque année<br>- Le papier explore un certain nombre de méthodes de notation, y compris des LLM comme juge.<br>- 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 <br><br> [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. <br><br> [Papier](https://arxiv.org/abs/2110.14168v2) | - Meilleurs résultats avec l'ajout d'une calculatrice externe<br>- Toutes les réponses sont des entiers positifs, 50% des réponses sont comprises entre 0 et 8<br>- 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 <br><br> [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<br>- 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 !).<br>- 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) <br><br> [Papier](https://arxiv.org/abs/2211.10435) | - Décrit dans l'annexe H1<br>- 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 <br><br>[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 <br><br> [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 <br><br> [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*<br>- 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 <br><br> [Papier](https://arxiv.org/abs/2010.06823) | - Jeu en  chinois<br>- 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 <br><br> [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.<br>- Jeu en chinois<br>- 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 <br>[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"<br>- 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 <br><br> [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. <br><br> [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 <br><br> [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 <br><br>[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<br>- 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<br>- 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<br>- 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) <br><br> [Papier](https://arxiv.org/abs/2410.07985) | - Sources: IMO, IMC, AoPS forum et wiki<br>- 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.<br>- Comprend un sous-ensemble de physique<br>- é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)  <br><br>[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. <br><br> [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 <br><br> [Papier](https://arxiv.org/abs/2209.14610) | - Source : IXL<br>- Les données tabulaires sont fournies sous forme d'image, de texte semi-structuré et de tableau.<br>- Les réponses sont génératives ou MCQA<br>- 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<br>- 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 <br><br> [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. <br><br> [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 <br><br> [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 <br><br> [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 <br><br> [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/) <br>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 <br><br> [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 <br><br> [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<br><br> [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 <br><br> [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<br><br> [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é. <br><br> [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 <br><br> [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). <br> | 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<br><br> [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é. <br><br> [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. <br><br> [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<br><br>[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 <br><br> [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.<br><br> [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.<br><br> [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 <br><br> [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.<br><br> [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. <br><br>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).<br><br> [Papier](https://sxsong.github.io/doc/21icde-imputation.pdf) | Voir le tableau 2 pour toutes les sources.<br>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 <br><br> [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 <br><br> [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. <br><br> [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) <br><br> [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 <br><br> [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 <br><br> [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 <br><br> [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é)<br><br> [Papier](https://arxiv.org/abs/2211.09110) | [The pile](https://pile.eleuther.ai/ )<br>[BLIMP](https://github.com/alexwarstadt/blimp )<br>[Wikitext](https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-raw-v1.zip )<br>[Twitter AAE](http://slanglab.cs.umass.edu/TwitterAAE/ )<br>[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. <br><br> [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 <br><br> [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. <br><br> [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 <br><br> [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 <br><br> [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.<br><br> [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. <br><br> [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. <br><br> [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. <br><br> [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.<br>Domaines : médical, finance, recherche, langue anglaise, droit, physique, sécurité de l'IA, réseaux sociaux.<br><br> [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 <br><br> [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 <br><br>  [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 <br><br> [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é <br><br> [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 <br><br> [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 <br><br> [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<br><br> [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<br><br> [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é <br><br> [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 <br><br> [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.<br>Domaines : Actualités, politique, sports, météo, affaires, technologie, science, santé, famille, éducation, divertissement et arts. <br><br> [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.<br>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é<br> 1) s'adresse au groupe ciblé ;<br> 2) soutient le message souhaité ;<br> 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é).<br> 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")

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 :<br>
+- 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.<br>
+- 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.<br> 
+- 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).<br>
+- 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 à :<br>
+- ajouter leur instruction système au tout début de l'inférence<br>
+- 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).<br>
+
+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.<br>
+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 : <br>
+- 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.<br>
+    - Résolution : adaptez votre analyse.<br>
+- 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)<br>
+    - Résolution : soit vous adaptez le format de votre instruction, soit vous supposez que les modèles devraient être capables de le suivre.<br>
+- 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)<br>
+    - 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")

pages/9_III._ÉVALUATION_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")

requirements.txt

@@ -0,0 +1 @@
+streamlit-extras