Busque “cómo recuperar mi dinero” y un buen sistema debería encontrar una página titulada “Política de reembolso”, aunque los dos no comparten palabras importantes. Esa capacidad proviene de las incrustaciones, una de las ideas más útiles de la IA moderna.

Esta guía explica las incrustaciones sin grandes cálculos matemáticos. Ejecutamos un pequeño ejemplo en Python 3.13 y su resultado se muestra a continuación. Los vectores que contiene son los que creamos a mano, con solo tres números cada uno, para que la idea sea fácil de ver. Las incrustaciones reales provienen de un modelo entrenado y, a menudo, tienen cientos o miles de números.

¿Qué es una incrustación?

Una incrustación es una representación de algo como una lista de números, llamada vector. Se entrena un modelo para que los elementos con significados relacionados obtengan vectores que estén muy juntos.

"kitten"  -> [0.9, 0.8, 0.1]
"cat"     -> [0.9, 0.7, 0.2]
"invoice" -> [0.0, 0.1, 0.9]

Una vez que el texto tiene esta forma, una computadora puede calcular qué tan similares son dos fragmentos de texto, lo que no puede hacer directamente con palabras. Las incrustaciones tampoco se limitan a palabras. Se pueden incrustar frases, documentos completos, imágenes, audio y productos.

¿Por qué no simplemente hacer coincidir palabras clave?

Nuestra guía de RAG muestra esto en la práctica. Una simple búsqueda de recuento de palabras obtuvo un resultado de cero para “¿Cuándo podré recuperar mi dinero?” contra un documento de reembolso, ya que no compartieron palabras. Tenga en cuenta también la tercera fila: los identificadores exactos son una debilidad de las incrustaciones, por lo que la búsqueda de palabras clave todavía tiene un lugar.

Piensa en un mapa

Imagine colocar cada palabra en un mapa enorme, donde la ubicación refleja el significado. “Gato” y “gatito” se sientan casi uno al lado del otro, “perro” está en el mismo vecindario y “factura” está en una ciudad diferente. Para encontrar palabras relacionadas, simplemente mira cerca.

Una incrustación real funciona de la misma manera, excepto que el mapa tiene cientos de dimensiones en lugar de dos. La gente no puede imaginarse eso, pero las matemáticas funcionan igual. Los números individuales generalmente no tienen un significado claro, como “furriness”. Lo que importa es la posición general.

Un pequeño ejemplo práctico

A continuación se explica cómo comparar nuestros vectores hechos a mano:

import math

def cosine(a, b):
    dot = sum(x * y for x, y in zip(a, b))
    return dot / (math.sqrt(sum(x * x for x in a)) *
                  math.sqrt(sum(y * y for y in b)))

vectors = {
    "kitten":  [0.9, 0.8, 0.1],
    "cat":     [0.9, 0.7, 0.2],
    "dog":     [0.8, 0.3, 0.2],
    "invoice": [0.0, 0.1, 0.9],
}

for word in ("kitten", "dog", "invoice"):
    print(word, round(cosine(vectors["cat"], vectors[word]), 3))

# kitten 0.994
# dog 0.955
# invoice 0.238

Frente a “gato”, “gatito” obtiene la puntuación más alta, “perro” le sigue y “factura” es mucho más baja. Elegimos estos vectores para producir ese patrón, por lo que la clasificación no prueba nada sobre el lenguaje real. Sólo muestra cómo se comporta el cálculo. Una búsqueda semántica hace lo mismo en tres pasos: incrustar la consulta, calificarla con cada elemento almacenado y ordenar.

query = [0.85, 0.75, 0.15]
sorted(vectors, key=lambda w: cosine(query, vectors[w]), reverse=True)

# ['kitten', 'cat', 'dog', 'invoice']

Similitud del coseno

Cada vector puede considerarse como una flecha que apunta desde el origen. La similitud del coseno mide el ángulo entre dos flechas, ignorando su longitud. Confirmamos los valores clave:

cosine([1, 2, 3], [2, 4, 6])   # 1.0   same direction
cosine([1, 0], [0, 1])         # 0.0   unrelated (at right angles)
cosine([1, 0], [-1, 0])        # -1.0  opposite directions

Mira la primera línea. [2, 4, 6] es el doble de largo que [1, 2, 3], pero la puntuación es perfecta de 1,0, porque lo único que cuenta es la dirección. Esto es útil para el texto, donde la longitud puede reflejar cosas como el tamaño del documento en lugar del significado. Tenga cuidado también con los umbrales. No existe una puntuación universal que signifique “similar”, ya que los rangos útiles difieren de un modelo a otro, así que pruebe con sus propios datos.

Otras medidas de distancia

La diferencia es fácil de ver. Esos mismos dos vectores con una puntuación de coseno de 1,0 tienen una distancia euclidiana de 3,742, ya que uno es más largo que el otro. Muchos sistemas normalizan vectores, escalando cada uno a una longitud de 1. Después de eso, el producto escalar y el coseno dan la misma respuesta, y lo confirmamos: ambos dieron 0,955 para “gato” y “perro”. Consulta la documentación de tu modelo para ver qué medida recomienda.

Cómo se aprenden las incrustaciones

Nadie asigna estos números a mano en sistemas reales. Una red neuronal los aprende durante el entrenamiento. Una idea temprana e influyente es que las palabras que aparecen en contextos similares tienden a tener significados similares, como “Le di de comer a mi gato” y “Le di de comer a mi perro”. Modelos como Word2Vec y GloVe aprendieron vectores de palabras a partir de esos patrones.

Más tarde, los modelos basados ​​en transformadores como BERT hicieron que las incorporaciones tuvieran en cuenta el contexto, por lo que “banco” podría obtener un vector diferente en “orilla del río” y “préstamo bancario”. Muchos modelos modernos incorporan frases o pasajes completos a la vez. Nuestra guía de modelos de lenguaje grandes explica cómo los transformadores manejan el contexto.

Donde se utilizan incrustaciones

Buscando a escala

Nuestro ejemplo comparó una consulta con cada elemento, lo que se conoce como búsqueda exacta. Esto funciona bien para miles de elementos, pero se vuelve lento con muchos millones. Los índices aproximados del vecino más cercano (ANN) como HNSW resuelven esto. Encuentran rápidamente coincidencias muy reñidas, renunciando a una pequeña posibilidad de perderse al mejor.

Las bases de datos y extensiones vectoriales, como pgvector para PostgreSQL, proporcionan estos índices junto con filtrado y almacenamiento. Nuestra guía de bases de datos vectoriales cubre las opciones. Para un proyecto pequeño, es posible que no necesite uno en absoluto, y una búsqueda en memoria es una buena manera de comenzar.

Elegir un modelo de incrustación

• Idioma. Si tu contenido está en hindi o tamil, por ejemplo, comprueba que el modelo lo maneja bien.
• Dominio. Los modelos generales pueden tener dificultades con términos médicos o legales especializados.
• Dimensiones. Más dimensiones pueden capturar más detalles, pero cuestan más almacenamiento y memoria.
• Costo y alojamiento. Compare una API alojada con un modelo abierto que pueda ejecutar usted mismo, especialmente para datos privados.
• Longitud de entrada. Los modelos tienen un límite, por lo que los documentos largos deben dividirse primero en partes.

La mejor prueba son tus propios datos. Recopile unas 20 consultas reales junto con los documentos que deberían encontrar y compare cómo las clasifica cada modelo. Es posible que los puntos de referencia publicados no reflejen su contenido.

Limitaciones

• Bloqueo de modelo. Los vectores de diferentes modelos no se pueden comparar. Si cambias de modelo, debes incrustar todo nuevamente.
• Términos exactos. Es posible que los ID, códigos y nombres raros no coincidan de manera confiable.
• Negación. “Reembolsos permitidos” y “reembolsos no permitidos” pueden aparecer muy juntos, a pesar de que significan cosas opuestas.
• Similar no significa correcto. Una coincidencia cercana puede estar desactualizada o simplemente ser incorrecta.
• Sesgo. Las incrustaciones pueden absorber estereotipos de sus datos de entrenamiento.
• El coseno no es mágico. Los investigadores han cuestionado qué tan significativo es en algunas incorporaciones aprendidas, por lo que deben tratarse las puntuaciones como una señal útil y no como una medida de verdad.

Errores comunes

• Mezcla de modelos. Incrustar consultas y documentos con el mismo modelo y versión.
• Usar un umbral de similitud en todas partes. Sintonícelo para cada modelo y tarea.
• Incrustar documentos enormes por completo. El significado se diluye, así que fragméntelos primero.
• Omitir evaluación. Sin consultas de prueba, no se puede saber si un cambio ayudó.
• Usar incrustaciones para todo. Si los usuarios buscan ID exactas, un índice de base de datos normal es mejor.

Conclusión

Una incrustación convierte el significado en números, de modo que el software pueda comparar ideas en lugar de cadenas. El concepto es simple, mientras que el trabajo práctico consiste en elegir un modelo, fragmentar datos y probar consultas reales. Para probarlo usted mismo, incruste algunas docenas de sus propios documentos con cualquier modelo de incrustación, búsquelos con preguntas reales y vea dónde le sorprenden los resultados.

Preguntas frecuentes

sigue aprendiendo