L'apprentissage automatique dans la négociation : théorie, modèles, pratique et algo-trading - page 900

Nouveau commentaire
 
Alexander Ivanov:

vous avez votre graal prêt ? avec une IA))

eh bien c'est ça... vous êtes déjà des oligarques ;))

Bien sûr, Maximko atteint toujours son but.

 
Maxim Dmitrievsky:

Bien sûr, Maximko fait toujours son travail.

)))

c'est tout... On abandonne tous nos robots, on fait la queue pour le robot intelligent.

 
Alexander Ivanov:

)))

c'est tout... on laisse tomber tous nos robots, on fait la queue pour le robot intelligent.

Je suis déjà à mi-chemin du bunker suisse avec des gardes paramilitaires, suivant Alexandre avec ses sacs poussiéreux remplis de notes, n'en parlons pas !

 
Maxim Dmitrievsky:

Alexander_K2 d'un autre fil de discussion

Je ne peux pas vraiment travailler avec python, je dois juste utiliser python pour la visualisation et la vérification immédiate... Maintenant je considère la possibilité d'appeler le shell python directement par winapi et d'envoyer des commandes à python depuis le bot, je ne sais pas si c'est possible. R et dll ne digèrent pas et ne savent pas comment et ne veulent pas travailler avec eux, bien que le python n'est pas nécessaire (en regardant les articles et le travail des anciens) de moins en moins envie d'entrer dans le vif du sujet - 500000 paquets et la sortie est la même que celle du bot sur 2 MA

Se lier à un tel monstre serait utile pour beaucoup, mais pas pour tous ceux qui sont en dessous de la force.

Si je voulais utiliser 10 MA avec un pas de 16 et faire un prédicteur - pour chaque prix ouvert au-dessus/au-dessous d'une MA et un de plus - le nombre de MA en numérotant toutes les MA du haut vers le bas, ce serait un modèle qui décrit le marché.

 
Maxim Dmitrievsky:

J'ai fait une petite expérience en laissant tomber des modèles entiers (10 modèles au total sont donnés). En avant à partir de 2018.04.01

Sans abandon :

Plus loin, on a marqué avec des chiffres combien de modèles aléatoires sont restés, le reste a été abandonné :

Eh bien, en quelque sorte, c'est ce qu'il s'avère être. Probablement pas très révélateur, car le modèle s'est avéré assez bien sans décrochage. Et les modèles sont trop similaires les uns aux autres, ce qui est mauvais, il faut revoir l'algorithme d'apprentissage (la théorie des jeux pour aider). Mais une certaine flexibilité de choix est tout de même apparue.

Ça a l'air bon ! S'arrêter à un (1 modèle).

 
Aleksey Vyazmikin:

Se lier à un tel monstre serait utile pour beaucoup, mais peu peuvent le faire.

Et en ce qui concerne les MAs, je m'endormais juste en pensant, que si nous prenons 10 MAs avec 16 étapes et faisons un prédicteur - pour chacune - le prix ouvert au-dessus/au-dessous de la MA et un de plus - le nombre de MAs en numérotant toutes les MAs du haut vers le bas du graphique, est-ce qu'un tel modèle décrira le marché ?

Ce n'est pas la façon de poser la question. Des expériences, des expériences... ...parce que rien en théorie n'est évident. En six mois, j'ai essayé une centaine de variantes différentes de TS, et c'est effrayant d'y penser.

L'historique de la branche stocke un grand nombre d'informations sur la façon de ne pas faire (et parfois sur la façon de faire) tout à fait utiles.

 
Aleksey Vyazmikin:

Se lier à un tel monstre serait utile pour beaucoup, mais peu peuvent le faire.

Qu'en est-il des MAs, j'y pensais juste en m'endormant. Et si je prends 10 flèches avec 16 étapes et que je fais un prédicteur - pour chaque prix ouvert au-dessus/au-dessous de la MA et un de plus - le nombre de MAs en comptant toutes les MAs du haut vers le bas du graphique, un tel modèle décrira-t-il le marché ?

Il y a eu un article il y a environ 10 ans sur une telle expérience avec des МА de 2 à 100.
 
elibrarius:
Un article paru il y a une dizaine d'années présentait une telle expérience avec des MA de 2 à 100.

Et je crois que ça s'appelle un ventilateur, si je ne me trompe pas...

 

Il semble résoudre tous les problèmes de communication mql4 avec des langues différentes. Il existe même un code pour R. Voici le schéma.



L'ensemble de la description est en trois parties :

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/

Approuvé :

Pourquoi ZeroMQ ?

1.permet aux programmeurs de connecter tout code à tout autre code, de plusieurs façons.

2.élimine la dépendance d'un utilisateur deMetaTrader à l'égard de la seule technologie supportée par MetaTrader (fonctions, indicateurs, constructions de langage, bibliothèques, etc.)

Les traders peuvent développer des indicateurs et des stratégies en C/C#/C++, Python, R et Java (pour n'en citer que quelques-uns), et les déployer sur le marché via MetaTrader 4.

Exploiter les boîtes à outils d'apprentissage automatique en Python et R pour l'analyse de données complexes et le développement de stratégies, tout en assurant l'interface avec MetaTrader 4 pour l'exécution et la gestion des transactions.

5.ZeroMQ peut être utilisé comme une couche de transport haute performance dans des systèmes de trading sophistiqués et distribués, autrement difficiles à mettre en œuvre dans MQL. 6.

Lesdifférents composants de la stratégie peuvent être construits dans différents langages, si nécessaire, et communiquer entre eux de manière transparente via des protocoles TCP, in-process, inter-process ou multicast.

7.modèles de communication multiples et fonctionnement déconnecté.

Voici le 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
   
}
 

Et voici le code pour 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
Nouveau commentaire