Hur man använder Parent Document Retriever i LangChain?

Hur Man Anvander Parent Document Retriever I Langchain



Ramverket LangChain gör det möjligt för utvecklarna att bygga stora språkmodeller som kan förstå och generera text på naturligt språk. LangChain-modellerna är tränade på en enorm mängd data så att modellen kan förstå språket genom att lagra data i vektorlager. Det gör det också möjligt för användaren att bygga retrievers som kan extrahera data från databasen eller vektorlagren med all data lagrad för modellen.

Det här inlägget kommer att demonstrera processen för att använda den överordnade dokumenthämtaren i LangChain.

Hur man använder en överordnad dokumentåterhämtning i LangChain?

Överordnad dokumentåterhämtning i LangChain kan användas genom att dela upp dokumenten i mindre bitar så att de inte förlorar sin mening vid inbäddningsögonblicken. Det överordnade dokumentet kan sägas vara hela dokumentet eller den större del från vilken de mindre bitarna extraheras.







För att lära dig hur man använder den överordnade dokumenthämtaren i LangChain, kolla bara in den här guiden:



Steg 1: Installera moduler



Börja först använda den överordnade dokumenthämtaren genom att installera LangChain-ramverket med pip-kommandot:





pip installera langkedja

Installera Chroma-databasmodulen för att spara inbäddningarna av dokumentet och hämta data från det:



pip installera chromadb

För att installera tiktoken som är en tokenizer som får dokumentets tokens genom att skapa små bitar:

pip installera tiktoken

Skaffa OpenAI-modulen genom att utföra följande kommando på Python-anteckningsboken för att få dess beroenden och bibliotek:

pip installera openai

Steg 2: Konfigurera miljö och ladda upp data

Nästa steg är att sätta upp miljön med API-nyckeln från OpenAI-kontot:

importera du
importera getpass

du . ungefär [ 'OPENAI_API_KEY' ] = getpass . getpass ( 'OpenAI API Key:' )

Ladda nu upp dokumenten från det lokala systemet efter att ha importerat filbiblioteket och anropa sedan upload()-metoden:

från Google. ET AL importera filer
laddat upp = filer. ladda upp ( )

Steg 3: Importera bibliotek

Nästa steg innehåller koden för att importera de nödvändiga biblioteken för att använda de överordnade dokumenthämtarna med hjälp av LangChain-ramverket:

från långkedja. retrievers importera ParentDocumentRetriever
från långkedja. vektorbutiker importera Chroma
från långkedja. inbäddningar importera OpenAIE-inbäddningar
från långkedja. text_splitter importera RecursiveCharacterTextSplitter
från långkedja. lagring importera InMemoryStore
från långkedja. document_loaders importera TextLoader

Ladda dokumentet för att bygga retrievern med hjälp av TextLoader()-metoderna med sökvägen till filerna:

lastare = [
TextLoader ( 'Data.txt' ) ,
TextLoader ( 'state_of_the_union.txt' ) ,
]
docs = [ ]
för l i lastare:

Steg 4: Hämta kompletta dokument

När dokumenten/filerna har laddats till modellen bygger du helt enkelt inbäddningarna av dokumenten och lagrar dem i vektorlagren:

barn_splitter = RecursiveCharacterTextSplitter ( chunk_size = 400 )

vectorstore = Chroma (
samlingsnamn = 'fullständiga_dokument' ,
inbäddningsfunktion = OpenAIE-inbäddningar ( )
)

Lagra = InMemoryStore ( )
retriever = ParentDocumentRetriever (
vectorstore = vectorstore ,
läkare = Lagra ,
barn_splitter = barn_splitter ,
)

Anropa nu add_documents()-metoden med hjälp av retriever för att få retriever till dokumenten:

retriever. add_documents ( docs , ids = Ingen )

Följande kod extraherar inbäddningarna av dokumenten som har lagrats i databasen för de uppladdade filerna:

lista ( Lagra. yield_keys ( ) )

Efter att ha fått inbäddningarna av dokumenten, anropa metoden similarity_search() med frågan för att få de små bitarna från dokumentet:

sub_docs = vectorstore. likhetssökning ( 'rättvisa brygger' )

Anropa metoden print() för att visa de bitar som anropades i föregående kod baserat på frågan:

skriva ut ( sub_docs [ 0 ] . page_content )

Anropa funktionen complete the retriever() för att få alla tokens lagrade i databasen med hjälp av följande kod:

hämtade_dokument = retriever. get_relevant_documents ( 'rättvisa brygger' )

Att skriva ut alla dokument skulle ta enorm tid och bearbetningskraft, så det är helt enkelt att få längden på dokument som hämtats tidigare:

endast ( hämtade_dokument [ 0 ] . page_content )

Steg 5: Hämta större bitar

Detta steg kommer inte att ta hela dokumentet; men det skulle ta en större jordekorre från dokumentet och hämta en mindre bit från det:

parent_splitter = RecursiveCharacterTextSplitter ( chunk_size = 2000 )
barn_splitter = RecursiveCharacterTextSplitter ( chunk_size = 400 )
vectorstore = Chroma ( samlingsnamn = 'delade_föräldrar' , inbäddningsfunktion = OpenAIE-inbäddningar ( ) )
Lagra = InMemoryStore ( )

Konfigurera retrievern för att få den mindre token från den enorma datapoolen som lagras i ' vectorstore ' variabel:

retriever = ParentDocumentRetriever (
vectorstore = vectorstore ,
läkare = Lagra ,
barn_splitter = barn_splitter ,
parent_splitter = parent_splitter ,
)

Ring retrievern för att få de större bitarna från vektorlagren med hjälp av docs variabel i argumentet för funktionen:

retriever. add_documents ( docs )

Få längden på dessa dokument från docs variabel via kommandot nedan:

endast ( lista ( Lagra. yield_keys ( ) ) )

Få helt enkelt en mindre bit från en större eftersom föregående skärmdump visar att det finns 23 dokument lagrade i vektorarkivet. Frågan används för att få relevant data med hjälp av likhet_sökning() metod för att hämta data från vektorlagret:

sub_docs = vectorstore. likhetssökning ( 'rättvisa brygger' )

Skriv ut de mindre bitarna med hjälp av frågan som nämndes i föregående kod för att visa dem på skärmen:

skriva ut ( sub_docs [ 0 ] . page_content )

Använd nu retrievern på hela datamängden som är lagrad i databasen med hjälp av frågan som argument för funktionen:

hämtade_dokument = retriever. get_relevant_documents ( 'rättvisa brygger' )

Få längden på de kompletta bitarna som skapats och lagras i databasen:

endast ( hämtade_dokument [ 0 ] . page_content )

Vi kan inte visa alla bitar, men den första biten med indexnumret 0 visas med följande kod:

skriva ut ( hämtade_dokument [ 0 ] . page_content

Det handlar om processen att använda den överordnade dokumenthämtaren i LangChain.

Slutsats

För att använda den överordnade dokumenthämtaren i LangChain, installera helt enkelt modulerna och konfigurera OpenAI-miljön med dess API-nyckel. Efter det, importera de nödvändiga biblioteken från LangChain för att använda den överordnade dokumenthämtaren och ladda sedan dokumenten för modellen. Användaren kan använda överordnade dokument som hela dokumentet eller den stora biten och få en mindre del med hjälp av frågan. Det här inlägget har utvecklat processen för att använda den överordnade dokumenthämtaren i LangChain.