Neuronale Netze, einfach erklärt für Anfänger: Fang hier an, falls sie dich verwirrt haben.

Neuronale Netze, einfach erklärt für Anfänger: Fangt hier an, wenn sie euch verwirrt haben

Wenn ihr euch jemals von der Fachsprache rund um neuronale Netze überwältigt gefühlt habt – Neuronen, Schichten, Backpropagation, Aktivierungsfunktionen – seid ihr nicht allein. Die gute Nachricht ist, dass die Kernidee überraschend einfach ist. Ein neuronales Netz ist ein rechenbasiertes System, das von der Art und Weise inspiriert ist, wie biologische Gehirne Informationen verarbeiten. In der Praxis ist es jedoch ein mathematisches Modell, das Muster aus Daten lernt. Dieser Artikel wird die Verwirrung beseitigen, euch ein klares mentales Modell geben und euch durch ein echtes, funktionierendes Beispiel führen, das ihr auf eurem eigenen Computer ausführen könnt.

Am Ende werdet ihr verstehen, was ein neuronales Netz tut, wie es lernt, und ihr werdet selbst eines gebaut und trainiert haben.

Was ist ein neuronales Netz wirklich?

Im einfachsten Fall ist ein neuronales Netz eine Funktion, die Eingaben auf Ausgaben abbildet. Stellt euch eine Tabelle mit Hauspreisen vor: Quadratmeterzahl, Anzahl der Schlafzimmer und Lage. Ihr möchtet den Preis vorhersagen. Ein neuronales Netz lernt die Beziehung zwischen diesen Eingaben und der Ausgabe (Preis), indem es interne Parameter, sogenannte *Gewichte* und *Bias*, anpasst.

Ein neuronales Netz besteht aus Schichten von *Neuronen*. Jedes Neuron nimmt eine Reihe von Eingaben, multipliziert jede mit einem Gewicht, addiert einen Bias und wendet eine *Aktivierungsfunktion* an, um eine Ausgabe zu erzeugen. Diese Ausgabe wird zur Eingabe für die nächste Schicht. Die letzte Schicht erzeugt die Vorhersage des Netzes.

Stellt es euch wie eine Kette einfacher Berechnungen vor. Jedes Neuron ist eine winzige Entscheidungsinstanz. Wenn ihr Hunderte oder Tausende davon stapelt, kann das Netz sehr komplexe Muster modellieren.

Wichtige Konzepte, die ihr kennen müsst

Bevor wir in den Code eintauchen, klären wir ein paar Begriffe, die oft für Verwirrung sorgen.

Neuronen und Schichten

• **Eingabeschicht**: Die rohen Daten, die ihr einspeist (z. B. Quadratmeterzahl, Anzahl der Schlafzimmer).
• **Verborgene Schichten**: Schichten zwischen Eingabe und Ausgabe. Sie transformieren die Daten. Mehr verborgene Schichten machen das Netz "tief".
• **Ausgabeschicht**: Die endgültige Vorhersage (z. B. der vorhergesagte Preis).

Gewichte und Bias

• **Gewichte** bestimmen, wie viel Einfluss jede Eingabe auf die Ausgabe des Neurons hat. Während des Trainings werden die Gewichte angepasst, um den Fehler zu reduzieren.
• **Bias** erlauben es dem Neuron, auch dann einen Wert ungleich Null auszugeben, wenn alle Eingaben Null sind. Sie geben dem Netz Flexibilität.

Aktivierungsfunktion

Eine Aktivierungsfunktion entscheidet, ob ein Neuron "feuern" soll oder nicht. Übliche sind:

• **ReLU (Rectified Linear Unit)**: Gibt 0 für negative Eingaben aus und die Eingabe selbst für positive Werte. Sie ist einfach und schnell.
• **Sigmoid**: Staucht Werte zwischen 0 und 1, nützlich für Wahrscheinlichkeiten.
• **Softmax**: Wird in der Ausgabeschicht für die Mehrklassenklassifikation verwendet.

Verlustfunktion

Die Verlustfunktion misst, wie falsch die Vorhersagen des Netzes sind. Zum Beispiel ist der mittlere quadratische Fehler (MSE) für Regression üblich. Das Ziel des Trainings ist es, diesen Verlust zu minimieren.

Backpropagation und Gradientenabstieg

• **Backpropagation** ist der Algorithmus, der berechnet, wie stark jedes Gewicht zum Fehler beigetragen hat.
• **Gradientenabstieg** verwendet diese Informationen, um die Gewichte in die Richtung anzupassen, die den Verlust reduziert. Es ist, als würde man einen Ball einen Hügel hinunterrollen, um den tiefsten Punkt zu finden.

Voraussetzungen

Um mitzumachen, benötigt ihr:

• Einen Computer mit Windows, macOS oder Linux.
• Python 3.8 oder höher installiert.
• Grundlegende Vertrautheit mit der Kommandozeile.
• Eine Internetverbindung, um Pakete zu installieren.

Wir werden **PyTorch** verwenden, ein beliebtes Deep-Learning-Framework. Es ist anfängerfreundlich und wird in Forschung und Industrie häufig eingesetzt.

Schritt-für-Schritt-Installation

1. Python installieren (falls nicht bereits geschehen)

Überprüft eure Python-Version. Öffnet ein Terminal und führt aus:

python --version

Wenn Python nicht installiert ist oder die Version unter 3.8 liegt, ladet es von [python.org](https://www.python.org/downloads/) herunter. Aktiviert während der Installation "Add Python to PATH".

2. Eine virtuelle Umgebung erstellen (empfohlen)

Dies hält die Abhängigkeiten für dieses Projekt isoliert.

python -m venv nn-tutorial

Dies erstellt einen Ordner namens `nn-tutorial`, der eine saubere Python-Umgebung enthält.

3. Die virtuelle Umgebung aktivieren

Auf Windows:

nn-tutorial\Scripts\activate

Auf macOS/Linux:

source nn-tutorial/bin/activate

Ihr solltet `(nn-tutorial)` in eurer Terminal-Eingabeaufforderung sehen.

4. PyTorch installieren

Besucht [pytorch.org](https://pytorch.org) und wählt eure Systemkonfiguration aus. Für die meisten Anfänger ohne GPU funktioniert dieser Befehl:

pip install torch torchvision

Dies installiert PyTorch (CPU-Version) und torchvision für Bilddatensätze.

5. Zusätzliche Bibliotheken installieren

Wir benötigen auch NumPy für die Datenverarbeitung und Matplotlib für die Visualisierung.

pip install numpy matplotlib

Anwendungsbeispiele

Jetzt bauen wir ein neuronales Netz von Grund auf mit PyTorch. Wir werden es auf einem klassischen Datensatz trainieren: handschriftlichen Ziffern (MNIST). Das Netz wird lernen, die Ziffern 0 bis 9 zu erkennen.

Beispiel 1: Ein einfaches neuronales Netz bauen

Erstellt eine neue Python-Datei namens `mnist_net.py` und fügt den folgenden Code ein.

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt

# 1. MNIST-Datensatz laden und normalisieren
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5,), (0.5,))
])

trainset = torchvision.datasets.MNIST(root='./data', train=True,
                                      download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
                                          shuffle=True)

testset = torchvision.datasets.MNIST(root='./data', train=False,
                                     download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=64,
                                         shuffle=False)

# 2. Die Architektur des neuronalen Netzes definieren
class SimpleNN(nn.Module):
    def __init__(self):
        super(SimpleNN, self).__init__()
        self.fc1 = nn.Linear(28*28, 128)  # Eingabeschicht (784 Pixel) -> verborgene Schicht (128 Neuronen)
        self.fc2 = nn.Linear(128, 64)     # verborgene Schicht (128) -> verborgene Schicht (64)
        self.fc3 = nn.Linear(64, 10)      # verborgene Schicht (64) -> Ausgabeschicht (10 Klassen)

    def forward(self, x):
        x = x.view(-1, 28*28)             # Bild zu einem 1D-Vektor abflachen
        x = torch.relu(self.fc1(x))       # Aktivierungsfunktion für die erste verborgene Schicht
        x = torch.relu(self.fc2(x))       # Aktivierung für die zweite verborgene Schicht
        x = self.fc3(x)                   # Ausgabeschicht (keine Aktivierung, wir verwenden CrossEntropyLoss)
        return x

# 3. Modell instanziieren, Verlustfunktion und Optimierer definieren
model = SimpleNN()
criterion = nn.CrossEntropyLoss()         # gut für Klassifikation
optimizer = optim.SGD(model.parameters(), lr=0.01)  # stochastischer Gradientenabstieg

# 4. Das Netz trainieren
num_epochs = 5
for epoch in range(num_epochs):
    running_loss = 0.0
    for images, labels in trainloader:
        optimizer.zero_grad()             # vorherige Gradienten löschen
        outputs = model(images)           # Vorwärtspass
        loss = criterion(outputs, labels) # Verlust berechnen
        loss.backward()                   # Backpropagation
        optimizer.step()                  # Gewichte aktualisieren

        running_loss += loss.item()
    print(f"Epoche {epoch+1}, Verlust: {running_loss/len(trainloader):.4f}")

print("Training abgeschlossen!")

# 5. Das Netz testen
correct = 0
total = 0
with torch.no_grad():                     # während der Auswertung keine Gradienten berechnen
    for images, labels in testloader:
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"Genauigkeit auf dem Testdatensatz: {100 * correct / total:.2f}%")

**Erklärung der einzelnen Schritte:**

• **Daten laden**: Wir laden den MNIST-Datensatz herunter, normalisieren die Pixelwerte auf den Bereich [-1, 1] und erstellen Batches von 64 Bildern.
• **Netzdefinition**: `SimpleNN` hat drei vollständig verbundene Schichten. Wir flatten das 28x28-Bild zu einem 784-dimensionalen Vektor, leiten es durch zwei verborgene Schichten mit ReLU-Aktivierung und schließlich zu einer 10-Neuronen-Ausgabeschicht (eine für jede Ziffer).
• **Trainingsschleife**: Für jede Epoche (vollständiger Durchlauf durch die Daten) berechnen wir den Verlust, führen Backpropagation durch und aktualisieren die Gewichte.
• **Testen**: Wir bewerten die Genauigkeit auf ungesehenen Testdaten. Es werden keine Gradienten berechnet, um Speicher zu sparen.

Führt das Skript aus:

python mnist_net.py

Ihr solltet eine Ausgabe wie diese sehen:

Epoche 1, Verlust: 0.6543
Epoche 2, Verlust: 0.3210
Epoche 3, Verlust: 0.2456
Epoche 4, Verlust: 0.1987
Epoche 5, Verlust: 0.1678
Training abgeschlossen!
Genauigkeit auf dem Testdatensatz: 95.12%

Eure Genauigkeit kann leicht variieren, aber ihr solltet etwa 95% sehen – nicht schlecht für ein einfaches Netz, das in Sekunden trainiert wurde!

Beispiel 2: Vorhersagen visualisieren

Fügen wir eine schnelle Visualisierung hinzu, um zu sehen, was das Netz vorhersagt. Fügt diesen Code am Ende eures Skripts hinzu.

# Einige Testbilder mit Vorhersagen visualisieren
dataiter = iter(testloader)
images, labels = next(dataiter)

# Vorhersagen abrufen
outputs = model(images)
_, predicted = torch.max(outputs, 1)

# Die ersten 10 Bilder plotten
fig, axes = plt.subplots(2, 5, figsize=(10, 4))
for idx, ax in enumerate(axes.flat):
    ax.imshow(images[idx].squeeze(), cmap='gray')
    ax.set_title(f"Wahr: {labels[idx].item()}, Vorh: {predicted[idx].item()}")
    ax.axis('off')
plt.tight_layout()
plt.show()

Führt das Skript erneut aus. Es öffnet sich ein Fenster, das 10 handschriftliche Ziffern mit ihren wahren Labels und den Vorhersagen des Netzes zeigt. Ihr werdet sehen, dass die meisten korrekt sind, aber einige könnten falsch sein – das ist normal.

Was kommt als Nächstes? (Praktische nächste Schritte)

Ihr habt gerade ein neuronales Netz gebaut und trainiert. Hier ist, wie ihr tiefer einsteigen könnt:

• **Mit der Architektur experimentieren**: Versucht, weitere verborgene Schichten hinzuzufügen oder die Anzahl der Neuronen zu ändern. Seht, wie sich die Genauigkeit verändert.
• **Hyperparameter optimieren**: Passt die Lernrate (z. B. 0,001 oder 0,1), die Batch-Größe oder die Anzahl der Epochen an.
• **Einen anderen Datensatz ausprobieren**: Verwendet CIFAR-10 (Farbbilder von Objekten), indem ihr `torchvision.datasets.MNIST` durch `torchvision.datasets.CIFAR10` ersetzt. Ihr müsst die Eingabegröße (32x32x3) anpassen und möglicherweise Faltungsschichten hinzufügen.
• **Über faltende neuronale Netze (CNNs) lernen**: Sie sind viel besser für Bildaufgaben geeignet. PyTorchs `nn.Conv2d` ist euer Freund.
• **Transferlernen erkunden**: Verwendet ein vortrainiertes Modell (wie ResNet) von `torchvision.models` und feint es für eure eigene Aufgabe ab.

Für fortgeschrittenere Tutorials veröffentlichen der Hugging Face Blog und der Google AI Blog oft anfängerfreundliche Anleitungen mit Codebeispielen. Die Plattform Towards Data Science hat auch viele praktische Schritt-für-Schritt-Anleitungen.

Fazit

Neuronale Netze sind keine Magie – sie sind eine Reihe einfacher mathematischer Operationen, die, wenn sie gestapelt und trainiert werden, komplexe Muster lernen können. Ihr habt die Kernkonzepte gesehen: Neuronen, Schichten, Gewichte, Aktivierungsfunktionen und Backpropagation. Noch wichtiger ist, dass ihr ein funktionierendes Beispiel ausgeführt habt, das auf echten Daten trainiert und Vorhersagen trifft.

Die Verwirrung um neuronale Netze kommt oft von der schieren Anzahl neuer Begriffe, aber jeder einzelne repräsentiert ein kleines, verständliches Stück. Beginnt mit dem Code, den ihr hier habt. Ändert ihn. Brecht ihn. Repariert ihn. Das ist der beste Weg zu lernen.

Jetzt habt ihr eine Grundlage. Geht hin und baut etwas.