Comprendre l'analyseur de sortie LangChain LLM

Le grand modèle linguistique, ou LLM, a révolutionné la façon dont les gens travaillent. En aidant les utilisateurs à générer la réponse à partir d'une invite textuelle, LLM peut faire de nombreuses choses, comme répondre à des questions, résumer, planifier des événements, etc.

Cependant, il arrive parfois que les résultats de LLM ne soient pas à la hauteur de nos normes. Par exemple, le texte généré pourrait être complètement erroné et nécessiter des instructions supplémentaires. C'est là que l'analyseur de sortie LLM pourrait vous aider.

En standardisant le résultat de sortie avec LangChain Output Parser, nous pouvons avoir un certain contrôle sur la sortie. Alors, comment ça marche ? Allons-y.

Préparation

Dans cet article, nous nous appuierons sur les packages LangChain, nous devons donc les installer dans l'environnement. Pour ce faire, vous pouvez utiliser le code suivant.

pip install langchain langchain_core langchain_community langchain_openai python-dotenv

De plus, nous utiliserions le modèle OpenAI GPT pour la génération de texte, alors assurez-vous que vous y avez accès par API. Vous pouvez obtenir la clé API depuis la plateforme OpenAI.

Je travaillerais dans l'IDE Visual Studio Code, mais vous pourriez travailler dans n'importe quel IDE préféré. Créez un fichier appelé .env dans votre dossier de projet et insérez la clé API OpenAI à l'intérieur. Cela devrait ressembler à ceci.

OPENAI_API_KEY = sk-XXXXXXXXXX

Une fois que tout est prêt, nous passerons à la partie centrale de l’article.

Analyseur de sortie

Nous pouvons utiliser de nombreux types d'analyseurs de sortie de LangChain pour standardiser notre sortie LLM. Nous en essayerions plusieurs pour mieux comprendre l’analyseur de sortie.

Tout d’abord, nous essayerions Pydantic Parser. C'est un analyseur de sortie que nous pourrions utiliser pour contrôler et valider la sortie du texte généré. Utilisons-les mieux avec un exemple. Créez un script Python dans votre IDE, puis copiez le code ci-dessous dans votre script.

from typing import List
from dotenv import load_dotenv
from langchain.output_parsers import PydanticOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_core.pydantic_v1 import BaseModel, Field, validator
from langchain_openai import ChatOpenAI

load_dotenv()

class MovieReview(BaseModel):
    title: str = Field(description="The movie title")
    year: int = Field(description="The year of the movie was released")
    genre: List[str] = Field(description="The main genres of the movie")
    rating: float = Field(description="Rating out of 10")
    summary: str = Field(description="Brief summary of the movie plot")
    review: str = Field(description="Critical review of the movie")

    @validator("year")
    def valid_year(cls, val):
        if val  2025:
            raise ValueError("Must a valid movie year")
        return val

    @validator("rating")
    def valid_rating(cls, val):
        if val  10:
            raise ValueError("Rating must be between 0 and 10")
        return val

parser = PydanticOutputParser(pydantic_object=MovieReview)

prompt = PromptTemplate(
    template="Generate a movie review for the following movie:\n{movie_title}\n\n{format_instructions}",
    input_variables=["movie_title"],
    partial_variables={"format_instructions": parser.get_format_instructions()}
)

model = ChatOpenAI(temperature=0)

chain = prompt | model | parser

movie_title = "The Matrix"
review = chain.invoke({"movie_title": movie_title})
print(review)

Nous avons initialement importé les packages dans le code ci-dessus et chargé la clé OpenAI avec le load_dotenv. Après cela, nous créons une classe appelée MovieReview qui contient toutes les informations souhaitées. Le résultat fournirait un résultat à partir du titre, de l’année, du genre, de la note, du résumé et de la critique. Dans chaque sortie, nous définissons la description de la sortie souhaitée.

À partir du résultat, nous créons un validateur pour l'année et la note afin de garantir que le résultat n'est pas celui que nous souhaitions. Vous pouvez également ajouter davantage de mécanismes de validation si nécessaire.

Ensuite, nous créons le modèle d'invite qui accepterait notre entrée de requête et son format.

La dernière chose que nous faisons est de créer la chaîne de modèles et de transmettre la requête pour obtenir notre résultat. À noter que la variable chain ci-dessus accepte la structure utilisant « | » qui est une méthode unique dans LangChain.

Dans l’ensemble, le résultat est similaire à celui ci-dessous.

Sortir :

title='The Matrix' year=1999 genre=['Action', 'Sci-Fi'] rating=9.0 summary='A computer hacker learns about the true nature of reality and his role in the war against its controllers.' review="The Matrix is a groundbreaking film that revolutionized the action genre with its innovative special effects and thought-provoking storyline. Keanu Reeves delivers a memorable performance as Neo, the chosen one who must navigate the simulated reality of the Matrix to save humanity. The film's blend of martial arts, philosophy, and dystopian themes make it a must-watch for any movie enthusiast."

Comme vous pouvez le voir, la sortie suit le format souhaité et le résultat passe notre méthode de validation.

Pedantic Parser est l'analyseur de sortie standard que nous pouvons utiliser. Nous pouvons utiliser l’autre Output Parser si nous avons déjà un format spécifique en tête. Par exemple, nous pouvons utiliser l'analyseur CSV si nous voulons le résultat uniquement dans les éléments séparés par des virgules.

from dotenv import load_dotenv
from langchain.output_parsers import CommaSeparatedListOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

load_dotenv()

output_parser = CommaSeparatedListOutputParser()

format_instructions = output_parser.get_format_instructions()
prompt = PromptTemplate(
    template="List six {subject}.\n{format_instructions}",
    input_variables=["subject"],
    partial_variables={"format_instructions": format_instructions},
)

model = ChatOpenAI(temperature=0)

chain = prompt | model | output_parser

print(chain.invoke({"subject": "Programming Language"}))

Sortir :

['Java', 'Python', 'C++', 'JavaScript', 'Ruby', 'Swift']

Le résultat est une liste avec les valeurs séparées par la virgule. Vous pouvez développer le modèle comme vous le souhaitez si le résultat est séparé par des virgules.

Il est également possible d’obtenir la sortie au format datetime. En modifiant le code et l'invite, nous pouvons nous attendre au résultat souhaité.

from dotenv import load_dotenv
from langchain.output_parsers import DatetimeOutputParser
from langchain_core.prompts import PromptTemplate
from langchain_openai import ChatOpenAI

load_dotenv()

output_parser = DatetimeOutputParser()

format_instructions = output_parser.get_format_instructions()
prompt = PromptTemplate(
    template="""Answer the users question:

    {question}

    {format_instructions}""",
    input_variables=["question"],
    partial_variables={"format_instructions": format_instructions},
)

model = ChatOpenAI(temperature=0)

chain = prompt | model | output_parser

print(chain.invoke({"question": "When is the Python Programming Language invented?"}))

Sortir :

1991-02-20 00:00:00

Vous pouvez voir que le résultat est au format datetime.

Tout tourne autour des analyseurs de sortie LangChain LLM. Vous pouvez visiter leur documentation pour trouver les analyseurs de sortie dont vous avez besoin ou utiliser Pydantic pour le structurer vous-même.

Conclusion

Dans cet article, nous avons découvert le LangChain Output Parser, qui standardise le texte généré à partir de LLM. Nous pouvons utiliser l'analyseur Pydantic pour structurer la sortie LLM et fournir le résultat souhaité. Il existe de nombreux autres analyseurs de sortie de LangChain qui pourraient convenir à votre situation, tels que l'analyseur CSV et l'analyseur Datetime.