AGB | AI learning

Was sind Neuronale Netze?

Künstliche neuronale Netze sind vom biologischen Gehirn inspirierte Rechenmodelle, die in der Lage sind, komplexe Muster in Daten zu erkennen und zu lernen. Sie bilden die Grundlage moderner KI-Anwendungen wie Bilderkennung, Sprachverarbeitung und autonome Systeme.

Ein neuronales Netz besteht aus miteinander verbundenen Knoten (Neuronen), die in Schichten organisiert sind. Jede Verbindung hat ein Gewicht, das während des Trainings angepasst wird, um die Leistung des Modells zu verbessern.

Wichtiger Hinweis

Obwohl neuronale Netze vom Gehirn inspiriert sind, funktionieren sie grundlegend anders als biologische Neuronen. Sie sind mathematische Modelle, die auf linearer Algebra und Optimierung basieren.

Aufbau eines einfachen Neurons

Ein künstliches Neuron nimmt mehrere Eingaben entgegen, gewichtet sie, summiert die gewichteten Werte und wendet eine Aktivierungsfunktion an. Hier ist eine einfache Implementierung in Python:

        import numpy as np
        
        class Neuron:
            def __init__(self, num_inputs):
                # Zufällige Initialisierung der Gewichte
                self.weights = np.random.randn(num_inputs)
                self.bias = np.random.randn()
            
            def sigmoid(self, x):
                # Sigmoid-Aktivierungsfunktion
                return 1 / (1 + np.exp(-x))
            
            def forward(self, inputs):
                # Gewichtete Summe berechnen
                z = np.dot(inputs, self.weights) + self.bias
                # Aktivierungsfunktion anwenden
                return self.sigmoid(z)
        
        # Beispielverwendung
        neuron = Neuron(3)
        inputs = np.array([0.5, 0.8, 0.2])
        output = neuron.forward(inputs)
        print(f"Neuron-Ausgabe: {output}")
                  

Kernkonzepte

Gewichte: Bestimmen die Stärke der Verbindungen zwischen Neuronen
Bias: Verschiebt die Aktivierungsfunktion für bessere Flexibilität
Aktivierungsfunktion: Führt Nichtlinearität ein (z.B. Sigmoid, ReLU, Tanh)
Forward Propagation: Berechnet die Ausgabe des Netzes

Backpropagation-Algorithmus

Backpropagation ist der zentrale Lernalgorithmus für neuronale Netze. Er berechnet den Gradienten der Verlustfunktion bezüglich jedes Gewichts und aktualisiert die Gewichte, um den Fehler zu minimieren.

        import numpy as np
        
        class NeuralNetwork:
            def __init__(self, input_size, hidden_size, output_size):
                # Gewichte initialisieren
                self.W1 = np.random.randn(input_size, hidden_size) * 0.01
                self.b1 = np.zeros((1, hidden_size))
                self.W2 = np.random.randn(hidden_size, output_size) * 0.01
                self.b2 = np.zeros((1, output_size))
        
            def relu(self, x):
                return np.maximum(0, x)
        
            def relu_derivative(self, x):
                return (x > 0).astype(float)
        
            def forward(self, X):
                # Hidden Layer
                self.z1 = np.dot(X, self.W1) + self.b1
                self.a1 = self.relu(self.z1)
                
                # Output Layer
                self.z2 = np.dot(self.a1, self.W2) + self.b2
                return self.z2
        
            def backward(self, X, y, learning_rate=0.01):
                m = X.shape[0]
                
                # Gradient der Ausgabeschicht
                dz2 = self.z2 - y
                dW2 = np.dot(self.a1.T, dz2) / m
                db2 = np.sum(dz2, axis=0, keepdims=True) / m
                
                # Gradient der versteckten Schicht
                dz1 = np.dot(dz2, self.W2.T) * self.relu_derivative(self.z1)
                dW1 = np.dot(X.T, dz1) / m
                db1 = np.sum(dz1, axis=0, keepdims=True) / m
                
                # Gewichte aktualisieren
                self.W2 -= learning_rate * dW2
                self.b2 -= learning_rate * db2
                self.W1 -= learning_rate * dW1
                self.b1 -= learning_rate * db1
                  

Der Lernprozess

Backpropagation verwendet die Kettenregel aus der Differentialrechnung, um Gradienten effizient durch alle Schichten des Netzes zu propagieren. Dies ermöglicht das Training tiefer Netzwerke mit Millionen von Parametern.

Aktivierungsfunktionen

Aktivierungsfunktionen sind entscheidend für die Leistung neuronaler Netze. Sie führen Nichtlinearität ein und ermöglichen es dem Netz, komplexe Funktionen zu lernen.

        import numpy as np
        
        # Sigmoid: Ausgabe zwischen 0 und 1
        def sigmoid(x):
            return 1 / (1 + np.exp(-x))
        
        # ReLU: Rectified Linear Unit - am häufigsten verwendet
        def relu(x):
            return np.maximum(0, x)
        
        # Tanh: Ausgabe zwischen -1 und 1
        def tanh(x):
            return np.tanh(x)
        
        # Leaky ReLU: Vermeidet das "Dying ReLU" Problem
        def leaky_relu(x, alpha=0.01):
            return np.where(x > 0, x, alpha * x)
        
        # Softmax: Für Multi-Klassen-Klassifikation
        def softmax(x):
            exp_x = np.exp(x - np.max(x, axis=1, keepdims=True))
            return exp_x / np.sum(exp_x, axis=1, keepdims=True)
                  

Vergleich verschiedener Aktivierungsfunktionen

Wahl der Aktivierungsfunktion

ReLU: Standard für versteckte Schichten (schnell und effektiv)
Sigmoid: Für binäre Klassifikation in der Ausgabeschicht
Softmax: Für Multi-Klassen-Klassifikation
Tanh: Wenn zentrierte Ausgaben bevorzugt werden

Training mit Keras/TensorFlow

In der Praxis verwenden wir Frameworks wie TensorFlow und Keras, um neuronale Netze zu erstellen und zu trainieren. Hier ist ein vollständiges Beispiel:

        import tensorflow as tf
        from tensorflow import keras
        from tensorflow.keras import layers
        
        # Daten laden (MNIST Beispiel)
        (X_train, y_train), (X_test, y_test) = keras.datasets.mnist.load_data()
        
        # Daten normalisieren
        X_train = X_train.reshape(-1, 784) / 255.0
        X_test = X_test.reshape(-1, 784) / 255.0
        
        # Modell erstellen
        model = keras.Sequential([
            layers.Dense(128, activation='relu', input_shape=(784,)),
            layers.Dropout(0.2),
            layers.Dense(64, activation='relu'),
            layers.Dropout(0.2),
            layers.Dense(10, activation='softmax')
        ])
        
        # Modell kompilieren
        model.compile(
            optimizer='adam',
            loss='sparse_categorical_crossentropy',
            metrics=['accuracy']
        )
        
        # Modell trainieren
        history = model.fit(
            X_train, y_train,
            epochs=10,
            batch_size=32,
            validation_split=0.2,
            verbose=1
        )
        
        # Modell evaluieren
        test_loss, test_acc = model.evaluate(X_test, y_test)
        print(f"Test-Genauigkeit: {test_acc:.4f}")
                  

Convolutional Neural Networks (CNNs)

CNNs sind spezialisierte neuronale Netze für die Verarbeitung von Bilddaten. Sie verwenden Faltungsschichten, um räumliche Muster zu erkennen.

        from tensorflow.keras import layers, models
        
        # CNN für Bildklassifikation erstellen
        model = models.Sequential([
            # Erste Faltungsschicht
            layers.Conv2D(32, (3, 3), activation='relu', 
                         input_shape=(28, 28, 1)),
            layers.MaxPooling2D((2, 2)),
            
            # Zweite Faltungsschicht
            layers.Conv2D(64, (3, 3), activation='relu'),
            layers.MaxPooling2D((2, 2)),
            
            # Dritte Faltungsschicht
            layers.Conv2D(64, (3, 3), activation='relu'),
            
            # Flach machen für Dense Layer
            layers.Flatten(),
            layers.Dense(64, activation='relu'),
            layers.Dropout(0.5),
            layers.Dense(10, activation='softmax')
        ])
        
        model.summary()
                  

Hyperparameter-Tuning

Die richtige Wahl der Hyperparameter ist entscheidend für die Leistung neuronaler Netze. Hier sind die wichtigsten Parameter und ihre Auswirkungen:

Wichtige Hyperparameter

Lernrate: Steuert die Schrittgröße bei der Gewichtsaktualisierung (typisch: 0.001-0.1)
Batch Size: Anzahl der Samples pro Trainingsschritt (typisch: 32-256)
Anzahl der Epochen: Wie oft das gesamte Dataset durchlaufen wird
Netzwerkarchitektur: Anzahl und Größe der versteckten Schichten
Dropout-Rate: Verhindert Overfitting (typisch: 0.2-0.5)

        from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
        
        # Callbacks für besseres Training
        early_stopping = EarlyStopping(
            monitor='val_loss',
            patience=5,
            restore_best_weights=True
        )
        
        reduce_lr = ReduceLROnPlateau(
            monitor='val_loss',
            factor=0.5,
            patience=3,
            min_lr=0.00001
        )
        
        # Training mit Callbacks
        history = model.fit(
            X_train, y_train,
            epochs=50,
            batch_size=64,
            validation_split=0.2,
            callbacks=[early_stopping, reduce_lr]
        )
                  

Overfitting vermeiden

Regularisierungstechniken wie Dropout, L1/L2-Regularisierung und Early Stopping helfen, Overfitting zu verhindern und die Generalisierung zu verbessern.

Fazit

Neuronale Netze sind mächtige Werkzeuge für Machine Learning und bilden die Grundlage moderner KI-Systeme. Von einfachen Feedforward-Netzen bis zu komplexen CNNs und Transformern - das Verständnis der Grundlagen ist essentiell.

Der Schlüssel zum Erfolg liegt im praktischen Experimentieren. Beginnen Sie mit einfachen Beispielen, verstehen Sie die mathematischen Konzepte und arbeiten Sie sich schrittweise zu komplexeren Architekturen vor.

Nächste Schritte

Vertiefen Sie Ihr Wissen mit fortgeschrittenen Themen wie Recurrent Neural Networks (RNNs), Transformer-Architekturen und Transfer Learning. Praktische Projekte sind der beste Weg zum Lernen!