Transmisión vectorial: indexación capaz en el uso de la memoria con Rust

Entrada

Se está introduciendo la transmisión vectorial en EmbedAnything, una función diseñada para optimizar la incrustación de documentos a gran escalera. Al habilitar la fragmentación y la incrustación asincrónicas mediante la concurrencia de Rust, se reduce el uso de memoria y se acelera el proceso. Hoy, mostraré cómo integrarlo con la saco de datos vectorial de Weaviate para conquistar una búsqueda e incrustación de imágenes sin inconvenientes.

En mi artículo aludido, Potencie su flujo de integraciones con EmbedAnythingAnalicé la idea detrás de EmbedAnything y cómo facilita la creación de incrustaciones desde múltiples modalidades. En este artículo, quiero presentar una nueva característica de EmbedAnything indicación transmisión vectorial y ver cómo funciona con la saco de datos vectorial de Weaviate.

Descripción caudillo

• La transmisión vectorial en EmbedAnything optimiza la incrustación de documentos a gran escalera mediante fragmentación asincrónica con la simultaneidad de Rust.
• Resuelve problemas de memoria y eficiencia en los métodos de integración tradicionales al procesar fragmentos en paralelo.
• La integración con Weaviate permite una integración y búsqueda perfectas en una saco de datos vectorial.
• La implementación de la transmisión vectorial implica crear un adaptador de saco de datos, iniciar un maniquí de incorporación e incorporar datos.
• Este enfoque ofrece una posibilidad más capaz, escalable y flexible para la incrustación de documentos a gran escalera.

¿Cuál es el problema?

En primer división, examinemos el problema presente con la creación de incrustaciones, especialmente en documentos de gran tamaño. marcos de incrustación funcionan en un proceso de dos pasos: fragmentación e incrustación. Primero, se extrae el texto de todos los archivos y se crean fragmentos/nodos. Luego, estos fragmentos se introducen en un maniquí de incrustación con un tamaño de trozo específico para procesar las incrustaciones. Mientras esto se hace, los fragmentos y las incrustaciones permanecen en la memoria del sistema.

Esto no es un problema cuando los archivos y las dimensiones de incrustación son pequeños. Pero se convierte en un problema cuando hay muchos archivos y se trabaja con modelos grandes y, lo que es peor, incrustaciones multivectoriales. Por lo tanto, para trabajar con esto, se requiere una gran cantidad de RAM para procesar las incrustaciones. Por otra parte, si esto se hace de forma sincrónica, se pierde mucho tiempo mientras se crean los fragmentos, ya que la fragmentación no es una operación que requiera muchos cálculos. A medida que se crean los fragmentos, pasarlos al maniquí de incrustación sería capaz.

Nuestra posibilidad al problema

La posibilidad es crear una tarea de fragmentación e incrustación asincrónica. Podemos suscitar subprocesos de forma efectiva para manejar esta tarea utilizando los patrones de concurrencia y la seguridad de subprocesos de Rust. Esto se hace utilizando El óxido Módulo MPSC (Multi-producer Single Consumer), que pasa mensajes entre subprocesos. De esta forma, se crea un flujo de fragmentos que se pasan al subproceso de incrustación con un búfer. Una vez que el búfer está completo, incrusta los fragmentos y envía las incrustaciones de envés al subproceso principal, que luego las envía a la saco de datos de vectores. Esto garantiza que no se pierda tiempo en una sola operación y que no haya cuellos de botella. Por otra parte, el sistema almacena solo los fragmentos y las incrustaciones en el búfer, borrándolos de la memoria una vez que se mueven a la saco de datos de vectores.

Ejemplo de caso de uso con EmbedAnything

Ahora, veamos esta función en bono:

Con EmbedAnything, se transmiten los vectores desde un directorio de archivos a la saco de datos de vectores Es un proceso simple de tres pasos.

1. Cree un adaptador para su saco de datos vectorial: Se alcahuetería de un contenedor de las funciones de la saco de datos que permite crear un índice, convertir metadatos del formato de EmbedAnything al formato requerido por la saco de datos y la función para insertar las incrustaciones en el índice. Los adaptadores para las bases de datos destacadas ya se han creado y están presentes. aquí.

2. Inicie un maniquí de integración de su votación: Puede nominar entre diferentes modelos locales o incluso modelos en la nubarrón. La configuración además se puede determinar estableciendo el tamaño del fragmento y el tamaño del búfer para la cantidad de incrustaciones que se deben transmitir a la vez. Lo ideal es que este valencia sea el veterano posible, pero la RAM del sistema lo limita.

3. Tildar a la función de incrustación desde EmbedAnything: Simplemente pase la ruta del directorio a taracear, el maniquí de incrustación, el adaptador y la configuración.

En este ejemplo, incorporaremos un directorio de imágenes y lo enviaremos a la bases de datos vectoriales.

Paso 1: Crear el adaptador

En EmbedAnything, los adaptadores se crean en el extranjero para no hacer que la biblioteca sea demasiado pesada y usted puede nominar con qué saco de datos desea trabajar. Aquí hay un adaptador simple para Weaviate:

from embed_anything import EmbedData

from embed_anything.vectordb import Adapter

class WeaviateAdapter(Adapter):

    def __init__(self, api_key, url):

        super().__init__(api_key)

        self.client = weaviate.connect_to_weaviate_cloud(

            cluster_url=url, auth_credentials=wvc.init.Auth.api_key(api_key)

        )

        if self.client.is_ready():

            print("Weaviate is ready")

    def create_index(self, index_name: str):

        self.index_name = index_name

        self.collection = self.client.collections.create(

            index_name, vectorizer_config=wvc.config.Configure.Vectorizer.none()

        )

        return self.collection

    def convert(self, embeddings: List(EmbedData)):

        data = ()

        for embedding in embeddings:

            property = embedding.metadata

            property("text") = embedding.text

            data.append(

                wvc.data.DataObject(properties=property, vector=embedding.embedding)

            )

        return data

    def upsert(self, embeddings):

        data = self.convert(embeddings)

        self.client.collections.get(self.index_name).data.insert_many(data)

    def delete_index(self, index_name: str):

        self.client.collections.delete(index_name)

### Start the client and index

URL = "your-weaviate-url"

API_KEY = "your-weaviate-api-key"

weaviate_adapter = WeaviateAdapter(API_KEY, URL)

index_name = "Test_index"

if index_name in weaviate_adapter.client.collections.list_all():

    weaviate_adapter.delete_index(index_name)

weaviate_adapter.create_index("Test_index")

Paso 2: Crear el maniquí de incrustación

Aquí, como estamos incrustando imágenes, podemos usar el maniquí de clip.

import embed_anything import WhichModel

model = embed_anything.EmbeddingModel.from_pretrained_cloud(

        embed_anything.WhichModel.Clip,     

        model_id="openai/clip-vit-base-patch16")

Paso 3: Taracear el directorio

data = embed_anything.embed_image_directory(

    "image_directory",

    embeder=model,

    adapter=weaviate_adapter,

    config=embed_anything.ImageEmbedConfig(buffer_size=100),

)

Paso 4: Consultar la saco de datos de vectores

query_vector = embed_anything.embed_query(("image of a cat"), embeder=model)(0).embedding

Paso 5: Consultar la saco de datos de vectores

response = weaviate_adapter.collection.query.near_vector(

    near_vector=query_vector,

    limit=2,

    return_metadata=wvc.query.MetadataQuery(certainty=True),

)

Check the response;

Producción

Utilizando el maniquí Clip, vectorizamos todo el directorio con imágenes de gatos, perros y monos. Con la simple consulta “imágenes de gatos”, pudimos inquirir imágenes de gatos en todos los archivos.

Consulte el cuaderno para obtener el código aquí colaboración.

Conclusión

Creo que la transmisión vectorial es una de las características que permitirá a muchos ingenieros optar por una posibilidad más optimizada y sin deudas tecnológicas. En división de utilizar marcos voluminosos en la nubarrón, puede utilizar una opción de transmisión liviana.

Consulte el repositorio de GitHub aquí: Repositorio EmbedAnything.

Preguntas frecuentes