Semantisches Chunking mit Embedding-Ähnlichkeit
Implementieren Sie semantisches Chunking, das Text an Stellen mit maximalem semantischem Abstand zwischen aufeinanderfolgenden Sätzen aufteilt und thematisch zusammengehörige Inhalte beibehält.
Semantisches Chunking mit Embedding-Ähnlichkeit ist eine kostenlose AI Engineering Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Engineering Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Was ist semantisches Chunking?
Semantisches Chunking ist eine Technik, die Text an Stellen aufteilt, an denen sich das Thema deutlich ändert, statt nach einer festen Anzahl von Zeichen. Anstatt zu fragen: 'Haben wir 500 Token erreicht?', wird gefragt: 'Gehört der nächste Satz zum selben Thema wie der aktuelle Chunk?' – die Antwort wird mithilfe der Ähnlichkeit von Embeddings ermittelt.
Die Grundidee: Abstand zwischen Embeddings
Der Algorithmus bettet jeden Satz (oder eine kleine Gruppe von Sätzen) ein und berechnet die Kosinusähnlichkeit zwischen den Embeddings aufeinanderfolgender Sätze. Wenn die Ähnlichkeit stark abfällt – das Thema sich also geändert hat –, fügt der Algorithmus eine Chunk-Grenze ein. Sätze, die dasselbe Konzept behandeln, bleiben im selben Chunk zusammen.
Schritt 1: Embeddings auf Satzebene
Im ersten Schritt wird das Dokument mithilfe eines Satz-Tokenizers in einzelne Sätze aufgeteilt. Anschließend wird jeder Satz mit einem schnellen Embedding-Modell eingebettet. Sie benötigen Embeddings auf Satzebene, nicht auf Dokumentebene, damit Sie beim Durchlaufen des Textes lokale Themenwechsel erkennen können.
from openai import OpenAI
from nltk.tokenize import sent_tokenize
import numpy as np
client = OpenAI()
def embed_sentences(text):
sentences = sent_tokenize(text)
response = client.embeddings.create(
model='text-embedding-3-small',
input=sentences
)
vectors = [item.embedding for item in response.data]
return sentences, np.array(vectors)Schritt 2: Benachbarte Ähnlichkeit berechnen
Sobald die Satz-Embeddings vorliegen, berechnen Sie die Kosinusähnlichkeit für jedes aufeinanderfolgende Paar: Satz i und Satz i+1. Das Ergebnis ist eine Liste von Ähnlichkeitswerten, einen pro Satzgrenze. Niedrige Werte zeigen an, dass die benachbarten Sätze unterschiedliche Themen behandeln – dies sind mögliche Trennstellen.
def cosine_similarity_adjacent(vectors):
similarities = []
for i in range(len(vectors) - 1):
a = vectors[i]
b = vectors[i + 1]
sim = np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))
similarities.append(sim)
return similaritiesSchritt 3: Trennstellen erkennen
Eine Trennstelle ist eine Satzgrenze, an der die Ähnlichkeit unter einen Schwellenwert fällt. Sie können einen festen Schwellenwert (z. B. 0.6) oder einen perzentilbasierten Schwellenwert verwenden, der sich an das Dokument anpasst – teilen Sie beispielsweise immer dann auf, wenn die Ähnlichkeit unter dem 25. Perzentil aller Ähnlichkeitswerte in diesem Dokument liegt.
def find_breakpoints(similarities, percentile=25):
threshold = np.percentile(similarities, percentile)
breakpoints = []
for i, sim in enumerate(similarities):
if sim < threshold:
breakpoints.append(i + 1) # split AFTER sentence i
return breakpointsSchritt 4: Chunks zusammensetzen
Nachdem die Trennstellen erkannt wurden, können Sie Chunks erstellen, indem Sie die aufeinanderfolgenden Sätze zwischen den einzelnen Trennstellen verbinden. Jeder resultierende Chunk enthält eine zusammenhängende Folge von Sätzen zum selben Thema. Die Chunk-Grenzen entsprechen den natürlichen Themenübergängen im ursprünglichen Dokument.
def assemble_chunks(sentences, breakpoints):
chunks = []
start = 0
for bp in breakpoints:
chunk = ' '.join(sentences[start:bp])
chunks.append(chunk)
start = bp
chunks.append(' '.join(sentences[start:])) # last chunk
return chunksVollständiges Beispiel für einen semantischen Chunker
Alles zusammengeführt in einer einzigen Funktion: Sätze einbetten, benachbarte Ähnlichkeiten berechnen, Trennstellen finden und Chunks zusammensetzen. Die Ausgabe ist eine Liste semantisch zusammenhängender Textabschnitte, die als vollständige Chunks eingebettet und in Ihrer Vektordatenbank gespeichert werden können.
def semantic_chunk(text, percentile=25):
sentences, vectors = embed_sentences(text)
similarities = cosine_similarity_adjacent(vectors)
breakpoints = find_breakpoints(similarities, percentile)
chunks = assemble_chunks(sentences, breakpoints)
return chunks
chunks = semantic_chunk(my_document)
print(f'Produced {len(chunks)} semantic chunks')
for i, c in enumerate(chunks):
print(f'Chunk {i+1}: {len(c)} chars')Den Perzentil-Schwellenwert auswählen
Der Perzentil-Schwellenwert bestimmt die Granularität der Chunks. Ein niedriges Perzentil (z. B. das 10.) bedeutet, dass nur bei größeren Themenwechseln aufgeteilt wird – dadurch entstehen weniger, längere Chunks. Ein hohes Perzentil (z. B. das 40.) teilt aggressiver auf – dadurch entstehen viele kleine, stark fokussierte Chunks. Stimmen Sie den Wert anhand Ihres Evaluationsdatensatzes für die Trefferquote des Abrufs ab.
LangChain SemanticChunker
LangChain bietet einen integrierten SemanticChunker, der diesen Algorithmus implementiert. Er akzeptiert ein Embedding-Modell und einen Typ für den Schwellenwert der Trennstellen. Dadurch müssen Sie den Algorithmus nicht von Grund auf implementieren; außerdem lässt er sich direkt in die Dokument-Loader und Vektorspeicher von LangChain integrieren.
from langchain_experimental.text_splitter import SemanticChunker
from langchain_openai import OpenAIEmbeddings
embeddings = OpenAIEmbeddings(model='text-embedding-3-small')
chunker = SemanticChunker(
embeddings,
breakpoint_threshold_type='percentile',
breakpoint_threshold_amount=25
)
chunks = chunker.create_documents([long_document_text])
print(f'{len(chunks)} semantic chunks created')Abwägungen gegenüber Chunking mit fester Größe
Semantisches Chunking erzeugt hochwertigere Chunks mit besserem thematischem Zusammenhang, ist aber teurer: Jeder Satz muss eingebettet werden, nur um die Chunk-Grenzen zu bestimmen – noch bevor die Chunks überhaupt indexiert werden. Bei einem 100-seitigen Dokument bedeutet das Tausende von Embedding-Aufrufen allein für das Chunking. Verwenden Sie semantisches Chunking, wenn die Abrufqualität wichtiger ist als die Geschwindigkeit der Indexierung.
Wann semantisches Chunking verwendet werden sollte
Semantisches Chunking eignet sich besonders für langformatige narrative Inhalte – Blogbeiträge, Forschungsarbeiten, juristische Dokumente und Bücher –, bei denen Themen auf natürliche Weise wechseln. Für stark strukturierte Dokumente wie Produktkataloge, FAQ-Listen oder Code-Dateien ist es weniger erforderlich. Diese lassen sich besser mit dokumentenbewussten Splittern verarbeiten, die die Struktur direkt berücksichtigen.
Kurzer Wissenstest
Testen Sie Ihr Verständnis des semantischen Chunkings aus dieser Lektion.
Zusammenfassung der Lektion
In dieser Lektion haben Sie gelernt: Semantisches Chunking verwendet die Ähnlichkeit von Embeddings, um Themenwechsel zu erkennen, der Perzentil-Schwellenwert steuert die Granularität und LangChains SemanticChunker implementiert diese Funktion direkt. Als Nächstes untersuchen wir Parent-Child-Chunking, das kleine, präzise Chunks mit großen, kontextreichen übergeordneten Passagen kombiniert.
Häufig gestellte Fragen
Ist die Lektion „Semantisches Chunking mit Embedding-Ähnlichkeit“ kostenlos?
Ja — der vollständige Text von „Semantisches Chunking mit Embedding-Ähnlichkeit“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Engineering Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Engineering Academy-Kurs umfasst insgesamt 4 Lektionen.
Was lerne ich in „Semantisches Chunking mit Embedding-Ähnlichkeit“?
Implementieren Sie semantisches Chunking, das Text an Stellen mit maximalem semantischem Abstand zwischen aufeinanderfolgenden Sätzen aufteilt und thematisch zusammengehörige Inhalte beibehält. Du übst AI Engineering Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.
Brauche ich Erfahrung, um AI Engineering Academy zu starten?
Keine Vorkenntnisse erforderlich. AI Engineering Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.
Wie lange dauert die Lektion „Semantisches Chunking mit Embedding-Ähnlichkeit“?
Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.
Kann ich in dieser AI Engineering Academy-Lektion Code schreiben und ausführen?
Ja. Jede AI Engineering Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.
Alle Lektionen in diesem Kurs
- Warum naives Chunking den Abruf verschlechtert
- Semantisches Chunking mit Embedding-Ähnlichkeit
- Parent-Child- und Small-to-Big-Retrieval
- Dokumentspezifische Strategien für Code und HTML