Cómo obtener las incrustaciones vectoriales adecuadas

Este artículo se publicó originalmente en The New Stack y se publica aquí con permiso.

Una introducción completa a las incrustaciones vectoriales y cómo generarlas con modelos populares de código abierto.

Imagen de Денис Марчук de Pixabay

Las incrustaciones vectoriales son fundamentales cuando se trabaja con similitud semántica. Sin embargo, un vector es simplemente una serie de números; una incrustación vectorial es una serie de números que representan datos de entrada. Con las incrustaciones 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 con los datos de entrada, en lugar de basarnos en comparaciones cualitativas.

Las incrustaciones vectoriales influyen en muchas tareas, sobre todo en la búsqueda semántica. Sin embargo, es crucial obtener las incrustaciones vectoriales adecuadas antes de utilizarlas. Por ejemplo, si se utiliza un modelo de imagen para vectorizar texto, o viceversa, probablemente se obtendrán malos resultados.

En este post, aprenderemos qué significan las incrustaciones vectoriales, cómo generar las incrustaciones vectoriales adecuadas para sus aplicaciones utilizando diferentes modelos y cómo hacer el mejor uso de las incrustaciones vectoriales con bases de datos vectoriales como Milvus y Zilliz Cloud.

¿Cómo se crean las incrustaciones vectoriales?

Ahora que entendemos la importancia de las incrustaciones vectoriales, aprendamos cómo funcionan. Una incrustación vectorial es la representación interna de los datos de entrada en un modelo de aprendizaje profundo, también conocido como modelos de incrustación o red neuronal profunda. Entonces, ¿cómo extraemos esta información?

Obtenemos los vectores eliminando la última capa y tomando la salida de la penúltima capa. La última capa de una red neuronal suele emitir la predicción del modelo, así que tomamos la salida de la penúltima capa. La incrustación vectorial son los datos que se introducen en la capa de predicción de una red neuronal.

La dimensionalidad de un vector es equivalente al tamaño de la penúltima capa del modelo y, por tanto, intercambiable con el tamaño o longitud del vector. Las dimensiones de vector más comunes son 384 (generado por Sentence Transformers Mini-LM), 768 (por Sentence Transformers MPNet), 1.536 (por OpenAI) y 2.048 (por ResNet-50).

¿Qué significa incrustación vectorial?

Alguien me preguntó una vez qué significaba cada dimensión de una incrustación vectorial. La respuesta corta es nada. Una sola dimensión de una incrustación 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 distintos atributos. Los atributos representados dependen de los datos de entrenamiento y del propio modelo. Los modelos de texto e imagen generan incrustaciones diferentes porque están entrenados para tipos de datos fundamentalmente distintos. Incluso los distintos modelos de texto generan incrustaciones diferentes. A veces difieren en tamaño; otras, en los atributos que representan. Por ejemplo, un modelo entrenado para datos jurídicos aprenderá cosas distintas que otro entrenado para datos sanitarios. Exploré este tema en mi post Comparación de incrustaciones vectoriales.

Generar las incrustaciones vectoriales adecuadas

¿Cómo se obtienen las incrustaciones vectoriales adecuadas? Todo comienza con la identificación del tipo de datos que se desea incrustar. Esta sección cubre la incrustación de cinco tipos diferentes de datos: imágenes, texto, audio, vídeos y datos multimodales. Todos los modelos que presentamos aquí son de código abierto y proceden de Hugging Face o PyTorch.

Incrustación de imágenes

El reconocimiento de imágenes despegó en 2012 tras la aparición de AlexNet. Desde entonces, el campo de la visión por ordenador ha experimentado numerosos avances. El último modelo notable de reconocimiento de imágenes es ResNet-50, una red residual profunda de 50 capas basada en la antigua arquitectura ResNet-34.

Las redes neuronales residuales (ResNet) resuelven el problema del gradiente de fuga en las redes neuronales convolucionales profundas mediante conexiones de atajo. Estas conexiones permiten que la salida de las capas anteriores vaya directamente a las capas posteriores sin pasar por todas las capas intermedias, evitando así el problema del gradiente evanescente. Este diseño hace que ResNet sea menos compleja que VGGNet (Visual Geometry Group), una red neuronal convolucional que hasta ahora había obtenido los mejores resultados.

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 obtención de incrustaciones difiere.

El siguiente ejemplo de código muestra cómo utilizar PyTorch para obtener incrustaciones vectoriales. En primer lugar, 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 la inferencia. A continuación, la función embed genera la incrustación 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 siguiente código muestra cómo obtener una incrustación vectorial de Hugging Face. En primer lugar, necesitamos un extractor de características y un modelo de la biblioteca transformers. Utilizaremos el extractor de características para obtener entradas para el modelo y utilizaremos 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()

Incrustación 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 son:

• 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 entre inglés y ruso basadas en reglas.

El funcionamiento de la IA en el lenguaje natural ha evolucionado significativamente a partir de sus incrustaciones basadas en reglas. Empezando con redes neuronales primarias, añadimos relaciones de recurrencia mediante RNN para seguir los pasos en el tiempo. A partir de ahí, utilizamos transformadores para resolver el problema de la transducción de secuencias.

Los transformadores constan de un codificador, que codifica una entrada en una matriz que representa el estado, una matriz de atención y un decodificador. El decodificador descodifica el estado y la matriz de atención para predecir el siguiente token correcto y terminar la secuencia de salida. GPT-3, el modelo lingüístico más popular hasta la fecha, consta de decodificadores estrictos. Codifican la entrada y predicen el siguiente token o tokens correctos.

Aquí tienes dos modelos de la biblioteca sentence-transformers de Hugging Face que puedes utilizar además de los embeddings de OpenAI:

• MiniLM-L6-v2: un modelo de 384 dimensiones
• MPNet-Base-V2: un modelo de 768 dimensiones

Puede acceder a las incrustaciones de ambos modelos de la misma manera.

from sentence_transformers import SentenceTransformer


model = SentenceTransformer("<model-name>")
vector_embeddings = model.encode(“<input>”)

Incrustaciones multimodales

Los modelos multimodales están menos desarrollados que los de imagen o texto. Suelen relacionar imágenes con texto.

El ejemplo de código abierto más útil es CLIP VIT, un modelo de imagen a texto. Puede acceder a las incrustaciones de CLIP VIT del mismo modo que lo haría con un modelo de imagen, como se muestra en el código siguiente.

# 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()

Incrustación 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 el audio es la conversión de voz a texto en sectores como los centros de llamadas, la tecnología médica y la accesibilidad. Un modelo popular de código abierto para la conversión de voz a texto es Whisper de OpenAI. El siguiente código muestra cómo obtener incrustaciones vectoriales a partir 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

Incrustaciones de vídeo

Las incrustaciones de vídeo son más complejas que las de audio o imagen. Es necesario un enfoque multimodal cuando se trabaja con vídeos, ya que incluyen audio e imágenes sincronizadas. Un modelo de vídeo popular es el perceptor multimodal de DeepMind. Este tutorial muestra cómo utilizar el modelo para clasificar un vídeo.

Para obtener las incrustaciones de la entrada, utilice outputs[1][-1].squeeze() del código que se muestra en el cuaderno en lugar de eliminar las salidas. Resalto 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 incrustaciones vectoriales con bases de datos vectoriales

Ahora que entendemos qué son las incrustaciones vectoriales y cómo generarlas utilizando varios modelos de incrustación potentes, la siguiente pregunta es cómo almacenarlas y aprovecharlas. Las bases de datos vectoriales son la respuesta.

Las bases de datos vectoriales, como Milvus y Zilliz Cloud, se han creado específicamente para almacenar, indexar y buscar conjuntos masivos de datos no estructurados mediante incrustaciones vectoriales. También son una de las infraestructuras más importantes para varias pilas de IA.

Las bases de datos vectoriales suelen utilizar el algoritmo del vecino más próximo aproximado (RNA ) 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 son. A continuación, el algoritmo encuentra los k vectores más próximos y se los entrega al usuario.

Las bases de datos vectoriales son populares en casos de uso como la generación aumentada de recuperación LLM (RAG), los sistemas de preguntas y respuestas, los sistemas de recomendación, las búsquedas semánticas y las búsquedas por similitud de imágenes, vídeo y audio.

Para obtener más información sobre incrustaciones vectoriales, datos no estructurados y bases de datos vectoriales, considere la posibilidad de comenzar con la serie Base de datos vectoriales 101.

Resumen

Los vectores son una poderosa herramienta para trabajar con datos no estructurados. Utilizando vectores, podemos comparar matemáticamente diferentes piezas de datos no estructurados basándonos en la similitud semántica. Elegir el modelo de incrustación vectorial adecuado es fundamental para construir un motor de búsqueda vectorial para cualquier aplicación.

En este post, 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. 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 este post, cubrimos los modelos para los cinco tipos de datos más comunes: imágenes, texto, multimodal, audio y vídeo. Además, si quieres aprovechar al máximo las incrustaciones vectoriales, las bases de datos vectoriales son la herramienta más popular.