3 stratégies avancées pour les retrievers à Langchain

Langchain Retrieval: Accès efficace et flexible aux documents

Le chercheur dans le cadre de Langchain joue un rôle crucial, fournissant une interface flexible pour les documents de retour basés sur des requêtes non structurées. Contrairement aux bases de données vectorielles, le chercheur n'a pas besoin de stocker des documents; Bien que les bases de données vectorielles puissent servir de base pour les rétractations, il existe différents types de rétrosteurs, chacun personnalisable pour un cas d'utilisation spécifique.

Objectifs d'apprentissage

• Comprenez le rôle clé des chercheurs dans Langchain et réalisez une récupération de documents efficace et flexible pour répondre à divers besoins d'application.
• Découvrez comment le chercheur de Langchain (des bases de données vectorielles aux multi-Queues et à la compression de contexte) simplifie l'accès aux informations pertinentes.
• Ce guide couvre divers types de chercheurs à Langchain et explique comment chaque chercheur est personnalisé pour optimiser le traitement des requêtes et l'accès aux données.
• Creusez dans les capacités de recherche de Langchain et consultez les outils pour améliorer la précision et la pertinence de la récupération des documents.
• Découvrez comment le Retriever personnalisé de Langchain s'adapte à des besoins spécifiques, permettant aux développeurs de créer des applications très réactives.
• Explorez les techniques de recherche de Langchain qui intègrent les modèles de langage et les bases de données vectorielles pour obtenir des résultats de recherche plus précis et efficaces.

Table des matières

• Objectifs d'apprentissage
• Chercheur à Langchain
• Utilisez la base de données vectorielle comme chercheur
• Utilisation du multi-ancret
  • Créer une base de données de vecteur d'échantillon
  • Utilisation simple
  • Conseils personnalisés
• Comment rechercher en utilisant la compression de contexte
  • Aperçu de la compression du contexte
• Créer un chercheur personnalisé
  • interface
  • Exemple
• en conclusion
• Questions fréquemment posées

Chercheur à Langchain

Le chercheur reçoit une requête de chaîne en entrée et publie une liste d'objets de document. Ce mécanisme permet aux applications d'acquérir efficacement des informations pertinentes, permettant des interactions avancées avec de grands ensembles de données ou des bases de connaissances.

1. Utilisez la base de données vectorielle comme chercheur

Le Retriever de la base de données vectorielle récupère efficacement les documents en utilisant des représentations vectorielles. Il agit comme un wrapper léger pour les classes de stockage vectoriel, est conforme à l'interface du chercheur et utilise des méthodes telles que la recherche de similitude et la corrélation marginale maximale (MMR).

Pour créer un Retriever à partir d'une base de données vectorielle, utilisez la méthode .as_retriever . Par exemple, pour une base de données vectorielle de Pinecone basée sur les avis des clients, nous pouvons le configurer comme suit:

 De Langchain_community.Document_loaders Importer CSVloader
De Langchain_community.VectorStores Importer Pinecone
De Langchain_Openai Import Openaiembedddings
De Langchain_Text_Splitters Importer le caractère de caractères

lourdeur = csvloader ("client_reviews.csv")
documents = chargeur.load ()
text_splitter = caractèrestextSplitter (chunk_size = 500, chunk_overlap = 50)
texts = text_splitter.split_documents (documents)
embeddings = openaiembeddings ()
vectorstore = pinecone.from_documents (textes, intégres)
Retriever = vectorstore.as_retriever ()

Nous pouvons maintenant utiliser ce chercheur pour interroger les commentaires connexes:

 docs = retriever.invoke ("Que pensent les clients de la durée de vie de la batterie?")

Par défaut, le chercheur utilise une recherche de similitude, mais nous pouvons spécifier MMR comme type de recherche:

 retriever = vectorstore.as_retriever (search_type = "mmr")

De plus, nous pouvons transmettre des paramètres tels que les seuils de score de similitude, ou utiliser Top-K pour limiter le nombre de résultats:

 Retriever = vectorstore.as_retriever (search_kwargs = {"k": 2, "score_threshold": 0,6})

Sortir:

L'utilisation d'une base de données vectorielle en tant que chercheur peut améliorer la récupération des documents en garantissant un accès efficace aux informations pertinentes.

2. Utilisation du multi-ancret

Multi-leryryretriever améliore la récupération de la base de données vectorielle basée sur la distance en traitant des limitations communes telles que les changements dans le libellé de la requête et l'intégration sous-optimale. En utilisant des ajustements d'invite d'automatisation du modèle grand langage (LLM), plusieurs requêtes peuvent être générées pour une entrée utilisateur donnée sous différents angles. Ce processus permet de récupérer des documents pertinents pour chaque requête et de combiner les résultats pour produire un ensemble plus riche de documents potentiels.

Créer une base de données de vecteur d'échantillon

Pour démontrer le multi-remétriever, créons un magasin vectoriel à l'aide de la description du produit à partir du fichier CSV:

 De Langchain_community.Document_loaders Importer CSVloader
De Langchain_community.VectorStores Import Faish
De Langchain_Openai Import Openaiembedddings
De Langchain_Text_Splitters Importer le caractère de caractères

# Charger le produit Description Loader = CSVLoader ("Product_descriptions.csv")
data = loader.load ()

# Split Text en blocs text_splitter = caractères TextSplitter (Chunk_Size = 300, Chunk_overlap = 50)
documents = text_splitter.split_documents (données)

# Créer des intégres de stockage vectoriel = openaiembeddings ()
vectordb = faiss.from_documents (documents, intégres)

Utilisation simple

Pour utiliser le multi-anret, spécifiez le LLM utilisé pour la génération de requêtes:

 De Langchain.Retrievers.Multi_Query Import MultiQyretriever
De Langchain_Openai Import Chatopenai

Question = "Quelles fonctionnalités les clients apprécient-ils dans les smartphones?"
llm = Chatopenai (température = 0)
Retriever_from_llm = multi-érythration
    retriever = vectordb.as_retriever (), llm = llm
)
unique_docs = retriever_from_llm.invoke (question)
LEN (UNIQUE_DOCS) # Nombre de documents uniques récupérés

Sortir:

Le multi-rérénerver génère plusieurs requêtes, améliorant la diversité et la pertinence des documents récupérés.

Conseils personnalisés

Pour ajuster la requête générée, vous pouvez créer un standtemplate personnalisé et un analyseur de sortie:

 de Langchain_core.output_parsers Import BaseOutputParser
à partir de Langchain_core.prompts Importer PromptTemplate
de la liste d'importation

# Sortie personnalisée Classe d'analyse LineListOutputParser (BaseOutputParser [List [STR]]):
    Def Parse (Self, Text: Str) -> List [Str]:
        Retour liste (filtre (aucun, text.strip (). Split ("\ n")))

output_parser = lineListOutputParser ()

# Invites personnalisées pour la génération de requêtes Query_Prompt = promptTEmplate (
    input_variables = ["Question"],
    template = "" "générer cinq versions différentes de la question: {question}" ""
)

llm_chain = query_prompt |

# Initialisez le retriever Retriever = MultiQuyRriever (
    retriever = vectordb.as_retriever (), llm_chain = llm_chain, parser_key = "lignes"
)

unique_docs = retriever.invoke ("Quelles fonctionnalités les clients apprécient-ils dans les smartphones?")
LEN (UNIQUE_DOCS) # Nombre de documents uniques récupérés

Sortir

L'utilisation du multi-rérératif peut obtenir un processus de recherche plus efficace, en garantissant des résultats divers et complets en fonction des requêtes utilisateur.

3. Comment rechercher en utilisant la compression de contexte

La récupération des informations pertinentes à partir d'une grande collection de documents peut être difficile, en particulier lorsque l'ingestion de données n'est pas connue sur la requête spécifique que l'utilisateur fera. Souvent, des idées précieuses sont cachées dans de longs documents, entraînant des appels inefficaces et coûteux vers le modèle de langue (LLM) tout en offrant moins de réactivité que l'idéal. La compression de contexte résout ce problème en améliorant le processus de recherche, garantissant que les informations pertinentes sont renvoyées uniquement en fonction de la requête de l'utilisateur. Cette compression comprend la réduction du contenu d'un seul document et le filtrage des documents non pertinents.

Aperçu de la compression du contexte

Le chercheur de compression de contexte s'exécute en intégrant le chercheur de base au compresseur de document. Cette méthode ne renvoie pas le document dans son intégralité, mais comprime le document en fonction du contexte fourni par la requête. Cette compression comprend la réduction du contenu d'un seul document et le filtrage des documents non pertinents.

Étapes de mise en œuvre

1. Initialisez le chercheur de base: configurez d'abord un chercheur de stockage vectoriel normal. Par exemple, considérez un article de presse sur la politique du changement climatique:

 à partir de Langchain_community.Document_loaders Importer Textloader
De Langchain_community.VectorStores Import Faish
De Langchain_Openai Import Openaiembedddings
De Langchain_Text_Splitters Importer le caractère de caractères

# Charger et diviser l'article Documents = Textloader ("climate_change_policy.txt"). Load ()
text_splitter = caractèrestextSplitter (chunk_size = 1000, chunk_overlap = 0)
texts = text_splitter.split_documents (documents)

# Initialize Vector Storage Retriever Retriever = FAISS.from_Documents (textes, openaiembeddings ()). AS_RETRIEVER ()

2. Exécutez une requête initiale: exécutez une requête pour afficher les résultats renvoyés par le Retriever de base, qui peut inclure des informations pertinentes et sans rapport.

 docs = retriever.invoke ("Quelles actions sont proposées pour lutter contre le changement climatique?")

3. Recherche améliorée à l'aide de la compression de contexte: enveloppez le chercheur de base avec ContextualCompressionRetRever et extraire le contenu pertinent à l'aide de LLMCHAINExtracteur:

 De Langchain.Rerevers Import ContextualCompressionretriever
De Langchain.Rerevers.Document_Compresseurs Import LlmChaineExtractor
de Langchain_Openai Import Openai

llm = openai (température = 0)
compressor = llmchainextractor.from_llm (llm)
Compression_Retriever = contextualCompressionReverriever (
    base_compressor = compresseur, base_retriever = retriever
)

# Effectuer compresser_docs = compression_retriever.invoke ("Quelles actions sont proposées pour lutter contre le changement climatique?")

Afficher les résultats compressés: ContextualCompressionRever traite le document initial et extrait uniquement les informations pertinentes liées à la requête, optimisant ainsi la réponse.

Créer un chercheur personnalisé

La récupération est essentielle dans de nombreuses applications LLM. Sa tâche consiste à obtenir des documents pertinents en fonction des requêtes utilisateur. Ces documents sont formatés sous forme d'invites LLM, leur permettant de générer des réponses appropriées.

interface

Pour créer un retriever personnalisé, étendez la classe de base de base et implémentez ce qui suit:

méthode	décrire	Requis / facultatif
_get_relevant_documents	Rechercher des documents liés à la requête.	Requis
_aget_relevant_documents	Implémentation asynchrone pour le support natif.	Facultatif

Hérité de BasereTriever fournira des fonctionnalités de course standard à votre retriever.

Exemple

Voici un exemple de simple retriever:

 de la liste d'importation
De Langchain_core.Documents Document d'importation
de Langchain_core.Rerevers Import BasereTriever

Class ToyRetriever (BasereTriever):
    "" "Un simple retriever qui renvoie les premiers k documents contenant la requête de l'utilisateur." ""
    Documents: Liste [Document]
    K: int

    def _get_relevant_documents (self, requête: str) -> list [document]:
        corresponding_documents = [doc pour doc dans self.documents si query.lower () dans doc.page_content.lower ()]
        return Matching_Documents [: self.k]

# Exemple de documents d'utilisation = [
    Document ("Les chiens sont de grandes entreprises.", {"Type": "chien"}),
    Document ("Les chats sont des animaux de compagnie indépendants.", {"Type": "Cat"}),
]]

Retriever = ToyRetriever (documents = documents, k = 1)
résultat = retriever.invoke ("chien")
print (résultat [0] .page_content)

Sortir

Cette implémentation fournit un moyen simple de récupérer des documents basés sur la saisie de l'utilisateur, illustrant la fonctionnalité principale d'un chercheur personnalisé à Langchain.

en conclusion

Dans le cadre de Langchain, le chercheur est un outil puissant qui peut accéder efficacement aux informations pertinentes dans divers types de documents et cas d'utilisation. En comprenant et en mettant en œuvre différents types de chercheurs (tels que Vector Storage Retrievers, MultiQuyReever et Context Compression Retrievers), les développeurs peuvent personnaliser les récupérations de documents en fonction des besoins spécifiques de leurs applications.

Chaque type Retriever présente des avantages uniques, de l'utilisation du multiquinadreveur à l'utilisation de la compression de contexte à l'optimisation des réponses. De plus, la création d'un chercheur personnalisé offre une plus grande flexibilité pour répondre aux exigences spéciales que les options intégrées peuvent ne pas répondre. La maîtrise de ces techniques de recherche permet aux développeurs de créer des applications plus efficaces et réactives qui exploitent le potentiel des modèles de langage et des grands ensembles de données.

Questions fréquemment posées

Q1. A1. Cela aide l'application à accéder efficacement aux informations nécessaires dans les grands ensembles de données sans stocker eux-mêmes des documents.

Q2. Comment est la différence entre un chercheur et une base de données vectorielle? A2. Bien qu'une base de données vectorielle puisse faire partie d'un chercheur, la tâche du chercheur se concentre sur l'obtention d'informations pertinentes.

Q3. A3. Cette méthode capture un plus large éventail de documents qui peuvent être liés à différents problèmes de formulation, améliorant ainsi la richesse des informations de recherche.

Q4. Pourquoi la compression du contexte est-elle importante? A4. La compression du contexte optimise les résultats de la recherche en réduisant le contenu du document à des pièces pertinentes et en filtrant des informations non liées. Ceci est particulièrement utile dans les grandes collections, car la documentation complète peut contenir des détails indépendants, économiser des ressources et fournir une réponse plus centralisée.

Q5. A5.

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!