Search the Community

Wird Zeit für ein neues Update: Auf meinem Rechner läuft jetzt seit ca. 1 Woche ständig irgendein Trainingsdurchlauf. MT nutzt zwar leider nur 1 Kern (ja man könnte es mit mehreren Installationen parallelisieren) aber da ich ja eigentlich selber beim "lernen" bzw. Erfahrung sammeln bin, und unter der Woche nicht gerade viel freie Zeit hab, passt das ganz gut. Wie gehe ich derzeit vor Ich habe einerseits eine mqh, die mir die Vorbereitung der Inputs (Erstellung des Inputvektors inkl. Normierung) und die gewünschten Outputs erzeugt, sowieso ein paar weitere Kapselungen für den Einsatz in einem EA liefert. zB getSignalFromNN() oder updateNN(). Sprich diese mqh enthält die Erweiterung des "allgemeinen NN" auf das "projektspezifische NN". Auch mit einer Funktion trainNN(int offsetBars, int barsInTraining), getCurrentNNError(int offsetBars, int barsInTest) etc. Was es derzeit "lernt" Zuerst habe ich die Outputs so gewählt das ein "positiver Move" vorhanden war wenn der Kurs mindestens x rauf und maximal y runter gegangen ist. Das ganze gleich mal mit einem 5 schichtigen Netz trainiert auf 1000 Bars. Nunja, das Netz/der Backprop ist so "intelligent" das er einfach den Input ignoriert und immer das rät was am häufigsten vorkommt (rauf/runter oder seitwärts). Also nicht wirklich brauchbar. Dann hab ich versucht die Kategorien aufzuweichen und rein auf die Differenz Close-Open des nächsten Bars zu gehen. Also "positiver Move" wenn Close-Open > x. Bei mehrschichtigem Netz der gleiche "Erfolg". Dann hab ich das Netz mal deutlich zurückgefahren und trainiere mal mit nur 1 inneren Schicht. Hier werden die Inputs zumindest nicht mehr ignoriert. Bei 1000 Trainingsbars lernt er jedoch scheinbar recht bald die Trainingsdaten auswendig, denn der Trainingserror geht runter (gestoppt bei 30% Fehler) wobei der Testfehler bei 60% blieb... möglicherweise wird der Testfehler mit der Zeit besser. Derzeit läuft jetzt ein Training auf 5000 Bars, mal sehen ob er da weniger auswendig lernt. Mögliche Gründe Warum er mit mehr als 1 inneren Schicht die Inputs ignoriert ist mir nicht ganz klar. Hier werd ich noch mehrere Test machen müssen. Warum er jedoch nicht so gut lernt bzw. wenn dann auswendig lernt könnte aus meiner Sicht folgenden Grund haben: Ich gebe ihm alle Bars und "hoffe" das er von alleine eine Struktur dahinter erkennt und diese lernt. Das ist natürlich etwas optimistisch. Es gänge vermutlich deutlich besser wenn man das NN zB auf ein konkretes Pattern trainieren lässt und ihm zum lernen eine Reihe klassischer Beispiele dieses Patterns gibt. Hiefür muss man aber zuerst ein Pattern finden das wirklich Aussagekraft hat. Das finden solcher Patterns ist aber bereits Thema des Evolution-Teil dieses Projektes, weswegen ich hier nicht auf diese Taktik wechseln werde, sondern weiter versuche eine Möglichkeit zu finden das NN auf den rohen Daten zu lernen. UPDATE Habe jetzt ein Netz mit 2 inneren Schichten "antrainiert". Mit 30 Bars als Input macht es ein schönes Overfitting: 2% Fehler am Training, 72% am Test. Die 500Bars Back auf 5000 Bars trainiert tümpeln noch immer bei 60% training und test error herum.

Der eine oder andere hat vielleicht schon gesehen das ich wieder mal an einem EA-Projekt arbeite. Für die Umsetzung hab ich einfach mal das Kitchen-Framework hergenommen. Details zur Idee und Hintergründe gibts im Blog. Hier mal die Version 0.x, ich hab eigentlich nur mal das Framework für den konkreten EA angepasst und Stops/TP etc. implementiert (was in dem Fall äußerst minimalistisch ist.) Interessant wird dann die calcEntry Funktion. Ich werde im weiteren Verlauf 2 include dateien machen. Eine für die KI-Variante, eine für die Evo-Variante. Aber das dürfte noch ein bissl dauern ;) Die Kitchen soll ja nicht nur aus Indikatoren bestehen, sondern darf auch ein bissl "fancy-math-stuff" kriegen ;) eKIvsEvo.mq4

Es ist wiedermal ein bissl Zeit für Theorie. Ich habs in Neuronale Netze: Hintergrund bereits kurz angerissen, aber da es jetzt zur konkreten Implementierung geht werd ich es doch nochmal detailierter angehen. Also: wie lernt ein Neuronales Netz? Etwas präziser gehts um den sogenannten Backpropagation Lernalgorithmus. Ich erspar euch die mathematischen Details und beschränk mich auf verständliches Kauderwelsch ;) Der backprop-algo ist ein häufig verwendeter Algorithmus zum trainieren von feed-forward Netzen. Hierfür eine kurze Wiederholung der Funktionsweise eines feedforward Netzes: Es besteht aus mehreren Schichten von Neuronen. Für eine Inputliste, wird für jedes Neuron der ersten Schicht der resultierende Output berechnet, aus diesen Outputs ergibt sich eine neue Inputliste, diese wird nun auf die 2. Schicht angewandt und so weiter bis zur letzten Schicht. Die Outputs der letzten Schicht sind dann die Outputs des Neuronalen Netzes. Es wird also der Input von vorne nach hinten "durch propagiert". Wenn man das Netz jetzt trainieren will, nimmt man eine Inputliste wo man die gewünschte Output liste kennt und propagiert die Inputliste durch das Netz. Nun hat man den tatsächlichen Output und den gewünschten Output. Die Differenz dieser beiden wird als Error bezeichnet. Auf der letzten Schicht kann man nun sehr einfach an der Behebung dieses Erros arbeiten: Da man sowohl die inputs dieser Schicht als auch die Aktivierungsfunktionen kennt, muss man lediglich die Gewichte so anpassen, das der Fehler "verschwindet". Aber man hat ja mehrere Schichten und will nicht sofort auswendig lernen. Also bewegt man die Gewichte nur einen kleinen Schritt (die sogenannte Lernrate) in die entsprechende Richtung und "propagiert" den Fehler weiter zur vorigen Schicht. Man "propagiert" den Fehler also zurück zum Anfang, deswegen Back-Propagation. Bei der Outputschicht ist die Bestimmung des Fehlers ja noch recht einfach. Bei den tieferen Schichten wirds dann schon schwieriger. Zunächst berechnet man wie beschrieben für die Outputneuronen, in welche Richtung sich der gesamte Input des Neurons, wie stark bewegen müsste damit der Output passt. Das ist für jedes Neuron auf dem Layer eine Zahl, wir nennen es Delta. Dann schiebt man die Gewichte für jedes Neuron einen kleinen Schritt in diese Richtung. Die größe dieses Schrittes hängt ab von der vorgegebenen Lernrate und dem Inputwert. Ist der Inputwert für dieses Gewicht negativ gewesen, muss man natürlich in die andere Richtung gehen, war der Wert klein, geht man einen kleinen Schritt, war er groß, einen großen Schritt. Für ein Neuron auf der nächsten Schicht, multipliziert man die Deltas der verbundenen Neuronen auf der nächsten Schicht, multipliziert sie mit den Gewichten und verwendet diesen Wert als "Error" für dieses Neuron. Mit diesem Error berechnet man das Delta für dieses Neuron und so weiter... Im Inneren des Netzes kann man also nicht direkt den Fehler und damit die notwendige Änderungen bestimmen, sondern muss aufgrund der "durchgereichten" Fehler der späteren Schichten Rückschlüsse auf den Fehler dieser Schicht ziehen. In der Praxis funktioniert das normal recht gut. Die Lernrate Im Backprop wird an sich der Outputfehler so durchgereicht als würde nur eine Schicht verändert werden. Es darf also auf keinen Fall jede Schicht einen vollen Schritt in diese Richtung gehen. Dadurch würde man übers Ziel hinausschießen und einen großen Schritt zu weit gehen. Bei der nächsten Iteration geht man dann einen noch größeren Schritt zurück etc. Die Lernrate sollte also einerseits klein sein und zur Anzahl der Schichten passen. Je mehr Schichten desto geringer sollte die Lernrate sein. Ich hab in ersten Test gute Ergebnisse mit 1% Lernrate gemacht. Man kann das ganze natürlich verbessern indem man die Lernrate variabel gestaltet je nach derzeitigem Error (bei großem Fehler, hohe Lernrate..) oder mit Momentum (die Gewichtsveränderung ist ein Mittelwert zwischen letzter Iteration und neuem Wert). Initiale Gewichte Es hilft bei der Lerngeschwindigkeit (und teils überhaupt beim Lernen), wenn die Gewichte zu Beginn nicht alle gleich sind, sondern Zufallswerte sind. Dadurch "merkt" das Netz leichter die Unterschiede bei den Inputs... Zufällige Änderungen Ich weiß jetzt nicht ob das irgendwo wissenschaftlich untersucht ist, aber ich werde beim Lernen auch noch leichte Zufällige "Verzerrungen" einbauen. Das hilft (hoffentlich) einerseits gegen zu schlimmes auswendig lernen, andererseits bekommt der Lernalgo eine nichtdeterministische Komponente was ihm die Möglichkeit gibt aus lokalen Mini auszubrechen und ggf. bessere Minima zu finden. soda, ich hoff das war noch halbwegs verständlich ;)

Es hat (leider) etwas länger gedauert als erwartet, aber jetzt steht mal die erste Version. Ausgeführt wie gesagt als eine Library. Folgende Probleme (und Lösungen) sind während der Implementierung aufgetreten: Transferfunktionen Ich kann leider nicht beliebige Transferfunktionen zulassen, Grund ist genaugenommen nur die "Beschränktheit" von MQL. Mit OO könnte man eine Abstrakte "Transferfunction" Klasse machen und dem NN pro neuron ein solches Objekt übergeben. Aber is halt nicht. Also gibt es derzeit 3 mögliche Funktionen: Linear, sigmoid und heavy side. Welches Neuron welche Funktion verwendet wird bei der Initialisierung durch ein Array von IDs festgelegt (Linear hat ID 0, Sigmoid 1, HeavySide 2). Damit keine verwechslungen aufkommen, hab ich die Definition dieser IDs über Prekompilerkonstanten in ein eigenes mqh gelöst. Je nachdem welche TransferId das Neuron hat, verhält sich nun also die Funktion zur Berechnung des Neuron-Outputs entsprechend anders. MT und die Arrays In MQL gibt es ja bekanntlich Arrays, und man kann mit ArrayResize auch zur Laufzeit beliebig die Größe des Arrays ändern. Das gilt in der Form aber leider nur für eindimensionale Arrays. Für ein NN benötigt man aber auch 2 und 3 dimensionale Arrays. Und da ich nicht ein konkretes NN mit fixer Anzahl an Layern und Neuronen bauen will, muss auch die Größe der verschiedenen Dimensionen dynamisch sein. Also musste ein workaround her. Sieht im konkreten Fall so aus, das ich alles eindimensionale Arrays habe und die mehrdimensionalität mit der Indizierung "simuliere". realesArray[0] entspricht theoretischesArray[0][0][0] realesArray[1] entspricht theoretischesArray[0][0][1] Schwierig wirds jetzt zusätzlich weil die Dimensionen nicht nur variabel in der Größe sind, sondern natürlich komplett unterschiedlich sind. Nehmen wir als Beispiel das "zweidimensionale" Array welches die Transferfunction-Id pro neuron speichert. Theoretisch ist das Array so aufgebaut: transferId[layer][neuron] gibt es jetzt 5 Neuronen am Eingangslayer, 3 am layer1 und 2 am Layer2, dann ist transferId[0][1]= realesArray[1] transferId[1][1]= realesArray[5+1]; transferId[1][2]= realesArray[5+2]; transferId[2][0]= realesArray[5+3+0]; Ich muss mir hier also merken wieviele Neuronen es bis zum LayerX gibt, um dann für LayerX den richtigen Offset im Array zu wissen. Diese Info hab ich wiederum in ein Array gespeichert (simple, eindimensional ;) das für jeden Layer genau diesen Offset speichert. Noch eine Ebene komplizierter wirds dann bei den Gewichten, die eigentlich 3-dimensional sind. Hier arbeite ich wieder mit solchen gespeicherten Offsets. wobei ich mir speichere wieviele Gewichtswerte es bis zu LayerX gibt (wieder in einem Array) und dann im LayerX einfach nach dem fixen 2D prinzip gehe. Hier funktioniert es, da innerhalb eines Layers alle 2. Dimensionen gleiche Länge haben, da ja jeder Konten auf dem Layer gleichviele Outputknoten hat (Anzahl Knoten vom nächsten Layer). Biases Jedes Neuron in einem NN hat ja einerseits die inputs, aber zusätzlich noch einen Schwellwert oder Bias der zur gewichteten Summe dazugezählt wird. Ich habs einfach so implementiert das es ein weiteres Array gibt das sämtliche Biases beinhaltet, analog zum Array mit den Ids der Transferfunktionen. Speichern und Laden Die nächste Herausforderung war die Speicherung eines NN (also die Anzahl der Layer, Neuronen pro Layer, TransferId und Bias pro Neuron sowie alle Gewichte zwischen den Neuronen). Da ich die Gewichte grundsätzlich auch händisch/extern anaylisieren will, hab ich mich für csv entschieden, obwohl binär natürlich schneller und effizienter wäre. MQL hat ja an sich recht nette Filezugriffsmöglichkeiten, aber der Schreibbefehl für csv nimmt zwar eine beliebig lange liste an werten, aber macht immer eine newline. wenn man also zur compilezeit noch nicht weiß wieviele werte das werden und über eine Schleife schreiben will, kann man nur entweder die gesamte line selber als string bauen oder jeden wert in eine eigene Zeile schreiben. Ich hab mich für zweiteres entschieden. Dadurch is das file zwar recht lang, aber mei, die Anzahl der Zeichen ist gleich ;) Weitere Herausforderungen gabs dann noch beim Einbau des Lernalgorithmus, aber dazu mehr nachdem ich den in einem anderen Eintrag erklärt hab ;)