Stratégies de découpage de texte

Le découpage (chunking) est l’une des étapes les plus critiques d’un pipeline RAG. La manière dont vous divisez vos documents impacte directement la qualité de tout le système. Une mauvaise stratégie de découpage peut mener à l’insertion de contexte non pertinent dans vos prompts, ce qui fait répondre le modèle de manière complètement erronée.

Prenons un exemple concret : vous avez un document avec des sections sur la recherche médicale et l’ingénierie logicielle. Si le découpage est mal fait, un utilisateur qui demande “Combien de bugs les ingénieurs ont-ils corrigés cette année ?” pourrait obtenir des informations sur la recherche médicale au lieu du genie logiciel, simplement parce que la section médicale contenait le mot “bug” dans un contexte différent.

C’est pourquoi le choix de la bonne stratégie de découpage est si important. Voyons les principales approches.

Découpage par taille fixe

C’est l’approche la plus simple : on divise le texte en chaînes de longueur egale. Par exemple, un document de 325 caractères serait coupe en trois chunks d’environ 108 caractères.

Cette méthode est facile à implémenter et fonctionne avec n’importe quel type de document, mais elle a des inconvénients clairs :

• Les mots sont coupes en plein milieu
• Les chunks perdent le contexte du texte environnant
• Les titres de section peuvent être séparés de leur contenu

Pour attenuer ces problèmes, on peut ajouter un chevauchement (overlap) entre les chunks. Chaque chunk inclut alors quelques caractères des chunks voisins, ce qui améliore le contexte et garantit des mots et phrases complets.

Voici une implémentation basique :

def chunk_by_char(text, chunk_size=150, chunk_overlap=20):
    # Decoupe le texte en morceaux de taille fixe avec chevauchement
    chunks = []
    start_idx = 0

    while start_idx < len(text):
        end_idx = min(start_idx + chunk_size, len(text))
        chunk_text = text[start_idx:end_idx]
        chunks.append(chunk_text)

        start_idx = (
            end_idx - chunk_overlap if end_idx < len(text) else len(text)
        )

    return chunks

Découpage par structure

Le découpage structurel divise le texte selon la structure naturelle du document : titres, paragraphes, sections. Il fonctionne très bien quand on dispose de documents bien formtes, comme des fichiers Markdown.

Pour un document Markdown, on peut simplement couper sur les marqueurs de titre :

def chunk_by_section(document_text):
    # Decoupe le document a chaque titre de niveau 2
    pattern = r"\n## "
    return re.split(pattern, document_text)

Cette approche produit les chunks les plus propres et les plus significatifs, car chacun représente une section complète. En revanche, elle ne fonctionne que lorsqu’on a des garanties sur la structure du document. Beaucoup de documents réels sont du texte brut ou des PDF sans marqueurs structurels clairs.

Découpage sémantique

Le découpage sémantique est l’approche la plus sophistiquee. On divise le texte en phrases, puis on utilise le traitement du langage naturel pour déterminer à quel point les phrases consecutives sont liées entre elles. On construit ensuite les chunks à partir de groupes de phrases apparentees.

Cette méthode est coûteuse en calcul mais produit les chunks les plus pertinents. Elle nécessite de comprendre le sens de chaque phrase et est plus complexe à implémenter.

Découpage par phrases

Un bon compromis pratique consiste à découper par phrases. On séparé le texte en phrases individuelles avec des expressions régulières, puis on les regroupe en chunks avec un chevauchement optionnel :

def chunk_by_sentence(text, max_sentences_per_chunk=5, overlap_sentences=1):
    # Decoupe le texte en groupes de phrases avec chevauchement
    sentences = re.split(r"(?<=[.!?])\s+", text)

    chunks = []
    start_idx = 0

    while start_idx < len(sentences):
        end_idx = min(start_idx + max_sentences_per_chunk, len(sentences))
        current_chunk = sentences[start_idx:end_idx]
        chunks.append(" ".join(current_chunk))

        start_idx += max_sentences_per_chunk - overlap_sentences

        if start_idx < 0:
            start_idx = 0

    return chunks

Comment choisir sa stratégie ?

Le choix dépend entièrement de votre cas d’usage et de vos garanties sur les documents :

Le découpage par taille fixe avec chevauchement est souvent le choix par défaut en production car il est simple, fiable et fonctionne avec n’importe quel type de document. Même s’il ne donne pas des résultats parfaits, il produit systématiquement des chunks raisonnables.

Il n’existe pas de stratégie “universellement meilleure”. La bonne approche dépend de vos documents, de vos cas d’usage, et des compromis que vous acceptez entre complexité d’implémentation et qualité des chunks.

Exercice : Testez les stratégies

Prenez un document Markdown que vous avez sous la main et implémentez les trois stratégies de découpage. Comparez les résultats :

1. Découpez-le par taille fixe (150 caractères, 20 de chevauchement)
2. Découpez-le par sections (titres H2)
3. Découpez-le par phrases (5 phrases par chunk, 1 phrase de chevauchement)

Questions :

• Quelle stratégie produit les chunks les plus cohérents ?
• Quelle stratégie perd le plus de contexte ?
• Pour votre cas d’usage, quelle stratégie choisiriez-vous ?