LangChain Output Parser

Analizator wyników

Model językowy LLM zwraca treść w formacie tekstowym, ale podczas tworzenia aplikacji opartych na sztucznej inteligencji chcemy otrzymać sformatowaną treść, na przykład, konwertując wyniki na obiekty docelowe, tablice, itp., aby ułatwić przetwarzanie programu. Wymaga to analizatora wyników dostarczonego przez LangChain do formatowania treści zwróconych przez model.

Funkcja analizatora wyników polega na formatowaniu wyników zwróconych przez model językowy. Analizator wyników musi zaimplementować dwie niezbędne metody:

• "get_format_instructions": Zwraca ciąg zawierający instrukcje dotyczące tego, w jakim formacie powinien zwrócić wynik model językowy.
• "parse": Parsuje treść zwróconą przez model do docelowego formatu.

Teraz przyjrzyjmy się wbudowanym analizatorom wyników w LangChain.

Analizator wyników Pydantic

Poniżej znajduje się główny analizator wyników PydanticOutputParser zaimplementowany przez LangChain. Ten analizator jest oparty na bibliotece Pythona pydantic i służy do konwertowania wyników modelu na obiekty Pythona.

from langchain.output_parsers import PydanticOutputParser
from langchain.prompts import PromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field, validator
from langchain_openai import OpenAI

model = OpenAI(model_name="gpt-3.5-turbo-instruct", temperature=0.0)

class Joke(BaseModel):
    setup: str = Field(description="pytanie związane z żartem")
    punchline: str = Field(description="odpowiedź na pytanie")

    @validator("setup")
    def question_ends_with_question_mark(cls, field):
        if field[-1] != "?":
            raise ValueError("Złe sformułowane pytanie!")
        return field

parser = PydanticOutputParser(pydantic_object=Joke)

prompt = PromptTemplate(
    template="Odpowiedz na zapytanie użytkownika.\n{format_instructions}\n{query}\n",
    input_variables=["query"],
    partial_variables={"format_instructions": parser.get_format_instructions()},
)

prompt_and_model = prompt | model
output = prompt_and_model.invoke({"query": "Powiedz mi żart."})
parser.invoke(output)

Przykładowy wynik zwrotny:

Joke(setup='Dlaczego kurczak przeszedł przez ulicę?', punchline='Żeby dostać się na drugą stronę!')

Interfejs LCEL

Interfejs Runnable

Analizator wyników implementuje interfejs Runnable, który jest jednym z podstawowych elementów języka wyrażeń LangChain (LCEL). Obsługuje metody wywołania takie jak invoke, ainvoke, stream, astream, batch, abatch, astream_log, itp.

Zastosowanie Analizatorów Wyników w LCEL

Analizator wyników może przyjmować ciąg znaków lub BaseMessage jako dane wejściowe i zwracać strukturalne dane dowolnego typu. Możemy budować i wywoływać łańcuch analizatorów poprzez dodanie analizatora do sekwencji Runnable.

chain = prompt | model | parser
chain.invoke({"query": "Powiedz mi żart."})

Zwraca

Joke(setup='Dlaczego kurczak przeszedł przez ulicę?', punchline='Żeby dostać się na drugą stronę!')

Niektóre analizatory mogą strumieniować częściowe obiekty analizy, takie jak SimpleJsonOutputParser, podczas gdy inne nie obsługują strumieniowania. Ostateczny wynik zależy od tego, czy analizator może budować częściowe obiekty analizy.

from langchain.output_parsers.json import SimpleJsonOutputParser

json_prompt = PromptTemplate.from_template(
    "Zwróć obiekt JSON z kluczem `odpowiedź`, który odpowiada na następujące pytanie: {question}"
)
json_parser = SimpleJsonOutputParser()
json_chain = json_prompt | model | json_parser

list(json_chain.stream({"question": "Kto wynalazł mikroskop?"}))

[{},
 {'answer': ''},
 {'answer': 'Mrówka'},
 {'answer': 'Anton'},
 {'answer': 'Antoni'},
 {'answer': 'Antoni van'},
 {'answer': 'Antoni van Lee'},
 {'answer': 'Antoni van Leeu'},
 {'answer': 'Antoni van Leeuwen'},
 {'answer': 'Antoni van Leeuwenho'},
 {'answer': 'Antoni van Leeuwenhoek'}]

W LCEL możemy budować złożone przepływy przetwarzania danych, łącząc różne analizatory, aby spełnić różne wymagania.