Almacenamiento estructurado de resultados de LLM y análisis en Python

Organización estructurada de resultados y análisis de LLM en Python

Introducción

La IA generativa se está utilizando ampliamente en todo el mundo. La capacidad de los Modelos de Lenguaje Grandes para comprender el texto proporcionado y generar un texto basado en eso ha llevado a numerosas aplicaciones, desde Chatbots hasta analizadores de texto. Pero a menudo, estos Modelos de Lenguaje Grandes generan texto tal cual, de manera no estructurada. A veces queremos que la salida generada por los LLM esté en un formato estructurado, digamos un formato JSON (Notación de Objetos JavaScript). Supongamos que estamos analizando una publicación en las redes sociales utilizando LLM, y necesitamos que la salida generada por LLM esté dentro del código mismo como una variable JSON/python para realizar alguna otra tarea. Lograr esto con la Ingeniería de las Pistas es posible, pero lleva mucho tiempo ajustar las pistas. Para resolver esto, LangChain ha introducido Output Parses, con los que se puede trabajar para convertir el almacenamiento de salida de los LLM en un formato estructurado.

Objetivos de Aprendizaje

• Interpretar la salida generada por los Modelos de Lenguaje Grandes
• Crear estructuras de datos personalizadas con Pydantic
• Comprender la importancia de las Plantillas de Pistas y generar una formateando la salida de LLM
• Aprender cómo crear instrucciones de formato para la salida de LLM con LangChain
• Ver cómo podemos analizar datos JSON en un Objeto Pydantic

Este artículo fue publicado como parte del Data Science Blogathon.

¿Qué es LangChain y Output Parsing?

LangChain es una biblioteca de Python que te permite construir aplicaciones con Modelos de Lenguaje Grandes en poco tiempo. Admite una amplia variedad de modelos, incluidos los LLM de OpenAI GPT, PaLM de Google, e incluso los modelos de código abierto disponibles en Hugging Face como Falcon, Llama y muchos más. Con LangChain, personalizar las Pistas para los Modelos de Lenguaje Grandes es muy fácil y también viene con una tienda de vectores incorporada, que puede almacenar las incrustaciones de las entradas y salidas. Por lo tanto, se puede trabajar con él para crear aplicaciones que puedan consultar cualquier documento en minutos.

• Mi experiencia con DevOps y DataOps
• Introducción a la regresión logística en PySpark
• Explicación intuitiva de los multiplicadores de Lagrange, las condiciones KKT y la dualidad

LangChain permite que los Modelos de Lenguaje Grandes accedan a información de internet a través de agentes. También ofrece analizadores de salida, que nos permiten estructurar los datos de la salida generada por los Modelos de Lenguaje Grandes. LangChain cuenta con diferentes analizadores de salida como el List Parser, el Datetime Parser, el Enum Parser, etc. En este artículo, veremos el analizador de salida JSON, que nos permite analizar la salida generada por los LLM en un formato JSON. A continuación, podemos observar un flujo típico de cómo se analiza la salida de LLM en un Objeto Pydantic, creando así datos listos para usar en variables de Python

Comenzando: configurando el modelo

En esta sección, configuraremos el modelo con LangChain. Utilizaremos PaLM como nuestro Modelo de Lenguaje Grande en todo este artículo. Utilizaremos Google Colab como nuestro entorno. Puedes reemplazar PaLM con cualquier otro Modelo de Lenguaje Grande. Comenzaremos importando los módulos necesarios.

!pip install google-generativeai langchain

• Esto descargará la biblioteca LangChain y la biblioteca google-generativeai para trabajar con el modelo PaLM.
• La biblioteca langchain es necesaria para crear pistas personalizadas y analizar la salida generada por los Modelos de Lenguaje Grandes
• La biblioteca google-generativeai nos permitirá interactuar con el modelo PaLM de Google.

Clave de API PaLM

Para trabajar con PaLM, necesitaremos una clave de API, que podemos obtener registrándonos en el sitio web de MakerSuite. A continuación, importaremos todas nuestras bibliotecas necesarias y proporcionaremos la clave de API para instanciar el modelo PaLM.

import osimport google.generativeai as palmfrom langchain.embeddings import GooglePalmEmbeddingsfrom langchain.llms import GooglePalmos.environ['GOOGLE_API_KEY']= 'TU CLAVE DE API'palm.configure(api_key=os.environ['GOOGLE_API_KEY'])llm = GooglePalm()llm.temperature = 0.1prompts = ["Nombra 5 planetas y describe algo sobre ellos"]llm_result = llm._generate(prompts)print(llm_result.generations[0][0].text)

• Aquí creamos primero una instancia del Modelo de Lenguaje de Rutas de Google (Google PaLM) y lo asignamos a la variable llm
• En el siguiente paso, establecemos la temperatura de nuestro modelo en 0.1, baja porque no queremos que el modelo alucine
• Luego creamos un Prompt como una lista y lo pasamos a la variable prompts
• Para pasar el prompt al PaLM, llamamos al método ._generate() y luego le pasamos la lista Prompt y los resultados se almacenan en la variable llm_result
• Finalmente, imprimimos el resultado en el último paso llamando a .generations y convirtiéndolo a texto llamando al método .text

A continuación se puede ver la salida para este prompt:

Podemos ver que el Modelo de Lenguaje Grande ha generado una salida justa y el LLM también intentó agregar cierta estructura agregando algunas líneas. Pero ¿qué sucede si quiero almacenar la información de cada modelo en una variable? ¿Qué sucede si quiero almacenar el nombre del planeta, el período de órbita y la distancia al sol, todos por separado en una variable? La salida generada por el modelo tal como está no se puede manipular directamente para lograr esto. Por lo tanto, surge la necesidad de los Analizadores de Salida (Output Parses).

Creación de un Analizador de Salida Pydantic y una Plantilla de Prompt

En esta sección, discutiremos el analizador de salida pydantic de langchain. En el ejemplo anterior, la salida estaba en un formato no estructurado. Veamos cómo podemos almacenar la información generada por el Modelo de Lenguaje Grande en un formato estructurado.

Implementación del código

Empecemos por ver el siguiente código:

from pydantic import BaseModel, Field, validatorfrom langchain.output_parsers import PydanticOutputParserclass PlanetData(BaseModel):    planet: str = Field(description="Este es el nombre del planeta")    orbital_period: float = Field(description="Este es el período de órbita en número de días terrestres")    distance_from_sun: float = Field(description="Este es un número decimal que indica la distancia desde el sol en millones de kilómetros")    interesting_fact: str = Field(description="Esto es sobre un hecho interesante del planeta")

• Aquí estamos importando el paquete Pydantic para crear una Estructura de Datos. Y en esta Estructura de Datos, almacenaremos la salida al analizar la salida del LLM.
• Aquí creamos una Estructura de Datos utilizando Pydantic llamada PlanetData que almacena los siguientes datos
• Planeta: Este es el nombre del planeta que daremos como entrada al modelo
• Período de Órbita: Este es un valor decimal que contiene el período de órbita en días terrestres para un planeta en particular.
• Distancia del Sol: Este es un valor decimal que indica la distancia desde un planeta al Sol
• Hecho Interesante: Esta es una cadena de texto que contiene un hecho interesante sobre el planeta solicitado

Ahora, nuestro objetivo es consultar el Modelo de Lenguaje Grande para obtener información sobre un planeta y almacenar todos estos datos en la Estructura de Datos PlanetData mediante el análisis de la salida del LLM. Para analizar una salida del LLM en una Estructura de Datos Pydantic, LangChain ofrece un analizador llamado PydanticOutputParser. Pasamos la Clase PlanetData a este analizador, que se puede definir de la siguiente manera:

planet_parser = PydanticOutputParser(pydantic_object=PlanetData)

Almacenamos el analizador en una variable llamada planet_parser. El objeto analizador tiene un método llamado get_format_instructions(), que le indica al LLM cómo generar la salida. Intentemos imprimirlo

from pprint import pppp(planet_parser.get_format_instructions())

En lo anterior, vemos que las instrucciones de formato contienen información sobre cómo formatear la salida generada por el LLM. Le indica al LLM que la salida debe ser en un esquema JSON, para que este JSON pueda analizarse en la Estructura de Datos Pydantic. También proporciona un ejemplo de un esquema de salida. A continuación, crearemos una Plantilla de Prompt.

Plantilla de consigna

desde langchain import PromptTemplate, LLMChaintemplate_string = """Eres un experto cuando se trata de responder preguntas sobre planetas \Se te dará el nombre de un planeta y deberás generar el nombre del planeta, su período orbital en días \También su distancia al sol en millones de kilómetros y un hecho interesante```{planet_name}```{format_instructions}"""planet_prompt = PromptTemplate(    template=template_string,    input_variables=["planet_name"],    partial_variables={"format_instructions": planet_parser.get_format_instructions()})

• En nuestra Plantilla de consigna, indicamos que daremos un nombre de planeta como entrada y el LLM debe generar una salida que incluya información como el período de órbita, la distancia al sol y un hecho interesante sobre el planeta
• Luego asignamos esta plantilla a PrompTemplate() y proporcionamos el nombre de la variable de entrada al parámetro input_variables, en nuestro caso es planet_name
• También proporcionamos instrucciones de formato que hemos visto anteriormente, que le indican al LLM cómo generar la salida en formato JSON

Vamos a intentar darle un nombre de planeta y observar cómo se ve la Consigna antes de enviarla al Modelo de Lenguaje Grande

input_prompt = planet_prompt.format_prompt(planet_name='mercurio')pp(input_prompt.to_string())

En la salida, vemos que la plantilla que hemos definido aparece primero con la entrada “mercurio”. Luego, aparecen las instrucciones de formato. Estas instrucciones de formato contienen las instrucciones que el LLM puede usar para generar datos JSON.

Probando el modelo de lenguaje grande

En esta sección, enviaremos nuestra entrada al LLM y observaremos los datos generados. En la sección anterior, veremos cómo será nuestra cadena de entrada cuando se envíe al LLM.

input_prompt = planet_prompt.format_prompt(planet_name='mercurio')output = llm(input_prompt.to_string())pp(output)

Podemos ver la salida generada por el Modelo de Lenguaje Grande. La salida se genera en un formato JSON. Los datos JSON contienen todas las claves que hemos definido en nuestra Estructura de Datos de PlanetData. Y cada clave tiene un valor que esperamos que tenga.

Ahora tenemos que analizar estos datos JSON en la Estructura de Datos que hemos hecho. Esto se puede hacer fácilmente con el analizador de salida PydanticOutputParser que hemos definido anteriormente. Echemos un vistazo a ese código:

parsed_output = planet_parser.parse(output)print("Planeta: ",parsed_output.planet)print("Período orbital: ",parsed_output.orbital_period)print("Distancia desde el Sol (en millones de KM): ",parsed_output.distance_from_sun)print("Hecho interesante: ",parsed_output.interesting_fact)

Llamar al método parse() para planet_parser tomará la salida y luego la analizará y convertirá en un objeto Pydantic, en nuestro caso un objeto de PlanetData. Por lo tanto, la salida, es decir, los datos JSON generados por el Modelo de Lenguaje Grande se analizan en la Estructura de Datos de PlannetData y ahora podemos acceder a los datos individuales de ella. La salida para lo anterior será

Vemos que los pares clave-valor de los datos JSON se analizaron correctamente en los Datos Pydantic. Intentemos con otro planeta y observemos la salida

input_prompt = planet_prompt.format_prompt(planet_name='venus')output = llm(input_prompt.to_string())parsed_output = planet_parser.parse(output)print("Planeta: ",parsed_output.planet)print("Período orbital: ",parsed_output.orbital_period)print("Distancia desde el Sol: ",parsed_output.distance_from_sun)print("Hecho interesante: ",parsed_output.interesting_fact)

Vemos que para la entrada “Venus”, el LLM fue capaz de generar un JSON como salida y se pudo analizar correctamente en Datos Pydantic. De esta manera, a través del análisis de salida, podemos usar directamente la información generada por los Modelos de Lenguaje de Gran Tamaño.

Posibles Aplicaciones y Casos de Uso

En esta sección, repasaremos algunas posibles aplicaciones y casos de uso en el mundo real, donde podemos emplear estas técnicas de análisis de salida. Usar el análisis en la extracción/después de la extracción, es decir, cuando extraemos cualquier tipo de datos, queremos analizarlo para que la información extraída pueda ser utilizada por otras aplicaciones. Algunas de las aplicaciones incluyen:

• Extracción y Análisis de Quejas de Productos: Cuando una nueva marca llega al mercado y lanza nuevos productos, lo primero que quiere hacer es verificar cómo está funcionando el producto, y una de las mejores formas de evaluar esto es analizar las publicaciones en redes sociales de los consumidores que usan estos productos. Los analizadores de salida y los LLM permiten la extracción de información, como la marca y los nombres de los productos, e incluso las quejas de las publicaciones en redes sociales de los consumidores. Estos Modelos de Lenguaje de Gran Tamaño almacenan estos datos en variables de Python mediante el análisis de salida, lo que te permite utilizarlos para visualizaciones de datos.
• Soporte al Cliente: Cuando creamos chatbots con LLMs para brindar soporte al cliente, una tarea importante será extraer la información del historial de chats del cliente. Esta información contiene detalles clave, como los problemas que los consumidores enfrentan con respecto al producto/servicio. Puedes extraer fácilmente estos detalles usando los analizadores de salida de LangChain en lugar de crear código personalizado para extraer esta información.
• Información de Publicaciones de Empleo: Al desarrollar plataformas de búsqueda de empleo como Indeed, LinkedIn, etc., podemos utilizar los LLMs para extraer detalles de las publicaciones de empleo, incluyendo títulos de trabajo, nombres de empresas, años de experiencia y descripciones de trabajo. El análisis de salida puede guardar esta información como datos JSON estructurados para la búsqueda de empleo y recomendaciones. El análisis de esta información directamente desde la salida del LLM a través de los Analizadores de Salida de LangChain elimina gran cantidad de código redundante necesario para realizar esta operación de análisis por separado.

Conclusión

Los Modelos de Lenguaje de Gran Tamaño son excelentes, ya que literalmente se adaptan a todos los casos de uso debido a sus extraordinarias capacidades de generación de texto. Pero a menudo carecen cuando se trata de utilizar realmente la salida generada, donde tenemos que dedicar una cantidad considerable de tiempo al análisis de la salida. En este artículo, hemos examinado este problema y cómo podemos solucionarlo utilizando los Analizadores de Salida de LangChain, especialmente el analizador JSON que puede analizar los datos JSON generados por los LLM y convertirlos en un objeto Pydantic.

Puntos Clave

Algunos de los puntos clave de este artículo incluyen:

• LangChain es una biblioteca de Python que permite crear aplicaciones con los Modelos de Lenguaje de Gran Tamaño existentes.
• LangChain proporciona Analizadores de Salida que nos permiten analizar la salida generada por los Modelos de Lenguaje de Gran Tamaño.
• Pydantic nos permite definir estructuras de datos personalizadas, que se pueden utilizar al analizar la salida de los LLMs.
• Además del analizador JSON de Pydantic, LangChain también proporciona diferentes Analizadores de Salida como el Analizador de Listas, el Analizador de Fechas y Horas, el Analizador Enum, etc.

Preguntas Frecuentes

Las imágenes mostradas en este artículo no son propiedad de Analytics Vidhya y se usan a discreción del autor.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!