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

hier die aktuellste Version:

 

eKIvsEvo.mq4

 

Die NNs können scheinbar aus den reinen Chartdaten noch kein "Muster" lernen. Die KI Variante ist also programmiertechnisch eingebaut, aber tradingtechnisch nicht wirklich zu empfehlen...

Unglaublich was für ein WISSEN hier vermittelt wird.

FETTES DANKE dir Mythos.

Ich wusste jetzt nicht wo ich es einsetzten sollte ob im Blog als Kommentar oder hier rein. Falls es im Blog besser aufgehoben wäre wusste ich nicht ob du da nochmal rein schaust ;-)

http://www.tom-next....ntierung-teil2/

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.

 

Könntest du bitte das näher erläutern?

Nochmal

5 Neuronen am Einganglayer

3 am Layer1

2 am Layer2

-> ergibt in diesem Fall "3 Layer" und "5 max Neuronen in einem Layer (Eingangslayer)"

transferId[0 bis 2][0 bis 4]

Arraysize 125 mit einem Offset von 25

 

oder aufgesplittet im konkret diesem Fall

transferId[0][0-4] (Eingangslayer) -> 5 verschiedene Möglichkeiten

transferId[1][0-2] (Layer1 3 Neuronen) -> 3 verschiedene Möglichkeiten

transferId[2][0-1] (Layer2 2 Neuronen) ->2 verschiedene Möglichkeiten

Arraysize 30 mit einem Offset von 6 (2*3)

ABER dann verstehe ich deine Zusammenführung nicht.

 

EDIT : Ich glaub ich hab es jetzt verstanden. Man addiert die Neuronen der vorherigen Layer bis man zum eigentlichen Layer kommt und zählt diese hinzu... Post kann vom Admin gelöscht werden.

transferId[0][0]= realesArray[0]; (realesArray[0])

transferId[0][1]= realesArray[1]; (realesArray[1])

transferId[0][2]= realesArray[2]; (realesArray[2])

transferId[0][3]= realesArray[3]; (realesArray[3])

transferId[0][4]= realesArray[4]; (realesArray[4])

transferId[1][0]= realesArray[5]; (realesArray[5+0])

transferId[1][1]= realesArray[6]; (realesArray[5+1])

transferId[1][2]= realesArray[7]; (realesArray[5+2])

transferId[2][0]= realesArray[8]; (realesArray[5+3+0])

transferId[2][1]= realesArray[9]; (realesArray[5+3+1])

 

Dein Satz "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." hat in meinem Hirn kein Anschluss gefunden. Nu hat es aber die richtige Andockstelle erhalten.

Post kann vom Admin gelöscht werden.

Wenns ok is, lass ich es stehen. Vielleicht hilfts wem anderen auch noch.

 

Nochmal zum Verständnis:

Das Problem an der Sache ist die Variable Größe der "hinteren" Dimensionen.

 

Wenn ich es als "wirkliches" zweidimensionales Array machen würde. Müsste ich die 2 Dimension auf eine fixe Größe einstellen. Die ist dann entweder immer viel zu groß, oder schnell mal zu klein. Oder wie im aktuellen Fall: der erste Layer hat 500 Neuronen, der zweite 32, der dritte 3. Dann müsste das Array double[][500] sein, und man verbraucht unnötig Speicher (und womöglich auch Performance).

 

Wie ich es gelöst hab, nochmal (hoffentlich) anschaulicher:

Mit dem alten Beispiel: 3 Layer, erster Layer 5, zweiter 3, dritter 2 Neuronen.

 

Das Array sieht dann so aus:

"transferId[x][y]" bezeichnet die Id für Neuron y auf Layer x:

 

{ transferId[0][0],transferId[0][1],transferId[0][2],transferId[0][3],transferId[0][4],

transferId[1][0],transferId[1][1],transferId[1][2],

transferId[2][0],transferId[2][1] }

 

transferId[1][0] liegt also bei Offset 5 ... Anzahl Neuronen am 1. Layer

transferId[2][0] liegt bei Offset 5+3= 8 ... Anzahl Neuronen am 1. und 2. Layer

 

HTH