hintergrundbild

Backpropagation: Training der neuronalen Netze

artemoppermann_x48ahib2 By Artem Oppermann In TrainingPosted
0

Backpropagation bildet die Essenz von dem Training der künstlichen neuronalen Netze. Backpropagation in neuronalen Netzen ist eine Kurzform für „Backward Propagation of Errors“. Es ist eine Standardmethode zum Trainieren künstlicher neuronaler Netze. Backpropagation bezeichnet das Verfahren zur Feinabstimmung der Gewichte von einem neuronalen Netz basierend auf der Fehlerrate, die in der vorherigen Epoche (d. h. Iteration) erhalten wurde. Bei dieser Methode werden die Gewichte der neuronalen Netze, basierend auf der Berechnung des Gradienten einer Verlustfunktion, angepasst.

Durch die Anpassung der Gewichte wird die Fehlerrate der neuronalen Netze reduziert und damit ihre Vorhersage deutlich verbessert.

In diesem Tutorial wird der Backpropagation Algorithmus für das Training der neuronalen Netze Schritt für Schritt hergeleitet.

Inhaltsverzeichnis

  1. Überwachtes Lernen
  2. Verlustfunktion
  3. Softmax-Funktion
  4. Herleitung von dem Backpropagation-Algorithmus
  5. Anzahl der Gleitkommaoperationen
  6. Laufzeitkomplexität von einem Multilayer Perceptron

1. Überwachtes Lernen

Damit im weiteren Verlauf mathematische Zusammenhänge klarer dargestellt werden können, werden an dieser Stelle folgende Definitionen eingeführt:

  • \vec{x}^{(n)}: n-te Eingabevektor, \vec{x}^{(n)}=( x_1, x_2, ..., x_d )^T
  • \vec{y}^{\text{}(n)}: n-te Ausgabevektor, \vec{y}^{\text{}(n)}=(y_1, y_2, ..., y_m )^T
  • \vec{t}^{\text{}(n)}: Das Label \vec{t}^{\text{}(n)}=( t_1, t_2, ..., t_m )^T stellt die wahren Ausgabewerte dar, die das neuronale Netz für die Eingabedaten \vec{x}^{(n)} berechnen soll.
  • (\vec{x}^{(n)},\vec{t}^{\text{}(n)}): Trainingspaar/Trainingsbeispiel
  • (\vec{x}^{(n)}, \vec{t}^{\text{}(n)})_{n=1,... , N}: Datensatz, der für das Training des neuronalen Netzes verwendet wird (auch Trainingsdatensatz genannt). Dieser besteht aus N Trainingspaaren.

Eine Eigenschaft der künstlichen neuronalen Netze ist die Fähigkeit, aus den Eingabedaten zu lernen. Das Lernen bezieht sich hier auf die Anpassung der Gewichte im neuronalen Netz, sodass das Netz in der Lage ist, eine Funktion g zu approximiert, die eine Abbildung g: \vec{x}^{(n)} \mapsto \vec{y}^{\text{}(n)} ermöglicht. Dabei soll der Unterschied zwischen \vec{y}^{\text{}(n)} und den Labels \vec{t}^{\text{}(n)} möglichst gering gehalten werden.

Beim überwachten Lernverfahren erhält das neuronale Netz die Eingabedaten \vec{x}^{(n)}. Mit diesen Werten werden Ausgabedaten \vec{y}^{(n)} berechnet.

Die Ausgabedaten werden mit den wahren Werten \vec{t}^{(n)} verglichen. Anhand des Fehlers zwischen \vec{t}^{(n)} und \vec{y}^{(n)} werden Änderungen an den Gewichten des Netzes vorgenommen. Die Änderung der Gewichte soll zukünftig zu einem kleineren Fehlerwert zwischen dem Label und den berechneten Ausgaben führen. Dieser Prozess wird für alle N Trainingsbeispiele im Trainingsdatensatz mehrmals wiederholt.

Die Anpassung der Gewichte basiert auf dem Gradientenverfahren, das in Abschnitt beschrieben wird. Der Lernprozess eines neuronalen Netzes wird auch als Training bezeichnet. Nach dem erfolgreichen Training ist das neuronale Netz in der Lage zu generalisieren, d.h. für neue Eingabedaten \vec{x}^{(neu)} eine korrekte Ausgabe \vec{y}^{(neu)} zu berechnen.

2. Verlustfunktion

Eine Verlustfunktion (auch Kostenfunktion genannt) setzt die Ausgabewerte \vec{y}^{(n)} eines neuronalen Netzes in Verhältnis zu den erwarteten Werten, den Labels \vec{t}^{(n)}. Je niedriger der Wert der Fehlerfunktion, desto besser ist das neuronale Netz in der Lage, für gegebene Eingabedaten \vec{x}^{(n)} eine passende Ausgabe \vec{y}^{(n)} zu berechnen. Mehr Informationen zu den wichtigsten Verlustfunktionen in Deep Learning, finden Sie in meinem Artikel „Verlustfunktionen in Deep Learning„.

Damit kann das Training eines neuronalen Netzes als eine Minimierung der Fehlerfunktion angesehen werden. Abhängig von der Art der Aufgabe, für die das neuronale Netz trainiert wird, muss eine andere Fehlerfunktion verwendet werden. Für Regressionsaufgaben kommt die sog. Mean Squared Error Fehlerfunktion zum Einsatz:

    \[ E_{MSE}=\frac{1}{M} \sum_{m=1}^{M}(y_m-t_m)^2 \]

Für Klassifikationsaufgaben, bei denen das neuronale Netz Wahrscheinlichkeitswerte im Intervall (0, 1) berechnen soll, wird die sog. Kreuzentropie verwendet (engl: Cross-Entropy) . Die Kreuzentropie für eine berechnete Wahrscheinlichkeitsverteilung \vec{y}^{(n)} und die tatsächliche Wahrscheinlichkeitsverteilung \vec{t}^{(n)} ist definiert gemäß:

(1)   \begin{equation*} E_{cross}=-\sum_{m=1}^{M}t_m \cdot log(y_m) \end{equation*}

3. Softmax-Funktion

Für Klassifikationsaufgaben ist eine Bedingung an die Ausgabewerte \vec{y}^{(n)} eines neuronalen Netzes zu stellen. Diese Bedingung ist, dass die Ausgabewerte eine Wahrscheinlichkeitsverteilung repräsentieren. Die einzelnen Werte im Ausgabevektor \vec{y}^{(n)} =( y_1, y_2, ..., y_m )^T müssen im Intervall (0, 1) liegen und es muss die Bedingung \sum_{m=1}^M y_m= 1 gelten.

Um diesen Zustand zu erreichen, wird in der Ausgabeschicht als Aktivierungsfunktion die Softmax-Funktion verwendet. Die Softmax-Funktion ist definiert als:

(2)   \begin{equation*} y_m=softmax(z_m)=\frac{e^{z_m}}{\sum_{m'} e^{z_{m'}}} \end{equation*}

z_m repräsentiert die gewichteten Eingabedaten (Ausgabewerte der vorherigen Schicht) des Neurons m in der Ausgabeschicht. Die Ausgabeschicht enthält dabei die gleiche Anzahl von Neuronen wie es Klassen gibt. Der Aktivierungswert y_m \in (0, 1) des Neurons m in der Ausgabeschicht gibt die Wahrscheinlichkeit an, dass die Eingabewerte \vec{x}^{(n)} zu der Klasse gehören, die durch das Neuron m repräsentiert wird.

Mehr Informationen zur Verwendung und Implementierung der Softmax-Funktion finden Sie in meinem Artikel „Aktivierungsfunktionen in neuronalen Netzen„.

4. Herleitung von dem Backpropagation-Algorithmus

Der Backpropagation-Algorithm (deutsch: Rückpropagierung-Algorithmus) hat sich als eines der effizientesten Lernverfahren für mehrschichtige neuronale Netzwerke herausgestellt.

Die Grundidee des Backpropagation-Algorithmus ist eine fortlaufende Anpassung der Verbindungsgewichte zwischen den Neuronen, bis die berechnete Ausgabe des neuronalen Netzes hinreichend genau mit der gewünschten Ausgabe, dem Label, übereinstimmt. Die Anpassung der Gewichte erfolgt mittels des Gradientenverfahrens.

Insbesondere wird hier der negative Gradient der Fehlerfunktion als Abstiegsrichtung gewählt.

Im Rahmen dieses Artikels werden Multilayer Perceptrons für Klassifikationsaufgaben implementiert. Aus diesem Grund werden an dieser Stelle die für die Anpassung der Gewichte erforderlichen Gleichungen hergeleitet, die später während des Backpropagation-Algorithmus im Quellcode verwendet werden.

Bei einer Klassifikation wird für die Eingabedaten \vec{x}^{(n)}= (x_1, x_2, ..., x_d )^T vom neuronalen Netz eine Wahrscheinlichkeitsverteilung \vec{y}^{(n)}= ( y_1, y_2, ..., y_m)^T berechnet. Dabei gibt y_i im Ausgabevektor \vec{y}^{(n)} die Wahrscheinlichkeit an, dass \vec{x}^{(n)} zu der i-ten Klasse gehört. Es gilt 0<y_i<1 und \sum_{m=1}^{M}y_m=1. Diese Anforderungen werden durch die Verwendung der Softmax-Funktion in der Ausgabeschicht des Netzes sichergestellt.

Die Herleitung der Gleichungen für die Anpassung der Gewichte erfolgt anhand des Beispiels von dem Multilayer Perceptron in der Abb. 1. Das Netzwerk besitzt eine einzelne versteckte Schicht mit C Neuronen, eine Eingabeschicht mit D Neuronen und eine Ausgabeschicht mit M Neuronen.

Multilayer Perceptron mit der Architektur von (D,C,M) Neuronen.
Abb. 1 Multilayer Perceptron mit der Architektur von (D,C,M) Neuronen.

Um die folgenden mathematischen Zusammenhänge besser verstehen zu können, werden an dieser Stelle folgende Definitionen eingeführt:

  • x_d^{(1)}: Das Neuron d der ersten Schicht (Eingabeschicht).
  • s_c^{(2)}: Das Neuron c der zweiten Schicht (Versteckte Schicht).
  • y_m^{(3)}: Das Neuron m der dritten Schicht (Ausgabeschicht).
  • W_{cd}^{(1)}: Die Gewichte der ersten Gewichtsmatrix, die die Verbindung zwischen den Neuronen d und c realisieren.
  • W_{mc}^{(2)}: Die Gewichte der zweiten Gewichtsmatrix, die die Verbindungen zwischen den Neuronen c und m realisieren.

Als Fehlerfunktion wird die Kreuzentropie verwendet:

(3)   \begin{equation*} E{}=-\sum_{m=1}^{M}t_m \cdot log(y_m) \end{equation*}

Das Label \vec{t}^{ (n)}=(t_1, t_2, ..., t_m)^T ist one-hot-encoded. Das bedeutet, dass alle Einträge in \vec{t}^{(n)} Werte von null aufweisen, bis auf einen Eintrag, der den Wert 1 hat. Der Index des Eintrags 1 repräsentiert die Klasse der Eingabedaten \vec{x}^{(n)}, zu dem dieses Label gehört.

Die Werte y_m^{(3)} in der Ausgabeschicht berechnet sich mit der Softmax-Funktion:

(4)   \begin{equation*} y_m^{(3)}=softmax(z_m^{(3)})=\frac{e^{z_m^{(3)}}}{\sum_{m'} e^{z_{m'}^{(3)}}} \end{equation*}

z_m^{(3)} ist die Summe der gewichteten Aktivierungswerte s_c^{(2)} der versteckten Schicht, die zum m-ten Neuron der Ausgabeschicht führen:

(5)   \begin{equation*} z_m^{(3)}=\sum_{c=1}^{C} W_{mc}^{(2)}s_c^{(2)} \end{equation*}

Dagegen ist z_c^{(2)} die gewichtete Summe der Neuronen der ersten Schicht, die zum Neuron c in der versteckt Schicht führen. Auf diese gewichtete Summe wird die Aktivierungsfunktion f(.) angewandt:

(6)   \begin{equation*} s_c^{(2)}=f(z_c^{(2)})=f(\sum_{d=1}^{D}W_{cd}^{(1)}x_d^{(1)}) \end{equation*}

Damit stellt s_c^{(2)} den Aktivierungswert des Neurons c in der versteckten Schicht dar. Das Einsetzen der Gl. 4 in Gl. 3 ergibt:

(7)   \begin{equation*} E=- \sum_{m=1}^{M} t_m \cdot log(y_m^{(3)})=- \sum_{m=1}^{M} t_m \cdot(z_m^{(3)}-log(\sum_{m'}e^{z_{m'}^{(3)}})) \end{equation*}

Im nächsten Schritt wird die Fehlerfunktion E gemäß des Gradientenverfahrens nach den einzelnen Gewichten des neuronalen Netzes abgeleitet. Die Ableitung der Fehlerfunktion nach den Gewichten erfolgt mittels der Kettenregel. Die Ableitung der Kreuzentropie E nach den Gewichten W_{mc}^{(2)} der zweiten Gewichtsmatrix ist gegeben durch Gl. 8.

(8)   \begin{equation*} \frac{dE}{dW_{mc}^{(2)}}=\frac{dE}{dz_m^{(3)}} \frac{dz_m^{(3)}}{dW_{mc}^{(2)}} \end{equation*}

Gl. 8 besteht aus zwei Differentialquotienten. Diese werden seperat voneinander berechnet. Für den ersten Differentialquotienten gilt:

(9)   \begin{equation*} \frac{dE}{dz_m^{(3)}}=-\sum_{m'}t_{m'}(\frac{dz_{m'}^{(3)}}{dz_m^{(3)}}-\frac{d}{dz_m^{(3)}}log(\sum_{m'}e^{z_{m'}^{(3)}})) \end{equation*}

(10)   \begin{equation*} =-\sum_{m'}t_{m'}(\delta_{mm'}-\frac{\sum_{m'}\frac{d}{dz_m^{(3)}}e^{z_{m'}^{(3)}}}{\sum_{m'} e^{z_{m'}^{(3)}}}) \end{equation*}

(11)   \begin{equation*} =-\sum_{m'}t_{m'}(\delta_{mm'}-\frac{\sum_{m'}\delta_{mm'}e^{z_{m'}^{(3)}}}{\sum_{m'} e^{z_{m'}^{(3)}}}) \end{equation*}

(12)   \begin{equation*} =-\sum_{m'}t_{m'}(\delta_{mm'}-\frac{e^{z_{m}^{(3)}}}{\sum_{m'} e^{z_{m'}^{(3)}}}) \end{equation*}

(13)   \begin{equation*} =-\sum_{m'}t_{m'}\delta_{mm'}+y_m^{(3)}\sum_{m'}t_{m'} \end{equation*}

(14)   \begin{equation*} =-t_m+y_m^{(3)}=y_m^{(3)}-t_m:= \delta_m^{(3)} \end{equation*}

In der der Gl. 14 wird die Eigenschaft \sum_{m=1}^{M}t_m=1 des one-hot-encoded Labels benutzt. Das Ergebnis des Differentialquotienten wird abgekürzt mit \delta_m^{(3)}=y_m^{(3)}-t_m.

Der zweite Differentialquotient aus Gl. 8 wird in Gl. 15 berechnet. Das Ergebnis stellt den Aktivierungswert des Neurons s_{c}^{(2)} in der versteckten Schicht dar.

(15)   \begin{equation*} \frac{dz_m^{(3)}}{dW_{mc}^{(2)}}=\sum_{c'}\frac{d}{dW_{mc}^{(2)}}W_{mc'}^{(2)}s_{c'}^{(2)} \end{equation*}

(16)   \begin{equation*} =\sum_{c'}\delta_{cc'}s_{c'}^{(2)}=s_{c}^{(2)} \end{equation*}

Damit erhalten wir mit Gl. 17 die vollständige Form der Ableitung der Fehlerfunktion nach den Gewichten der zweiten Gewichtsmatrix.

(17)   \begin{equation*} \frac{dE}{dW_{mc}^{(2)}}=(y_m^{(3)}-t_m)s_{c}^{(2)}=\delta_m^{(3)}s_{c}^{(2)} \end{equation*}

Die Ableitung der Fehlerfunktion nach den Gewichten W_{cd}^{(1)} der ersten Gewichtsmatrix wird ebenfalls mit der Kettenregel berechnet. Damit erhalten wir drei separate Differentialquotienten:

(18)   \begin{equation*} \frac{dE}{dW_{cd}^{(1)}}=\frac{dE}{ds_{c}^{(2)}}\frac{ds_{c}^{(2)}}{dz_c^{(2)}}\frac{dz_c^{(2)}}{dW_{cd}^{(1)}} \end{equation*}

Der erste Quotient in Gl. 18 wird wie folgt berechnet:

(19)   \begin{equation*} \frac{dE}{ds_{c}^{(2)}}=\sum_{m}\frac{dE}{dz_m^{(3)}}\frac{dz_m^{(3)}}{ds_c^{(2)}} \end{equation*}

(20)   \begin{equation*} =\sum_{m}\delta_m^{(3)}\sum_{c'}\frac{d}{ds_{c}^{(2)}}W_{mc'}^{(2)}s_{c'}^{(2)} \end{equation*}

(21)   \begin{equation*} =\sum_{m}\delta_m^{(3)}\sum_{c'}\delta_{cc'}W_{mc'}^{(2)} \end{equation*}

(22)   \begin{equation*} =\sum_{m}\delta_m^{(3)}W_{mc}^{(2)} \end{equation*}

Die Berechnung des zweiten Differentialquotienten in Gl. 18 ist trivial:

(23)   \begin{equation*} \frac{ds_{c}^{(2)}}{dz_c^{(2)}}=f'(z_c^{(2)}) \end{equation*}

Als letztes wird in Gl. 24 der dritte Quotient berechnet.

(24)   \begin{equation*} \frac{dz_c^{(2)}}{dW_{cd}^{(1)}}=\frac{d}{dW_{cd}^{(1)}}\sum_{d=1}^D W_{cd}^{(1)}x_d^{(1)} \end{equation*}

(25)   \begin{equation*} =\sum_{d'} \frac{d}{dW_{cd}^{(1)}} W_{cd'}^{(1)}x_{d'}^{(1)} \end{equation*}

(26)   \begin{equation*} =\sum_{d'}\delta_{dd'}x_{d'}^{(1)}=x_d^{(1)} \end{equation*}

Die Ergebnisse in Gleichungen 22, 23 und 24 ergeben die endgültige Form der Ableitung der Fehlerfunktion nach W_{cd}^{(1)}:

(27)   \begin{equation*} \frac{dE}{dW_{cd}^{(1)}}=x_d^{(1)}f'(z_c^{(2)})\sum_{m}\delta_m^{(3)}W_{mc}^{(2)} \end{equation*}

Wir führen die Definition \delta_c^{(2)} ein:

(28)   \begin{equation*} \delta_c^{(2)}:=f'(z_c^{(2)})\sum_{m}\delta_m^{(3)}W_{mc}^{(2)} \end{equation*}

Mit der Definition in Gl. 28 lässt sich die Ableitung in Gl. 27 umformulieren zu:

(29)   \begin{equation*} \frac{dE}{dW_{cd}^{(1)}}= \delta_c^{(2)}x_d^{(1)} \end{equation*}

Gemäß dem Gradientenverfahren werden die Gewichte in die negative Richtung der Ableitung der Fehlerfunktion angepasst. Für die Anpassung der Gewichte W_{cd}^{(1)}und W_{mc}^{(2)} gilt damit:

(30)   \begin{equation*} W_{cd}^{(1)}=W_{cd}^{(1)} - \eta \frac{dE}{dW_{cd}^{(1)}} \end{equation*}

(31)   \begin{equation*} W_{mc}^{(2)}=W_{mc}^{(2)} - \eta \frac{dE}{dW_{mc}^{(2)}} \end{equation*}

\eta bezeichnet hier die Lernrate. Das Einsetzen der vorherigen Ergebnisse in Gl. 30 und 31 ergibt:

(32)   \begin{equation*} W_{cd}^{(1)}=W_{cd}^{(1)} - \eta \delta_c^{(2)}x_d^{(1)} \end{equation*}

(33)   \begin{equation*} W_{mc}^{(2)}=W_{mc}^{(2)} - \eta \delta_m^{(3)}s_{c}^{(2)} \end{equation*}

Damit erhalten wir die finale Form der Gleichungen für die Anpassung der Gewichte in einem Multilayer Perceptron, der eine versteckte Schicht aufweist.

Diese Ergebnisse können für einen Multilayer Perceptron mit einer beliebigen Anzahl von Schichten verallgemeinert werden. Die Anpassungsregel für die Gewichte in einem Multilayer Perceptron mit L Schichten ist gegeben mit Gl. 36. Dabei nimmt l ganzzahlige Werte im Intervall [1, L-1] an.

(34)   \begin{equation*} \delta_c^{(l+1)}=\frac{dE}{dz_m^{l+1}} \end{equation*}

(35)   \begin{equation*} \delta_c^{(l)}=f'(z_c^{(l)})\sum_{m}\delta_m^{(l+1)}W_{mc}^{(l)} \end{equation*}

(36)   \begin{equation*} W_{mc}^{(l)}=W_{mc}^{(l)} - \eta \delta_m^{(l+1)}s_{c}^{(l)} \end{equation*}

5. Anzahl der Gleitkommaoperationen

Als Gleitkommaoperationen bezeichnet man einzelne Befehle und Berechnungen in Computerprogrammen, die Gleitkommazahlen verwenden.

An dieser Stelle soll die Gleichung für die Anzahl der beim Training eines Multilayer Perceptrons verwendeten Gleitkommaoperationen hergeleitet werden. Die Gleitkommaoperationen werden im Folgenden als FLOPs (englisch: floating-point operations) abgekürzt. Die Ableitung der Gleichung zur Berechnung der Anzahl der Gleitkommaoperationen wird für das Multilayer Perceptron mit der Architektur von (D, C, M) Neuronen durchgeführt (vgl. Abb. 1).

Die Menge der Gleitkommaoperationen für die Berechnung der Aktivierungswerte \vec{s}^{\text{ }(2)} der versteckten Schicht ergibt sich aus DC Multiplikationsoperationen, (D-1)C Additionsoperationen und C Anwendungen der Aktivierungsfunktion. Damit beträgt die Anzahl der Operationen für die Berechnungen der Aktivierungswerte der ersten versteckten Schicht FLOPs(\vec{s}^{\text{ }(2)}) = 2DC.

Die Menge der Operationen für die Berechnung der Ausgabewerte \vec{y}^{\text{ }(3)} berechnen sich analog und ergibt FLOPs(\vec{y}^{\text{ }(3)})=2CM, wobei \textit{softmax}(y_m) zur Vereinfachung als nur eine Operation gezählt wird.

Für die Berechnung der Gradienten \frac{dE}{dW^{(2)}} (vgl. Gl. ??), werden insgesamt FLOPs(\frac{dE}{dW^{(2)}})=M+CM Operationen benötigt. Dabei entfallen M Operationen auf die Berechnung von (s_m^{(3)}-t_m). CM steht für die Menge der Multiplikationen in (s_m^{(3)}-t_m)\cdot s_c^{(2)}.

Die Berechnung von FLOPs(\frac{dE}{dW^{(1)}}) ist umfangreicher. Für \sum_{m}\delta_m^{(3)}W_{mc}^{(2)} ergeben sich CM Multiplikationen und C(M-1) Additionen. f'(z_c^{(2)}) muss C mal berechnet werden. Zwischen f'(z_c^{(2)}) und \sum_{m}\delta_m^{(3)}W_{mc}^{(2)} werden C Multiplikationen benötigt. Zwischen x_d^{(1)} und f'(z_c^{(2)}) \sum_{m}\delta_m^{(3)}W_{mc}^{(2)} werden DC Multiplikationen durchgeführt. Damit gilt FLOPs(\frac{dE}{dW^{(1)}})=DC+2C+C(M+(M-1)).

Für die Anpassung der Gewichte in W^{(1)} mit den berechneten Gradienten gilt FLOPs(W_{update}^{(1)})=2DC. Dabei werden DC Multiplikationen und DC Subtraktionen durchgeführt. Analog ergibt sich mit FLOPs(W_{update}^{(2)})=2CM die Menge der Gleitkommaoperationen für die Anpassung von W^{(2)}.

Damit müssen in einer Trainingsiterationen bei einem Multilayer Perceptron mit (D, C, M) – Neuronen für einen einzelnen Datenpunkt insgesamt FLOPs= C(5D+7M+1)+M Gleitkommaoperationen durchgeführt werden.

6. Laufzeitkomplexität von einem Multilayer Perceptron

Die Laufzeitkomplexität von einem Multilayer Perceptron mit (D, C, M) – Neuronen bei der Berechnung eines Ausgabewertes beträgt \mathcal{O}(DC + C + C M + M)=\mathcal{O}(D C + C M).

Für die Berechnung von \frac{dE}{dW^{2}} und \frac{dE}{dW^{1}} muss der Aufwand von \mathcal{O}(C M) und \mathcal{O}(C+ C M +D C ) aufgebracht werden.

Für die Anpassung von W^{(2)} und W^{(1)} betragen die Laufzeitkomplexitäten \mathcal{O}(C M) und \mathcal{O}(D C).

Damit ergibt sich für den Backpropagation-Algotithmus mit \mathcal{O}(3CM +2DC +C)=\mathcal{O}(D C +C M) die gleiche Laufzeitkomplexität wie bei der Berechnung der Ausgabewerte.

Die gesamte Laufzeitkomplexität des Multilayer Perceptrons beträgt damit \mathcal{O}(D C + C M). Für einen Trainingsdatensatz mit N Datenpunkten ergibt sich mit \mathcal{O}(N D C + N C M) der Rechenaufwand für eine volle Epoche.

©KI Tutorials
artemoppermann_x48ahib2

Artem Oppermann

Related Posts

Data Preprocessing in Machine Learning
Auswahl der Trainingsdaten
KI Use Case: Natural Language Processing
KI Use Case: Vorhersage des nächsten Elements

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert