Las Intricacies de las Cadenas de LangChain: Desatando el Potencial de las Soluciones de Aprendizaje de Lenguas Multi-Modelo

Name

Akira Sakamoto

Updated on 24/7/2023

LangChain es una herramienta cautivadora que está teniendo un impacto significativo en la esfera dinámica de los modelos de aprendizaje de idiomas (LLMs). En esta publicación del blog, exploraremos el punto crucial de esta herramienta innovadora: las cadenas de LangChain. ¿Qué son? ¿Cómo funcionan? ¿Y por qué son tan cruciales para LangChain?

¿Qué es LangChain? ¿Qué es LangChain IA?

Antes de profundizar en las Cadenas de LangChain, entendamos LangChain en sí mismo. LangChain es una biblioteca sólida diseñada para simplificar la interacción con varios proveedores de grandes modelos de lenguaje (LLMs) como OpenAI, Cohere, Bloom, Huggingface y más. La proposición única de LangChain es su capacidad para crear Cadenas, que son vínculos lógicos entre uno o más LLMs. Esta característica es lo que proporciona a LangChain su gran utilidad.

Puedes leer más sobre LangChain con nuestro Artículo de Introducción a LangChain.

¿Qué son las Cadenas de LangChain?

Las Cadenas son el núcleo vital de LangChain. Estas conexiones lógicas entre uno o más LLMs son la columna vertebral de la funcionalidad de LangChain. Las Cadenas pueden ser simples o complejas, según las necesidades y los LLMs involucrados. Profundicemos en ambos tipos:

Cadenas Básicas

Una cadena básica es la forma más simple de una cadena que se puede crear. Implica que un solo LLM reciba una indicación de entrada y utilice esa indicación para la generación de texto.

Tomemos, por ejemplo, este escenario simple. Construimos una cadena básica utilizando Huggingface como proveedor de LLM con el siguiente código:

from langchain.prompts import PromptTemplate
from langchain.llms import HuggingFace
from langchain.chains import LLMChain
 
prompt = PromptTemplate(
    input_variables=["city"],
    template="¿Cómo sería un día perfecto en {city}?",
)
 
llm = HuggingFace(
          model_name="gpt-neo-2.7B", 
          temperature=0.9) 
 
llmchain = LLMChain(llm=llm, prompt=prompt)
llmchain.run("París")

La salida será un texto generado por IA que describe un día perfecto en París.

Cadenas Avanzadas

Las cadenas avanzadas, también conocidas como cadenas de utilidad, están compuestas por múltiples LLMs para abordar una tarea particular. Un ejemplo adecuado es la SummarizeAndTranslateChain, que se enfoca en tareas como la sumarización y la traducción.

Por ejemplo, LangChain cuenta con una cadena de utilidad específica llamada TopicModellingChain, que lee artículos y genera una lista de temas relevantes.

from langchain.chains import TopicModellingChain

El siguiente archivo de markdown está en inglés:

topic_chain = TopicModellingChain(llm=llm, verbose=True)
topic_chain.run("Text of a scientific article about climate change.")

El resultado aquí es una lista de temas relevantes para el artículo científico proporcionado sobre el cambio climático.

La fuerza de las cadenas LangChain

¿Qué hace que las cadenas LangChain sean tan importantes?

Las cadenas LangChain permiten a los usuarios vincular sin esfuerzo varios LLM, combinando las fortalezas de diferentes modelos y facilitando la ejecución de tareas más complejas y sofisticadas. Aumentan las habilidades de los arreglos de un solo modelo tradicionales, abriendo camino a soluciones innovadoras para problemas complejos.

Las cadenas LangChain representan un avance considerable en el mundo del LLM. Al unir las brechas entre modelos de una manera accesible, podrían convertirse en una herramienta invaluable para los desarrolladores en todo el mundo, desde aficionados hasta profesionales de nivel empresarial. Con el poder de las cadenas LangChain, no hay límite para lo que pueden lograr los modelos de aprendizaje de idiomas.

Cadenas sin LLM y emblemas

Mientras que la PalChain discutida anteriormente requiere un LLM (y un emblema correspondiente) para analizar la pregunta del usuario escrita en lenguaje natural, existen cadenas en LangChain que no lo necesitan. Estas son principalmente cadenas de transformación que procesan el emblema, como eliminar espacios adicionales, antes de ingresarlos en el LLM. Por ejemplo:

from langchain.chains import TrimSpacesChain
 
trim_chain = TrimSpacesChain()
trimmed_prompt = trim_chain.run("   What is the   weather   like?   ")
print(trimmed_prompt)  # Output: "What is the weather like?"

En este caso, se utiliza TrimSpacesChain para limpiar el emblema eliminando espacios innecesarios. Después del preprocesamiento, puede ingresar el emblema limpio en cualquier LLM de su elección.

Creación de cadenas: la cadena SimpleSequential

Ahora, centremos nuestros esfuerzos en un tipo específico de cadena: la cadena SimpleSequential. Este tipo de cadena nos permite vincular lógicamente LLM de modo que la salida de uno sirva como entrada para el siguiente.

Considere una situación en la que primero necesitamos limpiar el emblema (eliminar espacios adicionales, acortarlo, etc.), luego usar este emblema limpio para llamar a un LLM. Usemos TrimSpacesChain de arriba y combinémoslo con una cadena LLM.

from langchain.chains import SimpleSequentialChain
 
trim_chain = TrimSpacesChain()
llm_chain = LLMChain(llm=llm, prompt=prompt)
 
combined_chain = SimpleSequentialChain([trim_chain, llm_chain])
output = combined_chain.run("   What is the   weather   like?   ")
print(output)  # Salida de texto generado por AI basado en el emblema limpiado

En esta configuración, la salida de TrimSpacesChain (emblema limpio) se pasa como entrada a LLMChain.

El papel de los agentes en LangChain

Los agentes en LangChain presentan una forma innovadora de llamar dinámicamente a LLM basado en la entrada del usuario. No solo tienen acceso a un LLM sino también a una suite de herramientas (como búsqueda de Google, Python REPL, calculadora matemática, APIs meteorológicas, etc.) que pueden interactuar con el mundo exterior.

Consideremos un ejemplo práctico usando el agente ZERO_SHOT_REACT_DESCRIPTION de LangChain:

from langchain.agents import initialize_agent, AgentType, load_tools
from langchain.llms import OpenAI
 
llm = OpenAI(temperature=0)
tools = load_tools(["pal-math"], llm=llm)

agente = initialize_agent(herramientas, llm, agente=TipoAgente.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)

respuesta = agente.run("Si mi edad es la mitad de la edad de mi padre y él va a tener 60 el año que viene, ¿cuál es mi edad actual?") print(respuesta) # Salida: "Tengo 29.5 años de edad."

En este caso, el agente utiliza la herramienta pal-math y un modelo de lenguaje de OpenAI para resolver un problema matemático incrustado en una solicitud en lenguaje natural. Demuestra un caso práctico en el que el agente aporta valor adicional al comprender la solicitud, elegir la herramienta correcta para resolver la tarea y finalmente devolver una respuesta significativa.

Con las capacidades dinámicas de las cadenas y agentes en LangChain, los usuarios pueden diseñar de manera flexible flujos de trabajo de procesamiento de lenguaje multi-paso. Ya sea que desee preprocesar las solicitudes, crear cadenas multi-LLM o utilizar agentes para elegir dinámicamente LLM y herramientas, LangChain proporciona los bloques de construcción necesarios para hacerlo realidad.

Caso de uso avanzado: generar recomendaciones de películas basadas en los géneros favoritos del usuario

Para este caso de uso, trabajaremos con dos cadenas:

Cadena # 1 - Una cadena LLM que pregunta al usuario acerca de sus géneros favoritos de películas. Cadena # 2 - Otra cadena LLM que utiliza los géneros de la primera cadena para recomendar películas de los géneros seleccionados.

En primer lugar, creemos la cadena_uno.

plantilla = '''Eres una encuesta de géneros de películas. Pregunta al usuario acerca de sus géneros favoritos.
 
Preguntar:'''
plantilla_solicitud = PlantillaSolicitud(variables_entrada=[], plantilla=plantilla)
cadena_uno = CadenaLLM(llm=llm, plantilla_solicitud=plantilla_solicitud)

Luego, creamos cadena_dos para recomendar películas.

plantilla = '''Eres un recomendador de películas. Dados los géneros favoritos del usuario: {géneros}, sugiere algunas películas que correspondan a estos géneros.
 
Sugerir películas:'''
plantilla_solicitud = PlantillaSolicitud(variables_entrada=["géneros"], plantilla=plantilla)
cadena_dos = CadenaLLM(llm=llm, plantilla_solicitud=plantilla_solicitud)

A continuación, combinemos estas cadenas usando SimpleSequentialChain.

from langchain.cadenas import SimpleSequentialChain
 
cadena_total = SimpleSequentialChain(
    cadenas=[cadena_uno, cadena_dos],
    verbose=True)

Notará que no hemos mencionado explícitamente variables_entrada y variables_salida para SimpleSequentialChain. Esto se debe a que el supuesto subyacente es que la salida de la cadena 1 se pasa como entrada a la cadena 2.

Ahora, ejecutemos esta cadena:

cadena_total.run('¿Cuáles son tus géneros favoritos de películas?')
 
# SALIDA
# > Ingresando a la nueva cadena SimpleSequentialChain ...
# > Entrando en nuevo LLMChain...
# Géneros favoritos: Acción, Drama, Comedia
# > Finalizando cadena.
 
# Dados sus géneros favoritos: Acción, Drama, Comedia, algunas recomendaciones de películas serían:
# De Acción: Duro de Matar, Mad Max: Furia en el Camino, El Caballero de la Noche
# De Drama: Cadena Perpetua, La Lista de Schindler, Forrest Gump
# De Comedia: Súper Cool, ¿Qué Pasó Ayer?, Damas en Guerra
# > Finalizando cadena.

El primer LLMChain solicita los géneros favoritos y el segundo utiliza esta información para generar recomendaciones de películas. Este es un ejemplo genial de cómo se pueden combinar varios LLMChains en una cadena secuencial sencilla para crear un sistema de recomendación de películas personalizado.

Ahora supongamos que también quieres obtener información adicional del usuario, como su duración preferida de la película. Podemos actualizar la cadena_dos para tomar otra variable de entrada, la duración de la película.

template = '''Eres un recomendador de películas. Dados los géneros favoritos {genres} y su duración preferida de la película {movie_length}, sugiere algunas películas que caigan dentro de estos géneros.
 
Sugiere Películas:'''
prompt_template = PromptTemplate(input_variables=["genres", "movie_length"], template=template)
chain_two = LLMChain(llm=llm, prompt=prompt_template)

Finalmente, combinamos las cadenas usando SequentialChain, lo que nos permite manejar múltiples entradas y salidas.

overall_chain = SequentialChain(
    input_variables=["input"],
    memory=SimpleMemory(memories={"duracion_pelicula": "2 horas"}),
    chains=[chain_uno, chain_dos],
    verbose=True)

En este escenario, estamos usando SimpleMemory para almacenar el contexto adicional 'duracion_pelicula' que no debería cambiar entre las solicitudes. Cuando ejecutamos esta cadena, sugerirá películas no solo según los géneros favoritos, sino que también considerará la duración preferida de la película.

Conclusión

Les animo a experimentar y jugar con LangChain. Las posibilidades son ilimitadas cuando se trata de combinar diferentes agentes y modelos de inteligencia artificial para crear aplicaciones aún más poderosas y útiles.

Preguntas frecuentes

1. ¿Qué es LangChain? LangChain es una biblioteca de Python que le permite crear y combinar diferentes modelos de inteligencia artificial, agentes y solicitudes de una manera estructurada. Es perfecto para crear aplicaciones complejas de inteligencia artificial en las que necesita interactuar con múltiples modelos en una secuencia.

2. ¿Qué es SimpleSequentialChain y SequentialChain en LangChain? Ambos son tipos de cadenas en LangChain, permiten encadenar diferentes entidades de inteligencia artificial (modelos, agentes, etc.). Se utiliza SimpleSequentialChain cuando hay una sola entrada y salida entre cadenas, mientras que SequentialChain se utiliza cuando hay varias entradas y salidas.

3. ¿Cómo puedo agregar contexto adicional con LangChain? Puede utilizar SimpleMemory para agregar contexto adicional en LangChain. Es una forma sencilla de almacenar contexto u otros fragmentos de información que nunca deben cambiar entre solicitudes.

4. ¿Puedo crear agentes personalizados en LangChain? Sí, puede crear agentes personalizados utilizando la clase Agent en LangChain. Los agentes pueden encapsular lógica compleja y formar parte de una cadena.

5. ¿Dónde puedo encontrar más información sobre LangChain? Puede encontrar más información sobre LangChain en su sitio web oficial de documentación. Es un proyecto de código abierto, por lo que también puede consultar su código fuente en GitHub.