Creación y Gestión de Bases de Datos Vectoriales con Chroma

Resumen

Desde la conversión de documentos en PDF a texto hasta la implementación de un sistema de búsqueda eficiente con embeddings, el procesamiento del lenguaje natural (PLN) y la inteligencia artificial (IA) continúan revolucionando la gestión de la información. Gracias a herramientas open-source como ChromaDB, es posible almacenar y recuperar datos de manera eficiente, permitiendo a las máquinas entender y responder consultas de manera relevante. Acompáñame en este viaje mientras exploramos cómo transformar texto en datos numéricos y cómo implementar una solución de búsqueda basada en embeddings con ChromaDB.

¿Cómo se convierten los documentos en datos numéricos?

La transformación de documentos a datos numéricos se realiza mediante un proceso de embedding, donde el texto se divide en fragmentos y se convierte en vectores numéricos. A continuación, se describe cómo llevar a cabo este proceso:

Conversión de PDF a texto: Se inicia con la conversión de documentos en formato PDF a un formato de texto editable.
División del texto: Utilizando un splitter de texto, se divide el contenido en fragmentos del tamaño adecuado para ajustarse a los embeddings.
Embedding del texto: Se aplica un modelo de embedding para convertir los fragmentos de texto en vectores numéricos, que son listas de números que representan cada fragmento.

¿Qué es ChromaDB y cómo se utiliza para almacenar embeddings?

ChromaDB es una base de datos open-source diseñada específicamente para almacenar y gestionar embeddings. Es una de las varias opciones disponibles para manejar este tipo de datos, siendo algunas alternativas PyCon, Weebyte y FISE. A continuación, se detallan los pasos para utilizar ChromaDB:

Instalación de ChromaDB: A través de pip install, se instala ChromaDB en el entorno de trabajo.
Importación desde VectorStores: Luego se importa Chroma desde la librería VectorStores.
Creación del índice Chroma: Se asigna un nombre único al índice que almacenará los embeddings, basado en la aplicación deseada.
Configuración de la base de datos: Se indica el modelo de embedding utilizado y se realizan ajustes para garantizar que la base de datos persista localmente.

¿Cómo se asegura la persistencia de la base de datos?

Para asegurar que la base de datos de embeddings se mantenga a lo largo del tiempo, incluso después de cerrar la sesión, es necesario hacer uso del método persist. Aquí se explican los pasos:

Uso del método persist: Se almacenan los vectores numéricos en la base de datos con el método persist.
Recarga de la base de datos: En visitas futuras, la base de datos se puede recargar desde el almacenamiento local sin necesidad de recrear los embeddings.

¿Cómo se realiza búsquedas en la base de datos con embeddings?

Una vez que los embeddings están almacenados en ChromaDB, es posible realizar búsquedas para encontrar fragmentos de texto relevantes a una consulta específica. Veamos cómo:

Creación de una consulta: Se formula una búsqueda o 'query' en el idioma que maneja el modelo de embeddings.
Búsqueda por similitud: Se utiliza el método SimilaritySearch para encontrar los embeddings más similares a la consulta planteada.
Análisis de resultados: Se revisan los fragmentos de texto recuperados para identificar aquellos que mejor responden a la pregunta hecha.

Desafío para el aprendizaje continuo

Te invito a ampliar tus conocimientos y aplicar lo aprendido en un nuevo proyecto:

Usa un modelo de embedding diferente: Experimenta con distintos modelos disponibles, como los de OpenAI o Cohere.
Cambia el tipo de documento: Intenta trabajar con archivos en formatos CSV o datos extraídos de repositorios en GitHub.

El objetivo es crear tu propia base de datos vectorial con Chroma utilizando distintas fuentes de información y modelos de embeddings. Con pasión y constancia, no solo estarás mejorando tus habilidades, sino que también estarás contribuyendo al avance del conocimiento colectivo en el fascinante mundo del PLN y la IA.

Recuerda siempre: el aprendizaje es un viaje, no un destino, y cada nuevo conocimiento que adquieres es una pieza que contribuye al desarrollo de soluciones más avanzadas e inclusivas. ¡Adelante con tu proyecto!

Gabriel Ichcanziho Pérez Landa

student•

Les comparto el código formateado de una forma más "pythonica" y menos "colab".

Primero instalamos las biliotecas necesarias:

pip install langchain
pip install pypdf
pip install InstructorEmbedding 
pip instal sentence_transformers
pip install chromadb

Ahora el código documentado por mí

import requests
from langchain.document_loaders import PyPDFLoader
from langchain.text_splitter import RecursiveCharacterTextSplitter
from langchain.embeddings import HuggingFaceInstructEmbeddings
from langchain.vectorstores import Chroma


def download_pdf_file():
    url = 'https://www.cs.virginia.edu/~evans/greatworks/diffie.pdf'
    response = requests.get(url)

    with open('public_key_cryptography.pdf', 'wb') as f:
        f.write(response.content)
    print("documento descargado")


def load_pdf_file():
    loader = PyPDFLoader("./public_key_cryptography.pdf")
    data = loader.load()
    print("documento cargado")
    return data


def generate_document(data, chunk_size, overlap, function):
    text_splitter = RecursiveCharacterTextSplitter(
        chunk_size=chunk_size,
        chunk_overlap=overlap,
        length_function=function,
    )
    documents = text_splitter.split_documents(data)
    print(documents[0].page_content)
    return documents


def instantiate_embedding_model(model, device):
    # A junio de 2023 no hay modelos Instruct para español
    embedding_instruct = HuggingFaceInstructEmbeddings(
        model_name=model,
        model_kwargs={"device": device}
    )
    print("Tipo de Embedding:")
    print(type(embedding_instruct))
    return embedding_instruct


def generate_vectorstore(documents, embedding_instruct, vectorstore_name):
    vectorstore_chroma = Chroma.from_documents(
        documents=documents,
        embedding=embedding_instruct,
        persist_directory=vectorstore_name
    )
    print("Vector Store generado")
    return vectorstore_chroma


def save_vectorstore(vectorstore):
    vectorstore.persist()
    print("Vector store almacenado con éxito")


def load_vectorstore(vectorstore_name, embedding_instruct):
    vectorstore_chroma = Chroma(
        persist_directory=vectorstore_name,
        embedding_function=embedding_instruct
    )
    print("Vector Store cargado")
    return vectorstore_chroma


if __name__ == '__main__':
    # Primer paso: Descargar el documento PDF que queremos analizar
    download_pdf_file()
    # Ahora lo cargamos con un Loader que se adapte al tipo de archivo
    data = load_pdf_file()
    # Generamos un Document con una partición de 500 carácteres y un overlap del 10%
    documents = generate_document(data, chunk_size=500, overlap=50, function=len)
    # Si es la primera vez que se instancia el modelo entonces este se va a descargar y se va a cargar en el device CUDA
    embedding_model = instantiate_embedding_model(model="hkunlp/instructor-large", device="cuda")
    # Ya teniendo el modelo de embedding entonces podemos generar el Vector Store, le asignamos el siguiente nombre:
    vectorstore_name = "instruct-embeddings-public-crypto"
    # Y lo vamos a generar con la información de `Documents` utilizando el modelo `embedding_model` y nombre 
    # `vectorstore_name`
    vectorstore = generate_vectorstore(documents, embedding_model, vectorstore_name)
    # Guardamos el modelo en disco
    save_vectorstore(vectorstore)
    # Cargamos el modelo para trabajar con él
    vectorstore_loaded = load_vectorstore(vectorstore_name, embedding_model)
    # Vamos a hacer una petición que dada la siguiente pregunta obtenga 5 Chunks con información similar
    query = "What is public key cryptography?"
    docs = vectorstore_loaded.similarity_search_with_score(query, k=5)
    # Veamos cuantos documentos generó y un ejemplo del mismo
    print(len(docs))
    print(docs[3])

Sebastián Franco

student•

Si alguien quiere leer de manera más potable las respuestas del vectorstore, pueden usar este script al final para ver las respuestas, el contenido y el score:

contents  = ([x[0].page_content for x in docs])
score = [x[1] for x in docs]
for count, i in enumerate(contents):
  print(f"answer {count+1}:")
  print(i)
  print(f"score: {score[count]}\n")

Verán algo así

answer 1:
public key and substitute one for a public key they have 
manufactured themselves and whose corresponding secret 
key is therefore known to them. This will enable them to 
decrypt any message that Alice sends to Bob. If such a mis- 
DIFFIE: TEN YEARS OF PUBLIC-KEY CRYPTOGRAPHY 567
score: 0.2250361144542694

Andres Felipe Mendoza Tellez

student•

Listo, reto realizado. Utilicé el modelo:

embeddings_st = SentenceTransformerEmbeddings(
    model_name = "sentence-transformers/paraphrase-multilingual-MiniLM-L12-v2"
)

Con un archivo de texto convertido desde un PDF de 100 hojas, el problema que encuentro es que al hacer la pregunta no es nada acertado con ese modelo utilizado, pero creo que se puede mejorar ya que ya lo había probado con el de Open AI y va de maravilla.

Si alguien tiene una duda de como lo hice pueden escrbirme.

Sebastián Franco

student•

Es probable que no hayas modificado el tamaño máximo en el TextSplitter, por eso las respuestas no tienen sentido (este modelo soporta 128 tokens máximo y la configuración nuestra es de 500).

Manuel Castelnovo

student•

primer comentario

Evert Escalante

student•

A dia de hoy, con versiones de langchain >= 1.0 este seria la implementacion funcional.

Se deben instalar las librerias langchain-chroma langchain-hugginface sentence-transformers

Crear el vector Store y aniadirle los documentos a indexar

from langchain_chroma import Chroma

name_index_chroma = 'instruct-embeddings-data'

## Las nueva version de chroma por defecto hace persistente un vector store usando el attributo "persist_directory"
vector_store = Chroma(
  collection_name=name_index_chroma,
  embedding_function=embbedings_hf,
  persist_directory="./vector_store_chroma_db"

)

# aniadimos los documentos recortados con len = 512 usando recursive text splitter
vector_store.add_documents(splitted_documents)

Recargar el vector store con los documentos incluidos

embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")

# 2. Reload the store by passing the existing directory
vector_store_2 = Chroma(
    collection_name=name_index_chroma,
    embedding_function=embeddings,
    persist_directory="./vector_store_chroma_db"
)

Una vez recargado el vector_store podemos usarlo para hacer queries.

results = vector_store_2.similarity_search_with_score("What is public key criptography")

Documentacion de langchain-chroma:

Valentina Arenas Lozano

student•

Que locura que haya un embedding hasta para wikipedia

Duilio Sotelo

student•

Si quieren usar una base de datos diferente a chromadb y que se pueda hostear de manera sencilla en la nube recomiendo mucho Qdrant, tiene un servicio gratuito para 4gb de disco, y lo mejor es que cuenta con soporte para langchain, aquí adjunto la documentación:

Willian Diaz Pabón

student•

Cómo sería le proceso para vectorizar una imagen con langchain + chromadb?

Willian Diaz Pabón

student•

Sería bueno mejorar el proceso de respuestas a las dudas de los estudiantes, porque no ayuda mucho que preguntemos y pasen meses y ninguna respuesta. :-(

Creación y Gestión de Bases de Datos Vectoriales con Chroma

Introducción a LangChain

Creación de un sistema de preguntas y respuestas con LangChain

Estructura y Uso de Langchain en Python

Carga de Modelos Open Source con Langchain y Hugging Face

Uso de Modelos OpenAI con LangChain: Guía Práctica para Principiantes

Creación de Prompts Dinámicos con LangChain

Uso de Cadenas en Modelos de Lenguaje con Language Chain

Procesamiento de PDFs y creación de resúmenes con LangChain

Creación de Cadenas de Preguntas y Respuestas con Modelos de Lenguaje

Creación de cadenas secuenciales en Python para procesamiento de texto

Casos de uso de LangChain

Aplicaciones y Beneficios de Lancheng en el Manejo de LLMs

Implementación de Lanchain y LLMs: Costos, Privacidad y Buenas Prácticas

Manejo de documentos con índices

Carga de Documentos en Langchain para Creación de Índices

Fundamentos de la Clase Document en Langchain

Carga y Transformación de Documentos No Estructurados con Landship

Lectura de CSV y conversión a DataFrame de Pandas y LangChain

Creación de un Cargador de JSON-Lines Personalizado en Python

Fragmentación de Documentos con TextSplitter en Langsteam

Creación de un Chatbot con Documentación de Hugging Face

Creación de Índice Vectorial con Langchain y Embeddings

Embeddings y bases de datos vectoriales

Creación de Índices con Embeddings y Bases de Datos Vectoriales

Creación y uso de embeddings con OpenAI y Lanchain

Modelos de Embeddings Open Source en Español con Sentence Transformers

Creación y Gestión de Bases de Datos Vectoriales con Chroma

Creación y manejo de bases de datos vectoriales con OpenAI Embeddings

Creación y Uso de un Retriever en Chroma para Consultas Avanzadas

Modelo de Chat para Preguntas y Respuestas con LangChain y Chroma

Creación de un Chatbot para Preguntas con Bases de Datos Vectoriales

Chats y memoria con LangChain

Memoria de Corto Plazo en Chatbots: Implementación y Optimización

Creación y Uso de Modelos de Chat con OpenAI y LangChain

Creación de Plantillas Dinámicas para Prompts de Chat en Langstead

Memoria en chatbots: Implementación con ConversationBufferMemory

Configuración de ConversationBufferWindowMemory en Chatbots

Memoria de Resumen de Conversaciones con Chat GPT-3.5

Gestión de Memoria en Chatbots con ConversationSummaryBufferMemory

Memoria de Entidades en Chatbots para Soporte de Ventas

Implementación de Chatbot con Memoria en Python usando Langchain

Evolución del uso de LLM

Creación de Chatbots con Modelos de Lenguaje y Bases de Datos Vectoriales