pages/14_IV.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.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")