Hola, mi nombre es Alice y tengo aproximadamente dos décadas de experiencia en ABAP/SAP y una pasión de toda la vida por la programación.

Quería compartir con ustedes mi reciente proyecto/biblioteca de PoC.
Es una base de datos vectorial simple pero rápida implementada completamente en ABAP (y una tabla, cualquier base de datos).
Resultó que a) es posible yb) es “suficientemente bueno” para reemplazar soluciones externas en escenarios específicos.

Déjame mostrarte =)

TL;DR:

GitHub:oisee/zvdb: Biblioteca de búsqueda de vectores ABAP (github.com)

¿Qué problema estamos tratando de resolver?

Entonces, ¿qué problema estamos tratando de resolver?
La biblioteca sirve como una alternativa interna sencilla a las bases de datos vectoriales de terceros. Esto es particularmente útil si necesita capacidades de búsqueda semántica directamente en el servidor de aplicaciones ABAP.
Esta herramienta puede mejorar sus aplicaciones RAG (Generación Aumentada de Recuperación), junto con otras heurísticas.

(Descargo de responsabilidad: este proyecto se completó antes de la reciente conferencia de desarrolladores de OpenAI, lo que significa que es anterior a la introducción de «API asistente» y «GPT». Si bien la última API de OpenAI ahora admite RAG basado en conocimiento sin VDB externos, esta solución aún puede ser relevante , especialmente para implementaciones RAG que utilizan la API Azure OpenAI).

(Más información sobre RAG: texto video)

RAG es la técnica que impulsa el escenario de “chatear con sus documentos”:

• Cortar documentos en trozos
• Generar incrustación de vectores para estos fragmentos
• Cuando responda la pregunta, busque fragmentos semánticamente relevantes en la base de datos,
• Inyecte fragmentos semánticamente relevantes en el mensaje, algo como:

Considering only the information below:
###
{chunk01}
{chunk02}
{chunk03}
###
please provide a response to the following request:
{query from user}

Validación: “SUFICIENTEMENTE BUENO»

La practicidad de la Biblioteca de búsqueda de vectores ABAP se validará en función de los siguientes criterios:

• Hora de consulta local menos Llamada a VDB externo – excelente
• Hora de consulta local menos ~10% del tiempo de respuesta del LLM – OK
• Criterios basados ​​en el volumen: debe manejar al menos ~10 libros
  • => 10 * 300 páginas = 3000 incrustaciones

Tiempo de consulta local: el tiempo necesario para realizar una consulta local utilizando la biblioteca debe ser significativamente menor que cuando se llama a una base de datos vectorial externa de terceros, generalmente alojada en plataformas como Azure. Esto garantiza que la biblioteca ofrezca una alternativa práctica al uso de servicios externos.

Pero la parte más lenta de RAG es la respuesta del propio LLM, por lo que si la consulta tomará aproximadamente el 10 % del tiempo de respuesta del LLM, todavía está bien.

Criterios basados ​​en el volumen: la biblioteca debería poder manejar un volumen sustancial de vectores en la base de datos. Como punto de referencia, un umbral mínimo de practicidad podría ser la capacidad de consultar de manera eficiente un conjunto de datos equivalente a varios libros, siendo el tamaño promedio de un libro de aproximadamente 300 páginas. Si la biblioteca puede consultar de manera eficiente más que este volumen (por ejemplo, 3000 vectores o más), puede considerarse «suficientemente buena» para un uso práctico.

Estos criterios garantizan que la biblioteca sea eficiente en términos de tiempo de consulta y pueda manejar conjuntos de datos razonablemente grandes, lo que la convierte en una herramienta valiosa para diversas aplicaciones.

Comprender los datos

Empecemos con los datos:

Nuestros vectores de incrustación tienen 1536 dimensiones, y van de -1 a 1. Tenga en cuenta que es posible que estos vectores no siempre sean vectores unitarios.

Incrustación de 1536 dimensiones por el modelo. ada-002:

• [-7.912499859230593e-05, -0.022456586360931396, 0.018665215000510216, -0.02411365509033203, 0.0009089018567465246, 0.031524062156677246, -0.027944795787334442, 0.008245570585131645, -0.006893403362482786, -0.018983371555805206, 0.009723675437271595, 0.01825426146388054 … ]

La medida de similitud entre dos vectores – Similitud del coseno

Y se puede calcular como producto escalar (o producto escalar):

[a1,a2,a3,a4] • [b1,b2,b3,b4] = a1*b1 + a2*b2 + a3*b3 + a4*b4

es decir, la comparación de dos vectores 1536d requiere:

• 1536 multiplicaciones
• 1536 adiciones

=> 3072 operaciones para una comparación.

Punto de partida: búsqueda por fuerza bruta

La forma más sencilla de encontrar algo es una búsqueda de fuerza bruta: el vector de consulta debe compararse con todos los vectores en la base de datos. Resultado de cada comparación: la similitud del coseno se puede interpretar como «rango». El resultado debe ordenarse y luego los k vecinos más cercanos serán el resultado de la consulta.

Caminos hacia la optimización

• A – Cálculos más rápidos
• B – Menos cálculos

Ruta A – Cuantización:

• Cuantizar -1…+1 en 8 bits (bien)
• Cuantizar -1…+1 en 4 bits (grueso)
• Cuantizar -1…+1 en 1 bit (extremo)

cuantización, aritmética de punto fijo

Incrustación de 1536 dimensiones por ada-002:

Cuantizado:

• 8b: [-1, -3, 4, -4, 2, 6, -4, 3, -1, -3, 3, 4, 2, 2, -3, 2, 4, 3, 2, 3, -1, 5, 4, 4, -2, 4, 3, …] -127…+127
• 3b: [-1, -1, 2, -1, 2, 2, -1, 2, -1, -1, 2, 2, 2, 2, -1, 2, 2, 2, 2, 2, -1, 2, 2, 2, -1, 2, 2, …] -3…-3
• 1b: [-1, -1, 1, -1, 1, 1, -1, 1, -1, -1, 1, 1, 1, 1, -1, 1, 1, 1, 1, 1, -1, 1, 1, 1, -1, 1, 1, …] -1..+1

1b: el signo es suficiente:

• 0 – es positivo
• 1 – negativo

Ruta A: operaciones bit a bit

La multiplicación bit a bit es XOR: con 0 y 1 como +1 y -1:

• 0 xor 0 = 0 (+1 * +1 = +1 )
• 1 xor 1 = 0 (-1 * -1 = -1 )
• 0 xor 1 = 1 (1 * -1 = -1 )
• 1 xor 0 = 1 (-1 * 1 = -1 )

La suma es solo una operación de conteo de bits (+1 si 0 y -1 si 1):

01010 xor 10101 = 11111, conteo de bits: -5

(distancia máxima – los vectores no tienen nada en común)

11100 xor 11100 = 00000, conteo de bits: +5

(distancia mínima – vectores idénticos)

¡10111 xor 11111 = 01000, conteo de bits: +4 – 1 = 3

(algo de distancia – casi idéntico – un poco de diferencia)

Validación: 1b vs 8b vs fp

Hagamos la búsqueda de BF:

Calcular DP para:

Ordene la clasificación resultante y compare el orden de los resultados.

El orden para el rango 1536 (igual) a 512 (aún no perpendicular, pero lo suficientemente lejos como para dejar de preocuparse) es estable.

Ruta B – SELECCIÓN ESTRECHA

visualización de grupos de vectores en el espacio 3d

¿Qué pasa si podemos marcar vectores similares que estén cerca? ¡Hay una función para eso! =)

Función HASH espacial: Es probable que vectores similares terminen con el mismo hash o uno similar. (es decir, más cerca en el espacio de dimensiones inferiores)

1536d es excepcionalmente alto:

Si 64d (problema del trigo y el tablero de ajedrez) es solo 8×8 «imagen».

Entonces 1536d es un 48×32 «imagen».

Método de hiperplanos aleatorios

Podemos dividir el hiperespacio en dos partes con un vector aleatorio:

Si está “abajo” – 1 si está “arriba” 0

Tantos vectores – tantos dígitos en el hash.

8 vectores nos darán un hash de 8 bits (1 byte) que podemos usar como índice, que será «suficientemente bueno» para aproximadamente 256*256 = 65536 vectores en la base de datos.

Para ampliar la selección, podemos buscar no solo coincidencias exactas sino también vecinos con una distancia de Hamming 1 o 2.

Manejo de la distribución no uniforme

¿Pero qué pasa si nuestros vectores no están distribuidos uniformemente? Entonces, el método del hiperplano aleatorio podría ser irrelevante: se podrían agrupar vectores similares.

En este caso, podemos utilizar vectores del conjunto de datos como hiperplanos:

• Vector aleatorio de recogida
• Encuentra el más cercano
• Más lejos
• Punto medio
• El punto medio es un vector perpendicular muy probable, lo suficientemente bueno como para ser el siguiente eje del índice (función hash)

¿Algún otro método para acelerar la búsqueda?

Clasificación rápida Podemos usar productos punto entre HASH de dos vectores para hacer que la clasificación sea más rápida con «fuerza rápida» en lugar de «fuerza bruta».

Estadísticas

Algunas estadísticas:

Optimización: inicialmente, era ~3000μs para una comparación no cuantificada de punto flotante; utilizando la cuantificación 1b y la operación bit a bit, se optimizó hasta ~20 μs, por lo que podemos realizar fácilmente el producto escalar (es decir, realizar una búsqueda de fuerza bruta) para ~50000 vectores por segundo.

Para RAG con una ventana de contexto de 32k, es más que suficiente ^_^

Código fuente: $ZVDB.

GitHub:oisee/zvdb: Biblioteca de búsqueda de vectores ABAP (github.com)

Sobre el Autor:

Alice Vinogradova es una profesional experimentada en ABAP/SAP con una amplia experiencia en programación, que abarca desde el ensamblaje Z80 hasta técnicas modernas de procesamiento de datos. Su pasión radica en explorar y optimizar sistemas complejos, uniendo la informática tradicional con avances tecnológicos innovadores.