Analizador de Salida

El modelo de lenguaje LLM produce contenido en formato de texto, pero al desarrollar aplicaciones de inteligencia artificial, queremos recibir contenido formateado, como convertir los resultados en objetos de destino, matrices, etc., para facilitar su procesamiento. Esto requiere que el analizador de salida proporcionado por LangChain formatee el contenido devuelto por el modelo.

La función del analizador de salida es formatear los resultados devueltos por el modelo de lenguaje. Un analizador de salida debe implementar dos métodos necesarios:

  • "obtener_instrucciones_de_formato": Devuelve una cadena que contiene instrucciones sobre el formato en el que el modelo de lenguaje debe devolverlo.
  • "analizar": Analiza el contenido devuelto por el modelo en el formato de destino.

Ahora echemos un vistazo a los analizadores de salida integrados en LangChain.

Analizador Pydantic

A continuación se muestra el analizador de salida principal PydanticOutputParser encapsulado por LangChain. Este analizador se basa en la biblioteca Python pydantic y se utiliza para convertir el resultado de salida del modelo en objetos de Python.

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

modelo = OpenAI(model_name="gpt-3.5-turbo-instruct", temperatura=0.0)

class Chiste(BaseModel):
    setup: str = Field(description="pregunta para preparar un chiste")
    punchline: str = Field(description="respuesta para resolver el chiste")

    @validator("setup")
    def pregunta_termina_con_signo_de_interrogacion(cls, field):
        if field[-1] != "?":
            raise ValueError("¡Pregunta mal formulada!")
        return field

analizador = PydanticOutputParser(pydantic_object=Chiste)

plantilla = PromptTemplate(
    template="Responder la consulta del usuario.\n{format_instructions}\n{query}\n",
    input_variables=["consult"],
    partial_variables={"format_instructions": analizador.get_format_instructions()},
)

plantilla_y_modelo = plantilla | modelo
resultado = plantilla_y_modelo.invoke({"consulta": "Cuéntame un chiste."})
analizador.invoke(resultado)

Resultado de retorno de muestra:

Chiste(setup='¿Por qué el pollo cruzó la carretera?', punchline='¡Para llegar al otro lado!')

Interfaz LCEL

Interfaz Ejecutable

El analizador de salida implementa la interfaz Runnable, que es uno de los componentes básicos del Lenguaje de Expresión de LangChain (LCEL). Admite métodos de invocación como invoke, ainvoke, stream, astream, batch, abatch, astream_log, etc.

Aplicación de Analizadores de Salida en LCEL

El analizador de salida puede aceptar una cadena o BaseMessage como entrada y devolver datos estructurados de cualquier tipo. Podemos construir e invocar una cadena de analizadores agregando el analizador a una secuencia Runnable.

cadena = plantilla | modelo | analizador
cadena.invoke({"consulta": "Cuéntame un chiste."})

Devuelve

Chiste(setup='¿Por qué el pollo cruzó la carretera?', punchline='¡Para llegar al otro lado!')

Algunos analizadores pueden transmitir objetos de análisis parciales, como SimpleJsonOutputParser, mientras que otros no admiten la transmisión. La salida final depende de si el analizador puede construir objetos de análisis parciales.

from langchain.output_parsers.json import SimpleJsonOutputParser

plantilla_json = PromptTemplate.from_template(
    "Devolver un objeto JSON con una clave 'respuesta' que responda a la siguiente pregunta: {pregunta}"
)
analizador_json = SimpleJsonOutputParser()
cadena_json = plantilla_json | modelo | analizador_json

list(cadena_json.stream({"pregunta": "¿Quién inventó el microscopio?"}))

[{},
 {'respuesta': ''},
 {'respuesta': 'Hormiga'},
 {'respuesta': 'Antón'},
 {'respuesta': 'Antoine'},
 {'respuesta': 'Antonie van'},
 {'respuesta': 'Antonie van Lee'},
 {'respuesta': 'Antonie van Leeu'},
 {'respuesta': 'Antonie van Leeuwen'},
 {'respuesta': 'Antonie van Leeuwenho'},
 {'respuesta': 'Antonie van Leeuwenhoek'}]

En LCEL, podemos construir flujos de procesamiento de datos complejos combinando diferentes analizadores para satisfacer varios requisitos.