Maschinelles Lernen im Handel: Theorie, Modelle, Praxis und Algo-Trading - Seite 900

Neuer Kommentar
 
Alexander Iwanow:

Sie haben Ihren Gral bereit? mit einer KI))

Nun, das war's... ihr seid bereits Oligarchen ))

Maximko erreicht natürlich immer sein Ziel.

 
Maxim Dmitrievsky:

Maximko erledigt natürlich immer den Job.

)))

Das war's... Wir geben alle unsere Roboter auf und stellen uns für den intelligenten Wunderroboter an.

 
Alexander Iwanow:

)))

Das war's... wir lassen alle unsere Roboter fallen und stellen uns für den intelligenten Wunderroboter an.

Ich bin schon auf halbem Weg zum Schweizer Bunker mit paramilitärischen Wachen, die Alexander mit seinen verstaubten Taschen voller Geldscheine verfolgen, keine Ursache!

 
Maxim Dmitrievsky:

Alexander_K2 aus einem anderen Thread

Ich kann nicht wirklich mit Python arbeiten, ich muss Python nur für die Visualisierung und sofortige Überprüfung verwenden... Jetzt erwäge ich die Möglichkeit, Python-Shell direkt über Winapi aufzurufen und Befehle an Python von Bot zu senden, ich weiß nicht, ob es möglich ist. R und dll nicht verdauen und nicht wissen, wie und wollen nicht mit ihnen zu arbeiten, obwohl die Python ist nicht erforderlich (Blick auf Artikel und Oldtimer arbeiten) immer weniger Lust, in die dicke von ihm zu bekommen - 500000 Pakete und die Ausgabe ist die gleiche wie von der Bot auf 2 MA

Sich mit einem solchen Monster zu verbinden, wäre für viele nützlich, aber nicht für viele, die nicht stark genug sind.

Wenn ich wollte 10 MAs mit Schritt 16 und machen einen Prädiktor - für jeden Preis eröffnet über/unter einem MA und eine weitere - Nummer dieser MA, während die Nummerierung aller MAs von oben nach unten, würde es den Markt beschreiben?

 
Maxim Dmitrievsky:

Ich habe ein kleines Experiment mit dem Fallenlassen ganzer Modelle durchgeführt (insgesamt sind 10 Modelle vorgegeben). Vorwärts von 2018.04.01

Ohne Abbruch:

Weiter mit Zahlen markiert, wie viele zufällige Modelle links, der Rest fiel:

Irgendwie stellt sich heraus, dass dies der Fall ist. Wahrscheinlich nicht sehr aufschlussreich, da das Modell ohne Aussetzer recht gut gelungen ist. Und die Modelle sind einander zu ähnlich, was schlecht ist. Der Lernalgorithmus muss überarbeitet werden (die Spieltheorie kann dabei helfen). Dennoch ist eine gewisse Flexibilität bei den Auswahlmöglichkeiten gegeben.

Sieht gut aus! Bei einem (1 Modell) anhalten.

 
Aleksey Vyazmikin:

Die Verbindung mit einem solchen Monster wäre für viele nützlich, aber nicht viele können sie herstellen.

Was ist mit MAs, ich war gerade beim Einschlafen denken - was, wenn wir 10 Pfeile mit 16 Schritten und machen einen Prädiktor - für jeden - der Preis eröffnet über / unter MA und eine weitere - Anzahl der MA, wenn die Nummerierung aller MAs von oben nach unten, wird ein solches Modell beschreiben den Markt?

So kann man es nicht ausdrücken. Experimente, Experimente... ...denn in der Theorie ist nichts offensichtlich. In sechs Monaten habe ich etwa hundert verschiedene Varianten von TS ausprobiert, und es ist beängstigend, wenn ich daran denke.

Die Geschichte der Branche enthält viele Informationen darüber, was man nicht tun sollte (und manchmal auch, was man tun sollte).

 
Aleksey Vyazmikin:

Die Verbindung mit einem solchen Monster wäre für viele nützlich, aber nicht viele können sie herstellen.

Was ist mit den MAs, ich habe gerade beim Einschlafen nachgedacht. Was ist, wenn ich 10 Pfeile mit 16 Schritten nehme und einen Prädiktor erstelle - für jeden Preis, der über/unter dem MA eröffnet wurde, und einen weiteren - die Anzahl der MAs, wenn ich alle MAs von oben nach unten nummeriere, wird ein solches Modell den Markt beschreiben?

Vor etwa 10 Jahren gab es einen Artikel mit einem solchen Experiment mit МА von 2 bis 100.
 
elibrarius:
Vor etwa 10 Jahren gab es einen Artikel über ein solches Experiment mit MA von 2 bis 100.

Und ich glaube, man nennt es Ventilator, wenn ich mich nicht irre...

 

Es scheint alle Probleme der mql4-Kommunikation mit verschiedenen Sprachen zu lösen. Es gibt sogar einen Code für R. Hier ist der Schaltplan.



Die gesamte Beschreibung besteht aus drei Teilen:

https://blog.darwinex.com/zeromq-interface-python-r-metatrader4/

https://blog.darwinex.com/zeromq-trade-execution-metatrader-zmq2/

https://blog.darwinex.com/zeromq-transaction-reporting-metatrader-zmq3/

Genehmigt:

Warum ZeroMQ?

1.ermöglicht es Programmierern, jeden Code mit jedem anderen Code zu verbinden, und zwar auf verschiedene Weise.

2.die Abhängigkeit einesMetaTrader-Benutzers von der vom MetaTrader unterstützten Technologie (Funktionen, Indikatoren, Sprachkonstrukte, Bibliotheken usw.) beseitigt.

3. dieHändler können Indikatoren und Strategien in C/C#/C++, Python, R und Java (um nur einige zu nennen) entwickeln und über MetaTrader 4 auf den Markt bringen.

Nutzen Sie die Toolskits fürmaschinelles Lernen in Python und R für komplexe Datenanalysen und die Entwicklung von Strategien, während Sie gleichzeitig eine Schnittstelle zu MetaTrader 4 für die Handelsausführung und -verwaltung haben.

5.ZeroMQ kann als leistungsstarke Transportschicht in anspruchsvollen, verteilten Handelssystemen eingesetzt werden, die ansonsten nur schwer in MQL implementiert werden können. 6.

6.verschiedene Strategiekomponenten können bei Bedarf in verschiedenen Sprachen erstellt werden und nahtlos über TCP, prozessinterne, prozessübergreifende oder Multicast-Protokolle miteinander kommunizieren.

7.mehrere Kommunikationsmuster und getrennter Betrieb.

Hier ist der Code

/+------------------------------------------------------------------+
//|                                       ZeroMQ_MT4_EA_Template.mq4 |
//|                                    Copyright 2017, Darwinex Labs |
//|                                        https://www.darwinex.com/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2017, Darwinex Labs."
#property link      "https://www.darwinex.com/"
#property version   "1.00"
#property strict

// Required: MQL-ZMQ from https://github.com/dingmaotu/mql-zmq
#include <Zmq/Zmq.mqh>

extern string PROJECT_NAME = "DWX_ZeroMQ_Example";
extern string ZEROMQ_PROTOCOL = "tcp";
extern string HOSTNAME = "*";
extern int REP_PORT = 5555;
extern int PUSH_PORT = 5556;
extern int MILLISECOND_TIMER = 1;  // 1 millisecond

extern string t0 = "--- Trading Parameters ---";
extern int MagicNumber = 123456;
extern int MaximumOrders = 1;
extern double MaximumLotSize = 0.01;

// CREATE ZeroMQ Context
Context context(PROJECT_NAME);

// CREATE ZMQ_REP SOCKET
Socket repSocket(context,ZMQ_REP);

// CREATE ZMQ_PUSH SOCKET
Socket pushSocket(context,ZMQ_PUSH);

// VARIABLES FOR LATER
uchar data[];
ZmqMsg request;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---

   EventSetMillisecondTimer(MILLISECOND_TIMER);     // Set Millisecond Timer to get client socket input
   
   Print("[REP] Binding MT4 Server to Socket on Port " + REP_PORT + "..");   
   Print("[PUSH] Binding MT4 Server to Socket on Port " + PUSH_PORT + "..");
   
   repSocket.bind(StringFormat("%s://%s:%d", ZEROMQ_PROTOCOL, HOSTNAME, REP_PORT));
   pushSocket.bind(StringFormat("%s://%s:%d", ZEROMQ_PROTOCOL, HOSTNAME, PUSH_PORT));
   
   /*
       Maximum amount of time in milliseconds that the thread will try to send messages 
       after its socket has been closed (the default value of -1 means to linger forever):
   */
   
   repSocket.setLinger(1000);  // 1000 milliseconds
   
   /* 
      If we initiate socket.send() without having a corresponding socket draining the queue, 
      we'll eat up memory as the socket just keeps enqueueing messages.
      
      So how many messages do we want ZeroMQ to buffer in RAM before blocking the socket?
   */
   
   repSocket.setSendHighWaterMark(5);     // 5 messages only.
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
//---
   Print("[REP] Unbinding MT4 Server from Socket on Port " + REP_PORT + "..");
   repSocket.unbind(StringFormat("%s://%s:%d", ZEROMQ_PROTOCOL, HOSTNAME, REP_PORT));
   
   Print("[PUSH] Unbinding MT4 Server from Socket on Port " + PUSH_PORT + "..");
   pushSocket.unbind(StringFormat("%s://%s:%d", ZEROMQ_PROTOCOL, HOSTNAME, PUSH_PORT));
   
}
//+------------------------------------------------------------------+
//| Expert timer function                                            |
//+------------------------------------------------------------------+
void OnTimer()
{
//---

   /*
      For this example, we need:
      1) socket.recv(request,true)
      2) MessageHandler() to process the request
      3) socket.send(reply)
   */
   
   // Get client's response, but don't wait.
   repSocket.recv(request,true);
   
   // MessageHandler() should go here.   
   ZmqMsg reply = MessageHandler(request);
   
   // socket.send(reply) should go here.
   repSocket.send(reply);
}
//+------------------------------------------------------------------+

ZmqMsg MessageHandler(ZmqMsg &request) {
   
   // Output object
   ZmqMsg reply;
   
   // Message components for later.
   string components[];
   
   if(request.size() > 0) {
   
      // Get data from request   
      ArrayResize(data, request.size());
      request.getData(data);
      string dataStr = CharArrayToString(data);
      
      // Process data
      ParseZmqMessage(dataStr, components);
      
      // Interpret data
      InterpretZmqMessage(&pushSocket, components);
      
      // Construct response
      ZmqMsg ret(StringFormat("[SERVER] Processing: %s", dataStr));
      reply = ret;
      
   }
   else {
      // NO DATA RECEIVED
   }
   
   return(reply);
}

// Interpret Zmq Message and perform actions
void InterpretZmqMessage(Socket &pSocket, string& compArray[]) {

   Print("ZMQ: Interpreting Message..");
   
   // Message Structures:
   
   // 1) Trading
   // TRADE|ACTION|TYPE|SYMBOL|PRICE|SL|TP|COMMENT|TICKET
   // e.g. TRADE|OPEN|1|EURUSD|0|50|50|R-to-MetaTrader4|12345678
   
   // The 12345678 at the end is the ticket ID, for MODIFY and CLOSE.
   
   // 2) Data Requests
   
   // 2.1) RATES|SYMBOL   -> Returns Current Bid/Ask
   
   // 2.2) DATA|SYMBOL|TIMEFRAME|START_DATETIME|END_DATETIME
   
   // NOTE: datetime has format: D'2015.01.01 00:00'
   
   /*
      compArray[0] = TRADE or RATES
      If RATES -> compArray[1] = Symbol
      
      If TRADE ->
         compArray[0] = TRADE
         compArray[1] = ACTION (e.g. OPEN, MODIFY, CLOSE)
         compArray[2] = TYPE (e.g. OP_BUY, OP_SELL, etc - only used when ACTION=OPEN)
         
         // ORDER TYPES: 
         // https://docs.mql4.com/constants/tradingconstants/orderproperties
         
         // OP_BUY = 0
         // OP_SELL = 1
         // OP_BUYLIMIT = 2
         // OP_SELLLIMIT = 3
         // OP_BUYSTOP = 4
         // OP_SELLSTOP = 5
         
         compArray[3] = Symbol (e.g. EURUSD, etc.)
         compArray[4] = Open/Close Price (ignored if ACTION = MODIFY)
         compArray[5] = SL
         compArray[6] = TP
         compArray[7] = Trade Comment
   */
   
   int switch_action = 0;
   
   if(compArray[0] == "TRADE" && compArray[1] == "OPEN")
      switch_action = 1;
   if(compArray[0] == "RATES")
      switch_action = 2;
   if(compArray[0] == "TRADE" && compArray[1] == "CLOSE")
      switch_action = 3;
   if(compArray[0] == "DATA")
      switch_action = 4;
   
   string ret = "";
   int ticket = -1;
   bool ans = FALSE;
   double price_array[];
   ArraySetAsSeries(price_array, true);
   
   int price_count = 0;
   
   switch(switch_action) 
   {
      case 1: 
         InformPullClient(pSocket, "OPEN TRADE Instruction Received");
         // IMPLEMENT OPEN TRADE LOGIC HERE
         break;
      case 2: 
         ret = "N/A"; 
         if(ArraySize(compArray) > 1) 
            ret = GetBidAsk(compArray[1]); 
            
         InformPullClient(pSocket, ret); 
         break;
      case 3:
         InformPullClient(pSocket, "CLOSE TRADE Instruction Received");
         
         // IMPLEMENT CLOSE TRADE LOGIC HERE
         
         ret = StringFormat("Trade Closed (Ticket: %d)", ticket);
         InformPullClient(pSocket, ret);
         
         break;
      
      case 4:
         InformPullClient(pSocket, "HISTORICAL DATA Instruction Received");
         
         // Format: DATA|SYMBOL|TIMEFRAME|START_DATETIME|END_DATETIME
         price_count = CopyClose(compArray[1], StrToInteger(compArray[2]), 
                        StrToTime(compArray[3]), StrToTime(compArray[4]), 
                        price_array);
         
         if (price_count > 0) {
            
            ret = "";
            
            // Construct string of price|price|price|.. etc and send to PULL client.
            for(int i = 0; i < price_count; i++ ) {
               
               if(i == 0)
                  ret = compArray[1] + "|" + DoubleToStr(price_array[i], 5);
               else if(i > 0) {
                  ret = ret + "|" + DoubleToStr(price_array[i], 5);
               }   
            }
            
            Print("Sending: " + ret);
            
            // Send data to PULL client.
            InformPullClient(pSocket, StringFormat("%s", ret));
            // ret = "";
         }
            
         break;
         
      default: 
         break;
   }
}

// Parse Zmq Message
void ParseZmqMessage(string& message, string& retArray[]) {
   
   Print("Parsing: " + message);
   
   string sep = "|";
   ushort u_sep = StringGetCharacter(sep,0);
   
   int splits = StringSplit(message, u_sep, retArray);
   
   for(int i = 0; i < splits; i++) {
      Print(i + ") " + retArray[i]);
   }
}

//+------------------------------------------------------------------+
// Generate string for Bid/Ask by symbol
string GetBidAsk(string symbol) {
   
   double bid = MarketInfo(symbol, MODE_BID);
   double ask = MarketInfo(symbol, MODE_ASK);
   
   return(StringFormat("%f|%f", bid, ask));
}

// Inform Client
void InformPullClient(Socket& pushSocket, string message) {

   ZmqMsg pushReply(StringFormat("%s", message));
   // pushSocket.send(pushReply,true,false);
   
   pushSocket.send(pushReply,true); // NON-BLOCKING
   // pushSocket.send(pushReply,false); // BLOCKING
   
}
 

Und hier ist der Code für r

#+------------------------------------------------------------------+
#|                                          ZeroMQ_MT4_R_Template.R |
#|                                    Copyright 2017, Darwinex Labs |
#|                                        https://www.darwinex.com/ |
#+------------------------------------------------------------------+

# Load "rzmq" library. If not installed, run install.packages("rzmq")
library(rzmq)

# Random placeholder for PULL later.
pull.msg <- "N/A"

# Function to send commands to ZeroMQ MT4 EA
remote.send <- function(rSocket,data) {
  send.raw.string(rSocket, data)
  msg <- receive.string(rSocket)
  
  print(msg)
}

# Function to PULL data from ZeroMQ MT4 EA PUSH socket.
remote.pull <- function(pSocket) {

  msg <- receive.socket(pSocket, unserialize = FALSE, dont.wait = TRUE)
  
  if(is.null(msg)) {
    msg <- "No data PUSHED yet.."
    print(msg)
  } else {
    msg <- rawToChar(msg)
    print(msg)  
  }

  return(msg)
}

# CREATE ZeroMQ Context
context = init.context()

# Initialize ZeroMQ REQ Socket
reqSocket = init.socket(context,"ZMQ_REQ")

# Initialize ZeroMQ PULL Socket
pullSocket = init.socket(context, "ZMQ_PULL")

# Connect to REQ Socket on port 5555
connect.socket(reqSocket,"tcp://localhost:5555")

# Connect to PULL Socket on port 5556
connect.socket(pullSocket,"tcp://localhost:5556")

# Run Tests
while(TRUE) {
  
  # REMEMBER: If the data you're pulling isn't "downloaded" in MT4's History Centre,
  #           it's very likely your PULL will produce no data.
  
  #           So if you're going to be pulling data for a currency pair from MT4,
  #           make sure its data is downloaded, and chart open just in case.
  
  # Pull from server
  remote.pull(pullSocket)
  
  f <- file("stdin")
  open(f)
  
  print("Enter Command for MetaTrader 4 ZeroMQ Server, 'q' to quit")
  # e.g. RATES|EURUSD -> Retrieves Current Bid/Ask for EURUSD from MT4.
  mt4.command <- readLines(f, n=1)
  
  if(tolower(mt4.command) == "q") {
    break
  }
  
  # Send to ZeroMQ MetaTrader 4 Server
  if(!grepl("PULL", mt4.command))
    remote.send(reqSocket, mt4.command)
  
  # Pull from ZeroMQ MetaTrader 4 Server
  pull.msg <- remote.pull(pullSocket)
}
1...893894895896897898899900901902903904905906907...3399
Neuer Kommentar