Rask oversikt
Dette innlegget vil vise:
Hvordan legge til en tilpasset minnetype i LangChain
- Installere Frameworks
- Importerer biblioteker
- Bygge tilpasset minne
- Konfigurerer ledetekstmal
- Tester modellen
Hvordan legge til en tilpasset minnetype i LangChain?
Ved å legge til en tilpasset minnetype i LangChain kan brukeren få mest mulig ytelse som minne. Brukeren kan konfigurere minnetypen i henhold til sine krav. For å legge til en tilpasset minnetype i LangChain, gå ganske enkelt gjennom følgende trinn:
Trinn 1: Installere Frameworks
Installer først LangChain-rammeverket for å komme i gang med prosessen med å legge til en tilpasset minnetype:
pip installer langkjedeÅ kjøre kommandoen ovenfor i Python Notebook vil installere avhengighetene for LangChain som vist i følgende utdrag:
Installer OpenAI-modulen for å få bibliotekene som kan brukes til å konfigurere LLM-ene:
pip installer openai 
Denne veiledningen vil bruke spaCy-rammeverket til å designe den tilpassede minnetypen i LangChain, og følgende kode brukes til å installere modulen:
pip installer romslig 
SpaCy-modellen bruker hash-tabellen til å lagre informasjonen som observasjon som tidligere chat-meldinger. Følgende kode brukes til å laste ned Large Language Model eller LLM fra spaCy-biblioteket for å bygge en avansert NLP-modell:
! python -m spacy nedlasting en_core_web_lg 
Importerer ' du ' og ' få pass ”-biblioteker er for å legge inn API-nøkkelen fra OpenAI-kontoen til sette opp sitt miljø :
import duimport få pass
du . omtrent [ 'OPENAI_API_KEY' ] = få pass . få pass ( 'OpenAI API Key:' )
Trinn 2: Importere biblioteker
Det neste trinnet er å importere de nødvendige bibliotekene for å tilpasse minnetypen i henhold til chat-modellen:
fra langkjede. skjema import BaseMemoryfra langkjede. kjeder import Samtalekjede
fra pydantisk import BaseModel
fra langkjede. llms import OpenAI
fra skrive import Liste , Dict , Noen
Importerer ' spaCy ' biblioteket for å laste ' no_core_web_lg '-modellen og tilordne den til ' nlp '-variabel ettersom det er Natural Language Processing-modellen:
import romslignlp = romslig. laste ( 'en_core_web_lg' )
Trinn 3: Bygg tilpasset minne
Etter det bygger du ganske enkelt det tilpassede minnet ved å bruke BaseMemory- og BaseModel-argumentene i Memory-klassen. Konfigurer deretter enheter (samlet/lagret fra dataene) som kan lagres i minnet som fullstendig informasjon eller som en enkelt enhet. Minnet er konfigurert til å inneholde alle enhetene fra dokumentet for å optimere ytelsen til minnet og modellen:
klasse SpacyEntityMemory ( BaseMemory , BaseModel ) :''' Minneklasse for lagring av informasjon om enheter'''
enheter: dikt = { }
minnenøkkel: str = 'enheter'
def klar ( selv- ) :
selv- . enheter = { }
@ eiendom
def minne_variabler ( selv- ) - > Liste [ str ] :
''' Initialiser variablene som er gitt til spørringen'''
komme tilbake [ selv- . minnenøkkel ]
#definer minnevariablene ved å bruke argumentene
def load_memory_variables ( selv- , innganger: Dict [ str , Noen ] ) - > Dict [ str , str ] :
''' Ring variablene for minne, dvs. enhetsnøkkel'''
dok = nlp ( innganger [ liste ( innganger. nøkler ( ) ) [ 0 ] ] )
#configure enheter som skal lagres i minnet for en individuell enhet
enheter = [
selv- . enheter [ str ( ent ) ] til ent i dok. ents hvis str ( ent ) i selv- . enheter
]
komme tilbake { selv- . minnenøkkel : ' \n ' . bli med ( enheter ) }
#define save_context() for å bruke minnet
def lagre_kontekst ( selv- , innganger: Dict [ str , Noen ] , utganger: Dict [ str , str ] ) - > Ingen :
'''Lagre observasjon fra denne chatten til minnet'''
tekst = innganger [ liste ( innganger. nøkler ( ) ) [ 0 ] ]
dok = nlp ( tekst )
til ent i dok. ents :
ent_str = str ( ent )
hvis ent_str i selv- . enheter :
selv- . enheter [ ent_str ] + = f ' \n {tekst}'
ellers :
selv- . enheter [ ent_str ] = tekst
Trinn 4: Konfigurere ledetekstmal
Deretter konfigurerer du bare ledetekstmalen som forklarer strukturen til inndataene fra brukeren/mennesket:
fra langkjede. spør . ledetekst import PromptTemplatemal = '''Det følgende er en interaksjon mellom en maskin og et menneske Den sier at den ikke vet Hvis maskinen ikke vet svaret Maskinen (AI) gir detaljer fra sin kontekst og hvis den ikke forstår svaret på noe spørsmål sier bare unnskyld
Enhetsinformasjon:
{entities}
Kommunikasjon:
Menneske: {input}
AI:'''
ledetekst = PromptTemplate ( input_variables = [ 'enheter' , 'inngang' ] , mal = mal )
Trinn 5: Testing av modellen
Før du tester modellen, konfigurerer du bare LLM ved å bruke OpenAI()-metoden og setter opp ConversationChain()-funksjonen med argumenter:
llm = OpenAI ( temperatur = 0 )samtale = Samtalekjede (
llm = llm , ledetekst = ledetekst , ordrik = ekte , hukommelse = SpacyEntityMemory ( )
)
Gi informasjon til modellen ved å bruke input-argumentet mens du kaller predict()-metoden med samtalevariabelen:
samtale. forutsi ( input = 'Harrison liker maskinlæring' )Produksjon
Modellen har absorbert informasjonen og lagret den i minnet og stilt også spørsmålet knyttet til informasjonen for å komme videre med samtalen:
Brukeren kan svare på spørsmålet fra modellen for å legge til mer informasjon til minnet eller teste minnet ved å stille spørsmålet om informasjonen:
samtale. forutsi (input = 'Hva er Harrisons favorittfag'
)
Modellen gir utdata basert på den forrige informasjonen og viser den på skjermen som følgende utdrag viser:
Det handler om å legge til en tilpasset minnetype i LangChain.
Konklusjon
For å legge til en tilpasset minnetype i LangChain, installer ganske enkelt de nødvendige modulene for å importere biblioteker for å bygge det tilpassede minnet. SpaCy er det viktige biblioteket som brukes i denne veiledningen for å legge til et tilpasset minne ved å bruke NLP-modellen. Deretter konfigurerer du det tilpassede minnet og ledetekstmalen for å gi strukturen til chat-grensesnittet. Når konfigurasjonen er ferdig, tester du bare minnet til modellen ved å be om informasjon relatert til lagrede data.