Creación de un GAR multilingüe con Milvus, LangChain y OpenAI LLM
Durante los dos últimos años, la Generación de Recuperación Aumentada (RAG) se ha convertido rápidamente en una de las técnicas más populares para crear aplicaciones GenAI basadas en grandes modelos lingüísticos (LLM). En esencia, la RAG mejora los resultados de un LLM proporcionando información contextual sobre la que el modelo no ha sido preentrenado. La RAG multilingüe es una RAG ampliada que maneja datos de texto en varios idiomas.
Yujian Tang, director general de OSS4AI, habló recientemente en un Encuentro sobre datos no estructurados organizado por Zilliz. Habló de la RAG y sus componentes fundamentales y demostró cómo construir una RAG multilingüe para abordar diversos retos lingüísticos del mundo real.
En este artículo, recapitularemos los puntos clave de la presentación de Yujian y te guiaremos en la implementación de un GAR multilingüe. Si quieres saber más sobre la charla de Yujian, te recomendamos que veas su presentación en YouTube.
¿Qué es el GAR y cómo funciona?
Una de las principales limitaciones de las aplicaciones basadas en LLM es su dependencia de los datos con los que fueron entrenadas. Si el LLM no fue expuesto a cierta información o a todo un dominio de conocimiento durante el pre-entrenamiento, no entendería las relaciones lingüísticas necesarias para generar respuestas precisas. Esta falta de datos puede hacer que el LLM admita que no sabe la respuesta o, peor aún, que "alucine" y proporcione información incorrecta.
La GAR es una técnica popular que aborda los problemas de alucinación de los LLM proporcionándoles información contextual adicional. También permite a los desarrolladores y las empresas acceder a sus datos privados o patentados sin preocuparse por los problemas de seguridad.
Figura 1- Funcionamiento de la GAR](https://assets.zilliz.com/Figure_1_How_RAG_works_246044aacf.png)
RAG parte de un modelo de incrustación que transforma los datos de texto en incrustaciones vectoriales, representaciones numéricas que captan el significado semántico del texto. A continuación, el sistema RAG almacena estos vectores en una base de datos vectorial como Milvus o Zilliz Cloud, que los indexa para la búsqueda de similitudesh.
Cuando un usuario envía una consulta, el modelo de incrustación también convierte la entrada en un vector. A continuación, el sistema RAG compara la similitud de este vector de consulta con los vectores de la base de datos de vectores calculando su distancia en el espacio vectorial de alta dimensión. Si se encuentran datos relevantes, el sistema RAG recupera esta información y la añade a la consulta original para formar una nueva consulta para el LLM. El LLM utiliza esta información adicional para generar una respuesta más precisa y contextualmente relevante, superando lo que podría producir basándose únicamente en sus datos de entrenamiento.
¿Qué es el GAR multilingüe?
La GAR multilingüe amplía las capacidades de la GAR tradicional para admitir varios idiomas. Integra un modelo de incrustación entrenado en varios idiomas, lo que permite al sistema procesar y generar respuestas en distintas lenguas. Gracias a este enfoque multilingüe, el sistema RAG puede gestionar consultas en cualquier idioma, recuperar información relevante independientemente de su idioma original y ofrecer respuestas precisas y contextualmente relevantes en el idioma preferido del usuario.
Cómo crear una aplicación RAG multilingüe: guía paso a paso
Ahora que hemos aprendido los conceptos y componentes básicos de RAG, vamos a implementar una aplicación RAG multilingüe paso a paso.
Esta aplicación de ejemplo contiene dos partes: un raspador web y la aplicación principal.
El web scraper** extrae el conjunto de datos necesarios de Internet.
La aplicación principal crea incrustaciones vectoriales, realiza búsquedas de similitud vectorial y genera las respuestas.
El raspador web
En primer lugar, extraeremos datos de Wikipedia y los utilizaremos como información contextual para este ejemplo de RAG.
Definir los Títulos: Comenzamos definiendo una lista llamada
wiki_titles, que contiene una lista de ciudades. Cada ciudad representa un archivo de texto que el web scraper rellenará con el contenido de su correspondiente entrada de Wikipedia. Por ejemplo, "Atlanta.txt" contendrá texto extraído de la página de Atlanta en Wikipedia.Raspando los datos:** iteramos sobre cada ciudad en
wiki_titles, hacemos una petición GET a la API de Wikipedia, y extraemos el contenido de la página de la respuesta JSON. A continuación, el texto se guarda en un archivo de texto correspondiente a cada ciudad.
from pathlib import Ruta
importar peticiones
wiki_títulos = [
"Atlanta",
"Berlín",
"Boston",
"El Cairo",
"Chicago",
"Copenhague",
"Houston",
"Karachi",
"Lisboa",
"Londres",
"Moscú",
"Múnich",
"París",
"Pékin", # Pekín en francés
"San Francisco",
"Seattle",
"Shanghai",
"Tokio",
"Toronto",
]
data_path = Path("./ciudad_data")
data_path.mkdir(exist_ok=True) # Asegurarse de que el directorio existe
for title in wiki_titles:
response = requests.get(
"https://fr.wikipedia.org/w/api.php",
params={
"acción": "query",
"format": "json",
"titles": título,
"prop": "extractos",
"explaintext": True,
},
).json()
page = next(iter(response["query"]["pages"].values()))
wiki_text = page.get("extract", "") # Usa .get() para evitar KeyError
if wiki_text: # Compruebe si el extracto no está vacío
with open(ruta_datos / f"{título}.txt", "w") as fp:
fp.write(wiki_text)
si no:
print(f "No extract found for {title}")
Preparando su entorno
En primer lugar, configure su entorno de desarrollo instalando las bibliotecas necesarias: la base de datos vectorial Milvus, LangChain, OpenAI y transformadores de frases.
Además, tendrás que incluir tu clave API si te estás conectando a un LLM a través de una API, como OpenAI. Esta clave puede ser almacenada en un archivo .env separado y accedida usando load_dotenv() y os .
Aquí está el código para instalar las librerías y cargar tu clave API:
pip install -qU pymilvus langchain sentence-transformers tiktoken openai
from dotenv import carga_dotenv
import os
load_dotenv() # Cargar variables de entorno desde el archivo .env
os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY") # Establecer la clave API
Instalar librerías: Usa
pippara instalarpymilvus,langchain,sentence-transformers,tiktoken, yopenai.Cargar variables de entorno:** Usa
dotenvpara cargar variables de entorno desde un fichero.env.Establecer clave API:** Recupera la clave API de OpenAI de las variables de entorno y establécela.
Asegúrese de que su archivo .env contiene su clave de API OpenAI en el siguiente formato:
OPENAI_API_KEY=tu_clave_api_aquí
Inicializando el LLM
Una vez configurado el entorno, el siguiente paso es definir el LLM que utilizarás en tu aplicación. En el siguiente fragmento de código, lo conseguimos importando la librería OpenAI y definiendo el LLM con el constructor de OpenAI.
from langchain.llms import OpenAI
llm = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
Puedes optar por un LLM de código abierto para evitar los costes asociados a las llamadas a la API de OpenAI. Hugging Face ofrece cientos de miles de modelos de aprendizaje profundo con los que experimentar. Para utilizar un LLM de código abierto de HuggingFace, necesitarás importar la Transformers library.
from transformers import pipeline
llm = pipeline('text-generation', model='gpt2') # Sustituye 'gpt2' por el modelo que desees
Puedes cambiar entre OpenAI y un modelo de código abierto modificando el código de importación e inicialización correspondiente.
Elegir un modelo de incrustación apropiado.
Cuando se construye un sistema RAG multilingüe, nuestra elección del modelo de incrustación es tan importante como nuestra elección del LLM, ya que el modelo de incrustación debe ser compatible con el idioma con el que se está trabajando. Para este ejemplo, en el que el idioma es el francés, las incrustaciones HuggingFace predeterminadas son suficientes. Sin embargo, debe identificar y utilizar el modelo de incrustación más adecuado para otros idiomas.
El MTEB Leaderboard de HuggingFace es un valioso recurso para encontrar modelos de incrustación. Esta tabla de clasificación enumera los modelos de incrustación con mejores resultados para varios idiomas, como las incrustaciones en chino y polaco identificadas por Yujian. Al seleccionar un modelo de incrustación, debe especificar el nombre del modelo como parámetro.
A continuación se explica cómo configurar el modelo de incrustación:
from langchain_community.embeddings import HuggingFaceEmbeddings
embeddings = HuggingFaceEmbeddings()
# Alternativamente, para las incrustaciones chinas, el modelo se # pasa como parámetro, por ejemplo
# HuggingFaceEmbeddings(model_name="TownsWu/PEG")
Carga y división de datos en trozos
A continuación, cargamos los archivos de datos de ciudades que hemos extraído de Wikipedia y los dividimos en segmentos o trozos. Al dividir el texto en trozos, evitamos comparar una consulta con el documento completo, lo que aumenta la eficacia de la recuperación de información. Cuanto más pequeño sea el trozo, determinado por el parámetro chunk_size, mayor será la precisión, pero más operaciones de recuperación serán necesarias. Cuanto mayor sea el solapamiento entre trozos, definido por el parámetro chunk_overlap, menor será la posibilidad de que se pierda el contexto, a costa de una mayor redundancia.
from langchain.text_splitter import CharacterTextSplitter
from langchain.schema import Document
ficheros = os.listdir("./ciudad_francesa_data")
textos_archivo = []
for archivo in archivos:
with open(f"./ciudad_francesa_datos/{archivo}") as f:
texto_archivo = f.read()
text_splitter = CharacterTextSplitter.from_tiktoken_encoder(
chunk_size=512, chunk_overlap=64,
)
textos = text_splitter.split_text(texto_archivo)
for i, chunked_text in enumerate(textos):
file_texts.append(Document(page_content=chunked_text,
metadata={"doc_title": file.split(".")[0], "chunk_num":i}))
Cargar documentos en Milvus
Después de fragmentar los archivos de datos de la ciudad y almacenarlos como una lista de documentos, necesitamos cargarlos en un almacén vectorial - en este caso, la base de datos vectorial Milvus. El código siguiente gestiona la carga inicial y las actualizaciones cuando los datos de la ciudad se almacenan en Milvus.
from langchain_community.vectorstores import Milvus
# Para la primera ejecución
vector_store = Milvus.from_documents(
textos_archivo,
embedding=embeddings,
connection_args={"host": "localhost", "port": 19530},
collection_name="ciudades_francesas"
)
# si sus datos ya están almacenados en Milvus
vector_store = Milvus(
embedding_function=embeddings,
connection_args={"host": "localhost", "port": 19530},
collection_name="ciudades francesas"
)
Crear un Recuperador
A continuación, inicializaremos nuestro recuperador, una interfaz que devuelve documentos de una fuente concreta basándose en una consulta dada. El código siguiente utiliza el almacén vectorial que creamos en el último paso como recuperador y lo asigna a una variable.
recuperador = vector_almacén.como_recuperador()
Create Prompt Template Using LangChain
Las plantillas de avisos le permiten formatear su entrada a un LLM dentro de su aplicación con precisión. Son especialmente útiles en los casos en los que desee reutilizar el mismo esquema de solicitud pero con pequeños ajustes, como en nuestra aplicación multilingüe RAG, en la que podemos utilizar la misma plantilla de solicitud para varios idiomas.
Las plantillas de avisos también le permiten construir un aviso a partir de una entrada dinámica, por ejemplo, una entrada de usuario o datos recuperados de un almacén de vectores. En nuestra aplicación, incluiremos dinámicamente la pregunta, que se pasará directamente a la cadena, y el contexto que el recuperador obtuvo del almacén de vectores.
from langchain.prompts import ChatPromptTemplate
template=""
Eres un asistente para tareas de respuesta a preguntas. Utiliza las siguientes piezas de contexto recuperadas para responder a la pregunta. Si no sabes la respuesta, di simplemente que no la sabes.
Utiliza tres frases como máximo y sé conciso.
Responda en francés.
Pregunta: {pregunta}
Contexto: {contexto}
Respuesta:""
prompt = ChatPromptTemplate.from_template(template)
Encadenando los Componentes para Crear la Aplicación RAG
El encadenamiento es un proceso que conecta componentes para crear aplicaciones de IA de extremo a extremo, que es una de las capacidades clave de LangChain.
El siguiente código muestra cómo construir una cadena que incluya los siguientes elementos: el contexto del recuperador, el prompt de entrada procesado por la función runnablepassthrough(), la plantilla del prompt, el LLM, y el stroutparser(), que emite la respuesta de la invocación de la cadena.
from langchain_core.runnables import RunnablePassthrough
from langchain_core.output_parsers import StrOutputParser
cadena = (
{"contexto": retriever, "pregunta": RunnablePassthrough()}
| prompt
| llm
| StrOutputParser()
)
Realización de consultas con la cadena
Una vez construida la cadena, puede invocarla con diversas consultas. Por ejemplo:
response = chain.invoke("Cuéntame un hecho histórico sobre Karachi.")
Esta consulta produce la siguiente respuesta en francés
"Karachi a été mentionnée pour la première fois dans l'ouvrage Histoire des plantes de Théophraste au IIIe siècle av. J.-C. Fue ocupada por los británicos a principios del siglo XIX y se convirtió en capital de Sind en 1839. En 1876, el futuro fundador de Pakistán, Muhammad Ali Jinnah, nació y se instaló en Karachi".
Para demostrar su capacidad multilingüe, he aquí otra pregunta, esta vez en francés:
response_2 = chain.invoke("Racontez-moi un fait historique sur Karachi.")
A pesar de que la pregunta subyacente es la misma, los distintos idiomas (inglés y francés) dan lugar a incrustaciones diferentes, lo que se traduce en un resultado distinto:
"Karachi es una ciudad fundada por los británicos a principios del siglo XIX que se convirtió en la capital de Sind. Ha sido un importante centro económico y ha experimentado un rápido crecimiento, sobre todo gracias a su puerto. Desde 1980, la ciudad ha sido escenario de conflictos étnicos y religiosos, y en 2012 fue el lugar del incendio industrial más mortífero de la historia".
Enhorabuena. Has creado con éxito una aplicación RAG multilingüe. Ten en cuenta que las incrustaciones son fundamentales para el modo en que el LLM interpreta los idiomas. Selecciona la incrustación más adecuada para soportar múltiples idiomas e intégrala en tu aplicación.
Resumen
¡Wow! Este post es bastante largo. Recapitulemos algunos de sus puntos clave.
La Retrieval augmented generation (RAG) es un marco que aumenta la salida LLM insertando datos adicionales en las indicaciones de entrada. RAG puede resolver los molestos problemas de alucinación de LLM.
La RAG multilingüe es una RAG ampliada que gestiona documentos multilingües.
Los modelos de incrustación, las bases de datos vectoriales y los LLM son tres componentes básicos de las aplicaciones RAG.
La clave para desarrollar aplicaciones RAG multilingües es la elección del modelo de incrustación. La tabla de clasificación MTEB de HuggingFace es un excelente recurso para encontrar el modelo adecuado para su aplicación.
Otros recursos
Presentación completa de Yuijan Tang en YouTube](https://www.youtube.com/watch?v=UhRD_ALzAnU&list=PLPg7_faNDlT5F_6J8jjFSMw-Ars_ogtZk&index=28)
Top Performing Embedding Models for Your GenAI Apps | Zilliz](https://zilliz.com/ai-models)
Centro de recursos de IA Generativa | Zilliz](https://zilliz.com/learn/generative-ai)
Técnicas de mejora de la GAR:
Better RAG with HyDE - Hypothetical Document Embeddings](https://zilliz.com/learn/improve-rag-and-information-retrieval-with-hyde-hypothetical-document-embeddings)
Mejora de la GAR con grafos de conocimiento mediante WhyHow](https://zilliz.com/blog/enhance-rag-with-knowledge-graphs)
Cómo mejorar el rendimiento de su canal de RAG](https://zilliz.com/learn/how-to-enhance-the-performance-of-your-rag-pipeline)
Optimización de la GAR con rezonificadores: función y ventajas y desventajas](https://zilliz.com/learn/optimize-rag-with-rerankers-the-role-and-tradeoffs)
Trucos y consejos prácticos para desarrolladores que crean aplicaciones RAG](https://zilliz.com/blog/praticial-tips-and-tricks-for-developers-building-rag-applications)
Desafíos de infraestructura en la ampliación de la GAR con modelos de IA personalizados](https://zilliz.com/blog/infrastructure-challenges-in-scaling-rag-with-custom-ai-models)
Sigue leyendo
Cosmos World Foundation Model Platform for Physical AI
NVIDIA's Cosmos platform enables safe, digital twin training of GenAI models for physical applications, overcoming data scarcity and safety challenges.
Bringing AI to Legal Tech: The Role of Vector Databases in Enhancing LLM Guardrails
Discover how vector databases enhance AI reliability in legal tech, ensuring accurate, compliant, and trustworthy AI-powered legal solutions.
Selecting the Right ETL Tools for Unstructured Data to Prepare for AI
Learn the right ETL tools for unstructured data to power AI. Explore key challenges, tool comparisons, and integrations with Milvus for vector search.