So erstellen Sie Ihr eigenes RAG mit kostenlosen LLM-Modellen und einer Wissensdatenbank

In diesem Artikel wird die Implementierung eines unkomplizierten, aber effektiven Frage-Antwort-Systems untersucht, das moderne transformatorbasierte Modelle kombiniert. Das System verwendet T5 (Text-to-Text Transfer Transformer) für die Antwortgenerierung und Satztransformatoren für den semantischen Ähnlichkeitsabgleich.

In meinem vorherigen Artikel habe ich erklärt, wie man mithilfe eines kostenlosen grundlegenden LLM-Modells eine einfache Übersetzungs-API mit einer Webschnittstelle erstellt. Lassen Sie uns dieses Mal in den Aufbau eines Retrieval-Augmented Generation (RAG)-Systems unter Verwendung kostenloser transformatorbasierter LLM-Modelle und einer Wissensdatenbank eintauchen.

RAG (Retrieval-Augmented Generation) ist eine Technik, die zwei Schlüsselkomponenten kombiniert:

Abruf: Zunächst wird eine Wissensdatenbank (wie Dokumente, Datenbanken usw.) durchsucht, um relevante Informationen für eine bestimmte Abfrage zu finden. Dies beinhaltet normalerweise:

• Text in Einbettungen (numerische Vektoren, die Bedeutung darstellen) umwandeln
• Suchen ähnlicher Inhalte mithilfe von Ähnlichkeitsmaßen (z. B. Kosinus-Ähnlichkeit)
• Auswahl der relevantesten Informationen

Generierung: Anschließend wird ein Sprachmodell (wie T5 in unserem Code) verwendet, um eine Antwort zu generieren durch:

Kombinieren der abgerufenen Informationen mit der ursprünglichen Frage

Erstellen einer Antwort in natürlicher Sprache basierend auf diesem Kontext

Im Code:

• Der SentenceTransformer übernimmt den Abrufteil durch die Erstellung von Einbettungen
• Das T5-Modell übernimmt den Generierungsteil durch die Erstellung von Antworten

Vorteile von RAG:

• Genauere Antworten, da sie auf spezifischem Wissen basieren
• Reduzierte Halluzinationen im Vergleich zu reinen LLM-Reaktionen
• Möglichkeit, auf aktuelle oder domänenspezifische Informationen zuzugreifen
• Kontrollierbarer und transparenter als die reine Generierung

Überblick über die Systemarchitektur

Die Implementierung besteht aus einer SimpleQASystem-Klasse, die zwei Hauptkomponenten orchestriert:

• Ein semantisches Suchsystem mit Satztransformatoren
• Ein Antwortgenerierungssystem mit T5

Sie können die neueste Version des Quellcodes hier herunterladen: https://github.com/alexander-uspenskiy/rag_project

Systemdiagramm

RAG-Projekt-Setup-Handbuch

Diese Anleitung hilft Ihnen beim Einrichten Ihres Retrieval-Augmented Generation (RAG)-Projekts sowohl unter macOS als auch unter Windows.

Voraussetzungen

Für macOS:

Homebrew installieren (falls noch nicht installiert):
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
Installieren Sie Python 3.8 mit Homebrew
brew install python@3.10
Für Windows:
Laden Sie Python 3.8 von python.org herunter und installieren Sie es
Stellen Sie sicher, dass Sie während der Installation „Python zu PATH hinzufügen“ aktivieren

Projekt-Setup

Schritt 1: Projektverzeichnis erstellen

macOS:

mkdir RAG_project
cd RAG_project
Windows:

mkdir RAG_project
cd RAG_project

Schritt 2: Virtuelle Umgebung einrichten

macOS:

python3 -m venv venv
Quelle venv/bin/activate

Windows:

python -m venv venv
venvScriptsactivate

**Kernkomponenten

1. Initialisierung**

def __init__(self):
    self.model_name = 't5-small'
    self.tokenizer = T5Tokenizer.from_pretrained(self.model_name)
    self.model = T5ForConditionalGeneration.from_pretrained(self.model_name)
    self.encoder = SentenceTransformer('paraphrase-MiniLM-L6-v2')

Das System initialisiert mit zwei Hauptmodellen:

T5-small: Eine kleinere Version des T5-Modells zur Generierung von Antworten
paraphrase-MiniLM-L6-v2: Ein Satztransformationsmodell zum Kodieren von Text in sinnvolle Vektoren

2. Datensatzvorbereitung

def prepare_dataset(self, data: List[Dict[str, str]]):
    self.answers = [item['answer'] for item in data]
    self.answer_embeddings = []
    for answer in self.answers:
        embedding = self.encoder.encode(answer, convert_to_tensor=True)
        self.answer_embeddings.append(embedding)

Die Datensatzvorbereitungsphase:

• Extrahiert Antworten aus den Eingabedaten
• Erstellt Einbettungen für jede Antwort mithilfe des Satztransformators
• Speichert sowohl Antworten als auch deren Einbettungen zum schnellen Abrufen

Wie das System funktioniert

1. Fragenbearbeitung

Wenn ein Benutzer eine Frage einreicht, führt das System die folgenden Schritte aus:

Einbettungsgenerierung: Die Frage wird in eine Vektordarstellung umgewandelt, wobei dasselbe Satztransformationsmodell verwendet wird, das für die Antworten verwendet wird.

Semantische Suche: Das System findet die relevanteste gespeicherte Antwort nach:

• Berechnung der Kosinusähnlichkeit zwischen der Frageneinbettung und allen Antworteinbettungen
• Auswahl der Antwort mit der höchsten Ähnlichkeitsbewertung Kontextbildung: Die ausgewählte Antwort wird zum Kontext für T5, um eine endgültige Antwort zu generieren.

2. Antwortgenerierung

def get_answer(self, question: str) -> str:
    # ... semantic search logic ...
    input_text = f"Given the context, what is the answer to the question: {question} Context: {context}"
    input_ids = self.tokenizer(input_text, max_length=512, truncation=True, 
                             padding='max_length', return_tensors='pt').input_ids
    outputs = self.model.generate(input_ids, max_length=50, num_beams=4, 
                                early_stopping=True, no_repeat_ngram_size=2

Der Antwortgenerierungsprozess:

• Kombiniert die Frage und den Kontext zu einer Eingabeaufforderung für T5
• Tokenisiert den Eingabetext mit einer maximalen Länge von 512 Token
• Erzeugt eine Antwort mithilfe der Strahlsuche mit diesen Parametern:
• max_length=50: Begrenzt die Antwortlänge
• num_beams=4: Verwendet Strahlsuche mit 4 Strahlen
• early_stopping=True: Stoppt die Generierung, wenn alle Strahlen ein End-Token erreichen
• no_repeat_ngram_size=2: Verhindert die Wiederholung von Bigrammen

3. Antwort Reinigung

def __init__(self):
    self.model_name = 't5-small'
    self.tokenizer = T5Tokenizer.from_pretrained(self.model_name)
    self.model = T5ForConditionalGeneration.from_pretrained(self.model_name)
    self.encoder = SentenceTransformer('paraphrase-MiniLM-L6-v2')

• Entfernt doppelte aufeinanderfolgende Wörter (ohne Berücksichtigung der Groß- und Kleinschreibung)
• Der erste Buchstabe der Antwort wird groß geschrieben
• Entfernt zusätzliche Leerzeichen

Vollständiger Quellcode

Sie können die neueste Version des Quellcodes hier herunterladen: https://github.com/alexander-uspenskiy/rag_project

def prepare_dataset(self, data: List[Dict[str, str]]):
    self.answers = [item['answer'] for item in data]
    self.answer_embeddings = []
    for answer in self.answers:
        embedding = self.encoder.encode(answer, convert_to_tensor=True)
        self.answer_embeddings.append(embedding)

Speicherverwaltung:

Das System nutzt explizit die CPU, um Speicherprobleme zu vermeiden
Einbettungen werden bei Bedarf in CPU-Tensoren umgewandelt
Die Eingabelänge ist auf 512 Token begrenzt

Fehlerbehandlung:

• Umfassende Try-Except-Blöcke im gesamten Code
• Aussagekräftige Fehlermeldungen zum Debuggen
• Validierungsprüfungen für nicht initialisierte Komponenten

Anwendungsbeispiel

def get_answer(self, question: str) -> str:
    # ... semantic search logic ...
    input_text = f"Given the context, what is the answer to the question: {question} Context: {context}"
    input_ids = self.tokenizer(input_text, max_length=512, truncation=True, 
                             padding='max_length', return_tensors='pt').input_ids
    outputs = self.model.generate(input_ids, max_length=50, num_beams=4, 
                                early_stopping=True, no_repeat_ngram_size=2

Im Terminal ausführen

Einschränkungen und mögliche Verbesserungen

Skalierbarkeit:

Die aktuelle Implementierung behält alle Einbettungen im Speicher
Könnte mit Vektordatenbanken für groß angelegte Anwendungen verbessert werden

Antwortqualität:

Hängt stark von der Qualität des bereitgestellten Antwortdatensatzes ab
Begrenzt durch das Kontextfenster von T5-small
Könnte von einer Antwortvalidierung oder einer Konfidenzbewertung profitieren

Leistung:

• Die alleinige Verwendung der CPU kann bei umfangreichen Anwendungen langsamer sein
• Könnte durch Stapelverarbeitung optimiert werden
• Könnte Caching für häufig gestellte Fragen implementieren

Abschluss

Diese Implementierung bietet eine solide Grundlage für ein Frage-Antwort-System und kombiniert die Stärken der semantischen Suche und der transformatorbasierten Textgenerierung. Spielen Sie gerne mit Modellparametern (wie max_length, num_beams, Early_stopping, no_repeat_ngram_size usw.), um einen besseren Weg zu finden, um kohärentere und stabilere Antworten zu erhalten. Obwohl es Raum für Verbesserungen gibt, bietet die aktuelle Implementierung ein gutes Gleichgewicht zwischen Komplexität und Funktionalität, sodass sie für Bildungszwecke und kleine bis mittlere Anwendungen geeignet ist.

Viel Spaß beim Codieren!

Das obige ist der detaillierte Inhalt vonSo erstellen Sie Ihr eigenes RAG mit kostenlosen LLM-Modellen und einer Wissensdatenbank. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!