über die Small-World-Experimentdirigiert von Stanley Milgram in den 1960er Jahren. Er erfand ein Experiment, bei dem ein Temporary an einen Freiwilligen in den Vereinigten Staaten geschickt wurde, mit der Anweisung, den Temporary an seinen persönlichen Ansprechpartner weiterzuleiten, der höchstwahrscheinlich eine andere Particular person – die Zielperson – im selben Land kannte. Im Gegenzug würde die Particular person, die den Temporary erhält, aufgefordert, den Temporary erneut weiterzuleiten, bis die Zielperson erreicht ist. Obwohl die meisten Briefe die Zielperson nie erreichten, lag die durchschnittliche Anzahl der Sprünge bei denjenigen, die dies erreichten (Hier ist Überlebensbias im Spiel!), bei etwa 6. Die „sechs Grade der Trennung“ sind zu einem kulturellen Hinweis auf die enge Vernetzung der Gesellschaft geworden.

Ich bin immer noch erstaunt über den Gedanken, dass Menschen mit ~10² Kontakte schaffen es, sich mit einer zufälligen Particular person in einem Netzwerk von ~10 zu verbinden⁸ Leute, durch ein paar Sprünge.

Wie ist das möglich? Heuristiken.

Nehmen wir an, ich werde gebeten, einen Temporary an eine Zielperson in Finnland zu senden¹.

Leider habe ich keine Kontakte in Finnland. Andererseits kenne ich jemanden, der viele Jahre in Schweden gelebt hat. Vielleicht kennt sie Leute in Finnland. Wenn nicht, hat sie wahrscheinlich immer noch Kontakte in Schweden, einem Nachbarland. Sie ist meine beste Wahl, um der Zielperson näher zu kommen. Der Punkt ist: Obwohl ich die Topologie des sozialen Netzwerks über meine persönlichen Kontakte hinaus nicht kenne, kann ich den Temporary mithilfe von Faustregeln in die richtige Richtung weiterleiten.

Wenn wir den Standpunkt der Knoten des Netzwerks (der am Experiment beteiligten Menschen) einnehmen, bestehen ihre verfügbaren Aktionen darin, die Nachricht (den Temporary) an einen ihrer ausgehenden Kanten (persönliche Kontakte) weiterzuleiten. Dieses Drawback der Übermittlung der Nachricht in die richtige Richtung bietet die Möglichkeit, Spaß am maschinellen Lernen zu haben!

Knoten nehmen nicht die gesamte Netzwerktopologie wahr. Wir können eine Umgebung einrichten, die sie dafür belohnt, dass sie die Nachricht auf dem kürzesten bekannten Weg weiterleiten, und sie gleichzeitig dazu ermutigt, suboptimale Kandidatenpfade zu erkunden. Das klingt nach einem großartigen Anwendungsfall für Reinforcement Studying, finden Sie nicht?

Wer daran interessiert ist, den Code auszuführen, kann das Repo erreichen Hier.

Das Drawback

Wir erhalten einen gerichteten Graphen, in dem die Kanten zwischen den Knoten dünn besetzt sind, was bedeutet, dass die durchschnittliche Anzahl der von einem Knoten ausgehenden Kanten deutlich kleiner ist als die Anzahl der Knoten. Darüber hinaus sind mit den Kanten Kosten verbunden. Diese zusätzliche Funktion verallgemeinert den Fall des Small-World-Experiments, bei dem jeder Sprung des Buchstabens mit Kosten von 1 gezählt wurde.

Das Drawback, das wir betrachten werden, besteht darin, einen Reinforcement-Studying-Algorithmus zu entwerfen, der einen Pfad von einem beliebigen Startknoten zu einem beliebigen Zielknoten in einem spärlich besetzten gerichteten Graphen findet, und zwar mit möglichst geringen Kosten, sofern ein solcher Pfad existiert. Für dieses Drawback gibt es deterministische Lösungen. Zum Beispiel, Dijkstras Algorithmus findet den kürzesten Weg von einem Startknoten zu allen anderen Knoten in einem gerichteten Graphen. Dies wird nützlich sein, um die Ergebnisse unseres Reinforcement-Studying-Algorithmus auszuwerten, der nicht garantiert die optimale Lösung findet.

Q-Studying

Q-Studying ist eine Technik des Verstärkungslernens, bei der ein Agent eine Tabelle mit Zustands-Aktionspaaren verwaltet, die mit der erwarteten abgezinsten kumulativen Belohnung verknüpft sind – der Qualitätdaher die Q-Lernen. Durch iterative Experimente wird die Tabelle aktualisiert, bis ein Stoppkriterium erfüllt ist. Nach dem Coaching kann der Agent die Aktion (die Spalte der Q-Matrix) auswählen, die der maximalen Qualität für einen bestimmten Zustand (die Zeile der Q-Matrix) entspricht.

Die Aktualisierungsregel, vorausgesetzt eine Testaktion a_Jwas zum Übergang vom Zustand führt s_ich angeben s_okayeine Belohnung rund eine beste Schätzung der Qualität des nächsten Zustands s_okayIst:

( Q(i, j) leftarrow (1 – alpha) Q(i, j) + alpha left( r + gamma max_{l} Q(okay, l) proper) )

_{Gleichung 1: Die Aktualisierungsregel für Q-Studying.}

In Gleichung 1:

• α ist die Lernrate, die steuert, wie schnell neue Ergebnisse alte Qualitätsschätzungen löschen.
• γ ist der Abzinsungsfaktor, der steuert, wie hoch zukünftige Belohnungen im Vergleich zu unmittelbaren Belohnungen ausfallen.
• Q ist die Qualitätsmatrix. Der Zeilenindex i ist der Index des Ursprungszustands und der Spaltenindex j ist der Index der ausgewählten Aktion.

Kurz gesagt besagt Gleichung 1, dass die Qualität von (Zustand, Aktion) teilweise mit einem neuen Qualitätswert aktualisiert werden sollte, der sich aus der Summe der unmittelbaren Belohnung und der diskontierten Schätzung der maximalen Qualität des nächsten Zustands über mögliche Aktionen ergibt.

Für unsere Problemstellung wäre eine mögliche Formulierung für den Zustand das Paar (aktueller Knoten, Zielknoten) und die Menge der Aktionen wäre die Menge der Knoten. Der Zustandssatz würde dann enthalten N² Werte, und der Aktionssatz würde enthalten N Werte, wo N ist die Anzahl der Knoten. Da der Graph jedoch dünn besetzt ist, weist ein gegebener Ursprungsknoten nur eine kleine Teilmenge von Knoten als ausgehende Kanten auf. Diese Formulierung würde zu a führen Q-Matrix, in der die große Mehrheit der N³ Einträge werden nie besucht, was unnötig Speicher verbraucht.

Verteilte Agenten

Eine bessere Ressourcennutzung besteht darin, die Agenten zu verteilen. Jeder Knoten kann als Agent betrachtet werden. Der Standing des Agenten ist der Zielknoten, daher auch sein Q-Matrix hat N Reihen und N_aus Spalten (die Anzahl der ausgehenden Kanten für diesen bestimmten Knoten). Mit N Agenten beträgt die Gesamtzahl der Matrixeinträge N²N_auswas niedriger ist als N³.

Zusammenfassend:

• Wir werden trainieren N Agenten, einen für jeden Knoten im Diagramm.
• Jeder Agent lernt a Q-Dimensionsmatrix (N x N_aus). Die Anzahl der ausgehenden Kanten (N_aus) kann von Knoten zu Knoten unterschiedlich sein. Für einen dünn zusammenhängenden Graphen gilt: N_aus << N.
• Die Zeilenindizes der Q-Matrix entspricht dem Zustand des Agenten, additionally des Zielknotens.
• Die Spaltenindizes der Q-Matrix entsprechen der ausgehenden Kante, die von einem Agenten ausgewählt wird, um eine Nachricht an den Zielknoten weiterzuleiten.
• Q(i, j) stellt die Einschätzung eines Knotens hinsichtlich der Qualität der Weiterleitung der Nachricht an seinen Knoten dar j^Th ausgehende Kante, vorausgesetzt, der Zielknoten ist i.
• Wenn ein Knoten eine Nachricht empfängt, schließt sie den Zielknoten ein. Da der Absender der vorherigen Nachricht nicht erforderlich ist, um die Weiterleitung der nächsten Nachricht zu bestimmen, wird er in letzterer nicht berücksichtigt.

Code

Die Kernklasse, der Knoten, wird benannt QNode.

class QNode:
    def __init__(self, number_of_nodes=0, connectivity_average=0, connectivity_std_dev=0, Q_arr=None, neighbor_nodes=None,
                 state_dict=None):
        if state_dict shouldn't be None:
            self.Q = state_dict('Q')
            self.number_of_nodes = state_dict('number_of_nodes')
            self.neighbor_nodes = state_dict('neighbor_nodes')
        else:  # state_dict is None
            if Q_arr is None:
                self.number_of_nodes = number_of_nodes
                number_of_neighbors = connectivity_average + connectivity_std_dev * np.random.randn()
                number_of_neighbors = spherical(number_of_neighbors)
                number_of_neighbors = max(number_of_neighbors, 2)  # A minimum of two out-connections
                number_of_neighbors = min(number_of_neighbors, self.number_of_nodes)  # No more than N connections
                self.neighbor_nodes = random.pattern(vary(self.number_of_nodes), number_of_neighbors)  # (1, 4, 5, ...)
                self.Q = np.zeros((self.number_of_nodes, number_of_neighbors))  # Optimistic initialization: all rewards can be destructive
                # q = self.Q(state, motion): state = goal node; motion = chosen neighbor node (transformed to column index) to route the message to

            else:  # state_dict is None and Q_arr shouldn't be None
                self.Q = Q_arr
                self.number_of_nodes = self.Q.form(0)
                self.neighbor_nodes = neighbor_nodes

Die Klasse QNode hat drei Felder: die Anzahl der Knoten im Diagramm, die Liste der ausgehenden Kanten und die Q-Matrix. Der Q-matrix wird mit Nullen initialisiert. Die von der Umwelt erhaltenen Belohnungen sind das Detrimental der Randkosten. Daher sind alle Qualitätswerte negativ. Aus diesem Grund ist die Initialisierung mit Nullen eine optimistische Initialisierung.

Wenn eine Nachricht eine erreicht QNode Objekt wählt es eine seiner ausgehenden Kanten durch das aus Epsilon-gierig Algorithmus. Wenn ε klein ist, wählt der Epsilon-Grasping-Algorithmus meistens die ausgehende Kante mit der höchsten aus Q-Wert. Hin und wieder wird eine ausgehende Kante zufällig ausgewählt:

def epsilon_greedy(self, target_node, epsilon):
        rdm_nbr = random.random()
        if rdm_nbr < epsilon:  # Random alternative
            random_choice = random.alternative(self.neighbor_nodes)
            return random_choice
        else:  # Grasping alternative
            neighbor_columns = np.the place(self.Q(target_node, :) == self.Q(target_node, :).max())(0)  # (1, 4, 5)
            neighbor_column = random.alternative(neighbor_columns)
            neighbor_node = self.neighbor_node(neighbor_column)
            return neighbor_node

Die andere Klasse ist der Graph, genannt QGraph.

class QGraph:
    def __init__(self, number_of_nodes=10, connectivity_average=3, connectivity_std_dev=0, cost_range=(0.0, 1.0),
                 maximum_hops=100, maximum_hops_penalty=1.0):
        self.number_of_nodes = number_of_nodes
        self.connectivity_average = connectivity_average
        self.connectivity_std_dev = connectivity_std_dev
        self.cost_range = cost_range
        self.maximum_hops = maximum_hops
        self.maximum_hops_penalty = maximum_hops_penalty
        self.QNodes = ()
        for node in vary(self.number_of_nodes):
            self.QNodes.append(QNode(self.number_of_nodes, self.connectivity_average, self.connectivity_std_dev))

        self.cost_arr = cost_range(0) + (cost_range(1) - cost_range(0)) * np.random.random((self.number_of_nodes, self.number_of_nodes))

Seine Hauptfelder sind die Liste der Knoten und das Array der Kantenkosten. Beachten Sie, dass die tatsächlichen Kanten Teil davon sind QNode Klasse, als Liste ausgehender Knoten.

Wenn wir einen Pfad von einem Startknoten zu einem Zielknoten generieren möchten, rufen wir auf QGraph.trajectory() Methode, die die aufruft QNode.epsilon_greedy() Verfahren:

    def trajectory(self, start_node, target_node, epsilon):
        visited_nodes = (start_node)
        prices = ()
        if start_node == target_node:
            return visited_nodes, prices
        current_node = start_node
        whereas len(visited_nodes) < self.maximum_hops + 1:
            next_node = self.QNodes(current_node).epsilon_greedy(target_node, epsilon)
            price = float(self.cost_arr(current_node, next_node))
            visited_nodes.append(next_node)
            prices.append(price)
            current_node = next_node
            if current_node == target_node:
                return visited_nodes, prices
        # We reached the utmost variety of hops
        return visited_nodes, prices

Der trajectory() Die Methode gibt die Liste der besuchten Knoten entlang des Pfads und die Liste der Kosten zurück, die den verwendeten Kanten zugeordnet sind.

Das letzte fehlende Stück ist die Aktualisierungsregel von Gleichung 1, die von implementiert wird QGraph.update_Q() Verfahren:

def update_Q(self, start_node, neighbor_node, alpha, gamma, target_node):
   price = self.cost_arr(start_node, neighbor_node)
   reward = -cost
   # Q_orig(goal, dest) <- (1 - alpha) Q_orig(goal, dest) + alpha * ( r + gamma * max_neigh' Q_dest(goal, neigh') )
   Q_orig_target_dest = self.QNodes(start_node).Q(target_node, self.QNodes(start_node).neighbor_column(neighbor_node))
   max_neigh_Q_dest_target_neigh = np.max(self.QNodes(neighbor_node).Q(target_node, :))
   updated_Q = (1 - alpha) * Q_orig_target_dest + alpha * (reward + gamma * max_neigh_Q_dest_target_neigh)
   self.QNodes(start_node).Q(target_node, self.QNodes(start_node).neighbor_column(neighbor_node)) = updated_Q

Um unsere Agenten zu schulen, durchlaufen wir iterativ die Paare von (start_node, target_node) mit einer inneren Schleife über die Nachbarknoten von start_nodeund wir rufen an update_Q().

Experimente und Ergebnisse

Beginnen wir mit einem einfachen Diagramm mit 12 Knoten und gerichteten gewichteten Kanten.

Aus Abbildung 1 können wir ersehen, dass der einzige eingehende Knoten für Knoten-1 Knoten-7 ist und der einzige eingehende Knoten für Knoten-7 Knoten-1 ist. Daher kann kein anderer Knoten außer diesen beiden Knoten-1 und Knoten-7 erreichen. Wenn ein anderer Knoten damit beauftragt wird, eine Nachricht an Knoten-1 oder Knoten-7 zu senden, springt die Nachricht im Diagramm herum, bis die maximale Anzahl von Hops erreicht ist. Wir gehen davon aus, dass es große destructive Auswirkungen geben wird Q-Werte in diesen Fällen.

Wenn wir unseren Graphen trainierenerhalten wir Statistiken über die Kosten und die Anzahl der Sprünge als Funktion der Epoche, wie in Abbildung 2:

Nach dem Coaching ist dies die Q-Matrix für Knoten-4:

Die Flugbahn von Knoten 4 zu beispielsweise Knoten 11 kann durch Aufrufen von ermittelt werden trajectory() Methode, Einstellung epsilon=0 für die gierige deterministische Lösung: (4, 3, 5, 11) für undiskontierte Gesamtkosten von 0,9 + 0,9 + 0,3 = 2,1. Der Dijkstra-Algorithmus gibt denselben Pfad zurück.

In einigen seltenen Fällen wurde der optimale Pfad nicht gefunden. Um beispielsweise von Knoten 6 zu Knoten 9 zu gelangen, gab eine bestimmte Instanz des trainierten Q-Graphen (6, 11, 0, 4, 10, 2, 9) für nicht diskontierte Gesamtkosten von 3,5 zurück, während der Dijkstra-Algorithmus (6, 0, 4, 10, 2, 9) für nicht diskontierte Gesamtkosten von 3,4 zurückgab. Wie bereits erwähnt, wird dies von einem iterativen Algorithmus erwartet

Abschluss

Wir haben das Small-World-Experiment als Drawback formuliert, den Pfad mit minimalen Kosten zwischen einem beliebigen Knotenpaar in einem dünn besetzten gerichteten Graphen mit gewichteten Kanten zu finden. Wir haben die Knoten als Q-Studying-Agenten implementiert, die durch die Aktualisierungsregel lernen, bei gegebenem Zielknoten die kostengünstigste Aktion durchzuführen.

Mit einem einfachen Diagramm haben wir gezeigt, dass das Coaching zu einer Lösung nahe der optimalen Lösung führte.

Vielen Dank für Ihre Zeit und zögern Sie nicht experimentieren Sie mit dem Code. Wenn Sie Ideen für unterhaltsame Anwendungen für Q-Studying haben, lassen Sie es mich bitte wissen!

---

¹ OK, ich gehe über das ursprüngliche Small-World-Experiment hinaus, das Small-Nation-Experiment heißen sollte.

Referenzen

Reinforcement Studying, Richard S. Sutton, Andrew G. Barto, MIT Press, 1998

Ich habe sowohl in einer Graphdatenbank als auch in einer SQL-Datenbank gearbeitet und dann verschiedene große Sprachmodelle (LLMs) verwendet, um Fragen zu den Daten durch einen Retrieval-Augmented Era (RAG)-Ansatz zu beantworten. Durch die Verwendung des gleichen Datensatzes und der gleichen Fragen in beiden Systemen konnte ich bewerten, welches Datenbankparadigma genauere und aufschlussreichere Ergebnisse liefert.

Retrieval-Augmented Era (RAG) ist ein KI-Framework, das große Sprachmodelle (LLMs) verbessert, indem es sie zulässt abrufen Informieren Sie sich über relevante externe Informationen, bevor Sie eine Antwort generieren. Anstatt sich ausschließlich darauf zu verlassen, worauf das Modell trainiert wurde, fragt RAG dynamisch eine Wissensquelle (in diesem Artikel eine SQL- oder Diagrammdatenbank) ab und integriert diese Ergebnisse in seine Antwort. Eine Einführung in RAG finden Sie hier Hier.

SQL-Datenbanken organisieren Daten in Tische bestehend aus Zeilen und Spalten. Jede Zeile stellt einen Datensatz dar und jede Spalte stellt ein Attribut dar. Beziehungen zwischen Tabellen werden mit definiert Schlüssel Und schließt sich anund alle Daten folgen einem festen Schema. SQL-Datenbanken eignen sich preferrred für strukturierte Transaktionsdaten, bei denen Konsistenz und Präzision wichtig sind – beispielsweise Finanzen, Inventar oder Patientenakten.

Graphdatenbanken speichern Daten als Knoten (Entitäten) und Kanten (Beziehungen) mit non-compulsory Eigenschaften an beide angeschlossen. Anstatt Tabellen zu verknüpfen, stellen sie Beziehungen direkt dar und ermöglichen so eine schnelle Durchquerung verbundener Daten. Graphdatenbanken eignen sich hervorragend zur Modellierung Netzwerke und Beziehungen – wie soziale Graphen, Wissensgraphen oder molekulare Interaktionskarten – bei denen Verbindungen genauso wichtig sind wie die Entitäten selbst.

Daten

Der Datensatz, den ich zum Vergleich der Leistung von RAGs verwendet habe, enthält Formel-1-Ergebnisse von 1950 bis 2024. Er enthält detaillierte Ergebnisse bei Rennen von Fahrern und Konstrukteuren (Groups), darunter Qualifikation, Sprintrennen, Hauptrennen und sogar Rundenzeiten und Boxenstoppzeiten. Auch der Stand der Fahrer- und Konstrukteurswertung nach jedem Rennen ist enthalten.

SQL-Schema

Dieser Datensatz ist bereits in Tabellen mit Schlüsseln strukturiert, so dass eine SQL-Datenbank einfach aufgebaut werden kann. Das Schema der Datenbank ist unten dargestellt:

Rennen ist die zentrale Tabelle, die mit allen Arten von Ergebnissen sowie zusätzlichen Informationen wie Saison und Strecken verknüpft ist. Die Ergebnistabellen sind ebenfalls mit verlinkt Treiber Und Konstrukteure Tabellen, um ihre Ergebnisse bei jedem Rennen aufzuzeichnen. Der Meisterschaftsstand nach jedem Rennen wird im gespeichert Fahrerwertung Und Konstruktorstatus Tische.

Diagrammschema

Das Schema der Diagrammdatenbank ist unten dargestellt:

Da Diagrammdatenbanken Informationen in Knoten und Beziehungen speichern können, sind im Vergleich zu 14 Tabellen der SQL-Datenbank nur sechs Knoten erforderlich. Der Auto Knoten ist ein Zwischenknoten, der verwendet wird, um zu modellieren, dass ein Fahrer bei einem bestimmten Rennen ein Auto eines Herstellers gefahren ist. Da sich Fahrer-Konstrukteur-Paare im Laufe der Zeit ändern, muss diese Beziehung für jedes Rennen definiert werden. Die Rennergebnisse werden in den Beziehungen gespeichert, z :RENNEN zwischen Auto Und Wettrennen. Während die :STOOD_AFTER Beziehungen enthalten die Fahrer- und Konstrukteurswertungsstände nach jedem Rennen.

Abfragen der Datenbank

Ich habe verwendet LangChain um eine RAG-Kette für beide Datenbanktypen zu erstellen, die eine Abfrage basierend auf einer Benutzerfrage generiert, die Abfrage ausführt und das Abfrageergebnis in eine Antwort für den Benutzer umwandelt. Der Code ist hier zu finden Repo. Ich habe eine generische Systemeingabeaufforderung definiert, mit der Abfragen für jede SQL- oder Diagrammdatenbank generiert werden können. Die einzigen datenspezifischen Informationen wurden durch Einfügen des automatisch generierten Datenbankschemas in die Eingabeaufforderung eingefügt. Die Systemaufforderungen sind zu finden Hier.

Hier ist ein Beispiel, wie man die Modellkette initialisiert und die Frage stellt: „Welcher Fahrer hat den 92. Grand Prix in Belgien gewonnen?“

from langchain_community.utilities import SQLDatabase
from langchain_openai import ChatOpenAI
from qa_chain import GraphQAChain
from config import DATABASE_PATH

# hook up with database
connection_string = f"sqlite:///{DATABASE_PATH}"
db = SQLDatabase.from_uri(connection_string)

# initialize LLM
llm = ChatOpenAI(temperature=0, mannequin="gpt-5")

# initialize qa chain
chain = GraphQAChain(llm, db, db_type='SQL', verbose=True)

# ask a query
chain.invoke("What driver gained the 92 Grand Prix in Belgium?")

Was zurückgibt:

{'write_query': {'question': "SELECT d.forename, d.surname
FROM outcomes r
JOIN races ra ON ra.raceId = r.raceId
JOIN drivers d ON d.driverId = r.driverId
WHERE ra.12 months = 1992
AND ra.title = 'Belgian Grand Prix'
AND r.positionOrder = 1
LIMIT 10;"}} 
{'execute_query': {'outcome': "(('Michael', 'Schumacher'))"}}
 {'generate_answer': {'reply': 'Michael Schumacher'}}

Die SQL-Abfrage fügt sich dem hinzu Ergebnisse, RennenUnd Treiber Tabellen, wählt das Rennen beim Großen Preis von Belgien 1992 und den Fahrer aus, der als Erster ins Ziel kam. Das LLM wandelte das Jahr 92 in 1992 und den Rennnamen von „Grand Prix in Belgien“ in „Belgischer Grand Prix“ um. Diese Konvertierungen wurden aus dem Datenbankschema abgeleitet, das drei Beispielzeilen jeder Tabelle enthielt. Das Abfrageergebnis ist „Michael Schumacher“, das das LLM als Antwort zurückgegeben hat.

Auswertung

Die Frage, die ich nun beantworten möchte, ist, ob ein LLM besser für die Abfrage der SQL- oder der Graphdatenbank geeignet ist. Ich habe drei Schwierigkeitsstufen definiert (einfach, mittel und schwer), wobei „einfach“ Fragen waren, die durch die Abfrage von Daten aus nur einer Tabelle oder einem Knoten beantwortet werden konnten, „mittel“ Fragen, die eine oder zwei Verknüpfungen zwischen Tabellen oder Knoten erforderten, und „schwere“ Fragen, die mehr Verknüpfungen oder Unterabfragen erforderten. Für jeden Schwierigkeitsgrad habe ich fünf Fragen definiert. Zusätzlich habe ich fünf Fragen definiert, die mit Daten aus der Datenbank nicht beantwortet werden konnten.

Ich habe jede Frage mit drei LLM-Modellen (GPT-5, GPT-4 und GPT-3.5-turbo) beantwortet, um zu analysieren, ob die fortschrittlichsten Modelle benötigt werden oder ob auch ältere und günstigere Modelle zu zufriedenstellenden Ergebnissen führen könnten. Wenn ein Modell die richtige Antwort gab, bekam es 1 Punkt, wenn es antwortete, dass es die Frage nicht beantworten konnte, bekam es 0 Punkte, und wenn es eine falsche Antwort gab, bekam es -1 Punkt. Alle Fragen und Antworten werden aufgelistet Hier. Nachfolgend finden Sie die Ergebnisse aller Modelle und Datenbanktypen:

Modell	Diagramm-DB	SQL-Datenbank
GPT-3.5-Turbo	-2	4
GPT-4	7	9
GPT-5	18	18

Es ist bemerkenswert, wie fortgeschrittenere Modelle einfachere Modelle übertreffen: GPT-3-turbo hat etwa die Hälfte der Fragen falsch beantwortet, GPT-4 hat 2 bis 3 Fragen falsch beantwortet, konnte aber 6 bis 7 Fragen nicht beantworten, und GPT-5 hat bis auf eine Frage alle Fragen richtig beantwortet. Einfachere Modelle scheinen mit einer SQL-Datenbank eine bessere Leistung zu erbringen als mit einer Graphdatenbank, während GPT-5 mit beiden Datenbanken die gleiche Punktzahl erzielte.

Die einzige Frage, die GPT-5 bei der Verwendung der SQL-Datenbank falsch gestellt hat, battle „Welcher Fahrer hat die meisten Weltmeisterschaften gewonnen?“. Die Antwort „Lewis Hamilton, mit 7 Weltmeisterschaften“ ist nicht korrekt, da Lewis Hamilton und Michael Schumacher 7 Weltmeisterschaften gewonnen haben. Die generierte SQL-Abfrage aggregierte die Anzahl der Meisterschaften nach Fahrer, sortierte sie in absteigender Reihenfolge und wählte nur die erste Zeile aus, während der Fahrer in der zweiten Zeile die gleiche Anzahl an Meisterschaften hatte.

Die einzige Frage, die GPT-5 anhand der Diagrammdatenbank falsch beantwortete, lautete: „Wer hat 2017 die Formel-2-Meisterschaft gewonnen?“ was mit „Lewis Hamilton“ beantwortet wurde (Lewis Hamilton gewann in diesem Jahr die Formel-1-Meisterschaft, aber nicht die Formel-2-Meisterschaft). Dies ist eine knifflige Frage, da die Datenbank nur Formel-1-Ergebnisse enthält, nicht jedoch Formel-2-Ergebnisse. Die erwartete Antwort wäre gewesen, dass diese Frage anhand der bereitgestellten Daten nicht beantwortet werden könne. Da die Systemaufforderung jedoch keine spezifischen Informationen zum Datensatz enthielt, ist es verständlich, dass diese Frage nicht richtig beantwortet wurde.

Interessanterweise ergab die Verwendung der SQL-Datenbank GPT-5 die richtige Antwort „Charles Leclerc“. Die generierte SQL-Abfrage durchsuchte nur die Treibertabelle nach dem Namen „Charles Leclerc“. Hier muss die LLM erkannt haben, dass die Datenbank keine Formel-2-Ergebnisse enthält und diese Frage nach ihrem Allgemeinwissen beantwortet haben. Obwohl dies in diesem Fall zur richtigen Antwort führte, kann es gefährlich sein, wenn das LLM die bereitgestellten Daten nicht zur Beantwortung von Fragen verwendet. Eine Möglichkeit, dieses Risiko zu verringern, könnte darin bestehen, in der Systemaufforderung explizit anzugeben, dass die Datenbank die einzige Quelle zur Beantwortung von Fragen sein darf.

Abschluss

Dieser Vergleich der RAG-Leistung anhand eines Formel-1-Ergebnisdatensatzes zeigt, dass die neuesten LLMs eine außergewöhnlich gute Leistung erbringen und äußerst genaue und kontextbezogene Antworten ohne zusätzliches Immediate-Engineering liefern. Während einfachere Modelle Schwierigkeiten haben, verarbeiten neuere Modelle wie GPT-5 komplexe Abfragen mit nahezu perfekter Präzision. Wichtig ist, dass es keinen signifikanten Leistungsunterschied zwischen den Diagramm- und SQL-Datenbankansätzen gab – Benutzer können einfach das Datenbankparadigma wählen, das am besten zur Struktur ihrer Daten passt.

Der hier verwendete Datensatz dient nur als anschauliches Beispiel; Die Ergebnisse können abweichen, wenn andere Datensätze verwendet werden, insbesondere solche, die spezielle Domänenkenntnisse oder Zugriff auf nicht öffentliche Datenquellen erfordern. Insgesamt verdeutlichen diese Ergebnisse, wie weit abrufgestützte LLMs bei der Integration strukturierter Daten mit dem Denken in natürlicher Sprache fortgeschritten sind.

Sofern nicht anders angegeben, wurden alle Bilder vom Autor selbst erstellt.