Conselheiros em redes neurais, compartilhando experiências.

Novo comentário
 

Há poucas informações no fórum sobre soluções prontas e a eficácia das redes neurais para o comércio no mercado. Sugiro discutir e compartilhar experiências aqui. Se já existe um tópico com discussão, por favor, faça um link para ele.

Estou usando classes daqui, simples e multicamadas Perspectron. Espero que as aulas contem corretamente, estou contando com a experiência do autor. Começou a experimentar, interessante :)

No momento em que tenho 11 induks na entrada, a saída é um ziguezagueado deslocado por 1 barra para o futuro.

Estes são os resultados da minha grade de 8 meses. Estou treinando em 1000 barras, 10.000 épocas, 70 neurônios em uma camada oculta. Os sinais são invertidos e puramente por rede neural, sem filtros adicionais. 15 min tf.

 

Código Ziguezague

//+------------------------------------------------------------------+
//|                                                       FastZZ.mq5 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, Yurich"
#property link      "https://login.mql5.com/ru/users/Yurich"
#property version   "1.00"
//+------------------------------------------------------------------+
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots 1
#property  indicator_label1  "ZZ"
#property  indicator_type1   DRAW_ZIGZAG
#property  indicator_color1  clrRed
#property  indicator_style1  STYLE_SOLID
#property  indicator_width1  1
//+------------------------------------------------------------------+
input int Depth=2000; // Minimum points in a ray
//+------------------------------------------------------------------+
double zzH[],zzL[];
double depth;//, deviation;
int last,direction;
//+------------------------------------------------------------------+
void OnInit()
  {
   SetIndexBuffer(0,zzH,INDICATOR_DATA);
   SetIndexBuffer(1,zzL,INDICATOR_DATA);
   IndicatorSetInteger(INDICATOR_DIGITS,Digits());
   PlotIndexSetDouble(0,PLOT_EMPTY_VALUE,0.0);
   PlotIndexSetDouble(1,PLOT_EMPTY_VALUE,0.0);
   depth=Depth*_Point;
//deviation=10*_Point;
   direction=1;
   last=0;
  }
//+------------------------------------------------------------------+
int OnCalculate(const int total,
                const int calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick[],
                const long &real[],
                const int &spread[])
  {
   if(calculated==0) last=0;
   for(int i=calculated>0?calculated-1:0; i<total-1; i++)
     {
      bool set=false;
      zzL[i]=0;
      zzH[i]=0;
      //---
      if(direction>0)
        {
         if(high[i]>zzH[last])//-deviation)
           {
            zzH[last]=0;
            zzH[i]=high[i];
            if(low[i]<high[last]-depth)
              {
               if(open[i]<close[i]) zzH[last]=high[last]; else direction=-1;
               zzL[i]=low[i];
              }
            last=i;
            set=true;
           }
         if(low[i]<zzH[last]-depth && (!set || open[i]>close[i]))
           {
            zzL[i]=low[i];
            if(high[i]>zzL[i]+depth && open[i]<close[i]) zzH[i]=high[i]; else direction=-1;
            last=i;
           }
        }
      else
        {
         if(low[i]<zzL[last])//+deviation)
           {
            zzL[last]=0;
            zzL[i]=low[i];
            if(high[i]>low[last]+depth)
              {
               if(open[i]>close[i]) zzL[last]=low[last]; else direction=1;
               zzH[i]=high[i];
              }
            last=i;
            set=true;
           }
         if(high[i]>zzL[last]+depth && (!set || open[i]<close[i]))
           {
            zzH[i]=high[i];
            if(low[i]<zzH[i]-depth && open[i]>close[i]) zzL[i]=low[i]; else direction=1;
            last=i;
           }
        }
     }
//----
   zzH[total-1]=0;
   zzL[total-1]=0;
   return(total);
  }
//+------------------------------------------------------------------+

Os buffers indicadores contêm apenas valores altos e baixos, eu preencho os dados intermediários no laço, convertendo-os para 1 - subir na barra de corrente, -1 - cair. Parece estar correto, mas se houver erros, por favor, me corrija

void FillZZarray()
{
  ArrayResize(zz,vector);   
   int lastcountbar = 0;
   for(int i=0;i<vector;i++) // Заполняем массив выходов
     {
      if(zzH[i]>0)  
       {
        zz[i]=1; lastcountbar = 1;
        if(i!=0)
          for(int q=i-1;q>=0;q--)
           {
            if(zz[q]==0)zz[q]=lastcountbar;
           } 
       }    
      if(zzL[i]>0) 
       {
        zz[i]=-1; lastcountbar = -1; 
        if(i!=0)
          for(int q=i-1;q>=0;q--)
           {
            if(zz[q]==0)zz[q]=lastcountbar;
           } 
       } 
      if(zzH[i]==0 && zzL[i]==0) zz[i] = lastcountbar;
     }
}
 
Legal! Somente ao colocá-lo no real, troque os sinais de compra e venda.
 
Vladimir Tkach:
Legal! Somente quando você coloca no real, mude as posições dos sinais de compra e venda.
Por quê? )
 
Maxim Dmitrievsky:
Por quê? )
O presságio é este. Após os testes.
 
Vladimir Tkach:
O presságio é este. Após os testes.
A sério, porém, vamos falar sobre isso, se você tem algo a dizer). Não é como se eu estivesse aqui para brincar :)
 
Maxim Dmitrievsky:
Não, sério... vamos falar sobre isso, se você tiver alguma coisa). Não é como se eu estivesse aqui para brincar :)
Experimente este aqui para um tutorial.
Sampler
Sampler
  • votos: 33
  • 2012.06.01
  • Serj
  • www.mql5.com
Индикатор i_Sampler рассчитывает идеальные входы, предназначен для обучения нейросети.
 
Sergey Chalyshev:
Experimente este indutor para treinamento.

Preciso de um vetor de entrada de dados para treinamento, e aqui os sinais são interrompidos - depois comprar, depois vender, depois pular... e não sei como preenchê-los, não com zeros... Não sei como preenchê-los com zeros... Ziguezague, em minha opinião, fornece insumos que não são menos perfeitos, mas posso estar errado... Ainda não sou muito experiente em redes neurais...

 
Maxim Dmitrievsky:

Preciso de um vetor de entrada de dados para treinamento, e aqui os sinais são interrompidos - depois comprar, depois vender, depois pular... e não sei como preenchê-los, não com zeros... Não sei como preenchê-los com zeros, não está claro... O ziguezague, em minha opinião, não oferece entradas menos perfeitas, mas posso estar errado... Ainda não tenho muita experiência em redes neurais...

O indicador tem dois tipos de sinais, discreto e analógico para escolher. Preencher as lacunas com zeros.

A foto no primeiro post está na amostra de treinamento? Se estiver fora da amostra, então é interessante ver na amostra de treinamento, com tantos neurônios a rede deve memorizar de cor todos os dados de entrada.

 
Sergey Chalyshev:

Há dois tipos de sinal no indicador, discreto e analógico para escolher. Preencher as lacunas com zeros.

A foto no primeiro post é uma amostra de treinamento? Se estiver fora da amostra, então é interessante observar a amostra de treinamento, com tantos neurônios a rede deve memorizar de cor todos os dados de entrada.

A amostra de treinamento é a última 1000 barras, ou melhor, a primeira se você olhar de 0 como em séries temporais, tudo antes disso está fora de amostra.

Vou tentar amanhã e ver o que mostra. Até agora, o segundo ziguezagueou, maior, vendo como funciona em 2 saídas. Nada pendente até agora, funciona em média a zero :)

 
Maxim Dmitrievsky:

em média trabalha a zero :)

Por isso, foi sugerido que você passasse da compra para a venda.

Ainda não ouvi falar de ninguém que tenha lucros estáveis em redes neurais, é muito instável. O TS mais simples nos muwings - e eles funcionam mais estáveis.

12345678...10
Novo comentário