BAAI / bge-m3

Un modèle d'intégration multilingue multifonctionnel (extraction dense, éparse et multi-vectorielle) qui prend en charge 100 langues.

Milvus Integrated

Tâche: Intégration

Modalité: Texte

Métrique de similarité: Cosinus, produit de points

Licence: Mit

Dimensions: 1024

Tokens d'entrée max: 8192

Prix: Gratuit

Published Nov 01, 2024Lecture en 2 min

Introduction à BGE-M3

BGE-M3 est un modèle d'intégration de texte développé par BAAI, conçu pour s'adapter à différentes langues et tâches. Il prend en charge plus de 100 langues et gère des tailles d'entrée allant jusqu'à 8192 tokens. Cette capacité permet à BGE-M3 d'exceller dans les tâches d'extraction denses, éparses et multi-vectorielles, ce qui le rend très efficace pour l'extraction de documents et la réponse aux questions. Les performances de pointe du modèle sont démontrées dans des tests de référence tels que MKQA et MLDR. Son architecture comprend la distillation de l'auto-connaissance, ce qui améliore l'adaptabilité et la précision dans divers ensembles de données et en fait un outil puissant pour la recherche d'informations multilingues.

Comment créer des embeddings avec BGE-M3

Il existe deux façons de générer des embeddings vectoriels :

PyMilvus](https://github.com/milvus-io/pymilvus) : le SDK Python pour Milvus qui intègre de manière transparente le modèle bge-m3.
Bibliothèque FlagEmbedding : la bibliothèque Python FlagEmbedding.

Une fois les embeddings vectoriels créés, ils peuvent être stockés dans Zilliz Cloud (un service de base de données vectorielles entièrement géré par Milvus) et utilisés pour la recherche de similarité sémantique. Voici les quatre étapes clés :

S'inscrire pour un compte Zilliz Cloud gratuit.
Configurez un cluster sans serveur (https://docs.zilliz.com/docs/create-cluster#set-up-a-free-cluster) et obtenez le point de terminaison public et la clé API (https://docs.zilliz.com/docs/on-zilliz-cloud-console#free-cluster-details).
Créez une collection de vecteurs et insérez vos embeddings vectoriels.
Exécutez une recherche sémantique sur les encastrements stockés.

Créer des embeddings via PyMilvus

from pymilvus.model.hybrid import BGEM3EmbeddingFunction
from pymilvus import MilvusClient, DataType, AnnSearchRequest, WeightedRanker

ef = BGEM3EmbeddingFunction()

docs = [
   "L'intelligence artificielle a été fondée en tant que discipline universitaire en 1956,
   "Alan Turing a été la première personne à mener des recherches substantielles sur l'IA.",
   "Né à Maida Vale, Londres, Turing a grandi dans le sud de l'Angleterre."
]
# Générer des embeddings pour les documents
docs_embeddings = ef.encode_documents(docs)

queries = ["Quand l'intelligence artificielle a-t-elle été fondée ?
          "Où est né Alan Turing ?"]

# Génère des embeddings pour les requêtes
query_embeddings = ef.encode_queries(queries)

client = MilvusClient(
    uri=ZILLIZ_PUBLIC_ENDPOINT,
    token=ZILLIZ_API_KEY)
 
schema = client.create_schema(
    auto_id=True,
    enable_dynamic_field=True,
)

schema.add_field(field_name="pk", datatype=DataType.INT64, is_primary=True)
schema.add_field(
    field_name="dense_vector",
    datatype=DataType.FLOAT_VECTOR,
    dim=ef.dim["dense"],
)
schema.add_field(
    field_name="sparse_vector", datatype=DataType.SPARSE_FLOAT_VECTOR
)

index_params = client.prepare_index_params()
index_params.add_index(
    field_name="dense_vector", index_type="FLAT", metric_type="IP"
)
index_params.add_index(
    nom_du_champ="sparse_vector",
    index_type="SPARSE_INVERTED_INDEX",
    metric_type="IP",
)

COLLECTION = "documents"
if client.has_collection(collection_name=COLLECTION) :
    client.drop_collection(nom_de_la_collection=COLLECTION)
client.create_collection(
    nom_de_la_collection=COLLECTION,
    schema=schema,
    index_params=index_params,
    enable_dynamic_field=True,
)

for i in range(len(docs)) :
    doc, dense_embedding, sparse_embedding = docs[i], docs_embeddings["dense"][i], docs_embeddings["sparse"][[i]]
    client.insert(COLLECTION, {"text" : doc, "dense_vector" : dense_embedding, "sparse_vector" : sparse_embedding})

k = 1
req_list = []

dense_embedding = query_embeddings["dense"][0]
sparse_embedding = query_embeddings["sparse"][[0]]

dense_search_param = {
    "data" : [dense_embedding],
    "anns_field" : "dense_vector",
    "param" : {"metric_type" : "IP"},
    "limit" : k * 2,
}

dense_req = AnnSearchRequest(**dense_search_param)
req_list.append(dense_req)

sparse_search_param = {
    "data" : [sparse_embedding],
    "anns_field" : "sparse_vector",
    "param" : {"metric_type" : "IP"},
    "limit" : k * 2,
}
sparse_req = AnnSearchRequest(**sparse_search_param)
req_list.append(sparse_req)

results = client.hybrid_search(
    COLLECTION,
    req_list,
    WeightedRanker(1.0, 1.0),
    k,
    consistency_level="Strong",
    output_fields=["text"]
)

Référez-vous à notre [PyMilvus Documentation] (https://milvus.io/docs/embed-with-bgm-m3.md) pour un guide détaillé étape par étape.

Générer des encastrements vectoriels via la bibliothèque FlagEmbedding

from pymilvus import MilvusClient, DataType, AnnSearchRequest, WeightedRanker
from FlagEmbedding import BGEM3FlagModel

model = BGEM3FlagModel('BAAI/bge-m3', use_fp16=False)

docs = [
   "L'intelligence artificielle a été fondée en tant que discipline universitaire en 1956,
   "Alan Turing a été la première personne à mener des recherches approfondies sur l'intelligence artificielle,
   "Né à Maida Vale, Londres, Turing a grandi dans le sud de l'Angleterre."
]
# Générer des embeddings pour les documents
docs_embeddings = model.encode(docs, return_dense=True, return_sparse=True)

queries = ["Quand l'intelligence artificielle a-t-elle été fondée ?
          "Où est né Alan Turing ?"]

# Générer des embeddings pour les requêtes
query_embeddings = model.encode(queries, return_dense=True, return_sparse=True)

client = MilvusClient(
    uri=ZILLIZ_PUBLIC_ENDPOINT,
    token=ZILLIZ_API_KEY)
 
schema = client.create_schema(
    auto_id=True,
    enable_dynamic_field=True,
)

schema.add_field(field_name="pk", datatype=DataType.INT64, is_primary=True)
schema.add_field(
    field_name="dense_vector",
    datatype=DataType.FLOAT_VECTOR,
    dim=1024,
)
schema.add_field(
    field_name="sparse_vector", datatype=DataType.SPARSE_FLOAT_VECTOR
)

index_params = client.prepare_index_params()
index_params.add_index(
    field_name="dense_vector", index_type="FLAT", metric_type="IP"
)
index_params.add_index(
    nom_du_champ="sparse_vector",
    index_type="SPARSE_INVERTED_INDEX",
    metric_type="IP",
)

COLLECTION = "documents"
if client.has_collection(collection_name=COLLECTION) :
    client.drop_collection(nom_de_la_collection=COLLECTION)
client.create_collection(
    nom_de_la_collection=COLLECTION,
    schema=schema,
    index_params=index_params,
    enable_dynamic_field=True,
)

for i in range(len(docs)) :
    doc, dense_embedding, sparse_embedding = docs[i], docs_embeddings["dense_vecs"][i], docs_embeddings["lexical_weights"][i]
    client.insert(COLLECTION, {"text" : doc, "dense_vector" : dense_embedding, "sparse_vector" : {int(k) : sparse_embedding[k] for k in sparse_embedding}})

k = 1
req_list = []

dense_embedding = query_embeddings["dense_vecs"][0]
sparse_embedding = {int(k) : query_embeddings["lexical_weights"][0][k] for k in query_embeddings["lexical_weights"][0]}

dense_search_param = {
    "data" : [dense_embedding],
    "anns_field" : "dense_vector",
    "param" : {"metric_type" : "IP"},
    "limit" : k * 2,
}

dense_req = AnnSearchRequest(**dense_search_param)
req_list.append(dense_req)

sparse_search_param = {
    "data" : [sparse_embedding],
    "anns_field" : "sparse_vector",
    "param" : {"metric_type" : "IP"},
    "limit" : k * 2,
}
sparse_req = AnnSearchRequest(**sparse_search_param)
req_list.append(sparse_req)

results = client.hybrid_search(
    COLLECTION,
    req_list,
    WeightedRanker(1.0, 1.0),
    k,
    consistency_level="Strong",
    output_fields=["text"]
)

Autres lectures

Choisir le bon modèle d'intégration pour vos données](https://zilliz.com/blog/choosing-the-right-embedding-model-for-your-data)
Évaluation de votre modèle d'incorporation](https://zilliz.com/learn/evaluating-your-embedding-model)Évaluation de votre modèle d'incorporationÉvaluation de votre modèle d'incorporation
Formation de votre propre modèle d'incorporation de texte](https://zilliz.com/learn/training-your-own-text-embedding-model) _Guide du débutant sur le découpage et l'incorporation de sites web
Guide du débutant pour le regroupement et l'intégration de sites Web dans vos applications RAG] (https://zilliz.com/learn/beginner-guide-to-website-chunking-and-embedding-for-your-genai-applications) _[Qu'est-ce que le RAG ?
Qu'est-ce qu'un RAG ?(https://zilliz.com/learn/Retrieval-Augmented-Generation)_Qu'est-ce qu'un RAG ?[Qu'est-ce qu'un RAG ?

BAAI / bge-m3

Introduction à BGE-M3

Comment créer des embeddings avec BGE-M3

Créer des embeddings via PyMilvus

Générer des encastrements vectoriels via la bibliothèque FlagEmbedding

Autres lectures

Ressources connexes

Évaluer votre modèle d'intégration

Formation de votre propre modèle d'intégration de texte

Créer des applications d'IA avec Retrieval Augmented Generation (RAG)