Introduction

Dans mon article de blog précédent, en construisant un chiffon agentique multi-documents à l'aide de Llamaindex, j'ai démontré comment créer un système de génération (RAG) (RAG) de récupération qui pourrait gérer et interroger sur trois documents à l'aide de Llamaindex. Bien que ce soit un début puissant, les applications du monde réel nécessitent souvent la capacité de gérer un plus grand corpus de documents.

Ce blog se concentrera sur la mise à l'échelle de ce système de trois documents à onze ans et au-delà. Nous plongerons dans le code, les défis de la mise à l'échelle et la fa?on de construire un agent efficace qui peut récupérer dynamiquement des informations à partir d'un ensemble plus important de sources.

Objectifs d'apprentissage

• Comprendre la mise à l'échelle du système de chiffon agentique multi-documents de la gestion de quelques documents à plus de 10 documents à l'aide de Llamaindex.
• Apprenez à construire et à intégrer des mécanismes de requête basés sur des outils pour améliorer les modèles de chiffon.
• Comprendre l'utilisation de VectorStoreIndex et d'ObjecteIndex dans la récupération efficace des documents et des outils pertinents.
• Implémentez un agent dynamique capable de répondre aux requêtes complexes en récupérant des articles pertinents à partir d'un large ensemble de documents.
• Identifiez les défis et les meilleures pratiques lors de la mise à l'échelle des systèmes de chiffon vers plusieurs documents.

Cet article a été publié dans le cadre du Blogathon de la science des données.

Table des matières

• Introduction
• étapes clés impliquées
• Défis clés de l'échelle de 10 documents
• Implémentation du code pour gérer 10 documents
• Amélioration du chiffon agentique avec récupération d'outils
• Interroger sur 11 documents
• Résultats et informations sur les performances
• Conclusion
• Questions fréquemment posées

étapes clés impliquées

Dans le blog précédent, j'ai introduit le concept de chiffon agentique - une approche où nous combinons la recherche d'informations avec des modèles génératifs pour répondre aux requêtes utilisateur à l'aide de documents externes pertinents. Nous avons utilisé Llamaindex pour construire un chiffon agentique simple et multi-documents, qui pourrait interroger trois documents.

Les étapes clés impliquées:

• Ingestion de document: Utilisation de simplerectoryReader pour charger et diviser les documents en morceaux.
• Création d'index: tirant parti de VectorStoreIndex pour la recherche sémantique et SummaryIndex pour le résumé.
• Configuration de l'agent: l'intégration de l'API d'Openai pour répondre aux requêtes en récupérant des morceaux d'informations pertinentes à partir des documents.

Bien que cette configuration ait bien fonctionné pour un petit nombre de documents, nous avons rencontré des défis d'évolutivité. Alors que nous nous étendons au-delà de trois documents, des problèmes tels que la gestion des outils, les frais généraux de performance et les réponses de requête plus lents sont apparues. Ce message relève ces défis.

Défis clés de l'échelle de 10 documents

La mise à l'échelle de 11 documents ou plus introduit plusieurs complexités:

Considérations de performance

La requête sur plusieurs documents augmente la charge de calcul, en particulier en termes d'utilisation de la mémoire et de temps de réponse. Lorsque le système traite un plus grand nombre de documents, assurer des réponses rapides et précises devient un défi principal.

Gestion des outils

Chaque document est associé à son propre outil de récupération et de résumé, ce qui signifie que le système a besoin d'un mécanisme robuste pour gérer efficacement ces outils.

Efficacité de l'indice

Avec 11 documents, l'utilisation du VectorStoreIndex devient plus complexe. Plus l'index est grand, plus le système doit passer au crible pour trouver des informations pertinentes, ce qui augmente potentiellement les temps de requête. Nous discuterons de la fa?on dont Llamaindex gère efficacement ces défis avec ses techniques d'indexation.

Implémentation du code pour gérer 10 documents

Plongeons dans la mise en ?uvre pour faire passer notre chiffon agentique de trois à 11 documents.

Collection de documents

Voici les 11 articles avec lesquels nous travaillerons:

• Métagpte
• Longlora
• Loft-Q
• Banc de swe
• Selfrag
• Zipformateur
• Valeurs
• Diffusion de la foire Finetune
• Carte de connaissance
• Métra
• VR-MCL

La première étape consiste à télécharger les papiers. Voici le code Python pour automatiser ceci:

 URL = [
    "https://openreview.net/pdf?id=vtmbagcn7o",
    "https://openreview.net/pdf?id=6pmjorfdak",
    "https://openreview.net/pdf?id=lzpwwpady4",
    "https://openreview.net/pdf?id=vtf8ynqm66",
    "https://openreview.net/pdf?id=hsyw5go0v8",
    "https://openreview.net/pdf?id=9wd9kwssyt",
    "https://openreview.net/pdf?id=yv6fd7lykf",
    "https://openreview.net/pdf?id=hnrb5yhoyu",
    "https://openreview.net/pdf?id=wbwtoyizik",
    "https://openreview.net/pdf?id=c5pwl0soay",
    "https://openreview.net/pdf?id=tpd2ag1h0d"
]]

papiers = [
    "metagpt.pdf",
    "longlora.pdf",
    "loftq.pdf",
    "swebench.pdf",
    "selfrag.pdf",
    "zipformer.pdf",
    "valeurs.pdf",
    "finetune_fair_diffusion.pdf",
    "Knowledge_card.pdf",
    "métra.pdf",
    "vr_mcl.pdf"
]]

# Télécharger les papiers
Pour URL, papier dans ZIP (URL, papiers):
    ! wget "{url}" -o "{papier}"

Configuration de l'outil

Une fois les documents téléchargés, l'étape suivante consiste à créer les outils requis pour interroger et résumer chaque document.

 de Llama_index.core Import SimpledirectoryReader, VectorStoreIndex, SummaryIndex
de lama_index.core.node_parser importation de phrasesplitter
De Llama_index.core.tools Import FunctionTool, QueryEnginetool
de lama_index.core.vector_stores Importer des métadatafilters, FilterCondition
à partir de la liste des importations, facultative

def get_doc_tools (
    file_path: str,
    Nom: Str,
) -> str:
    "" "Obtenez des outils de requête vectorielle et de résumé d'un document." ""

    # Documents de chargement
    Documents = SimpleDirectoryReader (input_files = [file_path]). Load_data ()
    SPLITTER = SENDENSPLITTER (Chunk_Size = 1024)
    n?uds = splitter.get_nodes_from_documents (documents)
    vector_index = vectorstoreIndex (n?uds)
    
    DEF Vector_Query (
        requête: str, 
        page_numbres: facultatif [list [str]] = aucun
    ) -> str:
        "" "Utiliser pour répondre aux questions sur un papier donné.
    
        Utile si vous avez des questions spécifiques sur le document.
        Laissez toujours Page_numbers comme aucun à moins qu'il n'y ait une page spécifique que vous souhaitez rechercher.
    
        Args:
            requête (str): la requête de cha?ne à intégrer.
            Page_Numbers (facultatif [list [str]]): filtrez par jeu de pages. Partir comme aucun 
                Si nous voulons effectuer une recherche vectorielle
                sur toutes les pages. Sinon, filtrez par l'ensemble des pages spécifiées.
        
        "" "
    
        page_numbers = page_numbers ou []
        métadata_dicts = [
            {"key": "page_label", "valeur": p} pour p dans page_numbers
        ]]
        
        Query_Engine = vector_index.as_query_engine (
            similitude_top_k = 2,
            filtres = métadatafilters.from_dicts (
                Metadata_dicts,
                condition = filtercondition.or
            )
        )
        réponse = query_engine.query (Query)
        Réponse de retour
        
    
    vector_query_tool = functiontool.from_defaults (
        name = f "vector_tool_ {name}",
        fn = vector_query
    )
    
    résumé_index = résumé (n?uds)
    Summary_Query_Engine = Summary_index.as_Query_Engine (
        réponse_mode = "arbre_summarisé",
        use_async = true,
    )
    résumé_tool = queryenginetool.from_defaults (
        name = f "Summary_tool_ {name}",
        Query_Engine = Summary_Query_Engine,
        Description = (
            f "Utile pour les questions de résumé liées à {nom}"
        ),
    )

    return vector_query_tool, résumé_tool

Cette fonction génère des outils de requête vectoriels et de résumé pour chaque document, permettant au système de gérer efficacement les requêtes et de générer des résumés.

Amélioration du chiffon agentique avec récupération d'outils

Nous allons maintenant améliorer le chiffon agentique avec la récupération d'outils.

Construire l'agent

Ensuite, nous devons étendre l'agent avec la possibilité de récupérer et de gérer des outils à partir des 11 documents.

 De utils import get_doc_tools
à partir du chemin d'importation Pathlib

Paper_to_tools_dict = {}
pour le papier dans les papiers:
    print (f "Obtenir des outils pour papier: {papier}")
    vector_tool, résumé_tool = get_doc_tools (papier, chemin (papier) .stem)
    Paper_to_tools_dict [papier] = [vector_tool, résumé_tool]

all_tools = [t pour le papier dans les papiers pour t dans papier_to_tools_dict [papier]]

La sortie ressemblera ci-dessous:

Récupération d'outils

L'étape suivante consiste à créer un index ?objet? sur ces outils et à créer un système de récupération qui peut retirer dynamiquement les outils pertinents pour une requête donnée.

 De Llama_index.core Import VectorStoreIndex
de Llama_index.core.Objects Import ObjectIndex

obj_index = objectiveIndex.from_objects (
    all_tools,
    index_cls = vectorstoreIndex,
)
obj_retriever = obj_index.as_retriever (similitude_top_k = 3)

Désormais, le système peut récupérer les outils les plus pertinents en fonction de la requête.

Voyons un exemple:

 Tools = obj_retriever.RetReeve (
    "Parlez-moi de l'ensemble de données EVAL utilisé dans Metagpt et Swe-Bench"
)

#retrieves 3 objets, voyons le 3ème
Imprimer (outils [2] .Metadata)

Configuration de l'agent

Maintenant, nous intégrons l'outil Retriever dans le Runner Agent, en garantissant qu'il sélectionne dynamiquement les meilleurs outils pour répondre à chaque requête.

 De Llama_index.core.Agent Import FunctionCallingAgentworker
De Llama_index.core.Agent Import Agentrunner

agent_worker = functioncallingagentworker.from_tools (
    TOLL_RETRIEVER = OBJ_RETRIEVER,
    llm = llm, 
    system_prompt = "" "\
Vous êtes un agent con?u pour répondre aux requêtes sur un ensemble de papiers donnés.
Veuillez toujours utiliser les outils fournis pour répondre à une question. Ne comptez pas sur les connaissances antérieures. \

"" ",
    Verbose = vrai
)
agent = agentrunner (agent_worker)

Interroger sur 11 documents

Voyons comment le système fonctionne lors de l'interrogation sur plusieurs documents. Nous interrogerons les articles MetAgpt et Swe-Bench pour comparer leurs ensembles de données d'évaluation.

 Response = Agent.Query ("Parlez-moi de l'ensemble de données d'évaluation utilisé dans MetAgpt et comparez-le avec Swe-Bench")
print (str (réponse))

Sortir:

Voyons un autre exemple

 réponse = agent.query (
    "Comparez et contrastez les papiers LORA (Longlora, Loftq). Analysez d'abord l'approche de chaque article."
)
print (str (réponse))

Sortir:

Résultats et informations sur les performances

Nous allons maintenant explorer les résultats et les informations sur les performances ci-dessous:

Métriques de performance

Lors de la mise à l'échelle de 11 documents, les performances sont restées robustes, mais nous avons observé une augmentation des temps de requête d'environ 15 à 20% par rapport à la configuration à 3 documents. Cependant, la précision globale de la récupération est restée cohérente.

Analyse d'évolutivité

Le système est très évolutif grace à la partie et à l'indexation efficaces de Llamaindex. En gérant soigneusement les outils, nous avons pu gérer 11 documents avec un minimum de frais généraux. Cette approche peut être élargie pour soutenir encore plus de documents, permettant une croissance plus approfondie des applications du monde réel.

Conclusion

La mise à l'échelle de trois à 11 documents est une étape importante dans la construction d'un système de chiffon robuste. Cette approche tire parti de Llamaindex pour gérer de grands ensembles de documents tout en maintenant les performances et la réactivité du système.

Je vous encourage à essayer de mettre à l'échelle vos propres systèmes de génération auprès de la récupération à l'aide de Llamaindex et à partager vos résultats. N'hésitez pas à consulter mon blog précédent ici pour commencer!

Consultez le code complet et les ressources sur GitHub.

Principaux à retenir

• Il est possible de mettre à l'échelle un système de génération (RAG) (RAG) de récupération pour gérer plus de documents en utilisant des méthodes d'indexation efficaces comme VectorStoreIndex et ObjectIndex.
• En attribuant des outils spécifiques aux documents (recherche de vecteur, outils récapitulatifs), les agents peuvent tirer parti des méthodes spécialisées pour récupérer des informations, améliorer la précision de la réponse.
• L'utilisation de l'Agentrunner avec une récupération d'outils permet aux agents de sélectionner intelligemment et d'appliquer les bons outils en fonction de la requête, ce qui rend le système plus flexible et adaptatif.
• Même lorsqu'ils traitent d'un grand nombre de documents, les systèmes de chiffon peuvent maintenir la réactivité et la précision en récupérant et en appliquant des outils dynamiquement, plut?t que de rechercher brutal tous les contenus.
• L'optimisation des stratégies de bunking, d'attribution d'outils et d'indexation est cruciale lors de la mise à l'échelle des systèmes de chiffon pour garantir les performances et la précision.

Questions fréquemment posées

A. Gestion de 3 documents nécessite des processus d'indexation et de récupération plus simples. à mesure que le nombre de documents augmente (par exemple, à 10), vous avez besoin de mécanismes de récupération plus sophistiqués comme ObjectIndex et de la récupération d'outils pour maintenir les performances et la précision.

A. VectorStoreIndex aide à la récupération efficace des morceaux de document en fonction de la similitude, tandis que ObjectIndex vous permet de stocker et de récupérer des outils associés à différents documents. Ensemble, ils aident à gérer efficacement les ensembles de documents à grande échelle.

A. La récupération basée sur les outils permet au système d'appliquer des outils spécialisés (par exemple, recherche de vecteur ou résumé) à chaque document, améliorant la précision des réponses et réduisant le temps de calcul par rapport au traitement de tous les documents de la même manière.

A. Pour gérer plus de documents, vous pouvez optimiser le processus de récupération en amenant l'indexation, en utilisant des techniques informatiques distribuées et en introduisant potentiellement des mécanismes de filtrage plus avancés pour réduire l'ensemble de documents avant d'appliquer des outils.

A. La mise à l'échelle des systèmes de chiffon agentiques à plusieurs documents implique efficacement l'optimisation des méthodes de récupération des données, la mise en ?uvre de stratégies d'indexation efficaces et la mise en ?uvre de modèles de langage avancé pour améliorer la précision de la requête. L'utilisation d'outils comme Llamaindex peut améliorer considérablement les performances du système en facilitant une meilleure gestion de plusieurs documents et en garantissant un accès en temps opportun aux informations pertinentes.

Les médias présentés dans cet article ne sont pas détenus par l'analytique vidhya et sont utilisés à la discrétion de l'auteur.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!