pages/27_Panorama_2023.py

import streamlit as st
st.set_page_config(layout="wide")
from streamlit_extras.switch_page_button import switch_page

st.markdown("""# Panorama 2023""")
st.markdown(""" """)

st.markdown("""        
## 2023, année des LLM ouverts

L'année 2023 a vu un regain d'intérêt du public pour les grands modèles de langage (LLM), et maintenant que la plupart des gens savent ce qu'ils sont et peuvent faire, les débats publics autour de l'*open source* vs *closed source* ont également atteint un large public. Chez Hugging Face, nous suivons les modèles ouverts avec beaucoup d'intérêt, car ils permettent à la recherche d'être reproductible, à la communauté de participer au développement de modèles d'IA, d'examiner plus facilement les biais et les limites des modèles, et réduisent l'impact carbone global de notre domaine en favorisant la réutilisation des points de contrôle (parmi [de nombreux autres avantages](https://huggingface.co/papers/2302.04844)). 

Alors faisons une rétrospective des LLM ouverts de cet année ! 

Notez, que pour que ce document reste gérable, nous n'examinerons pas les modèles de code.
""", unsafe_allow_html=True)
st.markdown(""" """)
st.markdown(""" """)
st.markdown(""" """)
st.markdown("""
### 🍜 Recette pour un LLM pré-entraîné

Tout d'abord, comment obtenons-nous un grand modèle de langage ? (N'hésitez pas à sauter cette section si vous le savez déjà !)

L'**architecture** du modèle (son code) décrit son implémentation spécifique et sa forme mathématique : il s'agit d'une liste de tous ses paramètres, ainsi que de la façon dont ils interagissent avec les entrées. À l'heure actuelle, les LLM les plus performants sont des variations de l'architecture Transformer « décodeur uniquement » (plus de détails dans le [papier original des *transformers*](https://huggingface.co/papers/1706.03762)). 

Le **jeu de données d'entraînement** contient tous les exemples et documents sur lesquels le modèle est entraîné (c'est-à-dire sur lesquels les paramètres sont appris), et donc les motifs spécifiques appris. La plupart du temps, ces documents contiennent du texte, soit en langage naturel (ex : français, anglais, chinois), soit en langage de programmation (ex : Python, C), soit en tout type de données structurées exprimables sous forme de texte (ex : tableaux en markdown ou latex, équations, ...). 

Un ***tokenizer*** définit comment le texte du jeu de données d'entraînement est converti en nombres (car un modèle est une fonction mathématique et a donc besoin de nombres comme entrées). La tokenisation se fait en transformant le texte en sous-unités appelées *tokens* (qui peuvent être des mots, des sous-mots ou des caractères, selon les méthodes de tokenisation). La taille du vocabulaire du *tokenizer* indique le nombre de *tokens* différents qu'il connaît, généralement entre 32k et 200k. La taille d'un jeu de données est souvent mesurée comme le **nombre de *tokens*** qu'il contient une fois divisé en une séquence de ces unités individuelles « atomistiques ». Ces jours-ci les modèles vont de plusieurs centaines de milliards de *tokens* à plusieurs billions de *tokens* !

Les **hyperparamètres d'entraînement** définissent ensuite comment le modèle est entraîné. Dans quelle mesure les paramètres doivent-ils changer pour s'adapter à chaque nouvel exemple ? À quelle vitesse le modèle doit-il être mis à jour ?

Une fois ces paramètres sélectionnés, vous n'avez besoin que de 1) beaucoup de puissance de calcul pour entraîner le modèle et 2) de personnes compétentes (et gentilles) pour exécuter et surveiller l'entraînement. L'entraînement lui-même consistera à instancier l'architecture (création des matrices sur le matériel utilisé pour l'entraînement) et à exécuter l'algorithme d'entraînement sur le jeu de données d'entraînement avec les hyperparamètres mentionnés ci-dessus. Le résultat est un ensemble de **poids**. Il s'agit des paramètres du modèle après l'apprentissage et de ce que la plupart des gens entendent lorsqu'ils discutent de l'accès à un modèle pré-entraîné ouvert. Ces poids peuvent ensuite être utilisés pour l'inférence, c'est-à-dire pour la prédiction sur de nouvelles entrées, par exemple pour générer du texte.

Les LLM pré-entraînés peuvent également être spécialisés ou adaptés à une tâche spécifique après le pré-entraînement, en particulier lorsque les poids sont ouvertement relâchés. Ils sont ensuite utilisés comme point de départ pour des cas d'utilisation et des applications grâce à un processus appelé **finetuning**. Le finetuning consiste à appliquer des étapes d'entraînement supplémentaires sur le modèle sur un jeu de données différent, souvent plus spécialisé et plus petit, afin de l'optimiser pour une application spécifique. Même si cette étape a un coût en termes de puissance de calcul nécessaire, elle est généralement beaucoup moins coûteuse que l'entraînement d'un modèle à partir de zéro, tant sur le plan financier qu'environnemental. C'est l'une des raisons pour lesquelles les modèles pré-entraînés open-source de haute qualité sont très intéressants, car ils peuvent être librement utilisés et développés par la communauté, même lorsque les praticiens n'ont accès qu'à un budget informatique limité. 
""", unsafe_allow_html=True)
st.markdown(""" """)
st.markdown(""" """)
st.markdown(""" """)
st.markdown("""
### 🗝️ 2022, d'une course à la taille à une course aux données
Quels modèles ouverts étaient disponibles pour la communauté avant 2023 ?

Jusqu'au début de l'année 2022, la tendance de l'apprentissage automatique était que plus un modèle était grand (c'est-à-dire qu'il avait de paramètres), meilleures étaient ses performances. En particulier, il semble que les modèles dépassant des seuils de taille spécifiques font alors un bond en capacités, deux concepts qui ont été surnommés « capacités émergentes » et « lois d'échelle ». Les familles de modèles open source pré-entraînés publiées en 2022 ont principalement suivi ce paradigme. 

1. [BLOOM](https://huggingface.co/papers/2211.05100) (*BigScience Large Open-science Open-access Multilingual Language Model*) 
BLOOM est une famille de [modèles](https://huggingface.co/bigscience/bloom) publiée par BigScience, un effort collaboratif comprenant 1000 chercheurs de 60 pays et 250 institutions, coordonné par Hugging Face, en collaboration avec les organisations françaises GENCI et IDRIS. Ces modèles utilisent un *transformer* décodeur, avec des modifications mineures (normalisation post-embedding pour rendre l'apprentissage plus stable et utilisation d'embeddings positionnels ALiBi qui introduisent une pénalité lorsque des *tokens* trop éloignés dans une séquence sont connectés ensemble). Le plus grand modèle de cette famille est un modèle de 176 milliards de paramètres, entraîné sur 350 milliards de *tokens* de données multilingues dans 46 langues humaines et 13 langages de programmation. La plupart des données d'entraînement ont été publiées, et les détails de leurs sources, de leur conservation et de leur traitement ont été publiés. Il s'agit du plus grand modèle open source massivement multilingue à ce jour.

2. [OPT](https://huggingface.co/papers/2205.01068) (*Open Pre-trained Transformer*)
La famille des modèles [OPT](https://huggingface.co/facebook/opt-66b) a été lancée par Meta. Ces modèles utilisent une architecture de *transformer* décodeur, suivant les astuces du papier de GPT-3 (initialisation de poids spécifiques, pré-normalisation), avec quelques modifications du mécanisme d'attention (alternance de couches d'attention denses et localement bandées). Le plus grand modèle de cette famille est un modèle de paramètres 175B entraîné sur 180 milliards de *tokens* de données provenant principalement de sources publiques (livres, données sociales via Reddit, actualités, Wikipédia et autres sources Internet diverses). Cette famille de modèles avait des performances comparables à celles des modèles GPT-3, en utilisant des optimisations pour la rendre moins gourmande en calcul.

3. [GLM-130B](https://huggingface.co/papers/2210.02414) (*General Language Model*)
[GLM-130B](https://huggingface.co/THUDM/glm-roberta-large) a été publié par l'Université Tsinghua et Zhipu.AI. Il utilise un transformer complet avec quelques modifications (post-normalisation de couche avec DeepNorm, embeddings rotatifs). Le modèle de paramètres 130B a été entraîné sur 400 milliards de *tokens* de données Internet en anglais et en chinois (The Pile, Wudao Corpora, et d'autres corpus chinois). Il a également des performances comparables à celles des modèles GPT-3.

4. LLM ouverts plus petits ou plus spécialisés
Des modèles open-source plus petits ont également été publiés, principalement à des fins de recherche : Meta a publié la série [Galactica](https://huggingface.co/papers/2211.09085), LLM  allant jusqu'à [120B](https://huggingface.co/facebook/galactica-120b) de paramètres, pré-entraînée sur 106B de *tokens* de littérature scientifique, et EleutherAI a publié le modèle [GPT-NeoX-20B](https://huggingface.co/EleutherAI/gpt-neox-20b), un *transformer* décodeur entièrement open source (architecture, poids, données incluses) entraîné sur 500B de *tokens* (en utilisant RoPE et quelques modifications de l'attention et de l'initialisation), pour fournir un artefact complet pour les investigations scientifiques.

Ces énormes modèles étaient passionnants mais aussi très coûteux à faire fonctionner ! Lors de l'exécution d'une inférence (calcul des prédictions à partir d'un modèle), le modèle doit être chargé en mémoire, mais un modèle de 100 B de paramètres nécessitera généralement 220 Go de mémoire pour être chargé (nous expliquons ce processus ci-dessous), ce qui est très volumineux et n'est pas accessible à la plupart des organisations et des praticiens !

Cependant, en mars 2022, un [nouvel article](https://huggingface.co/papers/2203.15556) de DeepMind est sorti, étudiant quel est le rapport optimal entre les *tokens* et les paramètres du modèle pour un budget de calcul donné. En d'autres termes, si vous n'avez qu'un montant X à dépenser pour l'entraînement du modèle, quelles doivent être les tailles respectives du modèle et des données ? Les auteurs ont découvert que, dans l'ensemble, pour le budget de calcul moyen consacré aux LLM, les modèles devraient être plus petits, mais entraînés sur beaucoup plus de données. Leur propre modèle, Chinchilla (non open source), était un modèle de paramètres de 70B (un tiers de la taille des modèles ci-dessus) mais entraîné sur 1,4T de *tokens* (entre 3 et 4 fois plus de données). Il avait des performances similaires ou supérieures à celles de ses homologues plus grands, à la fois open source et source fermée.

Ce changement de paradigme, bien que probablement déjà connu dans les laboratoires fermés, a pris d'assaut la communauté de la science ouverte.
""", unsafe_allow_html=True)
st.markdown(""" """)
st.markdown(""" """)
st.markdown(""" """)
st.markdown("""
### 🌊 2023, une année de sorties ouvertes

#### L'essor de plsu petits modèles de langage
L'année 2023 a vu l'émergence d'une vague de *transformers* décodeur, avec de nouveaux modèles pré-entraînés sortis chaque mois, et bientôt chaque semaine voire chaque jour : LLaMA (par Meta) en février, StableLM (par StabilityAI) et Pythia (par Eleuther AI) en avril, MPT (par MosaicML) en mai, X-GEN (par Salesforce) et Falcon (par TIIUAE) en juin, Llama 2 (par Meta) en juillet,  StableLM v2 (par StabilityAI) en août, Qwen (par Alibaba) et Mistral (par Mistral.AI) en septembre, Yi (par 01-ai) en novembre, DeciLM (par Deci), Phi-2 et SOLAR (par Upstage) en décembre. 

Toutes ces versions a) incluaient des poids de modèle (sous des licences plus ou moins ouvertes) et b) avaient de bonnes performances pour les modèles plus petits (entre 3B et 70B de paramètres), et donc, ils ont été instantanément adoptés par la communauté. Presque tous ces modèles utilisent l'architecture *transformer* décodeur, avec divers ajustements (ALiBi ou RoPE, pré-normalisation RMS, SwiGLU), ainsi que quelques modifications des fonctions d'attention (Flash-Attention, GQA, fenêtres coulissantes) et différentes implémentations de base de code pour optimiser la vitesse d'entraînement ou d'inférence. Ces ajustements sont susceptibles d'affecter les performances et la vitesse d'entraînement dans une certaine mesure. Cependant, comme toutes les architectures ont été publiées publiquement avec les poids, les principales différences qui subsistent sont les données d'entraînement et la licence des modèles.

La première famille de modèles de cette série était la famille [LLaMA](https://huggingface.co/papers/2302.13971), publiée par Meta AI. L'objectif explicite des chercheurs était d'entraîner un ensemble de modèles de différentes tailles avec les meilleures performances possibles pour un budget de calcul donné. Pour l'une des premières fois, l'équipe de recherche a explicitement décidé de prendre en compte non seulement le budget d'entraînement, mais aussi le coût d'inférence (pour un objectif de performance donné, combien cela coûte-t-il d'exécuter une inférence avec le modèle). Dans cette perspective, ils ont décidé d'entraîner des modèles plus petits sur encore plus de données et pour plus d'étapes que ce qui était habituellement fait, atteignant ainsi des performances plus élevées à une taille de modèle plus petite (le compromis étant l'efficacité de calcul de l'entraînement). Le plus grand modèle de la famille Llama 1 est un modèle de paramètres 65B entraîné sur 1,4T de *tokens*, tandis que les modèles plus petits (paramètres 6 et 13B) ont été entraînés sur 1T de *tokens*. Le petit modèle 13B LLaMA a surpassé GPT-3 sur la plupart des benchmarks, et le plus grand modèle LLaMA était à la pointe de la technologie lors de sa sortie. Les poids ont cependant été publiés avec une licence non commerciale, limitant ainsi l'adoption par la communauté. 

Les modèles [Pythia](https://huggingface.co/papers/2304.01373) ont été publiés par le laboratoire open source à but non lucratif Eleuther AI, et étaient une [suite de LLM](https://huggingface.co/collections/EleutherAI/pythia-scaling-suite-64fb5dfa8c21ebb3db7ad2e1) de différentes tailles, entraînés sur des données entièrement publiques, fournis pour aider les chercheurs à comprendre les différentes étapes d'entraînement de LLM.

Les [modèles MPT](https://www.mosaicml.com/blog/mpt-7b), qui sont sortis quelques mois plus tard, publiés par MosaicML, étaient proches en termes de performances, mais avec une licence permettant une utilisation commerciale, et les détails de leur combinaison d'entraînement. Le premier modèle MPT était un [modèle 7B](https://huggingface.co/mosaicml/mpt-7b), suivi par des versions 30B en juin, toutes deux entraînées sur 1T de *tokens* d'anglais et du code (en utilisant des données de C4, CommonCrawl, The Stack, S2ORC). 

Les modèles MPT ont été rapidement suivis par les modèles 7 et 30B (https://huggingface.co/tiiuae/falcon-7b) de la série Falcon (https://huggingface.co/collections/tiiuae/falcon-64fb432660017eeec9837b5a), publiés par TIIUAE, et entraînés sur 1 à 1,5T de *tokens* d'anglais et de code (RefinedWeb, Project Gutemberg, Reddit, StackOverflow, Github, arXiv, Wikipedia, entre autres sources) - plus tard dans l'année, un gigantesque modèle 180B a également été publié. Les modèles, les données et le processus d'entraînement de Falcon ont été détaillés dans un rapport technique et un [papier de recherche ultérieur](https://huggingface.co/papers/2311.16867). 

Héritant du modèle GPT-Neo-X, StabilityAI a publié les modèles [StableLM-Base-Alpha](https://huggingface.co/stabilityai/stablelm-base-alpha-7b), une petite série pré-entraînée (3B et 7B) utilisant 1,5T de *tokens* d'un jeu de données expérimental construit sur ThePile. Suivie d'une [série v2](https://huggingface.co/stabilityai/stablelm-base-alpha-7b-v2) avec un mélange de données comprenant RefinedWeb, RedPajama, ThePile, et des jeux de données internes non divulgués, et enfin par un très petit modèle 3B, le [StableLM-3B-4E1T](https://huggingface.co/stabilityai/stablelm-3b-4e1t), accompagné d'un [rapport technique détaillé](https://stability.wandb.io/stability-llm/stable-lm/reports/StableLM-3B-4E1T--VmlldzoyMjU4?accessToken=u3zujipenkx5g7rtcj9qojjgxpconyjktjkli2po09nffrffdhhchq045vp0wyfo).

Alors que les données des modèles précédents étaient principalement publiques, à partir de ce moment-là, les versions suivantes n'ont donné pratiquement aucune information sur ce qui a été utilisé pour entraîner les modèles, et leurs efforts ne peuvent pas être reproduits. Cependant, ils fournissent des points de départ pour la communauté grâce aux poids publiés.

Au début de l'été sont arrivés les [modèles](https://huggingface.co/Salesforce/xgen-7b-4k-base) [X-Gen](https://huggingface.co/papers/2309.03450) de Salesforce, des modèles de 7B paramètres entraînés sur 1,5T *tokens* de langage naturel et de code, en plusieurs étapes, suivant un système d'ordonnancement des données (toutes les données ne sont pas introduites en même temps dans le modèle). 

X-Gen a été un peu éclipsé par la nouvelle famille très visible [LLaMA-2](https://huggingface.co/papers/2307.09288) de Meta, une gamme de [modèles de 7 à 70B](https://huggingface.co/meta-llama/Llama-2-7b) entraînés sur 2T de *tokens* « provenant de sources accessibles au public », avec une licence communautaire permissive et un processus de finetuning basé sur des préférences humaines (RLHF), ce qu'on appelle la procédure d'alignement.

Quelques mois plus tard, le premier [modèle](https://huggingface.co/mistralai/Mistral-7B-v0.1) de la startup Mistral nouvellement créée, [Mistral-7B](https://huggingface.co/papers/2310.06825) a été lancé, entraîné sur un nombre non divulgué de *tokens* à partir de données « extraites du Web ouvert ». La fin de l'année 2023 a été chargée par les sorties de modèles avec un deuxième modèle plus grand par Mistral (Mixtral 8x7B), un premier [modèle](https://huggingface.co/Deci/DeciLM-7B) impressionnant de Deci.AI appelé [DeciLM](https://deci.ai/blog/introducing-DeciLM-7B-the-fastest-and-most-accurate-7b-large-language-model-to-date) ainsi qu'une plus grande fusion de modèles d'upstage, [SOLAR](https://huggingface.co/upstage/SOLAR-10.7B-v1.0) également entraînés sur des quantités et des sources de données non divulguées. Tous ces modèles ont connu des augmentations constantes dans les classements et les benchmarks ouverts.

En parallèle, un événement notable de la fin de l'année 2023 a été l'augmentation des performances et un certain nombre de modèles entraînés en Chine et publiés ouvertement. Deux séries de modèles bilingues anglais-chinois ont été lancées : [Qwen](https://huggingface.co/papers/2309.16609) d'Alibaba, [modèles](https://huggingface.co/Qwen/Qwen-72B) de 7 à 70B de paramètres entraînés sur 2,4T *tokens*, et [Yi](https://huggingface.co/01-ai/Yi-34B) de 01-AI, modèles de 6 à 34B de paramètres, entraînés sur 3T de *tokens*. Les performances de ces modèles avaient une longueur d'avance sur les modèles précédents, à la fois sur les classements ouverts comme l'[*Open LLM leaderboard*](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard) et certains des benchmarks les plus difficiles comme [Skill-Mix](https://huggingface.co/papers/2310.17567). Un autre concurrent sérieux de la fin de 2023 était le modèle de codage DeepSeek de [DeepSeek AI](https://huggingface.co/deepseek-ai) entraîné à partir de zéro sur 2T de *tokens*, avec une composition de 87 % de code et de 13 % de langage naturel en anglais et en chinois (principalement un modèle de code). 
""", unsafe_allow_html=True)
st.markdown(""" """)
st.markdown(""" """)
st.markdown(""" """)
st.markdown("""
### Des modèles de dialogue partout

Par rapport à 2022, presque tous les modèles pré-entraînés sortis en 2023 sont à présent livrés avec une version pré-entraînée et une version finetunée pour dialoguer via l'une des nombreuses approches existantes. Alors que des approches de finetuning pour chatter ont été développées en 2022 et avant, l'adoption généralisée de ces techniques a réellement décollé en 2023, mettant l'accent sur l'utilisation croissante de ces modèles de chat par le grand public ainsi que sur l'évaluation manuelle croissante des modèles en discutant avec eux (évaluation « *vibe-check* »). Nous détaillons ici les approches les plus connues pour adapter des modèles pré-entraînés au chat, mais de nombreuses variantes existent !

Le **chat-finetuning** est une variante du finetuning supervisé, où les données annotées sont des données de chat (données de type dialogue à plusieurs tours, un peu comme ce que vous trouveriez sur les réseaux sociaux). Vous utilisez la même technique que lors de l'entraînement de votre modèle : pour les *transformers* décodeur, vous apprenez à votre modèle à prédire les mots suivants un par un (approche auto-régressive). 

L'IFT (**Instruction fine-tuning** suit la même approche, mais avec des jeux de données d'instructions, qui contiennent une collection de prompts de type requête et des réponses (avec des entrées supplémentaires facultatives si nécessaire). Ces jeux de données enseignent aux modèles comment suivre une instruction et peuvent être générés par l'homme ou par LLM. 
 L'utilisation de jeux de données synthétiques à grande échelle (jeux de données composés de générations de modèles, par exemple, des générations de GPT-4 à partir d'instructions ou d'interactions entre les utilisateurs et ledit modèle) est l'un des moyens d'effectuer un finetuning d'instructions et de chat. C'est ce qu'on appelle souvent la « distillation », car elle consiste à prendre les connaissances d'un modèle très performant pour entraîner un modèle plus petit.

Ces deux méthodes sont relativement faciles à mettre en œuvre : il vous suffit de trouver ou de générer des jeux de données associés, puis de finetuner votre modèle en utilisant la même technique que lors de l'entraînement. Un grand nombre de jeux de données instruct ont été publiés l'année dernière, ce qui a amélioré les performances du modèle dans des configurations de type dialogue. Pour plus d'informations sur ce sujet, vous pouvez lire cet [article de blog](https://huggingface.co/blog/dialog-agents). Cependant, les modèles, bien que meilleurs, ne peuvent toujours pas correspondre à ce que les humains attendent. 
 
L'apprentissage par renforcement à partir de la rétroaction humaine (**Reinforcement learning from human feedback** ou RLHF) est une approche spécifique qui vise à aligner ce que le modèle prédit sur ce que les humains préfèrent (en fonction de critères spécifiques). Il s'agissait (au début de l'année) d'une nouvelle technique. À partir d'une instruction donnée, le modèle génère plusieurs réponses possibles. Les humains classent ces réponses. Les classements sont utilisés pour entraîner ce qu'on appelle un modèle de préférence (qui apprend à donner un score reflétant la préférence humaine pour les réponses). Le modèle de préférence est ensuite utilisé pour finetuner le modèle de langage à l'aide de l'apprentissage par renforcement. Pour plus d'informations, voir cet [article de blog](https://huggingface.co/blog/rlhf), l'[article original du RLHF](https://huggingface.co/papers/1909.08593), ou l'article d'Anthropic sur [RLHF](https://huggingface.co/papers/2204.05862). Il s'agit d'une méthode coûteuse (l'annotation/classement + l'entraînement d'un nouveau modèle + la mise au point sont assez coûteuses) qui a été principalement utilisée pour aligner les modèles sur des objectifs de sécurité. Une variante moins coûteuse de cette méthode a été développée, qui utilise un LLM de haute qualité pour classer les résultats du modèle plutôt que les humains : **apprentissage par renforcement à partir de la rétroaction de l'IA** (RLAIF). 

L'optimisation directe des préférences (**Direct preference optimization** ou DPO) est une autre variante de RLHF, mais ne nécessite pas l'entraînement et l'utilisation d'un modèle de préférence distinct. La méthode nécessite le même jeu de données de classement humain ou IA, mais utilise ces données pour mettre à jour le modèle directement en examinant la différence entre sa politique d'origine (méthode de prédiction) et la politique optimale (qui prédirait les réponses les mieux classées). En d'autres termes, le modèle aligné est aussi le modèle de préférence, ce qui simplifie considérablement la procédure d'optimisation tout en donnant ce qui semble être des performances finales équivalentes.

Donc, pour revenir à notre vague de modèles à poids ouvert de sociétés (principalement) privées, beaucoup d'entre eux ont été publiés avec leur variantes finetunées : MPT-7B est également venu avec une version instruct et une version chat, des versions instruct-tuned des modèles Falcon et XGen ont été lancées à la fin de l'année, Llama-2, Qwen et Yi ont été sortis avec des versions chat et DeciLM avec une version instruct. La sortie de Llama-2 a été particulièrement remarquable en raison de l'accent mis sur la sécurité, à la fois dans les modèles de pré-entraînement et de finetuning. 
""", unsafe_allow_html=True)
st.markdown(""" """)
st.markdown(""" """)
st.markdown(""" """)
st.markdown("""
### Qu'en est-il de la communauté ?
Alors que les modèles de chat et les modèles d'instructions étaient généralement fournis directement avec les nouvelles versions de modèles, la communauté et les chercheurs n'ont pas pris cela pour acquis. Une communauté large et saine de perfectionneurs de modèles s'est épanouie sur les terrains fructueux fournis par ces modèles de base, avec des discussions ayant lieu spontanément sur Reddit, Discord, le Hub et Twitter. Les anoonces de modèles communautaires ont été fréquentes, parallèlement à la création de nouveaux jeux de données intéressants (également utilisés pour finetuner les modèles afin de déterminer leurs bonnes performances et leur qualité).

Au début de l'année 2023, quelques jeux de données d'instructions/chats ont déjà été publiés. Par exemple, pour les préférences humaines, [WebGPT](https://huggingface.co/datasets/openai/webgpt_comparisons) d'OpenAI, [HH-RLHF](https://github.com/anthropics/hh-rlhf) d'Anthropic et [Summarize](https://huggingface.co/datasets/openai/summarize_from_feedback) d'OpenAI ont été pionniers dans cette direction. Des exemples de jeux d'instructions sont le [Public Pool of Prompts](https://huggingface.co/datasets/bigscience/P3) de BigScience, [FLAN](https://github.com/google-research/FLAN) 1 et 2 de Google, [Natural Instructions](https://github.com/allenai/natural-instructions) d'AllenAI, [Self Instruct](https://github.com/yizhongw/self-instruct), un cadre pour générer des instructions automatiques par des chercheurs de différentes affiliations, [SuperNatural instructions](https://aclanthology.org/2022.emnlp-main.340/), un benchmark d'instructions créé par des experts, parfois utilisé comme données de réglage fin, [Unnatural instructions](https://aclanthology.org/2023.acl-long.806.pdf), un jeu d'instructions généré automatiquement par l'Université de Tel Aviv et Meta, entre autres.

❄️ Hiver 2022/2023 :  
En janvier de cette année, le [Human ChatGPT Instruction corpus](https://huggingface.co/datasets/Hello-SimpleAI/HC3) (HC3) a été publié par des chercheurs chinois de diverses institutions, et contenait des réponses humaines par rapport à des modèles à diverses questions. Le mois de mars a été riche en sorties : Stanford a ouvert le modèle [Alpaca](https://github.com/tatsu-lab/stanford_alpaca), qui était le premier modèle LLaMA (7B) suivant des instructions, et le jeu de données associé, 52K instructions générées avec un LLM. LAION (un laboratoire open source à but non lucratif) a publié [Open Instruction Generalist](https://laion.ai/blog/oig-dataset/) (OIG), 43M instructions à la fois créées avec l'augmentation des données et compilées à partir d'autres sources de données préexistantes. Le même mois, LMSYS org (à l'UC Berkeley) a publié [Vicuna](https://lmsys.org/blog/2023-03-30-vicuna/), également une mise au point LLaMA (13B), cette fois sur les données de chat : conversations entre les utilisateurs et ChatGPT, partagées publiquement par les utilisateurs eux-mêmes sur [ShareGPT](https://share-gpt.com/). [Guanaco](https://huggingface.co/datasets/JosephusCheung/GuanacoDataset), une extension d'Alpaca (contenant 500K entrées supplémentaires dans plus de langues), a également été publié, ainsi que le finetuning de LLaMA-7B associé. 

🌱 Printemps :  
En avril, BAIR (Berkeley AI Research lab) a publié [Koala](https://bair.berkeley.edu/blog/2023/04/03/koala/), un modèle LLaMA utilisant plusieurs des jeux de données précédents (Alpaca, HH-RLHF, WebGPT, ShareGPT) et DataBricks a publié [Dolly](https://huggingface.co/datasets/databricks/databricks-dolly-15k), un grand effort humain de 15K instructions générées manuellement ainsi que le modèle associé, un finetuning de Pythia. En mai, l'Université Tsinghua a publié [UltraChat](https://arxiv.org/abs/2305.14233), un jeu de données de 1,5 million de conversations contenant des instructions, et UltraLLaMA un finetuning dudit jeu de données. Microsoft a ensuite publié le dataset/framework [GPT4-LLM](https://github.com/Instruction-Tuning-with-GPT-4/GPT-4-LLM) pour générer des instructions avec GPT4, et en juin, une recherche de Microsoft a partagé une nouvelle méthode, [Orca](https://arxiv.org/pdf/2306.02707.pdf), pour construire des jeux de données d'instructions en utilisant la trace de raisonnement de modèles plus grands (qui expliquent leur raisonnement étape par étape). Elle a rapidement été reproduite par la communauté (notamment Alignmentlab.ai), qui a créé [Open Orca](https://huggingface.co/Open-Orca), plusieurs millions d'entrées, puis utilisés pour finetuner un certain nombre de modèles (Llama, Mistral, ...). En mai et juin, [Camel-AI](https://huggingface.co/camel-ai) a publié un certain nombre de jeux de données d'instructions ou de chat sur différents sujets (plus de 20K exemples dans chaque domaine, physique, biologie, chimie, ...) obtenus avec GPT4. En juin également, [Airoboros](https://github.com/jondurbin/airoboros) permettant de finetuner les modèles à l'aide de données générées par le modèle (selon l'approche d'auto-instruction) a été publié, ainsi qu'un certain nombre de [instruct datasets](https://huggingface.co/jondurbin). 

🌻Été :  
En août, [UltraLM](https://github.com/thunlp/UltraChat) (un finetuning de LLaMA très performante pour le chat) a été publié par OpenBMB, une organisation chinoise à but non lucratif, et en septembre, ils ont publié le jeu de données de préférence associé [UltraFeedback](https://huggingface.co/datasets/openbmb/UltraFeedback) obtenu via rétroaction d'entrées comparées par GPT4 (avec annotations). Tout au long de l'été, le collectif [NousResearch](https://huggingface.co/NousResearch), a publié plusieurs finetunings (notamment les collections Hermès et Capybara) à partir de plusieurs jeux d'instructions privées et publiques. En septembre, une équipe d'étudiants de l'Université de Tsinghua a publié [OpenChat](https://huggingface.co/openchat/openchat_3.5), un finetuning d'un LLaMA utilisant une nouvelle stratégie de RL, et Intel a publié un [jeu de données de DPO de style Orca](https://huggingface.co/datasets/Intel/orca_dpo_pairs). 

🍂 Automne :  
En octobre, Hugging Face a sorti [Zephyr](https://huggingface.co/HuggingFaceH4/zephyr-7b-beta), un finetuning de Mistral utilisant DPO et AIF sur UltraChat et UltraFeedback, et les membres de la communauté ont sorti [OpenHermes 2](https://huggingface.co/teknium/OpenHermes-2-Mistral-7B), un finetuning de Mistral-7B sur 900K entrées provenant du web ou générées avec Axolotl. Lmsys a publié LMSYS-Chat-1M, des conversations d'utilisateurs réels avec 25 LLM. En novembre, OpenBuddy a publié OpenBuddy-Zephyr, un Zephyr spécialisé sur des données de dialogue à plusieurs tours, et Argilla a sorti [Notus](https://huggingface.co/argilla/notus-7b-v1). NVIDIA a publié [HelpSteer](https://huggingface.co/datasets/nvidia/HelpSteer), un jeu d'alignement fournissant des instructions, des réponses de modèle associées et des notes desdites réponses sur plusieurs critères, tandis que Microsoft Research a publié le modèle [Orca-2](https://huggingface.co/microsoft/Orca-2-13b), un Llama 2 spécialisé sur un nouvel jeu de raisonnement synthétique. Intel a sorti [Neural Chat](https://huggingface.co/Intel/neural-chat-7b-v3-1), un finetuning de Mistral sur Orca et avec DPO. En décembre, Berkeley a publié [Starling](https://huggingface.co/berkeley-nest/Starling-LM-7B-alpha), un RLAIF  d'Open-Chat et le jeu de données associé [Nectar](https://huggingface.co/datasets/berkeley-nest/Nectar), 200K entrées de données de comparaison.

Comme nous pouvons le constater, le développement de toute cette année repose à la fois sur la création de nouveaux jeux de données grâce à l'utilisation de LLM pré-entraînés de haute qualité, ainsi que sur tous les modèles ouverts publiés par la communauté, faisant avancer le domaine à pas de géant ! Et si vous voyez maintenant l'un de ces noms dans le nom d'un modèle, vous pourrez vous faire une idée de son origine 🤗
""", unsafe_allow_html=True)

st.info("""
Certains jeux de données plus spécialisés (tels que [MetaMath](https://meta-math.github.io/) ou [MathInstruct](https://huggingface.co/datasets/TIGER-Lab/MathInstruct) jeux de problèmes mathématiques, [Evol-Instruct](https://huggingface.co/datasets/WizardLM/WizardLM_evol_instruct_70k), instructions mathématiques et de code, [CodeAlpaca](https://huggingface.co/datasets/sahil2801/CodeAlpaca-20k) et [CodeCapybara](https://github.com/FSoft-AI4Code/CodeCapybara) instructions de code) ont été également publiés. Nous ne les couvrirons pas en détail ici, bien qu'ils aient également été utilisés pour améliorer les performances du modèle sur des tâches spécifiques. Vous pouvez également consulter l'[*awesome instructions dataset*](https://github.com/jianzhnie/awesome-instruction-datasets) pour une compilation d'autres jeux de données pertinents.
""")
st.markdown(""" """)
st.markdown(""" """)
st.markdown(""" """)
st.markdown("""
### Démocratiser l'accès
Remarque : un certain nombre d'outils ont également émergé pour prendre en charge l'inférence et le déploiement pour les utilisateurs débutants, tels que llama.cpp, ollama, text-generation-inference, vllm, entre autres. Ils sont hors du champ d'application du présent document.
""", unsafe_allow_html=True)
st.markdown(""" """)
st.markdown("""
#### Fusion : Personnalisation extrême
D'une manière typiquement open-source, l'un des points de repère de la communauté est la fusion de modèle/données. À chaque fusion/commit, il peut être plus difficile de retracer à la fois les données utilisées (car un certain nombre de jeux de données publiés sont des compilations d'autres jeux de données) et l'historique des modèles, car les modèles très performants sont des versions affinées de versions affinées de modèles similaires (voir par exemple « l'arbre des modèles enfants » de Mistral [ici](https://huggingface.co/spaces/davanstrien/mistral-graph)). Dans ce résumé, nous n'avons pas encore eu le temps de parler de cette technique étonnante, alors consacrons-y quelques mots de la fin. 

Qu'est-ce que cela signifie de fusionner un modèle ?

La fusion de modèles est un moyen de fusionner les poids de différents modèles en un seul modèle afin (idéalement) de combiner les forces respectives de chaque modèle dans un seul modèle unifié. Il existe quelques techniques pour le faire qui ont été étendues et souvent publiées principalement dans des forums communautaires, un cas frappant de recherche entièrement décentralisée se déroulant dans le monde entier entre une communauté de praticiens, de chercheurs et d'amateurs. L'une des méthodes publiées les plus simples consiste à calculer la moyenne des paramètres d'un ensemble de modèles partageant une architecture commune ([exemple 1](https://huggingface.co/papers/2204.03044), [exemple 2](https://huggingface.co/papers/2109.01903)). Des combinaisons de paramètres plus complexes existent, telles que déterminer quels paramètres sont les plus influents dans chaque modèle pour une tâche donnée ([moyenne pondérée](https://huggingface.co/papers/2111.09832)), ou prendre en compte les interférences de paramètres entre les modèles avant de sélectionner les paramètres à conserver lors de la fusion ([Ties Merging](https://huggingface.co/papers/2306.01708)). Pour un bon aperçu de la littérature, vous pouvez consulter cette [collection d'articles](https://huggingface.co/collections/osanseviero/model-merging-65097893623330a3a51ead66) !

Ces techniques permettent à n'importe qui de générer facilement des combinaisons de modèles et sont rendues particulièrement faciles par le fait que la plupart des modèles sont aujourd'hui des variations de la même architecture. C'est la raison pour laquelle certains modèles soumis à l'[*Open LLM Leaderboard*](https://huggingface.co/spaces/HuggingFaceH4/open_llm_leaderboard) ont des noms tels que `llama2-zephyr-orca-ultra`. Cet exemple particulier est probablement une fusion des modèles `lama2` et `zephyr`, finetunés sur des jeux de données `orca` et `ultra`. En général, vous trouverez plus de détails dans la fiche de modèle correspondante sur le Hub.
""", unsafe_allow_html=True)
st.markdown(""" """)
st.markdown("""
#### PEFT : La personnalisation au bout des doigts
Parfois, vous pouvez souhaiter une personnalisation plus contrôlée, sans avoir suffisamment de mémoire pour charger un modèle entier afin de le finetunr. Saviez-vous qu'il n'est pas nécessaire d'utiliser un modèle entier lors du *finetuning* ?

Vous pouvez utiliser ce que l'on appelle le **parameter efficient fine-tuning** (PEFT).
Cette technique gèle d'abord les paramètres du modèle d'intérêt pré-entraîné, puis ajoute un certain nombre de nouveaux paramètres par-dessus, appelés adaptateurs. Ce que vous affinez ensuite dans votre tâche, ce sont uniquement les poids (légers) de l'adaptateur, considérablement plus petits que le modèle d'origine. Il ne vous reste plus qu'à partager vos petits poids d'adaptateur (et le modèle de base) ! Vous trouverez une liste d'approches intéressantes pour le PEFT [ici](https://github.com/huggingface/peft).
""", unsafe_allow_html=True)
st.markdown(""" """)
st.markdown("""
#### Quantification : des modèles qui tournent partout
Nous avons vu que les modèles performants sont maintenant de toutes formes et de toutes tailles... Mais même dans ce cas, cela ne veut pas dire qu'ils sont accessibles à tous ! Un modèle de paramètres 30B peut nécessiter plus de 66 Go de RAM rien que pour se charger en mémoire (même pas l'utiliser), et tout le monde dans la communauté n'a pas le matériel nécessaire pour le faire.

C'est là qu'intervient la quantification ! La quantification est une technique spéciale qui permet de réduire la taille d'un modèle en modifiant la précision de ses paramètres. 

Qu'est-ce que cela signifie ? 

Dans un ordinateur, les nombres sont stockés avec une précision donnée (par exemple, `float32`, `float16`, `int8`, etc.). Une précision indique à la fois le type de nombre (s'il s'agit d'un nombre à virgule flottante ou d'un entier) ainsi que la quantité de mémoire stockée du nombre : `float32` stocke les nombres à virgule flottante sur 32 bits. Pour une explication plus approfondie, voir [ce lien](https://huggingface.co/docs/optimum/concept_guides/quantization#going-further-how-do-machines-represent-numbers). Ainsi, plus la précision est élevée, plus un nombre prend de mémoire physique, car il sera stocké sur plus de bits. 

Si vous réduisez la précision, vous réduisez la mémoire que chaque paramètre du modèle prend en stockage, réduisant ainsi la taille du modèle ! Cela signifie également que vous réduisez... la précision réelle des calculs, qui peut réduire les performances du modèle. Cependant, nous avons découvert que sur les modèles plus grands, cette dégradation des performances est en réalité très [limitée](https://huggingface.co/blog/overview-quantization-transformers).

Pour revenir à notre exemple ci-dessus, notre modèle de paramètres 30B en `float16` nécessite un peu moins de 66G de RAM, en `8bit` il n'en nécessite que la moitié, donc 33G de RAM, et en `4bit` nous atteignons même la moitié de cela, donc environ 16G de RAM, ce qui le rend considérablement plus accessible.

Il existe de nombreuses façons de passer d'une précision à une autre, avec de nombreux schémas de « traduction » différents, chacun ayant ses propres avantages et inconvénients. Les approches populaires incluent [bitsandbytes](https://huggingface.co/papers/2208.07339), [GPTQ](https://huggingface.co/papers/2210.17323) et [AWQ](https://huggingface.co/papers/2306.00978). Certains utilisateurs, comme [TheBloke](https://huggingface.co/TheBloke), convertissent même des modèles populaires pour les rendre accessibles à la communauté. Tous sont très récents et encore en développement, et nous espérons voir encore plus de progrès à ce sujet au fil du temps.
""", unsafe_allow_html=True)
st.markdown(""" """)
st.markdown(""" """)
st.markdown(""" """)
st.markdown("""
### Quelle est la prochaine étape ?
L'année n'est pas encore finie ! Et ces derniers jours/heures sont déjà arrivés avec leur lot de surprises : une nouvelle architecture va-t-elle finalement surpasser le simple et efficace *transformer* ?

Les nouvelles sorties incluent
- Un mélange d'experts :
	- [Mixtral](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1), le modèle est composé de 8 sous-modèles (*transformer* décodeur), et pour chaque entrée, un routeur sélectionne les 2 meilleurs sous-modèles et additionne leurs sorties.
- Plusieurs SSM (modèles qui associent l'entrée à la sortie à travers un espace latent et qui peuvent être exprimés soit comme un RNN, soit comme un CNN selon les tâches, [cette ressource](https://srush.github.io/annotated-s4/) est excellente pour expliquer les modèles d'état si vous voulez plus d'informations) :
	- [Mamba](https://huggingface.co/papers/2312.00752), un SSM RNN avec un mécanisme de sélection
	- [StripedHyena](https://huggingface.co/togethercomputer/StripedHyena-Nous-7B), un SSM convolutif

Il est encore un peu tôt pour dire si ces nouvelles approches vont prendre le relais du Transformer, mais les modèles d'espace d'état sont assez prometteurs !
""", unsafe_allow_html=True)
st.markdown(""" """)
st.markdown(""" """)
st.markdown(""" """)
st.markdown("""
### À retenir
- Cette année a vu une augmentation des sorties ouvertes de toutes sortes d'acteurs (grandes entreprises, start-ups, laboratoires de recherche), ce qui a permis à la communauté de commencer à expérimenter et à explorer à un rythme jamais vu auparavant.
- Les annonces d'ouverture de modèles ont connu des hauts et des bas, des premières versions de cette année très ouvertes (mélanges de jeux de données, poids, architectures) aux versions tardives n'indiquant rien sur leurs données d'entraînement, étant donc non reproductibles.
- Des modèles ouverts ont émergé de nombreux nouveaux endroits, y compris de la Chine, avec plusieurs nouveaux acteurs se positionnant comme de solides concurrents dans le monde des LLM.
- Les possibilités de personnalisation ont atteint un niveau record, avec de nouvelles stratégies de finetunig (RLHF, adaptateurs, fusion), qui n'en sont qu'à leurs débuts.
- Les modèles de plus petite taille et les améliorations des méthodes de quantification ont rendu les LLM vraiment accessibles à beaucoup plus de personnes !
- De nouvelles architectures sont également apparues : vont-elles enfin remplacer le *transformer* ?

C'est tout les amis ! 
J'espère que vous avez apprécié la revue de cette année, que vous avez appris une chose ou deux, et que vous êtes aussi enthousiaste que moi quant à la mesure dans laquelle les progrès de l'IA reposent désormais sur l'open source et l'effort de la communauté ! 🤗
""", 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("Panoramas annuels")
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("Panorama 2024")