Embeddings y modelos multimodales: el futuro de la búsqueda

Introducción

La búsqueda tradicional basada en palabras clave está quedando obsoleta. Los usuarios ya no solo escriben texto; toman fotos, graban audios y esperan respuestas inteligentes. Los embeddings (incrustaciones vectoriales) y modelos multimodales son la clave para esta nueva era. En este artículo exploraremos cómo funcionan, sus aplicaciones prácticas y cómo puedes implementarlos en tus proyectos.

¿Qué son los embeddings?

Los embeddings son representaciones numéricas de datos (texto, imágenes, audio) en un espacio vectorial de alta dimensión. La idea es que entidades similares queden cerca unas de otras en ese espacio. Por ejemplo, la palabra "perro" y "cachorro" tendrán vectores similares, mientras que "perro" y "gato" estarán más lejos.

Embeddings de texto

Los modelos como Word2Vec, GloVe y más recientemente BERT y Sentence Transformers generan embeddings de palabras o frases completas. Para obtener embeddings de texto en Python:

from sentence_transformers import SentenceTransformer

model = SentenceTransformer('all-MiniLM-L6-v2')
sentences = ["El gato duerme en el sofá", "El perro corre en el parque"]
embeddings = model.encode(sentences)
print(embeddings.shape)  # (2, 384)

Embeddings de imágenes

Modelos como CLIP (Contrastive Language-Image Pre-training) de OpenAI permiten obtener embeddings tanto de imágenes como de texto en el mismo espacio. Así, una imagen de un gato y la frase "un gato" tendrán vectores similares.

import clip
import torch

model, preprocess = clip.load("ViT-B/32")
image = preprocess(Image.open("gato.jpg")).unsqueeze(0)
text = clip.tokenize(["un gato", "un perro"])

with torch.no_grad():
    image_features = model.encode_image(image)
    text_features = model.encode_text(text)

Modelos multimodales

Los modelos multimodales integran múltiples tipos de datos (texto, imagen, audio, video) en una única representación. Permiten realizar búsquedas cruzadas: buscar imágenes usando texto, o texto usando audio. Ejemplos destacados:

• CLIP (OpenAI): Permite búsqueda texto-imagen e imagen-texto.
• DALL-E: Genera imágenes a partir de texto.
• ImageBind (Meta): Conecta seis modalidades (imagen, texto, audio, profundidad, térmica, IMU).

Arquitectura típica

1. Codificadores por modalidad (ej: Transformer para texto, CNN para imágenes).
2. Proyección a un espacio común (lineal o MLP).
3. Función de pérdida contrastiva: maximiza similitud entre pares correctos y minimiza entre incorrectos.

Aplicaciones en búsqueda

Búsqueda semántica de texto

En lugar de buscar palabras exactas, se calcula la similitud coseno entre el embedding de la consulta y los embeddings de los documentos. Ejemplo con FAISS para búsqueda eficiente:

import faiss
import numpy as np

# Supongamos que tenemos embeddings de documentos (matriz 1000x384)
document_embeddings = np.random.random((1000, 384)).astype('float32')
index = faiss.IndexFlatIP(384)  # producto interno = similitud coseno si vectores normalizados
index.add(document_embeddings)

query_embedding = np.random.random((1, 384)).astype('float32')
distances, indices = index.search(query_embedding, k=5)

Búsqueda multimodal (texto-imagen)

Al usar CLIP, la consulta en texto obtiene embeddings que se comparan con embeddings de imágenes. Así, un usuario puede buscar "atardecer en la playa" y encontrar fotos relevantes sin etiquetas.

Búsqueda por audio

Modelos como ImageBind permiten buscar imágenes a partir de un sonido (ej: el ladrido de un perro encuentra fotos de perros).

Implementación práctica: buscador de imágenes con CLIP

Construyamos un buscador simple:

1. Indexar imágenes de un directorio.
2. Recibir una consulta de texto.
3. Mostrar las imágenes más similares.

import os
from PIL import Image
import clip
import torch
from sklearn.metrics.pairwise import cosine_similarity

# Cargar modelo
device = "cuda" if torch.cuda.is_available() else "cpu"
model, preprocess = clip.load("ViT-B/32", device=device)

# Indexar imágenes
image_paths = [os.path.join("images", f) for f in os.listdir("images") if f.endswith(('.png','.jpg','.jpeg'))]
image_features = []
for path in image_paths:
    image = preprocess(Image.open(path)).unsqueeze(0).to(device)
    with torch.no_grad():
        feature = model.encode_image(image)
        image_features.append(feature.cpu().numpy())

image_features = np.concatenate(image_features, axis=0)

# Consulta
query = "un paisaje montañoso"
with torch.no_grad():
    text_feature = model.encode_text(clip.tokenize([query]).to(device))
    text_feature = text_feature.cpu().numpy()

similarities = cosine_similarity(text_feature, image_features)[0]
top_indices = np.argsort(similarities)[::-1][:5]

for idx in top_indices:
    print(f"{image_paths[idx]} - similitud: {similarities[idx]:.4f}")

Desafíos y consideraciones

• Escalabilidad: Indexar millones de vectores requiere sistemas como FAISS, Annoy o Elasticsearch con plugin de vectores.
• Actualización: Si se añaden nuevos datos, hay que actualizar el índice.
• Calidad de los embeddings: Depende del modelo y los datos de entrenamiento. Para dominios específicos, puede ser necesario fine-tuning.

El futuro

Veremos modelos multimodales más ligeros para dispositivos móviles, integración con asistentes de voz y búsqueda en tiempo real. La combinación de embeddings con bases de datos vectoriales (como Pinecone, Weaviate o Qdrant) hará que estas capacidades sean accesibles para cualquier desarrollador.

Conclusión

Los embeddings y modelos multimodales están redefiniendo la búsqueda. Ya no se trata de coincidencia de cadenas, sino de comprensión semántica profunda. Empresas como Google, Microsoft y startups están adoptando estas técnicas para ofrecer experiencias más naturales y precisas. Implementar un sistema de búsqueda multimodal es más fácil que nunca gracias a bibliotecas open-source y APIs. El momento de empezar es ahora.