Stratégies de segmentation des textes longs
Découvrez la segmentation par taille fixe, par limites de phrases et par critères sémantiques.
Stratégies de segmentation des textes longs est une leçon AI Prompt Engineering 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 Prompt Engineering, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours AI Prompt Engineering comprend 4 leçons au total.
Pourquoi les documents longs posent problème
Les LLM disposent d’une fenêtre de contexte — un nombre maximal de jetons qu’ils peuvent traiter simultanément. GPT-4 prend en charge 128 k jetons et Claude 200 k, mais de nombreux documents dépassent même ces limites. Plus important encore, les recherches montrent que la précision des modèles diminue souvent dans les contextes très longs. La segmentation consiste à diviser les documents en parties plus petites avant leur traitement.
Segmentation de taille fixe
La segmentation de taille fixe divise le texte tous les N jetons (ou caractères), quelles que soient les limites du contenu. C’est la stratégie la plus simple et elle ne nécessite aucune compréhension sémantique.
Taille habituelle d’un segment : 500 à 1 000 jetons. Les segments sont faciles à indexer et à récupérer, mais peuvent couper les phrases en leur milieu et faire perdre du sens aux limites.
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)}')Compromis de la segmentation de taille fixe
Avantages :
- Simple à mettre en œuvre — aucun TAL nécessaire
- Tailles de segments prévisibles — gestion plus facile des coûts de l’API
- Traitement rapide
Inconvénients :
- Coupe les phrases et les paragraphes
- Une phrase divisée entre plusieurs segments perd son contexte lors de la recherche
- Peu adaptée au résumé — le segment peut se terminer au milieu d’un argument
Segmentation aux limites des phrases
La segmentation aux limites des phrases divise le texte aux ruptures naturelles entre les phrases ou les paragraphes. Chaque segment se termine par une phrase complète, ce qui évite d’en couper une en deux. Les segments produits sont ainsi plus lisibles et cohérents.
Utilisez un outil de segmentation des phrases (spaCy ou NLTK) pour détecter les limites, puis regroupez les phrases jusqu’à ce que le segment atteigne la taille cible.
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 chunksSegmentation sémantique
La segmentation sémantique va plus loin : elle divise le texte lorsque le sujet change. En vectorisant les phrases adjacentes et en mesurant leur similarité cosinus, nous pouvons détecter le moment où la discussion passe à un nouveau sujet.
Lorsque la similarité descend sous un seuil, insérez une limite de segment. Vous obtenez ainsi des segments cohérents sur le plan thématique, parfaitement adaptés à la génération augmentée par récupération (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 chunksComparer les trois stratégies
Voici une comparaison côte à côte pour vous aider à choisir :
- Taille fixe : limites les plus rapides et les moins précises — à utiliser pour les chaînes de traitement simples
- Limites des phrases : préserve l’intégrité des phrases — à utiliser lorsque la cohérence est importante
- Sémantique : meilleure cohésion thématique — à utiliser pour le RAG lorsque la précision de la recherche est essentielle
En pratique, la segmentation sémantique ajoute de la latence en raison du calcul des représentations vectorielles. Choisissez votre stratégie en fonction des exigences de précision de la recherche.
Segmentation pour les tâches de recherche
Pour la génération augmentée par récupération (RAG), les segments deviennent l’unité de recherche. Une requête utilisateur est vectorisée, puis les segments les plus similaires sont récupérés et injectés dans l’instruction.
Les petits segments (200 à 400 jetons) améliorent la précision de la recherche — chaque segment contient une idée ciblée. Les segments plus grands (800 à 1 000 jetons) fournissent davantage de contexte, mais peuvent inclure du contenu non pertinent à côté du passage recherché.
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]]Segmentation pour les tâches de résumé
Pour le résumé, les segments doivent être suffisamment grands pour contenir un argument ou une section complète. Des segments de 600 à 800 jetons délimités par les phrases donnent de bons résultats.
Chaque segment est résumé indépendamment (l’étape de mise en correspondance), puis les résumés sont réunis dans un résumé final (l’étape de réduction). Il s’agit du motif classique mise en correspondance-réduction, présenté dans la leçon suivante.
Chevauchement : relier les limites des segments
Une technique pratique pour réduire les erreurs aux limites consiste à ajouter un chevauchement entre les segments. Les 100 à 200 derniers jetons du segment N sont répétés au début du segment N+1.
Le chevauchement garantit qu’une phrase traversant une limite apparaît entièrement dans au moins un segment. Cela est particulièrement important pour la recherche : une requête portant sur un sujet qui chevauche une limite correspondra au segment chevauchant.
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 chunksEnrichissement des métadonnées de chaque segment
Chaque segment doit contenir des métadonnées afin que les étapes en aval puissent référencer son origine :
source: nom de fichier ou URLpage: numéro de pagechunk_index: position dans le documentsection: chapitre ou titre
Ces métadonnées sont stockées avec la représentation vectorielle dans une base de données vectorielle (Pinecone, Chroma, Weaviate) et renvoyées avec les segments récupérés afin que le LLM puisse citer ses sources.
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)
]Choisir la bonne stratégie
Guide de décision rapide :
- La vitesse est prioritaire et le contenu est en prose : segmentation aux limites des phrases
- La précision de la recherche est essentielle : segmentation sémantique avec de petits segments (300 jetons)
- Résumer un livre ou un rapport : segmentation aux limites des phrases, segments plus grands (800 jetons), mise en correspondance-réduction
- Documents juridiques ou techniques : segmentation sémantique pour conserver les clauses ensemble
Mesurez toujours le rappel de recherche sur un ensemble représentatif de requêtes avant d’adopter une stratégie.
Vérification des connaissances
Quelle stratégie de segmentation divise le texte lorsque la similarité cosinus entre les plongements de phrases adjacentes passe sous un seuil ?
Récapitulatif : stratégies de segmentation
Vous avez appris trois stratégies fondamentales de segmentation :
- Taille fixe : division toutes les N jetons — rapide, simple, sans tenir compte des limites
- Limites de phrases : division aux séparations naturelles entre les phrases — cohérente, complexité modérée
- Sémantique : division lors des changements de sujet à l’aide de la similarité des plongements — plus précise, coût le plus élevé
Ajoutez un chevauchement entre les segments pour réduire les erreurs aux limites, et associez toujours des métadonnées (source, page, index) afin de permettre la citation et la traçabilité. La prochaine leçon porte sur le modèle de synthèse par mappage-réduction.
Questions Fréquemment Posées
La leçon « Stratégies de segmentation des textes longs » est-elle gratuite ?
Oui — le texte complet de « Stratégies de segmentation des textes longs » 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 Prompt Engineering, passe à CoddyKit PRO. Le cours AI Prompt Engineering comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Stratégies de segmentation des textes longs » ?
Découvrez la segmentation par taille fixe, par limites de phrases et par critères sémantiques. Tu pratiques AI Prompt Engineering 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 Prompt Engineering ?
Aucune expérience préalable n'est requise. AI Prompt Engineering 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 « Stratégies de segmentation des textes longs » ?
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 Prompt Engineering ?
Oui. Chaque leçon AI Prompt Engineering 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
- Stratégies de segmentation des textes longs
- Modèle de résumé Map-Reduce
- Résumé hiérarchique
- Maintenir le contexte entre les segments