LLM de recuperación aumentada de última generación: bge-large-en-v1.5

Introducción

¿Te intriga el innovador LLM de recuperación aumentada ‘bge-large-en-v1.5’? Acompáñanos en este blog para explorar este modelo en profundidad. Descubrirás el papel de los modelos de embedding y sus aplicaciones prácticas. Te guiaremos en la implementación de ‘bge-large-en-v1.5’ en código, su ajuste fino y su integración perfecta con LLM API. ¡Prepárate para desbloquear nuevas posibilidades en la intersección de los modelos de embedding y los LLM!

¿Qué es bge-large-en-v1.5?

En resumen, bge-large-en-v1.5 es un modelo de embedding de código abierto creado por BAAI.

Específicamente, ‘bge’ en ‘bge-large-en-v1.5’ significa ‘BAAI General Embedding’. BAAI, también conocido como ‘FlagEmbedding’ en Github, es una organización privada sin fines de lucro dedicada a la investigación y desarrollo de IA. Centrándose en modelos de lenguaje grandes de recuperación aumentada (LLM), BAAI ha lanzado varios proyectos relacionados. Estos incluyen LLM de contexto largo (Activation Beacon), ajuste fino de LM (LM-Cocktail), recuperación densa (BGE-M3, LLM Embedder, BGE Embedding), modelo de reordenamiento (BGE Reranker) y benchmarking (C-MTEB). Bge-large-en-v1.5 pertenece a la serie de modelos BGE Embedding, desarrollado específicamente para fines de recuperación densa.

¿Qué hace un modelo de embedding para recuperación densa?

Un modelo de embedding para recuperación densa transforma datos de texto en representaciones semánticas densas que capturan el significado y el contexto de la entrada. Estas representaciones densas son utilizadas por un recuperador denso para recuperar información relevante de manera eficiente. Así es como funciona y algunos ejemplos:

Transformar texto en representaciones densas

El modelo de embedding toma oraciones, párrafos o documentos completos como entrada y los convierte en vectores de longitud fija (embeddings). Estos vectores codifican información semántica sobre el texto, permitiendo una comprensión más matizada más allá de la simple coincidencia de palabras clave.

Los LLM a menudo incorporan modelos de embedding como parte de su arquitectura. Por ejemplo, BERT utiliza técnicas de embedding para representar palabras y secuencias de entrada antes de procesarlas a través de sus capas transformer. Los LLM se benefician de los modelos de embedding al aprovechar su capacidad para capturar relaciones semánticas y matices contextuales, que son cruciales para generar respuestas coherentes y contextualmente apropiadas en tareas como la generación de diálogos o la traducción automática.

Rol del recuperador denso

El recuperador denso utiliza estos embeddings para realizar tareas de recuperación. A diferencia de los métodos tradicionales de recuperación dispersa que dependen de coincidencias exactas de palabras clave o índices, un recuperador denso calcula puntuaciones de similitud directamente entre los embeddings de consultas y los embeddings de documentos. Este enfoque permite una recuperación más precisa en longitudes de texto variables, desde oraciones cortas hasta documentos extensos.

Ejemplos de aplicaciones

En tareas de recuperación de información, como motores de búsqueda o sistemas de respuesta a preguntas, estas representaciones densas permiten una recuperación eficiente y precisa de documentos o pasajes relevantes.

Por ejemplo, una consulta como «¿Cuáles son los síntomas del COVID-19?» se puede transformar en un vector de embedding. Del mismo modo, los documentos que hablan sobre los síntomas del COVID-19 también se convierten en embeddings. Al comparar la similitud entre el embedding de la consulta y los embeddings de los documentos (usando técnicas como la similitud coseno), los documentos más relevantes se pueden identificar y clasificar rápidamente.

Otro ejemplo son los sistemas de recomendación. En este caso, los embeddings ayudan a recomendar productos, artículos o videos al comprender las preferencias del usuario y las similitudes de contenido.

En general, los modelos de embedding para recuperación densa, junto con los recuperadores densos, juegan un papel crucial en las aplicaciones modernas de IA al transformar texto en representaciones significativas y recuperar eficientemente información relevante basada en similitud semántica.

¿Cómo puedo usar bge-large-en-v1.5 en código?

Usando bge-large-en-v1.5 con Langchain

Puedes usar bge en langchain de esta manera:

from langchain.embeddings import HuggingFaceBgeEmbeddings
model_name = "BAAI/bge-large-en-v1.5"
model_kwargs = {'device': 'cuda'}
encode_kwargs = {'normalize_embeddings': True} # set True to compute cosine similarity
model = HuggingFaceBgeEmbeddings(
    model_name=model_name,
    model_kwargs=model_kwargs,
    encode_kwargs=encode_kwargs,
    query_instruction="Generate a representation for this sentence to be used for retrieving relevant articles:"
)
model.query_instruction = "Generate a representation for this sentence to be used for retrieving relevant articles:"

Usando bge-large-en-v1.5 con Huggingface Transformers

Con el paquete transformers, puedes usar el modelo de la siguiente manera: Primero, pasas tu entrada a través del modelo transformer, luego seleccionas el último estado oculto del primer token (es decir, [CLS]) como embedding de la oración.

from transformers import AutoTokenizer, AutoModel
import torch
# Sentences we want sentence embeddings for
sentences = ["Sample Data-1", "Sample Data-2"]

# Load model from HuggingFace Hub
tokenizer = AutoTokenizer.from_pretrained('BAAI/bge-large-en-v1.5')
model = AutoModel.from_pretrained('BAAI/bge-large-en-v1.5')
model.eval()
# Tokenize sentences
encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt')
# for s2p(short query to long passage) retrieval task, add an instruction to query (not add instruction for passages)
# encoded_input = tokenizer([instruction + q for q in queries], padding=True, truncation=True, return_tensors='pt')
# Compute token embeddings
with torch.no_grad():
    model_output = model(**encoded_input)
    # Perform pooling. In this case, cls pooling.
    sentence_embeddings = model_output[0][:, 0]
# normalize embeddings
sentence_embeddings = torch.nn.functional.normalize(sentence_embeddings, p=2, dim=1)
print("Sentence embeddings:", sentence_embeddings)

Para más información sobre el uso de los modelos bge, puedes visitar FlagEmbedding en Github.

¿Cómo puedo ajustar bge-large-en-v1.5?

Paso 1 Instalación

• Instalar usando pip: pip install -U FlagEmbedding
• O instalar desde la fuente después de clonar el repositorio y navegar hasta él: pip install .
• Para desarrollo, usar instalación editable: pip install -e .

Paso 2 Preparación de datos

• Los datos de entrenamiento deben estar en formato JSON, cada línea con un diccionario que contenga query, pos (lista de textos positivos) y neg (lista de textos negativos).
• Si no se dispone de textos negativos, se pueden muestrear aleatoriamente del corpus.

Paso 3 Minería de negativos difíciles

• Usar un script para minar negativos difíciles y mejorar la calidad de los embeddings de oraciones.
• Puedes minar negativos difíciles siguiendo este comando:

python -m FlagEmbedding.baai_general_embedding.finetune.hn_mine \
--model_name_or_path BAAI/bge-base-en-v1.5 \
--input_file toy_finetune_data.jsonl \
--output_file toy_finetune_data_minedHN.jsonl \
--range_for_sampling 2-200 \
--negative_number 15 \
--use_gpu_for_searching

• Archivo de entrada: Un archivo JSON que contiene datos para el ajuste fino, donde el script identifica los top-k documentos por consulta y luego selecciona aleatoriamente ejemplos negativos de estos resultados top-k, excluyendo cualquier ejemplo positivo ya proporcionado.
• Archivo de salida: El destino donde se almacenará el archivo JSON, ahora enriquecido con los negativos difíciles recién muestreados, para su uso en el proceso de ajuste fino.
• Número de negativos: Especifica cuántas muestras negativas recopilar.
• Rango de muestreo: Define el alcance del cual se extraerán las muestras negativas. Por ejemplo, un rango de 2–100 indica que los negativos se tomarán de los documentos del top 2 al top 200. Ampliar este rango, por ejemplo a 60–300, hace que la selección de negativos sea menos desafiante al considerar un conjunto más amplio de documentos.
• Pool de recuperación: La fuente de la cual el script extraerá documentos para la recuperación. Por defecto, es el conjunto de todos los negativos en el archivo de entrada, con formato similar a los datos de preentrenamiento. Si se designa un pool de recuperación específico, el script usará ese conjunto para encontrar ejemplos negativos.
• Búsqueda basada en GPU: Una opción para indicar si se debe utilizar faiss-gpu acelerado por GPU para mejorar la eficiencia del proceso de recuperación de negativos.

Paso 4 Entrenamiento

torchrun --nproc_per_node {number of gpus} \
-m FlagEmbedding.baai_general_embedding.finetune.run \
--output_dir {path to save model} \
--model_name_or_path BAAI/bge-large-en-v1.5 \
--train_data ./toy_finetune_data.jsonl \
--learning_rate 1e-5 \
--fp16 \
--num_train_epochs 5 \
--per_device_train_batch_size {large batch size; set 1 for toy data} \
--dataloader_drop_last True \
--normlized True \
--temperature 0.02 \
--query_max_len 64 \
--passage_max_len 256 \
--train_group_size 2 \
--negatives_cross_device \
--logging_steps 10 \
--save_steps 1000 \
--query_instruction_for_retrieval ""

• Tamaño de lote de entrenamiento por dispositivo: La cantidad de muestras procesadas en cada lote de entrenamiento. Generalmente, un tamaño de lote mayor mejora el rendimiento del modelo. Puedes aumentar este tamaño utilizando opciones como entrenamiento de media precisión (--fp16), configuración de DeepSpeed (--deepspeed ./df_config.json, donde df_config.json también puede denominarse ds_config.json) y gradient checkpointing (--gradient_checkpointing).
• Tamaño del grupo de entrenamiento: Determina el número total de ejemplos, tanto positivos como negativos, utilizados para cada consulta durante el entrenamiento. Como hay un ejemplo positivo garantizado, este ajuste determina la cantidad de ejemplos negativos (calculada como train_group_size - 1). Ten en cuenta que este número no debe exceder los negativos disponibles en la lista neg de tus datos. Además de estos negativos de grupo, otros negativos dentro del lote también se incorporan al proceso de ajuste fino.
• Compartición de negativos entre dispositivos: Permite distribuir los ejemplos negativos en todas las GPU disponibles, aumentando efectivamente el número total de negativos utilizados en el entrenamiento.
• Tasa de aprendizaje: Elige un valor que se adapte a tu modelo específico. Para modelos grandes, base o de pequeña escala, se recomiendan típicamente valores como 1e-5, 2e-5 o 3e-5.
• Temperatura: Afecta la dispersión de la distribución de puntuaciones de similitud. Los valores sugeridos van de 0.01 a 0.1.
• Longitud máxima de consulta: El límite superior para la longitud de la consulta, que debe corresponder a la longitud promedio de las consultas en tu conjunto de datos.
• Longitud máxima de pasaje: El límite superior para la longitud del pasaje, establecido según la longitud promedio de los pasajes en tus datos.
• Instrucción de consulta para recuperación: Una directiva opcional adjunta a cada consulta con fines de recuperación. Puedes dejarla en blanco configurándola como una cadena vacía si no se necesita contexto adicional.
• Uso de negativos dentro del lote: Una bandera que indica si se deben considerar los pasajes del mismo lote como ejemplos negativos en el entrenamiento. La configuración predeterminada está habilitada (True).
• Intervalo de guardado de puntos de control: Define la frecuencia con la que se guardan los puntos de control del modelo según la cantidad de pasos de entrenamiento completados.

Paso 5 Carga del modelo

Una vez que el modelo BGE ha sido ajustado, puedes cargarlo sin esfuerzo como se muestra en este ejemplo. Si especificaste un valor único para el hiperparámetro --query_instruction_for_retrieval durante la fase de ajuste fino, asegúrate de sustituir query_instruction_for_retrieval en consecuencia.

Paso 6 Evaluación del modelo

Para la evaluación del modelo, puedes ejecutar este script proporcionado por FlagEmbedding.

Ajustar el modelo bge fundamental mediante fine-tuning puede resultar en un mejor rendimiento específico de la tarea, pero también puede causar una disminución notable en la efectividad general del modelo fuera del dominio objetivo (por ejemplo, una caída en el rendimiento en tareas c-mteb). Para obtener información sobre la solución (usando LM-Cocktail) así como el proceso de ajuste fino, consulta «FlagEmbedding/examples/finetune» en Github.

¿Cómo puedo integrar bge-large-en-v1.5 con LLM API?

Integrar un modelo de embedding con un LLM enriquece las capacidades de procesamiento de lenguaje natural de la IA, permitiendo una búsqueda semántica más sofisticada, comprensión contextual e interacciones personalizadas. Esta integración es particularmente útil para mejorar tareas como recomendaciones basadas en contenido, agrupación de documentos, detección de anomalías, procesamiento multilingüe y construcción de grafos de conocimiento. También admite resumen de texto avanzado y mejora de características para modelos de aprendizaje automático, lo que conduce a un mejor rendimiento en análisis de sentimientos y clasificación de temas.

Paso 1: Configurar tu entorno

Primero, asegúrate de tener el entorno de Python necesario con los paquetes requeridos instalados.

pip install openai
# Install other necessary packages, e.g., requests, numpy, etc.

Paso 2: Inicializar el cliente de la API de Novita AI

Ya has proporcionado el código para inicializar el cliente de la API de Novita AI. Aquí está como referencia:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    api_key="<YOUR Novita AI API Key>",  # Replace with your actual API key
)
model = "nousresearch/nous-hermes-llama2-13b"

Paso 3: Obtener el modelo de embedding

Suponiendo que tienes acceso al modelo bge-large-en-v1.5, lo cargarías. Si es un modelo de Hugging Face, podrías usar la biblioteca transformers de la siguiente manera:

from transformers import AutoModel, AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("BAAI/bge-large-en-v1.5")
model = AutoModel.from_pretrained("BAAI/bge-large-en-v1.5")

Paso 4: Definir una función para obtener embeddings

Crea una función para obtener embeddings del modelo bge-large-en-v1.5.

def get_embeddings(text):
    inputs = tokenizer(text, return_tensors="pt")
    with torch.no_grad():
        embeddings = model(**inputs)[0].mean(dim=1)
    return embeddings.numpy()

Paso 5: Integrar con la API de LLM de Novita AI

Ahora, integra el modelo de embedding con la API de LLM para mejorar las respuestas de la API o realizar tareas como búsqueda semántica.

def enhanced_llm_response(prompt):
    # Get initial response from LLM
    response = client.completions.create(
        model=model,
        prompt=prompt,
        stream=True,
        max_tokens=512,
    )
    
    # Process the response (e.g., extract text)
    # This is a placeholder for the actual response processing
    response_text = next(response)['choices'][0]['text'].content
    
    # Get embeddings for the response
    response_embeddings = get_embeddings(response_text)
    
    # Here, you can use the embeddings for various purposes,
    # such as semantic search, filtering, etc.
    
    return response_text, response_embeddings

Paso 6: Usar la función mejorada

Ahora puedes usar la función enhanced_llm_response para obtener respuestas del LLM y procesarlas con el modelo de embedding.

prompt = "A chat between a curious user and an artificial intelligence assistant"
response, embeddings = enhanced_llm_response(prompt)
print(response)
# Do something with the embeddings, e.g., store them, search for similar texts, etc.

Paso 7: Manejo de errores y registro

Agrega manejo de errores y registro a tu código para gestionar límites de API, fallos de solicitudes y otros problemas potenciales.

Paso 8: Probar e iterar

Prueba la integración a fondo e itera según los resultados. Es posible que necesites ajustar parámetros, manejar más casos extremos u optimizar el rendimiento.

Ten en cuenta que los detalles de implementación reales pueden variar según las capacidades y requisitos específicos de la API de LLM de Novita AI y del modelo bge-large-en-v1.5. Puedes contactar al equipo de Novita AI para soporte técnico: support@novita.ai.

Conclusión

En resumen, nuestra exploración de ‘bge-large-en-v1.5’ ha destacado su papel integral en tareas de recuperación densa, ofreciendo una inmersión profunda en sus capacidades, aplicaciones e implementación práctica. Desde la introducción del modelo y su importancia en el ámbito del embedding hasta demostrar su uso en código y su proceso de ajuste fino, hemos presentado una guía completa. Además, la integración con la API de LLM de Novita AI ejemplifica el potencial del modelo para amplificar la comprensión semántica y la precisión de recuperación de los LLM.

¡Mantente atento para más actualizaciones sobre LLM!

Preguntas frecuentes

1. ¿Cómo funciona un reordenador BGE?

Al ingresar una consulta y un pasaje en el reordenador, puedes obtener una puntuación de relevancia. Esta puntuación se puede transformar en un valor de punto flotante dentro del rango [0, 1] usando una función sigmoidea. Este proceso tiene como objetivo garantizar que los resultados mejor clasificados sean más relevantes y de mayor calidad, mejorando el rendimiento general del sistema.

2. ¿Cuál es la longitud de contexto de BGE?

El modelo más reciente bge-m3 tiene una longitud de contexto de 8 kb.

3. ¿Cuál es el tamaño del embedding de bge m3?

Puede manejar entradas de longitudes variables, desde oraciones cortas hasta documentos extensos que contengan hasta 8192 tokens.

Novita AI es la plataforma en la nube integral que impulsa tus ambiciones de IA. Con API integradas sin problemas, computación sin servidor y aceleración de GPU, proporcionamos las herramientas rentables que necesitas para construir y escalar rápidamente tu negocio impulsado por IA. Elimina los dolores de cabeza de infraestructura y comienza gratis — Novita AI hace realidad tus sueños de IA.

Lectura recomendada

¿Qué son los embeddings de LLM? Todo lo que necesitas saber

Descubriendo el poder de BGE Large: El futuro del embedding de texto