Christian / Profile

Nächster Schritt ist ein Test über 128 Loops a 13,8 Tage = ca 5 Jahre
Der letzte mit 64 hat ca 30h gedauert.
Das wird dann ein echtes Ergebnis sein was man mit dem Model in 5 Jahren und 10 Lots erreichen kann.
Aber es sind nur theoretische Werte da bisher kein MT5 die Trades im Tester ausführt. Später wird er das.

Bis dann

Hier der Loop 45 , er zeigt das sich mein Model besonders gut mit oszillierenden Phasen des EURUSD zurechtkommt.
Und dabei ist noch kein Bit gedreht um den Trading Algorithmus zu optimieren.
Immer noch stur long-short-long-short immer im wechsel

Sehr schön ! Eben ist der Test über 64 Loops fertig geworden. 3 oder 4 Loops fehlen weil es in der Mitte wieder den Bug gab. Den ich nun aber beseitigen konnte.

Daten und Ergebnisse

Pro Loop wurden
180000 min Training = 125 Tage
20000 min Trading = 13,8 Tage
Zeit verwendet.
Es wurde insgesammt 64x13,8= 883 Tage gehandelt

Der Kurs ist startet im 2017/04 EURUSD

Jeder Loop wird um 2000 min weitergeschoben
Das bedeutet der Test hat 64x2000 min = 88,8 Tage umfasst
Es soll hiermit nicht den erzielbaren Gewinn darstellen sondern beweisen
das es moglich ist mit einem NN ein wiederholbares und in der Summer sehr positives Ergebnis zu erzielen.

Hier dazu die Grafik

Aktuell läuft ein langer Test bisher ohne Absturz :-) bin sehr gespannt auf die Ergebnisse.

In der Zwischenzeit arbeite ich mich in die MT-API von Vyacheslav Demidyuk http://mtapi4.net/
ein. Es sind 4 Entwickler die schon sehr weit gekommen sind. Sinn machtes für mich da ich wahrscheinlich die API nutzen werde um den EA der folgt damit auf MatLab zu programmieren. Ich habe schon einen EA in MQL5 erstellt aber die programmierung der Grafik ist doch sehr abenteuerlich. In Matlab ist alles seit Jahren erprobt und Fehlerbeseitigt. Riesige Dokumentation und eine breite Comunity. Plan ist es den MT5 nur als Brücke zum Broker zu nutzen. So bleibe ich flexible wenn der EA an andere Broker/System angepasst werden soll. (Ninjatrader...etc). Ich möchte die Jungs von MQL5 nicht schlecht machen aber ich habe in den Jahren doch sehr merkwürdige Eigenheiten des Landes feststellen können.
Es reicht mir wenn der MT5 einfach stur die Trades ausführt. Die technische Intelligenz ist in Matlab besser aufgehoben. Dort stehen Tür und Tor zu modernen Idee weit offen.

so genug gefaselt ...ran an den Speck :-) Das neue Ziel ist ein mini EA der Den Kurs aus dem MT5 holt und darstellt mit Live Quoten. Mal sehen in wie weit es mit der MT5-api damit schon möglich ist.Compelieren ließ sich das Github Paket auf jeden fall in Visual Studi 2017 problemlos.

Eins sei noch gesagt...die API funktioniert Netzwerkübergreifend !

Wenn Jemand Interesse an dem Thema hat schick mir eine PM

Hier die Auswertung mit Excel:

Guten Morgen an die Interessierten ,

ich konnte nun endlich mal einen langen test machen leider nur mit einer Karte.
Momentan schaltet sich sogar das Netzteil aus wenn ich den Multi-GPU modus in Matlab nehme.
Die Leistungsaufnahme der 1080 steigt sporadisch bis an 230 Watt an und die 1070ti knapp 180. Sollte ein 750 Watt Netzteil eigentlich schaffen. Fakt ist aber das es überlastet ist in diesem Modus. Also muss ein dickeres Netzteil her ...später :-)
Dadurch das man übedr CUDA nur "Jobs" an die G-Karte sendet ist es möglich gleich mehrer zu senden. Dann steigt die Auslastung an die technische Watt Grenze. Sprich 2 oder 4 Kerne nutzen G-Karte 1 die anderen 2-4 Kerne die G-Karte 2.
Aber das nur so nebenbei.

Zum Ergebniss :

Geplant waren 128 Loops ( Train/Trade)
180k Train
20k Trade

Leider gabs ein Abbruch nach ca 30 Loops , ein Bug den ich noch nicht beseitigt habe.
Da ich die Einzeltest in Ordner Speichere habe ich trotzdem die Ergebnisse. Kann sie nur nicht mit den Viewer Darstellen. Ich mache eben eine Excel Tabelle fertig.

hier ein Loop der mir gefällt :-)

Loop: 31
Folder Results/2018_2_11_0_48_54.322 created
Classify Train Data
End Classifying
Classes detected : 179690
Class 1 Buy : 10545
Class 2 TrendBuy : 69386
Class 3 Sell : 10530
Class 4 TrendSell : 89229
Elapsed time is 117.840306 seconds.

Train =

struct with fields:

info: [1x1 struct]
acc: 0.6914



*******************************************************
Simulator started....
*******************************************************

Start at Time: 23:22:00 Tick: 180000
End at Time: 21:47:00 Tick: 200000
*******************************************************
Simulator End!
*******************************************************
Results:
End Balance : 48100
Balance High : 49620
Balance Low : -760
Profit : 48100
Profit Forward : 48100
Comission : 4040
Trades : 101
Trades Long : 51
Trades Short : 50

Letze Woche wollte ich noch einen Langzeit Test zeigen . Es treten aber momentan mit den 2 Grafikkarten diverse Bugs auf die den Test verhindern. Ich arbeite dran.

Hie ein Test als einzel Loop.
Training 100k min Bars
Trading 40k min Bars.

Ich habe mal zum Spass die Output Neuronen auf 1000 gesetzt. Somit besitze das Netz ca 1000 x 126 = 126000 Neuronen.
Zeit waren 4h die aber auf einem Laptop mit GTX 960m durchgeführt wurde.
Ergebniss sieht sehr gut aus. Etwas zu viele Trades. Mit knapp 28/Tag
Da geht zu viel an Commission verloren. Aber es sieht gut aus und zeigt die richtige Richtung.

Daten :

Start at Time: 16:47:00 Tick: 100000
End at Time: 13:57:00 Tick: 140000
*******************************************************
Simulator End!
*******************************************************
Results:
End Balance : 23100
Balance High : 45040
Balance Low : -1660
Profit : 23100
Profit Forward : 23100
Comission : 30320
Trades : 758
Trades Long : 379
Trades Short : 379
Elapsed time is 12795.142048 seconds.

Ich hoffe am Wochenende einen langen Test zu zeigen

und die aus Loop 7 die ja um 1000 Bars weiter verschoben ist.
Wichtig ist mir dabei das die Ergebnisse reproduzierbar sind.

Man sieht deutlich das das Netz die Entscheidungen sehr gut gelernt hat und nicht mehr so zufällig agiert

Das sind die Trades aus Loop 6

Die Hardware wurde um eine GTX1070ti erweitert. Jeder weiß ja wie schwierig es momentan ist eine Grafikkarte zu bekommen. Netter Nebenverdienst lässt sich mit Mining einfahren. So nun aber zum Thema

Unten zu sehen ist das Ergebniss einen Loop Test über 8 Train-Trade Phasen.
Training Phase 30k minBars 10k Validierung minBars
Trade Phase 8k minBars
Die Phasen sind jeweils um 1000 minBars iteriert. Sprich der Gewinn ist nicht in der Zeit generiert worden sondern dient dem Testen des Konzeptes. Aktuell erreiche ich eine Accuracy füe die Erkennung der 4 Klassen des Kurses von 0.65-0.7.

Es ist nur ein kleiner Test der aber schon 2h dauerte. der nächste folgt heute Abend.

Ein Beispiel wie Overfitting aussieht. Im ersten Moment unbrauchbar aber es lässt sich auch mit übertrainierten NN Profit generieren

Ich baue den Simulator nun etwas um.
Die nächsten Ergebnisse werden Langzeit Test sein . Zum Bsp über ein Jahr.
Was dann ca 500 Training/Trade Phasen sind.
Nun kommt leide die schwache Hardware zum Tragen.
Eine GTX1080 in Kombination mit Ryzen 1700x und 32 GB Ram würde für diesen Test ca 1000 Stunden dauern.
Deswegen versuche ich nun so viel wie möglich des Codes in CUDA zu schreiben/konvertieren lassen . Damit die Sache dann etwas fahrt bekommt. Matlab bietet in der Hinsicht eine enorme Hilfe an in dem man sich die SCRIPT Funktionen in Code gießen lassen kann. C/C++/CUDA . Leider muss dann auf vieles verzichtet werden da sich nicht jede Funktion umwandeln lässt.

Gruß Christian

Auch ein mehrfaches Testen der selben Parameter bringt ein ähnliches Resultat.

Training 100000 Bars
Trading die nächsten 20000 Bars

Nach längerer Suche bin ich nun dem Problem auf die Schliche gekommen. Ich berichtete ja das die durchaus sehr positiven Ergebnisse im Langzeittest ( mehrere Training und Trade Phasen hintereinander) die doch sehr wackelig waren. Ein und der selbe Test ging einmal im Plus und dann mal wieder im gleich großen Minus zu Ende.

Es liegt an der Anzahl der Training Beispiele sprich die Anzahl der Bars/Training. Stabilere Ergebnisse kommen zum Beispiel erst ab ca 50000 1min Bars. Besser noch mit 100000 Bars. Die Training Zeit schnellt nun von Minuten auf 1-2h pro 10000 Bars Trading Zeit. Der Trainig Algo kann es anhand der wenige Beispiele nicht generalisieren und ein Model erstellen was robust genug ist.

Das alles wurde mit einer Testversion von Matlab2017b und einem LSTM Netzwerk mit ca 20-200 Outputneuronen erstellt. Zugrunde legt dann aber ein Classification Netzwerk. Timeseries als Input und 4 Klassen als OutPut.
Ich habe den Kurs auf folgende Klassen reduziert. ( Anmerkung mit mehren Klassen geht es besser)

Trendwende BUY
Trend Buy
Trendwende Sell
TrendSell

Gehandelt wirt nur die Klassen Trendwende Buy/Sell als Einstiegstsignal.

Hier ein paar Resultate.

Bin eben auf ein sehr interessantes Projekt gestoßen.
http://mtapi4.net/

Wer reinschauen möchte -> Github: https://github.com/vdemydiuk/mtapi

Ist eine komplette APi in Form von .NET für den MT4 und zum Teil für den MT5

Das würde mir die Option eröffnen den kompletten EA in Matlab zu schreiben und nur den MT5 als Brücke zum Broker.

hier mal ein bsp Code um in Matlab Quoten zu erhalten.

Hier ein Schema das Neuronalen Netzes. Ob das die Ideale Form ist weiß ich nicht aber es bringt sehr gute Ergebnisse.
Technisch sollen ja LSTM Netze mit "Speicher Funktion" besser für Zeitreihen sein. Aktuell unterstützt Matlab erst ab der Version 2017b LSTM Netze

Natürlich ist trotz aller Euphorie der Knackpunkt nicht weit.
Derselbe Test ein 2. Mal ausgeführt kann zu einem kompletten anderem Ergebnis führen.
Daran arbeite ich gerade . Es liegt in der Natur eines Training Algos und der Neuronalen Netze das er immer etwas anders ist . Jedes mal ist das netz auch mit fast gleichen Ziel Parametern doch immer etwas anders. Dort versuche ich gerade den "Zufallscharakter" einzukreisen und zu reduzieren.

Wer Interesse oder Ideen hat der möge es mir mitteilen.

Hier ein Bild der gehandelten Signale. Ich möchte dazu sagen das das neuronale Netz die Daten noch nie gesehen hat. Was viele beim Testen von Strategien falsch machen.
Wer genau hinsieht erkennt das Potential von solch einem Gespann.
Rotes Dreieck -> Short
Grünes Dreieck -> Long