BM25

BM25 est une fonction de classement utilisée dans la recherche d'informations pour estimer la pertinence des documents par rapport à une requête de recherche donnée. Il améliore l'approche de base de la fréquence des termes en incorporant la normalisation de la longueur des documents et la saturation de la fréquence des termes. La BM25 peut générer des encastrements épars en représentant les documents sous forme de vecteurs de scores d'importance des termes, ce qui permet une recherche et un classement efficaces dans des espaces vectoriels épars.

Milvus s'intègre au modèle BM25 à l'aide de la classe BM25EmbeddingFunction. Cette classe gère le calcul des embeddings et les renvoie dans un format compatible avec Milvus pour l'indexation et la recherche. La construction d'un analyseur pour la tokenisation est essentielle à ce processus.

Pour utiliser cette fonctionnalité, installez les dépendances nécessaires :

pip install --upgrade pymilvus
pip install "pymilvus[model]"

Pour créer facilement un analyseur de jetons, Milvus propose un analyseur par défaut qui nécessite uniquement de spécifier la langue du texte.

Exemple:

from pymilvus.model.sparse.bm25.tokenizers import build_default_analyzer
from pymilvus.model.sparse import BM25EmbeddingFunction

# there are some built-in analyzers for several languages, now we use 'en' for English.
analyzer = build_default_analyzer(language="en")

corpus = [
    "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.",
]

# analyzer can tokenize the text into tokens
tokens = analyzer(corpus[0])
print("tokens:", tokens)

Paramètres:

• langue(chaîne)

  La langue du texte à analyser. Les options valides sont en (anglais), de (allemand), fr (français), ru (russe), sp (espagnol), it (italien), pt (portugais), zh (chinois), jp (japonais), kr (coréen).

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

tokens: ['artifici', 'intellig', 'found', 'academ', 'disciplin', '1956']

L'algorithme BM25 traite le texte en le décomposant d'abord en tokens à l'aide d'un analyseur intégré, comme le montrent les tokens de langue anglaise tels que "artifici", "intellig" et "academ". Il recueille ensuite des statistiques sur ces tokens, en évaluant leur fréquence et leur distribution dans les documents. Le cœur de BM25 calcule le score de pertinence de chaque mot clé en fonction de son importance, les mots clés les plus rares recevant un score plus élevé. Ce processus concis permet de classer efficacement les documents en fonction de leur pertinence par rapport à une requête.

Pour recueillir des statistiques sur le corpus, utilisez la méthode fit():

# Use the analyzer to instantiate the BM25EmbeddingFunction
bm25_ef = BM25EmbeddingFunction(analyzer)

# Fit the model on the corpus to get the statstics of the corpus
bm25_ef.fit(corpus)

Ensuite, utilisez encode_documents() pour créer des embeddings pour les documents :

docs = [
    "The field of artificial intelligence was established as an academic subject in 1956.",
    "Alan Turing was the pioneer in conducting significant research in artificial intelligence.",
    "Originating in Maida Vale, London, Turing grew up in the southern regions of England.",
    "In 1956, artificial intelligence emerged as a scholarly field.",
    "Turing, originally from Maida Vale, London, was brought up in the south of England."
]

# Create embeddings for the documents
docs_embeddings = bm25_ef.encode_documents(docs)

# Print embeddings
print("Embeddings:", docs_embeddings)
# Since the output embeddings are in a 2D csr_array format, we convert them to a list for easier manipulation.
print("Sparse dim:", bm25_ef.dim, list(docs_embeddings)[0].shape)

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

Embeddings:   (0, 0)        1.0208816705336425
  (0, 1)        1.0208816705336425
  (0, 3)        1.0208816705336425
...
  (4, 16)        0.9606986899563318
  (4, 17)        0.9606986899563318
  (4, 20)        0.9606986899563318
Sparse dim: 21 (1, 21)

Pour créer des embeddings pour les requêtes, utilisez la méthode encode_queries():

queries = ["When was artificial intelligence founded", 
           "Where was Alan Turing born?"]

query_embeddings = bm25_ef.encode_queries(queries)

# Print embeddings
print("Embeddings:", query_embeddings)
# Since the output embeddings are in a 2D csr_array format, we convert them to a list for easier manipulation.
print("Sparse dim:", bm25_ef.dim, list(query_embeddings)[0].shape)

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

Embeddings:   (0, 0)        0.5108256237659907
  (0, 1)        0.5108256237659907
  (0, 2)        0.5108256237659907
  (1, 6)        0.5108256237659907
  (1, 7)        0.11554389108992644
  (1, 14)        0.5108256237659907
Sparse dim: 21 (1, 21)

Notes :

Lorsque vous utilisez BM25EmbeddingFunction, notez que les opérations encoding_queries() et encoding_documents() ne peuvent pas être interchangées mathématiquement. Par conséquent, il n'y a pas de bm25_ef(texts) implémenté disponible.