Het splitsen van documenten aanpassen
Implementeer geavanceerde technieken voor het splitsen van tekst, waaronder semantische chunking en het verwerken van code of specifieke datastructuren.
Het splitsen van documenten aanpassen is een gratis LangChain / RAG / vectordatabases-les op CoddyKit. Dit is les 3 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject LangChain / RAG / vectordatabases. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus LangChain / RAG / vectordatabases bevat in totaal 4 lessen.
Waarom tekstsegmentatie aanpassen?
Bij het voorbereiden van documenten voor Retrieval Augmented Generation (RAG) is de manier waarop je ze in segmenten opsplitst cruciaal. Eenvoudige tekstsplitters zijn een goed begin, maar schieten vaak tekort bij complexe of sterk gestructureerde inhoud.
Door je strategie voor tekstsegmentatie aan te passen, behoud je de contextuele samenhang beter. Dat leidt tot nauwkeurigere zoekresultaten en betere antwoorden van LLM's.
Tekstsplitters aanpassen
De CharacterTextSplitter van LangChain is eenvoudig maar krachtig. Je kunt deze aanpassen door specifieke tekens als separator op te geven. Dit is nuttig wanneer je documenten unieke scheidingstekens hebben die je wilt respecteren, zoals een specifieke tag of een uniek patroon van regeleinden.
Door je eigen scheidingstekens te definiëren, zorg je voor logische onderbrekingen in plaats van willekeurige aantallen tekens.
from langchain.text_splitter import CharacterTextSplitter
class Main:
def run(self):
text = "Chapter 1: Intro.Section 1.1: Basics.Section 1.2: Advanced."
# Custom separator is "."
splitter = CharacterTextSplitter(
separator=".",
chunk_size=20,
chunk_overlap=0
)
chunks = splitter.split_text(text)
for i, chunk in enumerate(chunks):
print(f"Chunk {i+1}: {chunk}")
if __name__ == "__main__":
Main().run()Recursieve splitters verfijnen
De RecursiveCharacterTextSplitter probeert tekst te splitsen met behulp van een lijst met scheidingstekens in volgorde, waarbij de segmenten zo groot mogelijk blijven. Je kunt deze lijst aanpassen aan de inherente structuur van je document.
Je kunt bijvoorbeeld dubbele regeleinden prioriteit geven, gevolgd door enkele regeleinden, spaties en ten slotte afzonderlijke tekens.
from langchain.text_splitter import RecursiveCharacterTextSplitter
class Main:
def run(self):
text = "Hello there!\n\nThis is a paragraph.\nAnd this is another sentence."
# Custom list of separators
splitter = RecursiveCharacterTextSplitter(
separators=["\n\n", "\n", " ", ""],
chunk_size=40,
chunk_overlap=0
)
chunks = splitter.split_text(text)
for i, chunk in enumerate(chunks):
print(f"Chunk {i+1}: {chunk}")
if __name__ == "__main__":
Main().run()Inleiding tot semantische segmentatie
Wat als we tekst niet alleen op basis van aantallen tekens of scheidingstekens zouden splitsen, maar op basis van de betekenis ervan?
Semantische segmentatie is gericht op het maken van segmenten die volledige, samenhangende ideeën of onderwerpen vertegenwoordigen. Deze methode helpt voorkomen dat belangrijke concepten willekeurig over verschillende segmenten worden verdeeld, wat vaak gebeurt bij splitters met een vaste grootte of eenvoudige tekensplitsing.
Hoe semantische segmentatie werkt
Semantische segmentatie bestaat doorgaans uit een aantal stappen:
- Zinnen insluiten: Elke zin of kleine teksteenheid wordt omgezet in een vectorrepresentatie.
- Overeenkomst meten: De semantische overeenkomst tussen aangrenzende zinnen of eenheden wordt gemeten met behulp van hun vectorrepresentaties.
- Onderbrekingspunten bepalen: Segmenten worden gevormd waar de semantische overeenkomst aanzienlijk afneemt, wat wijst op een onderwerpwijziging of een verschuiving in de bespreking.
Hoewel LangChain niet standaard één 'semantische splitter' heeft, is dit een patroon dat je kunt opbouwen met embeddingmodellen en aangepaste logica.
Gespecialiseerde splitters voor code
Code heeft een unieke structuur, met functies, klassen, opmerkingen en specifieke syntaxis. Algemene tekstsplitters splitsen code vaak op onhandige plaatsen, waardoor de resulterende segmenten moeilijk te begrijpen of als context voor een LLM te gebruiken zijn.
LangChain biedt gespecialiseerde splitters voor verschillende programmeertalen. Deze splitters begrijpen de syntaxis van een taal en zorgen ervoor dat segmenten syntactisch betekenisvol zijn, bijvoorbeeld door een volledige functie of klasse bij elkaar te houden.
Demonstratie: Python-codesplitter
Met de methode RecursiveCharacterTextSplitter.from_language kun je een programmeertaal opgeven. De methode gebruikt vervolgens taalspecifieke scheidingstekens, zoals klassedefinities en functiedefinities, om intelligentere segmenten te maken.
Zo blijft code die aan een LLM wordt doorgegeven beter samenhangen.
from langchain.text_splitter import RecursiveCharacterTextSplitter, Language
class Main:
def run(self):
python_code = """
def calculate_sum(a, b):
# This function adds two numbers
return a + b
class MyCalculator:
def __init__(self):
self.result = 0
def add(self, num):
self.result += num
if __name__ == "__main__":
total = calculate_sum(5, 3)
print(f"Sum: {total}")
calc = MyCalculator()
calc.add(10)
print(f"Calc result: {calc.result}")
"""
# Initialize splitter for Python code
python_splitter = RecursiveCharacterTextSplitter.from_language(
language=Language.PYTHON,
chunk_size=100, # Adjust chunk size to see more splits
chunk_overlap=0
)
docs = python_splitter.create_documents([python_code])
for i, doc in enumerate(docs):
print(f"--- Chunk {i+1} ---")
print(doc.page_content)
if __name__ == "__main__":
Main().run()Verder dan code: andere structuren
LangChain biedt ook gespecialiseerde splitters voor andere gestructureerde indelingen, niet alleen voor code:
MarkdownTextSplitter: Begrijpt de syntaxis van Markdown, zoals koppen, codeblokken en lijsten, om logisch gegroepeerde segmenten te maken.LatexTextSplitter: Herkent LaTeX-secties, hoofdstukken en omgevingen en behoudt de academische structuur van het document.
Deze gespecialiseerde splitters zijn onmisbaar voor het verwerken van documenten waarbij de opmaak zelf belangrijke structurele informatie overbrengt.
Aangepaste splitterlogica maken
Voor echt unieke documentstructuren of bedrijfseigen gegevensindelingen moet je mogelijk je eigen logica voor splitsen implementeren. LangChain stelt je in staat om:
- Een subklasse van
TextSplitterte maken: Maak een nieuwe klasse die overerft vanTextSplitteren de methoden ervan overschrijft om aangepaste splitsingsregels te definiëren. - Een aangepaste functie te schrijven: Ontwikkel een functie die je tekst als invoer neemt en een lijst met segmenten retourneert op basis van je specifieke vereisten voor het parseren.
Deze aanpak biedt maximale flexibiliteit voor complexe regex-patronen, aangepaste scheidingstekens of geneste structuren die uniek zijn voor je dataset.
Controleer je begrip
Je hebt verschillende manieren geleerd om tekstsegmentatie aan te passen aan verschillende typen documenten. Laten we je kennis testen.
Samenvatting: aangepaste tekstsegmentatie
In deze les hebben we onderzocht hoe je verder kunt gaan dan eenvoudige tekstsegmentatie om uiteenlopende en complexe documenttypen effectiever te verwerken:
- We hebben Character- en Recursive Character-splitters aangepast met specifieke lijsten met scheidingstekens.
- We hebben het concept van semantische segmentatie geïntroduceerd voor splitsingen op basis van betekenis.
- We hebben geleerd over taalspecifieke splitters voor code, zoals Python en Java, en andere gestructureerde indelingen zoals Markdown en LaTeX.
- Tot slot hebben we de kracht en flexibiliteit besproken van het maken van volledig aangepaste splitsingslogica voor unieke gegevens.
Het beheersen van aangepaste splitsingsstrategieën is een cruciale stap bij het bouwen van nauwkeurige en robuuste RAG-toepassingen.
Leer LangChain / RAG / vectordatabases met een AI-tutor — gratis
Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.
- Cursussen
- 12
- Lessen
- 48
Veelgestelde vragen
Is de les “Het splitsen van documenten aanpassen” gratis?
Ja — de volledige tekst van “Het splitsen van documenten aanpassen” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus LangChain / RAG / vectordatabases wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus LangChain / RAG / vectordatabases bevat in totaal 4 lessen.
Wat leer ik in “Het splitsen van documenten aanpassen”?
Implementeer geavanceerde technieken voor het splitsen van tekst, waaronder semantische chunking en het verwerken van code of specifieke datastructuren. Je oefent met LangChain / RAG / vectordatabases door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.
Heb ik ervaring nodig om met LangChain / RAG / vectordatabases te beginnen?
Ervaring vooraf is niet nodig. LangChain / RAG / vectordatabases op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 3 van 4.
Hoe lang duurt de les “Het splitsen van documenten aanpassen”?
De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.
Kan ik code schrijven en uitvoeren in deze les over LangChain / RAG / vectordatabases?
Ja. Elke les over LangChain / RAG / vectordatabases bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.
Alle lessen in deze cursus
- Verschillende documenttypen laden
- Strategieën voor het splitsen van tekst begrijpen
- Het splitsen van documenten aanpassen
- Documentmetadata en filtering verwerken