Vue d'ensemble de l'intégration

L'intégration est un concept d'apprentissage automatique qui permet de mapper des données dans un espace à haute dimension, où les données ayant une sémantique similaire sont placées à proximité les unes des autres. Il s'agit généralement d'un réseau neuronal profond de BERT ou d'autres familles de transformateurs. Le modèle d'intégration peut représenter efficacement la sémantique du texte, des images et d'autres types de données avec une série de nombres connus sous le nom de vecteurs. L'une des principales caractéristiques de ces modèles est que la distance mathématique entre les vecteurs dans l'espace à haute dimension peut indiquer la similarité de la sémantique du texte ou des images d'origine. Cette propriété ouvre la voie à de nombreuses applications de recherche d'informations, telles que les moteurs de recherche sur le web comme Google et Bing, la recherche de produits et les recommandations sur les sites de commerce électronique, ainsi que le paradigme récemment populaire de la génération augmentée de recherche (RAG) dans l'intelligence artificielle générative.

Il existe deux catégories principales d'encastrements, chacune produisant un type de vecteur différent :

• L'encastrement dense: La plupart des modèles d'intégration représentent l'information sous la forme d'un vecteur à virgule flottante de centaines ou de milliers de dimensions. Les résultats sont appelés vecteurs "denses" car la plupart des dimensions ont des valeurs non nulles. Par exemple, le modèle d'intégration à code source ouvert BAAI/bge-base-fr-v1.5 produit des vecteurs de 768 nombres à virgule flottante (vecteur flottant à 768 dimensions).

• Enrobage clairsemé: En revanche, les vecteurs de sortie des encapsulages épars ont la plupart des dimensions égales à zéro, c'est-à-dire des vecteurs "épars". Ces vecteurs ont souvent des dimensions beaucoup plus élevées (des dizaines de milliers ou plus) qui sont déterminées par la taille du vocabulaire de jetons. Les vecteurs épars peuvent être générés par des réseaux neuronaux profonds ou par l'analyse statistique de corpus de textes. En raison de leur facilité d'interprétation et de leurs meilleures capacités de généralisation hors domaine, les vecteurs épars sont de plus en plus adoptés par les développeurs en complément des vecteurs denses.

Milvus est une base de données vectorielles conçue pour la gestion, le stockage et l'extraction de données vectorielles. Grâce à l'intégration des modèles d'intégration et de reclassement, vous pouvez facilement transformer un texte original en vecteurs consultables ou reclasser les résultats à l'aide de modèles puissants afin d'obtenir des résultats plus précis pour le RAG. Cette intégration simplifie la transformation du texte et élimine le besoin de composants d'intégration ou de reclassement supplémentaires, ce qui rationalise le développement et la validation des RAG.

Pour créer des embeddings en action, voir Utilisation du modèle de PyMilvus pour générer des embeddings de texte.

Fonction d'intégration	Type de fonction	API ou Open-sourced
openai	Dense	API
transformateur de phrases	Dense	Open-sourced
bm25	Dense	Ouvert à tous
Splade	Sparse	En libre accès
bge-m3	Hybride	Open-sourced
voyageai	Dense	API
jina	Dense	API
cohère	Dense	API
Instructeur	Dense	Open-sourced
Mistral AI	Dense	API
Nomic	Dense	API
mGTE	Hybride	Open-sourced

Exemple 1 : Utiliser la fonction d'intégration par défaut pour générer des vecteurs denses

Pour utiliser les fonctions d'intégration avec Milvus, installez d'abord la bibliothèque client PyMilvus avec le sous-paquetage model qui contient tous les utilitaires pour la génération d'intégration.

pip install "pymilvus[model]"

Le sous-paquet model prend en charge différents modèles d'intégration, depuis OpenAI, Sentence Transformers, BGE M3, BM25, jusqu'aux modèles pré-entraînés SPLADE. Par souci de simplicité, cet exemple utilise le modèle DefaultEmbeddingFunction qui est un modèle de transformateur de phrase tout-MiniLM-L6-v2. Le modèle pèse environ 70 Mo et il sera téléchargé lors de la première utilisation :

from pymilvus import model

# This will download "all-MiniLM-L6-v2", a light weight model.
ef = model.DefaultEmbeddingFunction()

# Data from which embeddings are to be generated 
docs = [
    "Artificial intelligence was founded as an academic discipline in 1956.",
    "Alan Turing was the first person to conduct substantial research in AI.",
    "Born in Maida Vale, London, Turing was raised in southern England.",
]

embeddings = ef.encode_documents(docs)

# Print embeddings
print("Embeddings:", embeddings)
# Print dimension and shape of embeddings
print("Dim:", ef.dim, embeddings[0].shape)

Le résultat attendu est similaire à ce qui suit :

Embeddings: [array([-3.09392996e-02, -1.80662833e-02,  1.34775648e-02,  2.77156215e-02,
       -4.86349640e-03, -3.12581174e-02, -3.55921760e-02,  5.76934684e-03,
        2.80773244e-03,  1.35783911e-01,  3.59678417e-02,  6.17732145e-02,
...
       -4.61330153e-02, -4.85207550e-02,  3.13997865e-02,  7.82178566e-02,
       -4.75336798e-02,  5.21207601e-02,  9.04406682e-02, -5.36676683e-02],
      dtype=float32)]
Dim: 384 (384,)

Exemple 2 : Générer des vecteurs denses et épars en un seul appel avec le modèle BGE M3

Dans cet exemple, nous utilisons le modèle hybride BGE M3 pour intégrer du texte dans des vecteurs denses et épars et les utiliser pour retrouver des documents pertinents. Les étapes générales sont les suivantes :

1. Incorporer le texte dans des vecteurs denses et épars à l'aide du modèle BGE-M3 ;

2. Mise en place d'une collection Milvus pour stocker les vecteurs denses et épars ;

3. Insérer les données dans Milvus ;

4. Rechercher et inspecter le résultat.

Tout d'abord, nous devons installer les dépendances nécessaires.

from pymilvus.model.hybrid import BGEM3EmbeddingFunction
from pymilvus import (
    utility,
    FieldSchema, CollectionSchema, DataType,
    Collection, AnnSearchRequest, RRFRanker, connections,
)

Utiliser BGE M3 pour encoder les documents et les requêtes pour la recherche par incorporation.

# 1. prepare a small corpus to search
docs = [
    "Artificial intelligence was founded as an academic discipline in 1956.",
    "Alan Turing was the first person to conduct substantial research in AI.",
    "Born in Maida Vale, London, Turing was raised in southern England.",
]
query = "Who started AI research?"

# BGE-M3 model can embed texts as dense and sparse vectors.
# It is included in the optional `model` module in pymilvus, to install it,
# simply run "pip install pymilvus[model]".

bge_m3_ef = BGEM3EmbeddingFunction(use_fp16=False, device="cpu")

docs_embeddings = bge_m3_ef(docs)
query_embeddings = bge_m3_ef([query])

Exemple 3 : Générer des vecteurs épars à l'aide du modèle BM25

BM25 est une méthode bien connue qui utilise les fréquences d'occurrence des mots pour déterminer la pertinence entre les requêtes et les documents. Dans cet exemple, nous allons montrer comment utiliser BM25EmbeddingFunction pour générer des encastrements épars pour les requêtes et les documents.

Tout d'abord, importez la classe BM25EmbeddingFunction.

from pymilvus.model.sparse import BM25EmbeddingFunction

Dans BM25, il est important de calculer les statistiques de vos documents pour obtenir l'IDF (Inverse Document Frequency), qui peut représenter le modèle dans vos documents. L'IDF est une mesure de la quantité d'informations fournies par un mot, c'est-à-dire s'il est commun ou rare dans tous les documents.

# 1. prepare a small corpus to search
docs = [
    "Artificial intelligence was founded as an academic discipline in 1956.",
    "Alan Turing was the first person to conduct substantial research in AI.",
    "Born in Maida Vale, London, Turing was raised in southern England.",
]
query = "Where was Turing born?"
bm25_ef = BM25EmbeddingFunction()

# 2. fit the corpus to get BM25 model parameters on your documents.
bm25_ef.fit(docs)

# 3. store the fitted parameters to disk to expedite future processing.
bm25_ef.save("bm25_params.json")

# 4. load the saved params
new_bm25_ef = BM25EmbeddingFunction()
new_bm25_ef.load("bm25_params.json")

docs_embeddings = new_bm25_ef.encode_documents(docs)
query_embeddings = new_bm25_ef.encode_queries([query])
print("Dim:", new_bm25_ef.dim, list(docs_embeddings)[0].shape)

Le résultat attendu est similaire à ce qui suit :

Dim: 21 (1, 21)