Colaboraciones

Cuando la memoria de un agente se comprime en códigos dispersos, ¿coinciden dos IA en la misma respuesta errónea?

con Mohan Bheemadolu · desarrollador de agentes de IA · coautor de FlyHash for LLM agent memory

Ilustración: una mosca de la fruta sobre un archivo de recuerdos comprimidos en códigos dispersos con pocos bits encendidos; dos lámparas, turquesa y violeta, iluminan la misma tarjeta de código a la que le falta un trozo y apuntan al mismo cajón.

En medio minuto

Mohan Bheemadolu construye memoria para agentes de IA. Con la Dra. Chrisogonas O. Odhiambo escribió FlyHash, que guarda cada recuerdo como un código disperso, un vector largo con solo unos pocos "bits activos" encendidos, como la nariz de una mosca de la fruta distingue los olores. Con el mismo número de bits activos (32), en el benchmark sintético de los autores, ordena los recuerdos correctos unas 2.5 veces mejor que el método habitual (mAP 0.27 frente a 0.11). Con el mismo almacenamiento, el método habitual con unas cuatro veces más bits lo iguala o lo supera, y la ventaja es menor en conversaciones reales.

Nuestra pregunta: la respuesta de una IA suele ser verificada por una segunda IA, pero las dos leen la misma memoria. Si esa memoria no contiene el dato, ¿empiezan las dos a coincidir en la misma respuesta errónea?

En nuestra primera ejecución, con una memoria simple por palabras clave, parecía que sí: cuando la memoria no tenía el dato, el 45% de las respuestas en las que ambas IA coincidían eran erróneas, frente al 3% cuando lo tenía. Ahora Mohan ejecuta FlyHash con cuatro tamaños de código, y comprobaremos si los códigos con menos bits activos empeoran esto.

Ver en YouTube

El artículo

Un agente que recuerda conversaciones pasadas tiene que guardarlas en algún sitio y encontrar rápido el fragmento adecuado. FlyHash toma prestado el olfato de la mosca de la fruta. Guarda cada recuerdo como un código disperso: un vector largo en el que solo unos pocos "bits activos" están encendidos. El código completo sigue siendo largo (2,000 unidades), así que no ocupa menos almacenamiento que un código SimHash con el mismo número de bits activos.

El artículo es refrescantemente claro. Comparado con SimHash, la forma habitual de hacer tales códigos, con el mismo número de bits activos (32), en el benchmark sintético etiquetado de los autores, la precisión media (mAP) es 0.27 para FlyHash frente a 0.11 para SimHash. No es una comparación de almacenamiento. Un código FlyHash es disperso pero largo (2,000 unidades), así que ocupa más almacenamiento que un código SimHash con los mismos bits activos. Con el mismo almacenamiento, SimHash con unas cuatro veces más bits iguala o supera a FlyHash. En conversaciones reales de LoCoMo la ventaja con los mismos bits activos es menor (recall@10 con 32 bits activos: aproximadamente 0.32 frente a 0.17). Y dice sin rodeos dónde pierde FlyHash: cuando la memoria no está ajustada, un índice HNSW estándar, el tipo de búsqueda ordinaria de tamaño completo, sigue superando a ambos.

La recuperación densa exacta sobre los embeddings sin hashear sigue por delante de todos los códigos hasheados en estas pruebas. Con 128 bits activos, FlyHash queda entre 0.04 y 0.05 por debajo del recall@10 denso. SimHash con 1,024 bits conserva cerca del 97 % del recall denso en recall@50. El hashing da códigos compactos, no mejor calidad.

El código es abierto: github.com/mohanji/flyhash-agent-memory.

Ilustración: filas de recuerdos pasan por una prensa con forma de reloj de arena y salen como tiras dispersas con pocos bits encendidos; dos lámparas leen de los cajones de abajo.
Entran muchos recuerdos, salen códigos dispersos: la idea de FlyHash.

Cómo fue la conversación

Empezó en los comentarios bajo el artículo en Hugging Face. Preguntamos cómo se las arreglan los códigos cuando la pregunta se formula con otras palabras y no con una plantilla fija. Mohan dijo que las pruebas hasta ahora usaban plantillas y preguntó qué conjunto de datos le sugeríamos.

Le propusimos dos construidos a partir de conversaciones largas y reales, de muchas sesiones: LoCoMo y LongMemEval. Decidió empezar con LoCoMo y hacer LongMemEval después.

Luego preguntamos lo que más queríamos saber sobre sus códigos: ¿perderán más los códigos con menos bits activos en preguntas sobre el tiempo ("¿cuándo se mudó ella?") que en datos aislados?

Respuesta de la primera medición: en LoCoMo (embeddings MiniLM, centrados en la media, recall@10), con 128 bits activos FlyHash conserva cerca de 0.88 del recall denso exacto en preguntas multi-hop, 0.90 en temporales, 0.89 en dominio abierto y 0.91 en single-hop. Las diferencias respecto a single-hop son pequeñas (multi-hop −0.03, temporal −0.01), y sus intervalos bootstrap del 95 % incluyen el cero con 16, 32, 64 y 128 bits activos. Por tanto, no hay evidencia de que las preguntas temporales pierdan más con el hashing que las single-hop. Multi-hop tiene el recall absoluto más bajo con todos los métodos, el denso incluido, lo que apunta a la dificultad de la tarea, no al hashing.

Por qué importa la memoria para dos IA que se verifican entre sí

Cuando dos modelos de empresas distintas coinciden, la gente suele tomarlo como buena señal. Pero en un agente, los dos modelos suelen leer la misma memoria. Si esa memoria no tenía el dato, ya no son independientes. Pueden coincidir, con total seguridad, en la misma respuesta errónea.

Para ver con qué frecuencia ocurre, armamos una pequeña comprobación abierta sobre LoCoMo, memory-agreement-check, y la ejecutamos una vez con memoria simple por palabras clave (BM25, búsqueda corriente por palabras clave, con las 10 líneas de diálogo principales). GPT y Claude respondieron por separado, y Kimi los calificó a ciegas.

2 de 63respuestas coincidentes eran erróneas cuando la memoria contenía toda la evidencia (3%)
15 de 33respuestas coincidentes eran erróneas cuando la memoria no contenía parte de la evidencia (45%)
40% vs 20%los dos modelos fallan en la misma pregunta, frente al 20% si sus errores no tuvieran relación

Los errores de los dos modelos casi siempre venían juntos (una correlación de φ = 0.81). Es un solo tipo de memoria y una sola semilla aleatoria, así que muestra un vínculo, no una causa. Pero le da a FlyHash una pregunta afilada que responder.

El experimento que hacemos juntos

Mohan se ofreció a aportar la parte de recuperación; desde ahí seguimos nosotros.

Parte de Mohan LoCoMo diálogos largos FlyHash y SimHash 16 · 32 · 64 · 128 bits top-k recuerdos k = 10 y k = 5, como JSONL Nuestra parte GPT Claude responden por separado, misma memoria juez ciego de una tercera empresa La respuesta coinciden y fallan, por tamaño de código un salto varios saltos temporal
FlyHash, de Mohan, construye la memoria; la misma comprobación de la primera ejecución mide con qué frecuencia dos IA coinciden en una respuesta errónea a causa de ella.
  1. Mohan mide primero con qué frecuencia el recuerdo correcto queda entre los primeros resultados (recall@k). Lo separa por tipo de pregunta de LoCoMo: datos aislados (un salto), datos que hay que enlazar (varios saltos) y preguntas sobre el tiempo (temporal). Ejecuta FlyHash y SimHash con 16, 32, 64 y 128 bits activos, con los 10 recuerdos principales por pregunta, igual que en la primera ejecución.
  2. Sugerimos añadir también los 5 principales: menos recuerdos significan más fallos, lo que debería mostrar con qué rapidez crece la proporción de respuestas coincidentes y erróneas dadas con seguridad.
  3. Él envía los contextos recuperados como JSONL, una línea por pregunta.
  4. Nosotros ejecutamos la comprobación de coincidencia sobre cada archivo y le enviamos los resultados.

La pregunta que responderemos al final: con menos bits activos, ¿coinciden las dos IA más a menudo en respuestas erróneas, y crece más rápido en las preguntas sobre el tiempo?

Si es que sí, un código más comprimido tiene un coste oculto que una segunda IA no detectará. Si no, FlyHash queda incluso mejor de lo que dice el artículo.

El código

La comprobación acepta la salida de cualquier recuperador. Una línea por pregunta:

{"qid": "conv-26/0", "memories": [{"text": "[D1:3 | 1:56 pm on 8 May, 2023] Caroline: I went to a LGBTQ support group yesterday...", "dia_id": "D1:3", "score": 0.82}]}

El repositorio ya trae un ejemplo que construye estos contextos con las clases FlyHash y SimHash del código de Mohan:

git clone https://github.com/mohanji/flyhash-agent-memory
pip install numpy sentence-transformers
python examples/flyhash_contexts.py --flyhash-src flyhash-agent-memory/src \
  --method flyhash --active-bits 32 --out flyhash-k32.jsonl
python -m memcheck run --backend cli --contexts flyhash-k32.jsonl --memory-name flyhash-k32

Ejecutar las mismas preguntas con varios tamaños de código, o con --method dense como referencia, da la comparación.

Lo que las primeras cifras pueden y no pueden decir

  • Provienen de un solo recuperador (BM25), una pareja de modelos, un juez y una semilla, sobre 200 preguntas. Otros recuperadores y modelos pueden mover cada número.
  • Las preguntas que BM25 no encuentra no se parecen a las demás: las de varios saltos y las de dominio abierto fallan mucho más a menudo. Por eso comparamos también dentro de cada tipo.
  • Para probar una causa, habría que responder las mismas preguntas una vez con la evidencia y otra sin ella. FlyHash con varios tamaños de código es un paso natural hacia eso: mismas preguntas, mismos modelos, solo cambia la memoria.
  • Las cifras de FlyHash miden la recuperación, es decir, si se encuentran los turnos con la evidencia anotada. No miden si un modelo de lenguaje responde después correctamente, que es lo que estudia la verificación de coincidencia.

Cronología

  1. FlyHash se publica en arXiv (2611.05791) por Mohan Bheemadolu y Chrisogonas O. Odhiambo.
  2. El artículo aparece en Hugging Face Papers. En los comentarios preguntamos por las preguntas parafraseadas; Mohan pregunta qué conjunto de datos usar; sugerimos LoCoMo y LongMemEval, y él elige LoCoMo primero.
  3. Preguntamos si los códigos con menos bits activos pierden más en preguntas sobre el tiempo. La comprobación abierta se ejecuta por primera vez sobre 200 preguntas de LoCoMo, con un ejemplo para FlyHash, y enviamos las cifras a Mohan.
  4. Mohan expone el plan: recall de recuperación por categoría con 16, 32, 64 y 128 bits con k = 10, contextos como JSONL. Estamos de acuerdo y añadimos k = 5.

← Todas las colaboraciones · Proponer una colaboración