AI Prompt Engineering · Lezione

Strategie di chunking per testi lunghi

Approcci basati su dimensione fissa, confini delle frasi e segmentazione semantica

Strategie di chunking per testi lunghi è una lezione AI Prompt Engineering gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento AI Prompt Engineering, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso AI Prompt Engineering include 4 lezioni in totale.

Perché i documenti lunghi sono una difficoltà

Gli LLM hanno una finestra di contesto: il numero massimo di token che possono elaborare contemporaneamente. GPT-4 supporta 128k token e Claude ne supporta 200k, ma molti documenti superano persino questi limiti. Ancora più importante, le ricerche mostrano che la precisione del modello spesso diminuisce nei contesti molto lunghi. Il chunking consiste nel dividere i documenti in parti più piccole prima di elaborarli.

Chunking a dimensione fissa

Il chunking a dimensione fissa divide il testo ogni N token (o caratteri), indipendentemente dai confini del contenuto. È la strategia più semplice e non richiede alcuna comprensione semantica.

Dimensione tipica dei chunk: 500–1000 token. I chunk sono facili da indicizzare e recuperare, ma possono spezzare le frasi a metà, perdendo significato ai confini.

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

Compromessi del chunking a dimensione fissa

Vantaggi:

Semplice da implementare — non richiede NLP
Dimensioni dei chunk prevedibili — più facili da gestire i costi dell'API
Elaborazione rapida

Svantaggi:

Taglia le frasi e i paragrafi senza rispettarne i confini
Una frase divisa tra più chunk perde contesto durante il recupero
Non è adatto alla sintesi — il chunk potrebbe terminare a metà di un'argomentazione

Chunking ai confini delle frasi

Il chunking ai confini delle frasi divide il testo in corrispondenza delle interruzioni naturali tra frasi o paragrafi. Ogni chunk termina con una frase completa, così nessuna frase viene spezzata a metà. In questo modo si ottengono chunk più leggibili e coerenti.

Utilizzi un tokenizer di frasi (spaCy o NLTK) per rilevare i confini, quindi raggruppi le frasi finché il chunk non raggiunge la dimensione desiderata.

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

Chunking semantico

Il chunking semantico si spinge oltre: divide il testo quando cambia l'argomento. Generando gli embedding delle frasi adiacenti e misurando la similarità coseno, è possibile rilevare quando la discussione passa a un nuovo argomento.

Quando la similarità scende al di sotto di una soglia, inserisca un confine tra i chunk. Si ottengono così chunk coerenti dal punto di vista tematico, ideali per la generazione aumentata dal recupero (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

Confronto tra le tre strategie

Ecco un confronto affiancato per aiutarla a scegliere:

Dimensione fissa: confini più rapidi ma meno accurati — da utilizzare per pipeline semplici
Confini delle frasi: preserva l'integrità delle frasi — da utilizzare quando la coerenza è importante
Semantico: offre la migliore coesione tematica — da utilizzare per RAG, dove il recupero preciso è fondamentale

Nella pratica, il chunking semantico aggiunge latenza a causa del calcolo degli embedding. Scelga in base ai requisiti di accuratezza del recupero.

Chunking per le attività di recupero

Per la generazione aumentata dal recupero (RAG), i chunk diventano l'unità di ricerca. Una query dell'utente viene trasformata in un embedding e i chunk più simili vengono recuperati e inseriti nel prompt.

I chunk più piccoli (200–400 token) migliorano la precisione del recupero: ogni chunk contiene un'unica idea ben focalizzata. I chunk più grandi (800–1000 token) forniscono più contesto, ma possono includere contenuti irrilevanti insieme al passaggio pertinente.

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

Chunking per le attività di sintesi

Per la sintesi, i chunk devono essere abbastanza grandi da contenere un'argomentazione o una sezione completa. I chunk ai confini delle frasi da 600–800 token funzionano bene.

Ogni chunk viene sintetizzato indipendentemente (passaggio map), quindi le sintesi vengono combinate in una sintesi finale (passaggio reduce). Questo è il classico schema map-reduce, illustrato nella lezione successiva.

Overlap: collegare i confini dei chunk

Una tecnica pratica per ridurre gli errori ai confini consiste nell'aggiungere un overlap tra i chunk. Gli ultimi 100–200 token del chunk N vengono ripetuti all'inizio del chunk N+1.

L'overlap garantisce che una frase a cavallo di un confine compaia per intero in almeno un chunk. Questo è particolarmente importante per il recupero: una query relativa a un argomento che attraversa un confine corrisponderà al chunk sovrapposto.

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

Arricchimento dei metadati per ogni chunk

Ogni chunk dovrebbe contenere metadati, così i passaggi successivi possono risalire alla sua origine:

source: nome del file o URL
page: numero di pagina
chunk_index: posizione nel documento
section: capitolo o intestazione

Questi metadati vengono memorizzati insieme all'embedding in un DB vettoriale (Pinecone, Chroma, Weaviate) e restituiti con i chunk recuperati, così l'LLM può citare le fonti.

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

Scelta della strategia più adatta

Una guida rapida alla scelta:

La velocità è prioritaria e il contenuto è prosa: chunking ai confini delle frasi
La precisione del recupero è fondamentale: chunking semantico con chunk piccoli (300 token)
Sintesi di un libro o di un rapporto: chunking ai confini delle frasi, chunk più grandi (800 token), map-reduce
Documenti legali o tecnici: chunking semantico per mantenere unite le clausole

Misuri sempre il recall del recupero su un insieme rappresentativo di query prima di adottare definitivamente una strategia.

Verifica delle conoscenze

Quale strategia di suddivisione in chunk divide il testo quando la similarità coseno tra gli embedding di frasi adiacenti scende al di sotto di una soglia?

Riepilogo: strategie di suddivisione in chunk

Ha appreso tre strategie fondamentali di suddivisione in chunk:

Dimensione fissa: divide ogni N token — veloce, semplice, non tiene conto dei confini
Confini delle frasi: divide in corrispondenza delle interruzioni naturali tra frasi — coerente, complessità moderata
Semantica: divide in corrispondenza dei cambi di argomento tramite la similarità tra embedding — più accurata, costo maggiore

Aggiunga una sovrapposizione tra i chunk per ridurre gli errori ai confini e associ sempre i metadati (origine, pagina, indice) per abilitare citazioni e tracciabilità. La lezione successiva illustra il pattern di riepilogo map-reduce.

Domande Frequenti

La lezione «Strategie di chunking per testi lunghi» è gratuita?

Sì — il testo completo di «Strategie di chunking per testi lunghi» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso AI Prompt Engineering, passa a CoddyKit PRO. Il corso AI Prompt Engineering include 4 lezioni in totale.

Cosa imparerò in «Strategie di chunking per testi lunghi»?

Approcci basati su dimensione fissa, confini delle frasi e segmentazione semantica Eserciti AI Prompt Engineering con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare AI Prompt Engineering?

Non è richiesta alcuna esperienza precedente. AI Prompt Engineering su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Strategie di chunking per testi lunghi»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione AI Prompt Engineering?

Sì. Ogni lezione AI Prompt Engineering include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a AI Prompt Engineering