Grundlagen der KI

Dieser Abschnitt führt in die grundlegenden Elemente der KI ein, um intelligente Systeme zu entwickeln. Zu den Kern Themen gehören maschinelles Lernen, Deep Learning, Wissensgraphen (Knowledge Graphen), Schlussfolgerungen (Reasnonig) und große Sprachmodelle (LLMs). Diese Konzepte dienen als Bausteine für KI-unterstützte Systeme in verschiedenen Bereichen wie Ingenieurwissenschaft, Gesundheitswesen und Finanzwesen.

Kernkonzepte der KI

KI ist ein weites Fachgebiet, das die Entwicklung von Technologien umfasst, die in der Lage sind, Aufgaben auszuführen, die typischerweise menschliche Intelligenz erfordern. Diese Systeme stützen sich auf Algorithmen und Modelle, um Muster zu erkennen, Entscheidungen zu treffen, aus Daten zu lernen, Schlussfolgerungen zu simulieren und komplexe Probleme zu lösen. Das Hauptziel der KI besteht darin, menschliche kognitive Fähigkeiten in Maschinen zu emulieren oder zu reproduzieren. Grundlegende Konzepte wie Mustererkennung, Entscheidungsfindung und Lernen aus Daten sind zentral für die Funktionsweise von KI in praktischen Anwendungen.

Maschinelles Lernen (ML)

Maschinelles Lernen (ML) ist ein Teilbereich der KI, der es Systemen ermöglicht, automatisch aus Erfahrungen zu lernen und sich zu verbessern. Anstatt sich auf explizite Anweisungen zu verlassen, bauen ML-Algorithmen Modelle aus Beispieldaten auf, die als Trainingsdaten bekannt sind, um Muster zu erkennen und Vorhersagen oder Entscheidungen zu treffen, wenn sie mit neuen, unbekannten Daten konfrontiert werden. Die Fähigkeit, aus vergangenen Beispielen zu verallgemeinern, ermöglicht es ML-Systemen, komplexe, dynamische Probleme zu bewältigen, die die traditionelle regelbasierte Programmierung als herausfordernd oder unpraktisch erachtet.

ML ist transformativ in verschiedenen Branchen und automatisiert Prozesse, optimiert Systeme und liefert datengestützte Erkenntnisse. Die Anwendungen reichen von Gesundheitswesen (z.B. Diagnose von Krankheiten) über Finanzwesen (z.B. Betrugserkennung) bis hin zur Ingenieurwissenschaft (z.B. prädiktive Wartung). ML spielt eine Schlüsselrolle dabei, um umsetzbare Erkenntnisse aus großen Datensätzen zu liefern, wodurch die Entscheidungsfindung beschleunigt und Innovationen vorangetrieben werden.

ML umfasst mehrere Lernparadigmen, die jeweils auf spezifische Arten von Problemen und Datensätzen zugeschnitten sind. Diese Paradigmen umfassen überwachtes Lernen, unüberwachtes Lernen, halbüberwachtes Lernen und verstärkendes Lernen.

Das grundlegende Ziel von ML ist es, eine Funktion $f$ zu identifizieren, die eine Zuordnung vom Eingangsvektor (Eingangsvektor) $\mathbf{x}$ zur Ausgabeveriable $y$ definiert. Diese Beziehung wird mathematisch dargestellt als:

$y = f(\mathbf{x})$

Das Ziel von ML ist es, die optimale Funktion $f$ zu finden, die den Output $y$ basierend auf neuen Eingaben $\mathbf{x}$ am besten vorhersagt. Der Lernprozess umfasst die Minimierung einer Verlustfunktion $L(\mathbf{w})$, die den Fehler oder die Abweichung zwischen der vorhergesagten Ausgabe $\hat{y}$ (vom Modell) und der tatsächlichen Ausgabe $y$ (von den Daten) quantifiziert. Eine gängige Verlustfunktion, die im ML verwendet wird, ist der Mean Squared Error (MSE), der wie folgt ausgedrückt wird:

$L(\mathbf{w}) = \text{MSE}(\mathbf{w}) = \frac{1}{n} \sum_{k=1}^{n} \left( \hat{y}_k - y_k \right)^2$

Wo:

• $n$ ist die Anzahl der Datenpunkte im Trainingssatz.
• $y_k$ ist der tatsächliche Ausgabewert für den $k$-ten Datenpunkt.
• $\hat{y}_k$ ist der vorhergesagte Ausgabewert für den $k$-ten Datenpunkt, der vom Modell bereitgestellt wird.
• $\mathbf{w}$ repräsentiert die Parameter (Gewichte) des Modells, die optimiert werden müssen.

Ein Beispiel für diesen Prozess ist die lineare Regression, bei der das Modell annimmt, dass die Beziehung zwischen den Eingaben und Ausgaben linear ist. Das lineare Modell wird dargestellt als:

$\hat{y}_k = \mathbf{w}^\top \mathbf{x}_k$

Hier:

• $\mathbf{x}_k \in \mathbb{R}^p$ ist der Eingangsmerkmalsvektor für den $k$-ten Datenpunkt, mit $p$ Merkmalen.
• $\mathbf{w} \in \mathbb{R}^p$ ist der zu erlernende Parameter (Gewicht)vektor.

Wenn man alle $n$ Datenpunkte betrachtet, können die Eingaben und Ausgaben in Matrixform dargestellt werden:

• $X \in \mathbb{R}^{n \times p}$ ist die Matrix der Eingangsmerkmale, wobei jede Zeile $\mathbf{x}_k^\top$ dem $k$-ten Datenpunkt entspricht.
• $\hat{\mathbf{y}} \in \mathbb{R}^n$ ist der Vektor der vorhergesagten Ausgaben.
• $\mathbf{y} \in \mathbb{R}^n$ ist der Vektor der tatsächlichen Ausgaben.

Die Vorhersagen für alle Datenpunkte können ausgedrückt werden als:

$\hat{\mathbf{y}} = X \mathbf{w}$

Das Ziel der linearen Regression ist es, den Mean Squared Error (MSE) zu minimieren, indem die Parameter $\mathbf{w}$ angepasst werden. Die MSE-Verlustfunktion in Matrixnotation ist:

$L(\mathbf{w}) = \text{MSE}(\mathbf{w}) = \frac{1}{n} \left( \hat{\mathbf{y}} - \mathbf{y} \right)^\top \left( \hat{\mathbf{y}} - \mathbf{y} \right) = \frac{1}{n} \left( X \mathbf{w} - \mathbf{y} \right)^\top \left( X \mathbf{w} - \mathbf{y} \right)$

Gradientenabstieg-Optimierung

Der Gradientenabstieg ist ein iterativer Optimierungsalgorithmus, der verwendet wird, um den Mean Squared Error (MSE) zu minimieren, indem die Modellparameter $\mathbf{w}$ aktualisiert werden. Die Aktualisierungsregel für den Parametervektor $\mathbf{w}$ wird gegeben durch:

$\mathbf{w}_{\text{neu}} = \mathbf{w}_{\text{alt}} - \eta \nabla_{\mathbf{w}} L(\mathbf{w})$

Wo:

• $\mathbf{w}_{\text{neu}}$ ist der aktualisierte Parametervektor.
• $\mathbf{w}_{\text{alt}}$ ist der aktuelle Parametervektor.
• $\eta$ ist die Lernrate, ein Hyperparameter, der die Schrittgröße für jede Aktualisierung steuert.
• $\nabla_{\mathbf{w}} L(\mathbf{w})$ ist der Gradient der Verlustfunktion in Bezug auf den Parametervektor $\mathbf{w}$.

Der Gradient der MSE-Verlustfunktion in Bezug auf $\mathbf{w}$ wird berechnet als:

$\nabla_{\mathbf{w}} L(\mathbf{w}) = \frac{2}{n} X^\top \left( \hat{\mathbf{y}} - \mathbf{y} \right) = \frac{2}{n} X^\top \left( X \mathbf{w} - \mathbf{y} \right)$

Dieser Ausdruck liefert die Richtung und das Ausmaß des steilsten Anstiegs in der Verlustfunktion. Indem man in die entgegengesetzte Richtung bewegt (den Gradient subtrahiert), aktualisiert der Gradientenabstieg die Parameter $\mathbf{w}$ so, dass die Verlustfunktion minimiert wird.

Klärung der Dimensionen

Um Verwirrung zu vermeiden, ist es wichtig, die Dimensionen der beteiligten Vektoren und Matrizen zu klären:

• $X \in \mathbb{R}^{n \times p}$: Eingabematrix der Merkmale mit $n$ Datenpunkten und $p$ Merkmalen.
• $\mathbf{w} \in \mathbb{R}^p$: Parameter- (Gewichts-) Vektor.
• $\mathbf{y} \in \mathbb{R}^n$: Tatsächlicher Ausgabewertvektor.
• $\hat{\mathbf{y}} \in \mathbb{R}^n$: Vorhergesagter Ausgabewertvektor.

Wichtige Konzepte im Maschinellen Lernen

• Generalisierung: Die Fähigkeit eines ML-Modells, bei neuen, unbekannten Daten gut abzuschneiden.
• Overfitting: Wenn ein Modell außergewöhnlich gut bei den Trainingsdaten abschneidet, aber bei unbekannten Daten scheitert, da es das Rauschen anstelle des zugrunde liegenden Musters erfasst.
• Underfitting: Wenn ein Modell zu einfach ist, um die Muster in den Daten zu erfassen, was zu einer schlechten Leistung sowohl bei den Trainings- als auch bei den Testdaten führt.
• Regularisierung: Techniken wie L1- und L2-Regularisierung werden verwendet, um Overfitting zu verhindern, indem ein Strafterm zur Verlustfunktion hinzugefügt wird, der große Modellgewichte einschränkt.
• Kreuzvalidierung: Eine Technik zur Bewertung der Generalisierungsfähigkeit eines Modells, bei der der Datensatz in mehrere Teilmengen aufgeteilt und das Modell auf verschiedenen Kombinationen dieser Teilmengen trainiert und getestet wird.

ML kann anhand der Verfügbarkeit von gelabelten Daten und der spezifischen Ziele des Lernprozesses in verschiedene Ansätze kategorisiert werden. Die vier primären Paradigmen sind überwachtes Lernen, unüberwachtes Lernen, semi-überwachtes Lernen und Reinforcement Learning, die jeweils unterschiedliche Zwecke erfüllen und verschiedene Arten von Problemen adressieren.
Überwachtes Lernen ist ein grundlegender Ansatz im ML, bei dem das Modell aus gelabelten Daten lernt. In diesem Framework besteht jedes Trainingsbeispiel aus einem Eingabe-Ausgabe-Paar. Beim überwachten Lernen aktualisiert das Modell kontinuierlich seine internen Parameter basierend auf den gelabelten Trainingsdaten und versucht, den Fehler zwischen vorhergesagten und tatsächlichen Ergebnissen zu minimieren. Das trainierte Modell kann dann auf unbekannte Daten angewendet werden, um basierend auf den während der Trainingsphase gelernten Mustern genaue Vorhersagen zu treffen. Die Wahl zwischen Regression und Klassifikation hängt davon ab, ob das Problem die Vorhersage eines kontinuierlichen Wertes oder einer diskreten Kategorie erfordert.
Unüberwachtes Lernen ist eine Art des maschinellen Lernens, bei dem mit ungelabelten Daten gearbeitet wird, d.h. der Algorithmus erhält während des Trainings keine expliziten Ausgaben. Stattdessen versucht das Modell, versteckte Muster, Strukturen oder Beziehungen innerhalb der Daten zu entdecken. Unüberwachtes Lernen ist besonders nützlich bei großen Datensätzen, bei denen das Labeln teuer oder unpraktisch ist. Der Algorithmus identifiziert autonom Gruppierungen, Cluster oder dimensionale Beziehungen ohne menschliches Eingreifen und ermöglicht so Einblicke in die zugrunde liegende Datenverteilung.
Semi-Überwachtes Lernen ist ein hybrider Ansatz, der eine kleine Menge gelabelter Daten mit einer großen Menge ungelabelter Daten kombiniert. Diese Methode ist besonders nützlich, wenn die Beschaffung gelabelter Daten teuer oder zeitaufwendig ist, aber große Mengen ungelabelter Daten verfügbar sind. Durch die Nutzung der Muster und Strukturen in den ungelabelten Daten kann das Modell seine Leistung im Vergleich zur Verwendung nur gelabelter Daten erheblich verbessern.

Beim semi-überwachten Lernen verwendet das Modell die gelabelten Daten, um erste Vorhersagen zu treffen, und verfeinert diese Vorhersagen, indem es Muster in den ungelabelten Daten erkundet. Dieser Ansatz führt oft zu einer hohen Genauigkeit in Szenarien, in denen das Labeln aller Daten unpraktisch wäre.

Beispiel im Ingenieurwesen: Verbesserung von Bildverarbeitungsmodellen, wenn gelabelte Bilder knapp sind. Bei der Fehlererkennung in Produktionsprozessen kann das Labeln einer großen Anzahl von Fehlerbildern eine Herausforderung und ressourcenintensiv sein. Das Sammeln ungelabelter Bilder ist jedoch oft machbar. Semi-überwachtes Lernen ermöglicht es dem Modell, aus einer kleinen Menge gelabelter Fehlerbilder zu lernen und seine Leistung durch die Nutzung der in den großen Mengen ungelabelter Bilder gefundenen Muster zu verbessern.

Semi-überwachtes Lernen ist besonders wertvoll in Bereichen wie der Bilderkennung, der Verarbeitung natürlicher Sprache und der Anomalieerkennung, wo gelabelte Daten knapp sind, aber viele ungelabelte Daten vorhanden sind. Durch die Nutzung beider Datentypen bietet semi-überwachtes Lernen einen leistungsstarken Ansatz zur Verbesserung der Modellleistung, ohne dass umfangreiche manuelle Labelarbeit erforderlich ist. Dies macht es zu einer effektiven Lösung für datenintensive Anwendungen im Ingenieurwesen.
Reinforcement Learning (RL) ist eine Art des maschinellen Lernens, bei dem ein Agent durch Interaktion mit einer Umgebung lernt, Entscheidungen zu treffen, um eine kumulative Belohnung zu maximieren. Im Gegensatz zum überwachten Lernen konzentriert sich RL auf das Lernen durch Versuch und Irrtum, wobei der Agent Feedback aus seinen eigenen Aktionen und Erfahrungen erhält.

Die Interaktion mit der Umgebung wird durch die Belohnungsfunktion $r(s_t, a_t)$ und die Übergangswahrscheinlichkeiten $p(s_{t+1} \mid s_t, a_t)$ beschrieben, wobei $s_t$ der Zustand zum Zeitpunkt $t$ ist und $a_t$ die zu diesem Zeitpunkt gewählte Aktion ist. Die unmittelbare Belohnung $r_t$ ist mit dem Zustand und der Aktion zum Zeitpunkt $t$ verbunden.

Die kumulative diskontierte Belohnung $R_t$ zum Zeitpunkt $t$ ist definiert als:

$R_t = \sum_{\tau=0}^{\infty} \gamma^\tau r_{t+\tau}$

wobei:

• $\gamma \in (0, 1]$ der Diskontfaktor ist, der die Bedeutung zukünftiger Belohnungen bestimmt.
• $r_{t+\tau}$ die Belohnung ist, die zum Zeitpunkt $t+\tau$ erhalten wird.

Das Verhalten des Agenten wird durch eine Policy $\pi$ bestimmt, die die Wahrscheinlichkeiten für die Auswahl jeder Aktion $a$ im Zustand $s$ angibt, bezeichnet als $\pi(a \mid s)$. Die Policy kann stochastisch (wahrscheinlichkeitsbasiert) oder deterministisch sein. Im deterministischen Fall ist die Policy eine Funktion, die Zustände auf Aktionen abbildet: $a = \pi(s)$.

Das Ziel des Agenten besteht darin, eine optimale Policy $\pi^*$ zu finden, die den erwarteten kumulierten diskontierten Ertrag von jedem Anfangszustand $s_t$ maximiert:

$\pi^* = \arg\max_{\pi} \, \mathbb{E}[R_t \mid s_t, \pi]$

wobei $\mathbb{E}[\cdot]$ den Erwartungswert über alle möglichen Zustands- und Aktionssequenzen angibt, basierend auf der Policy $\pi$ und dem Startzustand $s_t$.

Die Wertfunktion $V_\pi(s)$ stellt den erwarteten kumulierten diskontierten Ertrag dar, wenn man vom Zustand $s$ aus startet und der Policy $\pi$ folgt:

$V_\pi(s) = \mathbb{E}[R_t \mid s_t = s, \pi]$

Sie prognostiziert den langfristigen Ertrag im Zustand $s$ unter der Policy $\pi$.

Ähnlich gibt die Aktions-Wertfunktion $Q_\pi(s, a)$ den erwarteten kumulierten diskontierten Ertrag nach Ausführung der Aktion $a$ im Zustand $s$ und anschließendem Folgen der Policy $\pi$ an:

$Q_\pi(s, a) = \mathbb{E}[R_t \mid s_t = s, a_t = a, \pi]$

Bellman-Gleichungen

Die Wertfunktionen können rekursiv mithilfe der Bellman-Gleichungen ausgedrückt werden.

Für die Wertfunktion $V_\pi(s)$:

$V_\pi(s) = \sum_{a \in A} \pi(a \mid s) \left[ r(s, a) + \gamma \sum_{s' \in S} p(s' \mid s, a) V_\pi(s') \right]$

Für die Aktions-Wertfunktion $Q_\pi(s, a)$:

$Q_\pi(s, a) = r(s, a) + \gamma \sum_{s' \in S} p(s' \mid s, a) \sum_{a' \in A} \pi(a' \mid s') Q_\pi(s', a')$

Diese Gleichungen stellen den Zusammenhang zwischen dem Wert eines Zustands (oder Zustands-Aktions-Paars) und den Werten nachfolgender Zustände her und bilden die Grundlage für viele RL-Algorithmen.

Zusammenfassung

Beim Reinforcement Learning strebt der Agent danach, die optimale Policy $\pi^*$ zu erlernen, die den erwarteten kumulierten diskontierten Ertrag maximiert. Dies beinhaltet die Schätzung der Wertfunktionen $V_\pi(s)$ und $Q_\pi(s, a)$ und deren Nutzung für fundierte Entscheidungen. RL kann sowohl auf diskrete als auch kontinuierliche Zustands- und Aktionsräume angewendet werden, was es vielseitig für verschiedene ingenieurtechnische Anwendungen, wie Robotik, Regelungssysteme und autonome Navigation, macht.

Deep Learning (DL)

Deep Learning (DL) ist ein leistungsstarkes Teilgebiet des maschinellen Lernens, das neuronale Netze mit mehreren Schichten verwendet, um komplexe Muster in Daten zu modellieren. Im Gegensatz zu traditionellen maschinellen Lernmodellen können Deep-Learning-Modelle Merkmale automatisch aus Rohdaten extrahieren und lernen, was sie besonders effektiv im Umgang mit unstrukturierten Daten wie Bildern, Texten und Audiodaten macht. Im Zentrum des Deep Learnings stehen tiefe neuronale Netze (DNNs), die aus Schichten miteinander verbundener Knoten (Neuronen) bestehen, die hierarchische Repräsentationen von Daten erlernen.

Verständnis von neuronalen Netzen

Ein neuronales Netz ist ein Berechnungsmodell, das von der Struktur des menschlichen Gehirns inspiriert ist. Es besteht aus Schichten von Neuronen, wobei jedes Neuron Eingaben empfängt, eine Transformation anwendet und das Ergebnis an die nächste Schicht weitergibt. Die Operation eines einzelnen Neurons kann mathematisch wie folgt dargestellt werden:

$z = \mathbf{w} \cdot \mathbf{x} + b$

wobei:

• $\mathbf{x} = [x_1, x_2, \dots, x_n]$ der Eingabevektor ist, der die Merkmale der Daten darstellt (z.B. Pixelwerte in einem Bild).
• $\mathbf{w} = [w_1, w_2, \dots, w_n]$ der Gewichtsvektor ist, wobei jedes Gewicht der Bedeutung eines jeden Eingabemerkmals entspricht.
• $b$ der Bias-Term ist, der es dem Neuron ermöglicht, seine Aktivierung zu verschieben.
• $z$ die lineare Kombination von Eingaben und Gewichten ist, die durch eine Aktivierungsfunktion geleitet wird.

Der Ausgang $y$ des Neurons wird mithilfe einer Aktivierungsfunktion $f(z)$ berechnet, die Nichtlinearität in das Modell einführt:

$y = f(z) = f(\mathbf{w} \cdot \mathbf{x} + b)$

Aktivierungsfunktionen

Aktivierungsfunktionen spielen eine entscheidende Rolle im Deep Learning, da sie es dem Netz ermöglichen, komplexe, nichtlineare Beziehungen in den Daten zu erfassen. Ohne Aktivierungsfunktionen wäre ein neuronales Netz lediglich ein lineares Modell, was seine Fähigkeit zur Lösung komplexer Probleme einschränken würde. Zu den gängigen Aktivierungsfunktionen gehören:

• ReLU (Rectified Linear Unit): $f(x) = \max(0, x)$ ReLU wird häufig im Deep Learning verwendet, da es hilft, das Vanishing-Gradient-Problem zu mildern, indem es nur positive Eingaben aktiviert und negative Eingaben auf null setzt. Dadurch wird der Trainingsprozess schneller und effizienter.
• Sigmoid: $f(x) = \frac{1}{1 + e^{-x}}$ Die Sigmoid-Funktion komprimiert Eingabewerte in einen Bereich zwischen 0 und 1, was sie für binäre Klassifizierungsaufgaben geeignet macht. Allerdings kann sie in tiefen Netzwerken unter dem Vanishing-Gradient-Problem leiden.
• Tanh (Hyperbolischer Tangens): $f(x) = \tanh(x) = \frac{e^x - e^{-x}}{e^x + e^{-x}}$ Tanh ähnelt der Sigmoid-Funktion, skaliert den Ausgang jedoch in einen Bereich zwischen -1 und 1. Sie wird oft der Sigmoid-Funktion vorgezogen, da sie die Daten zentriert und die Optimierung effizienter macht.

Tiefe neuronale Netze (DNNs)

Ein tiefes neuronales Netz (DNN) ist ein neuronales Netz mit mehreren übereinander angeordneten Schichten von Neuronen. Jede Schicht lernt zunehmend abstraktere Merkmale aus den Eingabedaten. Bei einer Bildverarbeitungsaufgabe erkennen beispielsweise die frühen Schichten einfache Merkmale wie Kanten, während tiefere Schichten komplexe Formen und Objekte identifizieren. Die allgemeine Struktur eines DNN besteht aus:

• Eingabeschicht: Nimmt die Rohdaten auf. Jedes Neuron in der Eingabeschicht entspricht einem Merkmal der Eingabedaten.
• Verborgene Schichten: Zwischenschichten, die lernen, Merkmale aus den vorherigen Schichten zu erkennen und zu kombinieren. Ein DNN kann viele verborgene Schichten haben.
• Ausgabeschicht: Erzeugt die endgültige Ausgabe, die ein einzelner Wert für Regressionsaufgaben oder eine Menge von Wahrscheinlichkeiten für Klassifizierungsaufgaben sein kann.

Backpropagation und Lernen

Der Lernprozess in DNNs wird durch den Backpropagation-Algorithmus gesteuert, der die Gewichte des Netzes anpasst, um den Unterschied zwischen der vorhergesagten Ausgabe und dem tatsächlichen Ziel zu minimieren. Backpropagation umfasst zwei Hauptschritte:

1. Vorwärtsdurchlauf: Die Eingabedaten werden durch das Netz geleitet, und Vorhersagen werden getroffen. Die Verlustfunktion vergleicht die vorhergesagte Ausgabe mit dem tatsächlichen Ziel, um den Fehler zu berechnen.
2. Rückwärtsdurchlauf: Die Gradienten der Verlustfunktion in Bezug auf die Gewichte werden mithilfe der Kettenregel der Differentialrechnung berechnet. Diese Gradienten werden dann verwendet, um die Gewichte in eine Richtung zu aktualisieren, die den Verlust (Fehler) verringert.

Die Regel zur Aktualisierung der Gewichte lautet: $w_{ij}^{\text{neu}} = w_{ij} - \eta \cdot \frac{\partial L}{\partial w_{ij}}$ wobei:

• $\eta$ die Lernrate ist, die die Schrittweite jeder Gewichtsaktualisierung steuert.
• $\frac{\partial L}{\partial w_{ij}}$ der Gradient der Verlustfunktion $L$ in Bezug auf das Gewicht $w_{ij}$ ist.

Mathematische Erklärung: Sei $L(\hat{y}, y)$ die Verlustfunktion, wobei $\hat{y}$ die vorhergesagte Ausgabe und $y$ das tatsächliche Ziel ist. Bei Klassifizierungsaufgaben ist eine gängige Verlustfunktion die Kreuzentropie:

$L(\hat{y}, y) = -\sum_{i} y_i \log(\hat{y}_i)$

Der Backpropagation-Algorithmus berechnet den Gradienten des Verlustes in Bezug auf jedes Gewicht im Netz, und diese Gradienten werden iterativ zur Aktualisierung der Gewichte verwendet.

Beispiel: Aufbau eines einfachen neuronalen Netzes in Python
Als nächstes demonstrieren wir, wie man ein einfaches neuronales Netz zur Klassifizierung von Ziffern mit TensorFlow und PyTorch implementiert. Die Aufgabe besteht darin, Bilder handgeschriebener Ziffern aus dem MNIST-Datensatz zu klassifizieren.
TensorFlow-Beispiel:

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist

# MNIST-Daten laden und vorverarbeiten
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0  # Daten normalisieren

# DNN-Modell erstellen
model = models.Sequential([
    layers.Flatten(input_shape=(28, 28)),  # Bilder in Vektoren umwandeln
    layers.Dense(128, activation='relu'),  # Verborgene Schicht mit ReLU
    layers.Dense(10, activation='softmax')  # Ausgabeschicht mit 10 Klassen
])

# Modell mit Kreuzentropie-Verlust und Adam-Optimierer kompilieren
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# Modell trainieren
model.fit(x_train, y_train, epochs=5)

# Modell bewerten
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Testgenauigkeit: {test_acc}")

Erklärung: - Die Eingabeschicht wandelt die 28x28-Pixel-Bilder in 1D-Vektoren um. - Die verborgene Schicht hat 128 Neuronen mit ReLU-Aktivierung. - Die Ausgabeschicht besteht aus 10 Neuronen mit Softmax-Aktivierung, die die 10 Ziffernklassen darstellen.
PyTorch-Beispiel:

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# Transformationen für den MNIST-Datensatz definieren
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

# MNIST-Datensatz laden
trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
testset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)
trainloader = DataLoader(trainset, batch_size=64, shuffle=True)
testloader = DataLoader(testset, batch_size=64, shuffle=False)

# Neuronales Netzwerkmodell definieren
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)  # Erste verborgene Schicht
        self.fc2 = nn.Linear(128, 10)     # Ausgabeschicht

    def forward(self, x):
        x = x.view(-1, 28*28)  # Eingabe flach machen
        x = torch.relu(self.fc1(x))  # ReLU-Aktivierung
        x = self.fc2(x)              # Ausgabeschicht (Logits)
        return x

# Modell, Verlustfunktion und Optimierer initialisieren
model = SimpleNN()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# Trainingsschleife
for epoch in range(5):
    for images, labels in trainloader:
        optimizer.zero_grad()  # Gradienten auf null setzen
        output = model(images)  # Vorwärtsdurchlauf
        loss = criterion(output, labels)  # Verlust berechnen
        loss.backward()  # Backpropagation
        optimizer.step()  # Gewichte aktualisieren

# Modell bewerten
correct = 0
total = 0
with torch.no_grad():
    for images, labels in testloader:
        output = model(images)
        _, predicted = torch.max(output, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"Testgenauigkeit: {</span>correct <span class="op">/</span> total<span class="sc">}")

Erklärung: Dieses PyTorch-Beispiel definiert ein einfaches neuronales Netz mit einer verborgenen Schicht. Die Trainingsschleife führt den Vorwärtsdurchlauf manuell durch, berechnet den Verlust, propagiert die Gradienten zurück und aktualisiert die Gewichte des Modells mit dem Adam-Optimierer.

Wissensrepräsentation und Wissensgraphen

Wissensrepräsentation ist ein grundlegender Aspekt der Künstlichen Intelligenz (KI), der sich darauf konzentriert, wie Informationen über die Welt strukturiert, gespeichert und von KI-Systemen genutzt werden. Eine effektive Wissensrepräsentation ermöglicht es KI-Systemen, zu schlussfolgern, Entscheidungen zu treffen und aus Daten zu lernen. Es gibt zwei Hauptansätze zur Wissensrepräsentation: symbolisch und sub-symbolisch.

Symbolische Repräsentationen

Die symbolische Repräsentation beinhaltet die explizite und strukturierte Kodierung von Wissen unter Verwendung von Symbolen, formalen Sprachen und logikbasierten Systemen. Jedes Symbol steht für eine Entität, ein Konzept oder eine Beziehung der realen Welt, wobei logische Regeln deren Interaktionen steuern. Dieser Ansatz ist hochgradig interpretierbar und transparent, was ihn für Anwendungen, die Erklärbarkeit erfordern, wie im Gesundheitswesen, in der Finanzwelt und in der juristischen Argumentation, geeignet macht.

Beispiele für symbolische Repräsentationen umfassen:

• Logikbasierte Systeme: Systeme, die logische Regeln verwenden, um Wissen darzustellen und Schlussfolgerungen zu ziehen. Beispielsweise kann das System aus "Alle Menschen sind sterblich" und "Sokrates ist ein Mensch" ableiten, dass "Sokrates sterblich ist."
• Ontologien: Strukturierte Mengen von Konzepten und Kategorien innerhalb eines bestimmten Bereichs, einschließlich ihrer Beziehungen. Ontologien werden in der Biologie weit verbreitet eingesetzt, um Beziehungen zwischen Spezies, Genen und Proteinen darzustellen.
• Semantische Netzwerke: Graphstrukturen, bei denen Knoten Konzepte darstellen und Kanten Beziehungen zwischen diesen Konzepten, die in der Verarbeitung natürlicher Sprache und der Informationsgewinnung verwendet werden.

Der Hauptvorteil symbolischer Repräsentationen liegt in ihrer Interpretierbarkeit. Sie haben jedoch Schwierigkeiten mit unvollständigen, unsicheren oder groß angelegten dynamischen Datensätzen, bei denen sich das Wissen kontinuierlich ändert, was ihre Flexibilität einschränkt.

Sub-symbolische Repräsentationen kodieren Wissen implizit in den Parametern von maschinellen Lernmodellen wie neuronalen Netzen. Diese Modelle lernen Muster direkt aus Daten, ohne dass eine explizite symbolische Kodierung erforderlich ist. Sub-symbolische Methoden wie Deep Learning sind besonders erfolgreich bei Aufgaben wie Mustererkennung, Bildanalyse und Verarbeitung natürlicher Sprache (NLP). Allerdings mangelt es ihnen oft an Transparenz, was es schwierig macht, das interne Schlussfolgern des Modells zu interpretieren.

Wissensgraphen (KGs) sind eine leistungsstarke Form der symbolischen Wissensrepräsentation. Ein KG strukturiert Daten als ein Netzwerk von Entitäten (Knoten) und deren Beziehungen (Kanten), was es KI-Systemen ermöglicht, aus komplexen, vernetzten Informationen zu schlussfolgern und Erkenntnisse abzuleiten. KGs modellieren effektiv Wissen der realen Welt, bei dem Entitäten durch verschiedene Arten von Beziehungen miteinander verbunden sind, und bieten eine transparente Struktur, die die Erklärbarkeit und das Schlussfolgern verbessert.

Im Gegensatz zu traditionellen Datenbanken, die Daten in Tabellen speichern, stellen KGs Wissen als Netz von miteinander verbundenen Entitäten dar, was tiefere Einblicke und fortgeschrittenes Schlussfolgern ermöglicht.

Wichtige Eigenschaften von Wissensgraphen

• Explizite Repräsentation: KGs speichern Fakten, Entitäten und Beziehungen in einem strukturierten Format, das logische Abfragen und Schlussfolgerungen ermöglicht, im Gegensatz zu maschinellen Lernmodellen, die sich auf Muster konzentrieren.
• Schlussfolgern: KGs ermöglichen Inferenzaufgaben, indem sie bekannte Fakten verknüpfen, um neue Erkenntnisse abzuleiten. Wenn ein KG beispielsweise weiß, dass "Unternehmen A Eigentümer von Unternehmen B ist" und "Unternehmen B in Italien ansässig ist", kann es ableiten, dass "Unternehmen A Einfluss in Italien hat."
• Umgang mit komplexen Daten: KGs sind hervorragend im Umgang mit hoch vernetzten Daten, bei denen Entitäten mehrere Beziehungen haben, wie in sozialen Netzwerken, Organisationsstrukturen oder biologischen Netzwerken.
• Reduzierte Halluzinationen: Im Gegensatz zu LLMs, die möglicherweise erfundene Informationen (Halluzinationen) generieren, stützen sich KGs auf überprüfbare Fakten und logische Regeln, was sie zuverlässiger macht, wenn faktische Korrektheit entscheidend ist.

Anwendungen von Wissensgraphen

Wissensgraphen sind in Bereichen, die über komplexe, vernetzte Daten schlussfolgern müssen, von entscheidender Bedeutung:

• Finanzen und Lieferketten: KGs modellieren komplexe Eigentümerstrukturen, Lieferketten und finanzielle Beziehungen, was Organisationen hilft, Prozesse zu optimieren und Schwachstellen zu identifizieren.
• Cybersicherheit: KGs kartieren potenzielle Angriffswege und Abhängigkeiten in Netzwerken, wodurch eine proaktive Identifizierung von Sicherheitsrisiken ermöglicht wird.
• Gesundheitswesen: KGs modellieren Beziehungen zwischen Krankheiten, Symptomen, Behandlungen und Medikamenten, wodurch Kliniker medizinische Daten besser verstehen und genauere Diagnosen stellen können.

Grundlegende Graphalgorithmen zum Schlussfolgern

Mehrere Graphalgorithmen sind entscheidend für das Schlussfolgern und das Extrahieren von Informationen aus Wissensgraphen (KGs):

• Breitensuche (BFS): Durchsucht Knoten Schicht für Schicht, um den kürzesten Pfad zwischen zwei Entitäten zu finden.
• Tiefensuche (DFS): Durchsucht jeden Zweig so weit wie möglich, bevor er zurückverfolgt, was nützlich für die Suche in großen Graphen ist.
• PageRank: Berechnet die Bedeutung von Knoten basierend auf der Anzahl und Qualität der Verbindungen, wird oft verwendet, um Suchergebnisse zu bewerten oder einflussreiche Entitäten in einem Graphen zu identifizieren.

Beispiel: Aufbau und Abfrage eines Wissensgraphen

Im folgenden Python-Beispiel wird gezeigt, wie ein Wissensgraph mithilfe von Memgraph und der Cypher-Abfragesprache erstellt und abgefragt wird:

 
# Erforderliche Bibliotheken installieren: memgraph, mgclient
# pip install memgraph mgclient

import mgclient

# Verbindung zur Memgraph-Instanz herstellen
connection = mgclient.connect(host='127.0.0.1', port=7687)
cursor = connection.cursor()

# Knoten (Entitäten) und Beziehungen (Kanten) im KG erstellen
cursor.execute("""
    CREATE (:Student {name: 'Alice', id: 1}),
           (:Student {name: 'Bob', id: 2}),
           (:Course {name: 'AI', id: 101}),
           (:Course {name: 'Machine Learning', id: 102}),
           (:Professor {name: 'Dr. Smith', id: 201}),
           (:Student {name: 'Carol', id: 3})
""")

cursor.execute("""
    MATCH (a:Student {name: 'Alice'}), (c:Course {name: 'AI'})
    CREATE (a)-[:ENROLLED_IN]->(c)
""")

cursor.execute("""
    MATCH (b:Student {name: 'Bob'}), (c:Course {name: 'AI'})
    CREATE (b)-[:ENROLLED_IN]->(c)
""")

cursor.execute("""
    MATCH (c:Course {name: 'AI'}), (p:Professor {name: 'Dr. Smith'})
    CREATE (p)-[:TEACHES]->(c)
""")

# Wissensgraph abfragen
cursor.execute("""
    MATCH (student:Student)-[:ENROLLED_IN]->(course:Course)
    RETURN student.name, course.name
""")
result = cursor.fetchall()
for row in result:
    print(f"Student {</span>row[<span class="dv">0</span>]<span class="sc">} is enrolled in {</span>row[<span class="dv">1</span>]<span class="sc">}.")

# Verbindung schließen
connection.close()

Erklärung des Codes:

• Verbindung zu Memgraph: Wir stellen eine Verbindung zu einer lokalen Memgraph-Instanz mithilfe der mgclient-Bibliothek her.
• Erstellen von Knoten und Beziehungen: Cypher-Befehle werden verwendet, um Knoten zu erstellen, die Studenten, Kurse und Professoren repräsentieren. Beziehungen wie ENROLLED_IN und TEACHES werden hinzugefügt, um Verbindungen zwischen Studenten und Kursen bzw. Professoren und Kursen darzustellen.
• Abfragen des Wissensgraphen: Eine Cypher-Abfrage wird verwendet, um zu ermitteln, welche Studenten in welchen Kursen eingeschrieben sind, und die Ergebnisse werden ausgegeben.

Beispielausgabe:

Student Alice is enrolled in AI.
Student Bob is enrolled in AI.

Transformer-Architektur

Die im Jahr 2017 eingeführte Transformer-Architektur ist zum Rückgrat von LLMs (Large Language Models) geworden. Sie basiert auf Aufmerksamkeitsmechanismen, um Eingabedaten zu verarbeiten und Beziehungen zwischen Wörtern unabhängig von ihrer Entfernung im Satz zu erfassen. Diese Architektur hat traditionelle Modelle wie Rekurrente Neuronale Netze (RNNs) und Long Short-Term Memory (LSTM)-Netzwerke in der effizienten Handhabung von langfristigen Abhängigkeiten übertroffen. Die wichtigsten Komponenten des Transformers sind:

• Multi-Head Self-Attention: Dieser Mechanismus ermöglicht es dem Modell, gleichzeitig mehrere Positionen in der Eingabesequenz zu beachten. Jeder Kopf berechnet eine gewichtete Repräsentation der Eingabetokens, wobei er sich auf die relevantesten Wörter für jedes Token konzentriert.

  Mathematisch lässt sich der Aufmerksamkeitsmechanismus wie folgt darstellen: $\text{Attention}(Q, K, V) = \text{softmax}\left( \frac{QK^T}{\sqrt{d_k}} \right) V$ wobei $Q$ (Queries), $K$ (Keys) und $V$ (Values) Matrizen sind, die aus den Eingabetokens abgeleitet werden, und $d_k$ die Dimension der Key-Vektoren ist. Dieser Mechanismus ermöglicht es dem Modell, die Bedeutung verschiedener Wörter dynamisch in Bezug auf das Query-Wort zu gewichten.

• Position Encoding: Da Transformer alle Tokens parallel verarbeiten, versteht das Modell nicht von Natur aus die Reihenfolge der Wörter in einer Sequenz. Positionskodierungen werden den Eingaben hinzugefügt, um Informationen über die Reihenfolge der Wörter zu injizieren. Die Kodierung erfolgt typischerweise durch eine Kombination von Sinus- und Kosinusfunktionen: $\text{PE}_{(pos, 2i)} = \sin\left(\frac{pos}{10000^{2i/d_{model}}}\right)$ $\text{PE}_{(pos, 2i+1)} = \cos\left(\frac{pos}{10000^{2i/d_{model}}}\right)$ wobei $pos$ die Wortposition und $i$ den Index der Dimension darstellt.
• Feed-Forward Network: Nach der Selbstaufmerksamkeit wird ein Feed-Forward-Netzwerk unabhängig auf jedes Token angewendet, um seine gelernte Repräsentation weiter zu verbessern. Dieses Netzwerk besteht typischerweise aus zwei linearen Transformationen mit einer ReLU-Aktivierungsfunktion.
• Layer-Normalisierung und Residualverbindungen: Diese Komponenten tragen zur Stabilisierung des Trainingsprozesses bei und beschleunigen die Konvergenz. Residualverbindungen ermöglichen es dem Modell, die ursprünglichen Eingabemerkmale wiederzuverwenden und Probleme wie verschwindende Gradienten zu mildern.

BERT

Bidirectional Encoder Representations from Transformers, (BERT), entwickelt von Google, ist eines der einflussreichsten vortrainierten Modelle, das auf der Transformer-Architektur basiert. Die wichtigste Innovation von BERT ist die Verwendung von bidirektionaler Aufmerksamkeit, die es dem Modell ermöglicht, den Kontext eines Wortes sowohl vor als auch nach dem Wort zu erfassen. Dieser bidirektionale Ansatz ermöglicht es BERT, außergewöhnlich gut bei einer Vielzahl von NLP-Aufgaben wie Fragebeantwortung, Named Entity Recognition und Sentimentanalyse abzuschneiden.

BERT wird mit einer Methode namens Masked Language Modeling (MLM) vortrainiert, bei der ein bestimmter Prozentsatz der Eingabetokens maskiert wird und das Modell trainiert wird, diese maskierten Tokens basierend auf dem umgebenden Kontext vorherzusagen. Die Zielfunktion für MLM lautet: $\mathcal{L}_{MLM} = - \sum_{i=1}^{N} \log P(w_i | \text{context})$ wobei $P(w_i | \text{context})$ die Wahrscheinlichkeit des maskierten Wortes $w_i$ im gegebenen Kontext darstellt.

Durch dieses bidirektionale Lernen kann BERT einen reichhaltigeren Kontext und Wortabhängigkeiten erfassen, was die Leistung bei Aufgaben, die ein tiefes Kontextverständnis erfordern, erheblich verbessert.

GPT

Generative Pre-trained Transformers, (GPT), entwickelt von OpenAI, ist ein weiteres populäres Modell, das auf der Transformer-Architektur basiert. Im Gegensatz zu BERT, das bidirektionale Aufmerksamkeit verwendet, nutzt GPT einen autoregressiven Ansatz. Das bedeutet, dass GPT Text generiert, indem es jedes Wort nacheinander vorhersagt, basierend nur auf den vorhergehenden Wörtern, ohne vorauszuschauen.

Autoregressives Modellieren

Das autoregressive Modell von GPT folgt der Kettenregel der Wahrscheinlichkeit, um das nächste Wort vorherzusagen: $P(x_1, x_2, \ldots, x_N) = \prod_{i=1}^{N} P(x_i | x_1, x_2, \ldots, x_{i-1})$ Dies ermöglicht es GPT, hochgradig kohärenten und flüssigen Text zu generieren, da jedes Wort in der Sequenz basierend auf dem vorherigen Kontext generiert wird.

Vortraining und Feinabstimmung

GPT-Modelle werden auf riesigen Mengen an Textdaten mit dem autoregressiven Ziel vortrainiert: $\mathcal{L}_{LM} = - \sum_{i=1}^{N} \log P(x_i | x_1, x_2, \ldots, x_{i-1})$ Sobald das Modell vortrainiert ist, kann es für spezifische Aufgaben wie Textzusammenfassungen, Fragebeantwortung oder Dialogsysteme feinabgestimmt werden.

Fähigkeiten

GPT ist bekannt für seine Fähigkeit, flüssigen und kontextuell relevanten Text zu generieren. Zu seinen Hauptanwendungen gehören:

• Kreatives Schreiben: Generierung von Geschichten, Gedichten und Essays basierend auf Vorgaben.
• Code-Generierung: Unterstützung von Entwicklern durch die Generierung von Code aus natürlichen Sprachbeschreibungen.
• Fragebeantwortung: Bereitstellung kohärenter, menschenähnlicher Antworten auf verschiedene Anfragen.

Vergleich von BERT und GPT

• Architektur:
  • BERT: Verwendet bidirektionale Aufmerksamkeit, um sowohl den linken als auch den rechten Kontext zu berücksichtigen, was es ideal für Aufgaben macht, die ein tiefes Verständnis erfordern.
  • GPT: Verwendet unidirektionale (autoregressive) Aufmerksamkeit und konzentriert sich auf Aufgaben der Textgenerierung.
• Vortrainingsziele:
  • BERT: Wurde mittels Masked Language Modeling vortrainiert, wobei das Modell lernt, Lücken in einem Satz zu füllen.
  • GPT: Wurde mittels autoregressiven Modellierens vortrainiert, wobei der Fokus darauf liegt, das nächste Wort in einer Sequenz vorherzusagen.
• Anwendungen:
  • BERT: Hauptsächlich für Verständnis-basierte Aufgaben wie Fragebeantwortung und Entitätserkennung verwendet.
  • GPT: Spezialisiert auf Aufgaben der Textgenerierung, wie kreatives Schreiben, Codegenerierung und Zusammenfassungen.

Große Sprachmodelle

Große Sprachmodelle (LLMs) sind fortgeschrittene Deep-Learning-Modelle, die dazu entwickelt wurden, menschenähnlichen Text zu verarbeiten und zu generieren, indem sie große Mengen natürlicher Sprachdaten verstehen. LLMs sind zentral für verschiedene Aufgaben der natürlichen Sprachverarbeitung (NLP), einschließlich Textgenerierung, Übersetzung, Zusammenfassung und Fragebeantwortung. Diese Modelle haben die Fähigkeit, Kontext, Syntax und Semantik zu verstehen, erheblich verbessert und sind daher für Anwendungen wie Chatbots, virtuelle Assistenten, maschinelle Übersetzung und Inhaltserstellung von entscheidender Bedeutung.

LLMs werden auf riesigen Datensätzen mit Milliarden von Wörtern vortrainiert, was es ihnen ermöglicht, die Komplexität der Sprache, einschließlich Grammatik, Kontext und Weltwissen, zu erlernen. Das Vortraining umfasst typischerweise Aufgaben wie Masked Language Modeling (wie bei BERT) oder die Vorhersage des nächsten Wortes (wie bei GPT). Sobald sie vortrainiert sind, werden LLMs auf spezifische Aufgaben feinabgestimmt, um ihre Leistung weiter zu verbessern.

Beispiel: Verwendung der Transformers-Bibliothek von Hugging Face

Eine der einfachsten Möglichkeiten, mit vortrainierten LLMs zu arbeiten, ist die Verwendung der ‘transformers‘-Bibliothek von Hugging Face. Unten ist ein Beispiel, wie man GPT-2 zur Textgenerierung verwendet:

from transformers import GPT2LMHeadModel, GPT2Tokenizer

# Vortrainiertes Modell und Tokenizer laden
model = GPT2LMHeadModel.from_pretrained('gpt2')
tokenizer = GPT2Tokenizer.from_pretrained('gpt2')

# Eingabetext kodieren
input_text = "In einer zukünftigen Welt, in der KI dominiert,"
inputs = tokenizer.encode(input_text, return_tensors='pt')

# Text generieren
outputs = model.generate(inputs, max_length=50, num_return_sequences=1)

# Generierten Text dekodieren und ausgeben
generated_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
print(generated_text)

Erklärung:

• Das GPT-2-Modell und der Tokenizer werden mit der ‘transformers‘-Bibliothek von Hugging Face geladen.
• Der Eingabetext wird in ein Format tokenisiert, das das Modell verarbeiten kann.
• Die Textgenerierung erfolgt durch die Erzeugung von bis zu 50 Tokens, und die Ausgabe wird in menschenlesbaren Text dekodiert.

LLMs haben die NLP revolutioniert, indem sie leistungsstarke Lösungen für eine Vielzahl von Aufgaben bieten:

• Chatbots und Virtuelle Assistenten: LLMs ermöglichen es konversationellen Agenten wie Siri, Alexa und Google Assistant, auf Benutzeranfragen mit natürlicher, kontextbezogener Sprache zu antworten.
• Textgenerierung: Tools wie GPT-3 generieren kohärenten, menschenähnlichen Text, von Artikeln bis hin zu Programmiercode.
• Maschinelle Übersetzung: LLMs werden verwendet, um Texte zwischen Sprachen zu übersetzen und liefern oft sehr genaue Übersetzungen.
• Zusammenfassung: LLMs können lange Dokumente in kürzere Versionen zusammenfassen und dabei die wichtigsten Informationen beibehalten.
• Codegenerierung: Modelle wie OpenAI Codex können Programmiercode aus Beschreibungen in natürlicher Sprache generieren und so Entwicklern bei der Softwareerstellung helfen.

Die Schlüsseltechnologie, die LLMs antreibt, ist die Transformer-Architektur. Jüngste Fortschritte haben jedoch zusätzliche Techniken eingeführt, um deren Leistung zu verbessern:

• Feinabstimmung (Fine-Tuning): LLMs werden oft auf allgemeine Textdaten vortrainiert und dann auf spezifische Aufgaben oder Domänen feinabgestimmt, um ihre Leistung in speziellen Bereichen zu verbessern (z.B. medizinische Texte, juristische Dokumente).
• Few-Shot- und Zero-Shot-Lernen: Moderne LLMs wie GPT-3 können neue Aufgaben mit minimalen Trainingsbeispielen (Few-Shot) oder sogar ohne spezifische Trainingsbeispiele (Zero-Shot) ausführen, was ihre Generalisierungsfähigkeit demonstriert.
• Prompt Engineering: LLMs können durch sorgfältig formulierte Prompts zu spezifischen Antworten geleitet werden, was mehr Kontrolle über ihre Ausgabe ermöglicht.
• Memory-Mechanismen und Umgang mit langen Kontexten: Einige LLMs sind darauf ausgelegt, lange Dokumente zu verarbeiten, indem sie ihr Kontextfenster erweitern und so größere Eingaben verarbeiten und generieren können.

Herausforderungen und Einschränkungen von LLMs

Trotz ihres Erfolgs stehen LLMs vor mehreren Herausforderungen:

• Halluzinationen: LLMs können ungenauen oder unsinnigen Text generieren, insbesondere wenn sie mit mehrdeutigen Eingaben konfrontiert werden.
• Vorurteile (Bias): Da LLMs auf großen, öffentlich verfügbaren Datensätzen trainiert werden, können sie unbeabsichtigt bestehende Vorurteile aus den Daten übernehmen und reproduzieren.
• Erklärbarkeit: LLMs werden oft als Black Boxes angesehen, was es schwierig macht zu verstehen, warum bestimmte Ausgaben generiert werden.
• Ressourcenintensiv: Das Training und der Einsatz von LLMs erfordern erhebliche Rechenleistung und Ressourcen, was Bedenken hinsichtlich der Nachhaltigkeit aufwirft.

Schlussfolgerungen in KI-Systemen

Schlussfolgern ist ein grundlegender Aspekt der KI und ermöglicht es Systemen, neue Informationen abzuleiten und Entscheidungen auf der Grundlage bekannter Fakten oder beobachteter Daten zu treffen. Traditionell wurde das Schlussfolgern in der KI in logikbasiertes und probabilistisches Schlussfolgern unterteilt, die beide für die Problemlösung in KI-Systemen von entscheidender Bedeutung sind.

Im Jahr 2024 erleben KI-Modelle einen revolutionären Wandel. Sie gehen über traditionelle Aufgaben wie Mustererkennung und Vorhersagen hinaus und entwickeln die Fähigkeit, durch komplexe, mehrstufige Probleme auf eine Weise zu schlussfolgern, die der menschlichen Kognition sehr nahekommt.

Die Einführung fortschrittlicher Schlussfolgerungstechniken, einschließlich Chain of Thought (CoT), Self-Consistency, Zero-Shot und Few-Shot-Prompting, markiert einen Wendepunkt in der Entwicklung der KI. Diese Techniken sind nicht nur theoretische Fortschritte, sondern werden aktiv in modernste Modelle wie die o1-Serie von OpenAI (eingesetzt am 12. September 2024) integriert, was eine neue Phase in der Fähigkeit der KI einleitet, zunehmend komplexe Aufgaben zu bewältigen.

Dieser Abschnitt befasst sich mit diesen aufkommenden Schlussfolgerungstechniken und untersucht, wie sie die Rolle der KI bei der Lösung anspruchsvoller Probleme verändern. Durch das Verständnis, wie diese Modelle mehrstufige Schlussfolgerungen angehen, können wir die weitreichenden Auswirkungen dieser aktuellen Entwicklung auf eine Vielzahl von Branchen und Disziplinen besser nachvollziehen.

Kategorien des Schlussfolgerns in KI

Das Schlussfolgern in der KI kann in drei Hauptkategorien unterteilt werden:

• Logikbasiertes Schlussfolgern
• Probabilistisches Schlussfolgern
• Fortgeschrittene Prompting-Techniken

Logikbasiertes Schlussfolgern

Beim logikbasierten Schlussfolgern werden formale Logik und vordefinierte Regeln verwendet, um Schlussfolgerungen aus bekannten Fakten abzuleiten. Dieser deterministische Ansatz wird in regelbasierten Systemen und Expertensystemen eingesetzt, bei denen Entscheidungen strikt nach logischen Schlussfolgerungen getroffen werden. Ein Beispiel ist, wenn ein System daraus schließt, dass Sokrates sterblich ist, basierend auf den Prämissen Alle Menschen sind sterblich und Sokrates ist ein Mensch.

Probabilistisches Schlussfolgern

Probabilistisches Schlussfolgern befasst sich mit Unsicherheit und unvollständigen Informationen. KI-Systeme verwenden probabilistische Modelle, wie Bayes’sche Netzwerke und Markov-Modelle, um die Wahrscheinlichkeit verschiedener Ergebnisse auf der Grundlage beobachteter Beweise abzuleiten. Dies ist in realen Szenarien unerlässlich, in denen Daten verrauscht oder unvollständig sind, wie z.B. bei medizinischen Diagnosen oder prädiktiver Analyse.

Fortgeschrittene Prompting-Techniken

Neue Fortschritte in der KI haben fortschrittliche Prompting-Techniken eingeführt, die die Schlussfolgerungsfähigkeiten von KI-Modellen verbessern. Zu diesen Techniken gehören:

• Chain of Thought (CoT) Prompting
• Self-Consistency Prompting
• Zero-Shot oder Few-Shot Prompting

Chain of Thought (CoT) Prompting

Chain of Thought (CoT) ist eine Schlussfolgerungstechnik, die KI-Modelle dazu ermutigt, Probleme in kleinere, handhabbare Schritte zu unterteilen. Anstatt eine sofortige, einstufige Antwort zu generieren, arbeitet die KI jeden Teil des Problems durch, um eine vollständige, logische Lösung zu entwickeln.
Funktionsweise von CoT: Bei CoT erzeugt das Modell Zwischenschritte des Denkprozesses, bevor es zur endgültigen Lösung kommt. Dieser Ansatz ist besonders nützlich bei komplexen Problemen, wie ingenieurtechnischen Berechnungen oder mehrstufigen Entscheidungsprozessen. Durch das Erklären jedes Schritts im Denkprozess verbessert das Modell die Transparenz und Interpretierbarkeit seiner Ergebnisse.
Vorteile von CoT: Der Hauptvorteil von CoT besteht in seiner Fähigkeit, die Genauigkeit zu verbessern. Durch das schrittweise Schlussfolgern können Modelle Fehler in Echtzeit erkennen und korrigieren, was in Disziplinen, in denen Fehlberechnungen zu fehlerhaften Ergebnissen führen können, von entscheidender Bedeutung ist.

Self-Consistency Prompting

Self-Consistency-Prompting beinhaltet die Erzeugung mehrerer Denkwege zur Lösung desselben Problems und die Auswahl der konsistentesten Ausgabe. Diese Technik ist besonders nützlich, um mit Unsicherheit bei komplexen Aufgaben umzugehen.
Funktionsweise von Self-Consistency: Bei Self-Consistency löst das Modell ein Problem mehrmals mit leicht unterschiedlichen Denkwegen. Die endgültige Antwort wird bestimmt, indem die häufigste oder konsistenteste Lösung aus diesen Versuchen ausgewählt wird. Dies ahmt nach, wie Experten schwierige Probleme angehen, indem sie mehrere Methoden ausprobieren und dann die zuverlässigste wählen.

Zero-Shot- und Few-Shot-Prompting

Zero-Shot- und Few-Shot-Prompting sind Techniken, die KI-Systemen helfen, über Aufgaben hinweg zu generalisieren, selbst wenn nur wenige oder keine Beispiele zur Verfügung stehen.

Zero-Shot-Prompting: Zero-Shot-Prompting bedeutet, dass das Modell aufgefordert wird, eine Aufgabe auszuführen, ohne dass zuvor Beispiele gegeben werden. Diese Technik ist in Domänen effektiv, in denen allgemeine Regeln auf spezifische Fälle angewendet werden können.

Few-Shot-Prompting: Few-Shot-Prompting beinhaltet, dass dem Modell einige Beispiele gegeben werden, bevor es aufgefordert wird, ein neues, aber verwandtes Problem zu lösen. Dieser Ansatz funktioniert gut in Bereichen, in denen historische Daten als Grundlage zur Bewältigung neuer Herausforderungen dienen können.

Anwendungen und Auswirkungen

Die Integration dieser fortschrittlichen Schlussfolgerungstechniken (Reasoning) in KI-Modelle wie die o1-Serie von OpenAI markiert eine neue Ära der KI-gestützten Problemlösung. Diese Modelle können Probleme ähnlich wie menschliche Experten durchdenken und ihre Fähigkeit verbessern, komplexe, mehrstufige Aufgaben zu lösen.

Schlussfolgerung im o1-Modell von OpenAI

Das o1-Modell von OpenAI führt einen innovativen Ansatz zum Schlussfolgern innerhalb großer Sprachmodelle (LLMs) ein. Das Modell verbessert seine Schlussfolgerungsfähigkeit durch eine neuartige Technik, die sogenannte Reasoning Tokens verwendet und es ermöglicht, mehrere Schlussfolgerungswege zu simulieren, bevor eine endgültige Antwort generiert wird:

• Mehrstufiges Schlussfolgern: Wenn ein Prompt empfangen wird, erzeugt das Modell Reasoning Tokens, die das Problem in verschiedene Ansätze unterteilen, ähnlich wie ein Mensch verschiedene Lösungswege in Betracht zieht.
• Reasoning Tokens: Diese Tokens werden intern vom Modell verwendet, um das Verständnis zu verfeinern, bevor die endgültige Ausgabe erstellt wird.
• Generierung der endgültigen Antwort: Nach dem Durchdenken dieser Ansätze produziert das Modell Completion Tokens, die dem Benutzer angezeigt werden.
• Kontextverwaltung: Die Reasoning Tokens werden nach jeder Interaktion verworfen, um den Kontext fokussiert zu halten und zu verhindern, dass Zwischenschritte das Ergebnis beeinträchtigen.

Dieser mehrstufige Schlussfolgerungsprozess erfolgt über ein großes Kontextfenster (bis zu 128.000 Tokens), was tiefere Schlussfolgerungen und Problemlösungen über mehrere Interaktionen hinweg ermöglicht. Durch die Integration von Schlussfolgerungsmechanismen in das Sprachmodell verbessert OpenAIs o1 seine Problemlösungsfähigkeiten und liefert genauere und kontextbezogene Antworten.

Vergleich von KI-Techniken

Die folgende Tabelle vergleicht maschinelles Lernen (ML), Deep Learning (DL), Large Language Models (LLMs), Wissensgraphen (KG) und Schlussfolgerung in Bezug auf mehrere Schlüsselmerkmale.

Die in der ersten Spalte der Tabelle aufgeführten Dimensionen beziehen sich auf Schlüsselmerkmale, die verschiedene KI-Techniken unterscheiden. Jede Dimension hebt eine spezifische Fähigkeit oder Eigenschaft der verglichenen Ansätze hervor. Diese Dimensionen sind wie folgt definiert:

• Informationsspeicherung: Diese Dimension bewertet, wie KI-Techniken Wissen speichern.
  • DL, ML, LLMs: Diese Modelle speichern Wissen implizit in den Gewichten neuronaler Netze, was den Zugriff oder die Schlussfolgerung auf die gespeicherten Informationen erschwert.
  • KG: Wissen wird explizit gespeichert, was einen einfachen Zugriff und transparentes Schlussfolgern auf der Grundlage bekannter Fakten und Beziehungen ermöglicht.
• Schlussfolgern: Misst die Fähigkeit von KI-Techniken, neues Wissen abzuleiten oder Entscheidungen zu treffen.
  • DL, ML: Konzentrieren sich auf Mustererkennung mit schwachen Schlussfolgerungsfähigkeiten.
  • LLMs: Bieten begrenztes Schlussfolgern, hauptsächlich assoziativ und auf Sprachmustern basierend.
  • KG: Bieten stark regelbasiertes Schlussfolgern, bei dem explizite Fakten und Logik angewendet werden können, um neues Wissen abzuleiten.
• Konnektivität höherdimensionaler Daten: Untersucht, wie KI-Modelle komplexe, vernetzte Daten handhaben.
  • DL, ML, LLMs: In der Lage, bestimmte Arten von höherdimensionalen Daten (z.B. Sequenzen, Bilder) zu verarbeiten.
  • KG: Hervorragend geeignet für den Umgang mit stark vernetzten und relationalen Daten.
• Halluzinationen: Bezieht sich auf die Generierung falscher oder erfundener Informationen.
  • DL, ML: Geringes Risiko, aber Überanpassung kann zu ungenauen Ergebnissen führen.
  • LLMs: Leiden häufig unter Halluzinationen, indem sie plausibel erscheinende, aber falsche Informationen generieren.
  • KG: Stützen sich auf faktische Daten und halluzinieren nicht, was zuverlässigere Ergebnisse liefert.
• Erklärbarkeit: Wie leicht der Entscheidungsprozess interpretiert werden kann.
  • DL, ML: Oft als „Black Boxes“ betrachtet, mit geringer Erklärbarkeit.
  • LLMs: Bieten moderate Erklärbarkeit, obwohl der Grund für die Ausgabe oft unklar bleibt.
  • KG: Bieten hohe Erklärbarkeit mit klaren und nachvollziehbaren Schritten hinter Schlussfolgerungen und Entscheidungen.
• Lernen aus Daten: Misst die Abhängigkeit des Modells von Daten zum Lernen.
  • DL, ML, LLMs: Benötigen große Mengen an gelabelten Daten für das Training und die Feinabstimmung.
  • KG: Lernen nicht auf dieselbe Weise aus Daten, sondern verlassen sich auf manuelle Kuratierung.
• Skalierbarkeit: Bezieht sich auf die Fähigkeit des Modells, mit zunehmender Komplexität oder größeren Datensätzen umzugehen.
  • DL, ML, LLMs: Hoch skalierbar, insbesondere bei Verwendung von GPU-Beschleunigung.
  • KG: Skalierbar, aber rechnerisch aufwendiger, insbesondere bei großen Datensätzen oder komplexen Abfragen.
• Aufgabenspezialisierung: Wie gut das Modell in bestimmten Domänen funktioniert.
  • DL, ML: Hoch spezialisiert in Aufgaben wie Bilderkennung oder Sprachverarbeitung.
  • LLMs: Allgemein einsetzbare Modelle, die in sprachbezogenen Aufgaben hervorragend sind, aber in spezialisierten Schlussfolgerungen an Tiefe mangeln.
  • KG: Spezialisieren sich auf wissensintensive Domänen und bieten starke Leistung, wo Beziehungen und Logik entscheidend sind.

Verweis auf die parallele Vorlesung

Dieser Kurs baut auf dem in der parallelen Vorlesung "Einführung in Computational und Artificial Intelligence (DAT504)" vermittelten Grundlagenwissen auf. Es wird dringend empfohlen, auf diese Konzepte zurückzugreifen, da sie für das Verständnis der in diesem Kurs behandelten praktischen Anwendungen von entscheidender Bedeutung sind. Die in jener Vorlesung besprochenen Prinzipien der KI bilden das Fundament für die fortgeschrittenen ingenieurwissenschaftlichen Themen in diesem Kurs und ermöglichen es den Studierenden, das Zusammenspiel von KI und verschiedenen Ingenieurprozessen vollständig zu erfassen.

• Die Kernkonzepte des Machine Learning (ML) und Deep Learning (DL) (siehe Kapitel 3) sind unerlässlich, um zu verstehen, wie KI-Systeme aus Daten lernen, um Vorhersagen und Entscheidungen in ingenieurtechnischen Anwendungen zu treffen.
• Die verschiedenen Techniken für ML und DL (siehe Kapitel 4), die in diesem Kurs eingeführt werden, verfeinern den Einsatz von KI in komplexen Problemlösungsszenarien und machen diese Techniken für die fortgeschrittene Integration von KI unverzichtbar.
• Die Anwendung des Reinforcement Learning (siehe Kapitel 5) erweitert den Einsatz von KI in dynamischen Umgebungen, in denen Agenten durch Interaktionen und Rückmeldungen lernen.
• Schließlich konzentriert sich die Bewertung und Verbesserung von KI-Modellen (siehe Kapitel 6) darauf, die Leistung der Modelle zu verfeinern und sicherzustellen, dass KI-gesteuerte Lösungen in realen ingenieurtechnischen Kontexten zuverlässig und effektiv sind.

Durch die Verbindung dieser Konzepte mit den praktischen KI-Anwendungen, die in diesem Kapitel behandelt werden, werden die Studierenden ihr Verständnis der Rolle von KI in der modernen Ingenieurwissenschaft vertiefen. Diese Schlüsseltechnologien der KI—ML, DL und Reinforcement Learning—treiben den technologischen Fortschritt in einer Vielzahl von Branchen voran. Die Fähigkeit, KI-Modelle zu bewerten und zu verbessern, ist entscheidend, um sicherzustellen, dass KI-Systeme auch in ihrer Weiterentwicklung effizient und anpassungsfähig bleiben.

Fazit

In diesem Abschnitt wurde ein umfassender Überblick über die grundlegenden Elemente der KI gegeben, wobei der Fokus auf Kernkonzepte wie ML, DL, KG, LLM und Schlussfolgerungstechniken lag. Diese Konzepte bilden die Bausteine für KI-gestützte Systeme, die verschiedene Branchen, darunter Ingenieurwesen, Gesundheitswesen und Finanzen, revolutionieren.

Wichtige Erkenntnisse

• KI zielt darauf ab, menschliche Intelligenz durch maschinelles Lernen, Deep Learning und Schlussfolgerungstechniken zu replizieren oder zu simulieren.
• Maschinelles Lernen beinhaltet Algorithmen, die es Maschinen ermöglichen, aus Daten zu lernen, ohne explizit programmiert zu werden, mit Anwendungen in verschiedenen Industrien.
• Deep Learning verwendet neuronale Netze mit mehreren Schichten, um automatisch Merkmale aus Rohdaten zu lernen, was es besonders nützlich für den Umgang mit unstrukturierten Daten wie Bildern und Texten macht.
• Wissensgraphen ermöglichen die explizite Speicherung von Fakten und Beziehungen zwischen Entitäten, was das Schlussfolgern und die Entscheidungsfindung auf der Grundlage komplexer, vernetzter Daten erleichtert.
• Große Sprachmodelle (LLMs) wie BERT und GPT brillieren bei Aufgaben der natürlichen Sprachverarbeitung und zeigen fortgeschrittene Fähigkeiten in der Textgenerierung, -zusammenfassung und Fragebeantwortung.
• Fortgeschrittene Schlussfolgerungstechniken wie Chain of Thought (CoT) und Self-Consistency ermöglichen es KI-Systemen, komplexe Probleme in kleinere, handhabbare Schritte zu unterteilen und ihre Problemlösungsfähigkeiten zu verbessern.
• KI-Techniken wie Wissensgraphen und LLMs sind entscheidend für ingenieurtechnische Anwendungen, da sie bei der Optimierung, der Systemmodellierung und der Automatisierung der Wissensabrufung helfen.