LangChain Cheatsheet – Todos los secretos en una sola página

LangChain Cheatsheet - Todos los secretos en una sola página al alcance de tu mano

El OnePager creado es mi resumen de los conceptos básicos de LangChain. En este artículo, repasaré secciones de código y describiré el paquete inicial que necesitas dominar para triunfar en LangChain.

Actualmente, este OnePager es la única hoja de trucos que cubre los conceptos básicos de LangChain. Descarga la versión en PDF, revisa GitHub, y visita el código en Colab.

Explora mi curso LangChain 101:

• Esta investigación de IA de China proporciona una evaluación exhaustiva del último modelo de lenguaje visual del Estado del Arte GPT-4V(isión) y su aplicación en escenarios de conducción autónoma
• Zero123++ Un solo modelo base de difusión multivista consistente a partir de una sola imagen
• Considera los riesgos antes de subirte al tren de las extensiones de IA

Curso LangChain 101 (actualizado)

Sesiones del curso LangChain 101. Todo el código está en GitHub. LLMs, Bots de Chat

VoAGI.com

Modelos

Un modelo en LangChain se refiere a cualquier modelo de lenguaje, como el texto-davinci-003/gpt-3.5-turbo/4/4-turbo de OpenAI, LLAMA, FALCON, etc., que se puede utilizar para diversas tareas de procesamiento del lenguaje natural.

Revisa mi conferencia sobre Modelos en mi curso LangChain 101:

LangChain 101: Parte 2ab. Todo lo que necesitas saber sobre Modelos (de Lenguaje Grande)

Esta es la parte 2ab del curso LangChain 101. Se recomienda encarecidamente revisar la primera parte para entender…

pub.towardsai.net

El siguiente código muestra cómo inicializar y usar un modelo de lenguaje (en este caso, OpenAI) dentro de LangChain.

from langchain.llms import OpenAIllm = OpenAI(model_name="text-davinci-003", temperature=0.01)print(llm("Sugiere 3 regalos de cumpleaños para un científico de datos"))>>> 1. Una suscripción a una revista o diario de ciencia de datos2. Un conjunto de libros de ciencia de datos3. Una taza o camiseta temática de ciencia de datos

Como puedes ver, inicializamos un LLM y lo llamamos con una consulta. Toda la tokenización y embeber ocurre detrás de escena. Podemos administrar el historial de conversación e incorporar instrucciones del sistema en el chat para obtener más flexibilidad de respuesta.

from langchain.chat_models import ChatOpenAIfrom langchain.schema import HumanMessage, AIMessage, SystemMessagechat = ChatOpenAI(model_name="gpt-3.5-turbo", temperature=0.01)conversation_history = [    HumanMessage(content="Sugiere 3 regalos de cumpleaños para un científico de datos"),    AIMessage(content="¿Cuál es tu rango de precio?"),    HumanMessage(content="Menos de 100$"),]print(chat(conversation_history).content)>>>1. Un libro de ciencia de datos: Considera regalar un libro popular y altamente recomendado sobre ciencia de datos, como "Python for Data Analysis" de Wes McKinney o "The Elements of Statistical Learning" de Trevor Hastie, Robert Tibshirani y Jerome Friedman. Estos libros pueden proporcionar ideas y conocimientos valiosos para el desarrollo profesional de un científico de datos.2. Herramienta de visualización de datos: Los científicos de datos a menudo lidian con grandes conjuntos de datos y necesitan presentar sus hallazgos de manera efectiva. Considera regalar una herramienta de visualización de datos como Tableau Public o Plotly, que les ayudará a crear gráficos e gráficos interactivos y visualmente atractivos para comunicar los resultados de su análisis de datos.3. Suscripción a una plataforma de ciencia de datos: Dales acceso a una plataforma de ciencia de datos como Kaggle o DataCamp, que ofrecen una amplia gama de cursos, tutoriales y conjuntos de datos para que los científicos de datos mejoren sus habilidades y se mantengan actualizados con las últimas tendencias en el campo. Este regalo les proporcionará valiosos recursos de aprendizaje y oportunidades para su crecimiento profesional.

system_instruction = SystemMessage(content="""Trabajas como asistente en una tienda de electrónica.                                 Tu ingreso depende de los artículos que vendas""")user_message = HumanMessage(content="3 regalos de cumpleaños para un científico de datos")print(chat([system_instruction, user_message]).content)>>>1. Portátil: Un portátil de alto rendimiento es esencial para cualquier científico de datos. Busca un modelo con un procesador potente, amplia RAM y una gran capacidad de almacenamiento. Esto les permitirá ejecutar tareas complejas de análisis de datos y almacenar grandes conjuntos de datos.2. Disco Duro Externo: Los científicos de datos manejan cantidades masivas de datos y tener espacio de almacenamiento adicional es crucial. Un disco duro externo con una gran capacidad les proporcionará una manera conveniente y segura de almacenar y respaldar sus datos.3. Herramienta de Visualización de Datos: La visualización de datos es un aspecto importante de la ciencia de datos. Considera regalarles una suscripción a una herramienta de visualización de datos como Tableau o Power BI. Estas herramientas les ayudarán a crear gráficos, gráficas y paneles interactivos y visualmente atractivos para presentar sus hallazgos de manera efectiva.

Como puedes ver, podemos dirigir la conversación en una dirección específica utilizando diferentes tipos de mensajes: HumanMessage, AIMessage y SystemMessage.

Código abierto

Ahora, hablemos sobre los modelos de código abierto. A continuación se muestra un ejemplo típico de inicialización y uso de un modelo de lenguaje pre-entrenado para la generación de texto. El código incluye el uso del tokenizador, la configuración del modelo y la inferencia eficiente con cuantización (varios fragmentos de código a continuación) y soporte para CUDA.

from auto_gptq import AutoGPTQForCausalLM
from transformers import AutoTokenizer
from torch import cuda

# Nombre del modelo pre-entrenado
model_name = "TheBloke/llama-2-13B-Guanaco-QLoRA-GPTQ"

# Inicializar el tokenizador para el modelo
tokenizer = AutoTokenizer.from_pretrained(model_name, use_fast=True)

# Inicializar el modelo AutoGPTQForCausalLM con configuraciones específicas
# Este modelo es una versión cuantizada del modelo GPT adecuada para inferencia eficiente
model = AutoGPTQForCausalLM.from_quantized(
    model_name,
    use_safetensors=True,  # Habilita SafeTensors para una serialización segura
    trust_remote_code=True,  # Confía en el código remoto (no se recomienda para fuentes no confiables)
    device_map="auto",  # Mapea automáticamente el modelo al dispositivo disponible
    quantize_config=None  # Configuración de cuantización personalizada (None para la configuración predeterminada)
)

# La consulta de entrada que se tokenizará y se pasará al modelo
query = "<Tu texto de entrada aquí>"

# Tokenizar la consulta de entrada y convertirla a un formato tensor compatible con CUDA
input_ids = tokenizer(query, return_tensors="pt").input_ids.cuda()

# Generar texto utilizando el modelo con la configuración de temperatura especificada
output = model.generate(input_ids=input_ids, temperature=0.1)

Generación de texto

Durante la generación de texto, puedes influir en gran medida en el proceso utilizando diferentes parámetros:

¿Cómo genera texto un LLM?

Este artículo no discutirá los transformadores ni cómo se entrenan los modelos de lenguaje grandes. En su lugar, nos concentraremos en cómo utilizar…

pub.towardsai.net

• temperature afecta la aleatoriedad de la generación de tokens
• Top-k sampling limita la generación de tokens a los k tokens más probables en cada paso
• Top-p (muestreo de núcleo) limita la generación de tokens a la probabilidad acumulativa de p
• max_tokens especifica la longitud de los tokens generados

llm = OpenAI(temperature=0.5, top_k=10, top_p=0.75, max_tokens=50)

Cuantización

Es crucial utilizar la cuantización en términos de rendimiento.

Cómo ajustar modelos de lenguaje grandes en memoria pequeña: Cuantización

Cómo ejecutar LLM en tu máquina local

pub.towardsai.net

A continuación, optimizaremos un modelo de lenguaje pre-entrenado para un rendimiento eficiente utilizando cuantización de 4 bits. El uso de BitsAndBytesConfig es vital para aplicar estas optimizaciones, que son especialmente beneficiosas para escenarios de implementación donde el tamaño del modelo y la velocidad son factores críticos.

from transformers import BitsAndBytesConfig, AutoModelForCausalLM
import torch

# Especifica el nombre o la ruta del modelo
model_name_or_path = "tu-nombre-o-ruta-del-modelo"

# Configurar BitsAndBytesConfig para la cuantización de 4 bits
# Esta configuración se utiliza para optimizar el tamaño del modelo y la velocidad de inferencia
bnb_config = BitsAndBytesConfig(
    load_in_4bit=True,  # Habilita la carga del modelo en precisión de 4 bits
    bnb_4bit_compute_dtype=torch.bfloat16,  # Establece el tipo de datos de cálculo en bfloat16
    bnb_4bit_quant_type="nf4",  # Establece el tipo de cuantización en nf4
    bnb_4bit_use_double_quant=True  # Habilita la cuantización doble para una mayor precisión
)

# Cargar el modelo de lenguaje causal pre-entrenado con cuantización de 4 bits
model_4bit = AutoModelForCausalLM.from_pretrained(
    model_name_or_path,
    quantization_config=bnb_config,  # Aplica la configuración de cuantización de 4 bits
    device_map="auto",  # Mapea automáticamente el modelo al dispositivo disponible
    trust_remote_code=True  # Confía en el código remoto (usar con cautela)
)

Ajuste fino

En algunos casos, es necesario ajustar finamente un modelo de lenguaje pre-entrenado. Por lo general, esto se logra utilizando la Adaptación de Rango Bajo (LoRA) para una adaptación eficiente específica de la tarea. También se muestra el uso de la verificación de gradiente y la preparación para el entrenamiento de k-bit, que son técnicas para optimizar el proceso de entrenamiento con respecto a la memoria y la eficiencia computacional.

LangChain 101: Parte 2c. Ajuste fino de LLMs con PEFT, LORA y RL

Todo lo que necesitas saber sobre el ajuste fino de LLMs, PEFT, LORA y el entrenamiento de modelos de lenguaje grandes

pub.towardsai.net

LangChain 101: Parte 2d. Ajuste fino de LLMs con retroalimentación humana

Cómo implementar el aprendizaje por refuerzo con retroalimentación humana para LLMs pre-entrenados. Considera si deseas corregir problemas…

pub.towardsai.net

from peft import LoraConfig, get_peft_model, prepare_model_for_kbit_trainingfrom transformers import AutoModelForCausalLM, Trainer, TrainingArguments, DataCollatorForLanguageModeling# Cargar un modelo de lenguaje causal pre-entrenadopretrained_model = AutoModelForCausalLM.from_pretrained("tu-nombre-de-modelo")# Habilitar la verificación de gradiente para una eficiencia de memoria óptimapretrained_model.gradient_checkpointing_enable()# Preparar el modelo para el entrenamiento de k-bit, optimizando para un entrenamiento de baja cantidad de bitsmodel = prepare_model_for_kbit_training(pretrained_model)# Definir la configuración de LoRa (Adaptación de Rango Bajo)# Esto configura el modelo para el ajuste fino específico de la tarea con matrices de rango bajocomfig = LoraConfig(    r=16,                            # Rango de las matrices de rango bajolora_alpha=32,                   # Escala para las capas de LoRAlora_dropout=0.05,               # Tasa de abandono para las capas de LoRAbias="none",                     # Tipo de sesgo a utilizar    target_modules=["query_key_value"],  # Componentes del modelo objetivo para la adaptación de LoRA    task_type="CAUSAL_LM"            # Tipo de tarea, aquí Modelado del Lenguaje Causal)# Adaptar el modelo con la configuración de LoRa especificada:model = get_peft_model(model, config)# Inicializar el Entrenador para el entrenamiento del modelotrainer = Trainer(    model=model,    train_dataset=train_dataset,  # Conjunto de datos de entrenaiento    args=TrainingArguments(        num_train_epochs=10,        per_device_train_batch_size=8,        # Otros argumentos de entrenamiento...    ),    data_collator=DataCollatorForLanguageModeling(tokenizer)  # Recopila lotes de datos)# Deshabilitar la memoria caché para ahorrar memoria durante el entrenamientomodel.config.use_cache = False# Iniciar el proceso de entrenamientotrainer.train()

Impulsos

LangChain permite la creación de impulsos dinámicos que pueden guiar el comportamiento de la capacidad de generación de texto de los modelos de lenguaje. Las plantillas de impulsos en LangChain proporcionan una manera de generar respuestas específicas del modelo. Veamos un ejemplo práctico en el que debemos crear descripciones de SEO para productos específicos.

from langchain.prompts import PromptTemplate, FewShotPromptTemplate# Definir y usar una plantilla de impulso simpletemplate = "Actuar como un experto en SEO. Proporcionar una descripción de SEO para {producto}"prompt = PromptTemplate(input_variables=["producto"], template=template)# Formatear el impulso con un producto específicoformatted_prompt = prompt.format(producto="Perpetuum Mobile")print(llm(formatted_prompt))>>>Perpetuum Mobile es un proveedor líder de soluciones energéticas innovadoras y sostenibles. Nuestros productos y servicios están diseñados para ayudar a las empresas y a las personas a reducir su huella de carbono y ahorrar dinero en costos de energía. Nos especializamos en sistemas de energía solar, eólica y geotérmica, así como en soluciones de almacenamiento de energía. Nuestro equipo de ingenieros y técnicos experimentados se dedica a proporcionar productos y servicios de la más alta calidad a nuestros clientes. Nos esforzamos por ser el proveedor de soluciones de energía renovable más confiable y rentable de la industria. Con nuestro compromiso con la sostenibilidad y la satisfacción del cliente, Perpetuum Mobile es la elección perfecta para sus necesidades energéticas.

Podría haber casos en los que tengas un conjunto de datos pequeño, de pocos ejemplos, que muestren cómo te gustaría que se realice la tarea. Veamos un ejemplo de una tarea de clasificación de texto:

# Define un comando de aprendizaje "few-shot" con ejemplos
ejemplos = [
    {"email_text": "¡Gana un iPhone gratis!", "category": "Spam"},
    {"email_text": "Próxima reunión de planificación del sprint.", "category": "Reuniones"},
    {"email_text": "La versión 2.1 de Y ya está disponible",
     "category": "Actualizaciones del Proyecto"}
]
plantilla_prompt = PromptTemplate(
    input_variables=["email_text", "category"],
    template="Clasifica el correo electrónico: {email_text} /n {category}"
)
prompt_few_shot = FewShotPromptTemplate(
    example_prompt=plantilla_prompt,
    examples=ejemplos,
    suffix="Clasifica el correo electrónico: {email_text}",
    input_variables=["email_text"]
)

# Usando el comando de aprendizaje "few-shot"
prompt_formateado = prompt_few_shot.format(email_text="Hola. Estoy reprogramando la reunión diaria de mañana a las 10 am.")
print(llm(prompt_formateado))  # Resultado: /n Reuniones

Índices

Los índices en LangChain se utilizan para manejar y recuperar grandes volúmenes de datos de manera eficiente. En lugar de cargar todo el archivo de texto en un LLM, primero indexamos/buscamos información relevante en la fuente y solo después de encontrar las mejores k respuestas, las pasamos para formular una respuesta. ¡Bastante interesante!

En LangChain, utilizar índices incluye cargar documentos de diversas fuentes, dividir textos, crear vectores de almacenamiento y recuperar documentos relevantes

from langchain.document_loaders import WebBaseLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.vectorstores import FAISS

# Cargar documentos desde una fuente web
cargador = WebBaseLoader("https://es.wikipedia.org/wiki/Historia_de_las_matemáticas")
documentos_cargados = cargador.load()

# Dividir los documentos cargados en textos más pequeños
divisor_texto = RecursiveCharacterTextSplitter(chunk_size=400, chunk_overlap=50)
textos = divisor_texto.split_documents(documentos_cargados)

# Crear un vectorstore y realizar una búsqueda de similitud
db = FAISS.from_documents(textos, embeddings)
print(db.similarity_search("¿Cuál es la contribución de Isaac Newton en las matemáticas?"))
# Resultado:
# [Documento(contenido_página="Basándose en trabajos anteriores de muchos predecesores, Isaac Newton descubrió las leyes de la física que explican las Leyes de Kepler y unió los conceptos ahora conocidos como cálculo. De forma independiente, Gottfried Wilhelm Leibniz desarrolló el cálculo y gran parte de la notación del cálculo que todavía se utiliza hoy en día. También perfeccionó el sistema de números binarios, que es la base de casi todos los digitales (electrónicos,", metadata={'fuente': 'https://es.wikipedia.org/wiki/Historia_de_las_matemáticas', 'título': 'Historia de las matemáticas - Wikipedia', 'idioma': 'es'}), Documento(contenido_página='desarrollos matemáticos, interactuando con nuevos descubrimientos científicos, se realizaron a un ritmo cada vez mayor que continúa hasta hoy. Esto incluye el trabajo innovador de Isaac Newton y Gottfried Wilhelm Leibniz en el desarrollo del cálculo infinitesimal durante el siglo XVII.', metadata={'fuente': 'https://es.wikipedia.org/wiki/Historia_de_las_matemáticas', 'título': 'Historia de las matemáticas - Wikipedia', 'idioma': 'es'}), Documento(contenido_página="En el siglo XIII, Nasir al-Din Tusi (Nasireddin) realizó avances en la trigonometría esférica. También escribió una obra influyente sobre el postulado paralelo de Euclides. En el siglo XV, Ghiyath al-Kashi calculó el valor de π hasta la decimosexta cifra decimal. Kashi también tenía un algoritmo para calcular raíces enésimas, que era un caso especial de los métodos dados muchos siglos después por Ruffini y Horner.", metadata={'fuente': 'https://es.wikipedia.org/wiki/Historia_de_las_matemáticas', 'título': 'Historia de las matemáticas - Wikipedia', 'idioma': 'es'}), Documento(contenido_página='Whitehead, inició un largo debate sobre los fundamentos de las matemáticas.', metadata={'fuente': 'https://es.wikipedia.org/wiki/Historia_de_las_matemáticas', 'título': 'Historia de las matemáticas - Wikipedia', 'idioma': 'es'})]

Además de usar similarity_search, podemos utilizar bases de datos de vectores como recuperadores:

# Inicializar y utilizar un recuperador para documentos relevantes    
recuperador = db.as_retriever()
print(recuperador.get_relevant_documents("¿Cuál es la contribución de Isaac Newton en las matemáticas?"))
# Resultado:
# [Documento(contenido_página="Basándose en trabajos anteriores de muchos predecesores, Isaac Newton descubrió las leyes de la física que explican las Leyes de Kepler y unió los conceptos ahora conocidos como cálculo. De forma independiente, Gottfried Wilhelm Leibniz desarrolló el cálculo y gran parte de la notación del cálculo que todavía se utiliza hoy en día. También perfeccionó el sistema de números binarios, que es la base de casi todos los digitales (electrónicos,", metadata={'fuente': 'https://es.wikipedia.org/wiki/Historia_de_las_matemáticas', 'título': 'Historia de las matemáticas - Wikipedia', 'idioma': 'es'}), Documento(contenido_página='desarrollos matemáticos, interactuando con nuevos descubrimientos científicos, se realizaron a un ritmo cada vez mayor que continúa hasta hoy. Esto incluye el trabajo innovador de Isaac Newton y Gottfried Wilhelm Leibniz en el desarrollo del cálculo infinitesimal durante el siglo XVII.', metadata={'fuente': 'https://es.wikipedia.org/wiki/Historia_de_las_matemáticas', 'título': 'Historia de las matemáticas - Wikipedia', 'idioma': 'es'}), Documento(contenido_página="En el siglo XIII, Nasir al-Din Tusi (Nasireddin) realizó avances en la trigonometría esférica. También escribió una obra influyente sobre el postulado paralelo de Euclides. En el siglo XV, Ghiyath al-Kashi calculó el valor de π hasta la decimosexta cifra decimal. Kashi también tenía un algoritmo para calcular raíces enésimas, que era un caso especial de los métodos dados muchos siglos después por Ruffini y Horner.", metadata={'fuente': 'https://es.wikipedia.org/wiki/Historia_de_las_matemáticas', 'título': 'Historia de las matemáticas - Wikipedia', 'idioma': 'es'}), Documento(contenido_página='Whitehead, inició un largo debate sobre los fundamentos de las matemáticas.', metadata={'fuente': 'https://es.wikipedia.org/wiki/Historia_de_las_matemáticas', 'título': 'Historia de las matemáticas - Wikipedia', 'idioma': 'es'})]

Memoria

En LangChain, la memoria se refiere a la capacidad de un modelo para recordar partes previas de una conversación o contexto. Esto es necesario para mantener la continuidad en las interacciones. Vamos a usar ConversationBufferMemory para almacenar y recuperar historias de conversaciones.

from langchain.memory import ConversationBufferMemory# Inicializar la memoria del búfer de conversaciónmemory = ConversationBufferMemory(memory_key="chat_history")# Agregar mensajes a la memoria de la conversaciónmemory.chat_memory.add_user_message("¡Hola!")memory.chat_memory.add_ai_message("¡Bienvenido! ¿Cómo puedo ayudarte?")# Cargar variables de memoria si existenmemory.load_memory_variables({})>>>{'chat_history': 'Humano: ¡Hola!\nIA: ¡Bienvenido! ¿Cómo puedo ayudarte?'}

Veremos más ejemplos del uso de la memoria en las secciones siguientes.

Cadenas

Las cadenas de LangChain son secuencias de operaciones que procesan la entrada y generan la salida. Veamos un ejemplo de construir una cadena personalizada para desarrollar una respuesta de correo electrónico basada en el feedback proporcionado:

from langchain.prompts import PromptTemplatefrom langchain.chains import ConversationChain, summarize, question_answeringfrom langchain.schema import StrOutputParser# Definir y usar una cadena para resumir el feedback del clientefeedback_summary_prompt = PromptTemplate.from_template(    """Eres un gerente de servicio al cliente. Dado el feedback del cliente,        tu trabajo es resumir los puntos principales.       Feedback del cliente: {feedback}       Resumen:""")# Plantilla para redactar una respuesta de correo electrónico empresarialemail_response_prompt = PromptTemplate.from_template(    """Eres un representante de servicio al cliente. Dado el resumen del feedback del cliente,         tu trabajo es escribir una respuesta de correo electrónico profesional.Resumen del feedback:{summary}Respuesta de correo electrónico:""")feedback_chain = feedback_summary_prompt | llm | StrOutputParser()email_chain = (    {"summary": feedback_chain}    | email_response_prompt    | llm    | StrOutputParser())# Usar la cadena de feedback con el feedback real del clienteemail_chain.invoke(  {"feedback": "Descontento con la entrega tardía y el empaquetado deficiente."})>>>\n\nEstimado [Cliente],\n\nGracias por tomarse el tiempo para brindarnos su feedback. Nos disculpamos por la entrega tardía y la calidad del empaquetado. Nos tomamos muy en serio la satisfacción del cliente y lamentamos no haber cumplido con sus expectativas.\n\nActualmente, estamos investigando el problema y tomaremos las medidas necesarias para asegurarnos de que esto no vuelva a suceder en el futuro. Valoramos su negocio y esperamos que nos brinde otra oportunidad para brindarle una mejor experiencia.\n\nSi tiene alguna otra pregunta o inquietud, no dude en contactarnos.\n\nSinceramente,\n[Su Nombre]

Como puedes ver, tenemos dos cadenas: una genera el resumen del feedback (feedback_chain) y otra genera una respuesta de correo electrónico basada en el resumen del feedback (email_chain). La cadena anterior fue creada usando LangChain Expression Language – la forma preferida de crear cadenas, según LangChain.

También podemos usar cadenas predefinidas, por ejemplo, para tareas de resumen o preguntas simples y respuestas (Q&A):

# Cadenas predefinidas para resumen y Q&Achain = summarize.load_summarize_chain(llm, chain_type="stuff")chain.run(texts[:30])>>>La historia de las matemáticas trata sobre el origen de los descubrimientos en matemáticas y los métodos y notación matemática del pasado. Comenzó en el siglo VI a.C. con los pitagóricos, quienes acuñaron el término "matemáticas". Las matemáticas griegas refinaron enormemente los métodos y expandieron la temática de las matemáticas. Las matemáticas chinas realizaron contribuciones tempranas, incluyendo un sistema de valor posicional y el primer uso de números negativos. El sistema numérico indo-arábigo y las reglas para el uso de sus operaciones evolucionaron a lo largo del primer milenio d.C. en la India y se transmitieron al mundo occidental a través de las matemáticas islámicas. Desde tiempos antiguos hasta la Edad Media, los períodos de descubrimiento matemático a menudo eran seguidos por siglos de estancamiento. A partir del Renacimiento en Italia en el siglo XV, se realizaron nuevos desarrollos matemáticos que, junto con nuevos descubrimientos científicos, se hicieron a un ritmo creciente que continúa hasta el día de hoy.

chain = question_answering.load_qa_chain(llm, chain_type="stuff")chain.run(input_documents=texts[:30],   question="Menciona los más grandes matemáticos árabes del pasado")>>>Muḥammad ibn Mūsā al-Khwārizmī

Además de las cadenas predefinidas para resumir comentarios, responder preguntas, etc., podemos construir nuestras propias ConversationChain personalizadas e integrar la memoria en ellas.

# Usando la memoria en una cadena de conversaciónmemory = ConversationBufferMemory()conversación = ConversationChain(llm=llm, memoria=memoria)conversación.run("Nombra la montaña más alta del mundo")>>>La montaña más alta del mundo es el Monte Everestconversación.run("¿Qué tan alta es?")>>>El Monte Everest tiene una altura de 8.848 metros (29.029 pies) sobre el nivel del mar.

Agentes y herramientas

LangChain permite la creación de herramientas y agentes personalizados para tareas especializadas. Las herramientas personalizadas pueden ser desde llamar a API hasta funciones personalizadas de Python, que se pueden integrar en agentes de LangChain para operaciones complejas. Creemos un agente que convierta cualquier frase a minúsculas.

from langchain.tools import StructuredTool, BaseToolfrom langchain.agents import initialize_agent, AgentTypeimport re# Definir y usar una herramienta de procesamiento de texto personalizadadef procesamiento_texto(cadena: str) -> str:    """Procesa el texto"""    return cadena.lower()herramienta_procesamiento_texto = StructuredTool.from_function(procesamiento_texto)# Inicializar y usar un agente con la herramienta personalizadaagente = initialize_agent([herramienta_procesamiento_texto], llm,   agente=AgentType.ZERO_SHOT_REACT_DESCRIPTION, verbose=True)agente.run({"input": "Procesar el texto: Londres es la capital de Gran Bretaña"})>>>> Entrando en una nueva cadena de AgentExecutor... Necesito usar una herramienta de procesamiento de textoAcción: procesamiento_textoAcción de entrada: Londres es la capital de Gran BretañaObservación: londres es la capital de gran bretañaPensamiento: Ahora sé la respuesta finalRespuesta final: londres es la capital de gran bretaña> Cadena finalizada.'londres es la capital de gran bretaña'

Como puedes ver, nuestro agente utilizó la herramienta que definimos y convirtió la oración a minúsculas. Ahora creemos un agente completamente funcional. Para ello, crearemos una herramienta personalizada para convertir unidades (millas a kilómetros, por ejemplo) dentro del texto e integrarla en un agente conversacional utilizando el marco de trabajo de LangChain. La clase UnitConversionTool proporciona un ejemplo práctico de cómo ampliar las funcionalidades básicas con lógica de conversión específica.

import refrom langchain.tools import BaseToolfrom langchain.agents import initialize_agentclass UnitConversionTool(BaseTool):    """    Una herramienta para convertir unidades americanas a unidades internacionales.    Específicamente, convierte millas a kilómetros.    """    nombre = "Herramienta de Conversión de Unidades"    descripción = "Convierte unidades americanas a unidades internacionales"    def _run(self, texto: str):        """        Convierte sincrónicamente las millas en el texto a kilómetros.        Args:            texto (str): El texto de entrada que contiene las millas a convertir.        Returns:            str: El texto con las millas convertidas a kilómetros.        """        def millas_a_km(match):            millas = float(match.group(1))            return f"{millas * 1.60934:.2f} km"        return re.sub(r'\b(\d+(\.\d+)?)\s*(millas|milla)\b', millas_a_km, texto)    def _arun(self, texto: str):        """        Versión asincrónica de la función de conversión. Todavía no implementado.        """        raise NotImplementedError("No está implementado el asincrónico aún")# Inicializar un agente con la Herramienta de Conversión de Unidadesagente = initialize_agent(    agente='chat-conversational-react-description',    herramientas=[UnitConversionTool()],    llm=llm,    memoria=memoria)# Ejemplo de uso del agente para convertir unidadesagente.run("cinco millas")>>> Cinco millas es aproximadamente 8 kilómetros.agente.run("Disculpa, quería decir 15")>>> 15 kilómetros es aproximadamente 9.3 millas

Esto resume el código mostrado en mi documento de una página sobre LangChain. ¡Espero que te haya sido útil!

Recordatorio: Puedes descargar la versión en PDF, consultar los documentos de una página en GitHub y ejecutar el código en Colab.

Agradecería que aplaudieran el artículo y me siguieran, ya que esto me motiva a escribir nuevas partes y artículos 🙂 Además, recibirán una notificación cuando se publique la nueva parte.

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