MQL5-Assistenten-Techniken, die Sie kennen sollten (Teil 30): Spotlight auf Batch-Normalisierung beim maschinellen Lernen

Einführung

Die Batch-Normalizierung ist eine Form der Standardisierung von Daten, bevor sie in die Schichten des neuronalen Netzes eingespeist werden, verbessert die Leistung der Netze, doch es herrscht Uneinigkeit darüber, warum dies so ist. Während in der Originalarbeit zu diesem Thema als Grund eine interne Kovariatenverschiebung angegeben wurde, die als Abschwächung der Auswirkungen von Ungleichgewichten in den Eingabedaten der „vorgelagerten Schichten“ auf die nachgelagerten Schichten verstanden werden kann, wird in dieser neuen Studie behauptet, dass die Verbesserungen der empirischen Leistung auf die Glättung zurückzuführen sind, da die schichtinternen Gradienten aufgrund der Normalisierung eine geringere Variabilität aufweisen.

Aus der Sicht eines Händlers ist das Interesse an der Frage, WARUM die Batch-Normalisierung die Leistung eines neuronalen Netzes beeinflusst, ein guter Grund, Systeme zu entwickeln und zu testen, die dieses Verfahren verwenden, und das ist unsere Aufgabe. Es gibt drei Hauptformen der Stapelnormalisierung, die wir untersuchen werden, nämlich Standard-Skalierung, Merkmal-Skalierung, und Robuste Skalierung. Jeder dieser Algorithmen ist sehr einfach. Wir werden Tests mit Expert Advisors durchführen, die jeden dieser Algorithmen verwenden, und als Kontrolle werden wir auch Tests mit Expert Advisors durchführen, die keine Batch-Normalisierung verwenden. Unser Artikel wird also zu dem Format zurückkehren, das wir vor den letzten beiden Artikeln (über Lernraten) verwendet haben, wo wir nun Beschreibungen aller drei Normalisierungen, dann Testberichte über dieselben mit einer Kontrolle und schließlich eine Schlussfolgerung haben werden.

In diesem Artikel, wie auch in allen anderen Artikeln dieser Reihe, wird die Verwendung von assistentengestützten Expert Advisors beim Testen neuer Ideen hervorgehoben. Eine Einführung, wie das gemacht wird, finden Sie hier und hier für neue Leser, wobei diese beiden Artikel eine Anleitung zur Verwendung des am Ende dieses Artikels beigefügten Codes bieten. Für diesen Beitrag verwenden wir einige nutzerdefinierte Enumerationen von Daten als optimierbare Eingaben. Die in MQL5 integrierte Enumerationen können in der Kopfzeile der nutzerdefinierten Signaldatei deklariert werden, und sie werden automatisch als Eingänge angezeigt und als Teil des Signalfilters initialisiert. Wenn die Enumerationen jedoch nutzerdefiniert sind, verhindert die Platzierung in der Kopfzeile, dass die Datei im MQL5-Assistenten sichtbar (oder erkennbar) ist, was bedeutet, dass Sie die Assemblierung nicht durchführen können. Um dies zu umgehen, lassen wir sie zu Beginn der nutzerdefinierten Signalklasse weg und deklarieren die Parameter und ihre Zuweisungsfunktionen innerhalb der Signalklasse, wie es bei jedem Eingabeparameter der Fall ist. Sobald der Assistent fertig ist, nehmen wir manuelle Änderungen an der Liste der Eingabeparameter und an der Initialisierung der Signalklasse vor, um diese nutzerdefinierten Enumerationswerte hinzuzufügen.

Es gab einen Hack, den ich gefunden hatte, um dies zu umgehen, der meines Erachtens die Deklaration der Enumerationen in der Signalklasse selbst beinhaltete, aber ich erinnere mich nicht an die Einzelheiten, sodass wir uns mit dieser manuellen Bearbeitung begnügen müssen. Unser Test-Expert Advisor verfügt über nutzerdefinierte Enumerationen für den Typ der Lernrate, den Typ der adaptiven Lernrate und, was für diesen Artikel am wichtigsten ist, eine Aufzählung der Normalisierungsarten. Der Code des letzteren wird unten mitgeteilt:

enum Enormalize
{  NORMALIZE_NONE = -1,
   NORMALIZE_ROBUST = 0,
   NORMALIZE_FEATURE = 1,
   NORMALIZE_STANDARD = 2,
};

Um diese Enumeration innerhalb des Expert Advisors zu verwenden und zu optimieren, müssten wir die Enumerationswerte manuell als Eingaben hinzufügen, wie folgt:

....

input ENUM_ACTIVATION_FUNCTION Signal_CMLP_ActivationType = AF_SIGMOID;  // CMLP(30,6,0.05,10,0.1,2,...) Activation Type
input Enormalize Signal_CMLP_NormalizeType   = NORMALIZE_FEATURE; // CMLP(30,6,0.05,10,0.1,2,...) Batch Normalisation Type
input Elearning Signal_CMLP_LearningType   = LEARNING_ADAPTIVE; // CMLP(30,6,0.05,10,0.1,2,...) Learning Type
input Eadaptive Signal_CMLP_AdaptiveType   = ADAPTIVE_GRADIENT; // CMLP(30,6,0.05,10,0.1,2,...) Adaptive Type

...

Darüber hinaus müssen wir die deklarierten Parameter zur Instanz des nutzerdefinierten Signals hinzufügen, das als „filter0“ initialisiert wird. Dies geschieht wie folgt:

...

   filter0.ActivationType(Signal_CMLP_ActivationType);
   filter0.NormalizeType(Signal_CMLP_NormalizeType);
   filter0.LearningType(Signal_CMLP_LearningType);
   filter0.AdaptiveType(Signal_CMLP_AdaptiveType);

...

Sobald dies geschehen ist, kann der vom Assistenten zusammengestellte Experte normal mit unserer nutzerdefinierten Signalklasse verwendet werden. Nachdem wir oben die 3 Formate der Normalisierung vorgestellt haben, die wir über die nutzerdefinierte Enumeration betrachten werden, wollen wir uns nun einen kurzen Überblick über das Thema verschaffen, bevor wir uns jeden der Batch-Aufzählungstypen genauer ansehen und anschließend die allgemeine Implementierung in der nutzerdefinierten Signalklasse betrachten.

Argumente für eine Batch-Normalisierung in neuronalen Netzen

Offiziell beruhen die meisten Vorteile der Batch-Normalisierung immer noch auf den Argumenten der Arbeit von 2015, die sie an das Licht brachte. Da inzwischen eine Debatte darüber geführt wird, wie die empirischen Ergebnisse zustande gekommen sind, haben diese ursprünglichen Argumente nicht mehr unbedingt das gleiche Gewicht wie zu Beginn. Nichtsdestotrotz stellen wir sie hier vor, um zumindest einen Einstieg in das Thema zu geben. Die Batch-Normalisierung soll den Trainingsprozess stabilisieren, indem sie die oben erwähnte interne Kovariatenverschiebung reduziert. Sie verbessert die Konvergenzgeschwindigkeit, da die Aktivierungen auf jeder Schicht „standardisierter“ sind. Darüber hinaus verringert sich die Empfindlichkeit gegenüber den Initialisierungsgewichten, die in einem Netz vor dem Training verwendet werden. Die anfänglichen Gewichte haben nicht nur einen unverhältnismäßig großen Einfluss auf die endgültigen Gewichte, sondern auch darauf, wie lange der Trainingsprozess dauert.

Darüber hinaus wirkt die Batch-Normalisierung als Regularisierer, indem sie das Netz weniger empfindlich gegenüber den Gewichten einiger Neuronen macht. Es ermöglicht auch das Training von tiefen neuronalen Netzen, indem es Probleme mit verschwindenden Gradienten reduziert. Es entkoppelt die Abhängigkeiten zwischen den Ebenen, macht den Trainingsprozess invariant gegenüber Veränderungen in der Skalierung der Eingangsmerkmale, verbessert die Modellgeneralisierung, erleichtert das Training mit verschiedenen Stapelgrößen und ist gut geeignet, um mit verschiedenen Lernraten zu experimentieren. Dies sind einige der angepriesenen Vorteile der Stapelnormalisierung. Betrachten wir nun die einzelnen Typen.

Merkmal Skalierung

Bei dieser Form der Normalisierung werden alle Daten eines Vektors auf einer Ebene in den Bereich 0,0 bis +1,0 gesetzt. Die Formel hierfür lautet für jeden Wert des Vektors:

Wobei:

• x' ist der normierte Wert
• x ist der ursprüngliche de-normierte Wert
• min(x) ist eine Funktion, die das Minimum des Vektors zurückgibt
• max(x) gibt das Maximum des Vektors zurück

Die Implementierung dieses sehr einfachen Algorithmus wäre in MQL5 wie folgt einfach zu bewerkstelligen:

//+------------------------------------------------------------------+
//| Function to apply Feature-Scaling
//+------------------------------------------------------------------+
void Cnormalize::FeatureScaling(vector &Data)
{  vector _copy;
   _copy.Copy(Data);
   if(_copy.Max() - _copy.Min() > 0.0)
   {  for (int i = 0; i < int(Data.Size()); i++)
      {  Data[i] = (_copy[i] - _copy.Min()) / (_copy.Max() - _copy.Min());
      }
   }
}

Bei der Auswahl eines Normalisierungsalgorithmus ist die Art der Aktivierung, die in jeder Schicht verwendet werden soll, eine wichtige Überlegung. Das liegt daran, dass nicht alle Aktivierungsfunktionen ihre Ergebnisse in demselben Bereich ausgeben. Hier finden Sie eine tabellarische Übersicht über die verschiedenen Aktivierungsfunktionen, die als Enumeration in MQL5 zur Verfügung stehen, und ihre jeweiligen Ausgabebereiche:

Aktivierung Funktion	Leistungsbereich
Exponential Linear Unit (ELU)		(-1, ∞)
Exponential (Exp)		(0, ∞)
Gaussian Error Linear Unit (GELU)		(-∞, ∞)
Hard Sigmoid		[0, 1]
Linear		(-∞, ∞)
Leaky Rectified Linear Unit (Leaky ReLU)		(-∞, ∞)
Rectified Linear Unit (ReLU)		[0, ∞)
Scaled Exponential Linear Unit (SELU)		(-∞, ∞)
Sigmoid		(0, 1)
Softmax		(0, 1), summiert sich auf 1
Softplus		(0, ∞)
Softsign		(-1, 1)
Swish		(-∞, ∞)
Hyperbolic Tangent (Tanh)		(-1, 1)
Thresholded Rectified Linear Unit (Thresholded ReLU)		{0} ∪ [θ, ∞), wobei θ > 0

Wie man sieht, haben wir nur 3 Aktivierungsfunktionen, die Ausgaben in einem Bereich liefern, der dem Batch-Normalisierungsalgorithmus der Merkmalsskalierung ähnlich ist. Diese sind Hard-Sigmoid, Sigmoid und Soft max. Alles andere ist tabu. Diese Abstimmung der Leistungsbereiche ist unerlässlich, wenn die Netze die verschwindenden/explodierenden Probleme der Gradienten, die beim Training häufig auftreten, zu vermeiden.

Die Aktivierung durch Hard Sigmoid ist eine einfache Annäherung an die Funktion sigmoide, die durch die folgende Gleichung definiert ist:

Unabhängig davon, welche Eingabe wir für x haben, wird die Ausgabe also im Bereich von 0,0 bis +1,0 liegen. Diese Anpassung an die Merkmalsskalierung gewährleistet konsistente und interpretierbare Aktivierungen. Außerdem ist das Hard Sigmoid rechnerisch effizient und daher für große und sehr tiefe Netze wie Transformer geeignet.

Die Aktivierungsfunktion Sigmoid ist wohl die beliebteste aller Aktivierungen, da sie Probleme mit explodierenden Gradienten durch die bereichsgesteuerte Ausgabe minimiert, die im Gegensatz zur obigen Aktivierung duch Hard Sigmoid noch ein gewisses Maß an Variabilität beibehält. Die Gleichung lautet wie folgt:

Wobei:

• e ist die Eulersche Konstante,
• x ist der normierte Wert.

Die Gleichmäßigkeit der Abbildung stimmt gut mit dem normalisierten Skalenbereich der Merkmale überein. Außerdem werden Probleme mit der Gradientensättigung vermieden, da Ausgangswerte von 0,0 oder 1,0 selten sind.

Die Softmax-Aktivierung normalisiert eine Klasse (oder sagen wir einen Datenvektor) so, dass alle ihre Werte nicht nur im Bereich von 0,0 bis 1,0 liegen, sondern dass diese normalisierten Werte, wenn sie addiert werden, 1,0 ergeben. Die Gleichung, aus der sich dies ableitet, ist unten angegeben:

Wobei:

• z i ist das i-te Element des Eingangsvektors Z
• K ist die Vektorgröße von Z,
• e ist die Eulersche Konstante.

Soft Max wird typischerweise in der Mehrklassen-Klassifikation oder beim Vergleich von Datenpunkten mit mehr als einer Dimension verwendet. Das Ergebnis impliziert eine Wahrscheinlichkeitsverteilung, bei der kein einzelnes Ergebnis die anderen unverhältnismäßig stark dominiert, wodurch eine Art gleiches Spielfeld entsteht. Darüber hinaus wird durch die Summierung auf eins sichergestellt, dass keine großen Zahlen vorhanden sind, die in sehr tiefen Netzen oder Transformer zu nachgelagerten Berechnungsproblemen führen können.

Somit sind Hard Sigmoid, Sigmoid und Soft Max die drei geeigneten Aktivierungsfunktionsalgorithmen für die Normalisierung der Eigenschafts-Skalierung, da die Ergebnisse aller drei Algorithmen in der Regel mit den Ergebnissen dieser Batch-Normalisierung übereinstimmen. Die Implementierung dieser Algorithmen in MQL5 ist wirklich einfach, da auf alle Aktivierungsalgorithmen und ihre jeweiligen Ableitungen über die eingebauten Funktionen des Vektordatentyps zugegriffen werden kann. Beispiele hierfür sind die Funktionen „Forward()“ und „Backward()“, die Teil der Klasse „Cmlp“ sind, die diesem Artikel beigefügt ist. Alternativ dazu gibt es auch offizielle Leitlinien für die Funktionen der Aktivierung und der Ableitung.

Die Implementierung des Algorithmus zur Merkmalsskalierung wurde bereits oben erläutert. Es handelt sich um eine einfache Funktion, die auf Nulldurchgänge prüft, indem sie sicherstellt, dass die Maximal- und Minimalwerte des Vektors nicht identisch sind. Die Skalierungsfunktionen sind sehr einfach, was für die Minimierung des Rechenaufwands wichtig ist, da viele Netze sehr tief und im Transformerformat sein können.

Robuste Skalierung

Diese Form der Normalisierung bietet etwas mehr Spielraum bei der Ausgabe, da sie unter bestimmten Bedingungen Werte liefert, die leicht über -1,0 und +1,0 hinausgehen, aber in den meisten Fällen liegen alle Daten zwischen -1,0 und +1,0. Ausnahmen hiervon sind üblich und treten dann auf, wenn Ausreißer vorhanden sind, deren Abstand zum Median so groß ist, dass er den Interquartilsbereich überschreitet. Die dafür maßgebliche Gleichung lautet wie folgt:

Wobei:

• x ist der ursprüngliche Wert
• median(x) ist der Vektor oder Klassenmedian
• IQR(x) ist das ^75-Perzentilminus das^25-Perzentilder Klasse.

Die robuste Skalierung ist zwar weniger empfindlich gegenüber Ausreißern als die Merkmalsskalierung, ignoriert sie aber nicht. Tatsächlich sind es Ausreißer, die weit vom Median entfernt sind, die dazu neigen, normalisierte Werte zu liefern, deren Größenordnung über eins liegt. Mit anderen Worten, eine Situation, in der Daten mit hoher Variabilität (Bereich zwischen Maximum und Minimum) überwiegend um den Median herum zentriert sind, die Zahl der Extremwerte jedoch allmählich abnimmt, sodass es sich bei den Extremwerten nicht unbedingt um Ausreißer handelt. In diesen Fällen haben auch die Werte, die näher an den Extremen liegen, Normalisierungen mit Größenordnungen von mehr als eins.

Aus der obigen Tabelle über die Aktivierungsausgangsbereiche geht hervor, dass die ideale Wahl der Aktivierungsfunktionen für die Kombination mit der robusten Skalierung die Soft-Sign-Aktivierung oder die TANH-Aktivierung wäre. Der Grund dafür ist, dass ihre Ausgaben, obwohl sie angesichts der oben erwähnten möglichen robusten Skalierungsausreißer etwas restriktiv auf den Bereich von -1,0 bis +1,0 beschränkt sind, die beste Übereinstimmung mit allen anderen Aktivierungen darstellen. Noch wichtiger ist jedoch, dass diese Aktivierungsausgänge keine unendlichen Werte erzeugen, sodass die Gefahr von verschwindenden und explodierenden Gradienten stark gemindert wird.

Soft Sign wird durch eine sehr einfache Gleichung definiert:

Wobei:

• x ist der Datenpunkt in der Klasse oder der Vektor
• |x| ist die Größe dieser Daten

Aus der Formel geht klar hervor, dass x oder die Daten innerhalb eines normalisierten Vektors idealerweise ein Fließkomma-Typ sein sollten und wahrscheinlich in einer Größenordnung von 0,0 bis 2,0 liegen. Da die x-Werte von 2,0 an aufwärts skalieren, würde die Variabilität und damit die Interpretation der normalisierten Daten beeinträchtigt werden. Dies deutet auf eine Sättigung der normalisierten Werte weg von Null hin, aber auf einen sanften Übergang um den Nullwert herum. Die Symmetrie und die Zentrierung der Werte um den Nullpunkt stehen im Einklang mit einer robusten Skalierung. Außerdem wurde beobachtet, dass die Gradienten von Soft Sign nicht so leicht verschwinden wie die von anderen Aktivierungsfunktionen, z. B. der beliebten Sigmoid Aktivierung. Dies kann sehr vorteilhaft sein, wenn umfangreiche Trainings mit großen Datensätzen durchgeführt werden.

Die TANH-Aktivierung ist ein weiterer Algorithmus zur Begrenzung des Bereichs von -1,0 bis +1,0, der gut funktionieren sollte und eine robuste Skalierung ermöglicht. Die Gleichung ist unten angegeben:

Wobei:

• x ist ein Datenpunkt innerhalb der Klasse oder des Vektors
• e ist die Eulersche Konstante.

Der TANH-Algorithmus ist in seiner Form dem Sigmoid-Algorithmus sehr ähnlich, mit dem offensichtlichen Unterschied, dass er um 0,0 zentriert ist, während der Sigmoid-Algorithmus um 0,5 zentriert ist. Außerdem bietet sie Berichten zufolge eine glattere Steigung als die Sigmoidfunktion. Der Vorzeichenbereich, wie bei Soft-Sign, macht es zu einem weiteren idealen Kandidaten für die Arbeit mit robuster Skalierung, wie wir oben gesehen haben. Verrauschte Daten oder Datensätze mit vielen Ausreißern, zu denen aus Sicht eines Händlers auch Preispuffer von sehr volatilen Wertpapieren gehören könnten, sind ideale Datensätze für die Verwendung von robuster Skalierung und TANH-Aktivierung. Dies ist auf die Fähigkeit zurückzuführen, Datensätze mit unterschiedlichen Maßstäben zu verarbeiten.

Die Implementierung in MQL5 ist so nahtlos, wie wir oben mit den 3 Aktivierungsfunktionen für die Merkmalsskalierung sagen. Der Vektor-Datentyp verfügt über eingebaute Aktivierungs- und Ableitungsfunktionen, die Ergebnisse an jeden Vektor ausgeben, der auch als Eingabe dient. Dies wird hier bzw. hier beschrieben, wie oben bereits mitgeteilt.

Der robuste Skalierungsalgorithmus ist in einer normalizierten Klasse in MQL5 wie folgt implementiert:

//+------------------------------------------------------------------+
//| Function to apply Robust-Scaling
//+------------------------------------------------------------------+
void Cnormalize::RobustScaling(vector &Data)
{  vector _copy;
   _copy.Copy(Data);
   if(_copy.Percentile(75) - _copy.Percentile(25) > 0.0)
   {  for (int i = 0; i < int(Data.Size()); i++)
      {  Data[i] = (_copy[i] - _copy.Median()) / (_copy.Percentile(75) - _copy.Percentile(25));
      }
   }
}

Wie beim obigen Skalierungsalgorithmus für Merkmale wird auch hier der Interquartilsbereich auf Nulldurchgänge geprüft. Auch hier handelt es sich um einen einfachen Algorithmus, und zwar aus den oben genannten Gründen der Effizienz.

Standard Score

Der Standard-Score, der wahrscheinlich häufiger als der Z-Score verwendet wird, ist wohl der beliebteste Normalisierungsalgorithmus. In der Batch-Normalisierung von Wikipedia Wikipedia ist dies die einzige verwendete Normalisierungsfunktion. Dabei wird eine Klasse oder ein Vektor von Daten in Werte umgewandelt, deren Mittelwert 0 und deren Standardabweichung 1 ist. Dies unterscheidet sich deutlich von den Fällen der Merkmalsskalierung und der robusten Skalierung, die wir oben betrachtet haben, wo der Bereich der Ausgabedaten im Mittelpunkt stand. Die Gleichung lautet wie folgt:

Wobei:

• Z ist der normierte Wert
• μ ist der Mittelwert
• σ ist die Standardabweichung

Aus dieser Gleichung geht also hervor, dass die Ausgabe einen ungebundenen Bereich hat, sodass die möglichen Ausgaben von minus unendlich bis plus unendlich reichen können. Dies sollte ein Warnsignal sein, da explodierende Gradienten schnell zu einem Problem werden können, insbesondere wenn die Aktivierungsfunktionen, die dabei verwendet werden, auch ungebundene Ausgänge haben. Allerdings zentriert es seine Ausgänge um Null, und das ist gut für die Stabilisierung des Trainingsprozesses für Netze, die Gradientenabstieg verwenden. Außerdem ist es bei normalverteilten Daten sehr effektiv, da es sicherstellt, dass die Eingabedatenpunkte gleichmäßig zum Lernprozess beitragen.

Sie hat aber auch Nachteile, vor allem die Empfindlichkeit gegenüber Ausreißern, die Annahme einer Gaußschen Verteilung der Daten und, wie bereits erwähnt, eine ungebundene Ausgabe. Die Implementierung dieses Standard-Scores in MQL5 kann wie folgt erreicht werden:

//+------------------------------------------------------------------+
//| Function to apply Standard-Score
//+------------------------------------------------------------------+
void Cnormalize::StandardScore(vector &Data)
{  vector _copy;
   _copy.Copy(Data);
   if(_copy.Std() != 0.0)
   {  for (int i = 0; i < int(Data.Size()); i++)
      {  Data[i] = (_copy[i] - _copy.Mean()) / _copy.Std();
      }
   }
}

Interessanterweise ist dies noch kein Standardmerkmal bei den MQL5-Funktionen. Um bei all diesen drei Normalisierungsfunktionen eine Nullteilung zu vermeiden, ist es üblich, statt auf einen Nenner von Null zu achten, am Ende einen kleinen, von Null verschiedenen Doppelwert hinzuzufügen, der oft als Epsilon bezeichnet wird. Diese Praxis kann jedoch bei der Skalierung von Merkmalen oder bei der robusten Skalierung zu sehr großen normalisierten Werten führen, wenn der Nenner eigentlich Null sein sollte.

Normierungstransformer

Sobald die Eingabedaten der Ebene entweder durch Merkmalsskalierung, robuste Skalierung oder die Standardbewertung normalisiert wurden, werden die Ergebnisse dieser Normalisierung in den Batch-Normalisierungstransformer eingegeben. Es handelt sich auch um eine relativ einfache Funktion, die durch die folgende Gleichung definiert ist:

Wobei:

• y steht für den Output im Vektor bei Index i
• x ist der zuvor normalisierte Datenpunkt bei Index i
• Gamma und Beta sind optimierbare Gleitkomma-Parameter

Dies zu kodieren erfordert auch nicht allzu viel, da wir dies in MQL5 wie folgt durchführen können:

//+------------------------------------------------------------------+
//| Batch Normalizing Transform
//+------------------------------------------------------------------+
void Cnormalize::Transform(Enormalize Type, vector &Output, vector &BatchTransform, vector &Beta, vector &Gamma)
{  if(Type != NORMALIZE_NONE)
   {  if(Type == NORMALIZE_STANDARD)
      {  StandardScore(Output);
      }
      else if(Type == NORMALIZE_FEATURE)
      {  FeatureScaling(Output);
      }
      else if(Type == NORMALIZE_ROBUST)
      {  RobustScaling(Output);
      }
      //Transformer
      BatchTransform.Init(Output.Size());
      BatchTransform.Fill(0.0);
      for(int i = 0; i < int(Output.Size()); i++)
      {  BatchTransform[i] = (Gamma[i] * Output[i]) + Beta[i];
      }
   }
}

Es gibt im Wesentlichen fünf Argumente dafür, den Normalisierungsausgang durch diesen Transformer zu führen. Erstens wird die Repräsentativität der ursprünglichen, nicht normalisierten Daten durch die Einführung von Flexibilität und Rekalibrierung wiederhergestellt. Flexibilität, da die Ausgangsdaten nach der Umwandlung nicht unbedingt in einem optimalen Zustand sind, um das Lernen des Netzes zu erleichtern. Bei der Standard-Score-Normalisierung zum Beispiel haben die Ausgabedaten jedes Vektors immer einen Mittelwert von 0 und eine Standardabweichung von 1. Dieser und andere ähnliche Fälle können zu extrem sein, als dass das Netz effektiv trainieren könnte. Deshalb kann die Einführung der lernbaren/optimierbaren Parameter Beta und Gamma dazu beitragen, diese Datensätze für das Training in eine optimale Form zu bringen.

Zweitens kann dieser Normalisierungstransformer in Fällen, in denen die anfängliche Normalisierungsfunktion potenziell ungebundene Ausgaben hat, wie z. B. bei der Standardbewertung, dazu beitragen, verschwindende und explodierende Gradienten zu vermeiden. Dies würde durch eine Feinabstimmung von Beta und Gamma erreicht werden. Drittens wird argumentiert, dass der Transformer die Varianz für effektives Lernen durch Varianzskalierung aufrechterhält. Der Gamma-Parameter kann die Varianz der normalisierten Ausgaben anpassen, da er ein direktes Vielfaches ist. Durch die Möglichkeit, diese Varianz anzupassen, kann der Lernprozess genau auf die Architektur des Netzes abgestimmt werden.

Darüber hinaus kann der Transformer die Lerndynamik eines Netzes verbessern, indem er das Netz an die Daten anpasst, was häufig zu einer Verbesserung der Konvergenz führt. Die optimierbaren Beta- und Gamma-Parameter leiten diesen Prozess wiederum so, dass die Daten so skaliert werden, dass die Einstellungen für die Anzahl und Größe der Netzwerkschichten besser genutzt werden, was letztendlich dazu führt, dass weniger Trainingsepochen erforderlich sind, um ideale Ergebnisse zu erzielen. Schließlich wird argumentiert, dass eine Regularisierung durch Skalierung und Verschiebung der Ausgaben der normalisierten Daten wie eine Dropout-Regularisierung funktioniert. Die Regularisierung soll das Netzwerk dazu bringen, mehr von den zugrundeliegenden Mustern in einem Datensatz zu lernen und weniger vom Rauschen, sodass die Beta- und Gamma-Parameter, die Vektorparameter sind, für jede Schicht eindeutig sind. Diese Anpassung auf Parameterbasis bewirkt nicht nur eine Regularisierung des Netzes, auch die in der Einleitung erwähnte Kovariatenverschiebung kann dank der parameterspezifischen Wirkung von Beta und Gamma besser realisiert werden.

Ergebnisse des Strategietests

Zum Testen verwenden wir das Symbol EURJPY auf dem täglichen Zeitrahmen für das Jahr 2023. Die Standard-Score-Normalisierung, die mit ungebundenen Daten arbeitet, hat nicht notwendigerweise eine Freier-Aktivierungsfunktion. Man kann die gebundenen Aktivierungsfunktionen verwenden, die wir in diesem Artikel erwähnt haben, aber das Testen bleibt dem Leser überlassen. Für unsere Zwecke testen wir nur die robuste Skalierungsnormalisierung und die Merkmalsskalierungsnormalisierung. Wir haben diese mit Soft-Sign- bzw. Sigmoid-Aktivierung gepaart.

Bei der Skalierung der Merkmale kamen wir zu folgenden Ergebnissen:

Für eine robuste Skalierung hatten wir:

Als Kontrolle führen wir Tests mit dem Expert Advisor mit identischen Einstellungen, aber ohne Normalisierung durch. Nachstehend finden Sie unsere Ergebnisse:

Schlussfolgerung

Zusammenfassend lässt sich also sagen, dass die Batch-Normalisierung parameterintensiv und daher rechenintensiv ist. Bei der Auswahl der zu verwendenden Normalisierungsalgorithmen ist besondere Vorsicht geboten. Obwohl der Standard-Score sehr beliebt und verbreitet ist, hat er ungebundene Ausgaben, die zu sehr großen Gradienten führen können, die die Konvergenz behindern und den gesamten Trainingsprozess verlangsamen. Wenn jedoch alternative Normalisierungsalgorithmen mit begrenzten Ausgängen wie Feature-Skalierung oder robuste Skalierung verwendet werden und diese mit ihren jeweiligen Aktivierungsfunktionen gepaart werden, die ähnliche begrenzte Ausgänge haben, dann kann der Trainingsprozess beschleunigt werden. Die Geschwindigkeit ist hier leider ein entscheidender Faktor, denn wie bereits erwähnt, umfasst die Stapelnormalisierung viele Parameter und ist sehr rechenintensiv, sodass bei der Paarung von Normalisierungsalgorithmen und Aktivierungsfunktionen sowie bei der Wahl der optimalen Netzschichten und Netzgrößen besondere Sorgfalt geboten ist.