Neuronale Netze¶
Ein Neuronales Netz ist ein Rechenmodell, das von der Struktur biologischer Gehirne inspiriert ist. Es besteht aus verbundenen Knoten ("Neuronen"), die Informationen verarbeiten und weitergeben.
Grundstruktur¶
Ein klassisches neuronales Netz besteht aus Schichten (Layers):
graph LR
subgraph "Input Layer"
I1((x₁))
I2((x₂))
I3((x₃))
end
subgraph "Hidden Layer"
H1((h₁))
H2((h₂))
end
subgraph "Output Layer"
O1((y))
end
I1 --> H1
I1 --> H2
I2 --> H1
I2 --> H2
I3 --> H1
I3 --> H2
H1 --> O1
H2 --> O1| Schicht | Funktion |
|---|---|
| Input Layer | Nimmt Rohdaten entgegen |
| Hidden Layers | Verarbeitung & Feature-Extraktion |
| Output Layer | Produziert das Ergebnis |
Das künstliche Neuron¶
Ein einzelnes Neuron macht drei Dinge:
- Gewichtete Summe der Inputs berechnen
- Bias addieren
- Aktivierungsfunktion anwenden
def neuron(inputs, weights, bias, activation_fn):
weighted_sum = sum(x * w for x, w in zip(inputs, weights))
return activation_fn(weighted_sum + bias)
Analogie
Wie ein Entscheider: Sammelt Informationen (Inputs), gewichtet ihre Wichtigkeit (Weights), hat eine Grundtendenz (Bias), und trifft dann eine Entscheidung (Aktivierung).
Forward Pass¶
Der Weg der Daten durch das Netz:
def forward(x, weights, biases):
# Layer 1
h = relu(x @ weights[0] + biases[0])
# Layer 2
y = softmax(h @ weights[1] + biases[1])
return y
Bei jedem Layer: 1. Matrixmultiplikation mit Gewichten 2. Bias addieren 3. Aktivierungsfunktion anwenden
Aktivierungsfunktionen¶
Ohne Aktivierungsfunktion wäre das Netz nur eine lineare Transformation – egal wie viele Layer. Aktivierungen bringen Nicht-Linearität:
| Funktion | Formel | Einsatz |
|---|---|---|
| ReLU | \(\max(0, x)\) | Hidden Layers (Standard) |
| GELU | \(x \cdot \Phi(x)\) | Transformer |
| Sigmoid | \(\frac{1}{1+e^{-x}}\) | Binary Classification |
| Softmax | \(\frac{e^{x_i}}{\sum e^{x_j}}\) | Multi-Class Output |
| Tanh | \(\frac{e^x - e{-x}}{ex + e^{-x}}\) | RNNs (historisch) |
→ Mehr Details: Aktivierungsfunktionen
Training: Wie lernt ein Netz?¶
Das Ziel: Finde Gewichte und Biases, die den Fehler minimieren.
graph LR
A[Input] --> B[Forward Pass]
B --> C[Prediction]
C --> D[Loss berechnen]
D --> E[Backpropagation]
E --> F[Gewichte updaten]
F --> B- Forward Pass: Berechne Output für Input
- Loss: Miss den Fehler (z.B. Cross-Entropy)
- Backpropagation: Berechne Gradienten
- Update: Passe Gewichte an
→ Details: Backpropagation, Loss Function
Typen neuronaler Netze¶
| Typ | Struktur | Anwendung |
|---|---|---|
| Feedforward (MLP) | Daten fließen nur vorwärts | Klassifikation, Regression |
| Convolutional (CNN) | Filter für räumliche Muster | Bilder, Computer Vision |
| Recurrent (RNN) | Loops für Sequenzen | Text, Zeitreihen (veraltet) |
| Transformer | Attention-basiert | NLP, LLMs, Vision |
Deep Learning¶
Deep Learning = Neuronale Netze mit vielen Schichten.
Warum tief?
- Frühe Schichten lernen einfache Features (Kanten, Farben)
- Tiefere Schichten kombinieren zu komplexen Konzepten (Gesichter, Objekte)
Layer 1: Erkennt Kanten
Layer 2: Erkennt Formen
Layer 3: Erkennt Objektteile
Layer 4: Erkennt Objekte
...
Layer N: Versteht Konzepte
Vanishing Gradients
Früher konnten sehr tiefe Netze nicht trainiert werden – Gradienten wurden zu klein. Gelöst durch ReLU, Residual Connections und bessere Initialisierung.
Parameter & Größe¶
Die Parameter eines Netzes sind alle trainierbaren Werte:
- Gewichte (Weights)
- Biases
# Beispiel: 3-Layer MLP
# Input: 784, Hidden: 256, Output: 10
params_layer1 = 784 * 256 + 256 # ~200k
params_layer2 = 256 * 256 + 256 # ~65k
params_layer3 = 256 * 10 + 10 # ~2.5k
total = ~270.000 Parameter
Moderne LLMs haben Milliarden von Parametern.
Mathematische Notation¶
Ein Layer als Matrix-Operation:
- \(\mathbf{x}\): Input-Vektor
- \(\mathbf{W}\): Weight-Matrix
- \(\mathbf{b}\): Bias-Vektor
- \(\sigma\): Aktivierungsfunktion
- \(\mathbf{h}\): Output (Hidden State)
Das ist der Grundbaustein, der in jedem Layer wiederholt wird.