Vektordatenbank
Eine Vektordatenbank ist ein Datenbanksystem, das speziell für das Speichern, Indizieren und Abrufen hochdimensionaler Vektordaten entwickelt wurde.
Man kann es sich so vorstellen: Dinge mit ähnlicher Bedeutung zusammen zu speichern und schnell diejenigen zu finden, die einem gegebenen Element am ähnlichsten sind.
Im Gegensatz zu traditionellen Datenbanken, die durch exakte Übereinstimmung abfragen (WHERE name = 'Alice'), fragen Vektordatenbanken durch Ähnlichkeit ab (die 10 Bilder finden, die diesem Bild am ähnlichsten sind).
Eine intuitive Analogie
Stellen Sie sich ein Bibliotheksszenario vor:
| Datenbanktyp | Abrufmethode | Analogie |
|---|---|---|
| Traditionelle Datenbank | Exakte Suche nach Buchnummer und Titel | Ein Buch mit einer bestimmten Nummer finden |
| Vektordatenbank | Suche nach inhaltlicher Relevanz | Finde "alle Science-Fiction-Romane, die im Stil ähnlich zu The Three-Body Problem sind" |
Diese semantische Ähnlichkeit ist genau das Kernproblem, das Vektordatenbanken lösen.
Warum brauchen wir eine Vektordatenbank?
Bevor wir in technische Details eintauchen, wollen wir zunächst verstehen, welche Probleme Vektordatenbanken lösen.
Grenzen traditioneller Datenbanken
Traditionelle relationale Datenbanken (MySQL, PostgreSQL) sind sehr gut für die Verarbeitung strukturierter Daten geeignet, aber sie stoßen an ihre Grenzen, wenn sie mit den folgenden Anforderungen konfrontiert werden:
- Bildsuche (visuell ähnliche Bilder finden)
- Semantische Suche (wenn ein Benutzer nach "Apple phone" sucht, kann sie verwandte Inhalte zu "iPhone" finden)
- Empfehlungssysteme (finde "Lieder, die im Stil denen ähneln, die dir gefallen")
- Anomalieerkennung (finde "Logs, die am stärksten vom normalen Verhalten abweichen")
Die Gemeinsamkeit dieser Probleme ist die Notwendigkeit, die "Bedeutung" von Inhalten zu verstehen, anstatt einen wörtlichen Abgleich durchzuführen.
Probleme traditioneller Ansätze
用 LIKE '%苹果%' 搜索 → 找不到 "iPhone"、"Apple" 用全文索引搜索 → 找不到语义相关但用词不同的内容
Vergleichsdiagramm
Das folgende Diagramm zeigt intuitiv die grundlegenden Unterschiede in den Abfragemethoden zwischen traditionellen Datenbanken und Vektordatenbanken.
Kernkonzepte: Vektoren und Embeddings
Das Verständnis von Vektoren und Embeddings ist der erste Schritt zur Beherrschung von Vektordatenbanken.
Was ist ein Vektor?
In der Mathematik ist ein Vektor eine geordnete Menge von Zahlen.
[0.12, -0.54, 0.87, 0.03, ..., 0.61] ← 这就是一个向量
Im maschinellen Lernen repräsentiert diese Zahlenmenge die semantischen Merkmale eines Objekts, typischerweise mit Dimensionen von 128 bis 4096.
Was ist ein Embedding?
Embedding ist der Prozess und das Ergebnis der Umwandlung realer Objekte (Text, Bilder, Audio usw.) in Vektoren.
Diese Umwandlung wird von einem Embedding-Modell durchgeführt, dessen Kernidee ist: Objekte mit ähnlicher Semantik haben Vektoren, die im Raum näher beieinander liegen.
Ähnliche Semantik bedeutet ähnliche Vektoren
Verwenden Sie ein vereinfachtes 2D-Beispiel zum Verständnis (in Wirklichkeit sind es Hunderte bis Tausende von Dimensionen):
Zentrale Erkenntnis: Zwei Vektoren, die im Vektorraum nahe beieinander liegen, haben auch semantisch ähnlichen ursprünglichen Inhalt. Dies ist die Grundlage aller Fähigkeiten von Vektordatenbanken.
Methoden zur Ähnlichkeitsberechnung
Der Kern beim Finden des "ähnlichsten Vektors" besteht darin, die Distanz oder Ähnlichkeit zwischen zwei Vektoren zu berechnen. Hier sind die drei am häufigsten verwendeten Methoden.
Kosinus-Ähnlichkeit
Die Kosinus-Ähnlichkeit misst den Winkel zwischen zwei Vektoren und ignoriert deren Betrag. Sie ist die am häufigsten verwendete Methode und eignet sich besonders für Textszenarien.
Formel:
\[ \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}} \]
- Ergebnisbereich: -1 bis 1, größerer Wert bedeutet ähnlicher
- Anwendungsszenarien: semantische Textsuche, Dokumentenähnlichkeit
Euklidische Distanz
Die euklidische Distanz misst die geradlinige Entfernung zwischen zwei Punkten; je kleiner die Distanz, desto ähnlicher sind sie.
Formel:
\[ d(A,B) = \sqrt{\sum_{i=1}^{n}(A_i-B_i)^2} \]
- Ergebnisbereich: 0 bis ∞, kleinerer Wert bedeutet ähnlicher
- Anwendungsszenarien: Bildsuche, ortsbezogene Anwendungen
Skalarprodukt
Das Skalarprodukt ist die Summe der Produkte der Vektorkomponenten und kombiniert Informationen über Richtung und Betrag.
Formel:
\[ A \cdot B = \sum_{i=1}^{n} A_i B_i \]
- Anwendungsszenarien: Empfehlungssysteme (entspricht der Kosinus-Ähnlichkeit, wenn Vektoren normalisiert sind)
Vergleich der drei Methoden
Python-Codebeispiel
Das folgende Beispiel demonstriert Python-Implementierungen dreier Ähnlichkeitsberechnungsmethoden:
Beispiel
# Kosinus-Ähnlichkeit: misst die Richtungsähnlichkeit
def cosine_similarity(a, b):
return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
# Euklidische Distanz: misst absolute Positionsunterschiede
def euclidean_distance(a, b):
return np.linalg.norm(a - b)
# Skalarprodukt: kombiniert Richtung und Betrag
def dot_product(a, b):
return np.dot(a, b)
# Beispielvektoren
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 Kosinus-Ähnlichkeit: {cosine_similarity(v1, v2):.4f}") # Ungefähr 0.9997 (sehr ähnlich)
print(fv1 vs v3 Kosinus-Ähnlichkeit: {cosine_similarity(v1, v3):.4f}) # Ungefähr -0.55 (nicht ähnlich)
v1 vs v2 余弦相似度: 0.9997 v1 vs v3 余弦相似度: -0.5512
Vektorindexierungsalgorithmen
Wenn das Datenvolumen groß ist (Millionen, Milliarden), ist die Berechnung der Ähnlichkeit für jedes Datenelement (Brute-Force-Suche) zu langsam. Vektordatenbanken verwenden spezialisierte Indexierungsalgorithmen, um Abfragen zu beschleunigen.
Brute-Force-Suche (Flat / Brute-Force)
Die Brute-Force-Suche durchläuft alle Vektoren und berechnet die Ähnlichkeit nacheinander.
| Dimension | Beschreibung |
|---|---|
| Prinzip | Alle Vektoren durchlaufen, Ähnlichkeit einzeln berechnen |
| Vorteile | 100% genaue Ergebnisse |
| Nachteile | Extrem langsam bei großen Datenmengen, O(n)-Komplexität |
| Anwendbar | Datenvolumen unter 100k, extrem hohe Genauigkeitsanforderungen |
IVF (Inverted File Index)
IVF-Ausführungsschritte:
- Trainingsphase: K-Means verwenden, um alle Vektoren in N Cluster zu gruppieren, und den Mittelpunkt jedes Clusters aufzeichnen
- Abfragephase: Zuerst die Mittelpunkte der nächstgelegenen Cluster finden, dann die exakte Suche nur innerhalb dieser Cluster durchführen
HNSW (Hierarchical Navigable Small World graph)
HNSW ist derzeit der am weitesten verbreitete Vektorindexierungsalgorithmus und balanciert Geschwindigkeit und Genauigkeit aus.
HNSW-Kernidee:
- Eine mehrschichtige Graphstruktur aufbauen, oben dünn besetzt, unten dicht besetzt
- Zur Abfragezeit vom Einstiegspunkt der obersten Ebene starten und ein "Hüpfspiel" spielen: gierig zu näheren Knoten auf jeder Ebene springen, dann zur nächsten Ebene absteigen
- Reduziert die Anzahl der zu vergleichenden Knoten erheblich, Zeitkomplexität ungefähr O(log n)
Andere gängige Indizes
| Indextyp | Funktionen | Anwendbare Szenarien |
|---|---|---|
| Flat (Brute-Force) | Genau, aber langsam | Kleine Datensätze, Genauigkeit an erster Stelle |
| IVF_Flat | Exakte Suche nach dem Clustering, schnell | Mittlere bis große Skalierung, ausreichend Speicher |
| IVF_PQ | Quantisierungskomprimierung, spart Speicher | Extrem große Skalierung, speicherbeschränkt |
| HNSW | Schnell, hohe Genauigkeit, hoher Speicherverbrauch | Am häufigsten verwendet, empfohlene erste Wahl |
| ScaNN | Von Google entwickelt, optimierter Durchsatz | Produktionsumgebungen mit hoher Nebenläufigkeit |
Vergleich gängiger Vektordatenbanken
Im Folgenden finden Sie einen horizontalen Vergleich der derzeit gängigsten Vektordatenbanken, der Ihnen bei der Auswahl in verschiedenen Szenarien hilft.
Einsteigertipp: Beginnen Sie mit Chroma oder pgvector. Ersteres eignet sich für KI-Anwendungsprototypen, Letzteres für Projekte mit vorhandenem PostgreSQL.
Schnellstart: Python-Beispiele
Im Folgenden verwenden wir Chroma (am einfachsten für den Einstieg), um den vollständigen CRUD-Workflow zu demonstrieren.
Installation
Beispiel
Vollständiges Beispiel: Aufbau eines semantischen Dokumentsuchsystems
Der folgende Code zeigt End-to-End, wie Sie mit Chroma ein semantikbasiertes Dokumentsuchsystem erstellen.
Beispiel
from chromadb.utils import embedding_functions
# ─── 1. Client initialisieren ───────────────────────────────────────────
# Lokal persistieren (empfohlen)
client = chromadb.PersistentClient(path="./my_vector_db")
# OpenAI-Embedding-Modell verwenden (kann auch auf ein lokales Modell umgestellt werden)
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
api_key="your-openai-api-key", # Erforderlich: durch Ihren API Key ersetzen
model_name="text-embedding-3-small" # 1536 Dimensionen, kosteneffizient
)
# ─── 2. Collection erstellen (wie eine "Tabelle" in relationalen Datenbanken)────────────────────────
collection = client.get_or_create_collection(
name="my_documents", # Collection-Name
embedding_function=openai_ef, # Embedding-Funktion binden
metadata={"hnsw:space": "cosine"} # Kosinus-Ähnlichkeit verwenden
)
# ─── 3. Dokumente einfügen ──────────────────────────────────────────────
documents = [
Python ist eine objektorientierte interpretierte Programmiersprache, die häufig in Data Science und KI-Entwicklung verwendet wird,
Maschinelles Lernen ist ein Teilgebiet der künstlichen Intelligenz, das Computern ermöglicht, Muster aus Daten zu lernen,
Deep Learning verwendet mehrschichtige neuronale Netze und erzielt hervorragende Ergebnisse bei Bilderkennung und NLP-Aufgaben,
Vektordatenbanken sind speziell dafür entwickelt, hochdimensionale Vektoren zu speichern und semantische Ähnlichkeitssuche zu unterstützen,
PostgreSQL ist eine leistungsstarke relationale Open-Source-Datenbank,
Redis ist eine In-Memory-Hochleistungs-Key-Value-Datenbank, die häufig zum Caching verwendet wird,
Docker-Containerisierungstechnologie ermöglicht es, Anwendungen in jeder Umgebung konsistent auszuführen,
Git ist ein verteiltes Versionskontrollsystem und ein grundlegendes Werkzeug für die moderne Softwareentwicklung,
]
ids = [f"doc_{i}" for i in range(len(documents))]
# Batch-Einfügung (Chroma ruft automatisch das Embedding-Modell auf, um vor dem Speichern in Vektoren umzuwandeln)
collection.add(
documents=documents,
ids=ids,
metadatas=[{"source": "tutorial", "index": i} for i in range(len(documents))]
)
print(fEingefügt {len(documents)} Dokumente)
已插入 8 条文档
Beispiel
query = Wie setzt man künstliche Intelligenz mit Python um
results = collection.query(
query_texts=[query],
n_results=3, # Die 3 ähnlichsten Ergebnisse zurückgeben
include=["documents", "distances", "metadatas"]
)
print(f"\n"Abfrage: {query}")
print("-" * 50)
for i, (doc, dist) in enumerate(zip(
results["documents"][0],
results["distances"][0]
)):
similarity = 1 - dist # Kosinus-Distanz in Ähnlichkeit umwandeln
print(fRang {i+1} (Ähnlichkeit {similarity:.4f}):)
print(f" {doc}")
print()
查询:如何用 Python 做人工智能 -------------------------------------------------- 第 1 名(相似度 0.9231):Python 是一种面向对象的解释型编程语言... 第 2 名(相似度 0.8874):机器学习是人工智能的子领域... 第 3 名(相似度 0.8612):深度学习使用多层神经网络...
Beispiel
results_filtered = collection.query(
query_texts=[Datenbanktechnologie],
n_results=2,
where={"source": "tutorial"}, # Nur unter Dokumenten suchen, bei denen source=tutorial
include=["documents", "distances"]
)
# ─── 6. Dokumente aktualisieren ──────────────────────────────────────────────
collection.update(
ids=["doc_0"],
documents=[Python ist derzeit die beliebteste Programmiersprache und wird umfassend in KI, Datenanalyse und Webentwicklung eingesetzt],
metadatas=[{"source": "tutorial", "index": 0, "updated": True}]
)
# ─── 7. Dokumente löschen ──────────────────────────────────────────────
collection.delete(ids=["doc_7"]) # Git-bezogene Dokumente löschen
# ─── 8. Sammlungsstatistiken anzeigen ──────────────────────────────────────────
print(fAktuelle Dokumentanzahl der Sammlung: {collection.count()})
Ohne Verwendung von Embedding-APIs von Drittanbietern (vollständig lokal)
Wenn Sie die OpenAI API nicht verwenden möchten, können Sie mit lokalen Embedding-Modellen vollständig offline arbeiten.
Beispiel
from sentence_transformers import SentenceTransformer
# Lokale Embedding-Modelle verwenden (kein API-Schlüssel erforderlich, vollständig offline)
model = SentenceTransformer("paraphrase-multilingual-MiniLM-L12-v2") # Unterstützt Chinesisch
client = chromadb.Client()
collection = client.create_collection("local_demo")
texts = ["Das Wetter ist heute schön", "Es ist sonnig und perfekt zum Ausgehen", "Der Aktienmarkt ist stark angestiegen", "Morgen könnte es regnen"]
# Vektoren vor dem Einfügen manuell generieren
embeddings = model.encode(texts).tolist()
collection.add(
embeddings=embeddings,
documents=texts,
ids=[f"id_{i}" for i in range(len(texts))]
)
# Abfrage
query_embedding = model.encode(["Wie ist das Wetter heute?"]).tolist()
results = collection.query(query_embeddings=query_embedding, n_results=2)
print(results["documents"])
# Ausgabe: [['Das Wetter ist heute schön', 'Es ist sonnig und perfekt zum Ausgehen']]
pgvector-Beispiel (für PostgreSQL-Benutzer)
Wenn Ihr Projekt bereits PostgreSQL verwendet, ist pgvector die einfachste Möglichkeit zur Integration.
Beispiel
CREATE EXTENSION IF NOT EXISTS vector;
-- Tabelle erstellen: Artikeltitel und ihre Vektoren speichern (1536 Dimensionen)
CREATE TABLE articles (
id SERIAL PRIMARY KEY,
title TEXT NOT NULL,
content TEXT,
embedding vector(1536) -- Vektorspalte, 1536 Dimensionen
);
-- HNSW-Index erstellen, um Abfragen zu beschleunigen
CREATE INDEX ON articles
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 64);
-- Daten einfügen (Vektoren werden in der Anwendungsschicht erzeugt und übergeben)
INSERT INTO articles (title, embedding)
VALUES ('Python-Einsteigerleitfaden', '[0.12, -0.54, 0.87, ...]'::vector);
-- Semantische Suche: die 5 ähnlichsten Artikel finden
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;
Hinweis: <=> ist ein von pgvector bereitgestellter Vektor-Distanzoperator, mit dem der Kosinusabstand berechnet wird. Subtrahieren Sie den Kosinusabstand von 1, um die Kosinusähnlichkeit zu erhalten.
Typische Anwendungsszenarien
Vektordatenbanken haben im KI-Zeitalter ein breites Anwendungsspektrum; hier ist ein Überblick über die sechs typischsten Szenarien.
RAG-Architektur (Retrieval-Augmented Generation)
RAG ist derzeit eines der primären Anwendungsszenarien für Vektordatenbanken. Unten ist sein Kernworkflow:
Auswahlempfehlungen und Best Practices
Auswahl-Entscheidungsbaum
Wähle basierend auf deiner spezifischen Situation eine geeignete Vektordatenbank gemäß dem folgenden Entscheidungsbaum aus:
你的情况是什么?
│
├─── 已有 PostgreSQL,且数据量 < 500 万
│ └──> 用 pgvector,无缝集成,零额外运维
│
├─── 做 AI/LLM 应用原型,快速验证
│ └──> 用 Chroma,几行代码跑起来
│
├─── 需要生产级部署,性能优先,数据量 500 万 ~ 1 亿
│ └──> 用 Qdrant,Rust 实现,性能强
│
├─── 超大规模(> 1 亿),有 K8s 运维能力
│ └──> 用 Milvus,分布式,功能最全
│
└─── 团队没有运维能力,愿意付费
└──> 用 Pinecone 云服务,开箱即用
Auswahl eines Embedding-Modells
Die Auswahl eines geeigneten Embedding-Modells ist der entscheidende erste Schritt in Vektordatenbank-Anwendungen.
| Anforderungen | Empfohlenes Modell |
|---|---|
| Chinesischer und englischer Text (hohe Qualität) | OpenAI text-embedding-3-small |
| Chinesischer Text (lokal offline) | BAAI/bge-large-zh-v1.5 |
| Mehrsprachig universell. | paraphrase-multilingual-MiniLM-L12-v2 |
| Bild-Text-multimodal. | OpenAI CLIPSerie |
Tipps zur Leistungsoptimierung
1. Batch-Einfügung: Füge mehrere Einträge auf einmal ein, um häufige Einzeleintragsschreibvorgänge zu vermeiden.
Beispiel
collection.add(documents=docs_list, ids=ids_list)
# Nicht empfohlen: elementweises Durchlaufen (indiziert jedes Mal neu, extrem ineffizient)
# for doc, id in zip(docs_list, ids_list):
# collection.add(documents=[doc], ids=[id])
2. Vektornormalisierung: Wenn du Vektoren vor der Verwendung der Kosinus-Ähnlichkeit normalisierst, kann das die Berechnung beschleunigen.
Beispiel
def normalize(v):
"""Führe eine L2-Normalisierung auf Vektoren durch, sodass die Norm 1 ist"""
return v / np.linalg.norm(v)
3. Setze n_results vernünftig: Setze nicht blind ein sehr großes top_k; 3~10 Ergebnisse sind normalerweise ausreichend für RAG-Szenarien.
4. Nutze Metadaten-Filterung gut: Kombiniere sie während der Suche mit where-Bedingungen, um den Suchbereich einzugrenzen.
Beispiel
collection.query(
query_texts=["Python-Ausnahmebehandlung"],
where={"category": "tech_doc"},
n_results=5
)
5. Baue Indizes regelmäßig neu auf: Nachdem das Datenvolumen gewachsen ist, baue den HNSW-Index rechtzeitig neu auf, um die Abfrageleistung aufrechtzuerhalten.
Häufige Fallstricke
Im Folgenden findest du die häufigsten Probleme, auf die Anfänger bei der Verwendung von Vektordatenbanken stoßen, zusammen mit Lösungen.
| Problem | Beschreibung | Lösung |
|---|---|---|
| Embedding-Modell muss konsistent sein | Dasselbe Modell muss für Einfügen und Abfrage verwendet werden | Fixiere die Modellversion in der Konfigurationsdatei |
| Dimensionsabweichung | Modelle gewechselt, aber die Collection nicht neu aufgebaut | Lösche und baue die Collection neu auf, wenn du Modelle wechselst |
| Text zu lang | Die meisten Modelle haben Token-Limits (512~8192) | Zerlege übermäßig langen Text zuerst in Chunks |
| Ungenaue Ähnlichkeit | Text wird nicht in Chunks aufgeteilt, wodurch die Semantik verwässert wird | Teile Dokumente nach Absatz oder fester Länge auf |
| Langsamer Kaltstart | Bei großem Datenvolumen dauert das initiale Laden des Index einige Zeit | Wärme im Voraus vor, oder verwende persistente Indizes |
Zusammenfassung
Lass uns die Kernpunkte dieses Tutorials wiederholen:
Vektordatenbanken sind ein entscheidender Teil der Infrastruktur des KI-Zeitalters.
Es löst das Problem der semantischen Ähnlichkeitssuche, das traditionelle Datenbanken nicht bewältigen können, und ist eine Kernkomponente für den Aufbau von RAG-Systemen, Empfehlungssystemen und multimodaler Suche.
Empfehlungen zum Lernpfad
- Schritt 1: Verstehe die Konzepte von Vektoren und Embeddings und führe das Chroma-Beispiel aus diesem Artikel aus.
- Schritt 2: Versuche, ein einfaches Dokumenten-Q&A-System mit LangChain + Chroma zu erstellen.
- Schritt 3: Lerne Indizierungsalgorithmen wie HNSW kennen und verstehe den Kompromiss zwischen Genauigkeit und Geschwindigkeit.
- Schritt 4: Wähle basierend auf den tatsächlichen Projektanforderungen eine geeignete Vektordatenbank aus und stelle sie in einer Produktionsumgebung bereit.