Snabb översikt
Det här inlägget kommer att visa:
Hur man lägger till en anpassad minnestyp i LangChain
Hur lägger man till en anpassad minnestyp i LangChain?
Genom att lägga till en anpassad minnestyp i LangChain kan användaren få ut mesta möjliga prestanda som minne. Användaren kan konfigurera minnestypen enligt sina krav. För att lägga till en anpassad minnestyp i LangChain, gå helt enkelt igenom följande steg:
Steg 1: Installera ramverk
Installera först LangChain-ramverket för att komma igång med processen att lägga till en anpassad minnestyp:
pip installera langkedjaOm du kör kommandot ovan i Python Notebook installeras beroenden för LangChain som visas i följande utdrag:
Installera OpenAI-modulen för att få dess bibliotek som kan användas för att konfigurera LLM:erna:
pip installera openai 
Den här guiden kommer att använda spaCy-ramverket för att designa den anpassade minnestypen i LangChain och följande kod används för att installera modulen:
pip installation spacy 
SpaCy-modellen använder hashtabellen för att lagra informationen som observation som tidigare chattmeddelanden. Följande kod används för att ladda ner Large Language Model eller LLM från spaCy-biblioteket för att bygga en avancerad NLP-modell:
! python -m spacy ladda ner en_core_web_lg 
Importerar ' du ' och ' getpass ”-bibliotek är till för att ange API-nyckeln från OpenAI:s konto till sätta upp sin miljö :
importera duimportera getpass
du . ungefär [ 'OPENAI_API_KEY' ] = getpass . getpass ( 'OpenAI API Key:' )
Steg 2: Importera bibliotek
Nästa steg är att importera de nödvändiga biblioteken för att anpassa minnestypen enligt chattmodellen:
från långkedja. schema importera BaseMemoryfrån långkedja. kedjor importera ConversationChain
från pydantisk importera Basmodell
från långkedja. llms importera OpenAI
från skriver importera Lista , Dict , Några
Importera ' rymd ' biblioteket för att ladda ' en_core_web_lg modell och tilldela den till nlp ” variabel eftersom det är Natural Language Processing-modellen:
importera rymlignlp = rymlig. ladda ( 'en_core_web_lg' )
Steg 3: Bygg anpassat minne
Därefter bygger du helt enkelt det anpassade minnet med argumenten BaseMemory och BaseModel i klassen Memory. Konfigurera sedan enheter (insamlade/lagrade från data) som kan lagras i minnet som fullständig information eller som en enda enhet. Minnet är konfigurerat att innehålla alla entiteter från dokumentet för att optimera prestanda för minnet och modellen:
klass SpacyEntityMemory ( BaseMemory , Basmodell ) :''' Minnesklass för lagring av information om enheter'''
enheter: dikt = { }
minnesnyckel: str = 'enheter'
def klar ( själv ) :
själv . enheter = { }
@ fast egendom
def minnesvariabler ( själv ) - > Lista [ str ] :
''' Initiera variablerna som tillhandahålls i frågan'''
lämna tillbaka [ själv . minnesnyckel ]
#definiera minnesvariablerna med hjälp av argumenten
def load_memory_variables ( själv , ingångar: Dikt [ str , Några ] ) - > Dict [ str , str ] :
''' Anropa variablerna för minne, dvs enhetsnyckel'''
doc = nlp ( ingångar [ lista ( ingångar. nycklar ( ) ) [ 0 ] ] )
#configure enheter som ska lagras i minnet för en enskild enhet
enheter = [
själv . enheter [ str ( ent ) ] för ent i doc. ents om str ( ent ) i själv . enheter
]
lämna tillbaka { själv . minnesnyckel : ' \n ' . Ansluta sig ( enheter ) }
#define the save_context() för att använda minnet
def save_context ( själv , ingångar: Dikt [ str , Några ] , utgångar: Dict [ str , str ] ) - > Ingen :
'''Lagra observation från denna chatt i minnet'''
text = ingångar [ lista ( ingångar. nycklar ( ) ) [ 0 ] ]
doc = nlp ( text )
för ent i doc. ents :
ent_str = str ( ent )
om ent_str i själv . enheter :
själv . enheter [ ent_str ] + = f ' \n {text}'
annan :
själv . enheter [ ent_str ] = text
Steg 4: Konfigurera promptmall
Efter det konfigurerar du bara promptmallen som förklarar strukturen för inmatningen som tillhandahålls av användaren/människan:
från långkedja. uppmaningar . prompt importera PromptMallmall = '''Följande är en interaktion mellan en maskin och en människa Det står att den inte vet Om maskinen inte vet svaret Maskinen (AI) tillhandahåller detaljer från sitt sammanhang och om den inte förstår svaret på någon fråga säger bara förlåt
Enhetsinformation:
{entities}
Kommunikation:
Människan: {input}
AI:'''
prompt = PromptMall ( input_variables = [ 'enheter' , 'inmatning' ] , mall = mall )
Steg 5: Testa modellen
Innan du testar modellen konfigurerar du helt enkelt LLM med OpenAI()-metoden och ställer in ConversationChain()-funktionen med argument:
llm = OpenAI ( temperatur = 0 )konversation = ConversationChain (
llm = llm , prompt = prompt , mångordig = Sann , minne = SpacyEntityMemory ( )
)
Ge information till modellen med hjälp av input-argumentet medan du anropar predict()-metoden med konversationsvariabeln:
konversation. förutse ( inmatning = 'Harrison gillar maskininlärning' )Produktion
Modellen har absorberat informationen och lagrat den i minnet och även ställt frågan relaterad till informationen för att komma vidare med konversationen:
Användaren kan svara på frågan från modellen för att lägga till mer information till minnet eller testa minnet genom att ställa frågan om informationen:
konversation. förutse (inmatning = 'Vilket är Harrisons favoritämne'
)
Modellen ger utdata baserat på den tidigare informationen och visar den på skärmen som följande utdrag visar:
Det handlar om att lägga till en anpassad minnestyp i LangChain.
Slutsats
För att lägga till en anpassad minnestyp i LangChain, installera helt enkelt de nödvändiga modulerna för att importera bibliotek för att bygga det anpassade minnet. SpaCy är det viktiga bibliotek som används i den här guiden för att lägga till ett anpassat minne med hjälp av dess NLP-modell. Efter det konfigurerar du det anpassade minnet och promptmallen för att ge strukturen för chattgränssnittet. När konfigurationen är klar, testa helt enkelt modellens minne genom att be om information relaterad till lagrad data.