02_02_ LLms Struktur
This commit is contained in:
centron\schwoerer
@@ -95,7 +95,7 @@ In der Praxis unterscheiden sich Artefakte darin, wie direkt sie fachliche Aussa
|
||||
|
||||
Diese Einteilung dient der Risikobewertung: Requirements, die überwiegend auf Sekundär- oder Kontextbelegen beruhen, sind anfälliger für Fehlinterpretation und sollten priorisiert validiert werden. Datenbankschemata und SQL-Statements sind häufig besonders aussagekräftig, weil sie Domänenobjekte, Kardinalitäten und Geschäftsregeln (z. B. referentielle Integrität, historisierte Tabellen) abbilden.
|
||||
|
||||
_Für diese Arbeit werden in der Schrittkette nur Punk 1 und 7 manuell durchgeführt, während die Schritte 2-6 durch KI-gestützte Analyse automatisiert werden sollen._
|
||||
_Für diese Arbeit werden in der Schrittkette lediglich Punk 1 und 7 manuell durchgeführt, während die Schritte 2-6 durch KI-gestützte Analyse automatisiert werden sollen._
|
||||
|
||||
/*
|
||||
#heading(level: 3)[Zwischenfazit zu 2.1]
|
||||
|
||||
@@ -1,32 +1,151 @@
|
||||
#import "@preview/cetz:0.4.2"
|
||||
#import "@preview/cetz-plot:0.1.3": plot
|
||||
#pagebreak()
|
||||
#heading(level: 2)[Large Language Models im Software Engineering]
|
||||
|
||||
#heading(level: 3)[Künstliche Intelligenz, Machine Learning und Einordnung von LLMs]
|
||||
|
||||
Künstliche Intelligenz (KI) ist ein Oberbegriff für Verfahren, die Aufgaben bearbeiten, die in der Praxis typischerweise kognitive Fähigkeiten erfordern (z. B. Klassifikation, Planung, Sprachverarbeitung). Machine Learning (ML) ist dabei ein Teilgebiet, das Modelle aus Daten lernt, anstatt Regeln vollständig manuell zu spezifizieren. In der gängigen Einordnung wird zwischen überwachtem Lernen (mit Zielwerten), unüberwachtem Lernen (Struktur in Daten) und Reinforcement Learning (Lernen über Rückmeldesignale) unterschieden @bishop2006prml @goodfellow2016dl.
|
||||
Die Einordnung von Large Language Models folgt einer hierarchischen Begriffsstruktur, die sich in vier Ebenen gliedern lässt (vgl. @abb_hierarchie_ki):
|
||||
|
||||
Deep Learning bezeichnet ML-Verfahren, die neuronale Netze mit vielen Parametern und mehreren Verarbeitungsebenen nutzen, um geeignete Repräsentationen aus Rohdaten zu lernen. Charakteristisch ist, dass Merkmalsextraktion und Modellanpassung gemeinsam über Optimierung (typischerweise Gradientenverfahren) erfolgen. #cite(<lecun2015deeplearning>, form: "prose") beschreiben Deep Learning als zentrale Entwicklungslinie moderner KI, insbesondere für Wahrnehmungs- und Sprachaufgaben.
|
||||
*Künstliche Intelligenz (KI)* ist der Oberbegriff für Verfahren, die Aufgaben bearbeiten, welche in der Praxis typischerweise kognitive Fähigkeiten erfordern (z. B. Klassifikation, Planung, Sprachverarbeitung) @bishop2006prml.
|
||||
|
||||
Neuronale Netze lassen sich dabei vereinfacht als parametrisierte Funktionsketten aus Schichten beschreiben, die Eingaben in zunehmend abstrakte Repräsentationen überführen. Das Training erfolgt über eine Zielfunktion (Loss) und Gradientenberechnung, praktisch meist über Backpropagation und Varianten des Gradientenabstiegs @goodfellow2016dl.
|
||||
*Machine Learning (ML)* ist ein Teilgebiet der KI, das Modelle aus Daten lernt, anstatt Regeln vollständig manuell zu spezifizieren (sogennante Expertensysteme). in der Praxis wird zwischen Systemen mit überwachtem Lernen (mit Zielwerten), unüberwachtem Lernen (ohne Zielwerte, System erkennt selbst eine Struktur) und Reinforcement Learning (Lernen über Rückmeldung, z.B. Ergebnis Richtig / Falsch) unterschieden @bishop2006prml @goodfellow2016dl. In der heutigen Welt sind Neuronale Netze die dominierende ML-Architektur, insbesondere für unstrukturierte Daten wie Text und Code.
|
||||
|
||||
*Deep Learning* ist wiederum ein Teilbereich von ML, der neuronale Netze mit vielen Parametern und vielen (tiefen) Verarbeitungsebenen nutzt, um geeignete Repräsentationen aus Rohdaten zu lernen. Charakteristisch ist, dass Merkmalsextraktion und Modellanpassung gemeinsam über Optimierung (typischerweise Gradientenverfahren) erfolgen.
|
||||
|
||||
*Large Language Models (LLMs)* sind eine spezielle Ausprägung von Neuronalen Netzen, die auf sehr großen Text- und Codemengen vortrainiert werden. Zudem verfügen sie über sehr große Mengen (>Milliarden) von Eingabeparametern (Tokens) und viele Schichten (>100). In der aktuellen Modellgeneration dominiert die Transformer-Architektur @vaswani2017attention, deren Funktionsweise in den folgenden Abschnitten erläutert wird.
|
||||
|
||||
#figure(
|
||||
image("../../Abbildungen/abb_2_1_feedforward_nn.png", width: 85%),
|
||||
cetz.canvas({
|
||||
import cetz.draw: *
|
||||
|
||||
rect((-6, -2.8), (6, 2.8), stroke: black + 0.6pt, fill: luma(242))
|
||||
content((0, 2.35), text(size: 9pt, weight: "bold")[Künstliche Intelligenz (KI)])
|
||||
|
||||
rect((-5.4, -2.2), (5.4, 1.9), stroke: black + 0.6pt, fill: luma(228))
|
||||
content((0, 1.45), text(size: 9pt, weight: "bold")[Machine Learning (ML)])
|
||||
|
||||
rect((-4.8, -1.6), (4.8, 1.0), stroke: black + 0.6pt, fill: luma(214))
|
||||
content((0, 0.55), text(size: 9pt, weight: "bold")[Deep Learning])
|
||||
|
||||
rect((-4.2, -1.0), (4.2, 0.1), stroke: black + 0.6pt, fill: luma(200))
|
||||
content((0, -0.45), text(size: 9pt, weight: "bold")[Large Language Models (LLMs)])
|
||||
}),
|
||||
caption: [Hierarchische Einordnung: KI ⊃ ML ⊃ Deep Learning ⊃ LLMs.],
|
||||
) <abb_hierarchie_ki>
|
||||
#pagebreak()
|
||||
*Neuronale Netze* lassen sich vereinfacht als parametrisierte Funktionsketten aus Schichten (Layern) beschreiben. Dabei geben die Schichten die Eingaben in zunehmend abstrakte Repräsentationen jeweils in die nächste Schicht weiter. Das Training erfolgt über eine Zielfunktion und Gradientenberechnung. In der Praxis geschieht dies meist über Backpropagation und Varianten des Gradientenabstiegs @goodfellow2016dl.
|
||||
|
||||
#figure(
|
||||
cetz.canvas({
|
||||
import cetz.draw: *
|
||||
|
||||
let r = 0.35
|
||||
let lx = 3.0
|
||||
let ny = 1.5
|
||||
|
||||
let ys-3 = (ny, 0, -ny)
|
||||
let ys-2 = (ny / 2, -ny / 2)
|
||||
|
||||
let layers = (
|
||||
(x: 0, ys: ys-3, labels: ($x_1$, $x_2$, $x_3$)),
|
||||
(x: lx, ys: ys-3, labels: ($h_1$, $h_2$, $h_3$)),
|
||||
(x: 2 * lx, ys: ys-2, labels: ($y_1$, $y_2$)),
|
||||
)
|
||||
|
||||
// Kanten (zuerst zeichnen, damit Knoten darüber liegen)
|
||||
for li in range(layers.len() - 1) {
|
||||
let l1 = layers.at(li)
|
||||
let l2 = layers.at(li + 1)
|
||||
for y1 in l1.ys {
|
||||
for y2 in l2.ys {
|
||||
line(
|
||||
(l1.x, y1), (l2.x, y2),
|
||||
stroke: luma(160) + 0.4pt,
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Knoten
|
||||
for layer in layers {
|
||||
for (i, y) in layer.ys.enumerate() {
|
||||
circle((layer.x, y), radius: r, stroke: black + 0.6pt, fill: white)
|
||||
content((layer.x, y), layer.labels.at(i))
|
||||
}
|
||||
}
|
||||
|
||||
// Schichtbeschriftungen
|
||||
let label-y = ny + 0.9
|
||||
content((0, label-y), text(size: 9pt)[Eingabe])
|
||||
content((lx, label-y), text(size: 9pt)[Verdeckte Schicht])
|
||||
content((2 * lx, label-y), text(size: 9pt)[Ausgabe])
|
||||
}),
|
||||
caption: [Schematische Darstellung eines vollständig verbundenen Feedforward-Netzes.]
|
||||
)
|
||||
|
||||
Ein einzelnes Neuron lässt sich als affine Transformation mit nachgeschalteter Aktivierungsfunktion formulieren:
|
||||
Ein einzelnes Neuron lässt sich als Transformation mit nachgeschalteter Aktivierungsfunktion formulieren:
|
||||
|
||||
$
|
||||
z = sum_(i=1)^d w_i x_i + b, #h(1em) a = phi (z)
|
||||
$
|
||||
|
||||
Typische Aktivierungsfunktionen sind die Sigmoid-Funktion und ReLU #cite(<goodfellow2016dl>):
|
||||
Typische Aktivierungsfunktionen ($a = phi (z)$) sind die Sigmoid-Funktion, der hyperbolische Tangens und ReLU #cite(<goodfellow2016dl>):
|
||||
|
||||
$
|
||||
sigma (z) = 1 / (1 + e^(-z)), #h(1em) op("ReLU") (z) = op("max") (0, z)
|
||||
$
|
||||
#grid(
|
||||
columns: (1fr, 1fr, 1fr),
|
||||
align: center,
|
||||
column-gutter: 0.8em,
|
||||
row-gutter: 0.4em,
|
||||
text(weight: "bold")[Sigmoid],
|
||||
text(weight: "bold")[tanh],
|
||||
text(weight: "bold")[ReLU],
|
||||
$ sigma(z) = frac(1, 1 + e^(-z)) $,
|
||||
$ tanh(z) = frac(e^z - e^(-z), e^z + e^(-z)) $,
|
||||
$ op("ReLU")(z) = max(0, z) $,
|
||||
)
|
||||
|
||||
#figure(
|
||||
image("../../Abbildungen/abb_2_2_aktivierungsfunktionen.png", width: 85%),
|
||||
cetz.canvas({
|
||||
import cetz.draw: *
|
||||
|
||||
plot.plot(
|
||||
size: (12, 7),
|
||||
x-tick-step: 2,
|
||||
y-tick-step: 1,
|
||||
x-min: -6, x-max: 6,
|
||||
y-min: -1.5, y-max: 6.5,
|
||||
x-label: $x$,
|
||||
y-label: $phi(x)$,
|
||||
legend: "north-west",
|
||||
{
|
||||
plot.add(
|
||||
style: (stroke: blue + 1.2pt),
|
||||
domain: (-6, 6),
|
||||
samples: 200,
|
||||
label: [$sigma(x)$ (Sigmoid)],
|
||||
x => 1 / (1 + calc.exp(-x)),
|
||||
)
|
||||
plot.add(
|
||||
style: (stroke: orange + 1.2pt),
|
||||
domain: (-6, 6),
|
||||
samples: 200,
|
||||
label: [$tanh(x)$],
|
||||
x => {
|
||||
let e2x = calc.exp(2 * x)
|
||||
(e2x - 1) / (e2x + 1)
|
||||
},
|
||||
)
|
||||
plot.add(
|
||||
style: (stroke: green.darken(20%) + 1.2pt),
|
||||
domain: (-6, 6),
|
||||
samples: 200,
|
||||
label: [ReLU $max(0, x)$],
|
||||
x => calc.max(0, x),
|
||||
)
|
||||
},
|
||||
)
|
||||
}),
|
||||
caption: [Beispielhafte Aktivierungsfunktionen (Sigmoid, tanh, ReLU).]
|
||||
)
|
||||
|
||||
@@ -36,82 +155,39 @@ $
|
||||
theta^(t+1) = theta^(t) - eta nabla_theta cal(L) (theta^(t))
|
||||
$
|
||||
|
||||
**Abgrenzung neuronaler Netze und LLMs zu anderen ML-Methoden**
|
||||
|
||||
Neuronale Netze sind ein Teilbereich von ML, sie ersetzen jedoch nicht automatisch klassische Verfahren. In der Praxis hängt die Methodenauswahl von Datenart, Datenmenge, Interpretierbarkeit und Betriebsvorgaben ab @bishop2006prml @hastie2009esl.
|
||||
LLMs unterscheiden sich von klassischen neuronalen Netzen nicht nur durch ihre Modellgröße, sondern vor allem durch ihre Zielsetzung: Sie sind Sprachmodelle -- Systeme, die Wahrscheinlichkeiten über Tokenfolgen schätzen und dadurch Texte fortsetzen, bewerten oder erzeugen können. Der Verarbeitungsablauf folgt dabei einem wiederkehrenden Muster.
|
||||
Zunächst wird die Texteingabe in Token zerlegt. Token sind die kleinsten Verarbeitungseinheiten des Modells. je nach Tokenisierungsverfahren können dies Wörter, Wortteile oder einzelne Zeichen sein. Der Satz „Das System prüft den Status" wird beispielsweise in die Folge [„Das", „System", „prüft", „den", „Status"] überführt. Für Quellcode gilt dasselbe Prinzip: Identifier, Schlüsselwörter und Operatoren werden in Einheiten aufgeteilt @goodfellow2016dl.
|
||||
|
||||
Die folgende Tabelle fasst die Abgrenzung zu häufigen ML-Familien zusammen:
|
||||
Die resultierende Tokenfolge bildet den Kontext des Modells. Der Kontext umfasst alle Token, die das Modell in einem Verarbeitungsschritt gleichzeitig berücksichtigt. Aktuelle Modelle besitzen Kontextfenster von mehreren tausend bis über eine Million Token. Eingaben, die dieses Fenster überschreiten, müssen segmentiert oder komprimiert werden.
|
||||
|
||||
#figure(
|
||||
kind: "table",
|
||||
supplement: [Tabelle],
|
||||
caption: [Abgrenzung zu häufigen Machine-Learning-Methoden.],
|
||||
table(
|
||||
columns: (1fr, 1.35fr, 1.2fr, 1.6fr),
|
||||
align: (left, left, left, left),
|
||||
[**Methodik**],
|
||||
[**Typischer Einsatz**],
|
||||
[**Stärken**],
|
||||
[**Grenzen**],
|
||||
[Lineare/GLM-Modelle],
|
||||
[Strukturierte Daten, Baselines],
|
||||
[schnell, gut interpretierbar],
|
||||
[begrenzte Nichtlinearität (ohne Feature Engineering)],
|
||||
[Support Vector Machines (SVM)],
|
||||
[Klassifikation/Regression, mittlere Datenmengen],
|
||||
[starke Theorie, robuste Margin-Idee],
|
||||
[Skalierung/Kernelwahl, eingeschränkte Erklärbarkeit @cortes1995svm],
|
||||
[Entscheidungsbäume/Ensembles],
|
||||
[Tabellarische Daten],
|
||||
[nichtlinear, oft gute Performance],
|
||||
[Overfitting ohne Regularisierung; Ensembles weniger interpretierbar],
|
||||
[Random Forests],
|
||||
[Tabellarische Daten, robuste Defaults],
|
||||
[stabil, gute Generalisierung],
|
||||
[begrenzte Extrapolation, Erklärbarkeit indirekt @breiman2001randomforests],
|
||||
[Gradient Boosting],
|
||||
[Tabellarische Daten, hohe Genauigkeit],
|
||||
[sehr starke Praxisleistung],
|
||||
[Hyperparameter-sensitiv, Trainingskosten @friedman2001gbm],
|
||||
[Neuronale Netze (Deep Learning)],
|
||||
[Unstrukturierte Daten (Text, Bild), große Datenmengen],
|
||||
[Representation Learning, End-to-End],
|
||||
[hoher Daten-/Rechenbedarf, schwerer zu erklären @lecun2015deeplearning],
|
||||
[LLMs (Transformers)],
|
||||
[Text- und Codeaufgaben, generative Assistenz],
|
||||
[Vortraining nutzt große Korpora; flexible Transferleistung],
|
||||
[Halluzinationen, Kontextlimit, Governance-Aufwand @vaswani2017attention @ji2023hallucination],
|
||||
)
|
||||
)
|
||||
|
||||
LLMs unterscheiden sich dabei von vielen klassischen Verfahren nicht nur durch Modellgröße, sondern auch durch Zielsetzung: Häufig wird ein generatives, autoregressives Sprachmodell trainiert, das die nächste Tokenwahrscheinlichkeit modelliert:
|
||||
Auf Basis des Kontexts berechnet das Modell eine Wahrscheinlichkeitsverteilung über alle möglichen nächsten Token. Das gewählte Token wird an die bisherige Folge angefügt, und die erweiterte Folge dient als Eingabe für den nächsten Berechnungsschritt. Dieser Prozess wiederholt sich, bis ein Abbruchkriterium erreicht ist (z. B. ein Stopptoken oder eine maximale Ausgabelänge). Da das Modell jedes Token statistisch aus dem bisherigen Kontext ableitet, können Ausgaben sprachlich konsistent wirken, ohne dass fachliche Korrektheit gewährleistet ist. Formal lässt sich das Trainingsziel als Maximierung der bedingten Log-Likelihood beschreiben:
|
||||
|
||||
$
|
||||
max_(theta) sum_(t=1)^T log p_(theta) (x_t mid x_(<t))
|
||||
$
|
||||
|
||||
Für das Requirements Engineering ist diese Abgrenzung wichtig, weil LLMs aufgrund ihrer generativen Natur Texte produzieren können, die sprachlich konsistent wirken, aber fachlich falsch sein können. Klassische Modelle liefern in solchen Fällen eher „falsche Vorhersagen", erzeugen jedoch nicht ohne weiteres neue, plausibel klingende Spezifikationen.
|
||||
Hierbei bezeichnet $x_(<t)$ die bisherige Tokenfolge und $p_(theta)(x_t mid x_(<t))$ die vom Modell geschätzte Wahrscheinlichkeit für das nächste Token $x_t$.
|
||||
|
||||
Für die Sprachverarbeitung ist der Begriff "Sprachmodell" relevant: Ein Sprachmodell schätzt Wahrscheinlichkeiten über Tokenfolgen und kann dadurch Texte fortsetzen oder bewerten. Large Language Models (LLMs) sind eine Ausprägung solcher Sprachmodelle, die auf Deep-Learning-Architekturen beruhen und auf sehr großen Korpora vortrainiert werden. In der aktuellen Modellgeneration dominiert die Transformer-Architektur, deren Kernprinzip die Self-Attention ist @vaswani2017attention.
|
||||
|
||||
Self-Attention lässt sich im Transformer formal als gewichtete Kombination von Value-Vektoren beschreiben, wobei die Gewichte aus Query-Key-Ähnlichkeiten berechnet werden #cite(<vaswani2017attention>):
|
||||
In der aktuellen Modellgeneration dominiert die Transformer-Architektur @vaswani2017attention, deren Kernmechanismus die Self-Attention ist. Self-Attention ermöglicht es dem Modell, bei der Verarbeitung jedes Tokens die Beziehungen zu allen anderen Token im Kontext zu gewichten. Formal wird dies als gewichtete Kombination von Value-Vektoren beschrieben, wobei die Gewichte aus Query-Key-Ähnlichkeiten berechnet werden #cite(<vaswani2017attention>):
|
||||
|
||||
$
|
||||
op("Attention") (Q, K, V) = op("softmax") ((Q K^T) / sqrt(d_k)) V
|
||||
$
|
||||
|
||||
/*
|
||||
#figure(
|
||||
image("../../Abbildungen/abb_2_3_attention_heatmap.png", width: 85%),
|
||||
caption: [Schematisches Beispiel einer Attention-Gewichtsmatrix (illustrativ).]
|
||||
)
|
||||
*/
|
||||
|
||||
Für diese Arbeit sind drei Konsequenzen dieser Modellklasse besonders relevant:
|
||||
_Für diese Arbeit sind drei Konsequenzen dieser Modellklasse besonders relevant:_
|
||||
|
||||
- **Kontextfenster:** Modelle verarbeiten Eingaben nur bis zu einer maximalen Tokenanzahl. Längere Artefakte müssen segmentiert oder komprimiert werden.
|
||||
- **Tokenisierung:** Quellcode und Fachsprache werden in Token zerlegt. Dies beeinflusst, wie gut Identifier, Struktur und Domänenterminologie repräsentiert werden.
|
||||
- **Generativer Charakter:** Ausgaben sind nicht deterministisch. Temperatur, Sampling-Strategien und Promptform beeinflussen Reproduzierbarkeit.
|
||||
_- *Kontextfenster:* Modelle verarbeiten Eingaben nur bis zu einer maximalen Tokenanzahl. Längere Artefakte müssen segmentiert oder komprimiert werden.
|
||||
- *Tokenisierung:* Quellcode und Fachsprache werden in Token zerlegt. Dies beeinflusst, wie gut Identifier, Struktur und Domänenterminologie repräsentiert werden.
|
||||
- *Generativer Charakter:* Ausgaben sind nicht deterministisch. Temperatur, Sampling-Strategien und Promptform beeinflussen Reproduzierbarkeit._
|
||||
|
||||
LLMs werden im Software Engineering eingesetzt, weil sie sowohl natürlichsprachliche Artefakte (z. B. Anforderungen, Kommentare) als auch Codeartefakte (z. B. Klassen, Funktionen, Tests) verarbeiten können. Surveyarbeiten ordnen LLM-Anwendungen nach Aufgabenklassen wie Codegenerierung, Codezusammenfassung, Fehlersuche, Testgenerierung oder Dokumentation @fan2023llmse @salem2024surveyllmse @llm4se2024slr @llm4se2024survey.
|
||||
_LLMs werden im Software Engineering eingesetzt, weil sie sowohl natürlichsprachliche Artefakte (z. B. Anforderungen, Kommentare) als auch Codeartefakte (z. B. Klassen, Funktionen, Tests) verarbeiten können. Surveyarbeiten ordnen LLM-Anwendungen nach Aufgabenklassen wie Codegenerierung, Codezusammenfassung, Fehlersuche, Testgenerierung oder Dokumentation_ @fan2023llmse @salem2024surveyllmse @llm4se2024slr @llm4se2024survey.
|
||||
|
||||
#heading(level: 3)[Training, Instruction Tuning und Prompting]
|
||||
|
||||
|
||||
Reference in New Issue
Block a user