Cómo obtener las incrustaciones vectoriales adecuadas
Este artículo se publicó originalmente en The New Stack y se vuelve a publicar aquí con permiso.
Una introducción completa a los embeddings vectoriales y cómo generarlos con modelos populares de código abierto.
Imagen de Денис Марчук de Pixabay
Los embeddings vectoriales son fundamentales al trabajar con la similitud semántica. Sin embargo, un vector es simplemente una serie de números; un embedding vectorial es una serie de números que representa datos de entrada. Usando embeddings vectoriales, podemos estructurar datos no estructurados o trabajar con cualquier tipo de datos convirtiéndolos en una serie de números. Este enfoque nos permite realizar operaciones matemáticas sobre los datos de entrada, en lugar de depender de comparaciones cualitativas.
Los embeddings vectoriales son influyentes para muchas tareas, particularmente para la búsqueda semántica. Sin embargo, es crucial obtener los embeddings vectoriales apropiados antes de usarlos. Por ejemplo, si usas un modelo de imágenes para vectorizar texto, o viceversa, probablemente obtendrás malos resultados.
En esta publicación, aprenderemos qué significan los embeddings vectoriales, cómo generar los embeddings vectoriales adecuados para tus aplicaciones usando diferentes modelos y cómo aprovechar al máximo los embeddings vectoriales con bases de datos vectoriales como Milvus y Zilliz Cloud.
¿Cómo se crean los embeddings vectoriales?
Ahora que entendemos la importancia de los embeddings vectoriales, aprendamos cómo funcionan. Un embedding vectorial es la representación interna de los datos de entrada en un modelo de aprendizaje profundo, también conocido como modelos de embedding o una red neuronal profunda. Entonces, ¿cómo extraemos esta información?
Obtenemos vectores eliminando la última capa y tomando la salida de la penúltima capa. La última capa de una red neuronal generalmente produce la predicción del modelo, por lo que tomamos la salida de la penúltima capa. El embedding vectorial es el dato que se alimenta a la capa predictiva de una red neuronal.
La dimensionalidad de un embedding vectorial es equivalente al tamaño de la penúltima capa del modelo y, por lo tanto, intercambiable con el tamaño o la longitud del vector. Las dimensionalidades vectoriales comunes incluyen 384 (generada por Sentence Transformers Mini-LM), 768 (por Sentence Transformers MPNet), 1,536 (por OpenAI) y 2,048 (por ResNet-50).
¿Qué significa un embedding vectorial?
Alguien me preguntó una vez sobre el significado de cada dimensión en un embedding vectorial. La respuesta corta es nada. Una sola dimensión en un embedding vectorial no significa nada, ya que es demasiado abstracta para determinar su significado. Sin embargo, cuando tomamos todas las dimensiones juntas, proporcionan el significado semántico de los datos de entrada.
Las dimensiones del vector son representaciones abstractas de alto nivel de diferentes atributos. Los atributos representados dependen de los datos de entrenamiento y del propio modelo. Los modelos de texto e imagen generan embeddings diferentes porque están entrenados para tipos de datos fundamentalmente distintos. Incluso diferentes modelos de texto generan embeddings diferentes. A veces difieren en tamaño; otras veces, difieren en los atributos que representan. Por ejemplo, un modelo entrenado con datos legales aprenderá cosas diferentes que uno entrenado con datos de atención médica. Exploré este tema en mi publicación comparando embeddings vectoriales.
Generar los embeddings vectoriales adecuados
¿Cómo se obtienen los embeddings vectoriales adecuados? Todo comienza con identificar el tipo de datos que deseas incrustar. Esta sección cubre la incrustación de cinco tipos diferentes de datos: imágenes, texto, audio, videos y datos multimodales. Todos los modelos que presentamos aquí son de código abierto y provienen de Hugging Face o PyTorch.
Embeddings de imágenes
El reconocimiento de imágenes despegó en 2012 después de que AlexNet apareciera en escena. Desde entonces, el campo de la visión por computadora ha presenciado numerosos avances. El modelo de reconocimiento de imágenes notable más reciente es ResNet-50, una red residual profunda de 50 capas basada en la arquitectura anterior ResNet-34.
Las redes neuronales residuales (ResNet) resuelven el problema del gradiente desvanecido en redes neuronales convolucionales profundas mediante conexiones de atajo. Estas conexiones permiten que la salida de capas anteriores vaya directamente a capas posteriores sin pasar por todas las capas intermedias, evitando así el problema del gradiente desvanecido. Este diseño hace que ResNet sea menos complejo que VGGNet (Visual Geometry Group), una red neuronal convolucional que anteriormente tenía un rendimiento superior.
Recomiendo dos implementaciones de ResNet-50 como ejemplos: ResNet 50 en Hugging Face y ResNet 50 en PyTorch Hub. Aunque las redes son las mismas, el proceso de obtener embeddings difiere.
El ejemplo de código siguiente demuestra cómo usar PyTorch para obtener embeddings vectoriales. Primero, cargamos el modelo desde PyTorch Hub. A continuación, eliminamos la última capa y llamamos a .eval() para indicar al modelo que se comporte como si se estuviera ejecutando para inferencia. Luego, la función embed genera el embedding vectorial.
# Load the embedding model with the last layer removed
model = torch.hub.load('pytorch/vision:v0.10.0', 'resnet50', pretrained=True) model = torch.nn.Sequential(*(list(model.children())[:-1]))
model.eval()
def embed(data):
with torch.no_grad():
output = model(torch.stack(data[0])).squeeze()
return output
HuggingFace utiliza una configuración ligeramente diferente. El código siguiente demuestra cómo obtener un embedding vectorial desde Hugging Face. Primero, necesitamos un extractor de características y un modelo de la biblioteca transformers . Usaremos el extractor de características para obtener entradas para el modelo y usaremos el modelo para obtener salidas y extraer el último estado oculto.
# Load model directly
from transformers import AutoFeatureExtractor, AutoModelForImageClassification
extractor = AutoFeatureExtractor.from_pretrained("microsoft/resnet-50")
model = AutoModelForImageClassification.from_pretrained("microsoft/resnet-50")
from PIL import Image
image = Image.open("<image path>")
# image = Resize(size=(256, 256))(image)
inputs = extractor(images=image, return_tensors="pt")
# print(inputs)
outputs = model(**inputs)
vector_embeddings = outputs[1][-1].squeeze()
Embeddings de texto
Los ingenieros e investigadores han estado experimentando con el lenguaje natural y la IA desde la invención de la IA. Algunos de los primeros experimentos incluyen:
- ELIZA, el primer chatbot terapeuta de IA.
- La Habitación China de John Searle, un experimento mental que examina si la capacidad de traducir entre chino e inglés requiere una comprensión del idioma.
- Traducciones basadas en reglas entre inglés y ruso.
La operación de la IA sobre el lenguaje natural ha evolucionado significativamente desde sus embeddings basados en reglas. Comenzando con redes neuronales primarias, añadimos relaciones de recurrencia mediante RNN para hacer seguimiento de los pasos en el tiempo. A partir de ahí, usamos transformadores para resolver el problema de transducción de secuencias.
Los transformadores consisten en un codificador, que codifica una entrada en una matriz que representa el estado, una matriz de atención y un decodificador. El decodificador decodifica el estado y la matriz de atención para predecir el siguiente token correcto para finalizar la secuencia de salida. GPT-3, el modelo de lenguaje más popular hasta la fecha, comprende decodificadores estrictos. Codifican la entrada y predicen el/los siguiente(s) token(s) correcto(s).
Aquí tienes dos modelos de la biblioteca sentence-transformers de Hugging Face que puedes usar además de los embeddings de OpenAI:
- MiniLM-L6-v2: un modelo de 384 dimensiones
- MPNet-Base-V2: un modelo de 768 dimensiones
Puedes acceder a los embeddings de ambos modelos de la misma manera.
from sentence_transformers import SentenceTransformer
model = SentenceTransformer("<model-name>")
vector_embeddings = model.encode(“<input>”)
Embeddings multimodales
Los modelos multimodales están menos desarrollados que los modelos de imagen o texto. A menudo relacionan imágenes con texto.
El ejemplo de código abierto más útil es CLIP VIT, un modelo de imagen a texto. Puedes acceder a los embeddings de CLIP VIT de la misma manera que lo harías con un modelo de imagen, como se muestra en el código a continuación.
# Load model directly
from transformers import AutoProcessor, AutoModelForZeroShotImageClassification
processor = AutoProcessor.from_pretrained("openai/clip-vit-large-patch14")
model = AutoModelForZeroShotImageClassification.from_pretrained("openai/clip-vit-large-patch14")
from PIL import Image
image = Image.open("<image path>")
# image = Resize(size=(256, 256))(image)
inputs = extractor(images=image, return_tensors="pt")
# print(inputs)
outputs = model(**inputs)
vector_embeddings = outputs[1][-1].squeeze()
Embeddings de audio
La IA para audio ha recibido menos atención que la IA para texto o imágenes. El caso de uso más común para audio es la conversión de voz a texto para industrias como centros de llamadas, tecnología médica y accesibilidad. Un modelo popular de código abierto para voz a texto es Whisper de OpenAI. El código a continuación muestra cómo obtener embeddings vectoriales del modelo de voz a texto.
import torch
from transformers import AutoFeatureExtractor, WhisperModel
from datasets import load_dataset
model = WhisperModel.from_pretrained("openai/whisper-base")
feature_extractor = AutoFeatureExtractor.from_pretrained("openai/whisper-base")
ds = load_dataset("hf-internal-testing/librispeech_asr_dummy", "clean", split="validation")
inputs = feature_extractor(ds[0]["audio"]["array"], return_tensors="pt")
input_features = inputs.input_features
decoder_input_ids = torch.tensor([[1, 1]]) * model.config.decoder_start_token_id
vector_embedding = model(input_features, decoder_input_ids=decoder_input_ids).last_hidden_state
Embeddings de video
Los embeddings de video son más complejos que los embeddings de audio o imagen. Es necesario un enfoque multimodal al trabajar con videos, ya que incluyen audio e imágenes sincronizados. Un modelo de video popular es el multimodal perceiver de DeepMind. Este tutorial en notebook muestra cómo usar el modelo para clasificar un video.
Para obtener los embeddings de la entrada, usa outputs[1][-1].squeeze() del código mostrado en el notebook en lugar de eliminar las salidas. Destaco este fragmento de código en la función autoencode .
def autoencode_video(images, audio):
# only create entire video once as inputs
inputs = {'image': torch.from_numpy(np.moveaxis(images, -1, 2)).float().to(device),
'audio': torch.from_numpy(audio).to(device),
'label': torch.zeros((images.shape[0], 700)).to(device)}
nchunks = 128
reconstruction = {}
for chunk_idx in tqdm(range(nchunks)):
image_chunk_size = np.prod(images.shape[1:-1]) // nchunks
audio_chunk_size = audio.shape[1] // SAMPLES_PER_PATCH // nchunks
subsampling = {
'image': torch.arange(
image_chunk_size * chunk_idx, image_chunk_size * (chunk_idx + 1)),
'audio': torch.arange(
audio_chunk_size * chunk_idx, audio_chunk_size * (chunk_idx + 1)),
'label': None,
}
# forward pass
with torch.no_grad():
outputs = model(inputs=inputs, subsampled_output_points=subsampling)
output = {k:v.cpu() for k,v in outputs.logits.items()}
reconstruction['label'] = output['label']
if 'image' not in reconstruction:
reconstruction['image'] = output['image']
reconstruction['audio'] = output['audio']
else:
reconstruction['image'] = torch.cat(
[reconstruction['image'], output['image']], dim=1)
reconstruction['audio'] = torch.cat(
[reconstruction['audio'], output['audio']], dim=1)
vector_embeddings = outputs[1][-1].squeeze()
# finally, reshape image and audio modalities back to original shape
reconstruction['image'] = torch.reshape(reconstruction['image'], images.shape)
reconstruction['audio'] = torch.reshape(reconstruction['audio'], audio.shape)
return reconstruction
return None
Almacenamiento, indexación y búsqueda de embeddings vectoriales con bases de datos vectoriales
Ahora que entendemos qué son los embeddings vectoriales y cómo generarlos usando varios modelos de embeddings potentes, la siguiente pregunta es cómo almacenarlos y aprovecharlos. Las bases de datos vectoriales son la respuesta.
Las bases de datos vectoriales como Milvus y Zilliz Cloud están diseñadas específicamente para almacenar, indexar y buscar en conjuntos de datos masivos de datos no estructurados mediante embeddings vectoriales. También son una de las infraestructuras más críticas para varias pilas de IA.
Las bases de datos vectoriales suelen utilizar el algoritmo Approximate Nearest Neighbor (ANN) para calcular la distancia espacial entre el vector de consulta y los vectores almacenados en la base de datos. Cuanto más cerca se encuentren los dos vectores, más relevantes serán. Luego, el algoritmo encuentra los k vecinos más cercanos y se los entrega al usuario.
Las bases de datos vectoriales son populares en casos de uso como la generación aumentada por recuperación con LLM (RAG), sistemas de preguntas y respuestas, sistemas de recomendación, búsquedas semánticas y búsquedas de similitud de imágenes, video y audio.
Para obtener más información sobre embeddings vectoriales, datos no estructurados y bases de datos vectoriales, considera comenzar con la serie Vector Database 101 .
Resumen
Los vectores son una herramienta potente para trabajar con datos no estructurados. Usando vectores, podemos comparar matemáticamente diferentes piezas de datos no estructurados en función de la similitud semántica. Elegir el modelo de embeddings vectoriales adecuado es fundamental para construir un motor de búsqueda vectorial para cualquier aplicación.
En esta publicación, aprendimos que las incrustaciones vectoriales son la representación interna de los datos de entrada en una red neuronal. Como resultado, dependen en gran medida de la arquitectura de la red y de los datos utilizados para entrenar el modelo. Los diferentes tipos de datos (como imágenes, texto y audio) requieren modelos específicos. Afortunadamente, hay muchos modelos de código abierto preentrenados disponibles para su uso. En esta publicación, cubrimos modelos para los cinco tipos de datos más comunes: imágenes, texto, multimodal, audio y video. Además, si quieres aprovechar al máximo las incrustaciones vectoriales, las bases de datos vectoriales son la herramienta más popular.
Sigue leyendo
Zilliz Cloud Audit Logs Goes GA: Security, Compliance, and Transparency at Scale
Zilliz Cloud Audit Logs are now GA, giving enterprises real-time visibility, compliance-ready trails, and stronger security across AWS, GCP, and Azure.
Demystifying the Milvus Sizing Tool
Explore how to use the Sizing Tool to select the optimal configuration for your Milvus deployment.
1 Table = 1000 Words? Foundation Models for Tabular Data
TableGPT2 automates tabular data insights, overcoming schema variability, while Milvus accelerates vector search for efficient, scalable decision-making.