Discussão do artigo "Redes neurais: Da teoria à prática" - página 6

Novo comentário
 
fyords: É claro que não me oponho a discutir as sutilezas das redes neurais neste tópico, mas, originalmente, o artigo foi planejado para iniciantes. Ele omite alguns detalhes, porque esses mesmos detalhes podem confundir um networkista neural novato. É claro que o artigo não especifica vários métodos de treinamento (ajuste) de redes neurais, mas isso não é necessário no estágio inicial. Se você perceber que as redes neurais não são tão difíceis assim, isso não lhe dará uma desculpa para se afastar e dizer "isso é muito difícil e não é para mim". Se você sabe mais, isso é ótimo, mas o artigo provavelmente não é para você.

Até agora, foi a ausência dos detalhes sobre os quais perguntei acima que me deixou, como um manequim comum, em um estado de estupor. Reli o artigo três vezes, mas só encontrei as respostas necessárias no fórum.

fyords: No momento, a segunda parte abordará o trabalho com redes neurais multicamadas. Se você tiver alguma dúvida sobre o conteúdo, escreva-a brevemente.
Apenas uma pergunta é de interesse: como criar um programa de autoaprendizagem que possa dispensar o uso de um otimizador "externo". Se isso for possível neste estágio, é claro.
 
fyords:

Após algumas deliberações, decidiu-se escrever a segunda parte do artigo.

No momento, a segunda parte abordará o trabalho com redes neurais multicamadas.
Se tiver alguma sugestão sobre o conteúdo, escreva-a brevemente.
As ideias que eu conseguir transmitir com meus dedos serão descritas no artigo.

Obrigado.

Gostaria de ver o método de aprendizado gradiente descrito nos dedos.
 
Yedelkin:

Eu "presumo ingenuamente" que, entre os falantes nativos de russo, não é comum chamar o processo de aprendizado independente de "ajuste de parâmetros". Da mesma forma, não é aceito chamar a seleção de parâmetros (com a ajuda de processos externos) para qualquer sistema como aprendizado.

Não importa como você chame o ajuste, ele não deixará de ser ajuste.

Otimização, ajuste e aprendizado para redes neurais que lidam com dados não estacionários são sinônimos. Porque todos os três termos significam a mesma coisa: seleção de coeficientes de ponderação para dados históricos passados (amostra de treinamento) a fim de minimizar os erros na saída da rede neural. Se fosse possível alimentar a rede com dados futuros, a situação seria diferente. Mas ainda não se vendem máquinas do tempo em lojas de equipamentos de escritório, portanto, temos que nos adaptar ao passado.

 
Reshetov:

Seja qual for o nome que você dê a uma adaptação, ela não deixará de ser uma adaptação.

O retreinamento é definido de forma elementar. Portanto, não há nada para culpar o espelho.
 
Yedelkin:

Apenas uma questão é de interesse: como criar um programa de autoaprendizagem que possa dispensar o uso de um otimizador "externo". Se isso for possível neste estágio, é claro.

É simples. O código EA pode conter a própria rede e seu otimizador de pesos, que pode ser iniciado automaticamente quando novos dados chegam. Em redes neurais, na maioria dos casos, estamos nos referindo a essas redes de autoaprendizagem. As redes treinadas externamente, por exemplo, pelo otimizador do testador, são brinquedos.

 
Pessoal, me ajudem! Eu entendi corretamente que a normalização dos dados de entrada deve ser feita para todo o período de treinamento da rede? Quero dizer, os valores máximo e mínimo de xi devem ser obtidos em todo o período?
 
net:
Pessoal, me ajudem! Eu entendi corretamente que a normalização dos dados de entrada deve ser feita para todo o período de treinamento da rede? Quero dizer, os valores máximo e mínimo de xi devem ser extraídos de todo o período?
Isso é necessário em toda a amostra de treinamento.
  
//+------------------------------------------------------------------+
//|macd-neuro-example.mq5
//| Copyright 2012, MetaQuotes Software Corp.
//|http://www.mql5.com
//+------------------------------------------------------------------+
#property copyright "Copyright 2012, MetaQuotes Software Corp."
#property link      "http://www.mql5.com"
#property version   "1.00"
//+------------------------------------------------------------------+
//| Função de inicialização de especialista|
//+------------------------------------------------------------------+

#define SIZE 1000

#include <Trade\Trade.mqh>        //conectar a biblioteca para realizar operações comerciais
#include <Trade\PositionInfo.mqh> //conectar a biblioteca para obter informações sobre posições
#include <Indicators/TimeSeries.mqh>

//--- valores dos coeficientes de ponderação 
input double w0=0.5;
input double w1=0.5;
input double w2=0.5;
input double w3=0.5;
input double w4=0.5;
input double w5=0.5;
input double w6=0.5;
input double w7=0.5;
input double w8=0.5;
input double w9=0.5;
input double w10=0.5;
input double w11=0.5;
input double w12=0.5;

string            my_symbol;         // variável para armazenar o caractere
double            inputsH[13];        // matriz para armazenar sinais de entrada
double            inputsL[13];        // matriz para armazenar sinais de entrada
int               periods[13]={2,3,5,8,13,21,34,55,89,144,233,377,610};
int B,Ba;
double            weight[13];        // matriz para armazenar os coeficientes de peso
double High[SIZE],Low[SIZE];

CTrade            m_Trade;           // objeto para realizar operações comerciais
CPositionInfo     m_Position;        // objeto para informações de posição
//+------------------------------------------------------------------+
//||
//+------------------------------------------------------------------+
int OnInit()
  {

   weight[0]=w0;
   weight[1]=w1;
   weight[2]=w2;
   weight[3]=w3;
   weight[4]=w4;
   weight[5]=w5;
   weight[6]=w6;
   weight[7]=w7;
   weight[8]=w8;
   weight[9]=w9;
   weight[10]=w10;
   weight[11]=w11;
   weight[12]=w12;

   my_symbol=Symbol();
   B=Bars(my_symbol,0);

//--- retorno 0, inicialização concluída
   return(0);
  }
//+------------------------------------------------------------------+
//| Função de desinicialização de especialista|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {  }
//+------------------------------------------------------------------+
//| Função de tique de especialista|
//+------------------------------------------------------------------+
void OnTick()
  {

   double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);                   // melhor oferta para comprar
   double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);                   // melhor oferta para venda

   B=Bars(my_symbol,0);
   if(B!=Ba)
     {
      CiHigh hi;
      CiLow li;
      hi.Create(_Symbol,_Period);
      li.Create(_Symbol,_Period);
      hi.GetData(0,SIZE,High);
      li.GetData(0,SIZE,Low);
     }
   Ba=B;

     {
      for(int i=0; i<13; i++)
        {
         int HB = ArrayMaximum(High,SIZE-periods[i],periods[i]);
         int LB = ArrayMinimum(Low, SIZE-periods[i],periods[i]);
         if(Bid>=High[HB]) inputsH[i] =1;
         else inputsH[i]=0;
         if(Bid<=Low[LB]) inputsL[i]=1;
         else inputsL[i]=0;
        }

      double outH=CalculateNeuron(inputsH,weight);
      double outL=CalculateNeuron(inputsL,weight);

      //--- se o valor de saída do neurônio for menor que 0
      if(outL>0)
        {
         //--- se já houver uma posição para esse caractere
         if(m_Position.Select(my_symbol))
           {
            //--- e o tipo dessa posição é Sell, então feche-a
            if(m_Position.PositionType()==POSITION_TYPE_SELL) m_Trade.PositionClose(my_symbol);
            //--- e se o tipo dessa posição for Buy, então saia.
            if(m_Position.PositionType()==POSITION_TYPE_BUY) return;
           }
         //--- se você chegou aqui, não há nenhuma posição, abra-a.
         m_Trade.Buy(0.1,my_symbol);
        }
      //--- se o valor de saída do neurônio for maior ou igual a 0
      if(outH>0)
        {
         //--- se já houver uma posição para esse caractere
         if(m_Position.Select(my_symbol))
           {
            //--- e o tipo dessa posição é Buy, então feche-a
            if(m_Position.PositionType()==POSITION_TYPE_BUY) m_Trade.PositionClose(my_symbol);
            //--- e se o tipo dessa posição for Sell, então saia.
            if(m_Position.PositionType()==POSITION_TYPE_SELL) return;
           }
         //--- se você chegou aqui, não há nenhuma posição, abra-a.
         m_Trade.Sell(0.1,my_symbol);
        }

      if(outH>0.0 || outL>0) Print(outH,"    ",outL);
     }

  }
//+------------------------------------------------------------------+
//|| Função de cálculo do neurônio|
//+------------------------------------------------------------------+
double CalculateNeuron(double &inputs[],double &w[])
  {
//--- variável para armazenar a soma ponderada dos sinais de entrada
   double NET=0.0;
//--- no loop pelo número de entradas, obtenha a soma média ponderada das entradas
   for(int n=0;n<ArraySize(inputs);n++)
     {
      NET+=inputs[n]*w[n];
     }
//--- multiplicar a soma média ponderada dos inputs pelo fator aditivo
   return(ActivateNeuron(NET));
  }
//+------------------------------------------------------------------+
//|| Função de ativação do neurônio|
//+------------------------------------------------------------------+
double ActivateNeuron(double x)
  {
//--- variável para armazenar o resultado da função de ativação
   double Out;
//--- função tangente hiperbólica
   Out=(exp(x)-exp(-x))/(exp(x)+exp(-x));
//--- retorna o valor da função de ativação
   return(Out);
  }
//+------------------------------------------------------------------+

Eu escrevi essa coruja. Podemos dizer que se trata de uma rede neural, pois tenho minhas dúvidas.

Coruja para negociação no canal.

O algoritmo é o seguinte: os extremos são tomados para o número de barras Fibo (2,3,5,8,13....). Para cada neurônio comprar, por exemplo, se o preço estiver abaixo ou igual ao preço do extremo BAIXO por um período, o retorno será 1, caso contrário, será 0. Além disso, como no exemplo com o NeuronMACD. Para vender - espelhar o oposto.

Estou aguardando críticas sobre o código e o algoritmo.

 
dimeon:

Eu escrevi essa coruja. Podemos dizer que é uma rede neural, pois tenho minhas dúvidas.

Coruja para negociação no canal.

O algoritmo é o seguinte: os extremos são tomados para o número de barras Fibo (2,3,5,8,13....). Para cada neurônio comprar, por exemplo, se o preço estiver abaixo ou igual ao preço do extremo BAIXO por um período, o retorno será 1, caso contrário, será 0. Além disso, como no exemplo com o NeuronMACD. Para vender - espelhar o oposto.

Estou aguardando as críticas sobre o código e o algoritmo.

No seu caso, a função de ativação do neurônio pode ser descartada, pois é um freio desnecessário.
return(NET);
Não se trata de uma rede neural, é apenas um perceptron. Você precisa de pelo menos dois perceptrons para uma rede.
 
her.human:
No seu caso, a Função de Ativação de Neurônios pode ser descartada, um freio desnecessário.
return(NET);
Não se trata de uma rede neural, é apenas um perceptron. Você precisa de pelo menos dois perceptrons para uma rede.
Você pode me dar um exemplo, como adicionar uma média móvel ou outro indicador ou qualquer outra coisa, e como colocar tudo isso em rede?
1234567891011
Novo comentário