Base de données vectorielle
Une base de données vectorielle est un système de base de données spécialement conçu pour stocker, indexer et récupérer des données vectorielles à haute dimension.
Vous pouvez le concevoir ainsi : stocker ensemble les choses ayant des significations similaires, et trouver rapidement celles qui sont les plus similaires à un élément donné.
Contrairement aux bases de données traditionnelles, qui interrogent par correspondance exacte (WHERE name = 'Alice'), les bases de données vectorielles interrogent par similarité (trouver les 10 images les plus similaires à cette image).
Une analogie intuitive
Imaginez un scénario de bibliothèque :
| Type de base de données | Méthode de récupération | Analogie |
|---|---|---|
| Base de données traditionnelle | Recherche exacte par numéro de livre et titre | Trouver un livre avec un numéro spécifié |
| Base de données vectorielle | Recherche par pertinence de contenu | Trouver « tous les romans de science-fiction similaires en style à The Three-Body Problem » |
Cette similarité sémantique est précisément le problème central que résolvent les bases de données vectorielles.
Pourquoi avons-nous besoin d'une base de données vectorielle ?
Avant de plonger dans les détails techniques, commençons par comprendre quels problèmes les bases de données vectorielles résolvent.
Limites des bases de données traditionnelles
Les bases de données relationnelles traditionnelles (MySQL, PostgreSQL) sont très efficaces pour gérer des données structurées, mais elles montrent leurs limites face aux exigences suivantes :
- Recherche d’images (trouver des images visuellement similaires)
- Recherche sémantique (lorsqu’un utilisateur recherche « Apple phone », elle peut trouver du contenu associé à « iPhone »)
- Systèmes de recommandation (trouver « des chansons au style similaire à celles que vous aimez »)
- Détection d’anomalies (trouver « les journaux qui diffèrent le plus du comportement normal »)
La caractéristique commune de ces problèmes est la nécessité de comprendre le « sens » du contenu, plutôt que d’effectuer une correspondance littérale.
Problèmes des approches traditionnelles
用 LIKE '%苹果%' 搜索 → 找不到 "iPhone"、"Apple" 用全文索引搜索 → 找不到语义相关但用词不同的内容
Schéma comparatif
Le diagramme ci-dessous montre intuitivement les différences fondamentales entre les méthodes d’interrogation des bases de données traditionnelles et des bases de données vectorielles.
Concepts clés : vecteurs et embeddings
Comprendre les vecteurs et les embeddings est la première étape pour maîtriser les bases de données vectorielles.
Qu'est-ce qu'un vecteur ?
En mathématiques, un vecteur est un ensemble ordonné de nombres.
[0.12, -0.54, 0.87, 0.03, ..., 0.61] ← 这就是一个向量
En apprentissage automatique, cet ensemble de nombres représente les caractéristiques sémantiques d'un objet, avec généralement des dimensions allant de 128 à 4096.
Qu'est-ce qu'un plongement ?
Le plongement est le processus et le résultat de la conversion d'objets du monde réel (texte, images, audio, etc.) en vecteurs.
Cette conversion est effectuée par un modèle de plongement, dont l'idée centrale est : des objets ayant une sémantique similaire ont des vecteurs plus proches dans l'espace.
Une sémantique similaire signifie des vecteurs similaires
Utilisez un exemple simplifié en 2D pour comprendre (en réalité, il s'agit de centaines à milliers de dimensions) :
Compréhension clé : deux vecteurs proches dans l'espace vectoriel ont également un contenu d'origine sémantiquement similaire. C'est le fondement de toutes les capacités des bases de données vectorielles.
Méthodes de calcul de similarité
Le cœur de la recherche du « vecteur le plus similaire » est de calculer la distance ou la similarité entre deux vecteurs. Voici les trois méthodes les plus couramment utilisées.
Similarité cosinus
La similarité cosinus mesure l'angle entre deux vecteurs, en ignorant leur magnitude. C'est la méthode la plus couramment utilisée, particulièrement adaptée aux scénarios textuels.
Formule :
\[ \text{CosineSimilarity}(A, B) = \frac{A \cdot B} {\|A\|\|B\|} = \frac{\sum_{i=1}^{n} A_i B_i} {\sqrt{\sum_{i=1}^{n} A_i^2}\sqrt{\sum_{i=1}^{n} B_i^2}} \]
- Plage de résultats : -1 à 1, une valeur plus grande signifie une plus grande similarité
- Scénarios applicables : recherche sémantique textuelle, similarité de documents
Distance euclidienne
La distance euclidienne mesure la distance en ligne droite entre deux points ; plus la distance est petite, plus ils sont similaires.
Formule :
\[ d(A,B) = \sqrt{\sum_{i=1}^{n}(A_i-B_i)^2} \]
- Plage de résultats : 0 à ∞, une valeur plus petite signifie une plus grande similarité
- Scénarios applicables : recherche d'images, applications liées à la localisation
Produit scalaire
Le produit scalaire est la somme des produits des composantes des vecteurs, combinant à la fois les informations de direction et de magnitude.
Formule :
\[ A \cdot B = \sum_{i=1}^{n} A_i B_i \]
- Scénarios d'application : systèmes de recommandation (équivalent à la similarité cosinus lorsque les vecteurs sont normalisés)
Comparaison des trois méthodes
Exemple de code Python
L'exemple suivant illustre des implémentations Python de trois méthodes de calcul de similarité :
Exemple
# Similarité cosinus : mesure la similarité directionnelle
def cosine_similarity(a, b):
return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
# Distance euclidienne : mesure les différences de position absolues
def euclidean_distance(a, b):
return np.linalg.norm(a - b)
# Produit scalaire : combine direction et norme
def dot_product(a, b):
return np.dot(a, b)
# Vecteurs d'exemple
v1 = np.array([0.12, -0.54, 0.87, 0.03])
v2 = np.array([0.10, -0.50, 0.90, 0.05])
v3 = np.array([-0.80, 0.20, -0.30, 0.70])
print(f"v1 vs v2 similarité cosinus : {cosine_similarity(v1, v2):.4f}") # Environ 0.9997 (très similaires)
print(fv1 vs v3 similarité cosinus : {cosine_similarity(v1, v3):.4f}) # Environ -0.55 (pas similaires)
v1 vs v2 余弦相似度: 0.9997 v1 vs v3 余弦相似度: -0.5512
Algorithmes d'indexation vectorielle
Lorsque le volume de données est important (millions, milliards), calculer la similarité pour chaque donnée (recherche exhaustive) est trop lent. Les bases de données vectorielles utilisent des algorithmes d'indexation spécialisés pour accélérer les requêtes.
Recherche exhaustive (Flat / Brute-force)
La recherche exhaustive parcourt tous les vecteurs et calcule la similarité un par un.
| Dimension | Description |
|---|---|
| Principe | Parcourir tous les vecteurs, calculer la similarité un par un |
| Avantages | Résultats exacts à 100% |
| Inconvénients | Extrêmement lent avec de grands volumes de données, complexité O(n) |
| Applicable | Volume de données inférieur à 100k, exigences de précision extrêmement élevées |
IVF (Index de fichier inversé)
Étapes d'exécution de l'IVF :
- Phase d'entraînement : Utiliser K-Means pour regrouper tous les vecteurs en N clusters, enregistrer le centre de chaque cluster
- Phase de requête : Trouver d'abord les centres des clusters les plus proches, puis effectuer une recherche exacte uniquement dans ces clusters
HNSW (graphe hiérarchique navigable de type petit monde)
HNSW est actuellement l'algorithme d'indexation vectorielle le plus répandu, alliant vitesse et précision.
Idée centrale de HNSW :
- Construire une structure de graphe multicouche, clairsemée en haut, dense en bas
- Au moment de la requête, partir du point d'entrée de la couche supérieure et jouer à un « jeu de marelle » : sauter avidement vers les nœuds les plus proches à chaque couche, puis descendre à la couche suivante
- Réduit considérablement le nombre de nœuds à comparer, complexité temporelle approximativement O(log n)
Autres index courants
| Type d'index | Fonctionnalités | Scénarios applicables |
|---|---|---|
| Flat (force brute) | Précis mais lent | Petits ensembles de données, priorité à la précision |
| IVF_Flat | Recherche exacte après regroupement, rapide | Échelle moyenne à grande, mémoire suffisante |
| IVF_PQ | Compression par quantification, économise de la mémoire | Très grande échelle, mémoire limitée |
| HNSW | Rapide, haute précision, utilisation élevée de la mémoire | Le plus couramment utilisé, premier choix recommandé |
| ScaNN | Développé par Google, débit optimisé | Environnements de production à forte concurrence |
Comparaison des principales bases de données vectorielles
Ce qui suit est une comparaison horizontale des bases de données vectorielles les plus courantes actuellement disponibles, pour vous aider à faire des choix dans différents scénarios.
Conseils pour débutants : commencez avec Chroma ou pgvector. Le premier convient aux prototypes d'applications d'IA, le second aux projets disposant déjà de PostgreSQL.
Démarrage rapide : exemples Python
Ci-dessous, nous utilisons Chroma (le plus simple pour démarrer) pour démontrer le flux de travail CRUD complet.
Installation
Exemple
Exemple complet : construction d'un système de recherche sémantique de documents
Le code suivant montre de bout en bout comment utiliser Chroma pour construire un système de recherche documentaire basé sur la sémantique.
Exemple
from chromadb.utils import embedding_functions
# ─── 1. Initialiser le client ───────────────────────────────────────────
# Persister localement (recommandé)
client = chromadb.PersistentClient(path="./my_vector_db")
# Utiliser le modèle d'embedding OpenAI (vous pouvez aussi passer à un modèle local)
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
api_key="your-openai-api-key", # Obligatoire : remplacez par votre clé API
model_name="text-embedding-3-small" # 1536 dimensions, économique
)
# ─── 2. Créer une collection (comme une "table" dans les bases de données relationnelles)────────────────────────
collection = client.get_or_create_collection(
name="my_documents", # Nom de la collection
embedding_function=openai_ef, # Lier la fonction d'embedding
metadata={"hnsw:space": "cosine"} # Utiliser la similarité cosinus
)
# ─── 3. Insérer des documents ──────────────────────────────────────────────
documents = [
Python est un langage de programmation interprété orienté objet, largement utilisé en science des données et dans le développement de l'IA,
L'apprentissage automatique est un sous-domaine de l'intelligence artificielle qui permet aux ordinateurs d'apprendre des motifs à partir des données,
L'apprentissage profond utilise des réseaux de neurones multicouches et excelle dans la reconnaissance d'images et les tâches de NLP,
Les bases de données vectorielles sont spécialement conçues pour stocker des vecteurs de grande dimension et prendre en charge la recherche de similarité sémantique,
PostgreSQL est une puissante base de données relationnelle open source,
Redis est une base de données clé-valeur en mémoire à hautes performances, souvent utilisée pour la mise en cache,
La technologie de conteneurisation Docker permet aux applications de s'exécuter de manière cohérente dans n'importe quel environnement,
Git est un système de gestion de versions distribué et un outil fondamental pour le développement logiciel moderne,
]
ids = [f"doc_{i}" for i in range(len(documents))]
# Insertion par lots (Chroma appelle automatiquement le modèle d'embedding pour convertir en vecteurs avant le stockage)
collection.add(
documents=documents,
ids=ids,
metadatas=[{"source": "tutorial", "index": i} for i in range(len(documents))]
)
print(f{len(documents)} documents insérés)
已插入 8 条文档
Exemple
query = Comment faire de l'intelligence artificielle avec Python
results = collection.query(
query_texts=[query],
n_results=3, # Renvoyer les 3 plus similaires
include=["documents", "distances", "metadatas"]
)
print(f"\n"Requête : {query}")
print("-" * 50)
for i, (doc, dist) in enumerate(zip(
results["documents"][0],
results["distances"][0]
)):
similarity = 1 - dist # Convertir la distance cosinus en similarité
print(fRang {i+1} (similarité {similarity:.4f}) :)
print(f" {doc}")
print()
查询:如何用 Python 做人工智能 -------------------------------------------------- 第 1 名(相似度 0.9231):Python 是一种面向对象的解释型编程语言... 第 2 名(相似度 0.8874):机器学习是人工智能的子领域... 第 3 名(相似度 0.8612):深度学习使用多层神经网络...
Exemple
results_filtered = collection.query(
query_texts=[Technologie des bases de données],
n_results=2,
where={"source": "tutorial"}, # Rechercher uniquement parmi les documents où source=tutorial
include=["documents", "distances"]
)
# ─── 6. Mettre à jour les documents ──────────────────────────────────────────────
collection.update(
ids=["doc_0"],
documents=[Python est actuellement le langage de programmation le plus populaire, largement utilisé dans l'IA, l'analyse de données et le développement web],
metadatas=[{"source": "tutorial", "index": 0, "updated": True}]
)
# ─── 7. Supprimer les documents ──────────────────────────────────────────────
collection.delete(ids=["doc_7"]) # Supprimer les documents liés à Git
# ─── 8. Afficher les statistiques de la collection ──────────────────────────────────────────
print(fNombre de documents dans la collection actuelle : {collection.count()})
Sans utiliser d'API d'embedding tierces (entièrement local)
Si vous ne voulez pas utiliser l'API OpenAI, vous pouvez fonctionner entièrement hors ligne avec des modèles d'embedding locaux.
Exemple
from sentence_transformers import SentenceTransformer
# Utiliser des modèles d'embedding locaux (aucune clé API requise, entièrement hors ligne)
model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2") # Prend en charge le chinois
client = chromadb.Client()
collection = client.create_collection("local_demo")
texts = ["Le temps est agréable aujourd'hui", "Il fait beau et c'est parfait pour sortir", "Le marché boursier a bondi", "Il pourrait pleuvoir demain"]
# Générer manuellement les vecteurs avant l'insertion
embeddings = model.encode(texts).tolist()
collection.add(
embeddings=embeddings,
documents=texts,
ids=[f"id_{i}" for i in range(len(texts))]
)
# Requête
query_embedding = model.encode(["Quel temps fait-il aujourd'hui ?"⟦⟧tolist]).tolist()
results = collection.query(query_embeddings=query_embedding, n_results=2)
print(results["documents"])
# Sortie : [['Le temps est agréable aujourd'hui', 'Il fait beau et c'est parfait pour sortir']]
exemple pgvector (pour les utilisateurs de PostgreSQL)
Si votre projet utilise déjà PostgreSQL, pgvector est le moyen le plus léger d'intégrer.
Exemple
CREATE EXTENSION IF NOT EXISTS vector;
-- Créer une table : stocker les titres d'articles et leurs vecteurs (1536 dimensions)
CREATE TABLE articles (
id SERIAL PRIMARY KEY,
title TEXT NOT NULL,
content TEXT,
embedding vector(1536) -- Colonne vectorielle, 1536 dimensions
);
-- Créer un index HNSW pour accélérer les requêtes
CREATE INDEX ON articles
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);
-- Insérer des données (les vecteurs sont générés dans la couche applicative et passés en entrée)
INSERT INTO articles (title, embedding)
VALUES ('Guide du débutant Python', '[0.12, -0.54, 0.87, ...]'::vector);
-- Recherche sémantique : trouver les 5 articles les plus similaires
SELECT id, title,
1 - (embedding <=> '[0.10, -0.50, 0.90, ...]'::vector) AS similarity
FROM articles
ORDER BY embedding <=> '[0.10, -0.50, 0.90, ...]'::vector
LIMIT 5;
Remarque : <=> est un opérateur de distance vectorielle fourni par pgvector, utilisé pour calculer la distance cosinus. Soustrayez la distance cosinus de 1 pour obtenir la similarité cosinus.
Scénarios d'application typiques
Les bases de données vectorielles ont un large éventail d'applications à l'ère de l'IA ; voici un aperçu des six scénarios les plus typiques.
Architecture RAG (Retrieval-Augmented Generation)
RAG est actuellement l'un des principaux scénarios d'application des bases de données vectorielles. Voici son workflow principal :
Recommandations de sélection et bonnes pratiques
Arbre de décision de sélection
En fonction de votre situation spécifique, choisissez une base de données vectorielle appropriée selon l'arbre de décision suivant :
你的情况是什么?
│
├─── 已有 PostgreSQL,且数据量 < 500 万
│ └──> 用 pgvector,无缝集成,零额外运维
│
├─── 做 AI/LLM 应用原型,快速验证
│ └──> 用 Chroma,几行代码跑起来
│
├─── 需要生产级部署,性能优先,数据量 500 万 ~ 1 亿
│ └──> 用 Qdrant,Rust 实现,性能强
│
├─── 超大规模(> 1 亿),有 K8s 运维能力
│ └──> 用 Milvus,分布式,功能最全
│
└─── 团队没有运维能力,愿意付费
└──> 用 Pinecone 云服务,开箱即用
Choisir un modèle d'embedding
Choisir un modèle d'embedding adapté est la première étape clé des applications de bases de données vectorielles.
| Exigences | Modèle recommandé |
|---|---|
| Texte en chinois et en anglais (haute qualité) | OpenAI text-embedding-3-small |
| Texte chinois (local hors ligne) | BAAI/bge-large-zh-v1.5 |
| Multilingue universel. | paraphrase-multilingual-MiniLM-L12-v2 |
| Multimodal image-texte. | OpenAI CLIPsérie |
Conseils d'optimisation des performances
1. Insertion par lots : Insérer plusieurs entrées à la fois pour éviter les écritures fréquentes d'une seule entrée.
Exemple
collection.add(documents=docs_list, ids=ids_list)
# Non recommandé : boucle un par un (réindexe à chaque fois, extrêmement inefficace)
# for doc, id in zip(docs_list, ids_list):
# collection.add(documents=[doc], ids=[id])
2. Normalisation vectorielle : avant d'utiliser la similarité cosinus, normaliser les vecteurs à l'avance peut accélérer le calcul.
Exemple
def normalize(v):
"""Effectuer une normalisation L2 sur les vecteurs afin que la norme soit 1"""
return v / np.linalg.norm(v)
3. Définissez n_results raisonnablement : ne définissez pas aveuglément un top_k très grand ; 3~10 résultats suffisent généralement pour les scénarios RAG.
4. Faites bon usage du filtrage des métadonnées : combinez avec les conditions where lors de la recherche pour restreindre le périmètre de recherche.
Exemple
collection.query(
query_texts=["Gestion des exceptions Python"],
where={"category": "tech_doc"},
n_results=5
)
5. Reconstruisez régulièrement les index : après que le volume de données augmente, reconstruisez l'index HNSW en temps voulu pour maintenir les performances des requêtes.
Pièges courants
Voici les problèmes les plus courants rencontrés par les débutants lors de l'utilisation de bases de données vectorielles, ainsi que leurs solutions.
| Problème | Description | Solution |
|---|---|---|
| Le modèle d'embedding doit être cohérent | Le même modèle doit être utilisé pour l'insertion et la requête | Épingler la version du modèle dans le fichier de configuration |
| Incompatibilité de dimensions | Modèle changé mais collection non reconstruite | Supprimez et reconstruisez la collection lors d'un changement de modèle |
| Texte trop long | La plupart des modèles ont des limites de tokens (512~8192) | Découper d'abord les textes trop longs |
| Similarité imprécise | Le texte n’est pas découpé, donc la sémantique est diluée | Découpez les documents par paragraphe ou selon une longueur fixe |
| Démarrage à froid lent | Lorsque le volume de données est important, le chargement initial de l’index prend du temps | Préchauffez à l’avance, ou utilisez des index persistants |
Résumé
Passons en revue les points de connaissance essentiels de ce tutoriel :
Les bases de données vectorielles sont un élément crucial de l’infrastructure de l’ère de l’IA.
Il résout le problème de recherche de similarité sémantique que les bases de données traditionnelles ne peuvent pas gérer, et constitue un composant essentiel pour construire des systèmes RAG, des systèmes de recommandation et de recherche multimodale.
Recommandations de parcours d’apprentissage
- Étape 1 : Comprendre les concepts de vecteurs et d’embeddings, et exécuter l’exemple Chroma de cet article.
- Étape 2 : Essayez de créer un système simple de questions-réponses sur documents avec LangChain + Chroma.
- Étape 3 : Apprendre les algorithmes d’indexation tels que HNSW, et comprendre le compromis entre précision et vitesse.
- Étape 4 : En fonction des exigences réelles du projet, sélectionnez une base de données vectorielle appropriée et déployez-la dans un environnement de production.