Hantera komplexa dokumentstrukturer
Implementera strategier för att effektivt segmentera och hämta information från komplexa dokument, till exempel tabeller eller nästlade avsnitt.
Hantera komplexa dokumentstrukturer är en gratis lektion i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) på CoddyKit. Detta är lektion 3 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för LLM-applikationer i produktion (RAG + vektordatabaser + cachning), och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) innehåller totalt 4 lektioner.
Bortom enkel text: komplexa dokument
När vi bygger RAG-system arbetar vi ofta med dokument som inte bara består av löpande text. Tänk på ekonomiska rapporter, vetenskapliga artiklar eller juridiska avtal.
De här dokumenten innehåller ofta tabeller, kapslade avsnitt (som kapitel och underkapitel) och andra invecklade strukturer. Standardmetoder för textsegmentering har ofta svårt att hantera detta, vilket bryter kontexten och gör hämtningen mindre effektiv.
Tabeller: en utmaning för RAG
Tabeller är ett tydligt exempel på komplexa strukturer. De presenterar data i ett strukturerat, rutnätsliknande format där relationerna mellan rader och kolumner är avgörande.
- Förlorad kontext: En enkel teckenbaserad segmenterare kan dela en tabellrad och skilja ett värde från dess rubrik, vilket gör segmentet meningslöst.
- Bristfälliga embeddingar: Utan rätt kontext kanske de embeddingar som genereras för tabellfragment inte representerar datan korrekt.
Strategier för tabellmedveten segmentering
För att hantera tabeller effektivt behöver vi särskilda strategier:
- Extrahering: Identifiera och extrahera tabeller som separata enheter.
- Serialisering: Konvertera tabeller till ett mer LLM-vänligt textformat, till exempel Markdown eller strukturerad JSON, och bevara relationerna mellan delarna.
- Sammanfattning: För mycket stora tabeller kan ni skapa en kort sammanfattning som bäddas in och länkar tillbaka till hela tabellen.
Detta säkerställer att LLM:en får tabellens fullständiga och meningsfulla kontext.
Extrahera tabelldata (Python)
Här är ett enkelt Python-exempel som visar hur ni kan bearbeta en tabell representerad som en sträng och konvertera den till en mer strukturerad lista med rader.
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)Förstå kapslade dokument
Dokument har ofta en naturlig hierarki. Tänk på en bok med kapitel, avsnitt och underavsnitt. Varje del bygger vidare på den föregående, och dess betydelse är ofta knuten till den överordnade kontexten.
Standardsegmentering kan skilja ett underavsnitt från rubriken för huvudavsnittet, vilket gör det hämtade segmentet mindre informativt eller till och med förvirrande utan rätt kontext.
Bevara dokumenthierarkin
För att hantera kapslade strukturer effektivt använder vi hierarkisk segmentering:
- Semantiska gränser: I stället för fasta teckenantal segmenterar ni utifrån logiska indelningar som rubriker (H1, H2, H3).
- Överordnad kontext: Inkludera rubriken för det överordnade avsnittet i det underordnade segmentet. Ett segment från "Avsnitt 2.1" kan till exempel börja med "Kapitel 2: Introduktion – Avsnitt 2.1: Delämne".
- Metadata: Lagra hela sökvägen eller hierarkinivån i segmentets metadata.
Segmentering efter avsnitt (Python)
Det här Python-exemplet visar ett enkelt sätt att dela upp ett dokument i segment baserat på rubriker i Markdown-stil. Varje segment innehåller innehållet i ett avsnitt.
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()Metadata för rikare kontext
Metadata är extra information som kopplas till ett segment och beskriver det utan att ingå i segmentets huvudtext. Det är otroligt användbart för komplexa dokument.
- Dokumenttitel: Vilket källdokument kommer det här segmentet från?
- Sidnummer: Var i originaldokumentet hittades detta?
- Överordnat avsnitt/kapitel: Vilken större kontext hör segmentet till?
- Tabell-ID: Vilken tabell är det, om segmentet gäller en tabell?
Metadata gör det möjligt att filtrera målinriktat under hämtningen och ger LLM:en värdefull kontext.
Bortom hämtning med en enda vektor
För mycket komplext innehåll kanske enkla textsegment inte räcker. Multivektorhämtning är en avancerad teknik där ni skapar olika typer av embeddingar för samma innehåll.
Ni kan till exempel skapa en liten, kortfattad sammanfattning av en tabell för snabb hämtning och lagra det fullständiga, detaljerade tabellinnehållet separat. RAG-systemet hämtar sammanfattningen och hämtar sedan vid behov hela tabellen för att skicka den till LLM:en.
Test av komplexa dokument
Ni har lärt er om olika strategier för att hantera komplexa dokumentstrukturer i RAG. Låt oss testa era kunskaper.
Repetition: Bemästra komplexa dokument
Grattis! Ni har utforskat viktiga strategier för att hantera komplexa dokumentstrukturer i RAG.
- Vi såg hur tabeller kan förlora sitt sammanhang vid vanlig chunkning och lärde oss att extrahera och serialisera dem.
- Vi diskuterade kapslade dokument och vikten av hierarkisk chunkning för att bevara relationer.
- Slutligen lyfte vi fram hur metadata kan berika chunks och möjliggöra mer exakt hämtning.
Genom att tillämpa dessa tekniker kan ert RAG-system ge mer korrekta och kontextuellt relevanta svar, även från de mest komplexa dokumenten!
Lär dig LLM-applikationer i produktion (RAG + vektordatabaser + cachning) med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 12
- Lektioner
- 48
Vanliga frågor
Är lektionen ”Hantera komplexa dokumentstrukturer” gratis?
Ja – hela texten till ”Hantera komplexa dokumentstrukturer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning), kan Ni uppgradera till CoddyKit PRO. Kursen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) innehåller totalt 4 lektioner.
Vad lär jag mig i ”Hantera komplexa dokumentstrukturer”?
Implementera strategier för att effektivt segmentera och hämta information från komplexa dokument, till exempel tabeller eller nästlade avsnitt. Ni övar på LLM-applikationer i produktion (RAG + vektordatabaser + cachning) med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig LLM-applikationer i produktion (RAG + vektordatabaser + cachning)?
Du behöver inga förkunskaper. Utbildningen i LLM-applikationer i produktion (RAG + vektordatabaser + cachning) på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 3 av 4.
Hur lång tid tar lektionen ”Hantera komplexa dokumentstrukturer”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här LLM-applikationer i produktion (RAG + vektordatabaser + cachning)-lektionen?
Ja. Varje LLM-applikationer i produktion (RAG + vektordatabaser + cachning)-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Frågeomskrivning och omrankning
- Flerstegs- och agentiska RAG-mönster
- Hantera komplexa dokumentstrukturer
- Självfrågande sökning och källhänvisningar