Search the Community
Showing results for tags 'ki'.
-
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
- 4 replies
-
- 6
-
- ea kitchen
- nn
-
(and 1 more)
Tagged with:
-
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 ;)
-
Kommen wir zum schwierigen Teil: Die Implementierung. Für das ganze restliche rundherum hab ich das EA Kitchen Framework genommen. Den aktuellen Source gibts dann immer im dazugehörigen Thread. Die konkrete Implementierung der NN Logik wird in eine Lib ausgelagert. Ich hatte zwar schon mal so eine geschrieben, aber keine Ahnung mehr wo die is. Also nochmal. Das ganze wird jetzt sicher ein bissl hardcore programmiertechnisch, also wems nur ums prinzip geht: besser wegschaun ;) Softwarestruktur Die Lib wird so aufgebaut das sie genau 1 NN repräsentiert. Sprich es gibt globale variablen in der Lib die Status und Konfiguration speichern, und dann Funktionen für die entsprechenden Zugriffe. Gespeichert werden muss: Anzahl der Schichten -> integer bzw. direkt über größe des layers array Anzahl der Neuronen pro Schicht -> int-array: layers Definition der Übergangsfunktion pro Neuron -> zweidimensionales array (anzahl schichten x knoten pro schicht) Gewichte pro Verbindung -> wird wohl ein dreidimensionales double array. Ebene 1: layer, ebene 2: neuron am layer Ebene 3: neuron auf nächstem Layer Nötige Zugriffsfunktionen: Erzeuge NN. Parameter: ,, , Berechne NN. , Lade Parameter von File: Speichere in File: Autosave (nimmt filename aus dem geladen wurde Trainiere 1 Schritt: , Als Lernalgorithmus werd ich den backpropagation verwenden, einfach weil ich ihn kenne ;) Sprich die Lib wird ein komplett allgemeines NN, das man ggf. auch für ganz andere Varianten verwenden kann. Alle Projektspezifischen Einstellungen werd ich in eine mqh packen die die NN-Lib dann verwendet. Dann geh ich mal an die Implementation der Lib. Mal sehen wie lang es dauert ;)
- 4 comments
-
- 3
-
- ki
- neuronales netz
-
(and 1 more)
Tagged with:
-
Kommen wir zum ersten spannenden Teil: Das Design des NN. Ob das NN die gewünschte Funktion richtig erlernt, hängt einerseits natürlich von der Funktion selbst ab. Aber zu einem großen Teil auch von der gewählten Form des Netzes und den Inputdaten. Ich habe vor für das Experiment verschiedene Ausprägungen eines Typs von NN zu testen. Grundsätzlich wird es wie gesagt ein mehrschichtiges feedforward NN. Die Anzahl der Schichten und Anzahl der Neuronen auf den Schichten werde ich variabel gestalten und im Laufe der Tests dann schaun welche Kombination am besten funktioniert. Die Funktion als solches wird ein "simpler" Klassifikator (darin sind NNs besonders gut). Sprich +1 wenn der nächste Bar min X Einheiten nach oben geht und nicht mehr als Y Einheiten fällt, -1 bei entsprechender Konstellation für Short und 0 sonst. Sicherheitshalber werde ich es auch mit 3 Outputneuronen (einen für Long, einen für Short, einen für Flat) testen um zu sehen wie hier die Unterschiede sind. Kurzer Exkurs zu NN als Klassifikator Will man ein NN nutzen um Inputs (zB Bilder) in gewisse Kategorien zu trennen, geht man meist so vor: Das NN hat gleich viele Outputneuronen wie es Kategorien gibt. Beim Trainieren setzt man dann den Output der korrekten Kategorie auf 1 und alle anderen auf 0. Ein neuer Input wird dann jener Kategorie zugeordnet deren zugehöriges Outputneuron den höchsten Wert hat. Weiter im Text: Also ein Klassifikator mit 3 Kategorien (entweder über 1 oder 3 Outputneuronen realisiert). nächste große Frage: Was wird klassifiziert/ Was sind die Inputs Einerseits werden natürlich die Daten der letzten X Bars (O/H/L/C + Volume) als Input dienen. Zusätzlich werd ich aber auch "jede Menge" halbwegs sinnvolle Vorverarbeitungen (Indikatoren) in das NN schmeißen und schaun was passiert. Aber: Mit genug Schichten kann sich das NN zwar aus den Inputs beliebige gewichtete Kombination bauen. die 2. Schicht kann also schon inputs der Form (C-O) oder (H-C) etc. kriegen. Aber es gibt (zumindest mit den Übergangsfunktionen die ich nehmen werd) keine Relationen zwischen den Inputs. Also (C-O)/ATR muss ich selber als Input definieren. Bei Inputs sollte man grundsätzlich sowieso immer darauf achten das alle auf ein einheitliches Maß "normiert" werden (meist zw. -1 und +1). Da in einem Chart ja stärker die relative Bewegung als die absoluten Zahlen zählen, werd ich die Bars auch entsprechend vorverarbeiten: Open_NN wird (Open- Close[1])/M wobei M wiederum per Parameter entschieden wird, entweder das Open des Bars (prozentuale Veränderung) oder ATR(13) (relative Bewegung) High_NN = (High - Open)/M Low_NN = (Open-Low)/M Close_NN= (Close-Open)/M Welche Indis noch dazukommen weiß ich noch nicht genau, aber auf jeden Fall: RSI, (Diff zw. zwei SMA)/M... Die Übergangsfunktionen Da ich noch keine Ahnung habe welche Übergangsfunktionen für diese Anwendung gut funktionieren, wirds auch hier im Sinne eines Forschungsprojekts zuerst einen Fundus geben. Nur das hier jedes NN gleich mit allen ausgestattet sind. Nach dem lernen werd ich mir die Gewichte anschauen, falls die Ausgangsgewichte eines Neurons alle nahe 0 sind, ist das Neuron für die Klassifikation offensichtlich umsonst. Dann kann ich es weglassen. Im ersten Schritt wird es also auf jedem Layer 3* an Neuronen geben. jeweils 1 lineare Übergangsfunktion, 1 Heavyside und eine sigmoide. Wie man merkt gibt es noch viele "Unbekannte" die im Laufe des Experiments gelöst werden sollen. Aber dafür ist so ein Projekt ja da ;)
-
Es werden also 2 Systeme werden. Da damit aber 2 Techniken verglichen werden sollen, haben beide Systeme die gleiche Basis und damit fangen wir mal an. Für die erfahreneren Handelssystementwickler: Ich will hier mal wirklich von ganz ganz unten anfangen, an dem Punkt der normalerweise unbeachtet bleibt weil er "selbstverständlich" passiert. Aber manchmal ist es gut sich klar zu machen worauf alles aufbaut. Also nicht wundern und ggf. einfach Einträge überspringen ;) Die Grundannahmen Jedes Handelssystem beruht auf (einer oder mehr) Grundannahmen. Ich meine da so Grundannahmen wie "Es gibt Trends an der Börse, und diese können vollautomatisch erkannt und gehandelt werden"... Egal wie die Grundannahme aussieht, sie ist in Stein gemeißelt. Auf dieser Annahme basiert das gesamte System. In meinem Fall sieht die Grundannahme so aus: Der Markt ist auf "längere" Sicht nicht (vollautomatisch) vorraussagbar. Vollautomatische Systeme können demnach nur in sehr kleinen Timeframes mit schnellen Positionen funktionieren. Im Preis (inkl. Volume und ggf. Level X ) sind alle nötigen Informationen für ein erfolgreiches System enthalten. Es gibt Muster und Konstellationen in den vorhandenen Daten, auf die der Markt "meist" ähnlich reagiert. Hat man diese Grundannahme für sich getroffen, kann man sich überlegen wie man darauf basierend ein erfolgreiches System schreibt. Meist ist die Grundrichtung hier offensichtlich. In meinem Fall wird es die Erkennung und Verwertung der Muster sein. Außerdem gibt die Grundannahme vor das es in sehr kleinen Timeframes passieren muss. Wie gesagt werde ich mich also nicht direkt mit Indikatoren etc. beschäftigen sondern versuchen auf die pure PriceAction zurückzugreifen. Da man natürlich zur Mustererkennung die Preise "vorbereiten" muss, werd ich hier teils sicher auf Indikatoren zurückgreifen, aber die Grundidee sind Muster in der Preisaction. Der nächste Schritt ist jetzt die erste Rohfassung für die Systemlogik. Noch bevor die erste Zeile Code geschrieben wird, sollte man eine grobe Vorstellung haben, auf welchen Eckpfeilern das System stehen wird. Dazu mehr im nächsten Eintrag.
- 2 comments
-
- 1
-
- handelssystem basics
- ki
-
(and 1 more)
Tagged with:
-
Also die Eckpfeiler. Ich möchte das System eigentlich möglichst "einfach" halten. Vor allem zu Beginn und solange noch nicht klar ist was die Ansätze überhaupt können. Die Eckpfeiler bestehen für mich (u.a.) aus diesen Punkten: Welcher Markt/Märkte Welcher Timeframe Einstiegslogik Ausstiegslogik MM/RM Markt: Da die Systeme selbstlernend werden (sollen), werde ich mich auf keinen Markt einschränken, sondern die Systeme dann mit diversen Märkten füttern und schaun was passiert, Schwerpunkt aber FOREX. Timeframe ergibt sich aus der Grundannahme: M1 bzw. ggf. M5. Die Systeme werde ich Timeframe unabhängig bauen damit man auch Test auf höheren Timeframes machen kann, aber der produktive Einsatz ist für kleine TF geplant. Die Ausstiege und MM/RM wird wie gesagt sehr simpel sein, jede Position bekommt TP und SL (abhängig von dem erkannten Muster). Später werde ich sicher auch mit trailing und BreakEven testen, aber derweil reicht TP und SL. Risiko bekommt jeder Trade gleich viel, es soll ja jeder die gleiche Chance haben. Kommt das spannenste hier: die Einstiege. Wie schon gesagt wird alles auf Mustererkennung beruhen. Eigentlich macht das fast jedes Handelssystem, also konkreter: Muster in der PriceAction. Der Knackpunkt ist natürlich "wie" diese Muster erkannt werden und welches Muster wie gehandelt werden soll. Und hier beginnen sich die beiden Systeme zu unterscheiden: klassische KI Der KI Teil, wird ein neuronales Netz bekommen, mit diversen (noch zu definierenden Eingängen) und damit klassifizieren ob der Kurs innerhalb der nächsten 2 Bars nach oben oder nach unten geht. (Details dazu später). Entsprechend dieser Klassifikation wird dann die Position eröffnet. Evolution Beim Evolutionsteil wird es noch etwas leichter sein zu verstehen warum das System etwas macht. Hier versuche ich zuerst einige mögliche Muster zu definieren. Das System wird dann diese Muster in der Vergangenheit testen und analysieren welche "funktionieren" und welche nicht. Die "guten Muster" werden dann einerseits gehandelt, andererseits werden durch Mutation und Vermischung neue "Muster" definiert die bei Erfolg automatisch zum Pool hinzugefügt werden. (Auch hier Details später). Um mir für das ganze rundherum die Arbeit zu erleichtern, werde ich das ganze in das EA-Kitchen Framework einbetten.
-
- 1
-
- handelssystem basics
- ki
-
(and 1 more)
Tagged with: