AI Engineering Academy · Leçon

Pourquoi le découpage naïf nuit à la recherche

Analysez des échecs réels de recherche dus à un mauvais découpage, notamment les réponses réparties entre plusieurs segments et le contexte perdu dans les en-têtes et les titres de section.

Leçon 1 sur 413 étapes

Pourquoi le découpage naïf nuit à la recherche est une leçon AI Engineering Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage AI Engineering Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Engineering Academy comprend 4 leçons au total.

Le coût d'une mauvaise segmentation

La segmentation consiste à diviser les documents en fragments plus petits avant de les vectoriser dans un magasin de vecteurs. La manière dont vous segmentez détermine le contexte disponible lors de la récupération. Une mauvaise segmentation est l'une des causes les plus courantes et les plus importantes des échecs des systèmes RAG.

Réponses séparées par des frontières

Imaginez un document qui indique : 'La politique de remboursement est de 30 jours à compter de l'achat. Les clients doivent joindre le reçu original.' Si un séparateur de taille fixe coupe le texte après « achat. », ces deux phrases se retrouvent dans des fragments différents. Une requête sur la politique de remboursement peut ne récupérer que la première moitié — le modèle est alors incapable de mentionner l'exigence concernant le reçu.

Contexte perdu dans les en-têtes

Les documents utilisent souvent des en-têtes de section pour fournir du sens. Prenez un tableau intitulé 'Tarifs des forfaits Entreprise', suivi de lignes de nombres. Si l'en-tête et le tableau se retrouvent dans des fragments différents, le fragment récupéré contenant le tableau présente des nombres sans libellé — le modèle ne peut pas répondre correctement à la question 'Quel est le tarif Entreprise ?'.

Pièges de la segmentation de taille fixe

La segmentation de taille fixe divise le texte tous les N caractères ou jetons, quels que soient les limites des phrases. Cette méthode est rapide et simple, mais elle coupe souvent les phrases en plein milieu. Un fragment qui se termine par 'The model was trained on' et le fragment suivant qui commence par 'a dataset of 500 billion tokens' n'ont chacun aucun sens sans l'autre.

from langchain.text_splitter import CharacterTextSplitter

# Naive fixed-size: may break mid-sentence
splitter = CharacterTextSplitter(chunk_size=200, chunk_overlap=0)
chunks = splitter.split_text(document_text)
print(f'Created {len(chunks)} chunks')
print('First chunk:', chunks[0])

Le chevauchement n'est pas toujours utile

Une solution courante consiste à ajouter un chevauchement entre fragments — en répétant les N derniers jetons d'un fragment au début du suivant. Cela aide lorsque les phrases sont séparées, mais introduit de la redondance et peut perturber les systèmes de récupération lorsque deux fragments très similaires sont tous deux récupérés. Le chevauchement est un pansement, pas un remède aux problèmes structurels de segmentation.

# Overlap helps partially but adds redundancy
splitter = CharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50  # last 50 chars repeated in next chunk
)
chunks = splitter.split_text(document_text)

Mesurer le taux d'échec de la récupération

Vous pouvez mesurer à quelle fréquence votre segmentation nuit à la récupération en créant un petit ensemble d'évaluation de référence : une liste de questions associées à des passages sources corrects connus. Vérifiez ensuite à quelle fréquence le passage correct figure parmi les k premiers fragments récupérés. Un hit rate faible révèle souvent des problèmes de segmentation avant même que vous n'examiniez la qualité de la génération.

def hit_rate(queries_and_answers, retriever, k=5):
    hits = 0
    for query, expected_text in queries_and_answers:
        results = retriever.retrieve(query, k=k)
        retrieved_texts = [r.page_content for r in results]
        if any(expected_text in text for text in retrieved_texts):
            hits += 1
    return hits / len(queries_and_answers)

Problèmes liés au code et aux données structurées

Les fichiers de code, le JSON et les tableaux possèdent des unités logiques — fonctions, objets, lignes de tableau — qui ne doivent pas être séparées. Diviser la définition d'une fonction Python entre deux fragments signifie qu'aucun des deux ne peut être compris indépendamment. Un système de récupération qui trouve le second fragment voit du code sans arguments et sans contexte.

# Bad: splits code arbitrarily
bad_chunk_1 = 'def calculate_price(item, qty'  # incomplete!
bad_chunk_2 = ', discount):\n    return item.price * qty * (1 - discount)'

# Good: keep the full function together
good_chunk = 'def calculate_price(item, qty, discount):\n    return item.price * qty * (1 - discount)'

Documents longs et perte du contenu central

Les recherches sur les LLM montrent le phénomène de 'perte au milieu' : lorsque de nombreux fragments sont récupérés et insérés dans une invite, le modèle prête attention au contenu proche du début et de la fin, mais tend à ignorer le milieu. Une mauvaise segmentation qui produit de nombreux petits fragments de faible qualité aggrave ce phénomène en diluant le signal pertinent.

Diagnostiquer manuellement les mauvais fragments

Pour un diagnostic rapide, affichez un échantillon aléatoire de vos fragments et lisez-les. Demandez-vous : Ce fragment est-il pertinent pris isolément ? Si un utilisateur posait une question, le modèle pourrait-il y répondre à partir de ce seul fragment ? Les fragments qui contiennent des pronoms sans antécédent défini (« Il a dit que... »), du code incomplet ou des nombres sans contexte sont des signaux d'alerte.

import random

def audit_chunks(chunks, sample_size=10):
    sample = random.sample(chunks, min(sample_size, len(chunks)))
    for i, chunk in enumerate(sample):
        print(f'--- Chunk {i+1} ({len(chunk)} chars) ---')
        print(chunk[:300])
        print()

Quand la taille des fragments est excessive

Les fragments très volumineux nuisent à la précision de la récupération. Un fragment de 2 000 jetons portant sur un vaste sujet peut correspondre à de nombreuses requêtes, mais fournir trop de contenu parasite au LLM. Le modèle doit trouver une aiguille dans une botte de foin au sein de ce fragment. Des fragments plus petits et ciblés améliorent la précision, au prix du risque de manquer une partie du contexte environnant.

Stratégies pour résoudre ces problèmes

Parmi les meilleures solutions de remplacement à la segmentation naïve de taille fixe figurent : la segmentation aux limites des phrases, qui ne coupe jamais une phrase en son milieu, la segmentation sémantique, qui sépare le texte aux frontières entre sujets, la segmentation parent-enfant, qui préserve un contexte plus large, et la segmentation adaptée aux documents, qui respecte les fonctions de code, les balises HTML et les en-têtes Markdown. Les leçons suivantes présentent chacune de ces méthodes.

Vérification rapide

Testez votre compréhension des modes d'échec de la segmentation présentés dans cette leçon.

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que : la segmentation naïve de taille fixe brise les limites des phrases et des sections, le chevauchement constitue une solution partielle, mais ajoute de la redondance et la qualité des fragments détermine directement le hit rate de la récupération. Nous allons maintenant explorer la segmentation sémantique, qui divise le texte aux frontières naturelles entre sujets à l'aide de la similarité des représentations vectorielles.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours
30
Leçons
120

Questions Fréquemment Posées

La leçon « Pourquoi le découpage naïf nuit à la recherche » est-elle gratuite ?

Oui — le texte complet de « Pourquoi le découpage naïf nuit à la recherche » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours AI Engineering Academy, passe à CoddyKit PRO. Le cours AI Engineering Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Pourquoi le découpage naïf nuit à la recherche » ?

Analysez des échecs réels de recherche dus à un mauvais découpage, notamment les réponses réparties entre plusieurs segments et le contexte perdu dans les en-têtes et les titres de section. Tu pratiques AI Engineering Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer AI Engineering Academy ?

Aucune expérience préalable n'est requise. AI Engineering Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Pourquoi le découpage naïf nuit à la recherche » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon AI Engineering Academy ?

Oui. Chaque leçon AI Engineering Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Pourquoi le découpage naïf nuit à la recherche
  2. Découpage sémantique avec la similarité des plongements
  3. Recherche parent-enfant et du petit vers le grand
  4. Stratégies propres aux documents pour le code et HTML
← Retour à AI Engineering Academy