pages/5_II.1._Bases.py

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