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!