Recherchez « comment récupérer mon argent » et un bon système devrait trouver une page intitulée « Politique de remboursement », même si les deux ne partagent aucun mot important. Cette capacité vient des intégrations, l’une des idées les plus utiles de l’IA moderne.

Ce guide explique les intégrations sans mathématiques lourdes. Nous avons exécuté un petit exemple dans Python 3.13 et son résultat est présenté ci-dessous. Les vecteurs qu’il contient sont ceux que nous créons à la main, avec seulement trois nombres chacun, pour rendre l’idée facile à voir. Les intégrations réelles proviennent d’un modèle entraîné et comportent souvent des centaines ou des milliers de nombres.

Qu’est-ce qu’une intégration ?

Une intégration est une représentation de quelque chose sous la forme d’une liste de nombres, appelée vecteur. Un modèle est entraîné de manière à ce que les éléments ayant des significations connexes obtiennent des vecteurs proches les uns des autres.

"kitten"  -> [0.9, 0.8, 0.1]
"cat"     -> [0.9, 0.7, 0.2]
"invoice" -> [0.0, 0.1, 0.9]

Une fois le texte sous cette forme, un ordinateur peut calculer la similitude de deux morceaux de texte, ce qu’il ne peut pas faire directement avec des mots. Les intégrations ne se limitent pas non plus aux mots. Des phrases, des documents entiers, des images, des fichiers audio et des produits peuvent tous être intégrés.

Pourquoi ne pas simplement faire correspondre les mots-clés ?

Notre guide de RAG le montre en pratique. Une simple recherche par nombre de mots a donné un résultat nul pour « Quand puis-je récupérer mon argent ? » contre un document de remboursement, puisqu’ils n’ont partagé aucun mot. Notez également la troisième ligne : les identifiants exacts sont une faiblesse des intégrations, donc la recherche par mot clé a toujours sa place.

Pensez à une carte

Imaginez placer chaque mot sur une immense carte, où l’emplacement reflète le sens. « Chat » et « chaton » sont assis presque l’un à côté de l’autre, « chien » est dans le même quartier et « facture » est dans une ville différente. Pour trouver des mots apparentés, il vous suffit de regarder à proximité.

Une véritable intégration fonctionne de la même manière, sauf que la carte a des centaines de dimensions au lieu de deux. Les gens ne peuvent pas imaginer cela, mais les calculs fonctionnent de la même manière. Les nombres individuels n’ont généralement pas de signification précise, comme « furriness ». Ce qui compte, c’est la position globale.

Un petit exemple fonctionnel

Voici comment comparer nos vecteurs fabriqués à la main :

import math

def cosine(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    return dot / (math.sqrt(sum(x * x for x in a)) *
                  math.sqrt(sum(y * y for y in b)))

vectors = {
    "kitten":  [0.9, 0.8, 0.1],
    "cat":     [0.9, 0.7, 0.2],
    "dog":     [0.8, 0.3, 0.2],
    "invoice": [0.0, 0.1, 0.9],
}

for word in ("kitten", "dog", "invoice"):
    print(word, round(cosine(vectors["cat"], vectors[word]), 3))

# kitten 0.994
# dog 0.955
# invoice 0.238

Par rapport au « chat », le « chaton » obtient le score le plus élevé, le « chien » vient ensuite et la « facture » est bien inférieure. Nous avons choisi ces vecteurs pour produire ce modèle, donc le classement ne prouve rien sur le langage réel. Il montre uniquement le comportement du calcul. Une recherche sémantique fait la même chose en trois étapes : intégrer la requête, l’évaluer par rapport à chaque élément stocké et trier.

query = [0.85, 0.75, 0.15]
sorted(vectors, key=lambda w: cosine(query, vectors[w]), reverse=True)

# ['kitten', 'cat', 'dog', 'invoice']

Similitude cosinus expliquée

Chaque vecteur peut être considéré comme une flèche pointant depuis l’origine. La similarité cosinus mesure l’angle entre deux flèches, en ignorant leur longueur. Nous avons confirmé les valeurs clés :

cosine([1, 2, 3], [2, 4, 6])   # 1.0   same direction
cosine([1, 0], [0, 1])         # 0.0   unrelated (at right angles)
cosine([1, 0], [-1, 0])        # -1.0  opposite directions

Regardez la première ligne. [2, 4, 6] est deux fois plus long que [1, 2, 3], mais le score est parfait de 1,0, car seule la direction compte. Cela est utile pour le texte, où la longueur peut refléter des éléments tels que la taille du document plutôt que sa signification. Soyez également prudent avec les seuils. Il n’existe pas de score universel signifiant « similaire », car les plages utiles diffèrent d’un modèle à l’autre, alors testez sur vos propres données.

Autres mesures de distance

La différence est facile à voir. Ces deux mêmes vecteurs avec un score cosinus de 1,0 ont une distance euclidienne de 3,742, puisque l’un est plus long que l’autre. De nombreux systèmes normalisent les vecteurs, en les mettant chacun à une longueur de 1. Après cela, le produit scalaire et le cosinus donnent la même réponse, et nous l’avons confirmé : les deux ont donné 0,955 pour “chat” et “chien”. Consultez la documentation de votre modèle pour voir quelle mesure il recommande.

Comment les intégrations sont apprises

Personne n’attribue ces numéros à la main dans les systèmes réels. Un réseau de neurones les apprend lors de l’entraînement. Une idée ancienne et influente est que les mots apparaissant dans des contextes similaires ont tendance à avoir des significations similaires, comme « J’ai nourri mon chat » et « J’ai nourri mon chien ». Des modèles tels que Word2Vec et GloVe ont appris des vecteurs de mots à partir de ces modèles.

Plus tard, des modèles basés sur des transformateurs tels que BERT ont rendu les intégrations sensibles au contexte, de sorte que « banque » puisse obtenir un vecteur différent dans « berge de rivière » et « prêt bancaire ». De nombreux modèles modernes intègrent des phrases ou des passages entiers à la fois. Notre guide des grands modèles de langage explique comment les transformateurs gèrent le contexte.

Où les intégrations sont utilisées

Recherche à grande échelle

Notre exemple a comparé une requête à chaque élément, ce que l’on appelle une recherche exacte. Cela fonctionne bien pour des milliers d’éléments, mais cela devient lent avec plusieurs millions. Les index Approximativement le plus proche voisin (ANN) tels que HNSW résolvent ce problème. Ils trouvent rapidement des matchs très serrés, en renonçant à une petite chance de rater le meilleur absolu.

Les bases de données vectorielles et les extensions, telles que pgvector pour PostgreSQL, fournissent ces index ainsi que le filtrage et le stockage. Notre guide des bases de données vectorielles couvre les options. Pour un petit projet, vous n’en aurez peut-être pas besoin du tout, et une recherche en mémoire est un très bon moyen de commencer.

Choisir un modèle d’intégration

• Langue. Si votre contenu est en hindi ou en tamoul par exemple, vérifiez que le modèle le gère bien.
• Domaine. Les modèles généraux peuvent avoir des difficultés avec les termes juridiques ou médicaux spécialisés.
• Dimensions. Plus de dimensions peuvent capturer plus de détails, mais elles coûtent plus de stockage et de mémoire.
• Coût et hébergement. Comparez une API hébergée avec un modèle ouvert que vous pouvez exécuter vous-même, notamment pour les données privées.
• Longueur d’entrée. Les modèles ont une limite, les documents longs doivent donc d’abord être divisés en morceaux.

Le meilleur test est celui de vos propres données. Collectez environ 20 requêtes réelles ainsi que les documents qu’elles devraient trouver et comparez la façon dont chaque modèle les classe. Les benchmarks publiés peuvent ne pas refléter votre contenu.

Limites

• Verrouillage du modèle. Les vecteurs de différents modèles ne peuvent pas être comparés. Si vous changez de modèle, vous devez tout réintégrer.
• Termes exacts. Les identifiants, codes et noms rares peuvent ne pas correspondre de manière fiable.
• Négation. Les « remboursements autorisés » et les « remboursements non autorisés » peuvent se rapprocher, même s’ils signifient des choses opposées.
• Similaire ne veut pas dire correct. Une correspondance serrée peut être obsolète ou tout simplement fausse.
• Biais. Les intégrations peuvent absorber les stéréotypes de leurs données de formation.
• Le cosinus n’est pas magique. Les chercheurs se demandent quelle est sa signification sur certaines intégrations apprises, donc traitez les scores comme un signal utile et non comme une mesure de vérité.

Erreurs courantes

• Mélange de modèles. Intégrez des requêtes et des documents avec le même modèle et la même version.
• Utiliser un seuil de similarité partout. Ajustez-le pour chaque modèle et chaque tâche.
• Intégrer d’énormes documents dans leur intégralité. Le sens se dilue, alors les fragmenter en premier.
• Ignorer l’évaluation. Sans requêtes de test, vous ne pouvez pas savoir si un changement a aidé.
• Utiliser des intégrations pour tout. Si les utilisateurs recherchent des identifiants exacts, un index de base de données normal est préférable.

Pour conclure

Une intégration transforme le sens en nombres, afin que le logiciel puisse comparer des idées plutôt que des chaînes. Le concept est simple, tandis que le travail pratique consiste à choisir un modèle, à regrouper les données et à tester sur des requêtes réelles. Pour l’essayer vous-même, intégrez quelques dizaines de vos propres documents avec n’importe quel modèle d’intégration, recherchez-les avec de vraies questions et voyez où les résultats vous surprennent.

Questions fréquentes

Continuez à apprendre