pages/15_IV.2._Définir_son_juge.py

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