Trouver les points de coupure optimaux dans les longs documents à l'aide de petits modèles de langage

Dans nos articles précédents, nous avons exploré les défis du découpage et introduit le concept de découpage tardif, qui aide à réduire la perte de contexte lors de l'intégration des segments. Dans cet article, nous nous concentrerons sur un autre défi : trouver les points de coupure optimaux. Bien que notre stratégie de découpage tardif se soit révélée assez résistante aux limites mal définies, cela ne signifie pas que nous pouvons les ignorer — elles restent importantes tant pour la lisibilité humaine que pour celle des LLM. Voici notre perspective : lors de la détermination des points de coupure, nous pouvons désormais nous concentrer pleinement sur la lisibilité sans nous soucier de la perte sémantique ou contextuelle. Le découpage tardif peut gérer à la fois les bons et les mauvais points de coupure, donc la lisibilité devient votre préoccupation principale.

Dans cette optique, nous avons entraîné trois petits modèles de langage spécifiquement conçus pour segmenter de longs documents tout en maintenant la cohérence sémantique et en gérant des structures de contenu complexes. Ce sont :

jinaai/text-seg-lm-qwen2-0.5b · Hugging Face

We're on a journey to advance and democratize artificial intelligence through open source and open science.

jinaai/text-seg-lm-qwen2-0.5b-cot-topic-chunking · Hugging Face

We're on a journey to advance and democratize artificial intelligence through open source and open science.

jinaai/text-seg-lm-qwen2-0.5b-summary-chunking · Hugging Face

We're on a journey to advance and democratize artificial intelligence through open source and open science.

Dans cet article, nous discuterons des raisons qui nous ont poussés à développer ce modèle, de notre approche pour ses trois variantes, et de leurs performances par rapport à l'API Segmenter de Jina AI. Enfin, nous partagerons ce que nous avons appris et quelques réflexions pour l'avenir.

tagProblème de Segmentation

La segmentation est un élément fondamental des systèmes RAG. La façon dont nous découpons les longs documents en segments cohérents et gérables affecte directement la qualité des étapes de récupération et de génération, influençant tout, de la pertinence des réponses à la qualité des résumés. Les méthodes traditionnelles de segmentation ont produit des résultats corrects mais ne sont pas sans limitations.

Pour paraphraser notre article précédent :

Lors de la segmentation d'un long document, un défi majeur est de décider où créer les segments. Cela peut être fait en utilisant des longueurs fixes de tokens, un nombre défini de phrases, ou des méthodes plus avancées comme les regex et les modèles de segmentation sémantique. Établir des limites de segment précises est crucial, car cela améliore non seulement la lisibilité des résultats de recherche mais garantit aussi que les segments fournis à un LLM dans un système RAG sont à la fois précis et suffisants.

Bien que le découpage tardif améliore les performances de récupération, dans les applications RAG, il est crucial de s'assurer que, autant que possible, chaque segment est significatif en soi, et pas seulement un morceau aléatoire de texte. Les LLM s'appuient sur des données cohérentes et bien structurées pour générer des réponses précises. Si les segments sont incomplets ou manquent de sens, le LLM peut avoir des difficultés avec le contexte et la précision, impactant les performances globales malgré les avantages du découpage tardif. En bref, que vous utilisiez ou non le découpage tardif, avoir une stratégie de segmentation solide est essentiel pour construire un système RAG efficace (comme vous le verrez dans la section benchmark plus bas).

Les méthodes traditionnelles de segmentation, qu'il s'agisse de couper le contenu à des limites simples comme les nouvelles lignes ou les phrases, ou d'utiliser des règles rigides basées sur les tokens, font souvent face aux mêmes limitations. Les deux approches ne tiennent pas compte des limites sémantiques et peinent avec les sujets ambigus, conduisant à des segments fragmentés. Pour relever ces défis, nous avons développé et entraîné un petit modèle de langage spécifiquement pour la segmentation, conçu pour capturer les changements de sujet et maintenir la cohérence tout en restant efficace et adaptable à diverses tâches.

tagPourquoi un Petit Modèle de Langage ?

Nous avons développé un Petit Modèle de Langage (SLM) pour répondre aux limitations spécifiques que nous avons rencontrées avec les techniques de segmentation traditionnelles, particulièrement lors du traitement des extraits de code et d'autres structures complexes comme les tableaux, les listes et les formules. Dans les approches traditionnelles, qui s'appuient souvent sur le comptage de tokens ou des règles structurelles rigides, il était difficile de maintenir l'intégrité du contenu sémantiquement cohérent. Par exemple, les extraits de code étaient fréquemment segmentés en plusieurs parties, brisant leur contexte et rendant plus difficile pour les systèmes en aval de les comprendre ou de les récupérer avec précision.

En entraînant un SLM spécialisé, nous visions à créer un modèle qui pourrait intelligemment reconnaître et préserver ces limites significatives, assurant que les éléments liés restent ensemble. Cela améliore non seulement la qualité de récupération dans les systèmes RAG mais aussi les tâches en aval comme la résumation et les réponses aux questions, où maintenir des segments cohérents et contextuellement pertinents est crucial. L'approche SLM offre une solution plus adaptable et spécifique à la tâche que les méthodes de segmentation traditionnelles, avec leurs limites rigides, ne peuvent simplement pas fournir.

tagEntraînement des SLM : Trois Approches

Nous avons entraîné trois versions de notre SLM :

• simple-qwen-0.5 est le modèle le plus simple, conçu pour identifier les limites basées sur les éléments structurels du document. Sa simplicité en fait une solution efficace pour les besoins de segmentation de base.
• topic-qwen-0.5, inspiré par le raisonnement Chain-of-Thought, pousse la segmentation plus loin en identifiant les sujets dans le texte, comme "le début de la Seconde Guerre mondiale", et en utilisant ces sujets pour définir les limites des segments. Ce modèle assure que chaque segment est cohérent thématiquement, le rendant bien adapté aux documents complexes à sujets multiples. Les tests initiaux ont montré qu'il excelle dans la segmentation du contenu d'une manière qui reflète étroitement l'intuition humaine.
• summary-qwen-0.5 non seulement identifie les limites du texte mais génère aussi des résumés pour chaque segment. Résumer les segments est très avantageux dans les applications RAG, particulièrement pour les tâches comme les questions-réponses sur de longs documents, bien que cela s'accompagne d'un compromis nécessitant plus de données lors de l'entraînement.

Tous les modèles ne retournent que les têtes de segment — une version tronquée de chaque segment. Au lieu de générer des segments entiers, les modèles produisent des points clés ou des sous-sujets, ce qui améliore la détection des limites et la cohérence en se concentrant sur les transitions sémantiques plutôt que de simplement copier le contenu d'entrée. Lors de la récupération des segments, le texte du document est divisé sur la base de ces têtes de segment, et les segments complets sont reconstruits en conséquence.

tagJeu de données

Nous avons utilisé le jeu de données wiki727k, une collection à grande échelle d'extraits de texte structurés tirés d'articles Wikipédia. Il contient plus de 727 000 sections de texte, chacune représentant une partie distincte d'un article Wikipédia, comme une introduction, une section ou une sous-section.

GitHub - koomri/text-segmentation : Implémentation de l'article : Text Segmentation as a Supervised Learning Task

Implémentation de l'article : Text Segmentation as a Supervised Learning Task - koomri/text-segmentation

GitHubkoomri

tagAugmentation des données

Pour générer des paires d'entraînement pour chaque variante du modèle, nous avons utilisé GPT-4 pour augmenter nos données. Pour chaque article de notre jeu de données d'entraînement, nous avons envoyé l'invite :

f"""
Generate a five to ten words topic and a one sentence summary for this chunk of text.
```
{text}
```
Make sure the topic is concise and the summary covers the main topic as much as possible.

Please respond in the following format:
```
Topic: ...
Summary: ...
```

Directly respond with the required topic and summary, do not include any other details, and do not surround your response with quotes, backticks or other separators.
   """.strip()
Copier

Nous avons utilisé un découpage simple pour générer des sections à partir de chaque article, en découpant sur \\n\\n\\n, puis en sous-découpant sur \\n\\n pour obtenir ce qui suit (dans ce cas, un article sur Common Gateway Interface) :

[
    [
      "In computing, Common Gateway Interface (CGI) offers a standard protocol for web servers to execute programs that execute like Console applications (also called Command-line interface programs) running on a server that generates web pages dynamically.",
      "Such programs are known as \\"CGI scripts\\" or simply as \\"CGIs\\".",
      "The specifics of how the script is executed by the server are determined by the server.",
      "In the common case, a CGI script executes at the time a request is made and generates HTML."
    ],
    [
      "In 1993 the National Center for Supercomputing Applications (NCSA) team wrote the specification for calling command line executables on the www-talk mailing list; however, NCSA no longer hosts the specification.",
      "The other Web server developers adopted it, and it has been a standard for Web servers ever since.",
      "A work group chaired by Ken Coar started in November 1997 to get the NCSA definition of CGI more formally defined.",
      "This work resulted in RFC 3875, which specified CGI Version 1.1.",
      "Specifically mentioned in the RFC are the following contributors: \\n1. Alice Johnson\\n2. Bob Smith\\n3. Carol White\\n4. David Nguyen\\n5. Eva Brown\\n6. Frank Lee\\n7. Grace Kim\\n8. Henry Carter\\n9. Ingrid Martinez\\n10. Jack Wilson",
      "Historically CGI scripts were often written using the C language.",
      "RFC 3875 \\"The Common Gateway Interface (CGI)\\" partially defines CGI using C, as in saying that environment variables \\"are accessed by the C library routine getenv() or variable environ\\"."
    ],
    [
      "CGI is often used to process inputs information from the user and produce the appropriate output.",
      "An example of a CGI program is one implementing a Wiki.",
      "The user agent requests the name of an entry; the Web server executes the CGI; the CGI program retrieves the source of that entry's page (if one exists), transforms it into HTML, and prints the result.",
      "The web server receives the input from the CGI and transmits it to the user agent.",
      "If the \\"Edit this page\\" link is clicked, the CGI populates an HTML textarea or other editing control with the page's contents, and saves it back to the server when the user submits the form in it.\\n",
      "\\n# CGI script to handle editing a page\\ndef handle_edit_request(page_content):\\n    html_form = f'''\\n    <html>\\n    <body>\\n        <form action=\\"/save_page\\" method=\\"post\\">\\n            <textarea name=\\"page_content\\" rows=\\"20\\" cols=\\"80\\">\\n            {page_content}\\n            </textarea>\\n            <br>\\n            <input type=\\"submit\\" value=\\"Save\\">\\n        </form>\\n    </body>\\n    </html>\\n    '''\\n    return html_form\\n\\n# Example usage\\npage_content = \\"Existing content of the page.\\"\\nhtml_output = handle_edit_request(page_content)\\nprint(\\"Generated HTML form:\\")\\nprint(html_output)\\n\\ndef save_page(page_content):\\n    with open(\\"page_content.txt\\", \\"w\\") as file:\\n        file.write(page_content)\\n    print(\\"Page content saved.\\")\\n\\n# Simulating form submission\\nsubmitted_content = \\"Updated content of the page.\\"\\nsave_page(submitted_content)"
    ],
    [
      "Calling a command generally means the invocation of a newly created process on the server.",
      "Starting the process can consume much more time and memory than the actual work of generating the output, especially when the program still needs to be interpreted or compiled.",
      "If the command is called often, the resulting workload can quickly overwhelm the server.",
      "The overhead involved in process creation can be reduced by techniques such as FastCGI that \\"prefork\\" interpreter processes, or by running the application code entirely within the web server, using extension modules such as mod_perl or mod_php.",
      "Another way to reduce the overhead is to use precompiled CGI programs, e.g.",
      "by writing them in languages such as C or C++, rather than interpreted or compiled-on-the-fly languages such as Perl or PHP, or by implementing the page generating software as a custom webserver module.",
      "Several approaches can be adopted for remedying this: \\n1. Implementing stricter regulations\\n2. Providing better education and training\\n3. Enhancing technology and infrastructure\\n4. Increasing funding and resources\\n5. Promoting collaboration and partnerships\\n6. Conducting regular audits and assessments",
      "The optimal configuration for any Web application depends on application-specific details, amount of traffic, and complexity of the transaction; these tradeoffs need to be analyzed to determine the best implementation for a given task and time budget."
    ]
  ],
Copier

Nous avons ensuite généré une structure JSON avec les sections, les sujets et les résumés :

{
  "sections": [
    [
      "In computing, Common Gateway Interface (CGI) offers a standard protocol for web servers to execute programs that execute like Console applications (also called Command-line interface programs) running on a server that generates web pages dynamically.",
      "Such programs are known as \\"CGI scripts\\" or simply as \\"CGIs\\".",
      "The specifics of how the script is executed by the server are determined by the server.",
      "In the common case, a CGI script executes at the time a request is made and generates HTML."
    ],
    [
      "In 1993 the National Center for Supercomputing Applications (NCSA) team wrote the specification for calling command line executables on the www-talk mailing list; however, NCSA no longer hosts the specification.",
      "The other Web server developers adopted it, and it has been a standard for Web servers ever since.",
      "A work group chaired by Ken Coar started in November 1997 to get the NCSA definition of CGI more formally defined.",
      "This work resulted in RFC 3875, which specified CGI Version 1.1.",
      "Specifically mentioned in the RFC are the following contributors: \\n1. Alice Johnson\\n2. Bob Smith\\n3. Carol White\\n4. David Nguyen\\n5. Eva Brown\\n6. Frank Lee\\n7. Grace Kim\\n8. Henry Carter\\n9. Ingrid Martinez\\n10. Jack Wilson",
      "Historically CGI scripts were often written using the C language.",
      "RFC 3875 \\"The Common Gateway Interface (CGI)\\" partially defines CGI using C, as in saying that environment variables \\"are accessed by the C library routine getenv() or variable environ\\"."
    ],
    [
      "CGI is often used to process inputs information from the user and produce the appropriate output.",
      "An example of a CGI program is one implementing a Wiki.",
      "The user agent requests the name of an entry; the Web server executes the CGI; the CGI program retrieves the source of that entry's page (if one exists), transforms it into HTML, and prints the result.",
      "The web server receives the input from the CGI and transmits it to the user agent.",
      "If the \\"Edit this page\\" link is clicked, the CGI populates an HTML textarea or other editing control with the page's contents, and saves it back to the server when the user submits the form in it.\\n",
      "\\n# CGI script to handle editing a page\\ndef handle_edit_request(page_content):\\n    html_form = f'''\\n    <html>\\n    <body>\\n        <form action=\\"/save_page\\" method=\\"post\\">\\n            <textarea name=\\"page_content\\" rows=\\"20\\" cols=\\"80\\">\\n            {page_content}\\n            </textarea>\\n            <br>\\n            <input type=\\"submit\\" value=\\"Save\\">\\n        </form>\\n    </body>\\n    </html>\\n    '''\\n    return html_form\\n\\n# Example usage\\npage_content = \\"Existing content of the page.\\"\\nhtml_output = handle_edit_request(page_content)\\nprint(\\"Generated HTML form:\\")\\nprint(html_output)\\n\\ndef save_page(page_content):\\n    with open(\\"page_content.txt\\", \\"w\\") as file:\\n        file.write(page_content)\\n    print(\\"Page content saved.\\")\\n\\n# Simulating form submission\\nsubmitted_content = \\"Updated content of the page.\\"\\nsave_page(submitted_content)"
    ],
    [
      "Calling a command generally means the invocation of a newly created process on the server.",
      "Starting the process can consume much more time and memory than the actual work of generating the output, especially when the program still needs to be interpreted or compiled.",
      "If the command is called often, the resulting workload can quickly overwhelm the server.",
      "The overhead involved in process creation can be reduced by techniques such as FastCGI that \\"prefork\\" interpreter processes, or by running the application code entirely within the web server, using extension modules such as mod_perl or mod_php.",
      "Another way to reduce the overhead is to use precompiled CGI programs, e.g.",
      "by writing them in languages such as C or C++, rather than interpreted or compiled-on-the-fly languages such as Perl or PHP, or by implementing the page generating software as a custom webserver module.",
      "Several approaches can be adopted for remedying this: \\n1. Implementing stricter regulations\\n2. Providing better education and training\\n3. Enhancing technology and infrastructure\\n4. Increasing funding and resources\\n5. Promoting collaboration and partnerships\\n6. Conducting regular audits and assessments",
      "The optimal configuration for any Web application depends on application-specific details, amount of traffic, and complexity of the transaction; these tradeoffs need to be analyzed to determine the best implementation for a given task and time budget."
    ]
  ],
  "topics": [
    "Common Gateway Interface in Web Servers",
    "The History and Standardization of CGI",
    "CGI Scripts for Editing Web Pages",
    "Reducing Web Server Overhead in Command Invocation"
  ],
  "summaries": [
    "CGI provides a protocol for web servers to run programs that generate dynamic web pages.",
    "The NCSA initially defined CGI in 1993, leading to its adoption as a standard for Web servers and later formalization in RFC 3875 chaired by Ken Coar.",
    "This text describes how a CGI script can handle editing and saving web page content through HTML forms.",
    "The text discusses techniques to minimize server overhead from frequent command invocation, including process preforking, using precompiled CGI programs, and implementing custom web server modules."
  ]
}
Copier

Nous avons également ajouté du bruit en mélangeant les données, en ajoutant des caractères/mots/lettres aléatoires, en supprimant aléatoirement la ponctuation, et en supprimant systématiquement les caractères de nouvelle ligne.

Tout cela peut contribuer en partie au développement d'un bon modèle - mais seulement jusqu'à un certain point. Pour vraiment optimiser les performances, nous avions besoin que le modèle crée des segments cohérents sans déstructurer les extraits de code. Pour cela, nous avons enrichi le jeu de données avec du code, des formules et des listes générés par GPT-4o.

tagLa Configuration de l'Entraînement

Pour l'entraînement des modèles, nous avons mis en place la configuration suivante :

• Framework : Nous avons utilisé la bibliothèque transformers de Hugging Face intégrée à Unsloth pour l'optimisation du modèle. Cela a été crucial pour optimiser l'utilisation de la mémoire et accélérer l'entraînement, rendant possible l'entraînement efficace de petits modèles avec de grands jeux de données.
• Optimiseur et Planificateur : Nous avons utilisé l'optimiseur AdamW avec un taux d'apprentissage linéaire et des étapes de préchauffage, nous permettant de stabiliser le processus d'entraînement pendant les époques initiales.
• Suivi des Expériences : Nous avons suivi tous les entraînements en utilisant Weights & Biases, et enregistré les métriques clés comme les pertes d'entraînement et de validation, les changements de taux d'apprentissage et la performance globale du modèle. Ce suivi en temps réel nous a fourni des insights sur la progression des modèles, permettant des ajustements rapides si nécessaire pour optimiser les résultats d'apprentissage.

tagL'Entraînement en Lui-même

En utilisant qwen2-0.5b-instruct comme modèle de base, nous avons entraîné trois variantes de notre SLM avec Unsloth, chacune avec une stratégie de segmentation différente. Pour nos échantillons, nous avons utilisé des paires d'entraînement, composées du texte d'un article de wiki727k et des sections, topics, ou summaries résultants (mentionnés ci-dessus dans la section "Augmentation des Données") selon le modèle entraîné.

• simple-qwen-0.5 : Nous avons entraîné simple-qwen-0.5 sur 10 000 échantillons avec 5 000 étapes, obtenant une convergence rapide et détectant efficacement les frontières entre les sections cohérentes du texte. La perte d'entraînement était de 0,16.
• topic-qwen-0.5 : Comme simple-qwen-0.5, nous avons entraîné topic-qwen-0.5 sur 10 000 échantillons avec 5 000 étapes, obtenant une perte d'entraînement de 0,45.
• summary-qwen-0.5 : Nous avons entraîné summary-qwen-0.5 sur 30 000 échantillons avec 15 000 étapes. Ce modèle s'est montré prometteur mais a eu une perte plus élevée (0,81) pendant l'entraînement, suggérant le besoin de plus de données (environ le double de notre compte d'échantillons initial) pour atteindre son plein potentiel.

tagLes Segments Eux-mêmes

Voici des exemples de trois segments consécutifs pour chaque stratégie de segmentation, avec l'API Jina Segmenter. Pour produire ces segments, nous avons d'abord utilisé Jina Reader pour extraire un article du blog Jina AI en texte brut (incluant toutes les données de la page, comme les en-têtes, pieds de page, etc.), puis nous l'avons passé à chaque méthode de segmentation.

Can Embedding/Reranker Models Compare Numbers?

A lot of LLMs can't figure out that 9.11 is actually smaller than 9.9. Can our embedding and reranker models do any better?

tagAPI Jina Segmenter

L'API Jina Segmenter a adopté une approche très granulaire pour segmenter l'article, divisant sur des caractères comme \n, \t, etc., pour découper le texte en segments souvent très petits. En regardant simplement les trois premiers, elle a extrait search\\n, notifications\\n et NEWS\\n de la barre de navigation du site, mais rien de pertinent au contenu de l'article lui-même :

Plus loin, nous avons enfin obtenu quelques segments du contenu réel de l'article, bien que peu de contexte ait été conservé dans chacun :

(Par souci d'équité, nous avons montré plus de segments pour l'API Segmenter que pour les modèles, simplement parce qu'autrement elle aurait eu très peu de segments significatifs à montrer)

tagsimple-qwen-0.5

simple-qwen-0.5 a décomposé l'article de blog en se basant sur la structure sémantique, extrayant des segments beaucoup plus longs qui avaient un sens cohérent :

tagtopic-qwen-0.5

topic-qwen-0.5 a d'abord identifié les sujets basés sur le contenu du document, puis segmenté le document en fonction de ces sujets :

tagsummary-qwen-0.5

summary-qwen-0.5 a identifié les limites des segments et généré un résumé du contenu au sein de chaque segment :

tagÉvaluation Comparative des Modèles

Pour évaluer les performances de nos modèles, nous avons extrait huit articles de blog du blog Jina AI et généré six questions et réponses de référence en utilisant GPT-4o.

Nous avons appliqué chaque méthode de segmentation, y compris l'API Jina Segmenter, à ces articles de blog, puis généré des embeddings pour les segments résultants en utilisant jina-embeddings-v3, sans découpage tardif ni reclassement.

Jina Embeddings v3: A Frontier Multilingual Embedding Model

jina-embeddings-v3 is a frontier multilingual text embedding model with 570M parameters and 8192 token-length, outperforming the latest proprietary embeddings from OpenAI and Cohere on MTEB.

Chaque ensemble de segments a ensuite été indexé séparément et nous avons utilisé un système RAG pour interroger chaque index avec les questions précédemment générées.

Pour mesurer les performances, nous avons comparé les réponses générées à partir de l'index de chaque méthode de segmentation avec les réponses de référence en utilisant les scores F1 de l'évaluation ROUGE-L, où des scores plus élevés indiquent de meilleures performances.

Par exemple, pour la question : "Quels facteurs influencent les capacités de comparaison numérique du modèle jina-embeddings-v2-base-en ?", nous avons reçu les réponses suivantes :

tagVérité terrain (Générée par GPT-4o à partir du texte complet) :

"The two key factors are tokenization and training data. Tokenization determines how numbers are segmented into tokens, and training data influences numerical reasoning abilities."
Copier

tagJina Segmenter API (score : 0,166667)

"The context does not provide specific factors that impact the numerical comparison abilities of the jina-embeddings-v2-base-en model."
Copier

tagsimple-qwen-0.5 (score : 0,279070)

"The numerical comparison abilities of the jina-embeddings-v2-base-en model are impacted by tokenization and training data."
Copier

tagtopic-qwen-0.5 (score : 0,190476)

"The numerical comparison abilities of the jina-embeddings-v2-base-en model are impacted by factors such as tokenization and its ability to handle different numerical formats, including small integers, large numbers, floats, negative numbers, currency, dates, and times."
Copier

tagsummary-qwen-0.5 (0,318182)

"The factors impacting the numerical comparison abilities of the jina-embeddings-v2-base-en model are tokenization and training data."
Copier

Nous avons également évalué la vitesse de chaque méthode (en chronométrant le temps nécessaire pour générer et intégrer les segments) et estimé l'espace disque (en multipliant le nombre d'embeddings par la taille d'un seul embedding de 1024 dimensions de jina-embeddings-v3). Cela nous a permis d'évaluer à la fois la précision et l'efficacité des différentes stratégies de segmentation.

tagPrincipales conclusions

Après avoir testé les variantes du modèle les unes contre les autres et contre l'API Jina Segmenter, nous avons constaté que les nouveaux modèles montraient effectivement des scores améliorés avec les trois méthodes, particulièrement la segmentation par sujet :

Cependant, il serait intéressant d'examiner les résultats avec la fonction de chunking tardif de jina-embeddings-v3, qui augmente la pertinence contextuelle des embeddings de segments, fournissant des résultats plus pertinents. Cela pourrait faire l'objet d'un futur article de blog.

Concernant la vitesse, il peut être difficile de comparer les nouveaux modèles à Jina Segmenter, puisque ce dernier est une API, tandis que nous avons exécuté les trois modèles sur un GPU Nvidia 3090. Comme vous pouvez le voir, tout gain de performance pendant l'étape rapide de segmentation de l'API Segmenter est rapidement dépassé par le besoin de générer des embeddings pour autant de segments :

Naturellement, plus de segments signifie plus d'embeddings. Et ces embeddings prennent beaucoup d'espace : les embeddings pour les huit articles de blog que nous avons testés ont pris plus de 21 Mo avec l'API Segmenter, tandis que la segmentation par résumé n'en prenait que 468 Ko. Cela, plus les scores ROUGE plus élevés de nos modèles, signifie moins de segments mais de meilleurs segments, économisant de l'argent et augmentant les performances :

tagCe que nous avons appris

tagLa formulation du problème est cruciale

Une découverte clé a été l'impact de notre façon de cadrer la tâche. En faisant générer les en-têtes de segments par le modèle, nous avons amélioré la détection des limites et la cohérence en nous concentrant sur les transitions sémantiques plutôt que de simplement copier-coller le contenu d'entrée en segments distincts. Cela a également permis d'obtenir un modèle de segmentation plus rapide, car la génération de moins de texte a permis au modèle de terminer la tâche plus rapidement.

tagLes données générées par LLM sont efficaces

L'utilisation de données générées par LLM, en particulier pour du contenu complexe comme les listes, les formules et les extraits de code, a élargi l'ensemble d'entraînement du modèle et amélioré sa capacité à gérer diverses structures de documents. Cela a rendu le modèle plus adaptable à différents types de contenu, un avantage crucial lors du traitement de documents techniques ou structurés.

tagCollationnement des données de sortie uniquement

En utilisant un collateur de données de sortie uniquement, nous avons veillé à ce que le modèle se concentre sur la prédiction des tokens cibles pendant l'entraînement, plutôt que de simplement copier depuis l'entrée. Le collateur de sortie uniquement a permis au modèle d'apprendre à partir des séquences cibles réelles, en mettant l'accent sur les complétions ou les limites correctes. Cette distinction a permis au modèle de converger plus rapidement en évitant le surajustement à l'entrée et l'a aidé à mieux généraliser sur différents jeux de données.

tagEntraînement efficace avec Unsloth

Avec Unsloth, nous avons rationalisé l'entraînement de notre petit modèle de langage, réussissant à l'exécuter sur un GPU Nvidia 4090. Ce pipeline optimisé nous a permis d'entraîner un modèle efficace et performant sans avoir besoin de ressources de calcul massives.

tagGestion des textes complexes

Les modèles de segmentation ont excellé dans le traitement de documents complexes contenant du code, des tableaux et des listes, qui sont généralement difficiles à gérer avec des méthodes plus traditionnelles. Pour le contenu technique, des stratégies sophistiquées comme topic-qwen-0.5 et summary-qwen-0.5 se sont révélées plus efficaces, avec le potentiel d'améliorer les tâches RAG en aval.

tagMéthodes simples pour du contenu plus simple

Pour du contenu simple axé sur la narration, des méthodes plus basiques comme l'API Segmenter sont souvent suffisantes. Les stratégies de segmentation avancées peuvent n'être nécessaires que pour du contenu plus complexe et structuré, permettant une flexibilité selon le cas d'utilisation.

tagProchaines étapes

Bien que cette expérience ait été conçue principalement comme une preuve de concept, si nous devions la poursuivre, nous pourrions apporter plusieurs améliorations. Premièrement, bien que la poursuite de cette expérience spécifique soit peu probable, l'entraînement de summary-qwen-0.5 sur un jeu de données plus important — idéalement 60 000 échantillons au lieu de 30 000 — conduirait probablement à des performances plus optimales. De plus, affiner notre processus d'évaluation serait bénéfique. Au lieu d'évaluer les réponses générées par le LLM du système RAG, nous nous concentrerions plutôt sur la comparaison directe des segments récupérés avec la vérité terrain. Enfin, nous irions au-delà des scores ROUGE et adopterions des métriques plus avancées (possiblement une combinaison de ROUGE et de scoring LLM) qui captent mieux les nuances de la qualité de la récupération et de la segmentation.

tagConclusion

Dans cette expérience, nous avons exploré comment des modèles de segmentation personnalisés conçus pour des tâches spécifiques peuvent améliorer les performances du RAG. En développant et en entraînant des modèles comme simple-qwen-0.5, topic-qwen-0.5, et summary-qwen-0.5, nous avons abordé les défis clés rencontrés dans les méthodes de segmentation traditionnelles, particulièrement en maintenant la cohérence sémantique et en gérant efficacement le contenu complexe comme les extraits de code. Parmi les modèles testés, topic-qwen-0.5 a constamment fourni la segmentation la plus significative et contextuellement pertinente, en particulier pour les documents multi-thématiques.

Bien que les modèles de segmentation fournissent la base structurelle nécessaire aux systèmes RAG, ils servent une fonction différente par rapport au découpage tardif, qui optimise les performances de récupération en maintenant la pertinence contextuelle entre les segments. Ces deux approches peuvent être complémentaires, mais la segmentation est particulièrement cruciale lorsque vous avez besoin d'une méthode qui se concentre sur la division des documents pour des flux de travail de génération cohérents et spécifiques à la tâche.