Omgaan met complexe documentstructuren
Implementeer strategieën om informatie uit complexe documenten, zoals tabellen of geneste secties, effectief op te splitsen en op te halen.
Omgaan met complexe documentstructuren is een gratis LLM-toepassingen in productie (RAG + vectordatabase + caching)-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 LLM-toepassingen in productie (RAG + vectordatabase + caching). Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus LLM-toepassingen in productie (RAG + vectordatabase + caching) bevat in totaal 4 lessen.
Verder dan eenvoudige tekst: complexe documenten
Bij het bouwen van RAG-systemen werken we vaak met documenten die niet alleen uit doorlopende tekst bestaan. Denk aan financiële rapporten, wetenschappelijke artikelen of juridische contracten.
Deze documenten bevatten vaak tabellen, geneste secties (zoals hoofdstukken en subhoofdstukken) en andere ingewikkelde structuren. Standaardmethoden voor tekst opdelen hebben hier vaak moeite mee: ze verbreken de context, waardoor informatie minder effectief kan worden opgehaald.
Tabellen: een uitdaging voor RAG
Tabellen zijn een goed voorbeeld van complexe structuren. Ze presenteren gegevens in een gestructureerde, rasterachtige vorm, waarbij de relaties tussen rijen en kolommen cruciaal zijn.
- Verloren context: Een eenvoudige opdeler op basis van tekens kan een tabelrij opsplitsen, waardoor een waarde van de kop wordt gescheiden en het deel betekenisloos wordt.
- Slechte embeddings: Zonder de juiste context geven de gegenereerde embeddings voor fragmenten van tabellen de gegevens mogelijk niet nauwkeurig weer.
Strategieën voor het opdelen van tabellen
Om tabellen effectief te verwerken, hebben we specifieke strategieën nodig:
- Extractie: Tabellen identificeren en als afzonderlijke entiteiten extraheren.
- Serialisatie: Tabellen omzetten naar een tekstindeling die beter geschikt is voor LLM's, zoals Markdown of gestructureerde JSON, waarbij de relaties behouden blijven.
- Samenvatting: Voor zeer grote tabellen een beknopte samenvatting genereren die wordt ingebed en verwijst naar de volledige tabel.
Zo ontvangt de LLM de volledige, betekenisvolle context van de tabel.
Tabelgegevens extraheren (Python)
Dit is een eenvoudig Python-voorbeeld dat laat zien hoe u een tabel die als tekenreeks is weergegeven kunt verwerken en omzetten in een meer gestructureerde lijst met rijen.
import csv
import io
def process_table_string(table_str):
# Use StringIO to treat the string as a file
f = io.StringIO(table_str)
reader = csv.reader(f, delimiter='|')
rows = []
for i, row in enumerate(reader):
# Strip whitespace and filter empty strings
cleaned_row = [item.strip() for item in row if item.strip()]
if cleaned_row and i > 0: # Skip header line
rows.append(cleaned_row)
return rows
if __name__ == "__main__":
data = """
Name | Age | City
-------|-----|--------
Alice | 30 | New York
Bob | 24 | London
Charlie| 35 | Paris
"""
processed_data = process_table_string(data)
for row in processed_data:
print(row)Geneste documenten begrijpen
Documenten hebben vaak een natuurlijke hiërarchie. Denk aan een boek met hoofdstukken, secties en subsecties. Elk onderdeel bouwt voort op het vorige en de betekenis ervan hangt vaak samen met de context van het bovenliggende onderdeel.
Bij standaard opdelen kan een subsectie worden gescheiden van de kop van de hoofdsectie, waardoor het opgehaalde deel zonder de juiste context minder informatief of zelfs verwarrend wordt.
De hiërarchie van documenten behouden
Om geneste structuren effectief te verwerken, gebruiken we hiërarchisch opdelen:
- Semantische grenzen: Deel op basis van logische indelingen zoals koppen (H1, H2, H3) in plaats van vaste aantallen tekens.
- Context van het bovenliggende onderdeel: Neem de titel van de bovenliggende sectie op in het onderliggende deel. Een deel uit 'Sectie 2.1' kan bijvoorbeeld beginnen met 'Hoofdstuk 2: Inleiding - Sectie 2.1: Onderwerp'.
- Metagegevens: Sla het volledige pad of hiërarchieniveau op in de metagegevens van het deel.
Opdelen per sectie (Python)
Dit Python-voorbeeld laat een eenvoudige manier zien om een document op te splitsen in delen op basis van koppen in Markdown-stijl. Elk deel bevat de inhoud van één sectie.
def chunk_by_headings(document_text):
lines = document_text.split('\n')
chunks = []
current_chunk = []
current_heading = ""
for line in lines:
if line.startswith('# '): # Main heading
if current_chunk:
chunks.append({'heading': current_heading, 'content': '\n'.join(current_chunk).strip()})
current_heading = line.strip()
current_chunk = [line]
elif line.startswith('## '):
# Sub-heading, can be part of the current chunk, or signal a new sub-chunk
# For simplicity, we'll just add it to the current chunk content here
# More advanced logic might create nested chunks or separate entries
current_chunk.append(line)
else:
current_chunk.append(line)
if current_chunk:
chunks.append({'heading': current_heading, 'content': '\n'.join(current_chunk).strip()})
return chunks
if __name__ == "__main__":
doc = """
# Chapter 1: Introduction
This is the introduction text.
## Section 1.1: Background
More details about the background.
# Chapter 2: Methods
Here we describe the methods used.
## Section 2.1: Data Collection
How data was collected.
"""
document_chunks = chunk_by_headings(doc)
for i, chunk in enumerate(document_chunks):
print(f"--- Chunk {i+1} ---")
print(f"Heading: {chunk['heading']}")
print(f"Content snippet: {chunk['content'][:50]}...")
print()Metagegevens voor uitgebreidere context
Metagegevens zijn extra gegevens die aan een deel zijn gekoppeld en het beschrijven zonder deel uit te maken van de hoofdtekst ervan. Ze zijn bijzonder krachtig voor complexe documenten.
- Documenttitel: Uit welk brondocument komt dit deel?
- Paginanummer: Waar in het oorspronkelijke document is dit gevonden?
- Bovenliggende sectie of hoofdstuk: Tot welke grotere context behoort dit deel?
- Tabel-ID: Om welke tabel gaat het als dit een tabel is?
Metagegevens maken gerichte filtering tijdens het ophalen mogelijk en bieden waardevolle context aan de LLM.
Verder dan ophalen met één vector
Voor zeer complexe inhoud zijn eenvoudige tekstgedeelten mogelijk niet voldoende. Ophalen met meerdere vectoren is een geavanceerde techniek waarbij u verschillende typen embeddings voor dezelfde inhoud maakt.
U kunt bijvoorbeeld een kleine, beknopte samenvatting van een tabel laten embedden voor snel ophalen en de volledige, gedetailleerde tabelinhoud afzonderlijk opslaan. Het RAG-systeem haalt de samenvatting op en haalt, als die relevant is, vervolgens de volledige tabel op om die aan de LLM door te geven.
Controle van complexe documenten
Je hebt verschillende strategieën geleerd voor het omgaan met complexe documentstructuren in RAG. Laten we je begrip testen.
Samenvatting: complexe documenten beheersen
Gefeliciteerd! Je hebt belangrijke strategieën verkend voor het omgaan met complexe documentstructuren in RAG.
- We zagen hoe tabellen context kunnen verliezen bij standaard opsplitsing in stukken en leerden hoe je ze kunt extraheren en serialiseren.
- We bespraken geneste documenten en het belang van hiërarchische opsplitsing om relaties te behouden.
- Tot slot benadrukten we de kracht van metadata om stukken te verrijken en nauwkeurigere zoekresultaten mogelijk te maken.
Door deze technieken toe te passen, kan je RAG-systeem nauwkeurigere en contextueel relevantere antwoorden geven, zelfs op basis van de meest ingewikkelde documenten!
Leer LLM-toepassingen in productie (RAG + vectordatabase + caching) 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 “Omgaan met complexe documentstructuren” gratis?
Ja — de volledige tekst van “Omgaan met complexe documentstructuren” 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 LLM-toepassingen in productie (RAG + vectordatabase + caching) wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus LLM-toepassingen in productie (RAG + vectordatabase + caching) bevat in totaal 4 lessen.
Wat leer ik in “Omgaan met complexe documentstructuren”?
Implementeer strategieën om informatie uit complexe documenten, zoals tabellen of geneste secties, effectief op te splitsen en op te halen. Je oefent met LLM-toepassingen in productie (RAG + vectordatabase + caching) 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 LLM-toepassingen in productie (RAG + vectordatabase + caching) te beginnen?
Ervaring vooraf is niet nodig. LLM-toepassingen in productie (RAG + vectordatabase + caching) 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 “Omgaan met complexe documentstructuren”?
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 LLM-toepassingen in productie (RAG + vectordatabase + caching)?
Ja. Elke les over LLM-toepassingen in productie (RAG + vectordatabase + caching) 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
- Query's herschrijven en opnieuw rangschikken
- RAG-patronen met meerdere stappen en agents
- Omgaan met complexe documentstructuren
- Self-querying en citaties