PricingLoginStart free
Promptteknik til AI · Lektion

Strategier til opdeling af lange tekster

Tilgange til opdeling i faste størrelser, ved sætningsgrænser og efter semantik.

Lektion 1 af 413 trin

Strategier til opdeling af lange tekster er en gratis Promptteknik til AI-lektion på CoddyKit. Dette er lektion 1 af 4. Du kan læse alle 3 lektioner i dette læringsspor gratis i deres fulde længde — derefter låser CoddyKit PRO alle lektioner op samt praktiske øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Den er en del af læringsforløbet i Promptteknik til AI, og dine fremskridt synkroniseres på tværs af nettet og CoddyKit-appen. Promptteknik til AI-kurset indeholder 4 lektioner i alt.

Hvorfor lange dokumenter er en udfordring

LLM'er har et kontekstvindue — et maksimalt antal tokens, som de kan behandle på én gang. GPT-4 understøtter 128k tokens, Claude understøtter 200k, men mange dokumenter overskrider selv disse grænser. Endnu vigtigere viser forskning, at modellens nøjagtighed ofte falder ved meget lange kontekster. Opdeling i tekststykker er praksissen med at dele dokumenter op i mindre dele før behandling.

Opdeling i tekststykker med fast størrelse

Opdeling i tekststykker med fast størrelse opdeler tekst for hver N tokens (eller tegn) uanset indholdsgrænser. Det er den enkleste strategi og kræver ingen semantisk forståelse.

Typisk størrelse på tekststykker: 500–1000 tokens. Tekststykker er nemme at indeksere og hente, men sætninger kan blive delt midt over, så betydning går tabt ved grænserne.

import tiktoken

def fixed_chunk(text, max_tokens=1000):
    enc = tiktoken.get_encoding('cl100k_base')
    tokens = enc.encode(text)
    chunks = []
    for i in range(0, len(tokens), max_tokens):
        chunk_tokens = tokens[i:i + max_tokens]
        chunks.append(enc.decode(chunk_tokens))
    return chunks

chunks = fixed_chunk(long_document)
print(f'Total chunks: {len(chunks)}')

Fordele og ulemper ved opdeling med fast størrelse

Fordele:

  • Enkelt at implementere — ingen NLP er nødvendig
  • Forudsigelige tekststørrelser — nemmere at styre API-omkostninger
  • Hurtig behandling

Ulemper:

  • Skærer på tværs af sætningers og afsnits grænser
  • En sætning, der er delt mellem tekststykker, mister kontekst ved hentning
  • Uegnet til opsummering — tekststykket kan slutte midt i et argument

Opdeling ved sætningers grænser

Opdeling ved sætningers grænser opdeler tekst ved naturlige sætning- eller afsnitsgrænser. Hvert tekststykke slutter ved et punktum, så ingen sætning bliver skåret over. Det giver mere læsbare og sammenhængende tekststykker.

Brug en tokenizer til sætninger (spaCy eller NLTK) til at registrere grænserne, og gruppér derefter sætninger, indtil tekststykket når den ønskede størrelse.

import spacy

nlp = spacy.load('en_core_web_sm')

def sentence_chunk(text, max_tokens=1000):
    doc = nlp(text)
    sentences = [sent.text.strip() for sent in doc.sents]
    chunks, current, count = [], [], 0
    for sent in sentences:
        word_count = len(sent.split())
        if count + word_count > max_tokens and current:
            chunks.append(' '.join(current))
            current, count = [], 0
        current.append(sent)
        count += word_count
    if current:
        chunks.append(' '.join(current))
    return chunks

Semantisk opdeling i tekststykker

Semantisk opdeling i tekststykker går et skridt videre — den opdeler tekst, når emnet skifter. Ved at embedde tilstødende sætninger og måle cosinuslighed kan vi registrere, hvornår diskussionen bevæger sig over i et nyt emne.

Når ligheden falder under en tærskel, indsættes en grænse mellem tekststykker. Det giver tematisk sammenhængende tekststykker, som er ideelle til generering med informationshentning (RAG).

from sentence_transformers import SentenceTransformer
from sklearn.metrics.pairwise import cosine_similarity
import numpy as np

model = SentenceTransformer('all-MiniLM-L6-v2')

def semantic_chunk(sentences, threshold=0.75):
    embeddings = model.encode(sentences)
    chunks, current = [], [sentences[0]]
    for i in range(1, len(sentences)):
        sim = cosine_similarity(
            [embeddings[i-1]], [embeddings[i]]
        )[0][0]
        if sim < threshold:
            chunks.append(' '.join(current))
            current = []
        current.append(sentences[i])
    if current:
        chunks.append(' '.join(current))
    return chunks

Sammenligning af de tre strategier

Her er en sammenligning side om side, som kan hjælpe dig med at vælge:

  • Fast størrelse: hurtigst, mindst præcise grænser — brug det til enkle behandlingsforløb
  • Sætningsgrænser: bevarer sætningers integritet — brug det, når sammenhæng er vigtig
  • Semantisk: bedste tematiske sammenhæng — brug det til RAG, hvor præcis informationshentning er afgørende

I praksis øger semantisk opdeling latenstiden på grund af beregningen af embeddings. Vælg ud fra kravene til nøjagtighed ved informationshentning.

Opdeling i tekststykker til informationshentning

Til generering med informationshentning (RAG) bliver tekststykkerne den enhed, der søges i. En brugerforespørgsel embeddes, og de mest lignende tekststykker hentes og indsættes i prompten.

Mindre tekststykker (200–400 tokens) forbedrer præcisionen i informationshentningen — hvert tekststykke indeholder én afgrænset idé. Større tekststykker (800–1000 tokens) giver mere kontekst, men kan indeholde irrelevant indhold sammen med det relevante afsnit.

import openai
import numpy as np

client = openai.OpenAI(api_key='sk-...')

def embed(text):
    resp = client.embeddings.create(
        model='text-embedding-3-small',
        input=text
    )
    return np.array(resp.data[0].embedding)

def retrieve(query, chunks, top_k=3):
    q_emb = embed(query)
    scores = [(i, np.dot(q_emb, embed(c))) for i, c in enumerate(chunks)]
    scores.sort(key=lambda x: x[1], reverse=True)
    return [chunks[i] for i, _ in scores[:top_k]]

Opdeling i tekststykker til opsummeringsopgaver

Til opsummering skal tekststykker være store nok til at indeholde et komplet argument eller afsnit. Tekststykker afgrænset ved sætninger på 600–800 tokens fungerer godt.

Hvert tekststykke opsummeres uafhængigt (map-trinnet), hvorefter opsummeringerne kombineres til en endelig opsummering (reduce-trinnet). Dette er det klassiske map-reduce-mønster, som gennemgås i den næste lektion.

Gentagelse på tværs af tekststykkegrænser

En praktisk teknik til at reducere fejl ved grænser er at tilføje en fælles del mellem tekststykker. De sidste 100–200 tokens i tekststykke N gentages i begyndelsen af tekststykke N+1.

Denne gentagelse sikrer, at en sætning, der går på tværs af en grænse, står helt i mindst ét tekststykke. Det er især vigtigt ved informationshentning — en forespørgsel om et emne, der går på tværs af en grænse, vil matche tekststykket med den fælles del.

def fixed_chunk_with_overlap(text, max_tokens=1000, overlap=200):
    enc = tiktoken.get_encoding('cl100k_base')
    tokens = enc.encode(text)
    chunks = []
    step = max_tokens - overlap
    for i in range(0, len(tokens), step):
        chunk_tokens = tokens[i:i + max_tokens]
        chunks.append(enc.decode(chunk_tokens))
        if i + max_tokens >= len(tokens):
            break
    return chunks

Berigelse af hvert tekststykke med metadata

Hvert tekststykke bør indeholde metadata, så efterfølgende trin kan henvise til dets oprindelse:

  • source: filnavn eller URL
  • page: sidetal
  • chunk_index: placering i dokumentet
  • section: kapitel eller overskrift

Disse metadata gemmes sammen med embeddinget i en vektordatabase (Pinecone, Chroma, Weaviate) og returneres sammen med hentede tekststykker, så LLM'en kan angive kilder.

def chunk_with_metadata(text, source='doc.pdf', page=1):
    chunks = fixed_chunk_with_overlap(text)
    return [
        {
            'text': chunk,
            'metadata': {
                'source': source,
                'page': page,
                'chunk_index': i
            }
        }
        for i, chunk in enumerate(chunks)
    ]

Valg af den rigtige strategi

En hurtig vejledning til valg:

  • Hastighed er vigtigst, og indholdet er prosa: opdeling ved sætningers grænser
  • Nøjagtighed ved informationshentning er afgørende: semantisk opdeling med små tekststykker (300 tokens)
  • Opsummering af en bog eller rapport: opdeling ved sætningers grænser, større tekststykker (800 tokens), map-reduce
  • Juridiske eller tekniske dokumenter: semantisk opdeling, så klausuler holdes samlet

Mål altid genkaldelsen ved informationshentning på et repræsentativt sæt forespørgsler, før du vælger en strategi.

Videnstjek

Hvilken opdelingsstrategi deler tekst, når cosinusligheden mellem indlejringer af tilstødende sætninger falder under en tærskelværdi?

Besvar den i den interaktive lektion

Opsummering: Opdelingsstrategier

Du har lært tre grundlæggende opdelingsstrategier:

  • Fast størrelse: del teksten ved hver N tokens — hurtigt, enkelt og uden hensyn til grænser
  • Sætningsgrænser: del teksten ved naturlige sætningsgrænser — sammenhængende og med moderat kompleksitet
  • Semantisk: del teksten ved emneskift baseret på ligheden mellem indlejringer — mest præcist og med de højeste omkostninger

Tilføj overlapning mellem tekstblokke for at reducere fejl ved grænser, og tilknyt altid metadata (kilde, side, indeks), så du får kildehenvisninger og sporbarhed. I næste lektion gennemgår vi map-reduce-mønstret til opsummering.

Gratis at komme i gang

Lær Promptteknik til AI med en AI-underviser — gratis

Skriv og kør rigtig kode i din browser, få øjeblikkelig hjælp fra en AI-underviser døgnet rundt, og fortsæt, hvor du slap, på web eller i appen.

Kurser
53
Lektioner
199
Start gratisSe hele kurset

Ofte stillede spørgsmål

Er lektionen “Strategier til opdeling af lange tekster” gratis?

Ja — alle 3 lektioner i læringssporet Promptteknik til AI, inklusive “Strategier til opdeling af lange tekster”, kan læses gratis i deres fulde længde her på webstedet. Derefter låser CoddyKit PRO alle lektioner op samt interaktive øvelser med en indbygget kodeeditor og en AI-underviser døgnet rundt. Promptteknik til AI-kurset indeholder 4 lektioner i alt.

Hvad lærer jeg i “Strategier til opdeling af lange tekster”?

Tilgange til opdeling i faste størrelser, ved sætningsgrænser og efter semantik. Du øver dig i Promptteknik til AI med praktisk kode, som du kører direkte i browseren, og en AI-vejleder døgnet rundt besvarer dine spørgsmål, mens du arbejder dig gennem lektionen.

Skal jeg have erfaring for at begynde på Promptteknik til AI?

Der kræves ingen tidligere erfaring. Promptteknik til AI på CoddyKit er tilrettelagt for både begyndere og øvede, så du kan starte her eller fra begyndelsen og lære i dit eget tempo. Dette er lektion 1 af 4.

Hvor lang tid tager lektionen “Strategier til opdeling af lange tekster”?

De fleste CoddyKit-lektioner tager cirka 5–10 minutter. Hver lektion er kort og interaktiv, så du gør løbende fremskridt og kan fortsætte, hvor du slap – på både web og app.

Kan jeg skrive og køre kode i denne Promptteknik til AI-lektion?

Ja. Alle Promptteknik til AI-lektioner har en indbygget kodeeditor, så du kan skrive og køre rigtig kode direkte i din browser og få øjeblikkelig feedback fra AI – uden lokal opsætning.

Alle lektioner i dette kursus

  1. Strategier til opdeling af lange tekster
  2. Map-Reduce-mønster til opsummering
  3. Hierarkisk opsummering
  4. Bevar konteksten på tværs af tekstdele
← Tilbage til Promptteknik til AI