Neuronale Netze im Handel: Heterogenitätsgestütztes Metaparameterlernen (Schlüsselkomponenten)
Einleitung
Im vorherigen Artikel haben wir uns mit dem HimNet-Framework befasst – einem praktischen Werkzeug, das Daten nicht nur analysiert, sondern auch deren Kontext versteht. Im Handel bedeutet dies, dass das Modell zwischen Phasen hoher Liquidität und Phasen geringer Aktivität unterscheidet. HimNet passt sich automatisch an diese Veränderungen an.
Die Architektur von HimNet ist einfach und logisch aufgebaut: Als Eingabe dienen Zeitreihensegmente der Länge T von N Standorten. Zunächst generiert das Modell zwei Arten von trainierbaren Embeddings – zeitliche und räumliche. Zeitliche Embeddings (Tageszeit, Wochentag) erfassen Zyklen und Marktregime – morgendliche Spitzen bei Börsenöffnung, Rückgänge im Tagesverlauf und nächtliche Flauten. Räumliche Embeddings – ein separater Vektor für jeden Standort oder jedes Tickersymbol – kodieren das Profil der Zeitreihe. Alle diese Vektoren werden in Wörterbüchern gespeichert und im Laufe des Trainingsprozesses verfeinert. Sie dienen als Abfragen an Metaparameterpools und ermöglichen es dem Modell, je nach Marktkontext unterschiedliche Gewichte auszuwählen, wie sie durch das Verhalten der Graphfaltung vorgegeben werden. Diese Generierung im laufenden Betrieb bietet die Flexibilität des Metalernens, ohne dabei große Mengen an Speicher und Rechenressourcen zu beanspruchen.
Das Herzstück von HimNet bilden graphrekurrente Blöcke (GCRU), die um eine Tschebyscheff-Basis erweitert sind. Dieser architektonische Ansatz verleiht dem Modell sowohl Tiefe als auch Praxisnähe. GCRU interpretiert das Netzwerk der Handelsplätze als Graph: Jeder Knoten steht für ein Tickersymbol oder einen Handelsplatz, und die Kanten spiegeln Korrelationen, Cross-Spreads oder empirische Zusammenhänge wider. Tschebyscheff-Polynome bieten eine kompakte Implementierung der K-Hop-Aggregation: Das Modell berücksichtigt den Einfluss von Nachbarn in einer Entfernung von bis zu K Kanten, kommt dabei jedoch ohne rechenintensive spektrale Diagonalisierung aus – schnell, lokal und numerisch stabil. Einfach ausgedrückt: Anstatt das gesamte Spektrum des Graphen zu berechnen, erstellen die Autoren des Frameworks Schritt für Schritt eine Reihe von Matrizen, die den Einfluss unmittelbarer Nachbarn, deren Nachbarn und so weiter erfassen, und kombinieren diese Effekte anschließend unter Berücksichtigung des Kontexts.
Die Kodierung in HimNet erfolgt über zwei parallele Informationsströme. Der erste (räumlicher Encoder) analysiert das Profil der Handelsplätze: Orderbuchtiefe, typisches Handelsvolumen und historische Reaktionen auf Nachrichten. Der zweite (zeitlicher Encoder) erfasst zeitliche Regime: die Marktöffnung, den Nachrichtenfluss, die nächtliche Ruhephase oder Veröffentlichungsphasen. Beide Encoder erzeugen verborgene Repräsentationen, die zu einem einheitlichen latenten Tensor zusammengefasst werden. Hierbei handelt es sich nicht um eine mechanische Summierung, sondern um eine sorgfältige Verflechtung von Bedeutungen: Die Zeit bestimmt den Grad der Empfindlichkeit, während der Raum die Art der Aggregation vorgibt. Dadurch erhalten wir ein einheitliches Bild der aktuellen Marktlage.
Der Decoder nimmt diese einheitliche Repräsentation und projiziert sie in ein raumzeitliches Embedding, das als Abfrage an den ST-Metaparameterpool dient. Der Pool gibt einen Satz von Parametern zurück, die für diese bestimmte Kombination aus Ort und Zeit spezifisch sind; diese Parameter bilden direkt die Gewichte des GCRU-Blocks im Decoder. Mit anderen Worten: Die Autoren des Frameworks rekonfigurieren zur Laufzeit die Struktur der rekurrenten Verarbeitung für das aktuelle Marktregime: ein Satz von Gewichten und Empfindlichkeiten zur Handelseröffnung und ein anderer während der Nacht. Der Decoder erstellt dann iterativ, Schritt für Schritt, Prognosen für einen festgelegten Prognosehorizont.
Aus algebraischer und numerischer Sicht berechnen wir für jeden Zustand K Tschebyscheff-Stufen, konkatenieren die Ergebnisse und leiten sie durch eine Matrix, die der Metaparameterpool anhand der Embedding-Abfrage erzeugt. Die Gradienten fließen sowohl in die Parameter des Metaparameterpools als auch in die Embeddings zurück. Daher lernt das Modell nicht nur, Vorhersagen zu treffen, sondern auch nützliche raumzeitliche Kontexte zu erkennen. In der Praxis bietet dies einen Anpassungsmechanismus, der es dem Modell ermöglicht, die Betriebsart auszuwählen, die in diesem bestimmten Moment am relevantesten ist.
Im realen Handel führt dies zu greifbaren Vorteilen. Zur Eröffnung der Haupthandelssitzung verstärkt HimNet automatisch seine Parameter für eine schnelle Reaktion auf Spitzen im Handelsvolumen, wodurch die Slippage reduziert wird. In Zeiten geringer Liquidität liefert das Modell konservativere Prognosen und reduziert Fehleinstiege, wodurch es vor einmaligen Ausschlägen schützt, die durch einzelne Handelsgeschäfte verursacht werden. Das bedeutet eine angemessene Ausweitung des Spreads, wenn die Liquidität versiegt, sowie eine strengere Filterung scheinbarer Kurslücken. Im Falle eines plötzlichen Schocks wechselt das ST-Modell in einen defensiven Modus, wodurch die Robustheit der Prognosen erhöht und das Risiko von Marktfallen verringert wird.
Technisch gesehen bleibt die Architektur pragmatisch und für den industriellen Einsatz geeignet: Die Metaparameterpools sind kompakt und führen nicht zu einem explosionsartigen Anstieg des Speicher- und Rechenbedarfs, während Berechnungen mit Tschebyscheff-Potenzen auf der GPU problemlos skalierbar sind.
Hyperparameter stellen im Wesentlichen einen sinnvollen Kompromiss zwischen Modellflexibilität und Reaktionsgeschwindigkeit dar. Sie werden durch Validierung anhand repräsentativer Marktszenarien ausgewählt. Die Interpretierbarkeit ist hier nicht bloßes Beiwerk: Anhand der Aktivierung einzelner Pool-Kandidaten und anhand von Heatmaps adaptiver Graphen können wir schnell erkennen, welche Regime das Modell derzeit identifiziert, warum bestimmte Vorhersagen getroffen wurden und welche Ausführungsregeln angewendet werden sollten.
In der Praxis entsteht daraus ein konkretes Steuerungsinstrument – von automatischen Auslösern für den Wechsel in einen konservativen Modus bis hin zu transparenten Berichten für das Risikomanagement –, das HimNet sowohl für Händler als auch für Ingenieure steuerbar und leicht verständlich macht.
Somit vereint HimNet leistungsstarke lokale Aggregation, adaptives Metalernen und eine praxisorientierte technische Umsetzung. Dies ist nicht nur ein verbessertes Prognosemodell – es ist ein Werkzeug, das Marktregime versteht und sein Verhalten entsprechend anpassen kann, dabei aber für Händler und Risikomanager weiterhin vorhersehbar und steuerbar bleibt.
Nachfolgend ist die vom Autor erstellte Darstellung des HimNet-Frameworks abgebildet.

Der praktische Teil des ersten Artikels hat bestätigt, dass das Konzept in einer realen technischen Umgebung funktioniert. Wir haben die rechenintensiven Operationen zur Berechnung von Tschebyscheff-Polynomen und zur Rückpropagation des Fehlers auf die GPU ausgelagert, indem wir die OpenCL-Kernel ChebStep und ChebStepGrad implementiert haben.
Im Hauptprogramm wurde das Objekt CChebPolinom implementiert, das die Kernel kapselt und eine einheitliche Schnittstelle für die Inferenz und die Gradientenberechnung bereitstellt. Das Ergebnis war eine hybride Pipeline: schnelles Training und zuverlässige Inferenz.
In diesem Artikel setzen wir unsere Arbeit zur Umsetzung der Ansätze des HimNet-Frameworks mithilfe von MQL5 fort.
Graphfaltungsobjekt
Im nächsten Schritt unserer Arbeit wenden wir uns der Erstellung eines Objekts für die Graphfaltung zu, das die Tschebyscheff-Basis als rechnerische Grundlage für die K-Hop-Aggregation verwendet. Dieses Modul spielt eine zentrale Rolle bei der Ausführung: Es nimmt die vorbereiteten Merkmalsfenster entgegen, fordert von CChebPolinom die vorgefertigten Matrizen 𝑇𝑘 an und erstellt auf der Grundlage der aktuellen Metaparameter Ausgabesequenzen, die für die weitere Verarbeitung im Modell bereit sind. Es ist wichtig, dass das Modul gleichzeitig flexibel, schnell und vorhersehbar ist: flexibel durch die Unterstützung verschiedener Metaparametrisierungsmodi sowie schnell und vorhersehbar durch strenge Speicherverwaltung und numerische Prüfungen.
Die Architektur des neuen CNeuronHimNetGrapConv-Objekts ist als pragmatischer und modularer Adapter zwischen zeitlichen Merkmalsfenstern und Graphfaltung konzipiert – sie vereint Datenaufbereitung, Aufrufe von Matrixoperationen und die Einbindung von OpenCL-Kerneln, ohne die übergeordnete Logik des Modells mit Implementierungsdetails zu überfrachten.
class CNeuronHimNetGrapConv : public CNeuronTransposeRCDOCL { protected: CNeuronBaseOCL cX_G; public: CNeuronHimNetGrapConv(void) {}; ~CNeuronHimNetGrapConv(void) {}; //--- virtual bool Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint count, uint window, uint cheb_k, ENUM_OPTIMIZATION optimization_type, uint batch) override; //--- virtual bool FeedForward(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support); virtual bool calcInputGradients(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support); //--- virtual bool Load(const int file_handle) override; //--- virtual int Type(void) const { return defNeuronHimNetGrapConv; } virtual void SetOpenCL(COpenCLMy *obj); virtual uint GetCount(void) override const { return iWindow; } virtual uint GetWindow(void) override const { return GetDimension(); } virtual uint GetChebK(void) const { return iCount; } };
Innerhalb der Klasse befindet sich ein kompaktes, aber unverzichtbares Hilfsobjekt, `cX_G`. Es dient als Arbeitspuffer und gewährleistet einen schnellen Datenaustausch zwischen den verschiedenen Rechenstufen. Da das Objekt statisch deklariert ist, können der Konstruktor und der Destruktor der Klasse leer bleiben – die Initialisierung und die Speicherbereinigung erfolgen einmalig über den gesamten Lebenszyklus hinweg, ohne unnötigen Aufwand beim Erstellen oder Löschen von Instanzen.
In der Methode „Init“ wird eine neue Instanz der Klasse initialisiert. In dieser Methode rufen wir zunächst die gleichnamige Methode der Basisklasse auf, die die allgemeinen Schnittstellen eines Neurons definiert.
bool CNeuronHimNetGrapConv::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint count, uint window, uint cheb_k, ENUM_OPTIMIZATION optimization_type, uint batch) { if(!CNeuronTransposeRCDOCL::Init(numOutputs, myIndex, open_cl, cheb_k, count, window, optimization_type, batch)) return false; if(!cX_G.Init(0, 0, OpenCL, Neurons(), optimization, iBatch)) return false; //--- return true; }
Als Nächstes wird der Hilfspuffer cX_G initialisiert; er dient als Arbeitsbereich für die bereits konkatenierten Daten und speichert das Ergebnis der Matrixmultiplikation. Sollte einer dieser Vorgänge fehlschlagen, gibt Init false zurück, und das Objekt verbleibt in einem sicheren Zustand.
Die Methode FeedForward für den Vorwärtsdurchlauf fungiert als Dirigent. Zunächst prüft die Methode sorgfältig die Kompatibilität der als Parameter übergebenen Objekte: Die übergebenen Objekte NeuronOCL und Support müssen vorhanden sein. Außerdem muss Support die erwarteten Werte für Dimension und Steps aufweisen, die mit den Moduleinstellungen übereinstimmen.
bool CNeuronHimNetGrapConv::FeedForward(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support) { if(!NeuronOCL || !Support) return false; if(Support.GetDimension() != iWindow || Support.GetSteps() != iCount) return false; if(NeuronOCL.Neurons() != (Neurons() / iCount)) return false;
Außerdem wird überprüft, ob die Anzahl der Neuronen im Quelldatenobjekt mit der erwarteten Struktur übereinstimmt. Diese Überprüfungen sind nicht nur reine Formalität; sie stellen sicher, dass die nachfolgenden Matrixoperationen nicht zu einer stillen Katastrophe auf der GPU werden.
Als Nächstes folgt die zentrale Matrixmultiplikation, bei der die resultierenden Tschebyscheff-Polynome mit dem Tensor der zu analysierenden Zeitreihe multipliziert werden. Das Ergebnis der Operation wird in unserem cX_G-Puffer gespeichert.
if(!MatMul(Support.getOutput(), NeuronOCL.getOutput(), cX_G.getOutput(), iWindow, iWindow, GetDimension(), iCount, false)) return false;
Im Wesentlichen handelt es sich hierbei genau um jene Operation, die die Konkatenation X_G der transformierten Darstellungen T0 X, T1 X, …, Tk X bildet. Um es mit einer Analogie aus dem Handel zu verdeutlichen: Support ist eine Karte der Beziehungen zwischen einzelnen Reihen (Tschebyscheff-Polynome), NeuronOCL ist ein Merkmalsfenster einer multimodalen Zeitreihe und cX_G ist die bereits analysierte Version der Rohdaten, bei der für jede einzelne Sequenz der Einfluss der Nachbarn berücksichtigt wird. Genau diese angepasste Matrix müssen wir weitergeben.
Beachten Sie jedoch, dass das Ergebnis der Matrixmultiplikation eine Folge mehrerer Sätze angepasster Quelldaten mit unterschiedlichem Detaillierungsgrad {K-hop, N, C} ist. Und dies ist nicht die Datendarstellung, die an der Ausgabe des Objekts erwartet wird. Daher übergeben wir als letzten Schritt der Methode für den Vorwärtsdurchlauf cX_G an die gleichnamige Methode in der Basisklasse, die den Tensor in die erwartete Darstellung transponiert. Durch diese Abfolge wird der Code modular aufgebaut, was das Testen und die Optimierung vereinfacht.
Sollte in einer beliebigen Phase ein Fehler auftreten, gibt die Methode ordnungsgemäß false zurück, ohne Nebenwirkungen zu hinterlassen.
Sobald der Vorwärtsdurchlauf die Ausgabe der Schicht berechnet hat, folgt der nächste, ebenso wichtige Schritt: die Weitergabe der Fehlergradienten. Genau hier wird die Fähigkeit der gesamten Architektur geschaffen, aus historischen Daten zu lernen und sich an reale Marktszenarien anzupassen.
Die Methode calcInputGradients beginnt mit einem Block zur Prüfung der übergebenen Parameter: Dabei wird geprüft, ob die Zeiger auf die vorherige Schicht und auf die Tschebyscheff-Polynommatrix gültig sind. Diese Überprüfung dient als eine Art Sicherheitsnetz, um fehlerhafte Berechnungen zu verhindern, falls die Modellstruktur nicht mehr synchron ist.
bool CNeuronHimNetGrapConv::calcInputGradients(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support) { if(!NeuronOCL || !Support) return false; if(Support.GetDimension() != iWindow || Support.GetSteps() != iCount) return false; if(NeuronOCL.Neurons() != (Neurons() / iCount)) return false;
Anschließend überprüft die Methode die Dimensionen: Die Anzahl der Schritte (K-Hop) und die Fenstergröße müssen den Erwartungen entsprechen. Dieser Schritt ist wichtig, da Graphfaltungen empfindlich auf nicht übereinstimmende Dimensionen reagieren – ein Fehler an dieser Stelle kann eine Kettenreaktion falscher Gradienten auslösen und den gesamten Trainingsprozess zum Scheitern bringen.
Wenn die Überprüfung erfolgreich ist, fahren wir direkt mit dem Verfahren zur Verteilung des Fehlergradienten fort. Zunächst transponieren wir die aus der nachfolgenden Schicht des Modells erhaltenen Gradienten in die Darstellung unserer Faltungsausgaben.
if(!CNeuronTransposeRCDOCL::calcInputGradients(cX_G.AsObject())) return false; if(!MatMulGrad(Support.getOutput(), Support.getGradient(), NeuronOCL.getOutput(), NeuronOCL.getGradient(), cX_G.getGradient(), iWindow, iWindow, GetDimension(), iCount, false)) return false; //--- return true; }
Im letzten Schritt werden die Fehlergradienten auf die Eingabedaten und die Tschebyscheff-Polynome verteilt. In diesem Schritt verteilt die Methode die kumulierte Wirkung des Fehlers effektiv auf dieselben Kanäle, über die die Informationen während des Vorwärtsdurchlaufs weitergeleitet wurden, nun jedoch in umgekehrter Richtung. Wir verwenden dazu die von der Basisklasse geerbte Methode MatMulGrad. Dadurch erhalten wir zwei Arten von Gradienten. Zum einen ist dies der Gradient in Bezug auf die Eingabedaten der Schicht selbst, der anschließend zur Anpassung der Gewichte der vorgelagerten Schichten verwendet wird. Der zweite ist der Gradient bezüglich der Koeffizienten der Tschebyscheff-Entwicklung, der es dem Framework ermöglicht, die graphstrukturierte Darstellung anzupassen, falls sich die Marktabhängigkeiten im Laufe der Zeit verändern.
In dieser Phase findet also die abschließende Auswertung statt: Das System ermittelt, welche Verbindungen sich als nützlich erwiesen haben und welche überflüssig waren, und legt damit den Grundstein für den nächsten Optimierungszyklus.
Aus praktischer Sicht ist CNeuronHimNetGrapConv der Punkt, an dem das Modell das Signal für den Händler hörbar macht. Es wandelt Fenster mit rohen Kursdaten in lokal angepasste Signale um. Die Klassenarchitektur ist speziell darauf ausgelegt, sicherzustellen, dass diese Transformationen schnell, reproduzierbar und nachvollziehbar sind. Der vollständige Code für diese Klasse und alle ihre Methoden ist im Anhang enthalten.
Rekurrenter Block
Nachdem wir nun die interne Struktur des grundlegenden Graphfaltungsblocks auf Basis von Tschebyscheff-Polynomen untersucht und gesehen haben, wie die Ströme der Eingabedaten und Fehlergradienten innerhalb dieses relativ kompakten Elements verteilt sind, ist es an der Zeit, eine Ebene höher zu gehen – zu dem Knoten, der die lokale Graphverarbeitung mit der Dynamik der verborgenen Zustände verknüpft. Hier entsteht das eigentliche Gedächtnis des Modells, und genau diese Komponente sorgt dafür, dass Informationen zwischen den Zeitschritten nicht verloren gehen, sondern nahtlos in die Graphstruktur eingebunden werden. Gemeint ist die Klasse CNeuronHimNetGCRU – die zentrale Komponente, die als eine Art Signalverteiler zwischen den zeitlichen und räumlichen Komponenten des Modells fungiert. Die Struktur des Objekts ist unten dargestellt.
class CNeuronHimNetGCRU : public CNeuronBaseOCL { protected: CNeuronBaseOCL cInpAndHidden; CNeuronHimNetGrapConv cZ_R; CNeuronConvOCL cZ_R_emb; CNeuronBaseOCL cZe_Re; CNeuronBaseOCL cZ; CNeuronBaseOCL cR; CNeuronBaseOCL cCandidate; CNeuronHimNetGrapConv cHC; CNeuronConvOCL cHC_emb; CNeuronBaseOCL cHCe; public: CNeuronHimNetGCRU(void) {}; ~CNeuronHimNetGCRU(void) {}; //--- virtual bool Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint units, uint window, uint window_out, uint cheb_k, uint embed_dim, ENUM_OPTIMIZATION optimization_type, uint batch); //--- virtual bool feedForward(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support, CNeuronBaseOCL *Embedding); virtual bool calcInputGradients(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support, CNeuronBaseOCL *Embedding); virtual bool updateInputWeights(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support, CNeuronBaseOCL *Embedding); //--- virtual int Type(void) const { return defNeuronHimNetGCRU; } //--- methods for working with files virtual bool Save(int const file_handle); virtual bool Load(int const file_handle); //--- virtual bool WeightsUpdate(CNeuronBaseOCL *source, float tau) override; virtual void SetOpenCL(COpenCLMy *obj) override; virtual void SetActivationFunction(ENUM_ACTIVATION value) override { }; };
In diesem Fall reicht es nicht mehr aus, lediglich eine Faltung über die Nachbarn des Knotens anzuwenden oder die Daten durch eine rekurrente Zelle zu leiten. Wie wir wissen, verhalten sich Finanzmärkte selten linear: Währungspaare bilden miteinander verbundene Cluster, Aktienkurse bewegen sich innerhalb einer Branche gemeinsam, und Rohstoffe bewegen sich oft parallel zu den Währungen der Exportländer. Deshalb reicht ein zeitliches Modell allein nicht aus – es benötigt eine Verbindungskarte, und die Graphfaltung liefert diese Karte. Für sich genommen ist sie jedoch statisch. Es gilt, im jeweiligen Moment zu entscheiden, ob das Signal für EURUSD verstärkt oder gedämpft werden soll, wenn sich die benachbarten Paare GBPUSD und EURGBP in entgegengesetzte Richtungen bewegen. Es ist eine Steuerungslogik erforderlich. Genau das setzt diese Klasse um.
Dieses Modul enthält nicht einfach den Entwicklern zeitlicher Modelle vertrauten GRU-Mechanismus, sondern eine an eine Graphstruktur angepasste Version davon. Während wir es bei der vorherigen Klasse für die Graphfaltung mit einer relativ kompakten Menge von Elementen zu tun hatten, sehen wir uns hier mit einer weitaus komplexeren Konfiguration konfrontiert. Die Liste der internen Komponenten ist beeindruckend, doch jede einzelne davon erfüllt eine genau festgelegte Aufgabe im Gesamtbetrieb. Wir werden ihre Aufgaben nach und nach erläutern, während wir die Methoden für dieses Objekt entwickeln, um den Leser nicht schon im Voraus mit Details zu überfordern. Es ist wichtig zu beachten, dass alle diese internen Objekte statisch deklariert sind, was die Verwaltung der Klasse vereinfacht und die Erstellung umständlicher Konstruktoren und Destruktoren überflüssig macht – sie bleiben leer, wie gut geölte Türen, die nicht knarren und bei jeder Ausführung des Algorithmus keinen zusätzlichen Aufwand erfordern.
Wenn wir von der allgemeinen Struktur der Klasse zu den konkreten Details ihrer Funktionsweise übergehen, kommen wir natürlich zur Initialisierungsmethode Init. Hier werden die Schachfiguren aufgestellt – hier werden alle internen Komponenten erstellt und vorbereitet, die später die Dynamik der Berechnungen bestimmen werden. Die Init-Methode ist wie der Taktstock eines Dirigenten hinter den Kulissen: Während der externe Code sie lediglich aufruft, vollzieht sich intern eine komplexe, aber gut organisierte Abfolge von Schritten zur Vorbereitung jedes Moduls.
bool CNeuronHimNetGCRU::Init(uint numOutputs, uint myIndex, COpenCLMy *open_cl, uint units, uint window, uint window_out, uint cheb_k, uint embed_dim, ENUM_OPTIMIZATION optimization_type, uint batch) { if(!CNeuronBaseOCL::Init(numOutputs, myIndex, open_cl, units * window_out, optimization_type, batch)) return false; activation = None;
Alles beginnt mit der Initialisierung der Basisklasse. Hier werden alle geerbten Basis-Schnittstellen der neuronalen Schicht erstellt. Bitte beachten Sie, dass die Anzahl der Neuronen als Produkt aus der Anzahl der Elemente in der Sequenz und der Größe des Merkmalsfensters am Ausgang des Objekts definiert ist – wodurch im Voraus Rechenkapazität für den gesamten zeitlichen Kontext reserviert wird.
Unmittelbar danach wird die Aktivierungsfunktion auf null zurückgesetzt. Dies geschieht bewusst: In dieser Phase ist es wichtig, Neutralität zu wahren, damit die nachfolgenden Schichten eine leere Leinwand für ihre spezifische Aktivierung erhalten.
Anschließend beginnt die Initialisierungssequenz für die internen Komponenten. Die erste Komponente – cInpAndHidden – dient als eine Art Schnittstelle zwischen den Eingabedaten und dem verborgenen Zustand. Die Dimensionalität ergibt sich aus der Summe der Eingabe- und Ausgabe-Merkmalsfenster, multipliziert mit der Anzahl der Elemente in der Sequenz, wodurch alle für die nachfolgende Verarbeitung erforderlichen Informationen erfasst werden können.
int index = 0; if(!cInpAndHidden.Init(0, index, OpenCL, (window + window_out)*units, optimization, iBatch)) return false; cInpAndHidden.SetActivationFunction(None);
Als Nächstes kommt cZ_R ins Spiel; es ist für die Bildung der kombinierten Matrizen Z und R zuständig – der zentralen GRU-Gates. An dieser Stelle kommt der Mechanismus zur Arbeit mit Graphstrukturen ins Spiel: Die Methode berücksichtigt die Tensorform der zu analysierenden Daten sowie die Anzahl der Terme im Tschebyscheff-Polynom, was sich direkt auf die Tiefe der Graphapproximation auswirkt.
index++; if(!cZ_R.Init(0, index, OpenCL, units, window + window_out, cheb_k, optimization, iBatch)) return false; cZ_R.SetActivationFunction(None);
Als Nächstes folgt in der Initialisierungskette das Objekt cZ_R_emb – eine Art Brücke zwischen dem Embedding und der Faltungsdynamik. Seine Aufgabe besteht darin, eine Matrix mit Faltungsparametern zu generieren – nicht mechanisch, sondern auf der Grundlage des resultierenden Embeddings –, damit diese Parameter anschließend in der Rechenpipeline angewendet werden können.
Es handelt sich hierbei nicht lediglich um eine Hilfsvariable, sondern um einen zentralen Vermittler: Hier findet die intelligente Neuordnung der Verbindungen zwischen einzelnen Reihen statt, wodurch diese von einer Ansammlung disparater Beobachtungen in eine schlüssige Darstellung der Zusammenhänge umgewandelt werden. Wenn wir eine Parallele zu den Finanzmärkten ziehen, ähnelt dieser Schritt der Arbeit eines erfahrenen Analysten, der Rohdaten zur Handelsaktivität in ein Format umwandelt, in dem sich Trends, Korrelationen und zeitverzögerte Abhängigkeiten abzeichnen, wodurch sich zukünftige Kursbewegungen prognostizieren lassen.
index++; if(!cZ_R_emb.Init(0, index, OpenCL, embed_dim, embed_dim, 2 * cheb_k * (window + window_out) * window_out, 1, units, optimization, iBatch)) return false; cZ_R_emb.SetActivationFunction(None); index++; if(!cZe_Re.Init(0, index, OpenCL, 2 * window_out * units, optimization, iBatch)) return false; cZe_Re.SetActivationFunction(None); index++; if(!cZ.Init(0, index, OpenCL, window_out * units, optimization, iBatch)) return false; cZ.SetActivationFunction(None); index++; if(!cR.Init(0, index, OpenCL, window_out * units, optimization, iBatch)) return false; cR.SetActivationFunction(None);
Anschließend initialisiert die Methode mehrere weniger umfangreiche, aber nicht weniger wichtige Blöcke: cZe_Re, cZ und cR. Diese Module erzeugen die endgültigen Z- und R-Vektoren und ermöglichen eine flexible Steuerung des Vergessens und Aktualisierens von Informationen. Ihre Dimensionalität hängt direkt vom Merkmalsfenster und der Anzahl der Sequenzelemente im Ergebnistensor ab – dies spiegelt im Grunde die Fähigkeit des Modells wider, den aktuellen Marktkontext im Speicher zu behalten.
Als Nächstes wird cCandidate erstellt – eine Komponente, die für die Berechnung des neuen Kandidatenzustands zuständig ist. Die Dimensionalität wird von dem bereits initialisierten cInpAndHidden übernommen, was die enge Beziehung zwischen dem Eingangssignal und dem vorgeschlagenen Modell des verborgenen Zustands unterstreicht.
index++; if(!cCandidate.Init(0, index, OpenCL, cInpAndHidden.Neurons(), optimization, iBatch)) return false; cCandidate.SetActivationFunction(None);
Der zweite große Block – cHC – ist eine weitere Graphfaltung, die auf der Ebene des aktualisierten Zustands arbeitet. Er verfügt über eigene Faltungsparameter, cHC_emb, die auf der Grundlage des erhaltenen Embeddings gebildet werden, jedoch mit anderen Koeffizienten. Das letzte Element ist cHCe, das letztendlich die Darstellung des aktualisierten verborgenen Zustands bildet.
index++; if(!cHC.Init(0, index, OpenCL, units, window + window_out, cheb_k, optimization, iBatch)) return false; cHC.SetActivationFunction(None); index++; if(!cHC_emb.Init(0, index, OpenCL, embed_dim, embed_dim, (window + window_out) * window_out * cheb_k, 1, units, optimization, iBatch)) return false; cHC_emb.SetActivationFunction(None); index++; if(!cHCe.Init(0, index, OpenCL, window_out * units, optimization, iBatch)) return false; cHCe.SetActivationFunction(None); //--- if(!Output.Fill(0)) return false; //--- return true; }
Sobald alle Module initialisiert sind, erfolgt die abschließende Vorbereitung: Der Ergebnispuffer wird auf Null gesetzt. Wir sollten nicht vergessen, dass wir hier mit einem rekurrenten Block arbeiten. Und durch das Leeren des Ergebnispuffers wird sichergestellt, dass das Modell in einem sauberen Zustand startet, der nicht durch frühere Störsignale verunreinigt ist.
All das erscheint nur auf den ersten Blick kompliziert. In der Praxis handelt es sich um eine schlanke Architektur, in der jeder Block seine eigene Rolle spielt: von der vorbereitenden Aufbereitung der Daten bis hin zur Feinabstimmung des Vergessens und der Aktualisierung von Informationen in einer graphbasierten GRU-Struktur. Dies ist für Aufgaben im Bereich der Finanzmärkte von entscheidender Bedeutung: Das Modell muss in der Lage sein, sowohl lokale Kursschwankungen (innerhalb des Zeitfensters) als auch deren globalen Kontext (durch Graphenapproximation) zu berücksichtigen und gleichzeitig flexibel auf neue Ereignisse zu reagieren, ohne dabei die historische Dynamik aus den Augen zu verlieren.
Nachdem wir uns nun den Initialisierungsprozess genauer angesehen haben, ist es an der Zeit, uns mit der Funktionsweise des graphrekurrenten Blocks zu befassen und zu untersuchen, wie die Methode feedForward für den Vorwärtsdurchlauf die Architektur zum Leben erweckt. Zunächst überprüfen wir sorgfältig, ob alle erforderlichen Komponenten auf dem neuesten Stand sind: der Hauptpuffer für die Quelldaten, der Tensor der Tschebyscheff-Polynome und die Embeddings. Fehlt auch nur eine davon, wird der Vorgang nicht gestartet. Das ist so, als würde ein Trader vor dem Eröffnen einer Position alle Indikatoren und Daten prüfen: Ohne den vollständigen Überblick kann man keine Prognose erstellen.
bool CNeuronHimNetGCRU::feedForward(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support, CNeuronBaseOCL *Embedding) { if(!NeuronOCL || !Support || !Embedding) return false; if(!SwapOutputs()) return false;
Anschließend werden die Zeiger auf die Datenpuffer für das aktuelle und das vorherige Ergebnis vertauscht, wodurch ein rekurrenter Speicher entsteht. Dieser Schritt ist wichtig, weil die Vergangenheit die Zukunft beeinflusst – genauso wie die Marktschwankungen von gestern die Erwartungen von heute prägen.
Beachten Sie außerdem, dass wir während des Initialisierungsprozesses die Konfigurationsparameter des Blocks nicht in separaten Variablen gespeichert haben. Das war Absicht. Schließlich sind sie alle bereits in den internen Komponenten hinterlegt. Und wir können sie auslesen.
uint cheb_k = cZ_R.GetChebK(); uint units = cZ_R.GetCount(); uint window_out = Neurons() / units; uint window = cZ_R.GetWindow() - window_out;
Erst wenn die Vorbereitungsarbeiten abgeschlossen sind, gehen wir zur Organisation des Prozesses über. Die Quelldaten und der vorherige Zustand werden im Objekt cInpAndHidden konkateniert und bilden so einen einzigen Informationsstrom. Dieser Datenstrom – eine Kombination aus Nachrichten, Indikatoren und Signalen – ist bereit für die weitere Verarbeitung.
if(!Concat(NeuronOCL.getOutput(), PrevOutput, cInpAndHidden.getOutput(), window, window_out, units)) return false;
Als Nächstes kommt cZ_R ins Spiel, wo mithilfe von Tschebyscheff-Polynomen eine Graphfaltung durchgeführt wird: Benachbarte Knoten beeinflussen sich gegenseitig, doch dieser Einfluss ist auf die K-Hop-Nachbarschaft beschränkt, was eine effiziente Ressourcennutzung und Rechenstabilität gewährleistet.
if(!cZ_R.FeedForward(cInpAndHidden.AsObject(), Support)) return false; if(!cZ_R_emb.FeedForward(Embedding)) return false;
Gleichzeitig generiert cZ_R_emb auf der Grundlage der Embeddings eine Faltungsparametermatrix – ähnlich wie ein Koch einem Gericht Gewürze hinzufügt, um feine Aromen hervorzuheben: Zeitliche und räumliche Merkmale werden sachgerecht aufbereitet, damit sie weiterverwendet werden können.
Die Ergebnisse der Faltung werden multipliziert und durch eine Sigmoid-Aktivierungsfunktion geleitet; anschließend werden sie in die Gates Z und R aufgeteilt. Sie kontrollieren den Informationsfluss und legen fest, was aus der Vergangenheit bewahrt und was aktualisiert werden soll.
if(!MatMul(cZ_R.getOutput(), cZ_R_emb.getOutput(), cZe_Re.getOutput(), 1, (window + window_out)*cheb_k, 2 * window_out, units, true)) return false; if(!Activation(cZe_Re.getOutput(), cZe_Re.getOutput(), SIGMOID)) return false; if(!DeConcat(cZ.getOutput(), cR.getOutput(), cZe_Re.getOutput(), window_out, window_out, units)) return false;
Anschließend wird ein Kandidatenzustand cCandidate gebildet, indem die aktuelle Eingabe und der modifizierte vorherige Zustand kombiniert werden. Dieser Zustand wird in den zweiten Graphfaltungsblock cHC eingespeist, in dem auf ähnliche Weise über cHC_emb neue Parameter erzeugt werden; anschließend wird die Tangens-hyperbolicus-Funktion auf das Ergebnis angewendet, wodurch ein aktualisierter verborgener Zustand entsteht.
if(!ElementMult(cZ.getOutput(), PrevOutput, cZ.getPrevOutput())) return false; if(!Concat(NeuronOCL.getOutput(), cZ.getPrevOutput(), cCandidate.getOutput(), window, window_out, units)) return false; if(!cHC.FeedForward(cCandidate.AsObject(), Support)) return false; if(!cHC_emb.FeedForward(Embedding)) return false; if(!MatMul(cHC.getOutput(), cHC_emb.getOutput(), cHCe.getOutput(), 1, (window + window_out)*cheb_k, window_out, units, true)) return false; if(!Activation(cHCe.getOutput(), cHCe.getOutput(), TANH)) return false; if(!GateElementMult(PrevOutput, cHCe.getOutput(), cR.getOutput(), Output)) return false; //--- return true; }
In der letzten Stufe wird der vorherige Zustand über das R-Gate elementweise mit dem Kandidatenzustand kombiniert; das Ergebnis ist eine Vorhersage, die zur Analyse oder zur weiteren Verarbeitung durch den Decoder bereitsteht. Übersetzt man dies in die Sprache der Finanzmärkte, so entspricht jeder Schritt einer mehrschichtigen Signalfilterung: Vergangene Kursbewegungen, benachbarte Vermögenswerte, zeitliche Merkmale und interne Embeddings werden kombiniert, um eine genaue und stabile Prognose zu erstellen. Die Methode feedForward ist hier wie ein Dirigent, der ein Orchester aus vielen Instrumenten koordiniert und chaotische Marktdaten in eine harmonische Symphonie aus Prognosen verwandelt.
Nachdem wir nun den Vorwärtsdurchlauf ausführlich behandelt haben, ist es an der Zeit, zu einem ebenso wichtigen wie faszinierenden Schritt überzugehen – der Weiterleitung der Fehlergradienten. Wenn man den Vorwärtsdurchlauf mit einem Trader vergleichen kann, der auf der Grundlage aktueller Daten eine Prognose erstellt, dann ist die Rückpropagation der Moment, in dem sich der Trader nach dem Handelstag hinsetzt, sein Handelstagebuch aufschlägt und analysiert, wo die Signale funktioniert haben und wo die Prognose fehlgeschlagen ist. Auf der Grundlage dieser Analyse werden die internen Parameter des Modells so angepasst, dass es am nächsten Tag genauere Ergebnisse liefert.
Die Methode calcInputGradients beginnt mit einer gründlichen Überprüfung aller Komponenten: des Eingabedatentensors, des Tschebyscheff-Polynom-Objekts und der Embeddings.
bool CNeuronHimNetGCRU::calcInputGradients(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support, CNeuronBaseOCL *Embedding) { if(!NeuronOCL || !Support || !Embedding) return false; //--- uint cheb_k = cZ_R.GetChebK(); uint units = cZ_R.GetCount(); uint window_out = Neurons() / units; uint window = cZ_R.GetWindow() - window_out;
Erst nachdem wir überprüft haben, dass alles stimmt, fahren wir mit der Berechnung der Schlüsselparameter fort: der Ordnung des Tschebyscheff-Polynoms, der Anzahl der Elemente in der Folge sowie der Merkmalsdimension an Ein- und Ausgang. Diese Werte bilden den Rahmen für die Weiterleitung des Fehlergradienten und legen fest, wie sich das Fehlersignal durch die Architektur ausbreitet.
Der erste Schritt besteht darin, den Gradienten der Operation zu verarbeiten, bei der der verborgene Zustand über das R-Gate elementweise mit den Kandidaten kombiniert wird. Bei diesem Vorgang werden die Auswirkungen aller verwendeten Komponenten berücksichtigt. Stellen Sie sich vor, wir würden den Beitrag jedes Indikators zur Performance der Strategie bewerten: Je nach ihrem Einfluss auf die Prognose werden manche Signale stärker und andere schwächer korrigiert.
if(!GateElementMultGrad(PrevOutput, cR.getPrevOutput(), cHCe.getOutput(), cHCe.getGradient(), cR.getOutput(), cR.getGradient(), Gradient, None, TANH, cR.Activation())) return false;
Anschließend leiten wir den Fehlergradienten durch die Matrixmultiplikation, um die Blöcke cHC und cHC_emb zu aktualisieren. Es ist vergleichbar mit der Filterung von Marktsignalen: Der Fehler durchläuft alle Ebenen und wird sorgfältig verteilt, sodass jede Komponente des Netzwerks ihren Anteil an der Korrektur erhält.
if(!MatMulGrad(cHC.getOutput(), cHC.getGradient(), cHC_emb.getOutput(), cHC_emb.getGradient(), cHCe.getGradient(), 1, (window + window_out)*cheb_k, window_out, units, true)) return false;
Der Aufruf von calcInputGradients für cHC stellt sicher, dass die Gradienten korrekt an den Kandidatenzustand weitergegeben werden, so als würden wir nicht nur die Ergebnisse einzelner Trades auswerten, sondern auch deren Wechselbeziehungen innerhalb der gesamten Handelsstrategie.
if(!cHC.calcInputGradients(cCandidate.AsObject(), Support)) return false; if(!DeConcat(NeuronOCL.getGradient(), cZ.getPrevOutput(), cCandidate.getGradient(), window, window_out, units)) return false;
Darauf folgt die Aufteilung – die Verteilung der Fehlergradienten auf die Eingabedaten und die Kandidaten aus dem verborgenen Zustand.
Indem die Fehlergradienten durch eine elementweise Multiplikation geleitet und anschließend konkateniert werden, erhält man die korrekten Gradienten für die Gates Z und R. Die Anpassung der erhaltenen Werte anhand der Ableitung der Aktivierungsfunktion gewährleistet eine korrekte Fehlerskalierung und verhindert so eine Überlastung des Modells.
if(!ElementMultGrad(cZ.getOutput(), cZ.getGradient(), PrevOutput, cCandidate.getPrevOutput(), cZ.getPrevOutput(), None, None)) return false; if(!Concat(cZ.getGradient(), cR.getGradient(), cZe_Re.getGradient(), window_out, window_out, units)) return false; if(!DeActivation(cZe_Re.getOutput(), cZe_Re.getGradient(), cZe_Re.getGradient(), SIGMOID)) return false;
Besonderes Augenmerk wird auf Tschebyscheff-Polynome gelegt. Zunächst wird der zuvor aus dem cHC-Objekt ermittelte Gradient gespeichert. Anschließend wird calcInputGradients für cZ_R aufgerufen, woraufhin die akkumulierten Gradienten sorgfältig summiert werden. Dadurch kann das Modell die direkten und indirekten Einflüsse benachbarter Knoten im Graphen berücksichtigen und so eine stabile und genaue Aktualisierung der Gewichte der Graphfaltung gewährleisten.
if(!MatMulGrad(cZ_R.getOutput(), cZ_R.getGradient(), cZ_R_emb.getOutput(), cZ_R_emb.getGradient(), cZe_Re.getGradient(), 1, (window + window_out)*cheb_k, 2 * window_out, units, true)) return false; CBufferFloat* temp = Support.getGradient(); if(!Support.SetGradient(Support.getPrevOutput(), false) || !cZ_R.calcInputGradients(cInpAndHidden.AsObject(), Support) || !SumAndNormilize(temp, Support.getGradient(), temp, Support.GetDimension(), false, 0, 0, 0, 1) || !Support.SetGradient(temp, false)) return false;
Der Hauptinformationsfluss endet mit der Übertragung der Gradienten auf die Rohdatenebene, wobei Informationen aus den beiden Informationspfaden zusammengeführt werden. Anschließend erfolgt eine Anpassung anhand der Ableitung der Aktivierungsfunktion.
if(!DeConcat(cInpAndHidden.getPrevOutput(), cCandidate.getPrevOutput(), cInpAndHidden.getGradient(), window, window_out, units)) return false; if(!SumAndNormilize(NeuronOCL.getGradient(), cInpAndHidden.getPrevOutput(), NeuronOCL.getGradient(), window, false, 0, 0, 0, 1)) return false; if(NeuronOCL.Activation() != None) if(!DeActivation(NeuronOCL.getOutput(), NeuronOCL.getGradient(), NeuronOCL.getGradient(), NeuronOCL.Activation())) return false;
Anschließend durchlaufen die Embeddings einen ähnlichen Vorgang: Ihre Gradienten werden über cHC_emb und cZ_R_emb angepasst. Diese werden anschließend summiert, wodurch sichergestellt wird, dass alle Parameter konsistent aktualisiert werden.
if(!Embedding.CalcHiddenGradients(cHC_emb.AsObject())) return false; temp = Embedding.getGradient(); if(!Embedding.SetGradient(Embedding.getPrevOutput(), false) || !Embedding.CalcHiddenGradients(cZ_R_emb.AsObject()) || !SumAndNormilize(temp, Embedding.getGradient(), temp, cZ_R_emb.GetWindow(), false, 0, 0, 0, 1) || !Embedding.SetGradient(temp, false)) return false; //--- return true; }
Dadurch wird calcInputGradients zu einem ausgeklügelten System zur Umverteilung von Fehlern innerhalb der gesamten GCRU-Architektur. In der Praxis lässt sich dies mit einem Trader vergleichen, der nicht nur Schwachstellen in einer Strategie aufdeckt, sondern jede einzelne Komponente im Detail analysiert – zeitliche und räumliche Muster, Zusammenhänge zwischen Vermögenswerten und Reaktionen auf Marktereignisse – und diese Informationen nutzt, um die Genauigkeit künftiger Prognosen zu verbessern. Dieser Ansatz macht den Trainingsprozess des Modells lebendig und dynamisch und bringt ihn so nah wie möglich an die reale Marktlogik heran.
Hier kommen wir nun zu dem Teil des Mechanismus, der auf den ersten Blick vielleicht am unscheinbarsten erscheint – der Gewichtsaktualisierung. Wie jedoch bei Architekturen mit einer sorgfältig durchdachten internen Logik oft der Fall ist, verbirgt sich hinter dieser Einfachheit eine gut durchdachte Hierarchie zur Verwaltung von Parametern. Das gesamte schwerfällige System – mit seinen Gates, Tschebyscheff-Polynomen, Matrixmultiplikationen und Aktivierungen – läuft letztendlich darauf hinaus, nur zwei Schlüsselobjekte korrekt zu konfigurieren: cZ_R_emb und cHC_emb. Es ist, als ob in einem komplexen Uhrwerk mit Dutzenden Zahnrädern nur zwei Einstellachsen tatsächlich die Genauigkeit des gesamten Uhrwerks bestimmen würden.
Die Methode updateInputWeights beginnt mit einer einfachen, aber grundlegenden Prüfung: Ist ein Embedding-Objekt vorhanden? Ohne dieses Objekt ist die Aktualisierung sinnlos, da das Modell darüber die räumlichen und semantischen Beziehungen des Graphen erfasst. Wenn das Objekt nicht existiert, endet die Methode sofort und gibt false zurück.
bool CNeuronHimNetGCRU::updateInputWeights(CNeuronBaseOCL *NeuronOCL, CChebPolinom *Support, CNeuronBaseOCL *Embedding) { if(!Embedding) return false; //--- if(!cZ_R_emb.UpdateInputWeights(Embedding)) return false; if(!cHC_emb.UpdateInputWeights(Embedding)) return false; //--- return true; }
Anschließend wird die Steuerung an die beiden wichtigsten Speicher für trainierbare Parameter übergeben: Zunächst werden die für den Z-R-Block zuständigen Gewichte (cZ_R_emb) aktualisiert, danach die für den H-C-Kandidatenblock zuständigen Gewichte (cHC_emb). Beide UpdateInputWeights-Aufrufe werden nacheinander ausgeführt – vergleichbar mit zwei präzisen Stellschrauben, von denen jede ihren eigenen Teil des Rechenknotens beeinflusst.
Es sei betont, dass diese Prägnanz das Ergebnis einer durchdachten architektonischen Gestaltung ist. Alle anderen Schichten, Zwischenpuffer und Gates haben ihre Gradienten bereits während der Rückpropagation erhalten. Hier geben wir im Grunde den Befehl, diese Änderungen anzuwenden – und zwar auf die Parameter, die das Verhalten des Modells langfristig tatsächlich bestimmen. Mit anderen Worten: Wenn man die vorherige Methode (calcInputGradients) mit der Analyse der Ursachen vergangener Fehler vergleichen kann, dann entspricht updateInputWeights der Anpassung des Handelssystems: Wir ziehen nicht nur Schlussfolgerungen, sondern lassen diese auch in die Einstellungen einfließen, damit die Prognose für morgen genauer und stabiler ausfällt.
Dieser Ansatz macht die Architektur nicht nur effizient, sondern auch vorhersehbar: Durch Änderungen an nur zwei Stellen lässt sich eine umfangreiche Rechenkette steuern, wobei deren Integrität und Konsistenz gewahrt bleiben.
Wir haben heute viel geschafft, und jetzt ist ein guter Zeitpunkt für eine kurze Pause. Im nächsten Artikel werden wir diesen Weg fortsetzen. Lassen Sie uns das Begonnene zu Ende bringen, indem wir die Implementierung zu ihrem logischen Abschluss führen, und sie anschließend anhand echter historischer Daten testen, um zu sehen, wie sich die Theorie in der Praxis bewährt.
Fazit
In diesem Artikel haben wir uns auf eine der Schlüsselkomponenten der gesamten Architektur konzentriert und deren Funktionsweise Schritt für Schritt analysiert – von der Bildung interner Verbindungen über den Mechanismus zur Weiterleitung der Fehlergradienten bis hin zum Verfahren zur Parameteraktualisierung. Wir haben gesehen, wie einzelne Module, die auf den ersten Blick autonom erscheinen, beginnen, im gleichen Rhythmus zusammenzuwirken, und so eine geschlossene Struktur bilden, die für das Training und den Betrieb unter realen Marktbedingungen bereit ist. Es ist besonders wichtig zu betonen, dass ein derart gut strukturiertes System auf nur zwei Objekten mit trainierbaren Parametern basiert, wodurch es nicht nur kompakt ist, sondern sich auch auf vorhersehbare Weise steuern lässt.
Zum jetzigen Zeitpunkt verfügen wir über einen nahezu vollständig ausgearbeiteten Bestandteil der zukünftigen Rechenkette, der bereit ist, die Last realer Handelsdaten zu bewältigen. Im nächsten Artikel werden wir einen entscheidenden Schritt unternehmen: Wir werden alle Komponenten in eine einzige Struktur integrieren, umfassende Tests anhand historischer Zeitreihen durchführen und prüfen, inwieweit der von uns entwickelte Algorithmus nicht nur in der Lage ist, vergangene Muster nachzubilden, sondern auch sicher durch die sich ständig verändernden Marktbewegungen zu navigieren.
Literaturverzeichnis
- Heterogenitätsgestütztes Metaparameterlernen für die raumzeitliche Zeitreihenprognose
- Andere Artikel dieser Serie
In diesem Artikel verwendete Software
| # | Name | Typ | Beschreibung |
|---|---|---|---|
| 1 | Study.mq5 | Expert Advisor | Expert Advisor für das Offline-Modelltraining |
| 2 | StudyOnline.mq5 | Expert Advisor | Expert Advisor für das Online-Training des Modells |
| 3 | Test.mq5 | Expert Advisor | Expert Advisor zum Testen des Modells |
| 4 | Trajectory.mqh | Klassenbibliothek | Struktur zur Beschreibung des Systemzustands und der Modellarchitektur |
| 5 | NeuroNet.mqh | Klassenbibliothek | Klassenbibliothek zum Erstellen neuronaler Netze |
| 6 | NeuroNet.cl | Bibliothek | Bibliothek mit OpenCL-Programmcode |
Übersetzt aus dem Russischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/ru/articles/19250
Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.
Dieser Artikel wurde von einem Nutzer der Website verfasst und gibt dessen persönliche Meinung wieder. MetaQuotes Ltd übernimmt keine Verantwortung für die Richtigkeit der dargestellten Informationen oder für Folgen, die sich aus der Anwendung der beschriebenen Lösungen, Strategien oder Empfehlungen ergeben.