Hugging Face and Zilliz Cloud Integration

Hugging Face est un écosystème IA/ML complet servant de plateforme collaborative pour la communauté de l’IA. Il propose une bibliothèque open source de plus de 728 000 modèles et de plus de 160 000 jeux de données, ainsi que des outils pour l’entraînement, le réglage fin et le déploiement de modèles. La plateforme fournit des modèles préentraînés couvrant le NLP, la vision par ordinateur et plus encore, avec le classement MTEB (Massive Text Embedding Benchmark) aidant les développeurs à sélectionner les meilleurs modèles d’embeddings selon le rang, les performances de récupération, la longueur des tokens et la dimension des embeddings.

Grâce à l’intégration avec Zilliz Cloud (Milvus entièrement géré), les modèles d’embeddings de pointe de Hugging Face sont associés à une base de données vectorielle hautes performances, permettant la conversion transparente de données non structurées en embeddings vectoriels stockés et recherchés à grande échelle pour la recherche de similarité sémantique, le RAG, la détection d’anomalies et les systèmes de recommandation.

• Plus de 728 000 modèles à portée de main : La vaste bibliothèque de modèles de Hugging Face offre aux développeurs la flexibilité de choisir le meilleur modèle d’embedding pour leur cas d’utilisation, Zilliz Cloud stockant et recherchant efficacement les vecteurs résultants, quel que soit le choix du modèle.
• Classement MTEB pour la sélection des modèles : Le classement MTEB aide les développeurs à filtrer et à sélectionner les modèles d’embedding optimaux selon les performances de récupération, la longueur des tokens et la dimension, garantissant la meilleure adéquation pour les applications propulsées par Zilliz Cloud.
• Flux de travail simplifié : De la sélection de modèles sur Hugging Face à la génération d’embeddings avec Transformers, puis au stockage vectoriel dans Zilliz Cloud, l’intégration offre un parcours simplifié des données aux applications d’IA prêtes pour la production.
• Dimensions d’embedding flexibles : Les modèles Hugging Face produisent des embeddings de différentes dimensions (par exemple, 384 pour all-MiniLM-L6-v2), et Zilliz Cloud gère efficacement n’importe quelle dimension grâce à l’indexation automatique et à la recherche de similarité.

Hugging Face sert de couche de modèles et de données, fournissant des modèles d’embeddings pré-entraînés (par exemple, all-MiniLM-L6-v2) via la bibliothèque Transformers et des jeux de données via la bibliothèque Datasets. Il gère la tokenisation, l’inférence de modèles et la génération d’embeddings, convertissant les données textuelles en représentations vectorielles de haute dimension.

Zilliz Cloud sert de couche de base de données vectorielle, stockant et indexant les embeddings générés par les modèles Hugging Face. Il fournit une recherche de similarité haute performance avec prise en charge des identifiants automatiques, des champs dynamiques et de plusieurs niveaux de cohérence, permettant une récupération rapide des résultats les plus pertinents.

Ensemble, Hugging Face et Zilliz Cloud créent une solution complète de recherche sémantique : les jeux de données sont chargés depuis Hugging Face, le texte est encodé en embeddings à l’aide de modèles pré-entraînés, et les vecteurs sont stockés dans Zilliz Cloud. Lorsqu’un utilisateur soumet une requête, elle est convertie en embedding à l’aide du même modèle et Zilliz Cloud effectue une recherche de similarité pour trouver les éléments correspondants les plus proches — permettant des applications telles que la réponse aux questions, les recommandations et le RAG.

1. Installer les packages requis

$ pip install --upgrade pymilvus transformers datasets torch

2. Charger les données depuis Hugging Face Datasets

Chargez des exemples de paires question-réponse depuis le jeu de données SQuAD :

from datasets import load_dataset

DATASET = "squad"
INSERT_RATIO = 0.001

data = load_dataset(DATASET, split="validation")
data = data.train_test_split(test_size=INSERT_RATIO, seed=42)["test"]
data = data.map(
    lambda val: {"answer": val["answers"]["text"][0]},
    remove_columns=["id", "answers", "context"],
)

print(data)

3. Générer des embeddings avec les modèles Hugging Face

Sélectionnez un modèle d’embedding de texte et définissez la fonction d’encodage :

from transformers import AutoTokenizer, AutoModel
import torch

MODEL = "sentence-transformers/all-MiniLM-L6-v2"
INFERENCE_BATCH_SIZE = 64

tokenizer = AutoTokenizer.from_pretrained(MODEL)
model = AutoModel.from_pretrained(MODEL)


def encode_text(batch):
    encoded_input = tokenizer(
        batch["question"], padding=True, truncation=True, return_tensors="pt"
    )

    with torch.no_grad():
        model_output = model(**encoded_input)

    token_embeddings = model_output[0]
    attention_mask = encoded_input["attention_mask"]
    input_mask_expanded = (
        attention_mask.unsqueeze(-1).expand(token_embeddings.size()).float()
    )
    sentence_embeddings = torch.sum(
        token_embeddings * input_mask_expanded, 1
    ) / torch.clamp(input_mask_expanded.sum(1), min=1e-9)

    batch["question_embedding"] = torch.nn.functional.normalize(
        sentence_embeddings, p=2, dim=1
    )
    return batch


data = data.map(encode_text, batched=True, batch_size=INFERENCE_BATCH_SIZE)
data_list = data.to_list()

4. Insérer les données dans Milvus

Connectez-vous à Milvus, créez une collection et insérez les données :

from pymilvus import MilvusClient

MILVUS_URI = "./huggingface_milvus_test.db"
COLLECTION_NAME = "huggingface_test"
DIMENSION = 384

milvus_client = MilvusClient(MILVUS_URI)
if milvus_client.has_collection(collection_name=COLLECTION_NAME):
    milvus_client.drop_collection(collection_name=COLLECTION_NAME)
milvus_client.create_collection(
    collection_name=COLLECTION_NAME,
    dimension=DIMENSION,
    auto_id=True,
    enable_dynamic_field=True,
    vector_field_name="question_embedding",
    consistency_level="Strong",
)

milvus_client.insert(collection_name=COLLECTION_NAME, data=data_list)

Concernant l’argument de MilvusClient : définir le uri comme un fichier local, par exemple ./milvus.db, est la méthode la plus pratique, car elle utilise automatiquement Milvus Lite pour stocker toutes les données dans ce fichier. Si vous avez des données à grande échelle, vous pouvez configurer un serveur Milvus plus performant sur Docker ou Kubernetes. Si vous souhaitez utiliser Zilliz Cloud, le service cloud entièrement géré pour Milvus, ajustez le uri et le token, qui correspondent au Public Endpoint et à l’API Key dans Zilliz Cloud.

5. Poser des questions et effectuer une recherche

Générez des embeddings de questions et effectuez une recherche dans Milvus :

questions = {
    "question": [
        "What is LGM?",
        "When did Massachusetts first mandate that children be educated in schools?",
    ]
}

question_embeddings = [v.tolist() for v in encode_text(questions)["question_embedding"]]

search_results = milvus_client.search(
    collection_name=COLLECTION_NAME,
    data=question_embeddings,
    limit=3,
    output_fields=["answer", "question"],
)

for q, res in zip(questions["question"], search_results):
    print("Question:", q)
    for r in res:
        print(
            {
                "answer": r["entity"]["answer"],
                "score": r["distance"],
                "original question": r["entity"]["question"],
            }
        )
    print("\n")

• Question Answering Using Milvus and Hugging Face — Tutoriel officiel de Milvus pour le QA avec Hugging Face
• Effortless AI Workflows: A Beginner's Guide to Hugging Face and PyMilvus — Tutoriel de Zilliz sur Hugging Face et PyMilvus
• Scaling Search with Milvus: Handling Massive Datasets with Ease — Blog de Zilliz sur la mise à l’échelle de la recherche avec les jeux de données Hugging Face
• Hugging Face Models — Hub de modèles Hugging Face
• MTEB Leaderboard — Classement Massive Text Embedding Benchmark