Synchrone Gradientenaggregation bei Parameter-Servern

In der modernen Welt des maschinellen Lernens und der künstlichen Intelligenz spielen neuronale Netzwerke eine zentrale Rolle. Mit der wachsenden Komplexität und Größe dieser Modelle steigt jedoch auch der Bedarf, das Training effizient auf mehrere Maschinen zu verteilen. Hierbei erweisen sich Parameter-Server als unverzichtbares Werkzeug, um die enormen Rechenanforderungen durch verteiltes Training zu bewältigen. Parameter-Server ermöglichen es, die Berechnungen auf mehrere Rechner (Worker-Knoten¹) aufzuteilen und die Modellparameter zentral zu speichern und zu aktualisieren.

sequenceDiagram
    participant DB as Datenbank
    participant W1 as Worker 1
    participant W2 as Worker 2
    participant PS as Parameter-Server

    DB->>W1: Sendet Trainingsdaten
    DB->>W2: Sendet Trainingsdaten

    W1->>PS: Sendet Gradienten
    W2->>PS: Sendet Gradienten

    PS-->>W1: Aggregierte & aktualisierte Parameter
    PS-->>W2: Aggregierte & aktualisierte Parameter

In diesem Beitrag wird ein einfaches Beispiel für das synchrone Training in einem verteilten maschinellen Lernsystem vorgestellt. Anhand des oben dargestellten Sequenzdiagramms wird gezeigt, wie zwei Worker-Knoten in Zusammenarbeit mit einem Parameter-Server und einer zentralen Datenbank das Training eines neuronalen Netzwerks durchführen. Die Datenbank stellt zunächst die benötigten Trainingsdaten den beiden Workern zur Verfügung. Jeder Worker berechnet daraufhin die Gradienten basierend auf diesen Daten und sendet sie synchron an den Parameter-Server. Der Parameter-Server aggregiert die empfangenen Gradienten, aktualisiert die Modellparameter und sendet die neuen Parameter zurück an die Worker. Dieses Verfahren gewährleistet, dass beide Worker stets mit konsistenten Modellparametern arbeiten, was zu einem stabilen und koordinierten Training führt.

Synchrones vs. Asynchrones Training

Ein zentrales Konzept bei der Verwendung von Parameter-Servern ist die Methode der Parameteraktualisierung, bei der zwischen synchronem und asynchronem Training unterschieden wird. Beim synchronen Training berechnen alle Worker-Knoten ihre Gradienten und senden diese an den Parameter-Server. Der Server aggregiert die Gradienten und aktualisiert die Modellparameter erst, nachdem alle Worker ihre Berechnungen abgeschlossen haben. Dies garantiert, dass alle Knoten mit konsistenten Parametern arbeiten, was zu einem stabilen Training führt, jedoch durch die Wartezeit auf langsamere Knoten verzögert werden kann.

Im Gegensatz dazu erlaubt das asynchrone Training eine schnellere, jedoch weniger koordinierte Aktualisierung der Parameter. Hierbei senden die Worker ihre Gradienten unabhängig voneinander an den Parameter-Server, der die Parameter sofort aktualisiert, ohne auf die anderen Worker zu warten. Diese Methode kann die Trainingszeit verkürzen, bringt jedoch das Risiko von Inkonsistenzen mit sich, da verschiedene Knoten zu unterschiedlichen Zeitpunkten mit unterschiedlichen Versionen der Parameter arbeiten könnten.

Netzwerk-Setup

Um ein neuronales Netzwerk mit einem Eingabevektor von 5x1 und einem Zielvektor von 2x1 zu erstellen, das aus drei Schichten² besteht, sind die Dimensionen der Gewichtsmatrizen entsprechend anzupassen. Hier ist das vollständige Beispiel:

• Schicht 1: Gewichtsmatrix $W^{[1]}$ (4 x 5)
• Schicht 2: Gewichtsmatrix $W^{[2]}$ (3 x 4)
• Schicht 3: Gewichtsmatrix $W^{[3]}$ (2 x 3)

Initialisierung der Parameter

Angenommen, die initialen Gewichtsmatrizen auf dem Parameter-Server sind:

$$W^{[1]} = \begin{pmatrix} 0.1 & 0.2 & 0.3 & 0.4 & 0.5 \\ 0.6 & 0.7 & 0.8 & 0.9 & 1.0 \\ 1.1 & 1.2 & 1.3 & 1.4 & 1.5 \\ 1.6 & 1.7 & 1.8 & 1.9 & 2.0 \end{pmatrix}$$

$$W^{[2]} = \begin{pmatrix} 0.2 & 0.3 & 0.4 & 0.5 \\ 0.6 & 0.7 & 0.8 & 0.9 \\ 1.0 & 1.1 & 1.2 & 1.3 \end{pmatrix}$$

$$W^{[3]} = \begin{pmatrix} 0.3 & 0.4 & 0.5 \\ 0.6 & 0.7 & 0.8 \end{pmatrix}$$

Beispiel in PythonOutput (Python)

import numpy as np

ETA = 0.01
W1 = np.array([
    [0.1, 0.2, 0.3, 0.4, 0.5],
    [0.6, 0.7, 0.8, 0.9, 1.0],
    [1.1, 1.2, 1.3, 1.4, 1.5],
    [1.6, 1.7, 1.8, 1.9, 2.0]
])
W2 = np.array([
    [0.2, 0.3, 0.4, 0.5],
    [0.6, 0.7, 0.8, 0.9],
    [1.0, 1.1, 1.2, 1.3]
])
W3 = np.array([
    [0.3, 0.4, 0.5],
    [0.6, 0.7, 0.8]
])

for matrix in [W1, W2, W3]:
    print(matrix, '\n')

[[0.1 0.2 0.3 0.4 0.5]
[0.6 0.7 0.8 0.9 1. ]
[1.1 1.2 1.3 1.4 1.5]
[1.6 1.7 1.8 1.9 2. ]] 

[[0.2 0.3 0.4 0.5]
[0.6 0.7 0.8 0.9]
[1.  1.1 1.2 1.3]] 

[[0.3 0.4 0.5]
[0.6 0.7 0.8]]

Beispiel-Daten

Wir verwenden einen Eingabevektor³ x (5 x 1) und ein Ziel⁴ y (2 x 1):

$$x = \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \\ 1 \end{pmatrix}, \quad y = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$$

Beispiel in PythonOutput (Python)

x = np.array([[1], [0], [1], [0], [1]])
y = np.array([[0], [1]])

print('\nx:\n', x)
print('\ny:\n', y)

x:
[[1]
[0]
[1]
[0]
[1]]

y:
[[0]
[1]]

Arbeiterknoten (Schritt 1-3)

Hinweis zur Verwendung des Bias

In der hier dargestellten Implementierung wurde bewusst darauf verzichtet, Biases in den Schichten des neuronalen Netzwerks zu verwenden. Dies wurde getan, um den Fokus auf die Erklärung des Gesamtprozesses und der Interaktionen zwischen den Gewichtsmatrizen und dem Parameter-Server zu legen, ohne zusätzliche Komplexität einzuführen. In realen Anwendungen können Biases jedoch eine wichtige Rolle spielen, da sie den Neuronen erlauben, ihre Aktivierungen unabhängig von den Eingabewerten zu verschieben.

Vorwärtsausbreitung (S1)

---

Schritt 1 (S1)

---

Die Vorwärtsausbreitung⁵ ist der Prozess, bei dem Eingabedaten durch ein neuronales Netzwerk geleitet werden, um eine Vorhersage zu erzeugen.

Schicht 1 (L1)

• $$W^{[1]} = \begin{pmatrix} 0.1 & 0.2 & 0.3 & 0.4 & 0.5 \\ 0.6 & 0.7 & 0.8 & 0.9 & 1.0 \\ 1.1 & 1.2 & 1.3 & 1.4 & 1.5 \\ 1.6 & 1.7 & 1.8 & 1.9 & 2.0 \end{pmatrix}$$

• $$x = \begin{pmatrix} 1 \\ 0 \\ 1 \\ 0 \\ 1 \end{pmatrix}$$

$$z^{[1]} = W^{[1]} \cdot x = \begin{pmatrix} 0.9 \\ 2.4 \\ 3.9 \\ 5.4 \end{pmatrix}$$

---

$$a^{[1]} = \text{ReLU}(z^{[1]}) = \begin{pmatrix} 0.9 \\ 2.4 \\ 3.9 \\ 5.4 \end{pmatrix}$$

Schicht 2 (L2)

• $$W^{[2]} = \begin{pmatrix} 0.2 & 0.3 & 0.4 & 0.5 \\ 0.6 & 0.7 & 0.8 & 0.9 \\ 1.0 & 1.1 & 1.2 & 1.3 \end{pmatrix}$$

• $$a^{[1]} = \begin{pmatrix} 0.9 \\ 2.4 \\ 3.9 \\ 5.4 \end{pmatrix}$$

$$z^{[2]} = W^{[2]} \cdot a^{[1]} = \begin{pmatrix} 5.16 \\ 10.2 \\ 15.24 \end{pmatrix}$$

---

$$a^{[2]} = \text{ReLU}(z^{[2]}) = \begin{pmatrix} 5.16 \\ 10.2 \\ 15.24 \end{pmatrix}$$

Schicht 3 (L3)

• $$W^{[3]} = \begin{pmatrix} 0.3 & 0.4 & 0.5 \\ 0.6 & 0.7 & 0.8 \end{pmatrix}$$

• $$a^{[2]} = \begin{pmatrix} 5.16 \\ 10.2 \\ 15.24 \end{pmatrix}$$

$$z^{[3]} = W^{[3]} \cdot a^{[2]} = \begin{pmatrix} 13.248 \\ 22.428 \end{pmatrix}$$

---

$$\hat{y} = a^{[3]} = \text{ReLU}(z^{[3]}) = \begin{pmatrix} 13.248 \\ 22.428 \end{pmatrix}$$

Beispiel in Python (L1-L3)

Beispiel in PythonOutput (Python)

def relu(z) -> np.ndarray:
    return np.maximum(0, z)

z1 = np.dot(W1, x)
a1 = relu(z1)

z2 = np.dot(W2, a1)
a2 = relu(z2)

z3 = np.dot(W3, a2)
a3 = relu(z3)

for id_, layer_output in enumerate([a1, a2, a3]):
    print('\n' + '-'*20 + f' a[{id_+1}]', layer_output, sep='\n')

-------------------- a[1]
[[0.9]
[2.4]
[3.9]
[5.4]]

-------------------- a[2]
[[ 5.16]
[10.2 ]
[15.24]]

-------------------- a[3]
[[13.248]
[22.428]]

Berechnung des Verlustes (S2)

---

Schritt 2 (S2)

---

Wir verwenden die Mean Squared Error (MSE) Verlustfunktion⁶:

$$\mathscr{L} = \frac{1}{2} \sum_{i=1}^{2} (\hat{y}_i - y_i)^2$$

$$\mathscr{L} = \frac{1}{2} \left[ (13.248 - 0)^2 + (22.428 - 1)^2 \right]$$

$$\mathscr{L} = 317.3343$$

def mse_loss(y_hat, y):
    return 0.5 * np.sum((y_hat - y) ** 2)

y_hat = a3

print('Loss =', mse_loss(y_hat, y))  # Loss = 317.33434400000004

Rückwärtsausbreitung (S3)

---

Schritt 3 (S3)

---

Die Rückwärtsausbreitung⁷ ist ein Algorithmus, der in neuronalen Netzwerken verwendet wird, um die Gewichte anzupassen, indem der Fehler von der Ausgabeschicht zurück zur Eingabeschicht propagiert wird. Dabei werden die Gradienten⁸ des Fehlers berechnet, um zu bestimmen, wie die Gewichte angepasst werden sollten, um den Fehler zu minimieren. Dieser Prozess ermöglicht es dem Netzwerk, durch wiederholtes Lernen und Optimieren genauer zu werden.

Gradienten (L3)

$$\hat{y} = \begin{pmatrix} 13.248 \\ 22.428 \end{pmatrix}$$

$$y = \begin{pmatrix} 0 \\ 1 \end{pmatrix}$$

• $$\delta^{[3]} = \hat{y} - y$$

$$\delta^{[3]} = \begin{pmatrix} 13.248 \\ 22.428 \end{pmatrix} - \begin{pmatrix} 0 \\ 1 \end{pmatrix}$$

$$\delta^{[3]} = \begin{pmatrix} 13.248 \\ 21.428 \end{pmatrix}$$

---

Gradienten bezüglich der Gewichtsmatrix $W^{[3]}$

$$(a^{[2]})^T = \begin{pmatrix} 5.16 & 10.2 & 15.24 \end{pmatrix}$$

• $$\frac{\partial \mathscr{L}}{\partial W^{[3]}} = \delta^{[3]} \cdot (a^{[2]})^T$$

$$\frac{\partial \mathscr{L}}{\partial W^{[3]}} = \begin{pmatrix} 13.248 \\ 21.428 \end{pmatrix} \cdot \begin{pmatrix} 5.16 & 10.2 & 15.24 \end{pmatrix}$$

$$\frac{\partial \mathscr{L}}{\partial W^{[3]}} = \begin{pmatrix} 68.35968 & 135.1296 & 201.89952 \\ 110.56848 & 218.5656 & 326.56272 \end{pmatrix}$$

Beispiel in Python (L3)

Beispiel in PythonOutput (Python)

delta3 = y_hat - y
dW3 = np.dot(delta3, a2.T)

print(delta3, '\n')
print(dW3)

[[13.248]
[21.428]] 

[[ 68.35968 135.1296  201.89952]
[110.56848 218.5656  326.56272]]

Gradienten (L2)

$$(W^{[3]})^T = \begin{pmatrix} 0.3 & 0.6 \\ 0.4 & 0.7 \\ 0.5 & 0.8 \end{pmatrix}$$

$$\delta^{[3]} = \begin{pmatrix} 13.248 \\ 21.428 \end{pmatrix}$$

• $$\delta^{[2]} = (W^{[3]})^T \cdot \delta^{[3]}$$

$$\delta^{[2]} = \begin{pmatrix} 0.3 & 0.6 \\ 0.4 & 0.7 \\ 0.5 & 0.8 \end{pmatrix} \cdot \begin{pmatrix} 13.248 \\ 21.428 \end{pmatrix}$$

$$\delta^{[2]} = \begin{pmatrix} 16.8312 \\ 20.2988 \\ 23.7664 \end{pmatrix}$$

---

Gradienten bezüglich der Gewichtsmatrix $W^{[2]}$

$$(a^{[1]})^T = \begin{pmatrix} 0.9 & 2.4 & 3.9 & 5.4 \end{pmatrix}$$

• $$\frac{\partial \mathscr{L}}{\partial W^{[2]}} = \delta^{[2]} \cdot (a^{[1]})^T$$

$$\frac{\partial \mathscr{L}}{\partial W^{[2]}} = \begin{pmatrix} 16.8312 \\ 20.2988 \\ 23.7664 \end{pmatrix} \cdot \begin{pmatrix} 0.9 & 2.4 & 3.9 & 5.4 \end{pmatrix}$$

$$\frac{\partial \mathscr{L}}{\partial W^{[2]}} = \begin{pmatrix} 15.14808 & 40.39488 & 65.64168 & 90.88848 \\ 18.26892 & 48.71712 & 79.16532 & 109.61352 \\ 21.38976 & 57.03936 & 92.68896 & 128.33856 \end{pmatrix}$$

Beispiel in Python (L2)

Beispiel in PythonOutput (Python)

delta2 = np.dot(W3.T, delta3)
dW2 = np.dot(delta2, a1.T)

print(delta2, '\n')
print(dW2)

[[16.8312]
[20.2988]
[23.7664]] 

[[ 15.14808  40.39488  65.64168  90.88848]
[ 18.26892  48.71712  79.16532 109.61352]
[ 21.38976  57.03936  92.68896 128.33856]]

Gradienten (L1)

$$(W^{[2]})^T = \begin{pmatrix} 0.2 & 0.6 & 1.0 \\ 0.3 & 0.7 & 1.1 \\ 0.4 & 0.8 & 1.2 \\ 0.5 & 0.9 & 1.3 \end{pmatrix}$$

$$\delta^{[2]} = \begin{pmatrix} 16.8312 \\ 20.2988 \\ 23.7664 \end{pmatrix}$$

• $$\delta^{[1]} = (W^{[2]})^T \cdot \delta^{[2]}$$

$$\delta^{[1]} = \begin{pmatrix} 0.2 & 0.6 & 1.0 \\ 0.3 & 0.7 & 1.1 \\ 0.4 & 0.8 & 1.2 \\ 0.5 & 0.9 & 1.3 \end{pmatrix} \cdot \begin{pmatrix} 16.8312 \\ 20.2988 \\ 23.7664 \end{pmatrix}$$

$$\delta^{[1]} = \begin{pmatrix} 39.31192 \\ 45.40156 \\ 51.4912 \\ 57.58084 \end{pmatrix}$$

---

Gradienten bezüglich der Gewichtsmatrix $W^{[1]}$

$$x^T = \begin{pmatrix} 1 & 0 & 1 & 0 & 1 \end{pmatrix}$$

• $$\frac{\partial \mathscr{L}}{\partial W^{[1]}} = \delta^{[1]} \cdot x^T$$

$$\frac{\partial \mathscr{L}}{\partial W^{[1]}} = \begin{pmatrix} 39.31192 \\ 45.40156 \\ 51.4912 \\ 57.58084 \end{pmatrix} \cdot \begin{pmatrix} 1 & 0 & 1 & 0 & 1 \end{pmatrix}$$

$$\frac{\partial \mathscr{L}}{\partial W^{[1]}} = \begin{pmatrix} 39.31192 & 0 & 39.31192 & 0 & 39.31192 \\ 45.40156 & 0 & 45.40156 & 0 & 45.40156 \\ 51.4912 & 0 & 51.4912 & 0 & 51.4912 \\ 57.58084 & 0 & 57.58084 & 0 & 57.58084 \end{pmatrix}$$

Beispiel in Python (L1)

Beispiel in PythonOutput (Python)

delta1 = np.dot(W2.T, delta2)
dW1 = np.dot(delta1, x.T)

print(delta1, '\n')
print(dW1)

[[39.31192]
[45.40156]
[51.4912 ]
[57.58084]] 

[[39.31192  0.      39.31192  0.      39.31192]
[45.40156  0.      45.40156  0.      45.40156]
[51.4912   0.      51.4912   0.      51.4912 ]
[57.58084  0.      57.58084  0.      57.58084]]

Parameter Server (Schritt 4-6)

Aggregation der Gradienten (S4)

---

Schritt 4 (S4)

---

Falls zwei Worker die Gradienten berechnen, aggregiert⁹ der Parameter-Server die Gradienten durch Mittelung¹⁰. Wenn mehrere Worker die Gradienten berechnen, aggregiert der Parameter-Server die Gradienten durch Mittelung, indem er die Gradienten aller Worker summiert und anschließend durch die Anzahl der Worker teilt.

$$\frac{\partial \mathscr{L}}{\partial W^{[1]}}_{\text{aggregiert}} = \frac{1}{2} \left(\frac{\partial \mathscr{L}}{\partial W^{[1]}}_{Worker1} + \frac{\partial \mathscr{L}}{\partial W^{[1]}}_{Worker2}\right)$$

$$\frac{\partial \mathscr{L}}{\partial W^{[2]}}_{\text{aggregiert}} = \frac{1}{2} \left(\frac{\partial \mathscr{L}}{\partial W^{[2]}}_{Worker1} + \frac{\partial \mathscr{L}}{\partial W^{[2]}}_{Worker2}\right)$$

$$\frac{\partial \mathscr{L}}{\partial W^{[3]}}_{\text{aggregiert}} = \frac{1}{2} \left(\frac{\partial \mathscr{L}}{\partial W^{[3]}}_{Worker1} + \frac{\partial \mathscr{L}}{\partial W^{[3]}}_{Worker2}\right)$$

Aktualisierung der Parameter (S5)

---

Schritt 5 (S5)

---

Mit einer Lernrate¹¹ von $\eta$ = 0.01 aktualisiert der Parameter-Server die Gewichtsmatrizen:

$$W^{[1]}_{\text{neu}} = W^{[1]} - \eta \cdot \frac{\partial \mathscr{L}}{\partial W^{[1]}}_{\text{aggregiert}}$$

$$W^{[2]}_{\text{neu}} = W^{[2]} - \eta \cdot \frac{\partial \mathscr{L}}{\partial W^{[2]}}_{\text{aggregiert}}$$

$$W^{[3]}_{\text{neu}} = W^{[3]} - \eta \cdot \frac{\partial \mathscr{L}}{\partial W^{[3]}}_{\text{aggregiert}}$$

Verteilung der aktualisierten Parameter (S6)

---

Schritt 6 (S6)

---

Die aktualisierten Gewichtsmatrizen $W^{[1]}_{\text{neu}}$, $W^{[2]}_{\text{neu}}$ und $W^{[3]}$ werden an die Worker-Knoten zurückgesendet, die den nächsten Vorwärts- und Rückwärtsdurchlauf mit den neuen Parametern durchführen.

Aggregation im Detail

Layer 1

• Arbeiterknoten 1: $\nabla_{\theta} \mathscr{L}_1^{[1]} = G_1^{[1]}$
• Arbeiterknoten 2: $\nabla_{\theta} \mathscr{L}_2^{[1]} = G_2^{[1]}$

Aggregation der Gradienten $$\text{Aggregierter Gradient für } W^{[1]} = \frac{1}{K} \sum_{k=1}^{K} \nabla_{\theta} \mathscr{L}_k^{[1]} = \frac{1}{2} \left( G_1^{[1]} + G_2^{[1]} \right)$$

Aktualisierung der Parameter $$W^{[1]}_{\text{neu}} = W^{[1]}_{\text{alt}} - \eta \times \text{Aggregierter Gradient für } W^{[1]}$$

Beispiel

• $$G_1^{[1]} = \begin{pmatrix} 0.2 & 0.1 & -0.1 & 0.0 & 0.1 \\ 0.3 & -0.2 & 0.1 & -0.1 & 0.2 \\ -0.1 & 0.3 & 0.2 & -0.3 & 0.1 \\ 0.2 & -0.1 & 0.0 & 0.1 & -0.2 \end{pmatrix}$$

• $$\quad G_2^{[1]} = \begin{pmatrix} -0.2 & 0.0 & 0.1 & -0.2 & 0.3 \\ 0.1 & -0.1 & 0.3 & 0.0 & 0.1 \\ 0.2 & -0.3 & 0.0 & 0.1 & -0.1 \\ 0.1 & 0.2 & -0.2 & 0.0 & 0.2 \end{pmatrix}$$

• $$dW^{[1]}_{\text{aggregiert}} = \frac{1}{2} \left( G_1^{[1]} + G_2^{[1]} \right)$$

$$dW^{[1]}_{\text{aggregiert}} = \begin{pmatrix} 0.0 & 0.05 & 0.0 & -0.1 & 0.2 \\ 0.2 & -0.15 & 0.2 & -0.05 & 0.15 \\ 0.05 & 0.0 & 0.1 & -0.1 & 0.0 \\ 0.15 & 0.05 & -0.1 & 0.05 & 0.0 \end{pmatrix}$$

• $$W^{[1]}_{\text{neu}} = W^{[1]}_{\text{alt}} - \eta \times dW^{[1]}_{\text{aggregiert}}$$

$$W^{[1]}_{\text{neu}} = \begin{pmatrix} 0.1 & 0.1995 & 0.3 & 0.401 & 0.498 \\ 0.598 & 0.7015 & 0.798 & 0.9005 & 0.9985 \\ 1.0995 & 1.2 & 1.299 & 1.401 & 1.5 \\ 1.5985 & 1.6995 & 1.801 & 1.8995 & 2.0 \end{pmatrix}$$

Beispiel in PythonOutput (Python)

G1_W1 = np.array([
    [0.2, 0.1, -0.1, 0.0, 0.1],
    [0.3, -0.2, 0.1, -0.1, 0.2],
    [-0.1, 0.3, 0.2, -0.3, 0.1],
    [0.2, -0.1, 0.0, 0.1, -0.2]
])

G2_W1 = np.array([
    [-0.2, 0.0, 0.1, -0.2, 0.3],
    [0.1, -0.1, 0.3, 0.0, 0.1],
    [0.2, -0.3, 0.0, 0.1, -0.1],
    [0.1, 0.2, -0.2, 0.0, 0.2]
])

dW1_aggr = (G1_W1 + G2_W1) / 2

ETA = 0.01  # Lernrate
layer_1_matrices = {
    'W1_old': W1,
    'dW1_aggregated': dW1_aggr,
    'W1_new': W1 - ETA * dW1_aggr
}

for mtx_name, mtx in layer_1_matrices.items():
    print('\n' + '-'*50 + ' ' + mtx_name, mtx, sep='\n')

-------------------------------------------------- W1_old
[[0.1 0.2 0.3 0.4 0.5]
[0.6 0.7 0.8 0.9 1. ]
[1.1 1.2 1.3 1.4 1.5]
[1.6 1.7 1.8 1.9 2. ]]

-------------------------------------------------- dW1_aggregated
[[ 0.    0.05  0.   -0.1   0.2 ]
[ 0.2  -0.15  0.2  -0.05  0.15]
[ 0.05  0.    0.1  -0.1   0.  ]
[ 0.15  0.05 -0.1   0.05  0.  ]]

-------------------------------------------------- W1_new
[[0.1    0.1995 0.3    0.401  0.498 ]
[0.598  0.7015 0.798  0.9005 0.9985]
[1.0995 1.2    1.299  1.401  1.5   ]
[1.5985 1.6995 1.801  1.8995 2.    ]]

Layer 2

• Arbeiterknoten 1: $\nabla_{\theta} \mathscr{L}_1^{[2]} = G_1^{[2]}$
• Arbeiterknoten 2: $\nabla_{\theta} \mathscr{L}_2^{[2]} = G_2^{[2]}$

Aggregation der Gradienten $$\text{Aggregierter Gradient für } W^{[2]} = \frac{1}{K} \sum_{k=1}^{K} \nabla_{\theta} \mathscr{L}_k^{[2]} = \frac{1}{2} \left( G_1^{[2]} + G_2^{[2]} \right)$$

Aktualisierung der Parameter $$W^{[2]}_{\text{neu}} = W^{[2]}_{\text{alt}} - \eta \times \text{Aggregierter Gradient für } W^{[2]}$$

Beispiel

• $$G_1^{[2]} = \begin{pmatrix} 0.2 & 0.1 & -0.2 & 0.3 \\ -0.3 & 0.2 & 0.1 & -0.1 \\ 0.1 & -0.2 & 0.0 & 0.2 \end{pmatrix}$$

• $$\quad G_2^{[2]} = \begin{pmatrix} -0.1 & 0.3 & 0.2 & 0.1 \\ 0.2 & -0.1 & 0.0 & 0.2 \\ 0.0 & 0.1 & -0.2 & -0.3 \end{pmatrix}$$

• $$dW^{[2]}_{\text{aggregiert}} = \frac{1}{2} \left( G_1^{[2]} + G_2^{[2]} \right)$$

$$dW^{[2]}_{\text{aggregiert}} = \begin{pmatrix} 0.05 & 0.2 & 0.0 & 0.2 \\ -0.05 & 0.05 & 0.05 & 0.05 \\ 0.05 & -0.05 & -0.1 & -0.05 \end{pmatrix}$$

• $$W^{[2]}_{\text{neu}} = W^{[2]}_{\text{alt}} - \eta \times dW^{[2]}_{\text{aggregiert}}$$

$$W^{[2]}_{\text{neu}} = \begin{pmatrix} 0.1995 & 0.298 & 0.4 & 0.498 \\ 0.6005 & 0.6995 & 0.7995 & 0.8995 \\ 0.9995 & 1.1005 & 1.201 & 1.3005 \end{pmatrix}$$

Beispiel in PythonOutput (Python)

G1_W2 = np.array([
    [0.2, 0.1, -0.2, 0.3],
    [-0.3, 0.2, 0.1, -0.1],
    [0.1, -0.2, 0.0, 0.2]
])

G2_W2 = np.array([
    [-0.1, 0.3, 0.2, 0.1],
    [0.2, -0.1, 0.0, 0.2],
    [0.0, 0.1, -0.2, -0.3]
])

dW2_aggr = (G1_W2 + G2_W2) / 2

layer_2_matrices = {
    'W2_old': W2,
    'dW2_aggregated': dW2_aggr,
    'W2_new': W2 - ETA * dW2_aggr
}

for mtx_name, mtx in layer_2_matrices.items():
    print('\n' + '-'*50 + ' ' + mtx_name, mtx, sep='\n')

-------------------------------------------------- W2_old
[[0.2 0.3 0.4 0.5]
[0.6 0.7 0.8 0.9]
[1.  1.1 1.2 1.3]]

-------------------------------------------------- dW2_aggregated
[[ 0.05  0.2   0.    0.2 ]
[-0.05  0.05  0.05  0.05]
[ 0.05 -0.05 -0.1  -0.05]]

-------------------------------------------------- W2_new
[[0.1995 0.298  0.4    0.498 ]
[0.6005 0.6995 0.7995 0.8995]
[0.9995 1.1005 1.201  1.3005]]

Layer 3

• Arbeiterknoten 1: $\nabla_{\theta} \mathscr{L}_1^{[3]} = G_1^{[3]}$
• Arbeiterknoten 2: $\nabla_{\theta} \mathscr{L}_2^{[3]} = G_2^{[3]}$

Aggregation der Gradienten $$\text{Aggregierter Gradient für } W^{[3]} = \frac{1}{K} \sum_{k=1}^{K} \nabla_{\theta} \mathscr{L}_k^{[3]} = \frac{1}{2} \left( G_1^{[3]} + G_2^{[3]} \right)$$

Aktualisierung der Parameter $$W^{[3]}_{\text{neu}} = W^{[3]}_{\text{alt}} - \eta \times \text{Aggregierter Gradient für } W^{[3]}$$

Beispiel

• $$G_1^{[3]} = \begin{pmatrix} 0.3 & -0.2 & 0.1 \\ -0.1 & 0.4 & 0.2 \end{pmatrix}$$

• $$\quad G_2^{[3]} = \begin{pmatrix} -0.2 & 0.1 & -0.3 \\ 0.1 & -0.2 & 0.3 \end{pmatrix}$$

• $$dW^{[3]}_{\text{aggregiert}} = \frac{1}{2} \left( G_1^{[3]} + G_2^{[3]} \right)$$

$$dW^{[3]}_{\text{aggregiert}} = \begin{pmatrix} 0.05 & -0.05 & -0.1 \\ 0.0 & 0.1 & 0.25 \end{pmatrix}$$

• $$W^{[3]}_{\text{neu}} = W^{[3]}_{\text{alt}} - \eta \times dW^{[3]}_{\text{aggregiert}}$$

$$W^{[3]}_{\text{neu}} = \begin{pmatrix} 0.2995 & 0.4005 & 0.501 \\ 0.6 & 0.699 & 0.7975 \end{pmatrix}$$

Beispiel in PythonOutput (Python)

G1_W3 = np.array([
    [0.3, -0.2, 0.1],
    [-0.1, 0.4, 0.2]
])

G2_W3 = np.array([
    [-0.2, 0.1, -0.3],
    [0.1, -0.2, 0.3]
])

dW3_aggr = (G1_W3 + G2_W3) / 2

layer_3_matrices = {
    'W3_old': W3,
    'dW3_aggregated': dW3_aggr,
    'W3_new': W3 - ETA * dW3_aggr
}

for mtx_name, mtx in layer_3_matrices.items():
    print('\n' + '-'*50 + ' ' + mtx_name, mtx, sep='\n')

-------------------------------------------------- W3_old
[[0.3 0.4 0.5]
[0.6 0.7 0.8]]

-------------------------------------------------- dW3_aggregated
[[ 0.05 -0.05 -0.1 ]
[ 0.    0.1   0.25]]

-------------------------------------------------- W3_new
[[0.2995 0.4005 0.501 ]
[0.6    0.699  0.7975]]

Fazit

Die Implementierung und Optimierung neuronaler Netzwerke in verteilten Systemen stellt eine anspruchsvolle Aufgabe dar, die eine sorgfältige Auswahl der richtigen Trainingsmethode erfordert. Parameter-Server spielen hierbei eine zentrale Rolle, da sie eine effiziente und konsistente Verwaltung der Modellparameter über mehrere Rechner hinweg ermöglichen. Das synchrone Training, bei dem alle Worker-Knoten ihre Gradienten gleichzeitig an den Parameter-Server senden, gewährleistet stabile und konsistente Ergebnisse. Dies ist besonders wichtig bei komplexen und großen Modellen, da es die Wahrscheinlichkeit von Inkonsistenzen im Training reduziert.

Allerdings bringt das synchrone Training auch Herausforderungen mit sich. Die Notwendigkeit, auf langsamere Worker-Knoten zu warten, kann das gesamte System verlangsamen und die Trainingszeit erheblich verlängern. Diese Herausforderung wird besonders in Umgebungen mit heterogener Hardware oder variabler Netzwerklatenz spürbar. Alternativ bietet das asynchrone Training eine schnellere, aber potenziell inkonsistente Methode, bei der Worker-Knoten ihre Updates unabhängig voneinander durchführen.

Die Wahl zwischen synchronem und asynchronem Training sollte daher sorgfältig abgewogen werden, abhängig von den spezifischen Anforderungen des Modells und der verfügbaren Ressourcen. Insgesamt bietet der Parameter-Server jedoch eine flexible und leistungsfähige Lösung, die es ermöglicht, die Herausforderungen des verteilten Trainings großer neuronaler Netzwerke zu bewältigen und somit die Entwicklung fortschrittlicher Anwendungen im Bereich des maschinellen Lernens zu fördern.

---

1. Ein Worker-Knoten ist eine Recheneinheit innerhalb eines verteilten Systems, die spezifische Aufgaben wie das Berechnen von Gradienten während des Trainings eines neuronalen Netzwerks ausführt. In einem verteilten maschinellen Lernsystem erhält jeder Worker-Knoten einen Teil der Trainingsdaten, verarbeitet diese und sendet die resultierenden Gradienten an einen zentralen Parameter-Server. Diese Architektur ermöglicht es, das Training großer Modelle effizient auf mehrere Maschinen zu verteilen und somit die Rechenzeit zu verkürzen. ↩

2. Ein Layer (Schicht) in einem neuronalen Netzwerk ist eine Sammlung von Knoten (Neuronen), die eine bestimmte Funktion innerhalb des Netzwerks erfüllt. Jeder Layer nimmt Eingabedaten an, verarbeitet sie durch eine Reihe von Gewichten und Aktivierungsfunktionen, und leitet die Ergebnisse an den nächsten Layer weiter. Es gibt verschiedene Arten von Layern, wie Eingabeschichten, versteckte Schichten und Ausgabeschichten, die gemeinsam die Struktur und die Lernfähigkeit des Netzwerks bestimmen. ↩

3. Ein Eingabevektor ist eine geordnete Liste von Zahlen, die die Features (Merkmale) eines Beispiels in einem maschinellen Lernmodell darstellen. Diese Features sind spezifische Eigenschaften oder Attribute der Daten, die das Modell verwendet, um Muster zu erkennen und Vorhersagen zu treffen. Der Eingabevektor wird in die Eingabeschicht eines neuronalen Netzwerks eingespeist, wo er die Grundlage für die weiteren Berechnungen und Verarbeitungsschritte bildet. ↩

4. Ein Ziel, auch als Zielwert oder Zielvariable bezeichnet, ist der Wert oder das Ergebnis, das ein maschinelles Lernmodell vorherzusagen versucht. In überwachten Lernaufgaben stellt das Ziel die erwartete Ausgabe dar, die das Modell lernen soll, basierend auf den Eingabedaten und deren Features. Während des Trainings vergleicht das Modell seine Vorhersagen mit den tatsächlichen Zielwerten, um Anpassungen vorzunehmen und die Genauigkeit der Vorhersagen zu verbessern. ↩

5. Die Vorwärtsausbreitung, auch Forward Propagation genannt, ist der Prozess, bei dem Eingabedaten durch ein neuronales Netzwerk geleitet werden, um eine Vorhersage oder Ausgabe zu erzeugen. Dabei wird der Eingabevektor zunächst in die Eingabeschicht eingespeist. Die Daten werden dann durch die versteckten Schichten des Netzwerks weitergegeben, wobei jede Schicht die Daten mittels Gewichtsmatrizen und Aktivierungsfunktionen transformiert. Schließlich erreicht die berechnete Information die Ausgabeschicht, wo die endgültige Vorhersage generiert wird. Die Vorwärtsausbreitung dient dazu, die Ausgabe eines Netzwerks für gegebene Eingabedaten zu berechnen, was später mit den tatsächlichen Zielwerten verglichen wird, um den Fehler zu bestimmen. ↩

6. Die Verlustfunktion spielt eine zentrale Rolle im Training neuronaler Netzwerke, da sie als Maß dafür dient, wie gut oder schlecht das Modell während des Trainings abschneidet. Sie quantifiziert den Unterschied zwischen den vorhergesagten Ausgaben des Netzwerks und den tatsächlichen Zielen (den erwarteten Ergebnissen). Je kleiner der Verlustwert, desto besser passt das Modell die Daten an. Die Verlustfunktion lenkt den Optimierungsprozess, indem sie die Richtung vorgibt, in die die Gewichte des Netzwerks angepasst werden sollten, um die Fehler zu minimieren. Durch wiederholte Berechnung und Minimierung der Verlustfunktion lernt das neuronale Netzwerk, seine Vorhersagen zu verbessern, wodurch es schließlich in der Lage ist, auch auf unbekannten Daten gut zu generalisieren. Ohne eine geeignete Verlustfunktion wäre es unmöglich, das Netzwerk in Richtung einer optimalen Lösung zu steuern, was die Verlustfunktion zu einem unverzichtbaren Element jedes maschinellen Lernmodells macht. ↩

7. Die Rückwärtsausbreitung, auch Backpropagation genannt, ist ein essenzieller Algorithmus im Training neuronaler Netzwerke, der verwendet wird, um die Gewichte der Neuronen in einem Netzwerk anzupassen. Nach der Vorwärtsausbreitung, bei der das Netzwerk eine Vorhersage auf der Grundlage von Eingabedaten macht, wird der Fehler berechnet, indem die Vorhersage mit dem tatsächlichen Zielwert verglichen wird. Dieser Fehler gibt an, wie weit das Modell von der richtigen Antwort abweicht, und dient als Grundlage für die Anpassungen, die während der Rückwärtsausbreitung vorgenommen werden. Während der Rückwärtsausbreitung wird dieser Fehler durch das Netzwerk in entgegengesetzter Richtung, also von der Ausgabeschicht zurück zur Eingabeschicht, propagiert. Dabei werden die Gradienten des Fehlers bezüglich der Gewichte in jeder Schicht berechnet. Diese Gradienten zeigen, wie stark jede Gewichtung zum Gesamtergebnis beiträgt und in welche Richtung die Gewichte angepasst werden sollten, um den Fehler zu minimieren. Dieser Prozess nutzt die Kettenregel der Differentialrechnung, um die Gradienten effizient durch das Netzwerk zu berechnen. Schließlich werden die Gewichte des Netzwerks unter Verwendung dieser Gradienten aktualisiert, in der Regel mithilfe eines Optimierungsalgorithmus wie dem Gradientenabstieg. Die Gewichte werden in die Richtung angepasst, die den Fehler verringert, was dazu führt, dass das Modell mit jeder Iteration besser lernt, die Zielwerte zu approximieren. Durch wiederholte Vorwärts- und Rückwärtsausbreitungen über viele Iterationen lernt das neuronale Netzwerk, die besten Gewichte zu finden, um präzise Vorhersagen zu treffen. ↩

8. Gradienten sind mathematische Größen, die die Richtung und die Rate der größten Zunahme einer Funktion an einem bestimmten Punkt angeben. In der Optimierung und im Training neuronaler Netzwerke geben Gradienten an, wie stark und in welche Richtung die Gewichte eines Netzwerks angepasst werden sollten, um den Fehler zu minimieren. Sie spielen eine zentrale Rolle in der Rückwärtsausbreitung, da sie verwendet werden, um die Gewichte so zu aktualisieren, dass das neuronale Netzwerk mit jeder Iteration bessere Vorhersagen macht. ↩

9. Aggregation bezieht sich im Allgemeinen auf den Prozess des Zusammenführens oder Kombinierens mehrerer Einzelwerte, Datenpunkte oder Informationen zu einem Gesamtwert oder einer zusammengefassten Information. In der Informatik und im maschinellen Lernen wird Aggregation oft verwendet, um die Ergebnisse aus verschiedenen Quellen oder Knoten zu konsolidieren, beispielsweise durch die Mittelung von Gradienten in einem verteilten neuronalen Netzwerk, um die Modellparameter zu aktualisieren. ↩

10. Mittelung ist eine spezifische Form der Aggregation, bei der die Summe einer Gruppe von Werten durch die Anzahl der Werte geteilt wird, um den Durchschnitt (Mittelwert) zu berechnen. Dies ist eine weit verbreitete Methode zur Aggregation, da sie einen repräsentativen Wert für die Gruppe von Werten liefert und extreme Werte (Ausreißer) in der Regel abschwächt. In maschinellen Lernsystemen wird die Mittelung häufig verwendet, um Gradienten oder Verluste über mehrere Knoten hinweg zu aggregieren, um stabile und robuste Updates der Modellparameter zu gewährleisten. ↩

11. Die Lernrate ist ein Hyperparameter in maschinellen Lernalgorithmen, der bestimmt, wie groß die Anpassung der Gewichte in einem neuronalen Netzwerk bei jedem Schritt der Optimierung sein soll. Sie steuert die Geschwindigkeit, mit der das Modell aus den Daten lernt. Eine zu hohe Lernrate kann dazu führen, dass das Modell die optimalen Werte der Gewichte überspringt und nicht konvergiert, während eine zu niedrige Lernrate das Training sehr langsam macht und das Risiko besteht, in lokalen Minima stecken zu bleiben. Die Lernrate ist also ein entscheidender Faktor für die Effizienz und Effektivität des Trainingsprozesses. ↩