LLM augmenté par récupération de pointe : bge-large-en-v1.5

Introduction

Êtes-vous intrigué par le dernier LLM augmenté par récupération (retrieval-augmented) « bge-large-en-v1.5 » ? Rejoignez-nous dans ce blog pour explorer ce modèle en profondeur. Vous découvrirez le rôle des modèles d’embedding et leurs applications pratiques. Nous vous guiderons dans le déploiement de « bge-large-en-v1.5 » en code, son réglage fin, et son intégration transparente avec l’API LLM. Préparez-vous à débloquer de nouvelles possibilités à l’intersection des modèles d’embedding et des LLM !

Qu’est-ce que bge-large-en-v1.5 ?

En bref, bge-large-en-v1.5 est un modèle d’embedding open source créé par BAAI.

Plus précisément, « bge » dans « bge-large-en-v1.5 » signifie « BAAI General Embedding ». BAAI, également connu sous le nom de « FlagEmbedding » sur Github, est une organisation privée à but non lucratif dédiée à la recherche et au développement en IA. Axée sur les grands modèles de langage (LLM) augmentés par récupération, BAAI a lancé plusieurs projets connexes. Ceux-ci incluent LLM à long contexte (Activation Beacon), le réglage fin des LM (LM-Cocktail), la récupération dense (BGE-M3, LLM Embedder, BGE Embedding), le modèle de reclassement (BGE Reranker), et l’évaluation comparative (C-MTEB). Bge-large-en-v1.5 appartient à la série de modèles d’embedding BGE, développée spécifiquement pour la récupération dense.

Que fait un modèle d’embedding pour la récupération dense ?

Un modèle d’embedding pour la récupération dense transforme les données textuelles en représentations denses et sémantiques qui capturent le sens et le contexte de l’entrée. Ces représentations denses sont utilisées par un récupérateur dense pour retrouver efficacement les informations pertinentes. Voici comment cela fonctionne et quelques exemples :

Transformation du texte en représentations denses

Le modèle d’embedding prend des phrases, des paragraphes ou des documents entiers en entrée et les convertit en vecteurs de longueur fixe (embeddings). Ces vecteurs encodent des informations sémantiques sur le texte, permettant une compréhension plus nuancée au-delà d’une simple correspondance de mots-clés.

Les LLM intègrent souvent des modèles d’embedding dans leur architecture. Par exemple, BERT utilise des techniques d’embedding pour représenter les mots et les séquences d’entrée avant de les traiter dans ses couches de transformeur. Les LLM bénéficient des modèles d’embedding en exploitant leur capacité à capturer les relations sémantiques et les nuances contextuelles, essentielles pour générer des réponses cohérentes et contextuellement appropriées dans des tâches telles que la génération de dialogues ou la traduction automatique.

Rôle du récupérateur dense

Le récupérateur dense utilise ces embeddings pour effectuer des tâches de récupération. Contrairement aux méthodes de récupération sparse traditionnelles qui reposent sur des correspondances exactes de mots-clés ou des index, un récupérateur dense calcule directement les scores de similarité entre les embeddings de requête et les embeddings de document. Cette approche permet une récupération plus précise sur des entrées textuelles de longueurs variées, des phrases courtes aux longs documents.

Exemples d’applications

Dans les tâches de recherche d’informations, comme les moteurs de recherche ou les systèmes de questions-réponses, ces représentations denses permettent une récupération efficace et précise des documents ou passages pertinents.

Par exemple, une requête comme « Quels sont les symptômes du COVID-19 ? » peut être transformée en un vecteur d’embedding. De même, les documents traitant des symptômes du COVID-19 sont également convertis en embeddings. En comparant la similarité entre l’embedding de la requête et ceux des documents (à l’aide de techniques comme la similarité cosinus), les documents les plus pertinents peuvent être rapidement identifiés et classés.

Un autre exemple est celui des systèmes de recommandation. Dans ce cas, les embeddings aident à recommander des produits, articles ou vidéos en comprenant les préférences des utilisateurs et les similarités de contenu.

Globalement, les modèles d’embedding pour la récupération dense, couplés aux récupérateurs denses, jouent un rôle crucial dans les applications d’IA modernes en transformant le texte en représentations significatives et en récupérant efficacement les informations pertinentes basées sur la similarité sémantique.

Comment puis-je utiliser bge-large-en-v1.5 en code ?

Utiliser bge-large-en-v1.5 avec Langchain

Vous pouvez utiliser bge dans langchain de cette manière :

from langchain.embeddings import HuggingFaceBgeEmbeddings
model_name = "BAAI/bge-large-en-v1.5"
model_kwargs = {'device': 'cuda'}
encode_kwargs = {'normalize_embeddings': True} # mettre True pour calculer la similarité cosinus
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:"

Utiliser bge-large-en-v1.5 avec Huggingface Transformers

Avec le package transformers, vous pouvez utiliser le modèle comme suit : D’abord, vous passez votre entrée dans le modèle transformeur, puis vous sélectionnez le dernier état caché du premier token (c’est-à-dire [CLS]) comme embedding de la phrase.

from transformers import AutoTokenizer, AutoModel
import torch
# Phrases pour lesquelles nous voulons des embeddings de phrase
sentences = ["Sample Data-1", "Sample Data-2"]

# Charger le modèle depuis HuggingFace Hub
tokenizer = AutoTokenizer.from_pretrained('BAAI/bge-large-en-v1.5')
model = AutoModel.from_pretrained('BAAI/bge-large-en-v1.5')
model.eval()
# Tokeniser les phrases
encoded_input = tokenizer(sentences, padding=True, truncation=True, return_tensors='pt')
# Pour la tâche de récupération s2p (requête courte vers passage long), ajouter une instruction à la requête (ne pas ajouter d'instruction pour les passages)
# encoded_input = tokenizer([instruction + q for q in queries], padding=True, truncation=True, return_tensors='pt')
# Calculer les embeddings des tokens
with torch.no_grad():
    model_output = model(**encoded_input)
    # Effectuer le pooling. Dans ce cas, cls pooling.
    sentence_embeddings = model_output[0][:, 0]
# normaliser les embeddings
sentence_embeddings = torch.nn.functional.normalize(sentence_embeddings, p=2, dim=1)
print("Sentence embeddings:", sentence_embeddings)

Pour plus d’informations sur l’utilisation des modèles bge, vous pouvez visiter FlagEmbedding sur Github.

Comment puis-je affiner bge-large-en-v1.5 ?

Étape 1 Installation

• Installer via pip : pip install -U FlagEmbedding
• Ou installer depuis la source après avoir cloné le dépôt et s’y être rendu : pip install .
• Pour le développement, utiliser une installation éditable : pip install -e .

Étape 2 Préparation des données

• Les données d’entraînement doivent être au format JSON, chaque ligne étant un dictionnaire contenant query, pos (liste de textes positifs) et neg (liste de textes négatifs).
• Si les textes négatifs ne sont pas disponibles, ils peuvent être échantillonnés aléatoirement depuis le corpus.

Étape 3 Extraction de négatifs difficiles (hard negatives)

• Utiliser un script pour extraire des négatifs difficiles afin d’améliorer la qualité des embeddings de phrases.
• Vous pouvez extraire des négatifs difficiles avec cette commande :

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

• Fichier d’entrée : Un fichier JSON contenant les données pour le réglage fin, où le script identifie les top-k documents par requête, puis sélectionne aléatoirement des exemples négatifs parmi ces top-k résultats, en excluant les exemples positifs déjà fournis.
• Fichier de sortie : La destination où le fichier JSON, maintenant enrichi des nouveaux négatifs difficiles échantillonnés, sera stocké pour être utilisé dans le processus de réglage fin.
• Nombre de négatifs : Spécifie combien d’échantillons négatifs collecter.
• Plage d’échantillonnage : Définit le périmètre à partir duquel tirer les échantillons négatifs. Par exemple, une plage de 2–100 indique que les négatifs seront pris parmi les 2 à 200 premiers documents. Élargir cette plage, par exemple à 60–300, rend la sélection des négatifs moins difficile en considérant un ensemble plus large de documents.
• Pool de récupération : La source à partir de laquelle le script tirera les documents pour la récupération. Par défaut, il s’agit de l’ensemble de tous les négatifs du fichier d’entrée, formaté comme les données de pré-entraînement. Si un pool de récupération spécifique est désigné, le script utilisera cet ensemble à la place pour trouver des exemples négatifs.
• Recherche basée sur GPU : Une option pour indiquer si le faiss-gpu accéléré par GPU doit être utilisé pour améliorer l’efficacité du processus de récupération des négatifs.

Étape 4 Entraînement

torchrun --nproc_per_node {nombre de gpus} \
-m FlagEmbedding.baai_general_embedding.finetune.run \
--output_dir {chemin pour sauvegarder le modèle} \
--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 {grande taille de lot; mettre 1 pour des données factices} \
--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 ""

• Taille du lot d’entraînement par périphérique : La quantité d’échantillons traités dans chaque lot d’entraînement. Généralement, une taille de lot plus élevée améliore les performances du modèle. Vous pouvez augmenter cette taille en utilisant des options telles que l’entraînement en demi-précision (--fp16), la configuration DeepSpeed (--deepspeed ./df_config.json, où df_config.json peut aussi être nommé ds_config.json), et le point de contrôle par gradient (--gradient_checkpointing).
• Taille du groupe d’entraînement : Détermine le nombre total d’exemples, à la fois positifs et négatifs, utilisés pour chaque requête pendant l’entraînement. Comme il y a un exemple positif garanti, ce paramètre dicte le nombre d’exemples négatifs (calculé comme train_group_size - 1). Notez que ce nombre ne doit pas dépasser le nombre de négatifs disponibles dans la liste neg de vos données. En plus de ces négatifs de groupe, d’autres négatifs dans le lot sont également incorporés dans le processus de réglage fin.
• Partage de négatifs entre dispositifs : Permet de distribuer les exemples négatifs sur tous les GPU disponibles, augmentant ainsi le nombre total de négatifs utilisés en entraînement.
• Taux d’apprentissage : Choisissez une valeur adaptée à votre modèle spécifique. Pour les modèles large, base ou small, des valeurs comme 1e-5, 2e-5 ou 3e-5 sont généralement recommandées.
• Température : Affecte la dispersion de la distribution des scores de similarité. Les valeurs suggérées vont de 0.01 à 0.1.
• Longueur maximale de la requête : La limite supérieure pour la longueur de la requête, qui doit correspondre à la longueur moyenne des requêtes dans votre jeu de données.
• Longueur maximale du passage : La limite supérieure pour la longueur du passage, définie en fonction de la longueur moyenne des passages dans vos données.
• Instruction de requête de récupération : Une directive optionnelle ajoutée à chaque requête à des fins de récupération. Vous pouvez la laisser vide en la définissant comme une chaîne vide si aucun contexte supplémentaire n’est nécessaire.
• Utilisation de négatifs intra-lot : Un indicateur précisant si les passages du même lot doivent être considérés comme des exemples négatifs dans l’entraînement. Le paramètre par défaut est activé (True).
• Intervalle de sauvegarde des points de contrôle : Définit la fréquence de sauvegarde des points de contrôle du modèle en fonction du nombre d’étapes d’entraînement effectuées.

Étape 5 Chargement du modèle

Une fois le modèle BGE affiné, vous pouvez le charger facilement comme illustré dans cet exemple. Si vous avez spécifié une valeur unique pour l’hyperparamètre --query_instruction_for_retrieval pendant la phase de réglage fin, assurez-vous de substituer query_instruction_for_retrieval en conséquence.

Étape 6 Évaluation du modèle

Pour l’évaluation du modèle, vous pouvez exécuter ce script fourni par FlagEmbedding.

Ajuster le modèle bge de base via le réglage fin peut conduire à de meilleures performances spécifiques à la tâche, mais peut aussi entraîner une baisse notable de l’efficacité globale du modèle en dehors du domaine ciblé (par exemple, une baisse de performance sur les tâches c-mteb). Pour plus d’informations sur la solution (utilisant LM-Cocktail) ainsi que sur le processus de réglage fin, consultez « FlagEmbedding/examples/finetune » sur Github.

Comment intégrer bge-large-en-v1.5 avec une API LLM ?

Intégrer un modèle d’embedding avec un LLM enrichit les capacités de traitement du langage naturel de l’IA, permettant une recherche sémantique plus sophistiquée, une compréhension contextuelle et des interactions personnalisées. Cette intégration est particulièrement utile pour améliorer des tâches telles que les recommandations basées sur le contenu, le regroupement de documents, la détection d’anomalies, le traitement multilingue et la construction de graphes de connaissances. Elle prend également en charge le résumé avancé de texte et l’amélioration des caractéristiques pour les modèles d’apprentissage automatique, conduisant à de meilleures performances dans l’analyse des sentiments et la classification de sujets.

Étape 1 : Configurer votre environnement

Assurez-vous d’avoir l’environnement Python nécessaire avec les paquets requis installés.

pip install openai
# Installer d’autres paquets nécessaires, par ex., requests, numpy, etc.

Étape 2 : Initialiser le client API Novita AI

Vous avez déjà fourni le code pour initialiser le client API Novita AI. Le voici pour référence :

from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    api_key="<YOUR Novita AI API Key>",  # Remplacez par votre vraie clé API
)
model = "nousresearch/nous-hermes-llama2-13b"

Étape 3 : Obtenir le modèle d’embedding

En supposant que vous ayez accès au modèle bge-large-en-v1.5, vous le chargeriez. S’il s’agit d’un modèle Hugging Face, vous pouvez utiliser la bibliothèque transformers comme ceci :

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")

Étape 4 : Définir une fonction pour obtenir des embeddings

Créez une fonction pour obtenir des embeddings à partir du modèle 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()

Étape 5 : Intégrer avec l’API LLM Novita AI

Maintenant, intégrez le modèle d’embedding avec l’API LLM pour améliorer les réponses de l’API ou effectuer des tâches comme la recherche sémantique.

def enhanced_llm_response(prompt):
    # Obtenir la réponse initiale du LLM
    response = client.completions.create(
        model=model,
        prompt=prompt,
        stream=True,
        max_tokens=512,
    )
    
    # Traiter la réponse (par ex., extraire le texte)
    # Ceci est un espace réservé pour le traitement réel de la réponse
    response_text = next(response)['choices'][0]['text'].content
    
    # Obtenir les embeddings pour la réponse
    response_embeddings = get_embeddings(response_text)
    
    # Ici, vous pouvez utiliser les embeddings à diverses fins,
    # comme la recherche sémantique, le filtrage, etc.
    
    return response_text, response_embeddings

Étape 6 : Utiliser la fonction améliorée

Vous pouvez maintenant utiliser la fonction enhanced_llm_response pour obtenir des réponses du LLM et les traiter avec le modèle d’embedding.

prompt = "A chat between a curious user and an artificial intelligence assistant"
response, embeddings = enhanced_llm_response(prompt)
print(response)
# Faire quelque chose avec les embeddings, par ex., les stocker, rechercher des textes similaires, etc.

Étape 7 : Gestion des erreurs et journalisation

Ajoutez une gestion des erreurs et une journalisation à votre code pour gérer les limites de l’API, les échecs de requête et d’autres problèmes potentiels.

Étape 8 : Tester et itérer

Testez l’intégration en profondeur et itérez en fonction des résultats. Vous devrez peut-être ajuster les paramètres, traiter davantage de cas particuliers ou optimiser les performances.

Veuillez noter que les détails réels de l’implémentation peuvent varier en fonction des capacités et des exigences spécifiques de l’API LLM Novita AI et du modèle bge-large-en-v1.5. Vous pouvez contacter l’équipe Novita AI pour un support technique : support@novita.ai.

Conclusion

En résumé, notre exploration de « bge-large-en-v1.5 » a mis en évidence son rôle central dans les tâches de récupération dense, offrant une plongée approfondie dans ses capacités, applications et implémentation pratique. De la présentation du modèle et de son importance dans le domaine de l’embedding à la démonstration de son utilisation en code et de son processus de réglage fin, nous avons fourni un guide complet. De plus, l’intégration avec l’API LLM Novita AI illustre le potentiel du modèle pour amplifier la compréhension sémantique et la précision de récupération des LLM.

Restez à l’écoute pour plus de mises à jour sur les LLM !

Questions fréquemment posées

1. Comment fonctionne un reranker BGE ?

En entrant une requête et un passage dans le reranker, vous obtenez un score de pertinence. Ce score peut être transformé en une valeur flottante dans l’intervalle [0, 1] à l’aide d’une fonction sigmoïde. Ce processus vise à garantir que les résultats les mieux classés soient plus pertinents et de meilleure qualité, améliorant ainsi les performances globales du système.

2. Quelle est la longueur de contexte de BGE ?

Le dernier modèle bge-m3 a une longueur de contexte de 8 ko.

3. Quelle est la taille de l’embedding bge m3 ?

Il peut traiter des entrées de longueurs variables, allant de phrases courtes à de longs documents contenant jusqu’à 8192 tokens.

Novita AI est la plateforme cloud tout-en-un qui stimule vos ambitions en IA. Grâce à des API intégrées de manière transparente, de l’informatique sans serveur et une accélération GPU, nous fournissons les outils rentables dont vous avez besoin pour développer et faire évoluer rapidement votre entreprise basée sur l’IA. Éliminez les problèmes d’infrastructure et commencez gratuitement — Novita AI fait de vos rêves d’IA une réalité.

Lectures recommandées

Qu’est-ce que les embeddings LLM : tout ce que vous devez savoir

Dévoiler la puissance de BGE Large : l’avenir de l’embedding de texte