Diskussion zum Artikel "Verwenden von OpenCL, um Kerzenmuster zu testen"

 

Neuer Artikel Verwenden von OpenCL, um Kerzenmuster zu testen :

Der Artikel beschreibt den Algorithmus, um die Kerzenmuster von OpenCL für den Tester im Modus "1 Minute OHLC" zu implementieren. Wir werden auch die Geschwindigkeiten des integrierten Strategietesters, gestartet in schnellen und langsamen Modi, vergleichen.

Wir müssen uns auf etwas verlassen können, um sicherzustellen, dass die Implementierung des Testers auf OpenCL korrekt funktioniert. Zuerst werden wir einen MQL5-EA entwickeln. Dann werden wir die Ergebnisse der Prüfung und Optimierung mit einem normalen Tester mit denen des OpenCL-Testers vergleichen.

Das Testobjekt ist ein einfacher EA, der mit den folgenden Kerzenmustern handelt.
  • Bearish (abwärts) Pin-Bar
  • Bullish (aufwärts) Pin-Bar
  • Bearish Engulfing (umhüllend)
  • Bullish Engulfing (umhüllend)

Die Strategie ist einfach:

  • Bearish Pin-Bar oder Bearish Engulfing  — verkaufen
  • Bullish Pin-Bar oder Bullish Engulfing — kaufen
  • Die Anzahl gleichzeitig offenere Positionen — unbegrenzt
  • Maximale Haltezeit der Positionen — begrenzt, nutzerdefiniert
  • Take-Profit und Stop-Loss — unveränderlich, nutzerdefiniert

Das Vorhandensein eines Musters ist mit komplett geschlossenen Bars zu überprüfen. Mit anderen Worten wir suchen die Muster mittels drei vorherigen Bars sobald eine neue Bar erscheint.

Die Bedingung der Mustererkennung ist wie folgt:

Pin-Bar

Abb. 1. Die Muster von "Bearish Pin-Bar" (a) und "Bullish Pin-Bar" (b)

Autor: Serhii Shevchuk

 

Herr Autor, ich danke Ihnen für diesen Artikel! Ich denke, Sie haben diese spezielle TK nicht ohne Grund zur Demonstration ausgewählt, denn sie weist perfekte Parallelen auf. Allerdings ist dies eine sehr enge Nische.

In dem Artikel haben Sie sich sehr stark von der Universalität zur Partikularität bewegt. Es ist klar, dass das Ziel darin besteht, potenzielle Möglichkeiten aufzuzeigen. Aber es gibt wenig, um es auf Ihre eigenen Bedürfnisse anzuwenden.

Ich würde gerne Beispiele für die Übersetzung verschiedener MQL-Codes in OpenCL-Codes sehen. Vielleicht ist dies in den Artikeln enthalten, auf die am Anfang Ihres Artikels verwiesen wird.

 
Benutzerdefinierte Symbole können beim Vergleich von Testergebnissen helfen, Vertauschungen und Provisionen zu vermeiden.
 
Fehlt die Datei OCLDefines.mqh nur bei mir? :-)
 
Denis Kirichenko:
Fehlt die Datei OCLDefines.mqh nur bei mir? :-)

Vielen Dank für Ihre Aufmerksamkeit) Wir werden es beheben, aber ich verstehe, bereits am Montag. Hier ist die Quelle:

//+------------------------------------------------------------------+
//| definiert|
//+------------------------------------------------------------------+
//--- Setzen eines Laufzeitfehlers
#define  SET_ERR(c) do {m_last_error.function = __FUNCTION__; \
      m_last_error.line =__LINE__; \
      m_last_error.code=::GetLastError(); m_last_error.comment=c;} while(0)
//--- Setzen eines Laufzeitfehlers durch Übergabe des Funktionsnamens und der Zeilennummer über den Parameter
#define  SET_ERRx(c,f,l) do {m_last_error.function = f; m_last_error.line = l; \
      m_last_error.code=::GetLastError(); m_last_error.comment=c;} while(0)
//--- Einstellung eines Benutzerfehlers
#define  SET_UERR(err,c) do {m_last_error.function = __FUNCTION__; \
      m_last_error.line =__LINE__; \
      m_last_error.code=ERR_USER_ERROR_FIRST+err; m_last_error.comment=c;} while(0)
//--- Setzen eines Benutzerfehlers durch Übergabe des Funktionsnamens und der Zeilennummer über den Parameter
#define  SET_UERRx(err,c,f,l) do {m_last_error.function = f; m_last_error.line = l; \
      m_last_error.code=ERR_USER_ERROR_FIRST+err; m_last_error.comment=c;} while(0)
//--- Funktionsaufrufe für die Arbeit mit OpenCL
#define _BufferFromArray(buffer_index,data,data_array_offset,data_array_count,flags) \
      if(BufferFromArray(buffer_index,data,data_array_offset,data_array_count,flags,__FUNCTION__,__LINE__)==false) return false
#define _BufferCreate(buffer_index,size_in_bytes,flags) \
      if(BufferCreate(buffer_index,size_in_bytes,flags,__FUNCTION__,__LINE__)==false) return false
#define _BufferRead(buffer_index,data,cl_buffer_offset,data_array_offset,data_array_count) \
      if(BufferRead(buffer_index,data,cl_buffer_offset,data_array_offset,data_array_count,__FUNCTION__,__LINE__)==false) return false
#define _BufferWrite(buffer_index,data,cl_buffer_offset,data_array_offset,data_array_count) \
      if(BufferWrite(buffer_index,data,cl_buffer_offset,data_array_offset,data_array_count,__FUNCTION__,__LINE__)==false) return false
#define _Execute(kernel_index,work_dim,work_offset,work_size) \
      if(Execute(kernel_index,work_dim,work_offset,work_size,__FUNCTION__,__LINE__)==false) return false
#define _SetArgument(kernel_index,arg_index,value) \
      if(SetArgument(kernel_index,arg_index,value,__FUNCTION__,__LINE__)==false) return false
#define _SetArgumentBuffer(kernel_index,arg_index,buffer_index) \
      if(SetArgumentBuffer(kernel_index,arg_index,buffer_index,__FUNCTION__,__LINE__)==false) return false
#define _KernelCreate(k,src) \
      if(KernelCreate(k,src,__FUNCTION__,__LINE__)==false) break

//--- Benutzerfehler 
#define  UERR_NONE                0     // Kein Fehler
#define  UERR_NO_OCL              1     // COpenCL-Objekt existiert nicht
#define  UERR_GET_MEMORY_SIZE     2     // Fehler beim Abrufen der Speichergröße
#define  UERR_KERNEL_CREATE       3     // Fehler beim Erstellen eines Kernels
#define  UERR_SET_BUF_COUNT       4     // Fehler beim Einstellen der Anzahl der Puffer
#define  UERR_DOUBLE_NOT_SUPP     5     // Nicht unterstützt von double
#define  UERR_BUFFER_CREATE       6     // Fehler bei der Erstellung des Puffers
#define  UERR_BUFFER_FROM_ARRAY   7     // Fehler beim Erstellen eines Puffers aus einem Array
#define  UERR_BUFFER_READ         8     // Fehler beim Lesen des Puffers
#define  UERR_BUFFER_WRITE        9     // Fehler beim Schreiben in den Puffer
#define  UERR_SET_ARGUMENT        10    // Fehler beim Setzen der Argumente
#define  UERR_SET_ARGUMENT_BUFFER 11    // Fehler beim Setzen des Puffers als Argument
#define  UERR_EXECUTE             12    // Fehler bei der Kernel-Ausführung
#define  UERR_NO_ENOUGH_MEM       13    // Kein freier Speicher

//--- Testerfehler
#define  UERR_TESTER_ERROR_FIRST  256
#define  SET_UERRt(err,c)         SET_UERR(UERR_TESTER_ERROR_FIRST+err,c)
//+------------------------------------------------------------------+
 
fxsaber:
Benutzerdefinierte Symbole können dazu beitragen, dass beim Vergleich von Testergebnissen keine Vertauschungen und Provisionen anfallen.

Ja, aber das ist noch weiter von der realen Welt entfernt. Es sei denn, es ist für die Fehlersuche.

 
Der Artikel ist wirklich beeindruckend. Es ist schade, dass dies der Fall ist, wenn man die Höhe des geistigen Aufwands und die nützliche Leistung nicht vergleichen will.
 

Herzlichen Glückwunsch, Sie haben einen großartigen Artikel geschrieben!

Der Code aus dem Artikel wird zitiert werden, und Sie haben die Messlatte für Ihre Kollegen, die Artikel über paralleles Rechnen im Handel schreiben werden, sehr hoch gelegt.

 
fxsaber:

In diesem Artikel haben Sie sich sehr stark vom Allgemeinen zum Besonderen hin bewegt.

Das ist erst der Anfang. Das Universelle liegt vor uns. Die versteckte Botschaft des Artikels ist, dass nicht alles so einfach ist. Man kann nicht einfach seriellen Code in parallelen Code umwandeln. Man muss von Anfang an parallel schreiben.

Wenn die Gemeinschaft daran interessiert ist, werde ich meine weiteren Entwicklungen in dieser Richtung veröffentlichen.

 
Serhii Shevchuk:

Dies ist erst der Anfang. Vielseitigkeit ist angesagt. Die versteckte Botschaft des Artikels ist, dass nicht alles so einfach ist. Man kann nicht einfach seriellen Code in parallelen Code umwandeln. Sie müssen von Anfang an parallelen Code schreiben.

Wenn die Community interessiert ist, werde ich meine weiteren Entwicklungen in dieser Richtung veröffentlichen.

die Community ist sehr interessiert, "Afftar fishi ischo!!!1111".

ein sehr wichtiges Thema im Hinblick auf die Beschleunigung der Optimierung/Tests, insbesondere für Algorithmen des maschinellen Lernens

 

Sehr nützlicher Artikel!

Natürlich würde ich gerne mehr einfache Beispiele für die Übersetzung von gewöhnlichen MQL-Code in OpenCL-Code, in Form von fertigen Funktionen mit Kommentaren für Dummies zu sehen.

Und eine andere Frage, wie lange dauert es, um Daten für eine Grafikkarte zu übertragen/vorbereiten, hörte ich eine Meinung, dass OpenCL für eine Grafikkarte macht keinen Sinn, für den realen Handel wegen der Zeitverlust auf Datenübertragung für die Verarbeitung zu verwenden, ist es wirklich so?