Retrieval-gestütztes LLM der Spitzenklasse: bge-large-en-v1.5

Einleitung

Sind Sie neugierig auf das hochmoderne retrieval-gestützte LLM ‚bge-large-en-v1.5‘? Begleiten Sie uns in diesem Blog, während wir dieses Modell eingehend erkunden. Sie werden die Rolle von Embedding-Modellen und ihre praktischen Anwendungen entdecken. Wir führen Sie durch die Bereitstellung von ‚bge-large-en-v1.5‘ im Code, das Feintuning und die nahtlose Integration mit der LLM-API. Machen Sie sich bereit, neue Möglichkeiten an der Schnittstelle von Embedding-Modellen und LLMs zu erschließen!

Was ist bge-large-en-v1.5?

Kurz gesagt, bge-large-en-v1.5 ist ein von BAAI entwickeltes Open-Source-Embedding-Modell.

Genauer gesagt steht ‚bge‘ in ‚bge-large-en-v1.5‘ für ‚BAAI General Embedding‘. BAAI, auf Github auch als ‚FlagEmbedding‘ bekannt, ist eine private gemeinnützige Organisation, die sich der KI-Forschung und -Entwicklung widmet. Mit einem Fokus auf retrieval-gestützte Large Language Models (LLMs) hat BAAI mehrere verwandte Projekte gestartet. Dazu gehören Long-Context-LLM (Activation Beacon), LM-Feintuning (LM-Cocktail), Dense Retrieval (BGE-M3, LLM Embedder, BGE Embedding), Reranker-Modell (BGE Reranker) und Benchmarking (C-MTEB). Bge-large-en-v1.5 gehört zur BGE-Embedding-Modellreihe und wurde speziell für Dense Retrieval entwickelt.

Was macht ein Embedding-Modell für Dense Retrieval?

Ein Embedding-Modell für Dense Retrieval wandelt Textdaten in dichte, semantische Repräsentationen um, die die Bedeutung und den Kontext der Eingabe erfassen. Diese dichten Repräsentationen werden von einem Dense Retriever verwendet, um relevante Informationen effizient abzurufen. So funktioniert es und einige Beispiele:

Umwandlung von Text in dichte Repräsentationen

Das Embedding-Modell nimmt Sätze, Absätze oder ganze Dokumente als Eingabe und wandelt sie in Vektoren (Embeddings) fester Länge um. Diese Vektoren kodieren semantische Informationen über den Text und ermöglichen ein nuancierteres Verständnis, das über einfache Schlüsselwortübereinstimmungen hinausgeht.

LLMs integrieren oft Embedding-Modelle als Teil ihrer Architektur. Beispielsweise verwendet BERT Embedding-Techniken, um Wörter und Eingabesequenzen darzustellen, bevor sie durch seine Transformer-Schichten verarbeitet werden. LLMs profitieren von Embedding-Modellen, indem sie deren Fähigkeit nutzen, semantische Beziehungen und kontextuelle Nuancen zu erfassen, die für die Generierung kohärenter und kontextuell angemessener Antworten bei Aufgaben wie Dialogsynthese oder maschineller Übersetzung entscheidend sind.

Rolle des Dense Retrievers

Der Dense Retriever verwendet diese Embeddings, um Retrieval-Aufgaben durchzuführen. Im Gegensatz zu traditionellen Sparse-Retrieval-Methoden, die auf exakten Schlüsselwortübereinstimmungen oder Indizes basieren, berechnet ein Dense Retriever Ähnlichkeitswerte direkt zwischen Query-Embeddings und Dokument-Embeddings. Dieser Ansatz ermöglicht eine genauere Abfrage über verschiedene Textlängen hinweg, von kurzen Sätzen bis zu langen Dokumenten.

Beispiele für Anwendungen

Bei Information-Retrieval-Aufgaben wie Suchmaschinen oder Frage-Antwort-Systemen ermöglichen diese dichten Repräsentationen ein effizientes und genaues Auffinden relevanter Dokumente oder Passagen.

Beispielsweise kann eine Frage wie „Welche Symptome hat COVID-19?“ in einen Embedding-Vektor umgewandelt werden. Ebenso werden Dokumente, die COVID-19-Symptome diskutieren, in Embeddings umgewandelt. Durch den Vergleich der Ähnlichkeit zwischen dem Query-Embedding und den Dokument-Embeddings (mithilfe von Techniken wie Kosinus-Ähnlichkeit) können die relevantesten Dokumente schnell identifiziert und eingestuft werden.

Ein weiteres Beispiel sind Empfehlungssysteme. Hier helfen Embeddings dabei, Produkte, Artikel oder Videos zu empfehlen, indem sie Benutzerpräferenzen und Inhaltsähnlichkeiten verstehen.

Insgesamt spielen Embedding-Modelle für Dense Retrieval, gekoppelt mit Dense Retrievern, eine entscheidende Rolle in modernen KI-Anwendungen, indem sie Text in bedeutungsvolle Repräsentationen umwandeln und relevante Informationen basierend auf semantischer Ähnlichkeit effizient abrufen.

Wie kann ich bge-large-en-v1.5 im Code verwenden?

Verwendung von bge-large-en-v1.5 mit Langchain

Sie können bge in langchain wie folgt verwenden:

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

Verwendung von bge-large-en-v1.5 mit Huggingface Transformers

Mit dem transformers-Paket können Sie das Modell wie folgt verwenden: Zuerst geben Sie Ihre Eingabe durch das Transformer-Modell, dann wählen Sie den letzten versteckten Zustand des ersten Tokens (d.h. [CLS]) als Satz-Embedding.

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)

Weitere Informationen zur Verwendung von bge-Modellen finden Sie auf FlagEmbedding auf Github.

Wie kann ich bge-large-en-v1.5 feintunen?

Schritt 1 Installation

• Installation mit pip: pip install -U FlagEmbedding
• Oder Installation aus dem Quellcode nach dem Klonen des Repositorys und Navigieren hinein: pip install .
• Für die Entwicklung verwenden Sie eine bearbeitbare Installation: pip install -e .

Schritt 2 Datenvorbereitung

• Die Trainingsdaten sollten im JSON-Format vorliegen, wobei jede Zeile ein Wörterbuch mit query, pos (Liste positiver Texte) und neg (Liste negativer Texte) enthält.
• Wenn keine negativen Texte verfügbar sind, können sie zufällig aus dem Korpus ausgewählt werden.

Schritt 3 Mining harter Negativbeispiele

• Verwenden Sie ein Skript, um harte Negativbeispiele zu minen und die Qualität der Satz-Embeddings zu verbessern.
• Sie können harte Negativbeispiele mit folgendem Befehl minen:

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

• Eingabedatei: Eine JSON-Datei mit Daten zum Feintuning, in der das Skript die Top-k-Dokumente pro Query identifiziert und dann zufällig negative Beispiele aus diesen Top-k-Ergebnissen auswählt, mit Ausnahme der bereits bereitgestellten positiven Beispiele.
• Ausgabedatei: Das Ziel, in dem die JSON-Datei, nun angereichert mit den neu abgebauten harten Negativbeispielen, für den Feintuning-Prozess gespeichert wird.
• Anzahl der Negativbeispiele: Gibt an, wie viele negative Stichproben gesammelt werden sollen.
• Stichprobenbereich: Definiert den Umfang, aus dem die negativen Stichproben gezogen werden. Zum Beispiel bedeutet ein Bereich von 2–100, dass Negativbeispiele aus den Top-2- bis Top-200-Dokumenten entnommen werden. Eine Vergrößerung dieses Bereichs, z. B. auf 60–300, macht die Auswahl von Negativbeispielen weniger anspruchsvoll, indem eine breitere Menge von Dokumenten berücksichtigt wird.
• Retrieval-Pool: Die Quelle, aus der das Skript Dokumente für das Retrieval bezieht. Standardmäßig ist dies die Menge aller Negativbeispiele in der Eingabedatei, formatiert wie die Vortrainingsdaten. Wenn ein bestimmter Retrieval-Pool angegeben wird, verwendet das Skript diese Menge, um negative Beispiele zu finden.
• GPU-basierte Suche: Eine Option, die angibt, ob GPU-beschleunigtes faiss-gpu verwendet werden soll, um die Effizienz des Negativ- Retrieval-Prozesses zu steigern.

Schritt 4 Training

torchrun --nproc_per_node {Anzahl der GPUs} \
-m FlagEmbedding.baai_general_embedding.finetune.run \
--output_dir {Pfad zum Speichern des Modells} \
--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 {große Batchgröße; für Beispieldaten auf 1 setzen} \
--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 ""

• Trainings-Batchgröße pro Gerät: Die Anzahl der Proben, die in jedem Trainingsbatch verarbeitet werden. Eine größere Batchgröße verbessert in der Regel die Modellleistung. Sie können diese Größe erhöhen, indem Sie Optionen wie Halbpräzisionstraining (--fp16), DeepSpeed-Konfiguration (--deepspeed ./df_config.json, wobei df_config.json auch als ds_config.json bezeichnet werden kann) und Gradient Checkpointing (--gradient_checkpointing) verwenden.
• Trainingsgruppengröße: Bestimmt die Gesamtzahl der Beispiele (sowohl positive als auch negative), die pro Query während des Trainings verwendet werden. Da es ein garantiertes positives Beispiel gibt, bestimmt diese Einstellung die Anzahl der negativen Beispiele (berechnet als train_group_size - 1). Beachten Sie, dass diese Anzahl die verfügbaren Negativbeispiele in der neg-Liste Ihrer Daten nicht überschreiten sollte. Zusätzlich zu diesen Gruppen-Negativbeispielen werden auch andere Negativbeispiele innerhalb des Batches in den Feintuning-Prozess einbezogen.
• Geräteübergreifendes Negativ-Sharing: Ermöglicht die Verteilung von Negativbeispielen über alle verfügbaren GPUs, wodurch die Gesamtzahl der im Training verwendeten Negativbeispiele effektiv erhöht wird.
• Lernrate: Wählen Sie einen Wert, der zu Ihrem spezifischen Modell passt. Für große, Basis- oder kleine Modelle werden typischerweise Werte wie 1e-5, 2e-5 oder 3e-5 empfohlen.
• Temperatur: Beeinflusst die Streuung der Ähnlichkeitsbewertungsverteilung. Empfohlene Werte reichen von 0,01 bis 0,1.
• Maximale Query-Länge: Die Obergrenze für die Query-Länge, die der durchschnittlichen Query-Länge in Ihrem Datensatz entsprechen sollte.
• Maximale Passage-Länge: Die Obergrenze für die Passage-Länge, die gemäß der durchschnittlichen Länge der Passagen in Ihren Daten festgelegt wird.
• Retrieval-Query-Anweisung: Eine optionale Anweisung, die jeder Query zu Retrieval-Zwecken hinzugefügt wird. Sie können sie leer lassen, indem Sie sie auf eine leere Zeichenkette setzen, wenn kein zusätzlicher Kontext benötigt wird.
• In-Batch-Negativ-Nutzung: Ein Flag, das angibt, ob Passagen aus demselben Batch als negative Beispiele im Training betrachtet werden sollen. Die Standardeinstellung ist aktiviert (True).
• Checkpoint-Speicherintervall: Definiert die Häufigkeit des Speicherns von Modell-Checkpoints basierend auf der Anzahl der abgeschlossenen Trainingsschritte.

Schritt 5 Modell laden

Sobald das BGE-Modell feinabgestimmt wurde, können Sie es mühelos laden, wie in diesem Beispiel gezeigt. Wenn Sie während der Feintuning-Phase einen eindeutigen Wert für den Hyperparameter --query_instruction_for_retrieval angegeben haben, stellen Sie sicher, dass Sie query_instruction_for_retrieval entsprechend ersetzen.

Schritt 6 Modell laden

Für die Modellevaluierung können Sie dieses Skript von FlagEmbedding ausführen.

Das Anpassen des grundlegenden bge-Modells durch Feintuning kann zu einer besseren aufgabenspezifischen Leistung führen, könnte aber auch zu einem merklichen Rückgang der Gesamteffektivität des Modells außerhalb des Zielbereichs führen (z. B. ein Leistungsabfall bei c-mteb-Aufgaben). Informationen zur Lösung (Verwendung von LM-Cocktail) sowie zum Feintuning-Prozess finden Sie unter „FlagEmbedding/examples/finetune“ auf Github.

Wie kann ich bge-large-en-v1.5 in die LLM-API integrieren?

Die Integration eines Embedding-Modells in ein LLM erweitert die Fähigkeiten der KI zur Verarbeitung natürlicher Sprache und ermöglicht anspruchsvollere semantische Suchen, kontextuelles Verständnis und personalisierte Interaktionen. Diese Integration ist besonders nützlich, um Aufgaben wie inhaltsbasierte Empfehlungen, Dokumenten-Clustering, Anomalieerkennung, sprachübergreifende Verarbeitung und den Aufbau von Wissensgraphen zu verbessern. Sie unterstützt auch fortgeschrittene Textzusammenfassungen und die Merkmalsverbesserung für maschinelle Lernmodelle, was zu einer verbesserten Leistung bei der Stimmungsanalyse und Themenklassifizierung führt.

Schritt 1: Einrichten Ihrer Umgebung

Stellen Sie zunächst sicher, dass Sie die erforderliche Python-Umgebung mit den benötigten Paketen installiert haben.

pip install openai
# Installieren Sie andere notwendige Pakete, z.B. requests, numpy usw.

Schritt 2: Initialisieren des Novita AI API-Clients

Sie haben bereits den Code zur Initialisierung des Novita AI API-Clients bereitgestellt. Hier ist er als Referenz:

from openai import OpenAI

client = OpenAI(
    base_url="https://api.novita.ai/v3/openai",
    api_key="<IHR Novita AI API-Schlüssel>",  # Ersetzen Sie dies durch Ihren tatsächlichen API-Schlüssel
)
model = "nousresearch/nous-hermes-llama2-13b"

Schritt 3: Embedding-Modell abrufen

Angenommen, Sie haben Zugriff auf das Modell bge-large-en-v1.5, würden Sie es laden. Wenn es sich um ein Hugging-Face-Modell handelt, könnten Sie die transformers-Bibliothek wie folgt verwenden:

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

Schritt 4: Definieren einer Funktion zum Abrufen von Embeddings

Erstellen Sie eine Funktion, um Embeddings aus dem bge-large-en-v1.5-Modell zu erhalten.

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

Schritt 5: Integration mit der Novita AI LLM-API

Integrieren Sie nun das Embedding-Modell mit der LLM-API, um die Antworten der API zu verbessern oder Aufgaben wie semantische Suche durchzuführen.

def enhanced_llm_response(prompt):
    # Erste Antwort vom LLM abrufen
    response = client.completions.create(
        model=model,
        prompt=prompt,
        stream=True,
        max_tokens=512,
    )
    
    # Antwort verarbeiten (z.B. Text extrahieren)
    # Dies ist ein Platzhalter für die tatsächliche Antwortverarbeitung
    response_text = next(response)['choices'][0]['text'].content
    
    # Embeddings für die Antwort abrufen
    response_embeddings = get_embeddings(response_text)
    
    # Hier können Sie die Embeddings für verschiedene Zwecke verwenden,
    # wie semantische Suche, Filterung usw.
    
    return response_text, response_embeddings

Schritt 6: Verwendung der erweiterten Funktion

Jetzt können Sie die Funktion enhanced_llm_response verwenden, um Antworten vom LLM zu erhalten und sie mit dem Embedding-Modell zu verarbeiten.

prompt = "Ein Gespräch zwischen einem neugierigen Benutzer und einem KI-Assistenten"
response, embeddings = enhanced_llm_response(prompt)
print(response)
# Machen Sie etwas mit den Embeddings, z.B. speichern, nach ähnlichen Texten suchen usw.

Schritt 7: Fehlerbehandlung und Protokollierung

Fügen Sie Ihrem Code Fehlerbehandlung und Protokollierung hinzu, um API-Limits, Anforderungsfehler und andere potenzielle Probleme zu verwalten.

Schritt 8: Testen und Iterieren

Testen Sie die Integration gründlich und iterieren Sie basierend auf den Ergebnissen. Möglicherweise müssen Sie Parameter anpassen, weitere Randfälle behandeln oder die Leistung optimieren.

Bitte beachten Sie, dass die tatsächlichen Implementierungsdetails je nach den spezifischen Fähigkeiten und Anforderungen der Novita AI LLM-API und des bge-large-en-v1.5-Modells variieren können. Sie können das Novita AI Team für technischen Support kontaktieren: support@novita.ai.

Fazit

Zusammenfassend hat unsere Untersuchung von ‚bge-large-en-v1.5‘ seine integrale Rolle bei Dense-Retrieval-Aufgaben hervorgehoben und einen tiefen Einblick in seine Fähigkeiten, Anwendungen und praktische Implementierung geboten. Von der Einführung des Modells und seiner Bedeutung im Bereich der Embeddings bis hin zur Demonstration seiner Verwendung im Code und des Feintuning-Prozesses haben wir einen umfassenden Leitfaden erstellt. Darüber hinaus veranschaulicht die Integration mit der Novita AI LLM-API das Potenzial des Modells, das semantische Verständnis und die Retrieval-Genauigkeit von LLMs zu verbessern.

Bleiben Sie dran für weitere Updates zu LLMs!

Häufig gestellte Fragen

1. Wie funktioniert ein BGE Reranker?

Durch die Eingabe einer Query und einer Passage in den Reranker erhalten Sie einen Relevanzwert. Dieser Wert kann mithilfe einer Sigmoidfunktion in einen Gleitkommawert im Bereich [0, 1] umgewandelt werden. Dieser Prozess zielt darauf ab, dass die am höchsten eingestuften Ergebnisse relevanter und von höherer Qualität sind, was die Gesamtsystemleistung verbessert.

2. Was ist die Kontextlänge von BGE?

Das neueste Modell bge-m3 hat eine Kontextlänge von 8 KB.

3. Wie groß ist das bge-m3-Embedding?

Es kann Eingaben unterschiedlicher Länge verarbeiten, von kurzen Sätzen bis hin zu langen Dokumenten mit bis zu 8192 Token.

Novita AI ist die All-in-One-Cloud-Plattform, die Ihre KI-Ambitionen verwirklicht. Mit nahtlos integrierten APIs, serverlosem Computing und GPU-Beschleunigung bieten wir die kosteneffektiven Tools, die Sie benötigen, um Ihr KI-gesteuertes Unternehmen schnell aufzubauen und zu skalieren. Beseitigen Sie Infrastruktur-Herausforderungen und starten Sie kostenlos – Novita AI macht Ihre KI-Träume wahr.

Empfohlene Lektüre

Was sind LLM-Embeddings: Alles, was Sie wissen müssen

Die Macht von BGE Large enthüllen: Die Zukunft des Text-Embeddings