Det här inlägget illustrerar metoden för att använda utdataparserfunktionerna och klasserna genom LangChain-ramverket.
Hur man använder Output Parser genom LangChain?
Utdataparsarna är utdata och klasser som kan hjälpa till att få den strukturerade utdata från modellen. För att lära dig processen att använda utdataparsarna i LangChain, gå helt enkelt igenom stegen i listan:
Steg 1: Installera moduler
Börja först processen med att använda utdataparsarna genom att installera LangChain-modulen med dess beroenden för att gå igenom processen:
pip Installera långkedja
Installera sedan OpenAI-modulen för att använda dess bibliotek som OpenAI och ChatOpenAI:
pip Installera openai
Nu, ställ in miljö för OpenAI med API-nyckeln från OpenAI-kontot:
importera oss
importera getpass
os.environ [ 'OPENAI_API_KEY' ] = getpass.getpass ( 'OpenAI API Key:' )
Steg 2: Importera bibliotek
Nästa steg är att importera bibliotek från LangChain för att använda utdataparsarna i ramverket:
från langchain.prompts importera HumanMessagePromptTemplate
från pydantic importfält
från langchain.prompts importera ChatPromptTemplate
från langchain.output_parsers importera PydanticOutputParser
från pydantic import BaseModel
från pydantic import validator
från langchain.chat_models importera ChatOpenAI
från langchain.llms importera OpenAI
från att skriva importlista
Steg 3: Bygg datastruktur
Att bygga strukturen för utdata är den viktiga tillämpningen av utdataparsarna i stora språkmodeller. Innan du kommer till datastrukturen för modellerna måste du definiera namnet på modellen vi använder för att få den strukturerade utdata från utdataparsrar:
temperatur = 0,0
modell = OpenAI ( modellnamn =modellnamn, temperatur =temperatur )
Använd nu klassen Joke som innehåller BaseModel för att konfigurera strukturen för utdata för att hämta skämtet från modellen. Efter det kan användaren enkelt lägga till anpassad valideringslogik med pydantic-klassen som kan be användaren att ställa en bättre utformad fråga/prompt:
klass skämt ( Basmodell ) :setup: str = Fält ( beskrivning = 'fråga för att visa ett skämt' )
punchline: str = Fält ( beskrivning = 'svara på frågan med ett skämt' )
#Logisk validering för frågan eftersom modellen behöver förstå den ordentligt
@ validator ( 'uppstart' )
def question_ends_with_question_mark ( cls, fält ) :
om fält [ - 1 ] ! = '?' :
höja ValueError ( 'Dåligt ställd fråga!' )
lämna tillbaka fält
Steg 4: Ställ in promptmall
Konfigurera parservariabeln som innehåller PydanticOutputParser()-metoden som innehåller dess parametrar:
Efter att ha konfigurerat parsern, definiera helt enkelt promptvariabeln med metoden PromptTemplate() med strukturen för frågan/prompten:
prompt = PromptTemplate (mall = 'Svara på användarens fråga. \n {format_instructions} \n {fråga} \n ' ,
input_variables = [ 'fråga' ] ,
partiella_variabler = { 'format_instructions' : parser.get_format_instructions ( ) }
)
Steg 5: Testa Output Parser
Efter att ha konfigurerat alla krav, skapa en variabel som tilldelas med hjälp av en fråga och anropa sedan format_prompt()-metoden:
_input = prompt.format_prompt ( fråga =skämtfråga )
Anropa nu funktionen model() för att definiera utdatavariabeln:
output = modell ( _input.to_string ( ) )Slutför testprocessen genom att anropa metoden parser() med utdatavariabeln som parameter:
parser.parse ( produktion ) 
Det handlar om processen att använda utdataparsern i LangChain.
Slutsats
För att använda utdataparsern i LangChain, installera modulerna och konfigurera OpenAI-miljön med dess API-nyckel. Därefter definierar du modellen och konfigurerar sedan datastrukturen för utgången med logisk validering av frågan som tillhandahålls av användaren. När datastrukturen är konfigurerad ställer du bara in promptmallen och testar sedan utdataparsern för att få resultatet från modellen. Den här guiden har illustrerat processen att använda utdataparsern i LangChain-ramverket.