0Pricing
AI Prompt Engineering · Lekcja

Strategie dzielenia długich tekstów na fragmenty

Poznaj podejścia oparte na fragmentach o stałym rozmiarze, granicach zdań i znaczeniu semantycznym.

Strategie dzielenia długich tekstów na fragmenty to bezpłatna lekcja AI Prompt Engineering na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Prompt Engineering, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Dlaczego długie dokumenty stanowią wyzwanie

LLM-y mają okno kontekstu — maksymalną liczbę tokenów, które mogą przetworzyć jednocześnie. GPT-4 obsługuje 128 tys. tokenów, a Claude 200 tys., jednak wiele dokumentów przekracza nawet te limity. Co ważniejsze, badania pokazują, że dokładność modeli często spada w przypadku bardzo długich kontekstów. Dzielenie na fragmenty polega na rozdzielaniu dokumentów na mniejsze części przed ich przetworzeniem.

Dzielenie na fragmenty o stałym rozmiarze

Dzielenie na fragmenty o stałym rozmiarze polega na dzieleniu tekstu co N tokenów (lub znaków), niezależnie od granic treści. Jest to najprostsza strategia i nie wymaga rozumienia semantyki.

Typowy rozmiar fragmentu to 500–1000 tokenów. Fragmenty można łatwo indeksować i pobierać, ale mogą one przecinać zdania w połowie, powodując utratę znaczenia na granicach.

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)}')

Kompromisy związane z dzieleniem na fragmenty o stałym rozmiarze

Zalety:

  • Prosta implementacja — nie wymaga NLP
  • Przewidywalne rozmiary fragmentów — łatwiejsze zarządzanie kosztami API
  • Szybkie przetwarzanie

Wady:

  • Przecina granice zdań i akapitów
  • Zdanie podzielone między fragmenty traci kontekst podczas wyszukiwania
  • Nie nadaje się dobrze do podsumowywania — fragment może kończyć się w połowie argumentu

Dzielenie na granicach zdań

Dzielenie na granicach zdań polega na dzieleniu tekstu w naturalnych miejscach, takich jak granice zdań lub akapitów. Każdy fragment kończy się kropką, dzięki czemu żadne zdanie nie zostaje przecięte w połowie. Powstają w ten sposób bardziej czytelne i spójne fragmenty.

Należy użyć tokenizera zdań (spaCy lub NLTK) do wykrywania granic, a następnie grupować zdania, aż fragment osiągnie docelowy rozmiar.

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

Dzielenie semantyczne

Dzielenie semantyczne idzie o krok dalej — dzieli tekst, gdy zmienia się temat. Osadzając sąsiednie zdania i mierząc podobieństwo cosinusowe, można wykryć moment, w którym dyskusja przechodzi do nowego zagadnienia.

Gdy podobieństwo spadnie poniżej ustalonego progu, należy wstawić granicę fragmentu. Powstają w ten sposób fragmenty spójne tematycznie, idealne do generowania wspomaganego wyszukiwaniem (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

Porównanie trzech strategii

Oto porównanie obok siebie, które pomoże wybrać odpowiednią strategię:

  • Stały rozmiar: najszybsze, ale z najmniej dokładnymi granicami — należy używać w prostych potokach
  • Granice zdań: zachowuje integralność zdań — należy używać, gdy ważna jest spójność
  • Semantyczne: zapewnia najlepszą spójność tematyczną — należy używać w RAG, gdy kluczowe jest precyzyjne wyszukiwanie

W praktyce dzielenie semantyczne zwiększa opóźnienie ze względu na obliczanie osadzeń. Strategię należy wybrać na podstawie wymagań dotyczących dokładności wyszukiwania.

Dzielenie na fragmenty na potrzeby wyszukiwania

W przypadku generowania wspomaganego wyszukiwaniem (RAG) fragmenty stają się jednostkami wyszukiwania. Zapytanie użytkownika jest osadzane, a najbardziej podobne fragmenty są pobierane i wstawiane do promptu.

Mniejsze fragmenty (200–400 tokenów) poprawiają precyzję wyszukiwania — każdy fragment zawiera jedną, skoncentrowaną ideę. Większe fragmenty (800–1000 tokenów) zapewniają więcej kontekstu, ale wraz z istotnym fragmentem mogą zawierać nieistotną treść.

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]]

Dzielenie na fragmenty na potrzeby podsumowywania

W przypadku podsumowywania fragmenty powinny być wystarczająco duże, aby zawierać kompletny argument lub sekcję. Dobrze sprawdzają się fragmenty wyznaczane na granicach zdań, liczące 600–800 tokenów.

Każdy fragment jest podsumowywany niezależnie (etap map), a następnie podsumowania są łączone w końcowe podsumowanie (etap reduce). Jest to klasyczny wzorzec map-reduce, omówiony w następnej lekcji.

Nakładanie fragmentów: łączenie granic

Jedną z praktycznych technik ograniczania błędów na granicach jest dodanie nakładania fragmentów. Ostatnie 100–200 tokenów fragmentu N jest powtarzane na początku fragmentu N+1.

Nakładanie gwarantuje, że zdanie przechodzące przez granicę pojawi się w całości w co najmniej jednym fragmencie. Jest to szczególnie ważne podczas wyszukiwania — zapytanie dotyczące tematu obejmującego granicę dopasuje fragment z nakładającą się treścią.

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

Wzbogacanie metadanych każdego fragmentu

Każdy fragment powinien zawierać metadane, aby kolejne etapy mogły odwoływać się do jego źródła:

  • source: nazwa pliku lub adres URL
  • page: numer strony
  • chunk_index: pozycja w dokumencie
  • section: rozdział lub nagłówek

Metadane te są przechowywane wraz z osadzeniem w wektorowej bazie danych (Pinecone, Chroma, Weaviate) i zwracane wraz z pobranymi fragmentami, aby LLM mógł podawać źródła.

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)
    ]

Wybór odpowiedniej strategii

Krótki przewodnik decyzyjny:

  • Priorytetem jest szybkość, a treść ma formę prozy: dzielenie na granicach zdań
  • Dokładność wyszukiwania ma kluczowe znaczenie: dzielenie semantyczne z małymi fragmentami (300 tokenów)
  • Podsumowywanie książki lub raportu: dzielenie na granicach zdań, większe fragmenty (800 tokenów), map-reduce
  • Dokumenty prawne lub techniczne: dzielenie semantyczne, aby zachować klauzule w całości

Przed wyborem strategii należy zawsze zmierzyć pełność wyszukiwania na reprezentatywnym zbiorze zapytań.

Sprawdzenie wiedzy

Która strategia dzielenia na fragmenty dzieli tekst, gdy podobieństwo cosinusowe między embeddingami sąsiednich zdań spada poniżej wartości progowej?

Podsumowanie: strategie dzielenia na fragmenty

Poznał(a) Pan/Pani trzy podstawowe strategie dzielenia na fragmenty:

  • Stały rozmiar: podział co N tokenów — szybko, prosto, bez uwzględniania granic
  • Granice zdań: podział w naturalnych miejscach zakończenia zdań — spójnie, umiarkowana złożoność
  • Semantyczna: podział przy zmianach tematu na podstawie podobieństwa embeddingów — najwyższa dokładność, najwyższy koszt

Należy dodać nakładanie między fragmentami, aby ograniczyć błędy na granicach, oraz zawsze dołączać metadane (źródło, strona, indeks), aby umożliwić cytowanie i śledzenie pochodzenia informacji. Następna lekcja obejmuje wzorzec podsumowywania map-reduce.

Często zadawane pytania

Czy lekcja „Strategie dzielenia długich tekstów na fragmenty” jest bezpłatna?

Tak — pełny tekst „Strategie dzielenia długich tekstów na fragmenty” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Prompt Engineering, przejdź na CoddyKit PRO. Kurs AI Prompt Engineering zawiera 4 lekcji w sumie.

Co nauczysz się w „Strategie dzielenia długich tekstów na fragmenty”?

Poznaj podejścia oparte na fragmentach o stałym rozmiarze, granicach zdań i znaczeniu semantycznym. Ćwiczysz AI Prompt Engineering z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Prompt Engineering?

Nie wymagamy żadnego doświadczenia. AI Prompt Engineering w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Strategie dzielenia długich tekstów na fragmenty”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Prompt Engineering?

Tak. Każda lekcja AI Prompt Engineering zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Strategie dzielenia długich tekstów na fragmenty
  2. Wzorzec podsumowywania Map-Reduce
  3. Podsumowywanie hierarchiczne
  4. Zachowywanie kontekstu między fragmentami
← Powrót do AI Prompt Engineering