Deep Learning

Was ist Deep Learning?

Deep Learning (DL) bezeichnet das Training von mehrschichtigen neuronalen Netzen, die hierarchische Repräsentationen von Daten erlernen. Jede Schicht extrahiert dabei abstraktere Merkmale als die vorherige – ein Bild-Netzwerk erkennt zuerst Kanten, dann Formen, dann Objekte.

Der Begriff "tief" bezieht sich auf die Anzahl der versteckten Schichten (Hidden Layers): Moderne Modelle wie GPT-4 oder ResNet haben Hunderte davon.

Warum ist Deep Learning so mächtig?

• Automatisches Feature Engineering: Klassisches ML erfordert handgefertigte Features – DL lernt sie selbst.
• Skalierbarkeit: Mehr Daten + mehr Parameter = bessere Leistung (Scaling Laws).
• Universelle Anwendbarkeit: Sprache, Bilder, Audio, Code – alles mit demselben Grundprinzip.

Typische Architekturen

Architektur	Einsatzgebiet
CNN (Convolutional Neural Network)	Computer Vision
RNN / LSTM	Sequenzdaten, Zeit­reihen
Transformer	NLP, LLMs, Multimodal
Diffusion Model	Bild-/Audiogenerierung

Minimales Beispiel mit PyTorch

import torch
import torch.nn as nn

# Einfaches tiefes Netz mit 3 Hidden Layers
class SimpleDeepNet(nn.Module):
    def __init__(self, input_dim=784, num_classes=10):
        super().__init__()
        self.network = nn.Sequential(
            nn.Linear(input_dim, 512),
            nn.ReLU(),
            nn.Linear(512, 256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.ReLU(),
            nn.Linear(128, num_classes)
        )

    def forward(self, x):
        return self.network(x)

model = SimpleDeepNet()
x = torch.randn(32, 784)  # Batch von 32 MNIST-Bildern
logits = model(x)
print(logits.shape)  # torch.Size([32, 10])

Training-Loop im Überblick

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
criterion = nn.CrossEntropyLoss()

for epoch in range(10):
    for X_batch, y_batch in dataloader:
        optimizer.zero_grad()
        predictions = model(X_batch)
        loss = criterion(predictions, y_batch)
        loss.backward()   # Backpropagation
        optimizer.step()  # Gewichte aktualisieren
    print(f"Epoch {epoch+1}, Loss: {loss.item():.4f}")

Typische Herausforderungen

• Overfitting: Das Modell memoriert Trainingsdaten statt zu generalisieren → Dropout, Regularisierung, mehr Daten.
• Rechenaufwand: Training großer Netze erfordert GPUs/TPUs über Stunden bis Wochen.
• Hyperparameter-Tuning: Learning Rate, Batch Size, Architektur müssen sorgfältig gewählt werden.
• Interpretierbarkeit: Tiefe Netze sind oft "Black Boxes".

Bezug zu modernen LLMs

Large Language Models wie GPT, Claude oder Llama sind Deep-Learning-Modelle – konkret riesige Transformer-Netzwerke. Das Verständnis von Deep Learning ist die Grundlage, um Fine-Tuning, LoRA oder RLHF wirklich zu verstehen.