Ingeniería rápida de cero a avanzada con Langchain en Python

Un aspecto importante de los modelos de lenguaje grande (LLM) es la cantidad de parámetros que estos modelos usan para el aprendizaje. Cuantos más parámetros tenga un modelo, mejor podrá comprender la relación entre palabras y frases. Esto significa que los modelos con miles de millones de parámetros tienen la capacidad de generar varios formatos de texto creativo y responder preguntas abiertas y desafiantes de manera informativa.

Los LLM como ChatGPT, que utilizan el modelo Transformer, dominan la comprensión y la generación del lenguaje humano, lo que los hace útiles para aplicaciones que requieren la comprensión del lenguaje natural. Sin embargo, tienen sus limitaciones, que incluyen conocimientos desactualizados, incapacidad para interactuar con sistemas externos, falta de comprensión del contexto y, en ocasiones, generar respuestas que suenan plausibles pero incorrectas o sin sentido, entre otras.

Abordar estas limitaciones requiere la integración de LLM con fuentes y capacidades de datos externas, lo que puede presentar complejidades y exigir amplias habilidades de codificación y manejo de datos. Esto, junto con los desafíos de comprender los conceptos de IA y los algoritmos complejos, contribuye a la curva de aprendizaje asociada con el desarrollo de aplicaciones que utilizan LLM.

Sin embargo, la integración de LLM con otras herramientas para formar aplicaciones impulsadas por LLM podría redefinir nuestro panorama digital. El potencial de tales aplicaciones es enorme, incluida la mejora de la eficiencia y la productividad, la simplificación de tareas, la mejora de la toma de decisiones y la provisión de experiencias personalizadas.

En este artículo, profundizaremos en estos temas, explorando las técnicas avanzadas de ingeniería rápida con Langchain, ofreciendo explicaciones claras, ejemplos prácticos e instrucciones paso a paso sobre cómo implementarlas.

Langchain, una biblioteca de última generación, brinda conveniencia y flexibilidad para diseñar, implementar y ajustar indicaciones. A medida que desglosemos los principios y las prácticas de la ingeniería rápida, aprenderá a utilizar las potentes funciones de Langchain para aprovechar las fortalezas de los modelos de IA generativa de SOTA como GPT-4.

Comprensión de las indicaciones

Antes de sumergirse en los tecnicismos de la ingeniería de avisos, es esencial comprender el concepto de avisos y su significado.

UNA 'puntual' es una secuencia de tokens que se utilizan como entrada a un modelo de lenguaje, instruyéndolo para generar un tipo particular de respuesta. Las indicaciones juegan un papel crucial en la dirección del comportamiento de un modelo. Pueden afectar la calidad del texto generado y, cuando se elaboran correctamente, pueden ayudar al modelo a proporcionar resultados detallados, precisos y específicos del contexto.

La ingeniería de avisos es el arte y la ciencia de diseñar avisos efectivos. El objetivo es obtener el resultado deseado de un modelo de lenguaje. Al seleccionar y estructurar cuidadosamente las indicaciones, se puede guiar el modelo hacia la generación de respuestas más precisas y relevantes. En la práctica, esto implica afinar las frases de entrada para satisfacer los sesgos estructurales y de entrenamiento del modelo.

La sofisticación de la ingeniería de avisos abarca desde técnicas simples, como alimentar el modelo con palabras clave relevantes, hasta métodos más avanzados que implican el diseño de avisos estructurados y complejos que aprovechan la mecánica interna del modelo.

Langchain: la herramienta rápida de más rápido crecimiento

LangChain, lanzado en octubre de 2022 por harrison chase, se ha convertido en uno de los marcos de código abierto mejor calificados en GitHub en 2023. Ofrece una interfaz simplificada y estandarizada para incorporar Large Language Models (LLM) en las aplicaciones. También proporciona una interfaz rica en funciones para ingeniería rápida, lo que permite a los desarrolladores experimentar con diferentes estrategias y evaluar sus resultados. Al utilizar Langchain, puede realizar tareas de ingeniería rápidas de manera más efectiva e intuitiva.

LangFlow sirve como una interfaz de usuario para orquestar los componentes de LangChain en un diagrama de flujo ejecutable, lo que permite la creación rápida de prototipos y la experimentación.

LangChain llena un vacío crucial en el desarrollo de IA para las masas. Permite una variedad de aplicaciones de NLP, como asistentes virtuales, generadores de contenido, sistemas de preguntas y respuestas y más, para resolver una variedad de problemas del mundo real.

En lugar de ser un modelo o proveedor independiente, LangChain simplifica la interacción con diversos modelos, ampliando las capacidades de las aplicaciones LLM más allá de las limitaciones de una simple llamada a la API.

La arquitectura de LangChain

Los componentes principales de LangChain incluyen E/S modelo, plantillas de solicitud, memoria, agentes y cadenas.

Modelo de E / S

LangChain facilita una conexión perfecta con varios modelos de lenguaje envolviéndolos con una interfaz estandarizada conocida como Model I/O. Esto facilita un cambio de modelo sin esfuerzo para la optimización o un mejor rendimiento. LangChain es compatible con varios proveedores de modelos de lenguaje, incluidos OpenAI, AbrazandoCara, Azure, Fuegos artificiales, y más.

Plantillas de solicitud

Estos se utilizan para administrar y optimizar las interacciones con LLM al proporcionar instrucciones o ejemplos concisos. La optimización de las indicaciones mejora el rendimiento del modelo y su flexibilidad contribuye significativamente al proceso de entrada.

Un ejemplo simple de una plantilla de solicitud:

from langchain.prompts import PromptTemplate
prompt = PromptTemplate(input_variables=["subject"],
template="What are the recent advancements in the field of {subject}?")
print(prompt.format(subject="Natural Language Processing"))

A medida que avanzamos en complejidad, encontramos patrones más sofisticados en LangChain, como el patrón Reason and Act (ReAct). ReAct es un patrón vital para la ejecución de acciones en el que el agente asigna una tarea a una herramienta adecuada, personaliza la entrada y analiza su salida para realizar la tarea. El siguiente ejemplo de Python muestra un patrón ReAct. Demuestra cómo se estructura un indicador en LangChain, utilizando una serie de pensamientos y acciones para razonar un problema y producir una respuesta final:

PREFIX = """Answer the following question using the given tools:"""
FORMAT_INSTRUCTIONS = """Follow this format:
Question: {input_question}
Thought: your initial thought on the question
Action: your chosen action from [{tool_names}]
Action Input: your input for the action
Observation: the action's outcome"""
SUFFIX = """Start!
Question: {input}
Thought:{agent_scratchpad}"""

Salud Cerebral

La memoria es un concepto crítico en LangChain, que permite que los LLM y las herramientas retengan información a lo largo del tiempo. Este comportamiento con estado mejora el rendimiento de las aplicaciones de LangChain al almacenar respuestas anteriores, interacciones del usuario, el estado del entorno y los objetivos del agente. Las estrategias ConversationBufferMemory y ConversationBufferWindowMemory ayudan a realizar un seguimiento de las partes completas o recientes de una conversación, respectivamente. Para un enfoque más sofisticado, la estrategia ConversationKGMemory permite codificar la conversación como un gráfico de conocimiento que se puede retroalimentar en indicaciones o usarse para predecir respuestas sin llamar al LLM.

Agentes

Un agente interactúa con el mundo realizando acciones y tareas. En LangChain, los agentes combinan herramientas y cadenas para la ejecución de tareas. Puede establecer una conexión con el mundo exterior para la recuperación de información para aumentar el conocimiento LLM, superando así sus limitaciones inherentes. Pueden decidir pasar los cálculos a una calculadora o a un intérprete de Python, según la situación.

Los agentes están equipados con subcomponentes:

• Herramientas: Estos son componentes funcionales.
• Kits de herramientas: Colecciones de herramientas.
• Agentes Ejecutores: Este es el mecanismo de ejecución que permite elegir entre herramientas.

Los agentes en LangChain también siguen el patrón Zero-shot ReAct, donde la decisión se basa solo en la descripción de la herramienta. Este mecanismo se puede ampliar con memoria para tener en cuenta el historial completo de la conversación. Con ReAct, en lugar de pedirle a un LLM que complete automáticamente su texto, puede solicitarle que responda en un ciclo de pensamiento/acción/observación.

Cadenas

Las cadenas, como sugiere el término, son secuencias de operaciones que permiten que la biblioteca LangChain procese las entradas y salidas del modelo de lenguaje sin problemas. Estos componentes integrales de LangChain se componen fundamentalmente de enlaces, que pueden ser otras cadenas, o primitivas como mensajes, modelos de lenguaje o utilidades.

Imagine una cadena como una cinta transportadora en una fábrica. Cada paso en este cinturón representa una determinada operación, que podría ser invocar un modelo de lenguaje, aplicar una función de Python a un texto o incluso solicitar el modelo de una manera particular.

LangChain clasifica sus cadenas en tres tipos: cadenas de servicios públicos, cadenas genéricas y cadenas de documentos combinados. Nos sumergiremos en las cadenas Utilitarias y Genéricas para nuestra discusión.

• Cadenas utilitarias están diseñados específicamente para extraer respuestas precisas de los modelos de lenguaje para tareas definidas de forma limitada. Por ejemplo, echemos un vistazo a LLMMathChain. Esta cadena de utilidades permite que los modelos de lenguaje realicen cálculos matemáticos. Acepta una pregunta en lenguaje natural y, a su vez, el modelo de lenguaje genera un fragmento de código de Python que luego se ejecuta para producir la respuesta.
• Cadenas genéricas, por otro lado, sirven como bloques de construcción para otras cadenas, pero no se pueden usar directamente de forma independiente. Estas cadenas, como LLMChain, son fundamentales y, a menudo, se combinan con otras cadenas para realizar tareas complejas. Por ejemplo, LLMChain se usa con frecuencia para consultar un objeto de modelo de lenguaje formateando la entrada en función de una plantilla de solicitud proporcionada y luego pasándola al modelo de lenguaje.

Implementación paso a paso de Prompt Engineering con Langchain

Lo guiaremos a través del proceso de implementación de ingeniería rápida utilizando Langchain. Antes de continuar, asegúrese de haber instalado el software y los paquetes necesarios.

Puede aprovechar herramientas populares como Docker, Conda, Pip y Poetry para configurar LangChain. Los archivos de instalación relevantes para cada uno de estos métodos se pueden encontrar en el repositorio de LangChain en https://github.com/benman1/generative_ai_with_langchain. Esto incluye un Dockerfile para Docker, un requerimientos.txt para Pip, un pyproject.toml para la poesía, y un langchain_ai.yml archivo para Conda.

En nuestro artículo usaremos Pip, el administrador de paquetes estándar para Python, para facilitar la instalación y administración de bibliotecas de terceros. Si no está incluido en su distribución de Python, puede instalar Pip siguiendo las instrucciones en https://pip.pypa.io/.

Para instalar una biblioteca con Pip, use el comando pip install library_name.

Sin embargo, Pip no gestiona los entornos por sí solo. Para manejar diferentes entornos, utilizamos la herramienta virtualenv.

En la siguiente sección, discutiremos las integraciones de modelos.

Paso 1: Configuración de Langchain

Primero, debe instalar el paquete Langchain. Estamos usando el sistema operativo Windows. Ejecute el siguiente comando en su terminal para instalarlo:

pip install langchain

Paso 2: Importación de Langchain y otros módulos necesarios

A continuación, importe Langchain junto con otros módulos necesarios. Aquí, también importamos la biblioteca de transformadores, que se usa ampliamente en tareas de NLP.

import langchain
from transformers import AutoModelWithLMHead, AutoTokenizer

Paso 3: Cargue el modelo preentrenado

AI abierto

OpenAI los modelos se pueden interconectar convenientemente con la biblioteca LangChain o la biblioteca de cliente OpenAI Python. En particular, OpenAI proporciona una clase de incrustación para modelos de incrustación de texto. Dos modelos LLM clave son GPT-3.5 y GPT-4, que difieren principalmente en la longitud del token. Los precios de cada modelo se pueden encontrar en el sitio web de OpenAI. mientras hay mas modelos sofisticados como GPT-4-32K que tienen una mayor aceptación de tokens, su disponibilidad a través de API es no siempre garantizado.

Acceder a estos modelos requiere una clave API de OpenAI. Esto se puede hacer creando una cuenta en la plataforma de OpenAI, configurando la información de facturación y generando una nueva clave secreta.

import os
os.environ["OPENAI_API_KEY"] = 'your-openai-token'

Después de crear correctamente la clave, puede establecerla como una variable de entorno (OPENAI_API_KEY) o pasarla como parámetro durante la creación de instancias de clase para las llamadas de OpenAI.

Considere un script LangChain para mostrar la interacción con los modelos de OpenAI:

from langchain.llms import OpenAI
llm = OpenAI(model_name="text-davinci-003")
# The LLM takes a prompt as an input and outputs a completion
prompt = "who is the president of the United States of America?"
completion = llm(prompt)

The current President of the United States of America is Joe Biden.

En este ejemplo, se inicializa un agente para realizar cálculos. El agente toma una entrada, una simple tarea de suma, la procesa utilizando el modelo OpenAI proporcionado y devuelve el resultado.

Abrazando la cara

Abrazando la cara es un DE USO GRATUITO Biblioteca Transformers Python, compatible con PyTorch, TensorFlow y JAX, e incluye implementaciones de modelos como BERTI, T5, etc.

Hugging Face también ofrece Hugging Face Hub, una plataforma para alojar repositorios de código, modelos de aprendizaje automático, conjuntos de datos y aplicaciones web.

Para utilizar Hugging Face como proveedor de sus modelos, necesitará una cuenta y claves API, que se pueden obtener en su sitio web. El token puede estar disponible en su entorno como HUGGINGFACEHUB_API_TOKEN.

Considere el siguiente fragmento de Python que utiliza un modelo de código abierto desarrollado por Google, el modelo Flan-T5-XXL:

from langchain.llms import HuggingFaceHub
llm = HuggingFaceHub(model_kwargs={"temperature": 0.5, "max_length": 64},repo_id="google/flan-t5-xxl")
prompt = "In which country is Tokyo?"
completion = llm(prompt)
print(completion)

Este script toma una pregunta como entrada y devuelve una respuesta, mostrando el conocimiento y las capacidades de predicción del modelo.

Paso 4: Ingeniería básica de avisos

Para empezar, generaremos un aviso simple y veremos cómo responde el modelo.

prompt = 'Translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')
generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

En el fragmento de código anterior, proporcionamos un mensaje para traducir el texto en inglés al francés. Luego, el modelo de lenguaje intenta traducir el texto dado según el aviso.

Paso 5: Ingeniería rápida avanzada

Si bien el enfoque anterior funciona bien, no aprovecha al máximo el poder de la ingeniería rápida. Mejorémoslo introduciendo algunas estructuras de indicaciones más complejas.

prompt = 'As a highly proficient French translator, translate the following English text to French: "{0}"'
input_text = 'Hello, how are you?'
input_ids = tokenizer.encode(prompt.format(input_text), return_tensors='pt')
generated_ids = model.generate(input_ids, max_length=100, temperature=0.9)
print(tokenizer.decode(generated_ids[0], skip_special_tokens=True))

En este fragmento de código, modificamos el indicador para sugerir que la traducción la está realizando un 'traductor de francés altamente competente'. El cambio en el indicador puede conducir a traducciones mejoradas, ya que el modelo ahora asume la personalidad de un experto.

Creación de un sistema de preguntas y respuestas sobre literatura académica con Langchain

Construiremos un sistema de preguntas y respuestas sobre literatura académica utilizando LangChain que pueda responder preguntas sobre artículos académicos publicados recientemente.

En primer lugar, para configurar nuestro entorno, instalamos las dependencias necesarias.

pip install langchain arxiv openai transformers faiss-cpu

Después de la instalación, creamos un nuevo cuaderno de Python e importamos las bibliotecas necesarias:

from langchain.llms import OpenAI
from langchain.chains.qa_with_sources import load_qa_with_sources_chain
from langchain.docstore.document import Document
import arxiv

El núcleo de nuestro sistema de preguntas y respuestas es la capacidad de obtener artículos académicos relevantes relacionados con un determinado campo, aquí consideramos el procesamiento del lenguaje natural (NLP), utilizando la base de datos académica arXiv. Para realizar esto, definimos una función get_arxiv_data(max_results=10). Esta función recopila los resúmenes en papel de NLP más recientes de arXiv y los encapsula en objetos LangChain Document, utilizando el resumen como contenido y la identificación de entrada única como fuente.

Usaremos la API de arXiv para obtener artículos recientes relacionados con la PNL:

def get_arxiv_data(max_results=10):
    search = arxiv.Search(
        query="NLP",
        max_results=max_results,
        sort_by=arxiv.SortCriterion.SubmittedDate,
    )
   
    documents = []
   
    for result in search.results():
        documents.append(Document(
            page_content=result.summary,
            metadata={"source": result.entry_id},
        ))
    return documents

Esta función recupera los resúmenes de los artículos de NLP más recientes de arXiv y los convierte en objetos LangChain Document. Usamos el resumen del artículo y su identificación de entrada única (URL del artículo) como contenido y fuente, respectivamente.

def print_answer(question):
    print(
        chain(
            {
                "input_documents": sources,
                "question": question,
            },
            return_only_outputs=True,
        )["output_text"]
    )                 

Definamos nuestro corpus y configuremos LangChain:

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(temperature=0))

Con nuestro sistema académico de preguntas y respuestas ahora listo, podemos probarlo haciendo una pregunta:

print_answer("What are the recent advancements in NLP?")

El resultado será la respuesta a su pregunta, citando las fuentes de donde se extrajo la información. Por ejemplo:

Recent advancements in NLP include Retriever-augmented instruction-following models and a novel computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs).
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Puede cambiar fácilmente de modelo o modificar el sistema según sus necesidades. Por ejemplo, aquí estamos cambiando a GPT-4, lo que termina dándonos una respuesta mucho mejor y más detallada.

sources = get_arxiv_data(2)
chain = load_qa_with_sources_chain(OpenAI(model_name="gpt-4",temperature=0))

Recent advancements in Natural Language Processing (NLP) include the development of retriever-augmented instruction-following models for information-seeking tasks such as question answering (QA). These models can be adapted to various information domains and tasks without additional fine-tuning. However, they often struggle to stick to the provided knowledge and may hallucinate in their responses. Another advancement is the introduction of a computational framework for solving alternating current optimal power flow (ACOPF) problems using graphics processing units (GPUs). This approach utilizes a single-instruction, multiple-data (SIMD) abstraction of nonlinear programs (NLP) and employs a condensed-space interior-point method (IPM) with an inequality relaxation strategy. This strategy allows for the factorization of the KKT matrix without numerical pivoting, which has previously hampered the parallelization of the IPM algorithm.
SOURCES: http://arxiv.org/abs/2307.16877v1, http://arxiv.org/abs/2307.16830v1

Un token en GPT-4 puede ser tan corto como un carácter o tan largo como una palabra. Por ejemplo, GPT-4-32K puede procesar hasta 32,000 4 tokens en una sola ejecución, mientras que GPT-8-3.5K y GPT-8,000-turbo admiten 4,000 y XNUMX tokens respectivamente. Sin embargo, es importante tener en cuenta que cada interacción con estos modelos tiene un costo que es directamente proporcional a la cantidad de tokens procesados, ya sea de entrada o de salida.

En el contexto de nuestro sistema de preguntas y respuestas, si una pieza de literatura académica excede el límite máximo de tokens, el sistema no podrá procesarla en su totalidad, lo que afectará la calidad y la integridad de las respuestas. Para solucionar este problema, el texto se puede dividir en partes más pequeñas que cumplan con el límite de tokens.

FAISS (búsqueda de similitud de IA de Facebook) ayuda a encontrar rápidamente los fragmentos de texto más relevantes relacionados con la consulta del usuario. Crea una representación vectorial de cada fragmento de texto y utiliza estos vectores para identificar y recuperar los fragmentos más similares a la representación vectorial de una pregunta dada.

Es importante recordar que incluso con el uso de herramientas como FAISS, la necesidad de dividir el texto en fragmentos más pequeños debido a las limitaciones de los tokens a veces puede conducir a la pérdida de contexto, lo que afecta la calidad de las respuestas. Por lo tanto, la gestión cuidadosa y la optimización del uso de tokens son cruciales cuando se trabaja con estos grandes modelos de lenguaje.

 
pip install faiss-cpu langchain CharacterTextSplitter

Después de asegurarse de que las bibliotecas anteriores estén instaladas, ejecute

 
from langchain.embeddings.openai import OpenAIEmbeddings 
from langchain.vectorstores.faiss import FAISS 
from langchain.text_splitter import CharacterTextSplitter 
documents = get_arxiv_data(max_results=10) # We can now use feed more data
document_chunks = []
splitter = CharacterTextSplitter(separator=" ", chunk_size=1024, chunk_overlap=0)
for document in documents:
    for chunk in splitter.split_text(document.page_content):
        document_chunks.append(Document(page_content=chunk, metadata=document.metadata))
search_index = FAISS.from_documents(document_chunks, OpenAIEmbeddings())
chain = load_qa_with_sources_chain(OpenAI(temperature=0))
def print_answer(question):
    print(
        chain(
            {
                "input_documents": search_index.similarity_search(question, k=4),
                "question": question,
            },
            return_only_outputs=True,
        )["output_text"]
    )

Con el código completo, ahora tenemos una poderosa herramienta para consultar la literatura académica más reciente en el campo de la PNL.

 
Recent advancements in NLP include the use of deep neural networks (DNNs) for automatic text analysis and natural language processing (NLP) tasks such as spell checking, language detection, entity extraction, author detection, question answering, and other tasks. 
SOURCES: http://arxiv.org/abs/2307.10652v1, http://arxiv.org/abs/2307.07002v1, http://arxiv.org/abs/2307.12114v1, http://arxiv.org/abs/2307.16217v1 

Conclusión

La integración de modelos de lenguaje grande (LLM) en las aplicaciones ha acelerado la adopción de varios dominios, incluida la traducción de idiomas, el análisis de opiniones y la recuperación de información. La ingeniería rápida es una herramienta poderosa para maximizar el potencial de estos modelos, y Langchain está liderando el camino para simplificar esta tarea compleja. Su interfaz estandarizada, plantillas de solicitud flexibles, integración sólida de modelos y el uso innovador de agentes y cadenas garantizan resultados óptimos para el desempeño de los LLM.

Sin embargo, a pesar de estos avances, hay algunos consejos a tener en cuenta. A medida que usa Langchain, es esencial comprender que la calidad de la salida depende en gran medida de la redacción del aviso. Experimentar con diferentes estilos y estructuras de indicaciones puede producir mejores resultados. Además, recuerde que si bien Langchain admite una variedad de modelos de lenguaje, cada uno tiene sus fortalezas y debilidades. Elegir el adecuado para su tarea específica es crucial. Por último, es importante recordar que el uso de estos modelos conlleva consideraciones de costos, ya que el procesamiento de tokens influye directamente en el costo de las interacciones.

Como se demuestra en la guía paso a paso, Langchain puede potenciar aplicaciones sólidas, como el sistema de preguntas y respuestas sobre literatura académica. Con una creciente comunidad de usuarios y una creciente prominencia en el panorama del código abierto, Langchain promete ser una herramienta fundamental para aprovechar todo el potencial de los LLM como GPT-4.