Berater für neuronale Netze, Erfahrungsaustausch.

Aleksey Vyazmikin 2015.09.02 16:45 #51

Das ist ein interessantes Thema. Ich habe eine Idee, aber eine einfachere. Ich werde erst einmal Fragen stellen :)

Es ist klar, wie man den Einstiegspunkt bestimmt - wir nehmen einen Zick-Zack-Kurs, aber wir müssen wissen, was vor dem Punkt war, um den Einstieg vorherzusagen. Welches Fenster in den Balken wird für die Analyse der vorangegangenen Daten verwendet?

Haben Sie versucht, die Eingabe- und Ausgabefunktionen zu trennen? Oder ist eine Umkehrung - das Eintreffen des gegenteiligen Signals - üblich? Was wäre das Ergebnis, wenn anstelle eines Ausstiegs aus einem Flip andere Möglichkeiten der Gewinn-/Verlustfeststellung genutzt würden?

Numerische Reihendichte Abenteuer eines Neulings Gunn, Astromechanik. Prognosen, Diskussion

Anton Govorukhin 2015.09.02 20:44 #52

Habe gestern mit dem Neuroner in der Demo begonnen https://www.mql5.com/ru/signals/129790 Scheint soweit in Ordnung zu sein.

[Gelöscht] 2015.09.02 21:30 #53

-Aleks-:

Das ist ein interessantes Thema. Ich habe eine Idee, aber eine einfachere. Ich werde erst einmal Fragen stellen :)

Es ist klar, wie man den Einstiegspunkt bestimmt - wir nehmen einen Zickzackkurs, aber wir müssen wissen, was vor dem Punkt war, um den Einstieg vorherzusagen. Welches Fenster in den Balken wird für die Analyse der vorangegangenen Daten verwendet?

Haben Sie versucht, die Eingabe- und Ausgabefunktionen zu trennen? Oder ist die Umkehrung - das Eintreffen des entgegengesetzten Signals - üblich? Was wäre das Ergebnis, wenn anstelle eines Ausstiegs aus einem Flip andere Möglichkeiten der Gewinn-/Verlustfeststellung genutzt würden?

Ich habe versucht, 1 Bar vorwärts zu prognostizieren, d.h. eine Verschiebung um 1 Bar zurück. Aber das Problem ist, dass das Zickzack auf den letzten Balken mit Werten gefüllt werden muss und es überzeichnet ist, so dass alles nicht so klar ist... Ich benutze immer noch Umkehrsignale zum Öffnen/Eröffnen, oder ich verarsche Martin... Aber das Feld der Forschung ist sehr groß, es ist schwer zu sagen, wie man es richtig macht...

Auftrag automatisch nach einem Lassen Sie uns das [ARCHIV] Alle Fragen von

[Gelöscht] 2015.09.02 21:31 #54

Anton Govorukhin:
Habe den Neuroner in der Demo gestern in Betrieb genommen https://www.mql5.com/ru/signals/129790 Scheint bis jetzt in Ordnung zu sein.

Cool, mal sehen... was ist die Grundlage dafür?

Anton Govorukhin 2015.09.02 21:47 #55

Maxim Dmitrievsky:
Прикольно, понаблюдаемс.. а что в основу заложено?
Объемы, открытый интерес, баланс сил на рынке.

[Gelöscht] 2015.09.03 03:40 #56

Bislang ist noch nichts Interessantes herausgekommen. Der Code und die Logik können Fehler enthalten. Ich schreibe nur, um das Thema sozusagen weiterzuentwickeln, vielleicht ändert es jemand für sich selbst oder korrigiert meine Fehler.

Ich habe die wichtigsten Momente im Code korrigiert. Prognosebalken - Vorhersagetiefe, wie viele Balken vorausgeschaut werden sollen. Dann die Länge des Feldes für das Gittertraining und die Anzahl der Trainingsepochen. 30 Neuronen, können Sie es im Code ändern.

//+------------------------------------------------------------------+
//|                                                      zzNeuro.mq5 |
//|                                                 max dmitrievsky  |
//|                        https://www.mql5.com/ru/users/dmitrievsky |
//+------------------------------------------------------------------+
#property copyright "Copyright 2015, MetaQuotes Software Corp."
#property link      "https://www.mql5.com"
#property version   "1.00"
#include <Trade\Trade.mqh>        
#include <Trade\PositionInfo.mqh> 
#include <Trade\AccountInfo.mqh>
#include "class_mlp.mqh"
CTrade            m_Trade;
CPositionInfo     m_Position;
CNetMLP *net;

input double MaximumRisk=0.01;
input int ZZperiod = 300;
input int PrognozBars = 30;

input int vectorLength = 1000;
input int epoch = 10000;

int    zz_handle, RSI_handle, MA1_handle, MA2_handle; //хендлы индикаторов
double a1[],a2[],a3[],a4[],a5[],ma1[],ma2[],MAbuff[],zzH[],zzL[]; //массивы индикаторов
double inputs[], outputs[]; //массивы для нейросети
bool   learn;
double in[6],out[1]; //количество входов и выходов нейросети
int    snn[]={70,1}; // параметры нейросети

double min,max, minMA, maxMA; //переменные для нормировки данных входящих векторов

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- инициализируем хендлы индикаторов
   learn=false;
   zz_handle=iCustom(Symbol(),0,"zz",ZZperiod);
   RSI_handle=iRSI(Symbol(),0,14,PRICE_CLOSE);
   MA1_handle=iMA(Symbol(),0,200,0,MODE_SMA,PRICE_CLOSE);
   MA2_handle=iMA(Symbol(),0,20,0,MODE_SMA,PRICE_CLOSE);
   
//---
   return(INIT_SUCCEEDED);
  }
  
void FillZZarray(double &a[]) //заполняем массив выходов для нейросети с индикатора зигзаг. Присваиваем значения зигзага каждому бару.
{                             //1 растущий, -1 падающий.
  ArrayResize(a,vectorLength); 
    
   int lastcountbar = 0;
   for(int i=0;i<vectorLength;i++)
     {
      if(zzH[i]>0)  
       {
        a[i]=1; lastcountbar = 1;
       }    
      if(zzL[i]>0) 
       {
        a[i]=-1; lastcountbar = -1;  
       } 
      if(zzH[i]==0 && zzL[i]==0) a[i] = lastcountbar;
     }
}
 
void NormalizeArrays(double &a[]) //нормируем входные данные для рси
  {
   double d1=-1.0;
   double d2=1.0;

   double x_min=a[ArrayMinimum(a)];
   double x_max=a[ArrayMaximum(a)];
   min = x_min;
   max=x_max;

   for(int i=0;i<ArraySize(a);i++)
     {
      a[i]=(((a[i]-x_min)*(d2-d1))/(x_max-x_min))+d1;
     }
  }
  
void NormalizeArraysMA(double &a[]) //нормируем входные данные для МА
  {
   double d1=-1.0;
   double d2=1.0;

   double x_min=a[ArrayMinimum(a)];
   double x_max=a[ArrayMaximum(a)];
   minMA = x_min;
   maxMA=x_max;

   for(int i=0;i<ArraySize(a);i++)
     {
      a[i]=(((a[i]-x_min)*(d2-d1))/(x_max-x_min))+d1;
     }
  }
  
void NormalizeArrays2(double &a[]) //нормируем для рси на каждом новом баре
  {
   double d1=-1.0;
   double d2=1.0;

   for(int i=0;i<ArraySize(a);i++)
     {
      a[i]=(((a[i]-min)*(d2-d1))/(max-min))+d1;
     }
  }
  
void NormalizeArrays2MA(double &a[]) //нормируем для МА на каждом новом баре
  {
   double d1=-1.0;
   double d2=1.0;

   for(int i=0;i<ArraySize(a);i++)
     {
      a[i]=(((a[i]-minMA)*(d2-d1))/(maxMA-minMA))+d1;
     }
  }
   
void learnWeb()
  {
   CopyBuffer(zz_handle,0,PrognozBars,vectorLength,zzH);
   CopyBuffer(zz_handle,1,PrognozBars,vectorLength,zzL);
   FillZZarray(outputs); //заполняем массив выходов, предварительно скопировав хай и лоу зигзага.
   
   CopyBuffer(RSI_handle,0,PrognozBars*2+1,vectorLength,a1);
   CopyBuffer(RSI_handle,0,PrognozBars*2+5,vectorLength,a2);
   CopyBuffer(RSI_handle,0,PrognozBars*2+10,vectorLength,a3);
   CopyBuffer(RSI_handle,0,PrognozBars*2+15,vectorLength,a4);
   CopyBuffer(RSI_handle,0,PrognozBars*2+20,vectorLength,a5);
   CopyBuffer(MA1_handle,0,PrognozBars*2+1,vectorLength,ma1);
   CopyBuffer(MA2_handle,0,PrognozBars*2+1,vectorLength,ma2);
   
   ArrayResize(MAbuff,vectorLength);
   for(int i=0;i<ArraySize(ma1);i++) //вычисляем разницу между двумя МА
     {
      MAbuff[i]=ma1[i]-ma2[i];
     }
    NormalizeArrays(a1);
     NormalizeArrays(a2);
      NormalizeArrays(a3);
       NormalizeArrays(a4);
        NormalizeArrays(a5);
         NormalizeArraysMA(MAbuff); //нормируем все входы
   
   int j = 0;
   for(int i=0;i<vectorLength*6;i=i+6) //компануем массив входов для нейросети
     {
       ArrayCopy(inputs,MAbuff,i,j,1);
       ArrayCopy(inputs,a5,i+1,j,1);
       ArrayCopy(inputs,a4,i+2,j,1);
       ArrayCopy(inputs,a3,i+3,j,1);
       ArrayCopy(inputs,a2,i+4,j,1);
       ArrayCopy(inputs,a1,i+5,j,1);      
       j++;
     }      
   ArraySetAsSeries(inputs,true);
   ArraySetAsSeries(outputs,true);
   
  //+------------------------------------------------------------------+
  //| Neuro Learn                                                      |
  //+------------------------------------------------------------------+     
   net=new CNetMLP(ArraySize(snn),snn,ArraySize(in),1);
   net.Learn(vectorLength,inputs,outputs,epoch,1.0 e-8); Print("MSE=",net.mse,"  Epoch=",net.epoch);
  //--- сохранение сети в файл и удаление сети
   int h=FileOpen("test.net",FILE_BIN|FILE_WRITE);
   net.Save(h);
   FileClose(h);
   
   learn=true;
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   delete net;
   FileDelete("test.net");
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
   
  if(learn==false) learnWeb();
//---
   
   if(fn_NEW_BAR()) //запускаем сеть на каждом новом баре, получаем выходы. Торгуем.
   {  
      ArrayResize(a1,1);
      ArrayResize(a2,1);
      ArrayResize(a3,1);
      ArrayResize(a4,1);
      ArrayResize(a5,1);
      ArrayResize(ma1,1);
      ArrayResize(ma2,1);
      ArrayResize(MAbuff,1);
      
      CopyBuffer(RSI_handle,0,1,1,a1);
      CopyBuffer(RSI_handle,0,5,1,a2);
      CopyBuffer(RSI_handle,0,10,1,a3);
      CopyBuffer(RSI_handle,0,15,1,a4);
      CopyBuffer(RSI_handle,0,20,1,a5);
      CopyBuffer(MA1_handle,0,1,1,ma1);
      CopyBuffer(MA2_handle,0,1,1,ma2);
      
      for(int i=0;i<ArraySize(ma1);i++)
      {
       MAbuff[i]=ma1[i]-ma2[i];
      }
       
      NormalizeArrays2(a1);
       NormalizeArrays2(a2);
        NormalizeArrays2(a3);
         NormalizeArrays2(a4);
          NormalizeArrays2(a5);
           NormalizeArrays2MA(MAbuff);
           
      in[0] = MAbuff[0];
      in[1] = a5[0];
      in[2] = a4[0];
      in[3] = a3[0];
      in[4] = a2[0];
      in[5] = a1[0];
      
          
      net.Calculate(in,out); //подаем на вход данные индикаторов на текущем баре, получаем результат на выходе.
     
//+------------------------------------------------------------------+
//| Expert trade function                                            |
//+------------------------------------------------------------------+         
   if(out[0]>0.9) //если на выходе больше этого значения, то покупаем
     {
      double Lot=LotsOptimized();
      double priceBuy=SymbolInfoDouble(Symbol(),SYMBOL_ASK);
      if(m_Position.Select(Symbol()))
        {
         if(m_Position.PositionType()==POSITION_TYPE_SELL) m_Trade.PositionClose(Symbol());
        }
      if(CountPosBuy()==0) m_Trade.PositionOpen(Symbol(),ORDER_TYPE_BUY,Lot,priceBuy,0,0,NULL);
     }
       
   if(out[0]<-0.9) //если ниже, то продаем
     {
      double Lot=LotsOptimized();
      double priceSell=SymbolInfoDouble(Symbol(),SYMBOL_BID);
      if(m_Position.Select(Symbol()))
        {
         if(m_Position.PositionType()==POSITION_TYPE_BUY) m_Trade.PositionClose(Symbol());
        }
      if(CountPosSell()==0) m_Trade.PositionOpen(Symbol(),ORDER_TYPE_SELL,Lot,priceSell,0,0,NULL);
     }
   } 
  }
//+------------------------------------------------------------------+
//| Custom Functions                                                 |
//+------------------------------------------------------------------+
bool fn_NEW_BAR()
  {
   static int nBars=0;
   if(nBars!=Bars(Symbol(),0))
     {
      nBars=Bars(Symbol(),0);
      return(true);
     }
   return(false);
  }
//+------------------------------------------------------------------+
//| Calculate optimal lot size                                       |
//+------------------------------------------------------------------+  
double LotsOptimized()
  {
   CAccountInfo myaccount;
   double lot;
//---- select lot size
   lot=NormalizeDouble(myaccount.FreeMargin()*MaximumRisk/1000.0,1);
//---- return lot size
   if(lot<0.01) lot=0.01;
   if(lot>50) lot=50;
   return(lot);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountPosBuy()
  {
   CPositionInfo myposition;
   int result=0;
   for(int k=0; k<PositionsTotal(); k++)
     {
      if(myposition.Select(_Symbol)==true)
        {
         if(myposition.PositionType()==POSITION_TYPE_BUY)
           {result++;}
         else
           {}
           }
        }
      return(result);
     }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
   int CountPosSell()
     {
      CPositionInfo myposition;
      int result=0;
      for(int k=0; k<PositionsTotal(); k++)
        {
         if(myposition.Select(_Symbol)==true)
           {
            if(myposition.PositionType()==POSITION_TYPE_SELL)
              {result++;}
            else
              {}
              }
           }
         return(result);
        }

[WARNUNG GESCHLOSSEN!] Alle Fragen Fragen von Neueinsteigern zu Jede Anfängerfrage, um das

Rustam Karpunin 2015.09.14 02:26 #57

Meine Herren, wenn Ihre Expert Advisors nicht berücksichtigen die Grundlagen, dann die Wahrscheinlichkeit von Gewinn / Verlust = 50/50 - Spread! Und keine Neuronen in der Expert Advisor wird helfen, weder ihre eigenen noch jemand anderes:)

Vladimir Tkach 2015.09.14 05:49 #58

Rustam Karpunin:
Meine Herren, wenn Ihre Expert Advisors nicht berücksichtigen, die Grundlage, dann die Wahrscheinlichkeit von Gewinn/Verlust = 50/50 - der Spread! Und keine Neuronen in der Expert Advisor wird helfen, weder ihre eigenen noch jemand anderes:)

Wer sagt das?

[Gelöscht] 2015.09.14 10:36 #59

Rustam Karpunin:
Meine Herren, wenn Ihre Expert Advisors nicht lernen, die Grundlagen, die Wahrscheinlichkeit von Gewinn / Verlust = 50/50 - Spread! Und keine Neuronen in der Expert Advisor wird helfen, weder ihre eigenen noch jemand anderes:)

Das ist sehr cool, ich habe begonnen, einige Funktionen der Arbeit mit ihnen zu kaufen, ich habe bereits interessante Ergebnisse, ich werde sie später posten. Ich muss nur viel Zeit aufwenden, um mir eine Strategie zu überlegen.

[ARCHIV] Alle Fragen von FOREX - Trends, Prognosen PPZ-Berechnung - Hilfe zur

Sergey Ponomarev 2015.09.14 11:03 #60

Was ist das?

Berater für neuronale Netze?

Berater für neuronale Netze, Erfahrungsaustausch. - Seite 6