Découvrez en profondeur l’architecture et le fonctionnement des modèles à mélange d’experts (MoE) et explorez les applications et avantages de modèles MoE populaires tels que Mixtral 8X7B, DBRX et Deepseek-v2. Implémentez un modèle MoE en Python et évaluez sa performance dans des tâches telles que le raisonnement logique, le résumé et l’extraction d’entités.

Le concept de modèle à mélange d’experts (MoE) fait sensation depuis un certain temps dans le domaine des grands modèles de langage (LLM). Non seulement il améliore considérablement l’efficacité et l’évolutivité des modèles, mais il offre aussi de nouvelles approches pour traiter des tâches complexes. En termes simples, un modèle MoE divise un large modèle en plusieurs petits modèles, chacun se concentrant sur une tâche ou un type de données spécifique. Ainsi, lors du traitement d’une tâche, le modèle n’active que les “experts” concernés, économisant ainsi considérablement les ressources informatiques.

Dans cet article, vous allez :

• Comprendre l’architecture de base et le fonctionnement des modèles MoE
• Découvrir quelques modèles MoE populaires comme Mixtral 8X7B, DBRX et Deepseek-v2
• Implémenter un modèle MoE en Python sur Google Colab
• Évaluer la performance d’un modèle MoE typique dans des tâches de raisonnement logique, de résumé et d’extraction d’entités
• Explorer les avantages et défis des modèles MoE dans des tâches complexes telles que le traitement du langage naturel et la génération de code

1 Qu’est-ce qu’un modèle à mélange d’experts (MoE) ?

Les modèles d’apprentissage profond actuels sont principalement basés sur les réseaux de neurones artificiels, composés de plusieurs couches, chacune contenant de nombreux “neurones”. Chaque neurone traite les données d’entrée, effectue des calculs basiques (comme les fonctions d’activation), puis transmet le résultat à la couche suivante. Des modèles plus avancés comme le Transformer introduisent un mécanisme d’auto-attention capable de capturer des motifs complexes dans les données.

Cependant, dans les modèles denses traditionnels, l’ensemble du réseau contribue au calcul de chaque entrée, ce qui engendre des coûts computationnels extrêmement élevés. Pour y remédier, les modèles Mixture of Experts (MoE) adoptent une architecture éparse, n’activant que les parties du réseau pertinentes pour la tâche en cours, ou les “experts”. De cette manière, les modèles MoE consomment nettement moins de ressources informatiques pour traiter des tâches complexes comme le traitement du langage naturel.

Imaginez un projet d’équipe où les membres sont divisés en groupes, chaque groupe se concentrant sur une tâche différente. Le fonctionnement d’un modèle MoE est similaire. Il divise un problème complexe en plusieurs sous-tâches, chacune étant gérée par des “experts” dédiés.

Les principaux avantages des modèles MoE sont :

• Vitesse de pré-entraînement accélérée : Par rapport aux modèles denses traditionnels, les modèles MoE sont plus efficaces lors du processus de pré-entraînement.
• Vitesse d’inférence améliorée : Même avec un nombre de paramètres identique, un modèle MoE offre une vitesse d’inférence plus rapide.
• Exigences élevées en VRAM : Tous les experts doivent être stockés simultanément en mémoire, d’où une demande en VRAM relativement grande pour les modèles MoE.

Un modèle MoE est constitué de deux composants clés : les experts, petits réseaux neuronaux se concentrant sur des tâches spécifiques, et un routeur, qui active sélectivement les experts pertinents à partir des données d’entrée. Cette activation sélective améliore l’efficacité en n’utilisant que les experts nécessaires pour chaque tâche.

2 Quelques modèles MoE typiques

Ces dernières années, les modèles MoE ont suscité un vif intérêt dans la recherche en IA en raison de leur capacité à conserver des performances élevées tout en étendant efficacement les grands modèles de langage. Parmi ceux-ci, Mixtral 8x7B est un exemple typique reposant sur l’architecture à mélange d’experts épars. Ce modèle active seulement un sous-ensemble de ses experts pour chaque entrée, améliorant ainsi l’efficacité tout en réalisant des performances comparables à celles d’un modèle dense massif.

Voyons quelques modèles MoE populaires et testons-les en Python sur Google Colab avec Ollama pour apprécier leur potentiel.

2.1 Mixtral 8X7B

L’architecture de Mixtral 8X7B repose sur un Transformer uniquement avec décodeur. Le modèle traite les entrées sous forme de séries de tokens, convertis en vecteurs puis traités via les couches de décodeur. Le résultat est une probabilité que chaque position soit remplie par un mot, permettant ainsi un remplissage et une prédiction de texte.

Chaque couche de décodeur se compose principalement de deux parties clés : un mécanisme d’attention pour capturer des informations contextuelles, et une section à mélange d’experts épars (SMOE) pour traiter individuellement chaque vecteur de mot. La couche MLP constitue le principal poste de dépense en ressources informatiques. SMOE offre de nombreux “experts”, et pour chaque entrée, seul le résultat pondéré des experts les plus pertinents est retenu, permettant à la couche SMOE d’apprendre des modèles complexes avec un coût de calcul réduit.

Caractéristiques clés du modèle :

• Nombre total d’experts : 8
• Nombre d’experts activés : 2
• Nombre de couches de décodeur : 32
• Taille du vocabulaire : 32000
• Taille d’embedding : 4096
• Taille par expert : 5,6 milliards de paramètres, au lieu de 7 milliards. Les autres paramètres (7 milliards - 5,6 milliards) proviennent de composants partagés comme les couches d’embedding, de normalisation et le mécanisme de porte.
• Total des paramètres activés : 12,8 milliards
• Longueur du contexte : 32k tokens

Lors du chargement du modèle, tous les 44,8 milliards (8*5,6 milliards de paramètres) doivent être chargés (ainsi que tous les paramètres partagés), mais seuls 2×5,6 milliards (12,8 milliards) de paramètres sont nécessaires pour l’inférence.

Mixtral 8x7B excelle dans de nombreux domaines tels que la génération de texte, la compréhension, la traduction, le résumé, l’analyse de sentiment, l’éducation, les services à la clientèle automatisés, et l’assistance à la recherche. Son architecture efficace en fait un outil puissant pour divers champs d’application.

2.2 DBRX

Développé par Databricks, DBRX est un modèle de langage de grande taille (LLM) basé sur un décodeur Transformer, entraîné pour prédire le prochain token. Il utilise une architecture de mélange d’experts (MoE) à granularité fine avec un total de 132 milliards de paramètres, et 36 milliards de paramètres activés pour chaque entrée. Il a été pré-entraîné sur 12 000 milliards de données textuelles et de code. Comparé à d’autres modèles MoE open source (comme Mixtral et Grok-1), DBRX se distingue par une granularité plus fine et l’utilisation de plus petits experts. DBRX utilise 16 experts, en choisissant 4, contre 8 experts pour Mixtral et Grok-1, qui choisissent 2.

Caractéristiques clés de l’architecture :

• Experts à granularité fine : Au lieu de simplement dupliquer les couches FFN pour créer plusieurs experts lors de la transition vers une couche MoE, l’objectif avec des experts à granularité fine est de créer davantage d’experts sans augmenter le nombre de paramètres. Pour ce faire, une seule couche FFN peut être divisée en multiples segments, chaque segment se comportant comme un expert distinct. DBRX adopte ce type d’architecture MoE, avec 16 experts parmi lesquels 4 sont sélectionnés pour chaque entrée.
• Le modèle applique aussi d’autres innovations comme le codage de position rotatif (RoPE), les unités linéaires avec engorgement (GLU) et l’attention de requête groupée (GQA).

Caractéristiques clés du modèle :

• Nombre total d’experts : 16
• Nombre d’experts activés par couche : 4
• Nombre de couches de décodeur : 24
• Total des paramètres activés : 36 milliards
• Nombre total de paramètres : 132 milliards
• Longueur du contexte : 32k tokens

Le modèle DBRX est particulièrement performant dans des cas d’échelle tels que la génération de code, la compréhension fine du langage, le raisonnement mathématique et les tâches de programmation, notamment dans des scénarios exigeant efficacité et précision, comme la génération de snippets de code, la résolution de problèmes mathématiques, et la fourniture d’explications détaillées pour des prompts complexes.

2.3 Deepseek-v2

Dans l’architecture MoE de Deepseek-v2, deux idées essentielles sont mises à profit :

• Experts à granularité fine : Convient à une spécialisation plus avancée des experts et à un accès plus précis aux connaissances.
• Experts partagés : Cette méthode vise à désigner certains experts comme des experts partagés, garantissant leur activation continuelle. Cette stratégie aide à rassembler et à synthétiser des connaissances universelles pertinentes à travers divers contextes.

Caractéristiques clés du modèle :

• Nombre total de paramètres : 236 milliards
• Total des paramètres activés : 21 milliards
• Nombre d’experts par couche routée : 160 (dont 2 sont choisis)
• Nombre d’experts partagés par couche : 2
• Nombre d’experts activés par couche : 8
• Nombre de couches de décodeur : 60
• Longueur du contexte : 128k tokens

Le modèle a été pré-entraîné sur un large ensemble de données comptant 81 000 milliards de tokens.

DeepSeek-V2 est particulièrement adapté pour les conversations, ce qui en fait un bon choix pour les chatbots et les assistants virtuels. Le modèle peut générer du texte de haute qualité et est donc approprié pour la création de contenu, la traduction linguistique, et le résumé. Il est également bien adapté pour des cas d’utilisation générant du code.

3 Implémenter un modèle MoE avec Python

Les modèles MoE représentent une avancée majeure en apprentissage machine, sélectionnant dynamiquement différents réseaux d’experts pour traiter diverses tâches. Voici comment implémenter un modèle MoE en Python et explorer sa puissance.

3.1 Étape 1 : Installer les bibliothèques Python nécessaires

D’abord, il est nécessaire d’installer quelques bibliothèques Python essentielles :

1
2
3
4
5

!sudo apt update
!sudo apt install -y pciutils
!pip install langchain-ollama
!curl -fsSL https://ollama.com/install.sh | sh
!pip install ollama==0.4.2

3.2 Étape 2 : Activer les threads

Ensuite, utilisez threading pour faire fonctionner le service Ollama :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

import threading
import subprocess
import time

def run_ollama_serve():
  subprocess.Popen(["ollama", "serve"])

thread = threading.Thread(target=run_ollama_serve)
thread.start()
time.sleep(5)

3.3 Étape 3 : Récupérer le modèle Ollama

Récupérez un modèle Ollama, tel que DBRX :

1

!ollama pull dbrx

3.4 Étape 4 : Interroger le modèle

Testez le modèle et voyez comment il se comporte :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

from langchain_core.prompts import ChatPromptTemplate
from langchain_ollama.llms import OllamaLLM
from IPython.display import Markdown

template = """Question: {question}

Answer: Let's think step by step."""

prompt = ChatPromptTemplate.from_template(template)

model = OllamaLLM(model="dbrx")

chain = prompt | model

# Préparer les données d'entrée pour l'appel
input_data = {
    "question": 'Résumez le contenu suivant en une seule phrase : "Bob est un garçon. Bob a un chien. Bob et son chien vont se promener. Bob et son chien vont au parc. Au parc, Bob lance un bâton et son chien le rapporte. Le chien court après un écureuil et Bob le poursuit. Bob récupère son chien et ils rentrent chez eux ensemble."'
}

# Utiliser les données d'entrée pour appeler la chaîne et afficher la réponse
response = chain.invoke(input_data)
display(Markdown(response))

4 Performance Réelle du Modèle Mixtral 8x7B

Lors de la comparaison des sorties des différents modèles MoE, nous pouvons analyser leurs différences sur des tâches telles que le raisonnement logique, le résumé et l’extraction d’entités.

Problème de Raisonnement Logique

1

Donnez-moi une liste de 13 mots, chacun ayant 9 lettres.

Sortie :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

Bien sûr, voici treize mots, chacun ayant neuf lettres :
1. Agriculture
2. Beautiful
3. Chocolate
4. Dangerous
5. Encyclopedia
6. Fireplace
7. Grammarly
8. Hamburger
9. Important
10. Juxtapose
11. Kitchener
12. Landscape
13. Necessary
J'espère que cette liste vous aidera ! Si vous avez d'autres questions ou besoin d'assistance supplémentaire, n'hésitez pas à demander.

Comme on peut le voir dans la sortie ci-dessus, tous les mots de la réponse n’ont pas 9 lettres. Sur les 13 mots, seuls 8 ont 9 lettres. Ainsi, la réponse est partiellement correcte.

Problème de Résumé

1

Résumez le contenu suivant en une seule phrase : "Bob est un garçon. Il a un chien. Bob et son chien se promènent. Bob et son chien vont au parc. Au parc, Bob jette un bâton que son chien rapporte. Le chien poursuit un écureuil, Bob le poursuit. Bob récupère son chien et ils rentrent ensemble à la maison."

Sortie :

1

Le petit garçon Bob profite d'une sortie animée avec son chien adoré. Ils vont ensemble au parc, jouent à rapporter la balle, poursuivent un écureuil puis rentrent ensemble à la maison.

La sortie ci-dessus montre que la réponse est bien résumée.

Extraction d’Entités

1

Extrayez toutes les valeurs numériques et leurs unités correspondantes du texte : "Le marathon mesure 42 kilomètres, plus de 30 000 personnes participent."

Sortie :

1
2
3
4
5
6
7

1. Dans le texte donné, il y a deux valeurs numériques avec leurs unités correspondantes :
   - 42 (longueur du marathon, unité non mentionnée dans le texte mais plus loin, il est indiqué que c'est en kilomètres)
   - 30,000 (nombre de participants)
2. Plus tard dans le texte, l'unité de la longueur du marathon est fournie : kilomètres. Puisqu'aucune autre unité n'est spécifiée pour cette valeur, nous supposons qu'elle est en kilomètres.
3. Ainsi, la réponse finale est :
   - 42 (kilomètres, longueur du marathon)
   - 30,000 (nombre de participants)

La sortie ci-dessus montre que toutes les valeurs et unités ont été correctement extraites.

Problème de Raisonnement Mathématique

1

J'ai 2 pommes, puis j'en achète 2 autres. J'ai utilisé 2 pommes pour faire une tarte. Après avoir mangé la moitié de la tarte, combien de pommes me reste-t-il ?

Sortie :

1
2
3
4

1. Vous commencez avec 2 pommes.
2. Vous en achetez 2 autres, vous avez donc 4 pommes (2 + 2 = 4).
3. Vous utilisez 2 pommes pour faire une tarte, vous avez donc 2 pommes restantes (4 - 2 = 2).
4. Vous mangez la moitié de la tarte, mais comme nous ne savons pas combien de pommes il y avait dans la tarte, il est impossible de déterminer combien de pommes il reste.

La sortie du modèle est inexacte. La réponse correcte devrait être 2, car il reste 2 des 4 pommes après en avoir utilisé 2 pour la tarte.

5 Conclusion

Les modèles MoE offrent une méthode d’apprentissage profond efficace en n’activant que les experts pertinents pour chaque tâche. Cette activation sélective permet aux modèles MoE de réaliser des opérations complexes avec moins de ressources informatiques comparé aux modèles denses traditionnels. Cependant, les modèles MoE nécessitent des compromis, car ils demandent une grande quantité de VRAM pour stocker tous les experts.

L’architecture Mixtral 8X7B est un exemple typique. Elle utilise un mécanisme de mélange d’experts épars (SMoE) qui active uniquement un sous-ensemble d’experts pour réaliser un traitement de texte efficace, ce qui diminue considérablement le coût computationnel. Avec ses 12,8 milliards de paramètres activés et une longueur de contexte de 32k tokens, il performe bien dans diverses applications allant de la génération de texte à l’automatisation du service client. Le modèle DBRX de Databricks se distingue également par son architecture MoE innovante à granulométrie fine, permettant d’activer uniquement 36 milliards de paramètres lors de chaque entrée tout en utilisant un total de 1320 milliards de paramètres. De même, DeepSeek-v2 utilise des experts granulaires et partagés pour offrir une architecture puissante avec 2360 milliards de paramètres et une longueur de contexte de 128 000 tokens, ce qui le rend idéal pour des applications variées telles que les chatbots, la création de contenu et la génération de code.

5.1 Points Clés

• Les modèles MoE améliorent l’efficacité de l’apprentissage profond en n’activant que les experts pertinents pour des tâches spécifiques, réduisant l’utilisation des ressources informatiques par rapport aux modèles denses traditionnels.
• Bien que les modèles MoE offrent une efficacité computationnelle, ils requièrent une grande capacité de VRAM pour stocker tous les experts, soulignant un compromis clé entre la puissance de calcul et les besoins en mémoire.
• Mixtral 8X7B adopte un mécanisme de mélange d’experts épars (SMoE), activant un sous-ensemble des 12,8 milliards de paramètres pour un traitement de texte efficace et prise en charge d’une longueur de contexte de 32 000 tokens, le rendant applicable à diverses applications, y compris la génération de texte et l’automatisation du service client.
• Le modèle DBRX de Databricks utilise une architecture de mélange d’experts à grains fins, activant efficacement 36 milliards de paramètres à chaque entrée tout en exploitant 1320 milliards de paramètres au total, démontrant sa capacité à gérer des tâches complexes de traitement du langage.
• DeepSeek-v2 combine une stratégie d’experts granulaires et partagés, formant une architecture puissante avec 2360 milliards de paramètres et une longueur de contexte de 128 000 tokens, le faisant exceller dans des applications variées telles que les chatbots, la création de contenu et la génération de code.

6 Questions Fréquemment Posées

Q1. Qu’est-ce qu’un modèle à mélange d’experts (MoE) ?

A. Les modèles MoE utilisent une architecture éparse, n’activant que les experts les plus pertinents pour chaque tâche, réduisant ainsi l’utilisation des ressources informatiques comparé aux modèles denses traditionnels.

Q2. Quels sont les avantages et inconvénients de l’utilisation des modèles MoE ?

A. Bien que les modèles MoE améliorent l’efficacité computationnelle, ils requièrent une grande quantité de VRAM pour stocker tous les experts, nécessitant un compromis entre la puissance de calcul et les besoins en mémoire.

Q3. Combien de paramètres activés compte le modèle Mixtral 8X7B ?

A. Mixtral 8X7B compte 12,8 milliards (2×5,6 milliards) de paramètres activés, représentant une portion des 44,8 milliards au total (8×5,6 milliards de paramètres), le rendant capable de gérer efficacement des tâches complexes tout en offrant une inférence plus rapide.

Q4. En quoi le modèle DBRX diffère-t-il des autres modèles MoE, tels que Mixtral et Grok-1 ?

A. DBRX utilise une méthode de mélange d’experts à granularité fine avec 16 experts par couche et 4 experts activés, contrairement aux autres modèles MoE avec 8 experts par couche et 2 experts activés.

Q5. Comment DeepSeek-v2 se distingue-t-il parmi les autres modèles MoE ?

A. DeepSeek-v2 combine des experts granulaires et partagés ainsi qu’un ensemble de paramètres vastes et une longue longueur de contexte, en faisant un outil puissant pour une variété d’applications.

7 Lectures Recommandées

1. Mixtral of experts | Mistral AI | Frontier AI in your hands
2. DeepSeekMoE: MoE with Segmented and Shared Experts
3. Mixtral of Experts
4. DBRX: A Large-Scale Decoder-Only Language Model with Fine-Grained Mixture of Experts

Les machines à vecteurs de support (SVM) sont des algorithmes classiques en apprentissage automatique. Cet article se concentre sur la déduction des formules dans les SVM, telles que le raisonnement détaillé de la formule de la distance de marge, ainsi que la formulation du problème primal et du problème dual. Il explore en profondeur les problèmes d’optimisation, y compris la construction de la fonction lagrangienne pour traiter les problèmes d’optimisation sous contrainte, et l’utilisation des conditions KKT pour trouver la solution optimale. Il aborde également les caractéristiques des fonctions noyau polynomial et gaussien.

Raisonnement de la Distance de Marge

Dans les machines à vecteurs de support (SVM), les équations des hyperplans positif et négatif sont respectivement : $$ \vec{w} \cdot \vec{x} + b = 1 \quad \text{(Hyperplan positif)} $$ $$ \vec{w} \cdot \vec{x} + b = -1 \quad \text{(Hyperplan négatif)} $$ où $\vec{w}=(w_1, w_2)$ est le vecteur de poids, $b$ est le biais, et $\vec{x}=(x_1, x_2)$ est le point de données.

Supposons que $\vec{x_m}$ est un point sur l’hyperplan positif et $\vec{x_n}$ un point sur l’hyperplan négatif, alors : $$ w_1 x_{1m} + w_2 x_{2m} + b = 1 \quad \text{(1)} $$ $$ w_1 x_{1n} + w_2 x_{2n} + b = -1 \quad \text{(2)} $$

En soustrayant l’équation (2) de l’équation (1), on obtient : $$ w_1 (x_{1m} - x_{1n}) + w_2 (x_{2m} - x_{2n}) = 2 $$ Sous forme vectorielle : $$ \vec{w} \cdot (\vec{x_m} - \vec{x_n}) = 2 \quad \text{(3)} $$ Considérons deux points $\vec{x_0}$ et $\vec{x_p}$ sur l’hyperplan de décision, satisfaisant l’équation de l’hyperplan de décision $\vec{w} \cdot \vec{x} + b = 0$, c’est-à-dire : $$ w_1 x_{10} + w_2 x_{20} + b = 0 $$ $$ w_1 x_{1p} + w_2 x_{2p} + b = 0 $$ En soustrayant les deux équations, on obtient : $$ w_1 (x_{10} - x_{1p}) + w_2 (x_{20} - x_{2p}) = 0 $$ Sous forme vectorielle : $$ \vec{w} \cdot (\vec{x_0} - \vec{x_p}) = 0 \quad \text{(4)} $$ L’équation (4) montre que $\vec{w}$ est perpendiculaire à la différence vectorielle de deux points quelconques sur l’hyperplan de décision.

D’après les équations (3) et (4), on sait que le produit scalaire de $\vec{w}$ et $(\vec{x_m} - \vec{x_n})$ est égal à 2. Selon la définition du produit scalaire $\vec{a} \cdot \vec{b}=|\vec{a}| \cdot |\vec{b}| \cdot \cos \theta$, où $\theta$ est l’angle entre $\vec{w}$ et $(\vec{x_m} - \vec{x_n})$, nous avons : $$ |\vec{x_m} - \vec{x_n}| \cdot \cos \theta \cdot |\vec{w}| = 2 $$ En posant $L = |\vec{x_m} - \vec{x_n}| \cdot \cos \theta$, on obtient : $$ L \cdot |\vec{w}| = 2 $$ En résolvant, on trouve : $$ L=\frac{2}{|\vec{w}|} $$

Ici, $L$ est la distance de marge du SVM.

Dans la déduction de la distance de marge, nous avons utilisé la signification géométrique du produit scalaire, c’est-à-dire $\vec{a} \cdot \vec{b}=|\vec{a}| \cdot |\vec{b}| \cdot \cos \theta$, où $\theta$ est l’angle entre les deux vecteurs. Grâce à cette relation, nous avons transformé le produit scalaire en une relation entre la norme des vecteurs et l’angle, ce qui nous a permis de dériver l’expression de la distance de marge.

Preuve de l’Équivalence Duale

Dans les machines à vecteurs de support (SVM) linéaires, le problème primal est de trouver le vecteur de poids $w$ et le biais $b$ qui minimisent la fonction objectif :

$$ \min_w f(w) = \frac{1}{2} |w|^2 $$

Ici, $|w|^2$ représente le carré de la norme euclidienne du vecteur $w$, c’est-à-dire la norme $L_2$. L’objectif est de minimiser la largeur de la marge de décision pour obtenir une meilleure capacité de généralisation. Ce problème est soumis à la contrainte suivante :

$$ y_j (w^T x_j + b) - 1 \geq 0 $$

Ici, $x_j$ est le $j$-ième échantillon d’entraînement, et $y_j$ est l’étiquette correspondante, prenant les valeurs +1 ou -1, ce qui garantit que tous les points de données sont correctement classifiés et sont à au moins une unité de distance de la marge de décision.

Pour traiter ce problème d’optimisation sous contrainte, nous construisons la fonction lagrangienne :

$$ L(w, b, \alpha) = f(w) - \sum_{j = 1}^n \alpha_j g_j(w, b) $$

Ici, $\alpha_j \geq 0$ sont les multiplicateurs de Lagrange, utilisés pour introduire les conditions de contrainte du problème primal $g_j(w, b) = y_j (w^T x_j + b) - 1 \geq 0$.

Ensuite, nous définissons la fonction duale $q(\alpha)$ comme suit :

$$ q(\alpha) = \min_{w, b} L(w, b, \alpha) = \min_{w, b} \left( f(w) - \sum_{j = 1}^n \alpha_j g_j(w, b) \right) $$

Puisque $\alpha_j \geq 0$ et $g_j(w^{*}, b^{*}) \geq 0$, nous pouvons en déduire :

$$ q(\alpha) = \min_{w, b} \left( f(w) - \sum_{j = 1}^n \alpha_j g_j(w, b) \right) \leq f(w^*) - \sum_{j = 1}^n \alpha_j g_j(w^*, b^*) \leq f(w^*) \leq f(w) $$

Cela signifie que la fonction duale fournit une borne inférieure du problème primal. Ensuite, nous devons trouver un $\alpha^*$ tel que :

$$ q(\alpha) \leq q(\alpha^*) \leq f(w^*) \leq f(w) $$

Le problème primal et le problème dual des SVM peuvent être formulés comme suit :

$$ \max_{\alpha} q(\alpha) = \max_{\alpha} \min_{w, b} L(w, b, \alpha) $$

Avec la contrainte : $ \alpha_i \geq 0 $

Et lorsque la dualité faible est satisfaite, nous avons $q(\alpha^*) \leq f(w^*)$ ; tandis que lorsque la dualité forte est satisfaite, c’est-à-dire lorsque la condition de Slater est remplie, nous avons $q(\alpha^*) = f(w^*)$. La condition de Slater exige qu’il existe une solution faisable telle que toutes les contraintes d’inégalité soient strictement satisfaites, et le SVM linéairement séparable satisfait automatiquement la condition de Slater.

Ainsi, nous avons :

$$ f(w) \geq q(\alpha^*) = f(w^*) \geq q(\alpha_i) $$

D’après cette équation, nous pouvons obtenir :

$$ q(\alpha^*) \geq q(\alpha_i) $$ $$ f(w^*) \leq f(w) $$

$f(w)$ a trouvé sa valeur minimale (problème primal), $q(\alpha)$ a trouvé sa valeur maximale (problème dual), et les solutions optimales du problème primal et du problème dual sont égales, c’est-à-dire :

$ w^*, b^* $ est la solution du problème primal, $\alpha^*$ est la solution du problème dual, et $f(w^*) = q(\alpha^*)$.

Nous pouvons voir que dans les SVM linéaires, lorsque certaines conditions (conditions de Slater) sont satisfaites, les solutions du problème primal et du problème dual sont cohérentes. Cela constitue une méthode efficace pour résoudre des problèmes d’optimisation complexes, en particulier lorsque le problème primal est difficile à résoudre directement, on peut résoudre le problème dual pour le résoudre indirectement.

Exemple Simple

Pour comprendre plus intuitivement que les solutions du problème primal et du problème dual sont les mêmes, considérons un problème d’optimisation simple, défini comme suit :

Problème primal : $$ \min_x f(x) = x^2 $$ Avec la contrainte : $$ x - 1 \geq 0 $$

L’objectif de ce problème est de minimiser la fonction $f(x) = x^2$, tout en satisfaisant $x \geq 1$. Intuitivement, nous savons que lorsque $x = 1$, $f(x) = 1$, c’est la valeur minimale sous la contrainte donnée.

Pour vérifier la dualité, nous construisons la fonction lagrangienne :

$$ q(\alpha) = \min_x L(x, \alpha) = \min_x (x^2 - \alpha(x - 1)) $$

Ici, $\alpha \geq 0$ est le multiplicateur de Lagrange, utilisé pour introduire la contrainte du problème primal $x - 1 \geq 0$. En construisant la fonction lagrangienne, nous avons transformé le problème d’optimisation sous contrainte en un problème sans contrainte.

Ensuite, nous dérivons $L(x, \alpha)$ par rapport à $x$ et nous l’égalons à zéro :

$$ \frac{\partial L}{\partial x} = 0 2x - \alpha = 0 $$

En résolvant, on trouve :

$$ x = \frac{\alpha}{2} $$

En substituant $x = \frac{\alpha}{2}$ dans $q(\alpha)$ :

$$ q(\alpha) = - \frac{\alpha^2}{4} + \alpha $$

Nous avons maintenant obtenu la forme de la fonction duale $q(\alpha)$. Ensuite, nous devons résoudre le problème dual pour trouver le maximum $\max_{\alpha} q(\alpha) $

Pour cela, nous dérivons $q(\alpha)$ par rapport à $\alpha$ et nous l’égalons à zéro :

$$ \frac{dq}{d\alpha} = - \frac{\alpha}{2} + 1 = 0 $$

En résolvant, on trouve $$ \alpha = 2 $$

En substituant $\alpha = 2$ dans $x = \frac{\alpha}{2}$, on obtient : $$ x = 1 $$

À ce moment-là, en substituant $\alpha = 2$ dans $q(\alpha)$, on calcule :

$$ q(\alpha) = - \frac{2^2}{4} + 2 = 1 $$

À travers cet exemple simple, nous pouvons voir que la solution du problème primal $x = 1$, $f(x) = 1$, est équivalente à la solution du problème dual $\alpha = 2$, $q(\alpha) = 1$. Cela vérifie que, sous certaines conditions, les solutions du problème dual et du problème primal sont cohérentes.

En appliquant la théorie de la dualité, nous avons non seulement trouvé la solution du problème primal, mais aussi obtenu le même résultat en résolvant le problème dual, vérifiant ainsi l’équivalence des solutions du problème dual.

Résolution avec les Conditions KKT

SVM Satisfait les Conditions KKT

Le problème d’optimisation original des SVM est un problème d’optimisation convexe. La fonction objectif des SVM $\frac{1}{2}|w|^2$ est une fonction quadratique, qui est une fonction convexe par rapport à $w$. En même temps, la contrainte $y_i(w \cdot x_i + b) \geq 1$ est linéaire (contrainte affine), donc elle est également convexe. Dans un problème d’optimisation convexe, une solution localement optimale est également globalement optimale, et les conditions KKT sont des conditions nécessaires et suffisantes. Cela signifie que si un point satisfait les conditions KKT, alors il est globalement optimal.

La fonction objectif $\frac{1}{2}|w|^2$ est continue et différentiable, et la contrainte $y_i(w \cdot x_i + b) \geq 1$ est également continue et différentiable. Cette régularité garantit l’existence et l’unicité du gradient, permettant ainsi l’application efficace des conditions KKT dans lesquelles on dérive par rapport à $w$ et $b$ et on égalise à zéro.

Dans un problème d’optimisation convexe, les conditions KKT ne sont pas seulement nécessaires, mais aussi suffisantes. Cela signifie que si un point satisfait les conditions KKT, alors il est nécessairement une solution globalement optimale. Pour les SVM, en résolvant les conditions KKT, nous pouvons trouver les valeurs optimales de $w^*$ et $b^*$, déterminant ainsi le meilleur hyperplan séparateur.

Utilisation des Conditions KKT pour Résoudre les SVM Linéaires

Le problème d’optimisation original des SVM est de minimiser $\frac{1}{2}|w|^{2}$ tout en satisfaisant la contrainte $y_{i}(w\cdot x_{i}+b)\geqslant1$, où $i = 1,2,\cdots,N$.

Tout d’abord, construisons la fonction lagrangienne $L(w,b,\alpha)=\frac{1}{2}|w|^{2}-\sum_{i = 1}^{N}\alpha_{i}(y_{i}(w\cdot x_{i}+b)-1)$, où $\alpha_{i}\geqslant0$ sont les multiplicateurs de Lagrange. Selon les conditions KKT, nous avons :

$$ \nabla_{w}L(w^*,b^*,\alpha^*) = w^*-\sum_{i = 1}^{N}\alpha_{i}^*y_{i}x_{i}=0 $$

$$ \nabla_{b}L(w^*,b^*,\alpha^*)=-\sum_{i = 1}^{N}\alpha_{i}^*y_{i}=0 $$

$$ \alpha_{i}^*(y_{i}(w^*\cdot x_{i}+b^*)-1)=0 $$

$$ y_{i}(w^*\cdot x_{i}+b^*)-1\geqslant0 $$

$$ \alpha_{i}^*\geqslant0 $$

Ces conditions s’appliquent pour tous les $i = 1,2,\cdots,N$.

De $\nabla_{w}L(w^*,b^*,\alpha^*) = w^*-\sum_{i = 1}^{N}\alpha_{i}^*y_{i}x_{i}=0$, nous pouvons déduire

$$ w^*=\sum_{i = 1}^{N}\alpha_{i}^*y_{i}x_{i} \quad \text{(5)} $$ Étant donné qu’il existe au moins un $\alpha_{j}^*>0$ (si nous supposons que $\alpha_{i}^*=0$, cela conduirait à une contradiction avec la solution donnée par l’équation $\nabla_{w}L(w^*,b^*,\alpha^*) = w^*-\sum_{i = 1}^{N}\alpha_{i}^*y_{i}x_{i}=0$).

Pour résoudre $b^*$, nous pouvons substituer $w^*=\sum_{i = 1}^{N}\alpha_{i}^*y_{i}x_{i}$ dans $y_{j}(w^*\cdot x_{j}+b^*)-1 = 0$ (considérant l’existence de $\alpha_{j}^*>0$), et en notant que $y_{j}^{2}=1$, nous obtenons :

$$ b^*=y_{j}-\sum_{i = 1}^{N}\alpha_{i}^*y_{i}(x_{i}\cdot x_{j}) \quad \text{(6)} $$

Basé sur la théorie ci-dessus, l’hyperplan séparateur peut être exprimé comme :

$$ \sum_{i = 1}^{N}\alpha_{i}^*y_{i}(x\cdot x_{i})+b^*=0 $$

Ainsi, la fonction de décision de classification peut être écrite comme :

$$ f(x)=\text{sign}(\sum_{i = 1}^{N}\alpha_{i}^*y_{i}(x\cdot x_{i})+b^*) $$

Dans les SVM, la condition de complémentarité $\alpha_i (y_i(w \cdot x_i + b) - 1) = 0$ indique que si un point d’échantillon $x_i$ n’est pas un vecteur de support (c’est-à-dire $y_i(w \cdot x_i + b) > 1$), alors le multiplicateur de Lagrange correspondant $\alpha_i$ doit être nul. Inversement, si un point d’échantillon est un vecteur de support (c’est-à-dire $y_i(w \cdot x_i + b) = 1$), alors $\alpha_i$ peut être non nul. Cette condition garantit que seuls les vecteurs de support contribuent à la solution du problème d’optimisation, simplifiant ainsi le processus de résolution du problème.

Fonction Noyau Polynomial et Noyau Gaussien

Si le problème actuel n’est pas linéairement séparable, nous pouvons mapper les données existantes dans un espace de haute dimension, de sorte qu’elles deviennent un problème linéairement séparable dans cet espace de haute dimension. Mais effectuer des calculs directement dans l’espace de caractéristiques de haute dimension peut être très complexe. D’après les équations (5) et (6), nous savons que nous n’avons pas vraiment besoin de mapper les données dans un espace de haute dimension, tant que nous connaissons le produit scalaire entre les points de données. Le rôle de la fonction noyau est d’éviter de réaliser explicitement le mappage vers un espace de haute dimension, en calculant la valeur de la fonction noyau dans l’espace de caractéristiques d’origine pour réaliser indirectement le calcul du produit scalaire dans l’espace de caractéristiques de haute dimension.

La fonction noyau gaussienne est une fonction noyau courante, de la forme : $$ K(x, y) = \exp\left(-\gamma |x - y|^2\right) $$

où $\gamma$ est un paramètre positif, contrôlant la largeur de la fonction noyau.

Nous pouvons développer la fonction exponentielle en série de Taylor :

$$ \exp(z) = \sum_{k=0}^{\infty} \frac{z^k}{k!} $$

En substituant $ z = -\gamma |x - y|^2 $ dans la formule ci-dessus, on obtient :

$$ K(x, y) = \exp\left(-\gamma |x - y|^2\right) = \sum_{k=0}^{\infty} \frac{(-\gamma |x - y|^2)^k}{k!} $$

La fonction noyau polynomial est de la forme :

$$ K_{\text{poly}}(x, y) = (x \cdot y + c)^d $$

où $ c $ est la constante et $ d $ est le degré du polynôme.

$|x - y|^2$ peut être développé comme suit :

$$ |x - y|^2 = (x - y) \cdot (x - y) = x \cdot x + y \cdot y - 2 x \cdot y $$

En substituant cette expression dans la série de Taylor de la fonction noyau gaussienne :

$$ K(x, y) = \sum_{k=0}^{\infty} \frac{(-\gamma (x \cdot x + y \cdot y - 2 x \cdot y))^k}{k!} $$

On peut voir que chaque terme $ \frac{(-\gamma (x \cdot x + y \cdot y - 2 x \cdot y))^k}{k!} $ est en fait un terme polynomial, c’est-à-dire que chaque terme peut être exprimé comme une combinaison de puissances différentes de $ x $ et $ y $.

Si nous examinons attentivement chaque terme, nous pouvons constater que la fonction noyau gaussienne est en réalité obtenue en harmonisant les fonctions noyau polynomiales de différents ordres. Chaque terme $ \frac{(-\gamma (x \cdot x + y \cdot y - 2 x \cdot y))^k}{k!} $ peut être considéré comme une forme pondérée d’une fonction noyau polynomiale d’ordre $ k $.

Par exemple, lorsque $ k = 1 $ :

$$ \frac{(-\gamma (x \cdot x + y \cdot y - 2 x \cdot y))^1}{1!} = -\gamma (x \cdot x + y \cdot y - 2 x \cdot y) $$

Lorsque $ k = 2 $ :

$$ \frac{(-\gamma (x \cdot x + y \cdot y - 2 x \cdot y))^2}{2!} = \frac{\gamma^2 (x \cdot x + y \cdot y - 2 x \cdot y)^2}{2} $$

Ces termes sont tous sous forme polynomiale de $ x $ et $ y $, et sont pondérés par la factorielle $ k! $.

La fonction noyau gaussienne peut être considérée comme étant obtenue en harmonisant les fonctions noyau polynomiales de différents ordres dans un espace de dimensions infinies. Cette harmonisation permet à la fonction noyau gaussienne de capturer des relations non linéaires plus complexes dans l’espace de caractéristiques de haute dimension. Par conséquent, dans la plupart des scénarios de tâches non linéaires, la fonction noyau gaussienne est un très bon choix.

VLDB 2024 est une conférence internationale de premier plan dans le domaine de la gestion des données et des bases de données, couvrant des domaines tels que la gestion des données, l’architecture des bases de données, la gestion des données graphiques, la confidentialité et la sécurité des données, l’exploration de données, l’apprentissage automatique, l’intelligence artificielle et la recherche sur les systèmes de bases de données. Cette année, la conférence s’est tenue du 26 au 30 août à Guangzhou, en Chine, réunissant des chercheurs et des entreprises du monde entier. Le programme était riche, avec plus de 250 présentations de recherche, 11 discours principaux, plusieurs tutoriels et ateliers, offrant aux participants de nombreuses opportunités d’apprentissage et d’échange.

Je suis récemment allé à Guangzhou pour participer à VLDB 2024 et j’ai vécu l’intégralité du processus de la conférence académique. J’ai également rencontré de nombreuses choses intéressantes pendant le voyage, et j’ai pensé écrire un blog pour partager mon expérience.

Le voyage a duré 6 jours, avec le programme suivant. Les 5 premiers jours se sont déroulés près du centre d’exposition de la foire de Canton sur l’île de Pazhou, principalement pour assister à la conférence et à la croisière nocturne sur la rivière des Perles ; le dernier jour était consacré à un tourisme éclair, partant de l’île de Shamian à l’ouest, passant par le musée des Treize Hongs, jusqu’à la cathédrale du Sacré-Cœur, et à l’est, le mémorial de l’académie militaire de Huangpu.

Jour 0 : Un petit choc à Guangzhou pour les citadins

À 15h, je suis arrivé à la station de métro de Pazhou depuis la gare du sud de Guangzhou. Avant même de sortir de la station, j’ai réalisé que quelque chose n’allait pas : le métro était rempli de cosplayers. Par un malheureux hasard, la carte m’a dirigé vers la sortie du Poly World Trade Center, ce qui m’a plongé au cœur d’un rassemblement de passionnés de culture anime : de la sortie de métro au sous-sol du centre, du Poly World Trade Center au centre d’exposition de la foire de Canton, l’île de Pazhou était envahie par les fans d’anime ! Non seulement ils étaient nombreux, mais les personnages cosplayés étaient très variés, allant des jeux chinois aux animes japonais, de personnages historiques à des figures politiques… Le parking était également rempli de voitures décorées, presque aucune voiture électrique, les propriétaires étant probablement aussi de fervents amateurs d’anime.

Après avoir enfin réussi à me frayer un chemin jusqu’à l’hôtel, j’ai découvert à 21h, en allant dîner, que le salon n’était pas encore terminé et qu’une scène nocturne avait même été installée le long de la rivière - et le lendemain était un lundi ! L’atmosphère de la culture anime à Guangzhou est vraiment très forte.

Jour 1 : Les sauterelles académiques et le quiproquo du dîner

VLDB2024 a été organisé par l’Université des Sciences et Technologies de Hong Kong (Guangzhou) à l’hôtel Langham de Guangzhou. Le premier jour, l’enregistrement a commencé à 8h du matin. Étant très excité pour ma première participation à une conférence académique, je suis arrivé très tôt. Lors de l’enregistrement, on vous remet un badge, un manuel de la conférence, un programme, des tickets repas, un billet de bateau, une boîte de souvenirs et une pile de publicités de sponsors. Les souvenirs incluent un carnet relié, un stylo à bille et un parapluie, disponibles en deux couleurs : noir et bleu.

Le contenu de la première journée de la conférence était entièrement organisé sous forme d’ateliers. Plusieurs ateliers sur différents thèmes se déroulaient simultanément, il fallait donc choisir à l’avance les thèmes qui vous intéressaient. J’ai choisi des thèmes liés aux LLM, Knowledge Graph et Vector Database. Comprendre le contenu des présentations n’était pas trop difficile, mais lors des discussions, certains intervenants se sont emballés, accélérant leur discours, ce qui m’a fait perdre le fil. Mon écoute et mon expression en anglais nécessitent encore du travail.

Les pauses-café ont lieu à 10h et 15h, et le petit-déjeuner à 8h est également sous forme de pause-café. Pour les grands chercheurs, les pauses-café sont des moments propices pour socialiser, discuter de recherches ou échanger des contacts. Mais pour moi, simple participant, les pauses-café sont vraiment juste des pauses. Bien que les aliments varient à chaque pause, ils se composent généralement de biscuits, de pain, de gâteaux, de fruits et de boissons. Parmi eux, le gâteau mousse et le gâteau de poisson thaïlandais avec sauce sucrée et épicée sont mes préférés.

Le dîner de bienvenue était également très copieux, sous forme de buffet. Cependant, il y avait tellement de monde dans la file d’attente que je n’ai pas fait attention aux plats disponibles, et j’ai pris deux cuillères de riz en premier, manquant ainsi de nombreux bons plats. Les plats comprenaient environ 30% de cuisine chinoise, le reste étant des plats japonais (sushi et sashimi), curry, salades de légumes, desserts, fruits et boissons (vin rouge et jus de fruits), répondant aux différentes préférences alimentaires. Cependant, parmi ces plats, la cuisine chinoise était plutôt ordinaire, ce qui m’a conduit à finir avec du riz au curry et des petits gâteaux. Hélas, il m’est difficile de renoncer aux petits gâteaux.

Pendant le dîner, il y a eu un quiproquo. J’étais venu à cette conférence avec un autre étudiant, et nous n’avions jamais rencontré notre directeur. Après avoir choisi nos plats et trouvé une table, nous avons commencé à écouter les discussions des autres à notre table. Et nous avons eu le dialogue suivant : “Ne trouves-tu pas que celui en face ressemble à notre directeur ?” “Impossible, quelle coïncidence ?” “Le domaine de recherche correspond, ils ont dit…” “L’âge ne correspond pas…” “Le nombre de personnes correspond aussi…” “La taille correspond aussi…” “C’est trop ressemblant…” “C’est carrément lui…” “Que faire, on se présente maintenant ?” “À ce stade, mangeons d’abord.” Nous avons donc terminé notre repas très nerveusement, et après nous être présentés, nous avons découvert que ce n’était pas lui. Ils étaient doctorants de l’Université de Tianjin et de l’Université normale de Chine de l’Est, avec des domaines de recherche similaires. Après nous être présentés, nous avons échangé nos contacts. Plus tard, nous avons découvert que leurs articles étaient nominés pour le meilleur article de recherche, ce qui nous a rendus très envieux.

Jour 2 : Lion dansant, ouverture !

Lors de la cérémonie d’ouverture, ce qui m’a le plus marqué, c’est la performance de lion dansant de Shapeng à Guangzhou. Au début de la performance, les danseurs manipulaient le lion pour imiter des mouvements réalistes, reproduisant les habitudes de vie du lion, comme secouer la tête, se gratter, rouler, etc. Le plus remarquable était que les yeux du lion bougeaient (c’est ce qui m’a permis de reconnaître que c’était un lion dansant de Shapeng). Ensuite, le lion a commencé à sauter et à marcher sur des poteaux sur scène, démontrant les compétences précises et la force physique des danseurs. Enfin, les dirigeants sont montés sur scène pour peindre les yeux du lion, et le lion a sorti une banderole de félicitations. Toute la performance, accompagnée du rythme des tambours et des gongs, montrait un lion tantôt puissant, tantôt agile, à la fois plein de force et de charme.

C’était la première fois que je voyais une véritable performance de lion dansant, et c’était le lion dansant cantonnais le plus caractéristique. Bien que de nombreux jeux incluent des scènes inspirées du lion dansant cantonnais, en particulier le mouvement emblématique de marcher sur des poteaux, ces scènes se concentrent souvent sur l’ambiance de la performance, manquant de l’humour des mouvements imitatifs du lion, et la force ressentie n’est pas aussi intense que lors d’une performance en direct.

Après la performance de lion dansant, le président de la conférence, le professeur Chen Lei de l’Université des Sciences et Technologies de Hong Kong, a présenté quelques informations générales sur la conférence : c’était la conférence VLDB avec le plus grand nombre de participants de son histoire, avec 60% des participants venant de Chine continentale, c’était la conférence la plus riche (half a million dollar), avec le plus grand nombre d’articles sur l’IA et le moins d’articles sur la conception de bases de données.

Après la cérémonie d’ouverture, une journée entière de sessions parallèles a commencé. Les sessions parallèles nécessitent également de choisir à l’avance les thèmes qui vous intéressent, et il est préférable de lire les articles qui vous intéressent à l’avance, voire de préparer des questions à poser. Le dîner était aussi copieux que la veille, la soupe épaisse aux légumes italiens et le mille-feuille étaient excellents ! (Seul) Ce jour-là, il y avait aussi des brochettes, avec des ailes de poulet et du gluten. Après le repas, en faisant le tour, j’ai remarqué que toutes les tables avec des Chinois avaient pris des brochettes, et certains mangeaient même du riz blanc avec des brochettes, montrant que tout le monde avait encore un goût chinois. Les barbecues pour informaticiens ont de l’avenir.

Jour 3 : Du sommet de la cuisine cantonaise au pont

La matinée a commencé par un discours principal de Google, sur l’impact des grands modèles sur la recherche en bases de données. Ensuite, les sessions parallèles ont continué comme la veille.

Cuisine cantonaise raffinée

Le dîner du soir s’est déroulé au restaurant Bing Sheng Pinwei Haizhu. Sur le chemin, j’ai rencontré deux étudiants étudiant aux États-Unis, qui ont dit que pour une conférence organisée par des Chinois, il fallait en mettre plein la vue. Ce n’était pas faux, j’ai découvert plus tard que ce restaurant était à la fois étoilé Michelin et considéré comme le sommet de la cuisine cantonaise. L’un d’eux, vivant sur la côte ouest des États-Unis, a décrit sa vie comme étant dans un village, sans rien à manger ni à faire ; l’autre, sur la côte est, a également mentionné que les conditions alimentaires n’étaient pas idéales, mais qu’il pouvait pratiquer différents sports tous les jours. En parlant des objectifs de leurs études supérieures, l’un d’eux a dit que c’était pour maintenir une capacité d’insight et une mentalité d’apprentissage tout au long de la vie, ce avec quoi je suis tout à fait d’accord.

Le dîner était en effet très varié. Comme il n’était pas pratique d’utiliser un téléphone à table, je ne peux me souvenir que de quelques plats marquants : soupe de côtes au ginseng, cochon de lait rôti entier (mais avec des ampoules rouges dans les yeux, en tant qu’étranger, je l’appellerais cochon de lait rôti démoniaque), homard de Boston à la vapeur à l’ail, gros concombre de mer, poisson, poulet et canard, porc aigre-doux, eau sucrée, tomates et melon, gâteau de riz soufflé et thé Pu’er. Dans l’ensemble, c’était plutôt bon, le cochon de lait rôti était croustillant et tendre, le porc aigre-doux était savoureux, et les ingrédients choisis étaient très typiques de Lingnan. Cependant, peut-être parce que je n’y suis pas habitué, certains plats caractéristiques de la cuisine cantonaise étaient les plus difficiles à manger : l’eau sucrée était vraiment trop sucrée, le ginseng dans la soupe était acide, et un dessert ressemblait à une pâte de gâteau de lune enveloppant une farce crue de céleri et de porc, ce qui était vraiment difficile à accepter. Curieusement, le restaurant ne fournissait pas de couteaux et de fourchettes par défaut, et certains étrangers étaient obligés d’utiliser des baguettes, mais cela ne semblait pas poser de problème.

À notre table, il y avait un chercheur d’Amazon et un professeur assistant d’une université américaine. Le chercheur d’Amazon a dit des choses inappropriées pour les étudiants du point de vue de l’industrie, devant mon directeur. Le professeur assistant a parlé de l’atmosphère détendue dans les universités américaines, où on peut obtenir un poste permanent en suivant son propre rythme de travail. La soupe de côtes a peut-être été acidifiée par le ginseng à ce moment-là.

Après le repas, tout le monde s’est rendu à pied au quai pour participer à une croisière nocturne sur la rivière des Perles. En chemin, j’ai rencontré un étudiant en première année de doctorat à l’Université de Nagoya, qui a fait l’éloge de la vie doctorale au Japon, y compris la liberté laissée par les directeurs, les allocations élevées, le marché de l’emploi favorable aux vendeurs et l’environnement culturel. Faire un doctorat peut être aussi agréable ?

Croisière nocturne sur la rivière des Perles

À la tombée de la nuit, les lumières des deux rives de la rivière des Perles s’illuminent. Nous montons à bord du bateau, naviguant lentement dans la nuit scintillante. Les gratte-ciels des deux rives brillent de mille feux, se reflétant sur l’eau ondulante, comme des étoiles tombées dans les vagues.

En passant devant des bâtiments emblématiques, la tour de Canton se dresse majestueusement, ses lumières changeantes créant une atmosphère onirique. Le quartier des affaires de Zhujiang New Town, avec ses gratte-ciels, dessine la ligne d’horizon d’une métropole moderne. En passant sous le pont de Haizhu, la circulation sur le pont est dense, tandis que les bateaux naviguent en dessous, créant une scène animée.

La brise caresse le visage, l’eau clapote doucement contre la coque. Sous le pont, des musiques folkloriques ajoutent une touche de détente à cette nuit. Les touristes s’appuient à la rambarde pour admirer la vue, ou lèvent leurs verres pour discuter, envoûtés par cette nuit enchanteresse.

Les deux heures de croisière passent en un clin d’œil. En repensant à tout le voyage, la métropole animée et l’histoire ancienne se fondent parfaitement sur cette rivière mère, laissant une impression inoubliable.

Nouvelle forme de rencontre

Mon camarade et moi étions à l’avant du bateau au troisième étage pour admirer le paysage, lorsqu’un étranger est arrivé. Il portait un sac à dos, transpirait abondamment et semblait pressé. Il nous a demandé s’il y avait du Wi-Fi sur le bateau et si nous connaissions le mot de passe, car il voulait contacter sa famille. Nous avons découvert qu’il n’y en avait pas, alors nous lui avons proposé de partager notre connexion. Une fois connecté, nous avons pensé que, puisque les applications de réseaux sociaux étrangères sont presque toutes bloquées, cet homme pourrait avoir cherché du Wi-Fi à Guangzhou sans succès. En se mettant à sa place : être dans un pays lointain et mystérieux, chaque Wi-Fi étant bloqué, sans contact avec sa famille pendant trois jours, demander à d’autres de partager leur connexion mais personne ne veut “partager” - c’est vraiment triste. Nous avons donc essayé de partager notre VPN via le réseau local, mais cela s’est avéré impossible sur un téléphone.

Cependant, nous avons rapidement découvert que cet homme était très sociable. Tout au long du voyage, il a posé des questions : “Que signifie ICBC ? Que signifie ‘Liede’ ? D’où venez-vous ? Quel est ce logo ?” … et a insisté pour prendre des photos avec nous.

Ainsi, nous avons discuté tout au long du voyage, ajoutant une touche différente à cette croisière nocturne.

Plus tard, sur Whova, nous avons découvert que cet homme était classé deuxième en termes d’activité, travaillait dans une université allemande et avait même une entreprise - cela ne ressemblait pas du tout à quelqu’un qui aurait perdu contact avec sa famille et aurait besoin de chercher du Wi-Fi partout.

Jour 4 : Collecte de goodies

Pendant VLDB2024, des stands de sponsors tels que Google, Meta, Alibaba et ByteDance étaient présents. Sur ces stands, vous pouviez remplir des questionnaires d’enquête et recevoir des goodies. Les questionnaires portaient principalement sur les domaines de recherche et les préférences de carrière, certains demandaient directement des cartes de visite. Parmi tous les goodies, j’ai préféré la chemise blanche de Google et le pingouin sur la photo ci-dessous. Si vous ne savez pas de quelle entreprise vient ce pingouin, lorsque vous verrez l’autocollant anti-contrefaçon dessus, vous saurez qu’il est de Tencent.

Les présentations de l’après-midi m’ont beaucoup inspiré. Certains travaux semblent simples, voire de simples idées, mais après une recherche approfondie, ils peuvent aboutir à un article complet, ce qui est impressionnant. Ce qui m’a le plus marqué, c’est un chercheur solitaire de l’Université Cornell, qui a présenté deux travaux qu’il avait réalisés seul lors de la même session. Il tenait le micro d’une main, l’autre main dans sa poche, les deux bras appuyés sur le pupitre, et ses diapositives étaient d’un style simple avec de grands caractères (aucune diapositive ne comportait plus de 30 mots), transformant la présentation en un véritable discours. C’est peut-être cela être un grand chercheur, déjà à un niveau supérieur.

Cette journée a marqué la fin de notre programme de conférence. En quittant l’hôtel, nous avons été confrontés à un temps orageux extrême, avec une pluie battante.

Jour 5 : En une demi-journée, traverser cinq siècles de l’histoire chinoise

Dans l’esprit du “puisque nous sommes là”, j’ai planifié une journée de tourisme éclair pour mon dernier jour à Guangzhou. Ce jour-là, j’ai parcouru plusieurs sites célèbres de Guangzhou, découvrant la riche histoire et le patrimoine culturel de cette ville.

Tôt le matin, je suis d’abord allé sur l’île de Shamian, pleine de charme exotique. En me promenant dans cette ancienne concession, les bâtiments européens et les plantes tropicales se mêlent harmonieusement, me transportant dans le passé. Un critère pour juger de la beauté d’un lieu est de savoir si des gens y prennent des photos de mariage, comme la gare de Pukou, le parc de la verdure et le mausolée Sun Yat-sen à Nanjing, et l’île de Shamian à Guangzhou.

Après avoir passé la matinée sur l’île de Shamian, je suis allé à pied au musée des Treize Hongs à proximité, pour en apprendre davantage sur l’histoire glorieuse de Guangzhou en tant que port important de la route maritime de la soie. Les artefacts et les photos exposés au musée illustrent vividamente la prospérité commerciale de Guangzhou du XVIIe siècle et son statut semi-colonial au XIXe siècle. J’ai appris que, après l’ouverture forcée de Guangzhou au commerce, les comptoirs étrangers étaient initialement situés le long du centre-ville de l’autre côté de la rivière, mais ont été déplacés sur l’île de Shamian après un incendie.

Dans l’après-midi, je suis allé à la cathédrale du Sacré-Cœur. C’est un bâtiment gothique imposant, recommandé sur Xiaohongshu comme un incontournable. Mais en réalité, c’est juste un point de repère, avec seulement l’entrée accessible, et la plupart du temps, elle n’est pas ouverte.

L’après-midi, j’ai visité le site de l’ancienne académie militaire de Huangpu. En me promenant dans cet endroit qui a formé de nombreux révolutionnaires, j’espérais ressentir l’époque passionnée. N’ayant pas fait de recherches préalables, cela ne correspondait pas à mes attentes et j’ai été quelque peu déçu. Le site original de l’académie militaire de Huangpu a été réduit en cendres par les bombardements japonais pendant la guerre, et les bâtiments actuels sont des reconstructions. En regardant les bâtiments propres et bien rangés, je ne pouvais m’empêcher de penser à “Fuzimiao” - je me sentais simplement dans un site touristique. J’ai cherché longtemps la porte principale, mais je n’ai pas trouvé la célèbre inscription : “Pour ceux qui veulent s’enrichir et obtenir des promotions, allez ailleurs ; pour ceux qui craignent la mort, n’entrez pas ici.”

À la tombée de la nuit, je suis retourné au bord de la rivière des Perles, me promenant le long des rives. La nuit à Guangzhou, l’horizon et la ligne d’horizon, la petite tour et le grand théâtre, sont toujours fascinants. Du pont de Haizhu au pont de Liede, la même rivière des Perles, du XVIIe au XXIe siècle, chaque siècle offre un paysage différent.

Ces jours passés à Guangzhou ont été comme un voyage à travers le temps, de l’antiquité à nos jours. De la salle académique de Pazhou aux lumières éblouissantes des rives de la rivière des Perles ; du charme exotique de l’île de Shamian aux vestiges révolutionnaires de l’académie militaire de Huangpu. Cette ville, avec sa manière unique, fusionne parfaitement l’académique, la culture, l’histoire et la modernité. À l’ombre des gratte-ciels, il y a aussi la vie animée des villages urbains ; sous les ponts bondés, il y a aussi des sans-abri, rappelant que cette ville est toujours en progrès et en inclusion. Mais ces scènes n’affaiblissent pas le charme de Guangzhou, elles rendent la ville plus authentique et plus humaine.

Au revoir, Guangzhou.

Nous estimons que le stock de texte public produit par l’humanité est d’environ 300 000 milliards de tokens. Si la tendance se poursuit, les modèles linguistiques auront épuisé ce stock entre 2026 et 2032, ou même plus tôt en cas de surentraînement. ——Epoch AI

En 2006, Fei-Fei Li, alors professeur à l’Université de l’Illinois (aujourd’hui à Stanford), a vu le potentiel d’Internet pour transformer la recherche en intelligence artificielle (IA). La recherche en linguistique avait identifié 80 000 “ensembles de synonymes de noms”, c’est-à-dire des ensembles de synonymes décrivant la même catégorie d’objets. Fei-Fei Li a supposé que parmi les milliards d’images sur Internet, il devait y avoir d’innombrables exemples de ces ensembles de synonymes. Si suffisamment de ces images pouvaient être collectées, cela permettrait de créer une base de données plus vaste que toute ressource d’entraînement en IA antérieure. Elle a déclaré : “Beaucoup de gens se concentrent sur les modèles, nous devrions nous concentrer sur les données”. Ainsi, le projet ImageNet est né.

Internet a fourni non seulement des images, mais aussi des ressources pour l’annotation d’images. Après avoir trouvé des images de chats, de chiens, de chaises, etc., via des moteurs de recherche, des personnes sur la plateforme de crowdsourcing Mechanical Turk d’Amazon ont vérifié et annoté ces images manuellement. Finalement, une base de données contenant des millions d’images vérifiées a été construite. C’est en utilisant une partie des données d’ImageNet qu’AlexNet a démontré en 2012 le potentiel énorme de “l’apprentissage profond”, ouvrant le cycle précédent de l’IA et donnant naissance à une industrie dépendante de grandes quantités de données annotées.

1 L’ère de l’IA pilotée par les données

Dans ce cycle de l’IA, le développement de l’IA s’est étendu aux grands modèles linguistiques (LLM), qui dépendent également des données Internet pour leur entraînement, mais de manière différente. La tâche classique d’entraînement en vision par ordinateur (CV) est de prédire le contenu d’une image (tâche de classification d’images), tandis que la tâche classique d’entraînement des LLM est de prédire les mots manquants dans un texte basé sur le contexte.

Cette méthode d’entraînement ne nécessite pas de données annotées manuellement, le système peut lui-même masquer des mots, faire des inférences et évaluer la justesse des réponses par “entraînement auto-supervisé”. Mais cette méthode nécessite de grandes quantités de données. En général, plus un modèle reçoit de texte et plus le volume de données est grand, meilleures sont ses performances (Scaling Law). Internet fournit justement des dizaines de milliards de textes, qui pour les LLM ont une signification comparable à celle du carbone déposé pendant des millions d’années pour l’industrie moderne, une ressource précieuse pouvant être raffinée en carburant.

Une source de données d’entraînement courante est Common Crawl, une archive Internet contenant 50 milliards de pages web. Avec le développement des modèles IA, davantage de données ont été ajoutées, comme Books3 - une base de données contenant des milliers de livres. Cependant, avec la croissance de la demande de données textuelles par l’IA, l’offre de données de qualité sur Internet devient progressivement insuffisante. Selon les estimations d’Epoch AI, d’ici 2028, les données textuelles de haute qualité sur Internet seront complètement épuisées, et l’industrie fera face à ce qu’on appelle le “mur de données”. L’Internet chinois est encore plus touché, passant de “l’Internet chinois s’effondre” à de grandes plateformes verrouillant leurs portes, une fois que la valeur des données a été reconnue, elles ont été mises en sécurité. Comment surmonter cette barrière pourrait être l’un des problèmes les plus épineux pour le développement futur de l’IA, et peut-être celui qui pourrait le ralentir le plus.

2 Problèmes de propriété et de droits d’auteur des données

Les modèles IA dépendent de plus en plus des données Internet, mais les questions de droits d’auteur des données sont également controversées. De nombreuses données utilisées pour entraîner les grands modèles linguistiques sont souvent utilisées sans le consentement des détenteurs des droits d’auteur, certaines entreprises d’IA exploitant même du contenu derrière des paywalls. Bien que les entreprises d’IA prétendent que cette utilisation relève de la “fair use” du droit d’auteur, les détenteurs de droits ne sont pas d’accord. Getty Images a poursuivi l’entreprise de génération d’images Stability AI, l’accusant d’avoir utilisé sa bibliothèque d’images sans autorisation. Le New York Times a poursuivi OpenAI et Microsoft, les accusant de violer les droits d’auteur de millions d’articles. Stack Overflow, Reddit et X (anciennement Twitter) facturent désormais des frais aux entreprises d’IA. Zhihu perturbe également les crawlers de Bing et Google avec des caractères illisibles pour limiter l’utilisation de son contenu chinois dans les ensembles de données pour l’entraînement de l’IA.

Les attitudes envers ce problème varient selon les régions. Le Japon et Israël ont adopté une position souple pour promouvoir le développement de leur industrie de l’IA. L’Union européenne, qui n’a pas de concept général de “fair use”, pourrait être plus stricte. En Chine, un Bureau national des données a été créé, clarifiant que les données ont une double identité de moyen de production et d’objet de production.

3 Stratégies actuelles d’utilisation des données

Face au mur de données, le domaine de l’IA a proposé plusieurs stratégies pour y faire face. Une stratégie clé est de se concentrer sur la qualité des données plutôt que sur la quantité. Les laboratoires d’IA ne se contentent plus d’utiliser aveuglément toutes les données d’Internet pour entraîner leurs modèles, mais accordent plus d’importance au filtrage, au nettoyage et à l’optimisation des données, garantissant que les modèles peuvent en extraire le contenu le plus précieux. Au cours de l’année écoulée (2024), les modèles d’OpenAI ne semblent plus “largement en avance”, les modèles des autres se battent à armes égales, et les différences de performance sur différentes tâches proviennent de la construction des données d’entraînement. Après tout, il existe de nombreux algorithmes et modèles open-source, mais très peu de jeux de données open-source.

Obtenir des “informations du monde réel” est crucial, surtout lorsque les modèles impliquent beaucoup de raisonnement, les ressources autoritaires comme les manuels académiques deviennent particulièrement précieuses. Mais comment trouver le meilleur équilibre entre différentes sources de données reste une science occulte.

Dans le processus d’utilisation des données, les modèles font également face au problème de “l’oubli catastrophique” - c’est-à-dire que lorsque le système est trop entraîné sur certains types de données, il peut exceller dans ce domaine tout en oubliant d’autres connaissances précédemment acquises. Par conséquent, l’ordre des données lors de l’entraînement doit également être soigneusement considéré. Si toutes les données sur un sujet (comme les mathématiques) sont concentrées à la fin du processus d’entraînement, le modèle pourrait bien performer sur les problèmes mathématiques, mais cela pourrait affaiblir ses capacités dans d’autres domaines. Ce déséquilibre dans l’entraînement augmente le risque d’oubli catastrophique.

Lorsque les données concernent à la fois différents domaines et différentes formes (modalités), ces stratégies deviennent plus complexes. En raison de la pénurie de nouvelles données textuelles, les modèles de pointe comme GPT-4 d’OpenAI et Gemini de Google utilisent, en plus des textes, des images, des vidéos et de l’audio pour s’entraîner lors de l’apprentissage auto-supervisé. Cependant, les données vidéo sont particulièrement délicates car les fichiers vidéo contiennent des points de données extrêmement denses. Pour simplifier le problème, les modèles actuels extraient généralement uniquement certaines images clés pour un traitement simplifié, et le monde académique cherche encore des solutions plus efficaces.

4 Données synthétiques et auto-entraînement de l’IA

Les capacités des modèles peuvent également être améliorées en utilisant des données supplémentaires pour un réglage fin (fine-tuning) sur la base des versions générées par l’apprentissage auto-supervisé (version pré-entraînement). Par exemple, le “réglage fin supervisé” consiste à fournir au modèle des paires de questions-réponses collectées ou créées par des humains pour lui enseigner ce qu’est une bonne réponse. Une autre méthode, “l’apprentissage par renforcement basé sur le retour d’information humain” (RLHF), consiste à indiquer au modèle si les réponses satisfont le demandeur.

Dans le RLHF, les utilisateurs donnent leur avis sur la qualité des sorties du modèle, et ces retours sont ensuite utilisés pour ajuster les paramètres (poids) du modèle. Les interactions des utilisateurs avec les chatbots, telles que les likes ou dislikes, sont particulièrement utiles pour le RLHF. C’est le mécanisme de la “flywheel des données” : plus d’utilisateurs apportent plus de données, qui à leur tour optimisent de meilleurs modèles. Les entreprises d’IA surveillent de près les diverses questions posées à leurs modèles par les utilisateurs, puis collectent des données pour ajuster les modèles afin de couvrir ces sujets. Alibaba, ByteDance et Minimax, entre autres, ont lancé des guerres de prix sur les modèles, difficile de dire qu’il n’y a pas de considérations à cet égard.

À mesure que les données pré-entraînement sur Internet s’épuisent progressivement, l’importance de l’entraînement postérieur (Post-Training) devient de plus en plus évidente. Des entreprises d’annotation comme Scale AI et Surge AI gagnent chaque année des centaines de millions de dollars en collectant des données d’entraînement postérieur. Scale a récemment levé 1 milliard de dollars à une valorisation de 14 milliards de dollars. Aujourd’hui, le travail d’annotation a dépassé l’ère de Mechanical Turk : les meilleurs annotateurs peuvent gagner jusqu’à 100 dollars de l’heure. Bien que l’entraînement postérieur contribue à générer de meilleurs modèles et puisse répondre aux besoins de nombreuses applications commerciales, cela reste une amélioration incrémentale, un remède temporaire.

Outre le franchissement progressif du mur de données, une solution consiste à le contourner complètement, c’est-à-dire à utiliser des données synthétiques générées par des machines. Le modèle AlphaGo Zero de DeepMind (filiale de Google) en est un bon exemple. Le premier modèle de Go réussi de l’entreprise a été entraîné sur les données de millions de parties amateurs, tandis qu’AlphaGo Zero n’a utilisé aucune donnée existante. Au lieu de cela, il a appris le Go en jouant 4,9 millions de parties contre lui-même en trois jours, enregistrant les stratégies réussies. Cet “apprentissage par renforcement” lui a appris à répondre aux coups de l’adversaire en simulant de nombreuses réponses possibles et en choisissant la stratégie avec la plus grande probabilité de succès.

Des méthodes similaires peuvent également être utilisées pour les LLM, comme le modèle open-source le plus puissant actuellement, Llama 3.1. Une proportion significative des données SFT de Llama 3.1 est constituée de données synthétiques générées par le modèle, et une grande partie des données de la phase SFT de Gemma2 est synthétisée par un modèle de plus grande envergure, prouvant que la qualité des données synthétiques n’est pas inférieure à celle des données annotées manuellement.

Peut-on alors générer des données synthétiques à l’infini, en se reposant sur ses propres lauriers ? Je pense que la réponse est non. Une étude publiée le mois dernier dans “Nature” a révélé que l’utilisation excessive de données synthétiques dans l’entraînement des modèles peut entraîner des “défauts irréversibles”. En utilisant des données synthétiques générées par des modèles pour affiner le modèle, il suffit de quelques cycles pour que le modèle commence à délirer, un phénomène que les chercheurs appellent “l’effondrement du modèle”.

Le problème plus important est de savoir comment étendre cette méthode à des domaines verticaux tels que la médecine ou l’éducation. Dans les jeux, la définition de la victoire est claire, et il est plus facile de collecter des données sur la pertinence d’une action. Dans d’autres domaines, c’est beaucoup plus complexe. Les données sur les “bonnes” décisions sont généralement collectées auprès d’experts, mais cela est coûteux et chronophage, et les solutions ne sont pas exhaustives. Comment déterminer si un expert a raison est aussi une question en soi.

5 Conclusion

Obtenir plus de données sera essentiel pour maintenir le progrès rapide de l’IA. Que ce soit des données spécialisées provenant de sources expertes ou des données synthétiques générées par des machines, le progrès de l’IA dépend de l’approvisionnement continu en données. À mesure que les réserves de données les plus facilement accessibles s’épuisent, l’industrie de l’IA a fait de nombreux efforts pour atténuer ce problème :

• Mettre l’accent sur la qualité des données, effectuer un nettoyage des données
• Augmenter la proportion de données mathématiques, logiques et de code, ajuster l’ordre d’entraînement
• Utiliser des données synthétiques pour compléter les données réelles

Mais tout cela semble insoutenable, il est nécessaire de trouver de nouvelles sources de données ou de développer des alternatives durables ; ou de concevoir de nouvelles architectures qui ne dépendent pas des données, ouvrant ainsi la voie au prochain cycle de l’IA.

6 Lectures recommandées

1. L’Internet chinois s’effondre à un rythme accéléré | He Jia Yan
2. Allons-nous manquer de données ? Limites de l’échelle des LLM basées sur les données générées par l’homme | EpochAI
3. Zhihu perturbe les crawlers de Bing/Google avec des caractères illisibles | CSDN
4. Les données d’entraînement de l’intelligence artificielle s’épuisent, les données synthétiques suscitent une énorme controverse | Wall Street Insights
5. Discussion sur Llama3.1, de la structure, du processus d’entraînement, de l’impact à la synthèse des données | Volcan Community
6. Les modèles IA s’effondrent lorsqu’ils sont entraînés sur des données générées de manière récursive | Nature

Ce n’est pas que Llama 3.1 405B soit inabordable, mais GPT-4o-mini offre un meilleur rapport qualité-prix.

1 Scénarios d’application de l’ajustement fin

Pour des tâches simples, il suffit de rédiger des prompts, et le modèle peut bien les accomplir. Si la tâche est plus complexe, on peut essayer d’utiliser une chaîne de pensée pour décomposer la tâche en plusieurs étapes et raisonner progressivement. Mais pour des tâches nécessitant une sortie de haute précision et cohérente, un ajustement fin est nécessaire.

Le tableau ci-dessous compare les avantages et inconvénients de ces trois méthodes ainsi que leurs scénarios d’application.

Le théorème NFL nous dit qu’aucune méthode ne peut s’appliquer à tous les scénarios, et c’est pareil ici, l’ajustement fin n’est pas forcément meilleur que les deux autres méthodes. Mais il est clair que l’ajustement fin convient aux tâches “difficiles à décrire”, comme un style et un ton particuliers. De plus, ces trois méthodes ne sont pas incompatibles, un modèle ajusté finement utilisant des prompts soigneusement conçus, voire combiné avec une chaîne de pensée, pourrait donner de meilleurs résultats.

Pour simplement écrire un article ou un paragraphe, un prompt suffit. Mais pour un article de blog, si l’on considère le SEO, il y a beaucoup de détails, comme la fréquence d’apparition des mots-clés principaux, etc. Ces détails ne sont pas forcément bien compris par le grand modèle, et en tant qu’utilisateur, on ne peut pas forcément bien les décrire dans le prompt. Ainsi, pour rédiger un tel article de blog, on peut utiliser l’ajustement fin.

2 Préparation des données

Les données doivent être organisées au format jsonl, chaque ligne étant un json. Par exemple :

1
2
3

{"messages": [{"role": "system", "content": "Marv est un chatbot factuel qui est aussi sarcastique."}, {"role": "user", "content": "Quelle est la capitale de la France ?"}, {"role": "assistant", "content": "Paris, comme si tout le monde ne le savait pas déjà."}]}
{"messages": [{"role": "system", "content": "Marv est un chatbot factuel qui est aussi sarcastique."}, {"role": "user", "content": "Qui a écrit 'Roméo et Juliette' ?"}, {"role": "assistant", "content": "Oh, juste un gars nommé William Shakespeare. Vous en avez déjà entendu parler ?"}]}
{"messages": [{"role": "system", "content": "Marv est un chatbot factuel qui est aussi sarcastique."}, {"role": "user", "content": "Quelle est la distance entre la Lune et la Terre ?"}, {"role": "assistant", "content": "Environ 384 400 kilomètres. À quelques kilomètres près, comme si cela avait vraiment de l'importance."}]}

Il est également possible de définir des poids dans les dialogues multi-tours, un poids de 0 indiquant au modèle d’éviter ce type de réponse.

1
2
3

{"messages": [{"role": "system", "content": "Marv est un chatbot factuel qui est aussi sarcastique."}, {"role": "user", "content": "Quelle est la capitale de la France ?"}, {"role": "assistant", "content": "Paris", "weight": 0}, {"role": "user", "content": "Peux-tu être plus sarcastique ?"}, {"role": "assistant", "content": "Paris, comme si tout le monde ne le savait pas déjà.", "weight": 1}]}
{"messages": [{"role": "system", "content": "Marv est un chatbot factuel qui est aussi sarcastique."}, {"role": "user", "content": "Qui a écrit 'Roméo et Juliette' ?"}, {"role": "assistant", "content": "William Shakespeare", "weight": 0}, {"role": "user", "content": "Peux-tu être plus sarcastique ?"}, {"role": "assistant", "content": "Oh, juste un gars nommé William Shakespeare. Vous en avez déjà entendu parler ?", "weight": 1}]}
{"messages": [{"role": "system", "content": "Marv est un chatbot factuel qui est aussi sarcastique."}, {"role": "user", "content": "Quelle est la distance entre la Lune et la Terre ?"}, {"role": "assistant", "content": "384 400 kilomètres", "weight": 0}, {"role": "user", "content": "Peux-tu être plus sarcastique ?"}, {"role": "assistant", "content": "Environ 384 400 kilomètres. À quelques kilomètres près, comme si cela avait vraiment de l'importance.", "weight": 1}]}

Bien sûr, le traitement des données est la partie la plus chronophage, mais vous pouvez également utiliser directement le jeu de données que j’ai créé. Ce jeu de données est utilisé pour ajuster finement le grand modèle, provenant de la capture de plus de 3000 pages dans 13 domaines de classification sur le site reads.alibaba.com, avec non seulement les données traitées en open source, mais aussi les données brutes et le code du crawler.

Téléchargez les données préparées et enregistrez l’ID du fichier retourné.

1
2
3
4
5
6
7

from openai import OpenAI
client = OpenAI()

client.files.create(
  file=open("all_filter_2120.jsonl", "rb"),
  purpose="fine-tune"
)

3 Ajustement fin du modèle

Une fois les données prêtes, vérifiées et le coût en tokens confirmé, vous pouvez créer une tâche d’ajustement fin.

1
2
3
4
5
6
7

from openai import OpenAI
client = OpenAI()

client.fine_tuning.jobs.create(
  training_file="file-zWptPbsD37ZnemssjpsK6CnF", 
  model="gpt-4o-mini"
)

Pour une configuration plus détaillée des paramètres, vous pouvez consulter la documentation API officielle.

Ces deux étapes peuvent également être rapidement réalisées via l’interface utilisateur, et après avoir soumis la tâche, vous pouvez également suivre en temps réel la progression et les variations de perte dans l’interface utilisateur.

4 Appel du modèle

Utilisez le code ci-dessous pour interroger l’état de la tâche d’ajustement fin. Une fois la tâche réussie, vous verrez le champ fine_tuned_model rempli avec le nom du modèle. Notez ce nom pour pouvoir l’appeler.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

from openai import OpenAI
client = OpenAI()

# Liste des tâches d'ajustement fin
client.fine_tuning.jobs.list(limit=10)

# Détails de la tâche d'ajustement fin
client.fine_tuning.jobs.retrieve("ftjob-gvP0VB7RlWcF3QHdQrEVf49Y")

# Annuler une tâche
client.fine_tuning.jobs.cancel("ftjob-gvP0VB7RlWcF3QHdQrEVf49Y")

# Voir le journal des tâches
client.fine_tuning.jobs.list_events(fine_tuning_job_id="ftjob-gvP0VB7RlWcF3QHdQrEVf49Y", limit=10)

# Supprimer un modèle ajusté finement
client.models.delete("ft:gpt-3.5-turbo:acemeco:suffix:abc123")

La méthode d’appel est la même que pour les modèles officiels, il suffit de modifier le nom du modèle, par exemple :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

from openai import OpenAI
client = OpenAI()

completion = client.chat.completions.create(
  model="ft:gpt-4o-mini-2024-07-18:personal:0724:9oMH6S7A",
  messages=[
    {"role": "system", "content": "Veuillez rédiger un article SEO de pas moins de 800 mots basé sur le titre que je vous ai donné, incluant au moins 4 sous-titres au format HTML. N'incluez pas la balise <h1>, <body>. N'incluez pas la balise <html> au début et à la fin du contenu. Commencez directement par le contenu."},
    {"role": "user", "content": f"title:{task.title},core keyword:{task.coreKeywords},related keyword:{task.relatedKeywords}"}
  ]
)
print(completion.choices[0].message)

5 Évaluation des résultats

Pendant l’entraînement, deux indicateurs sont disponibles : la perte et la précision des tokens. L’explication officielle est la suivante :

La perte de validation et la précision des tokens de validation sont calculées de deux manières différentes : sur un petit lot de données à chaque étape, et sur l’ensemble du jeu de validation à la fin de chaque époque. Les indicateurs de perte et de précision des tokens sur l’ensemble du jeu de validation sont les plus précis pour suivre les performances globales du modèle. Ces statistiques visent à fournir une vérification de la rationalité pour s’assurer que l’entraînement se déroule bien (la perte devrait diminuer, la précision des tokens devrait augmenter).

Cependant, les indicateurs ne sont que des références, et l’efficacité réelle doit être évaluée par vous-même. Le modèle ajusté finement présente au moins les améliorations suivantes :

• Augmentation de 20 % de la longueur des articles
• Structure des articles plus proche des données d’entraînement
• Plus d’erreurs de format (comme le format markdown, l’ajout de CSS, etc.)

Voici un article généré sur le thème “Quelle est la différence entre une fresque et une mosaïque ?” :

6 Articles de référence

• https://platform.openai.com/docs/guides/fine-tuning

Si l’on compare l’utilisation de l’IA pour accomplir des tâches à la rédaction d’un essai, alors la méthode non-agent (Agent) consiste à faire écrire l’IA d’une traite, sans modification, tandis que la méthode agent permet à l’IA de modifier plusieurs fois et de s’appuyer sur des outils et de collaborer avec l’extérieur pendant le processus de modification. En 2024, l’agent est considéré comme l’une des voies pour réaliser l’intelligence artificielle générale (AGI).

Les modèles de base ont stimulé le développement de l’intelligence artificielle générative, permettant aux agents AI d’aider automatiquement les utilisateurs à accomplir des tâches. Au cours de l’année écoulée, divers agents ont émergé. Inspiré par le discours d’Andrew Ng au sommet AI de Sequoia, cet article compile les agents existants à partir des articles publiés et des blogs d’ingénierie tels que Langchain, et résume les paradigmes de conception dans l’espoir d’aider à concevoir des agents basés sur des modèles de base.

Les 16 modèles suivants peuvent être provisoirement compilés dans le tableau ci-dessous :

Ces 16 modèles peuvent tous être regroupés dans les 4 paradigmes proposés par Andrew Ng dans son discours au sommet AI de Sequoia, à savoir :

• Réflexion
• Utilisation d’outils
• Planification
• Collaboration multi-agents

1 Réflexion

1.1 Réflexion de base

Dans le contexte de la construction d’agents LLM, la réflexion désigne le processus consistant à inciter le LLM à observer ses étapes passées (ainsi que les observations potentielles des outils/environnements) pour évaluer la qualité des actions choisies. Ces retours sont ensuite utilisés pour des tâches en aval telles que la replanification, la recherche ou l’évaluation. L’image ci-dessous montre un modèle de réflexion de base.

Réflexion de base

1.2 Acteur Reflexion

Proposé par Shinn et al., Reflexion est une architecture qui apprend par le biais de retours linguistiques et d’auto-réflexion. Cet agent commente ses résultats de tâches pour générer des résultats finaux de meilleure qualité, mais au prix d’un temps d’exécution plus long. Il comprend principalement trois composants :

1. Acteur (agent) avec auto-réflexion
2. Évaluateur externe (spécifique à la tâche, par exemple, étapes de compilation de code)
3. Mémoire épisodique qui stocke les réflexions de (1).

Acteur Reflexion

1.3 LATS

La recherche d’arbre d’agents linguistiques (LATS), proposée par Zhou et al., est un algorithme de recherche d’agent LLM général qui combine réflexion/évaluation et recherche (en particulier la recherche d’arbre de Monte Carlo), capable de réaliser de meilleures performances globales de tâches par rapport à des techniques similaires telles que ReACT, Reflexion ou Tree of Thoughts.

Il comprend quatre étapes principales :

1. Sélectionner : choisir les meilleures actions suivantes en fonction des récompenses agrégées de l’étape (2). Répondre (si une solution est trouvée ou si la profondeur maximale de recherche est atteinte) ou continuer la recherche.

2. Étendre et simuler : sélectionner les 5 meilleures actions potentielles à entreprendre et les exécuter en parallèle.

3. Réfléchir + Évaluer : observer les résultats de ces actions et évaluer les décisions en fonction de la réflexion (et éventuellement des retours externes)

4. Rétropropager : mettre à jour les scores des trajectoires racines en fonction des résultats.

LATS

2 Utilisation d’outils

Appeler des outils, utiliser sous forme de fonctions.

3 Planification

3.1 ReAct

ReAct améliore les capacités des agents en combinant raisonnement et action. La méthode ReAct permet aux agents de réagir immédiatement après avoir reçu des informations, plutôt que d’attendre que toutes les informations soient traitées. Cette méthode met également l’accent sur la combinaison étroite du raisonnement et de l’action, où les agents doivent non seulement analyser et comprendre les informations d’entrée, mais aussi agir en conséquence. Cette approche est avantageuse en raison de sa flexibilité et de son adaptabilité à l’environnement.

Cadre ReAct

3.2 Planifier et exécuter

Le cœur de Planifier et exécuter est de d’abord établir un plan à plusieurs étapes, puis d’exécuter ce plan étape par étape. Après avoir accompli une tâche spécifique, le plan peut être réexaminé et modifié si nécessaire.

Comparé aux agents typiques de style ReAct, qui pensent une étape à la fois, ce style “planifier et exécuter” présente les avantages suivants :

1. Planification à long terme claire (même les LLM très puissants ont du mal à le faire)
2. Capacité à utiliser des modèles plus petits/moins puissants pour les étapes d’exécution, en utilisant uniquement des modèles plus grands/meilleurs pour les étapes de planification

Planifier et exécuter

3.3 ReWOO

Dans ReWOO, Xu et al. ont proposé un agent combinant un planificateur à plusieurs étapes et un remplacement de variables pour une utilisation efficace des outils. Il améliore l’architecture des agents de style ReACT dans les aspects suivants :

1. Réduit la consommation de tokens et le temps d’exécution en générant une chaîne d’outils complète à utiliser en une seule fois. (Les architectures d’agents de style ReACT nécessitent de nombreux appels LLM et ont des préfixes redondants car les prompts système et les étapes précédentes sont fournies au LLM à chaque étape de raisonnement)
2. Simplifie le processus de fine-tuning. Étant donné que les données de planification ne dépendent pas des sorties des outils, le modèle peut théoriquement être fine-tuné sans appeler réellement les outils

Raisonnement sans observation

3.4 LLMCompiler

LLMCompiler est une architecture d’agent qui accélère l’exécution des tâches d’agent en exécutant les tâches en rafale dans un DAG. Il économise également sur les coûts d’utilisation des tokens redondants en réduisant le nombre d’appels LLM. Il comprend principalement trois parties :

1. Planificateur : diffuse un DAG de tâches.

2. Unité de récupération de tâches : planifie et exécute les tâches dès qu’elles sont exécutables

3. Assembleur : répond à l’utilisateur ou déclenche un deuxième plan

LLMCompiler

4 Collaboration multi-agents

4.1 Supervision

Gérer et planifier la collaboration de plusieurs agents par un superviseur.

Mode de supervision

4.2 Équipes hiérarchiques

Organiser les agents de manière hiérarchique et graduée pour accomplir des tâches complexes et volumineuses. AutoGen est un exemple typique de cette approche.

Mode d’équipe hiérarchique

4.3 Collaboration

La capacité d’un agent unique à utiliser plusieurs outils (domaines) est limitée, nécessitant plusieurs agents pour utiliser plus de types d’outils. On peut utiliser l’idée de “diviser pour régner”, où chaque agent devient un “expert” spécialisé dans le traitement d’une catégorie de problèmes, puis les faire collaborer.

Une forme de collaboration multi-agents de base

5 Évaluation

Une idée la plus directe est d’utiliser un agent comme “utilisateur virtuel” pour l’évaluation, de nombreuses tâches dont les résultats ne peuvent pas être évalués quantitativement peuvent devoir utiliser cette méthode. Mais pour les tâches avec des indicateurs clairs (classification, régression), il peut être possible d’utiliser directement un outil pour l’évaluation.

Évaluation basée sur les agents

6 Autres méthodes pour l’AGI

Les agents ne sont qu’une méthode prometteuse pour réaliser l’AGI, mais ce n’est pas la seule méthode. La méthode des agents elle-même peut être combinée avec RAG, la participation des utilisateurs et d’autres méthodes. Par exemple, Shi et al. ont combiné la méthode des agents et de la récupération pour résoudre des problèmes de programmation olympique avec de grands modèles.

7 Lectures recommandées

https://github.com/AGI-Edgerunners/LLM-Agents-Papers

https://github.com/zjunlp/LLMAgentPapers

Articles classiques sur la décomposition et la planification des tâches des agents intelligents AI - bonelee - Blog Park (cnblogs.com)

Quatre paradigmes d’agents | CRITIC : paradigmes de conception d’agents promus par Andrew Ng - Zhihu (zhihu.com)

8 Références

1. Kim, Sehoon, Suhong Moon, Ryan Tabrizi, Nicholas Lee, Michael W. Mahoney, Kurt Keutzer, and Amir Gholami. “An LLM Compiler for Parallel Function Calling.” arXiv, February 6, 2024. https://doi.org/10.48550/arXiv.2312.04511.
2. Liu, Yue, Sin Kit Lo, Qinghua Lu, Liming Zhu, Dehai Zhao, Xiwei Xu, Stefan Harrer, and Jon Whittle. “Agent Design Pattern Catalogue: A Collection of Architectural Patterns for Foundation Model Based Agents.” arXiv, May 16, 2024. https://doi.org/10.48550/arXiv.2405.10467.
3. Shi, Quan, Michael Tang, Karthik Narasimhan, and Shunyu Yao. “Can Language Models Solve Olympiad Programming?” arXiv, April 16, 2024. https://doi.org/10.48550/arXiv.2404.10952.
4. Shinn, Noah, Federico Cassano, Edward Berman, Ashwin Gopinath, Karthik Narasimhan, and Shunyu Yao. “Reflexion: Language Agents with Verbal Reinforcement Learning.” arXiv, October 10, 2023. https://doi.org/10.48550/arXiv.2303.11366.
5. Wang, Lei, Wanyu Xu, Yihuai Lan, Zhiqiang Hu, Yunshi Lan, Roy Ka-Wei Lee, and Ee-Peng Lim. “Plan-and-Solve Prompting: Improving Zero-Shot Chain-of-Thought Reasoning by Large Language Models.” arXiv, May 26, 2023. https://doi.org/10.48550/arXiv.2305.04091.
6. Xu, Binfeng, Zhiyuan Peng, Bowen Lei, Subhabrata Mukherjee, Yuchen Liu, and Dongkuan Xu. “ReWOO: Decoupling Reasoning from Observations for Efficient Augmented Language Models.” arXiv, May 22, 2023. https://doi.org/10.48550/arXiv.2305.18323.
7. Yao, Shunyu, Jeffrey Zhao, Dian Yu, Nan Du, Izhak Shafran, Karthik Narasimhan, and Yuan Cao. “ReAct: Synergizing Reasoning and Acting in Language Models.” arXiv, March 9, 2023. https://doi.org/10.48550/arXiv.2210.03629.
8. “Yoheinakajima/Babyagi.” Accessed May 21, 2024. https://github.com/yoheinakajima/babyagi/tree/main.
9. “LangGraph tutorials.” Accessed May 21, 2024. https://langchain-ai.github.io/langgraph/tutorials/
10. Zhou, Andy, Kai Yan, Michal Shlapentokh-Rothman, Haohan Wang, and Yu-Xiong Wang. “Language Agent Tree Search Unifies Reasoning Acting and Planning in Language Models.” arXiv, December 5, 2023. https://doi.org/10.48550/arXiv.2310.04406.
11. Zhou, Pei, Jay Pujara, Xiang Ren, Xinyun Chen, Heng-Tze Cheng, Quoc V. Le, Ed H. Chi, Denny Zhou, Swaroop Mishra, and Huaixiu Steven Zheng. “Self-Discover: Large Language Models Self-Compose Reasoning Structures.” arXiv, February 5, 2024. https://doi.org/10.48550/arXiv.2402.03620.

Parmi les nombreuses bases de données vectorielles et bibliothèques de vecteurs, chacune a ses propres caractéristiques, et choisir celle qui convient à son application nécessite une évaluation. Cet article explore en profondeur les facteurs clés à considérer lors du choix d’une base de données vectorielle pour le RAG, notamment la disponibilité open source, le support CRUD (création, lecture, mise à jour, suppression), l’architecture distribuée, le support des répliques, l’évolutivité, les performances et la maintenance continue.

Actuellement, des bases de données conçues spécifiquement pour les vecteurs comme Weaviate, Milvus, Qdrant, Vespa et Pinecone attirent beaucoup d’attention dans l’industrie. En outre, certaines bibliothèques de vecteurs plus anciennes possèdent également ces fonctionnalités. Cet article compare également diverses bibliothèques de vecteurs telles que FAISS, HNSWLib, ANNOY, ainsi que des bases de données SQL prenant en charge les vecteurs, comme pgvector et Supabase.

1 Bibliothèques de vecteurs (FAISS, HNSWLib, ANNOY)

La différence entre les bases de données vectorielles et les bibliothèques de vecteurs réside dans le fait que les bibliothèques de vecteurs sont principalement utilisées pour stocker des données statiques, où les données d’index sont immuables. Cela est dû au fait que les bibliothèques de vecteurs ne stockent que les embeddings vectoriels et ne stockent pas les objets associés qui génèrent ces embeddings vectoriels. Par conséquent, contrairement aux bases de données vectorielles, les bibliothèques de vecteurs ne prennent pas en charge les opérations CRUD. Cela signifie qu’il peut être difficile d’ajouter de nouveaux documents à un index existant dans des bibliothèques de vecteurs comme FAISS ou ANNOY. HNSWLib est une exception, car elle dispose de fonctionnalités CRUD et prend en charge de manière unique les opérations de lecture et d’écriture concurrentes. Cependant, elle ne peut échapper aux limitations d’une bibliothèque de vecteurs, à savoir l’absence de capacité de déploiement d’écosystème, de réplication d’instances et de tolérance aux pannes.

2 Bases de données de recherche en texte intégral (ElasticSearch, OpenSearch)

Les bases de données de recherche en texte intégral (par exemple, ElasticSearch et OpenSearch) peuvent prendre en charge des fonctions de recherche textuelle et d’analyse avancée relativement complètes. Cependant, lorsqu’il s’agit d’exécuter des recherches de similarité vectorielle et de traiter des données de haute dimension, elles ne sont pas aussi puissantes que les bases de données vectorielles spécialisées. Ces bases de données nécessitent souvent l’utilisation d’autres outils pour réaliser des recherches sémantiques, car elles reposent principalement sur des index inversés plutôt que sur des index vectoriels. Selon les résultats des tests de Qdrant, ElasticSearch est à la traîne par rapport à des bases de données vectorielles comme Weaviate, Milvus et Qdrant en termes de performances.

3 Bases de données SQL prenant en charge les vecteurs (pgvector, Supabase, StarRocks)

Les bases de données SQL comme pgvector, grâce à leurs extensions de support vectoriel, offrent un moyen d’intégrer les données vectorielles dans les systèmes de stockage de données existants, mais elles présentent également certains inconvénients évidents par rapport aux bases de données vectorielles spécialisées.

Le défaut le plus évident est le décalage entre le modèle relationnel des bases de données SQL traditionnelles et la nature des données vectorielles non structurées. Ce décalage entraîne une inefficacité des opérations impliquant des recherches de similarité vectorielle, et ces bases de données ne sont pas idéales pour la construction d’index et le traitement de grandes quantités de données vectorielles, comme le montre le test ANN. De plus, la limite de dimension des vecteurs supportée par pgvector (2000 dimensions) est relativement faible par rapport à des bases de données vectorielles spécialisées comme Weaviate, qui peut traiter des données vectorielles allant jusqu’à 65535 dimensions. En termes d’évolutivité et d’efficacité, les bases de données vectorielles spécialisées ont également un avantage. Les extensions de bases de données SQL prenant en charge les vecteurs, telles que pgvector, conviennent mieux aux scénarios où le volume de données vectorielles est faible (moins de 100 000 vecteurs) et où les données vectorielles ne sont qu’une fonction complémentaire de l’application. En revanche, si les données vectorielles sont au cœur de l’application ou si des exigences élevées en matière d’évolutivité sont nécessaires, les bases de données vectorielles spécialisées sont un choix plus approprié.

Quant à StarRocks, c’est un autre système fonctionnant sur un cadre SQL, optimisé pour les scénarios de traitement analytique en ligne (OLAP) et de traitement transactionnel en ligne (OLTP), mais il n’est pas spécialement optimisé pour les recherches de similarité vectorielle.

4 Bases de données NoSQL prenant en charge les vecteurs (Redis, MongoDB)

Les fonctionnalités de support vectoriel nouvellement ajoutées dans les bases de données NoSQL sont encore à un stade précoce et n’ont pas encore été suffisamment testées et vérifiées. Prenons l’exemple de la recherche de similarité vectorielle (VSS) de Redis, cette fonctionnalité a été publiée en avril 2022, il y a moins de deux ans. Bien que Redis VSS puisse servir de base de données multifonctionnelle, elle n’est pas optimisée et conçue spécifiquement pour la recherche de similarité vectorielle.

5 Bases de données vectorielles spécialisées (Pinecone, Milvus, Weaviate, Qdrant, Vald, Chroma, Vespa, Vearch)

Les bases de données vectorielles spécialisées prennent en charge nativement diverses opérations vectorielles, telles que le produit scalaire, la similarité cosinus, etc. Ces bases de données sont conçues pour traiter des données de haute dimension, capables de gérer un grand nombre de requêtes et de réaliser rapidement des recherches de similarité entre vecteurs. Pour atteindre ces objectifs, elles adoptent diverses stratégies d’indexation, souvent basées sur des algorithmes de plus proche voisin approximatif (ANN). Ces algorithmes nécessitent de faire des compromis entre efficacité, occupation de l’espace de stockage et précision de la recherche. Par exemple, l’index FLAT est un index vectoriel qui n’utilise aucune technique d’optimisation ou d’approximation, ce qui signifie qu’il peut atteindre un taux de rappel et une précision de 100 %, mais il est également plus lent et moins efficace que d’autres types d’index vectoriels ; en revanche, l’index IVF_FLAT sacrifie une certaine précision pour obtenir une vitesse de recherche plus rapide ; l’index HNSW offre un compromis entre précision et vitesse de recherche.

Pinecone est une base de données vectorielle à code source fermé, maintenue par une équipe professionnelle, dont la version gratuite offre des fonctionnalités limitées en termes d’évolutivité. Chroma est un système spécialement conçu pour les données audio, mais il n’a pas été particulièrement optimisé pour le traitement des données textuelles. Par rapport à d’autres bases de données vectorielles grand public, Chroma manque de documentation sur les tests de performance globale. Étant donné que Chroma utilise SQLite comme méthode de stockage de documents dans sa version 0.4, il peut ne pas être aussi évolutif et efficace que d’autres solutions de stockage conçues spécifiquement pour les données vectorielles.

Vearch et Vald présentent des lacunes en matière d’intégration avec Langchain, ce qui est défavorable au développement et à l’utilisation. Par rapport à des concurrents comme Milvus, leur communauté de développeurs est plus petite et la maintenance de la communauté open source n’est pas très active.

Par conséquent, pour le RAG, Weaviate, Milvus, Qdrant et Vespa pourraient être les meilleurs choix. En théorie, le choix du système le plus approprié devrait être basé sur les tests de performance et d’évolutivité (voir ci-dessous les benchmarks ANN) mais il y a aussi des caractéristiques de conception du système et des fonctionnalités à comparer. Le tableau ci-dessous présente une comparaison visuelle de ces aspects.

En résumé, Qdrant a des coûts particulièrement faibles, Weaviate supporte la combinaison de la recherche vectorielle, du stockage d’objets et de l’index inversé, Milvus a les performances les plus fortes et le plus de fonctionnalités.

6 Comparaison des méthodes de recherche des bases de données vectorielles

6.1 Milvus

Milvus supporte deux types de recherche, selon le nombre de champs vectoriels dans la collection : recherche mono-vecteur et recherche multi-vecteurs.

La recherche mono-vecteur utilise la méthode search(), compare le vecteur de requête avec les vecteurs existants dans la collection, et renvoie l’ID des entités les plus similaires et la distance entre elles. Il est également possible de renvoyer les valeurs vectorielles et les métadonnées des résultats de manière optionnelle.

La recherche multi-vecteurs est adaptée aux collections ayant deux champs vectoriels ou plus, et est exécutée via la méthode hybrid_search(), qui exécute plusieurs requêtes de recherche de plus proche voisin approximatif (ANN) et combine les résultats pour renvoyer les correspondances les plus pertinentes. (La dernière version 2.4.x supporte jusqu’à 10 vecteurs pour la recherche)

La recherche multi-vecteurs est particulièrement adaptée aux situations complexes nécessitant une haute précision, notamment lorsque la même entité peut être représentée par plusieurs vecteurs différents. Cela s’applique aux mêmes données (comme une phrase) traitées par différents modèles d’intégration, ou lorsque des informations multimodales (comme des images, empreintes digitales et empreintes vocales d’une personne) sont converties en divers formats vectoriels. Grâce au “rappel multi-chemins” à l’échelle de la table et à l’attribution de poids à ces vecteurs, leur action combinée peut augmenter considérablement la capacité de rappel et améliorer l’efficacité des résultats de recherche.

Autres opérations de recherche de base :

• La recherche de base comprend la recherche mono-vecteur, la recherche par lots de vecteurs, la recherche par partition et la recherche avec des champs de sortie spécifiés.
• La recherche par filtrage affine les résultats de recherche en fonction des conditions de filtrage des champs scalaires.
• La recherche par plage trouve les vecteurs situés dans une plage de distance spécifique par rapport au vecteur de requête.
• La recherche par regroupement regroupe les résultats de recherche en fonction d’un champ spécifique pour assurer la diversité des résultats.

6.2 Weaviate

• Recherche de similarité vectorielle : couvre une gamme de méthodes de recherche approximative, cette recherche cherche les objets les plus similaires à la représentation vectorielle de la requête.
• Recherche d’images : utilise des images comme entrée pour la recherche de similarité.
• Recherche par mots-clés : une recherche par mots-clés utilisant l’algorithme BM25F pour classer les résultats.
• Recherche hybride : combine BM25 et la recherche de similarité pour classer les résultats.
• Recherche générative : utilise les résultats de recherche comme prompts pour les LLM.
• Réorganisation : réorganise les résultats de recherche récupérés à l’aide d’un module de réorganisation.
• Agrégation : agrège les données à partir de l’ensemble des résultats.
• Filtres : applique des filtres conditionnels à la recherche.

6.3 Qdrant

Opérations de recherche de base supportées :

• Filtrage par score de pertinence
• Chargement de plusieurs opérations de recherche dans une seule requête
• API de recommandation
• Opérations de regroupement

Autres méthodes de recherche supportées par Qdrant :

Qdrant supporte-t-il une recherche en texte intégral ou une recherche hybride ?

Qdrant est avant tout un moteur de recherche vectorielle, nous ne mettons en œuvre un support complet du texte que si cela n’affecte pas les cas d’utilisation de la recherche vectorielle. Cela inclut l’interface et les performances.

Ce que Qdrant peut faire :

• Recherche avec des filtres de texte intégral
• Appliquer des filtres de texte intégral à la recherche vectorielle (c’est-à-dire effectuer une recherche vectorielle dans les enregistrements contenant un mot ou une phrase spécifique)
• Faire des recherches par préfixe et des recherches sémantiques instantanées

Fonctionnalités que Qdrant prévoit d’introduire à l’avenir :

• Support des vecteurs clairsemés, comme ceux utilisés dans SPLADE ou des modèles similaires

Fonctionnalités que Qdrant ne prévoit pas de supporter :

• BM25 ou d’autres fonctions de récupération ou de classement non basées sur les vecteurs
• Ontologie intégrée ou graphe de connaissances
• Analyseur de requêtes et autres outils NLP

Actuellement, la question qui se pose est de savoir s’il existe une solution qui permette à la fois de bénéficier des caractéristiques de recherche sémantique des bases de données vectorielles et de la précision de la recherche par mots-clés traditionnelle.

7 Annexe

7.1 Benchmarks ANN

Les benchmarks peuvent être perturbés par divers facteurs influençant les performances des bases de données, tels que le type de recherche (recherche filtrée ou recherche régulière), les paramètres de configuration, l’algorithme d’indexation, l’intégration des données, le matériel, etc. Outre les performances des benchmarks, le choix d’une bibliothèque de vecteurs doit également prendre en compte la capacité de distribution, le support des répliques en mémoire et du cache, l’algorithme d’indexation utilisé, la capacité de recherche de similarité vectorielle (y compris la recherche hybride, le filtrage et les mesures de similarité multiples), le mécanisme de sharding, la méthode de clustering, le potentiel d’évolutivité, la cohérence des données et la disponibilité globale du système.

ANN-Benchmarks est la principale plateforme de benchmark pour évaluer les performances de recherche des algorithmes de plus proche voisin approximatif. Dans la recherche de texte, les performances des bases de données vectorielles sur les mesures angulaires sont souvent plus importantes que leurs performances sur les mesures euclidiennes. En effet, les mesures angulaires sont plus sensibles à la similarité sémantique des documents textuels, tandis que les mesures euclidiennes sont plus sensibles à la longueur et à l’échelle des documents. Par conséquent, lors de l’évaluation du contexte généré par la recherche, il est plus important de se concentrer sur l’évaluation des performances des bases de données vectorielles sur des ensembles de données angulaires couvrant différentes dimensions.

7.1.1 glove-100-angular

7.1.2 nytimes-256-angular

7.2 Indicateurs de similarité vectorielle

Voici une présentation détaillée de chaque indicateur, y compris leurs avantages et inconvénients relatifs, ainsi que les scénarios d’utilisation adaptés.

7.2.1 Distance cosinus

La distance cosinus mesure la valeur du cosinus de l’angle entre deux vecteurs, souvent utilisée pour traiter des ensembles normalisés ou convexes.

• Avantages : Prend principalement en compte la direction des vecteurs, ce qui la rend très adaptée aux espaces de haute dimension, comme la comparaison de textes, car dans ce contexte, la longueur des documents est moins importante.
• Inconvénients : Pas adaptée aux scénarios nécessitant une correspondance des dimensions des vecteurs, par exemple lors de la comparaison des embeddings d’images basés sur la densité des pixels. Si les données ne forment pas un ensemble convexe, elle peut ne pas fournir une mesure de similarité précise.

La distance cosinus est adaptée à la classification de documents, à la recherche sémantique, aux systèmes de recommandation et à toute autre tâche impliquant des données de haute dimension et normalisées. Dans la recherche d’informations, la distance cosinus est souvent utilisée pour mesurer la similarité entre le contenu de la requête et les vecteurs de documents, en ignorant leur longueur mais en se concentrant sur la signification sémantique.

7.2.2 Distance euclidienne L2

La distance euclidienne calcule la distance en ligne droite entre deux vecteurs dans un espace multidimensionnel, également appelée norme-2.

• Avantages : Intuitive, facile à calculer, sensible à la fois à la taille et à la direction des vecteurs.
• Inconvénients : Peut ne pas bien fonctionner dans les espaces de haute dimension en raison de la “malédiction de la dimensionnalité”.

Adaptée aux scénarios de reconnaissance d’images, de reconnaissance vocale, d’analyse d’écriture manuscrite, etc.

7.2.3 Produit scalaire

Le produit scalaire calcule la somme des produits des composantes correspondantes des vecteurs, également appelé norme-n.

• Avantages : Calcul rapide, peut refléter la taille et la direction des vecteurs.
• Inconvénients : Sensible à la fois à la direction et à la taille des vecteurs.

L’application la plus classique du produit scalaire se trouve dans le domaine des systèmes de recommandation. Dans les systèmes de recommandation, le produit scalaire peut être utilisé pour déterminer la similarité entre les vecteurs utilisateur et les vecteurs d’articles, aidant à prédire l’intérêt d’un utilisateur pour un article. Le produit scalaire est adapté aux systèmes de recommandation, au filtrage collaboratif, à la décomposition matricielle.

7.2.4 Distance L2 au carré

Carré de la distance euclidienne entre deux vecteurs.

• Avantages : Pénalise les grandes différences entre les éléments des vecteurs, ce qui peut être utile dans certains cas.
• Inconvénients : L’opération de mise au carré peut fausser les distances et est sensible aux valeurs aberrantes.

La distance L2 au carré est particulièrement adaptée aux problèmes de différence d’éléments individuels, par exemple dans le traitement d’images, pour comparer les différences entre deux images.

7.2.5 Distance de Hamming

Mesure le nombre de différences entre les vecteurs sur chaque dimension.

• Avantages : Adaptée à la comparaison de données binaires ou catégorielles.
• Inconvénients : Pas adaptée aux données continues ou numériques.

Les scénarios d’application sont également assez spécifiques, par exemple la détection et la correction d’erreurs (données catégorielles) ; mesure de la distance génétique entre deux chaînes d’ADN.

7.2.6 Distance de Manhattan L1

Mesure la distance entre les dimensions des vecteurs le long des axes orthogonaux, également appelée norme-1.

• Avantages : Plus résistante aux valeurs aberrantes que la distance euclidienne.
• Inconvénients : Moins intuitive en termes de signification géométrique que la distance euclidienne.

Adaptée au calcul de la distance sur un échiquier, aux problèmes de planification logistique des chemins les plus courts.

8 Références

1. https://github.com/milvus-io/milvus
2. Powering AI With Vector Databases: A Benchmark - Part I - Data - Blog - F-Tech (farfetchtechblog.com)
3. Fundamentals - Qdrant
4. Milvus documentation
5. Home | Weaviate - Vector Database
6. Qdrant Documentation - Qdrant
7. Vector Database Use Cases - Qdrant

1 Qu’est-ce que RAG

Améliorer la précision et la fiabilité des modèles d’IA génératifs en récupérant des informations externes est ce qu’on appelle la technologie de génération augmentée par la récupération (Retrieval-Augmented Generation). Si l’on compare le processus de réalisation de tâches par les grands modèles de langage (LLM) à un examen, alors un grand modèle avec RAG équivaut à un examen à livre ouvert, tandis que sans RAG, c’est comme un examen à livre fermé. RAG est une technologie qui aide les LLM à récupérer des informations pour améliorer l’effet de génération.

RAG a été proposé pour la première fois par Patrick Lewis et al. dans cet article, et leur entreprise est Cohere, qui propose actuellement des services API incluant des modèles d’Embedding et de Rerank, avec de bonnes performances.

2 Pourquoi avons-nous besoin de RAG

L’apparition de RAG vise à résoudre certains problèmes et insuffisances des grands modèles de langage lors de leur application. Le point le plus notable est le problème des hallucinations des grands modèles, c’est-à-dire que la sortie des grands modèles peut ne pas correspondre aux faits ou inventer des réponses. De plus, les données utilisées pour entraîner les LLM peuvent être obsolètes, et les LLM ne connaissent rien des informations récentes.

RAG permet aux LLM d’accéder à des informations récentes ou personnalisées et permet aux utilisateurs de vérifier les sources d’information des LLM pour garantir leur exactitude. Les données récupérées par RAG peuvent être publiques (comme les moteurs de recherche) ou privées (comme les informations d’entreprise, les données personnelles sensibles), ce qui offre un large éventail d’applications pour RAG. RAG est déjà largement utilisé, par exemple, le NeMo Retriever de Nvidia lit les informations internes de l’entreprise, et Kimi Chat de Dark Side of the Moon utilise des moteurs de recherche pour répondre.

3 Base de connaissances construite autour de RAG

La base de connaissances d’IA est un outil important pour permettre à l’IA de “s’adapter aux besoins”. En aidant l’IA à mieux accomplir les tâches grâce à la base de connaissances, la construction de bases de connaissances d’IA peut actuellement se faire de trois manières :

• Ingénierie des invites (Prompt Engineering)
• Réglage fin (Fine Tuning)
• Embedding (Embedding)

L’ingénierie des invites consiste à construire directement une base de connaissances dans les invites, en plaçant toutes les informations dans les invites. Cette méthode convient à une utilisation à petite échelle, mais le nombre de tokens d’entrée des modèles d’IA actuels ne peut généralement pas répondre à cette méthode. En fait, même avec le développement de l’IA, le jour où la fenêtre d’entrée de l’IA sera suffisamment grande pour contenir une base de connaissances générale, la construction de bases de connaissances aura toujours sa valeur. Car la longueur du contenu d’entrée affecte les performances de l’IA (du moins pour les modèles actuels), comme le montre Needle In A Haystack - Pressure Testing LLMs.

Le réglage fin est une forme populaire dans le milieu académique, utilisant des données de tâches spécifiques pour ajuster un modèle pré-entraîné. Cette méthode est en fait adaptée pour créer un grand modèle générique pour un secteur, comme un grand modèle pour le secteur juridique, un grand modèle pour le secteur médical, etc. D’une part, les données d’entraînement nécessaires pour le réglage fin ne sont pas peu nombreuses, et le coût est élevé ; d’autre part, le réglage fin n’est pas assez flexible, par exemple pour s’ajuster rapidement en fonction d’un ou deux documents. Le processus de réglage fin consiste en fait à apprendre et généraliser les données d’entraînement, plutôt qu’à mémoriser le contenu, il s’agit plutôt d’améliorer les capacités dans un domaine particulier.

Ainsi, la méthode la plus courante pour construire une base de connaissances est actuellement l’Embedding. Et ce type de base de connaissances nécessite également une combinaison avec RAG pour être efficace.

4 Composants de base de RAG

Une composition classique et basique de RAG est illustrée ci-dessous.

4.1 Embedding

Dans ce processus, l’utilisateur doit d’abord télécharger des documents, que le système stocke dans une base de données vectorielle après les avoir passés par l’Embedding. L’Embedding consiste à convertir des textes sémantiquement similaires en vecteurs proches, ce qui est communément appelé vectorisation.

4.2 Récupération

Lorsque l’utilisateur pose une question au LLM, le contenu de la question est converti en vecteur et correspond dans la base de données vectorielle, récupérant une série de contenus. C’est la première étape de la récupération.

4.3 Rerank

Le contenu récupéré directement dans la base de données vectorielle peut ne pas être parfait, et les résultats ne correspondent souvent pas au contenu de la requête, nécessitant une deuxième étape de récupération, appelée Rerank. À cette étape, le modèle Rerank réorganise le contenu récupéré lors de l’étape précédente, en produisant un classement des résultats selon leur pertinence. Une fois le Rerank terminé, on peut appliquer le Top K dans la phase de génération suivante.

5 Implémentation de RAG en 5 lignes de code

Une instruction d’affectation compte pour une ligne

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from transformers import RagTokenizer, RagRetriever, RagTokenForGeneration
from datasets import load_dataset

retriever = RagRetriever.from_pretrained(
    config_name = "facebook/rag-token-nq",
    index_name = "compressed",  # Type d'index
    use_dummy_dataset = True,  # Utiliser un jeu de données factice pour tester
    dataset = "wiki_dpr"  # Jeu de données utilisé pour la récupération
)

# Charger le tokenizer et le modèle pré-entraînés
tokenizer = RagTokenizer.from_pretrained("facebook/rag-token-nq")
model = RagTokenForGeneration.from_pretrained("facebook/rag-token-nq", retriever=retriever)

# Entrer une question et la convertir en vecteur
input_ids = tokenizer(input_text = "What is the capital of France?", 
		return_tensors="pt").input_ids

# Générer une réponse
outputs = model.generate(input_ids)
print(tokenizer.decode(outputs[0], skip_special_tokens=True))

RagTokenizer est utilisé pour le tokenisation du texte, RagTokenForGeneration est la partie génératrice du modèle RAG, et RagRetriever est responsable de la récupération. RagTokenizer.from_pretrained("facebook/rag-token-nq") charge un tokenizer pré-entraîné pour convertir le texte en un format compréhensible par le modèle (c’est-à-dire le tokenisation). RagTokenForGeneration.from_pretrained("facebook/rag-token-nq", retriever=retriever) charge le modèle RAG pré-entraîné. facebook/rag-token-nq est le nom du modèle et du tokenizer, qui sont pré-entraînés sur le jeu de données Natural Questions.

6 Implémentations open-source de RAG

Dify est une plateforme de développement d’applications LLM, avec plus de 100 000 applications construites sur Dify.AI. Elle intègre les concepts de Backend as Service et LLMOps, couvrant la pile technologique de base nécessaire pour construire des applications natives d’IA générative, y compris un moteur RAG intégré. Avec Dify, vous pouvez déployer des capacités similaires à Assistants API et GPTs sur n’importe quel modèle. Ce projet est dirigé par une entreprise de Suzhou et propose des services SaaS.

Langchain-Chatchat est un projet de base de connaissances RAG de grands modèles de langage, open-source et déployable hors ligne, basé sur des modèles de langage tels que ChatGLM et des cadres d’application tels que Langchain. Initialement, il ne supportait que le modèle ChatGLM, mais il a ensuite ajouté le support de nombreux modèles open-source et en ligne.

Le tableau comparatif des fonctionnalités des deux projets est le suivant :

En fait, il existe encore certaines fonctionnalités que les projets open-source actuels ne couvrent pas complètement, telles que :

• Capacités multimodales
• Support des bases de données relationnelles traditionnelles
• Récupération multi-bases/unifiée
• Fonction de citation
• RAG avancé
• Indicateurs d’évaluation

7 Références

1. gkamradt/LLMTest_NeedleInAHaystack: Doing simple retrieval from LLM models at various context lengths to measure accuracy (github.com)
2. What is retrieval-augmented generation? | IBM Research Blog
3. Retrieval (langchain.com)
4. langgenius/dify (github.com)
5. Langchain-Chatchat (github.com)

1 Sortie standard (stdout) et erreur standard (stderr)

Dans la plupart des systèmes d’exploitation, la sortie standard et l’erreur standard sont les deux principaux flux de sortie d’un processus. Ils fournissent un mécanisme permettant au processus d’envoyer des informations et des messages d’erreur au terminal ou à un fichier. Bien que ces deux flux puissent être physiquement identiques (par exemple, affichés dans la même interface terminal), ils sont logiquement utilisés à des fins différentes :

• Sortie standard (stdout) : généralement utilisée pour afficher les résultats de l’exécution du programme ou des informations de fonctionnement normales.
• Erreur standard (stderr) : spécifiquement utilisée pour afficher des messages d’erreur ou des avertissements, même lorsque la sortie standard est redirigée, ces informations doivent généralement être vues ou enregistrées.

2 print et logging en Python

En Python, la fonction print envoie par défaut les informations à stdout, tandis que le module logging envoie par défaut les messages de journal à stderr. L’objectif est de distinguer la sortie normale du programme des sorties de journal (y compris les erreurs et les informations de débogage), permettant ainsi aux développeurs de gérer et de filtrer plus facilement les informations de sortie.

2.1 Utilisation de print

print est la fonction de sortie la plus basique en Python, utilisée pour envoyer des informations au flux de sortie standard. Elle est simple à utiliser et convient pour un débogage rapide ou pour afficher des informations à l’utilisateur. Par exemple :

1

print("Hello, world!")

2.2 Utilisation de logging

Le module logging fournit un cadre flexible pour ajouter des messages de journal dans une application. Contrairement à print, logging prend en charge différents niveaux de journalisation (DEBUG, INFO, WARNING, ERROR, CRITICAL), permettant aux développeurs d’ajuster le niveau de détail et l’emplacement de la sortie des journaux selon leurs besoins. Par exemple :

1
2
3

import logging

logging.error('This is an error message')

3 tqdm et stderr

Dans les programmes complexes ou de longue durée, l’utilisation d’une barre de progression est un moyen efficace de montrer à l’utilisateur l’avancement du processus. La bibliothèque tqdm de Python est un outil largement utilisé pour ajouter des barres de progression dans la ligne de commande. tqdm envoie par défaut les informations de progression à stderr pour éviter d’interférer avec la sortie normale du programme (stdout).

3.1 Séparation de stdout et stderr

Dans certains cas, il est utile de séparer la sortie normale des messages d’erreur ou de journal, par exemple en les redirigeant vers des fichiers ou des terminaux différents. En ligne de commande, vous pouvez utiliser les opérateurs de redirection > et 2> pour y parvenir. Dans le code Python, vous pouvez configurer le module logging ou utiliser des objets de fichier spécifiques pour un contrôle plus granulaire.

1

python script.py > output.log 2> error.log

Grâce à la redirection en ligne de commande, à la fonction print de Python et même au module logging, vous pouvez contrôler et séparer de manière flexible ces deux types de sortie, rendant ainsi la gestion des erreurs, l’enregistrement des journaux et l’interaction avec l’utilisateur plus clairs et ordonnés.

4 Utilisation de nohup pour gérer stdout et stderr

Lors du déploiement de processus en arrière-plan de longue durée, la commande nohup devient un outil important. nohup, ou “no hang up”, permet à une commande de continuer à s’exécuter après la déconnexion de l’utilisateur, ce qui est particulièrement utile pour lancer des tâches à distance. Une caractéristique clé de nohup est sa capacité à gérer stdout et stderr.

Par défaut, l’utilisation de nohup pour exécuter une commande redirige stdout et stderr vers le fichier nohup.out, sauf indication contraire. Cela signifie que les sorties normales et les messages d’erreur seront capturés dans le même fichier, ce qui est pratique pour un examen ultérieur. Cependant, dans certains cas, il peut être plus utile de séparer ces deux types de sortie.

4.1 Séparation de stdout et stderr avec nohup

Pour séparer les sorties stdout et stderr lors de l’utilisation de nohup, vous pouvez combiner les opérateurs de redirection. Par exemple :

1

nohup python script.py > output.log 2> error.log &

Cette commande redirige stdout vers output.log, stderr vers error.log, et exécute le programme en arrière-plan avec &. Ainsi, même si le terminal ou la session SSH est fermé, le programme continuera de s’exécuter et ses sorties seront correctement enregistrées.

5 Comportement de mise en mémoire tampon en Python

stdout et stderr ont des comportements différents en matière de mise en mémoire tampon. Par défaut, stdout est mis en mémoire tampon par ligne lorsqu’il est connecté à un terminal, ce qui signifie qu’il met en mémoire tampon les données jusqu’à ce qu’un saut de ligne soit reçu ou que le tampon soit plein ; en mode non interactif, stdout est mis en mémoire tampon par bloc (comme un fichier). En revanche, stderr est toujours mis en mémoire tampon par ligne (avant la version 3.9 de Python, il était mis en mémoire tampon par bloc en mode non interactif). Les informations suivantes proviennent de la documentation officielle sys — Paramètres et fonctions liés au système — Documentation Python 3.12.2

Lorsque interactif, le flux stdout est mis en mémoire tampon par ligne. Sinon, il est mis en mémoire tampon par bloc comme les fichiers texte réguliers. Le flux stderr est mis en mémoire tampon par ligne dans les deux cas. Vous pouvez rendre les deux flux non mis en mémoire tampon en passant l’option de ligne de commande -u ou en définissant la variable d’environnement PYTHONUNBUFFERED.

Changé dans la version 3.9: stderr non interactif est maintenant mis en mémoire tampon par ligne au lieu d’être entièrement mis en mémoire tampon.

Plus la granularité de la mise en mémoire tampon est petite, plus la sortie est rapide, mais le coût d’E/S est plus élevé. Avant Python 3.9, stdout et stderr avaient la même granularité de mise en mémoire tampon, ce qui n’était pas très raisonnable ; après la version 3.9, stderr a une granularité de mise en mémoire tampon plus petite, ce qui signifie que chaque opération d’écriture est plus rapide que stdout. Cette différence rend stderr adapté aux informations d’erreur et de journal, garantissant que même en cas de plantage ou de sortie anormale du programme, ces informations ont une priorité plus élevée que la sortie standard.

En C++, l’erreur standard n’est pas mise en mémoire tampon (voir ci-dessous), ce qui est plus agressif, mais je pense personnellement que c’est plus raisonnable.

Heureusement, en Python, vous pouvez désactiver ce comportement de mise en mémoire tampon en utilisant python -u ou en définissant la variable d’environnement PYTHONUNBUFFERED, ou en utilisant directement sys.stdout.flush() pour contrôler le moment de la sortie.

6 Comportement en environnement concurrent en Python

Lors de l’utilisation de stdout et stderr dans un environnement multithread ou multiprocessus, les sorties peuvent être entremêlées ou désordonnées, car les sorties provenant de différents threads ou processus peuvent interférer les unes avec les autres lors de l’écriture sur le terminal ou le fichier. Une solution à ce problème est de créer des fichiers de sortie distincts pour chaque thread ou processus, ou d’utiliser des verrous de thread (thread locks) ou des mécanismes de synchronisation de processus (comme multiprocessing.Lock) pour synchroniser l’accès à stdout ou stderr.

7 Contrôle de stdout et stderr en Python

Dans des applications complexes, vous pouvez avoir besoin de contrôler plus flexiblement la destination des flux de sortie. Python offre plusieurs moyens pour y parvenir :

• Redirection de stdout et stderr : vous pouvez rediriger la sortie standard et l’erreur standard d’un programme Python en modifiant les valeurs de sys.stdout et sys.stderr. Cela est particulièrement utile pour capturer et analyser les sorties, ou pour rediriger les sorties vers des interfaces graphiques ou d’autres dispositifs de sortie non standards.
• Utilisation du module subprocess : lors de l’exécution de commandes ou de scripts externes, le module subprocess vous permet de contrôler les flux stdout et stderr de la commande, y compris les rediriger vers des variables internes du programme Python, ou les séparer ou les combiner.
• Utilisation avancée du module de journalisation : le module logging de Python prend en charge l’envoi des journaux vers plusieurs destinations, y compris des fichiers, la sortie standard, le réseau, etc. En configurant différents gestionnaires de journaux (handlers), vous pouvez mettre en œuvre des solutions de gestion de journaux complexes, telles que la séparation des journaux en fonction du niveau ou du contenu du message vers différentes sorties.

7.1 Conseils

• Gérer les sorties avec précaution : lors de la conception de logiciels, distinguer clairement la sortie destinée à l’interaction avec l’utilisateur (stdout) de celle destinée au rapport d’erreurs ou à l’enregistrement des journaux (stderr). Cela aide à améliorer la convivialité et la maintenabilité du programme.
• Optimiser les performances : tenir compte de l’impact des opérations de sortie sur les performances, en particulier dans les scénarios de journalisation ou de sortie de données à haute fréquence. Une utilisation raisonnable de la mise en mémoire tampon et du traitement par lots peut réduire l’impact sur les performances.
• Considérations de sécurité : avant de sortir des informations sensibles, effectuer un filtrage et une désensibilisation appropriés pour éviter de divulguer des données sensibles par le biais des journaux.

En comprenant en profondeur et en appliquant de manière flexible stdout et stderr, vous pouvez construire des applications Python plus robustes et plus faciles à gérer, traiter efficacement les journaux et les sorties, et améliorer l’expérience utilisateur et la stabilité de l’application.

8 Comportement de mise en mémoire tampon en C++

En C++, stdout (généralement associé à std::cout) et stderr (associé à std::cerr) ont des stratégies de mise en mémoire tampon différentes :

• std::cout est par défaut mis en mémoire tampon par ligne, ce qui signifie que lorsqu’il est connecté à un terminal, la sortie est rafraîchie à chaque saut de ligne ou lorsque le tampon est plein.
• std::cerr est par défaut non mis en mémoire tampon, donc chaque donnée écrite dans std::cerr est immédiatement sortie, ce qui est très utile pour signaler des messages d’erreur, car cela réduit le risque que des informations d’erreur ne soient pas sorties en cas de plantage du programme.

9 Redirection de stdout et stderr

Dans un programme C++, vous pouvez rediriger stdout et stderr de plusieurs manières. Une méthode courante consiste à utiliser la fonction freopen pour rediriger la sortie standard ou l’erreur standard vers un fichier pendant l’exécution du programme :

1
2

freopen("output.txt", "w", stdout);
freopen("error.log", "w", stderr);

Cette méthode peut être utilisée pour rediriger la sortie vers un fichier, facilitant ainsi l’analyse et le débogage ultérieurs.

10 Utilisation en environnement multithread en C++

Dans un programme C++ multithread, l’utilisation de std::cout et std::cerr peut entraîner des conditions de concurrence, entraînant une sortie désordonnée. Pour éviter cela, il est recommandé d’utiliser des verrous mutex (comme std::mutex) pour synchroniser l’accès à ces flux :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
#include <mutex>
#include <thread>

std::mutex cout_mutex;

void thread_function(int id) {
    std::lock_guard<std::mutex> lock(cout_mutex);
    std::cout << "Thread " << id << " is running\n";
}

int main() {
    std::thread t1(thread_function, 1);
    std::thread t2(thread_function, 2);

    t1.join();
    t2.join();

    return 0;
}

11 Contrôle de la sortie en C++

La bibliothèque standard C++ fournit std::streambuf, qui peut être utilisé pour un contrôle plus fin de std::cout et std::cerr, y compris la redirection et le comportement de mise en mémoire tampon personnalisé. En héritant de std::streambuf et en réécrivant les fonctions membres correspondantes, vous pouvez créer des stratégies de mise en mémoire tampon personnalisées ou rediriger la sortie vers des composants GUI, des connexions réseau, etc.

11.1 Conseils

• Utiliser la mise en mémoire tampon de manière appropriée : choisir une stratégie de mise en mémoire tampon appropriée en fonction du scénario d’application. Pour les informations d’erreur nécessitant un retour immédiat, utiliser std::cerr ou rafraîchir manuellement std::cout.
• Éviter d’utiliser directement la sortie standard dans un environnement multithread : utiliser des verrous mutex ou d’autres mécanismes de synchronisation pour garantir la cohérence et l’ordre de la sortie.
• Utiliser la redirection et des streambuf personnalisés : pour traiter les sorties de manière plus flexible, envisager d’utiliser la redirection ou des streambuf personnalisés pour répondre à des besoins de sortie spécifiques, tels que l’enregistrement des journaux, la transmission sur le réseau, etc.

En maîtrisant ces techniques avancées, vous pouvez gérer et contrôler efficacement la sortie des programmes C++ tout en garantissant la robustesse et la flexibilité du programme.

Lorsqu’il s’agit de partager ou d’analyser du contenu web, les captures d’écran longues sont une forme très pratique car elles permettent de montrer la page entière. Cependant, traiter ces captures d’écran longues pour maintenir l’intégrité et la lisibilité des informations tout en facilitant les opérations ultérieures a toujours été un défi. Par exemple, à l’heure actuelle (début 2024), les modèles d’images AI grand public ne peuvent toujours pas traiter des images très grandes et complexes. Si l’on force une capture d’écran longue dans le modèle, cela peut entraîner une dégradation des performances du modèle (de nombreux détails ne peuvent pas être reconnus). Pour résoudre ce problème, j’ai développé un outil basé sur OpenCV visant à simplifier le processus de traitement des captures d’écran longues tout en maintenant l’intégrité et la lisibilité de leur contenu.

Ce projet est open-source sur mon Github : https://github.com/Ryaang/Web-page-Screenshot-Segmentation

Contrairement à de nombreux outils ou méthodes existants, Web-page-Screenshot-Segmentation utilise OpenCV pour identifier et suivre automatiquement les lignes de séparation naturelles du contenu web, trouvant ainsi les points de segmentation les plus appropriés. Cela signifie que les titres, paragraphes ou graphiques peuvent être conservés de manière ordonnée dans les images segmentées, sans rupture ou omission de contenu.

L’utilisation de Web-page-Screenshot-Segmentation est très simple : il suffit de préparer une capture d’écran longue, et l’outil analysera automatiquement le contenu de l’image et déterminera intelligemment les points de segmentation. Vous obtiendrez finalement une série d’images complètes et bien structurées, prêtes à être partagées et traitées ultérieurement.

2 Présentation

Ce projet est utilisé pour segmenter une capture d’écran longue d’une page web en plusieurs parties selon la hauteur du texte. L’idée principale est de trouver les zones de faible variation de l’image, puis de trouver les lignes de segmentation dans ces zones de faible variation.

Le résultat est une série de petites images complètes de la page web, qui peuvent être utilisées pour générer des pages web ou entraîner des modèles avec Screen-to-code. Plus de résultats peuvent être trouvés dans le répertoire images.

3 Commencer à utiliser

3.1 Installation

1

 pip install Web-page-Screenshot-Segmentation

4 Utilisation en ligne de commande

Obtenez la hauteur des lignes de segmentation de l’image

1

python -m Web_page_Screenshot_Segmentation.master -f "path/to/img"

La sortie devrait être une liste : [6, 868, 1912, 2672, 3568, 4444, 5124, 6036, 7698]. C’est la liste des hauteurs des lignes de segmentation de l’image. Si vous souhaitez afficher cette ligne de segmentation dans l’image, vous pouvez ajouter le paramètre -s True :

1

python -m Web_page_Screenshot_Segmentation.master -f "path/to/img" -s True

4.1 Dessiner les lignes de segmentation sur l’image

1

python -m Web_page_Screenshot_Segmentation.drawer --image_file path/to/image.jpg --hl [100,200] --color (0,255,0)

4.2 Découper l’image

1

python -m Web_page_Screenshot_Segmentation.spliter --f path/to/image.jpg -ht "[233,456]"

Vous obtiendrez les images segmentées, enregistrées dans le chemin retourné par la commande.

Pour plus d’explications sur l’utilisation, veuillez vous référer à l’aide :

1
2

python master.py --help
python spliter.py --help

5 Utilisation à partir du code source

5.1 Fonction split_heights

La fonction split_heights est utilisée pour segmenter une image en plusieurs parties selon divers seuils. Elle accepte les paramètres suivants :

• file_path: Le chemin du fichier image.
• split: Un booléen indiquant s’il faut segmenter l’image.
• height_threshold: Le seuil de hauteur pour les zones de faible variation.
• variation_threshold: Le seuil de variation pour les zones de faible variation.
• color_threshold: Le seuil de différence de couleur.
• color_variation_threshold: Le seuil de variation de différence de couleur.
• merge_threshold: Le seuil de distance minimale entre deux lignes.

Si split est False, la fonction retourne la liste des hauteurs des lignes de segmentation ; si split est True, elle retourne le chemin des images segmentées.

5.1.1 Exemple d’utilisation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import Web_page_Screenshot_Segmentation
from Web_page_Screenshot_Segmentation.master import split_heights

# Segmente l'image 'path/to/image.jpg' en plusieurs parties
split_image_path = split_heights(
    file_path='path/to/image.jpg',
    split=True,
    height_threshold=102,
    variation_threshold=0.5,
    color_threshold=100,
    color_variation_threshold=15,
    merge_threshold=350
)

print(f"Les images segmentées sont enregistrées dans {split_image_path}")

Dans cet exemple, l’image ‘path/to/image.jpg’ est segmentée en plusieurs parties selon les seuils fournis. Les images segmentées sont enregistrées dans le chemin retourné par la fonction.

5.2 Fonction draw_line_from_file

La fonction draw_line_from_file est utilisée pour dessiner des lignes sur une image à des hauteurs spécifiées. Elle accepte les paramètres suivants :

• image_file: Le chemin du fichier image.
• heights: La liste des hauteurs où dessiner les lignes.
• color: La couleur des lignes. La couleur par défaut est rouge (0, 0, 255).

Cette fonction lit l’image à partir du chemin de fichier fourni, dessine des lignes aux hauteurs spécifiées, puis enregistre l’image modifiée dans un nouveau fichier. Le nouveau fichier est enregistré dans le répertoire result, avec le même nom que le fichier original mais avec ‘result’ ajouté avant l’extension du fichier.

Si la fonction rencontre une erreur lors de la lecture du fichier image (par exemple, si le chemin du fichier contient des ‘.’ ou des caractères chinois), elle lèvera une exception.

5.2.1 Exemple d’utilisation

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

import Web_page_Screenshot_Segmentation
from Web_page_Screenshot_Segmentation.spliter import draw_line_from_file

# Dessine des lignes sur l'image 'path/to/image.jpg' aux hauteurs 100 et 200
result_image_path = draw_line_from_file(
    image_file='path/to/image.jpg',
    heights=[100, 200],
    color=(0, 255, 0)  # Dessine les lignes en vert
)

print(f"L'image modifiée est enregistrée dans {result_image_path}")

Dans cet exemple, l’image ‘path/to/image.jpg’ est modifiée pour dessiner des lignes vertes aux hauteurs 100 et 200. L’image modifiée est enregistrée dans le chemin retourné par la fonction.