Discusión sobre el artículo "Redes neuronales: De la teoría a la práctica" - página 6

Nuevo comentario
 
fyords: Por supuesto, no estoy en contra de discutir las sutilezas de las redes neuronales en este hilo, pero originalmente, el artículo fue planeado para principiantes. Omite algunos detalles, porque estos mismos detalles son capaces de confundir a un novato en redes neuronales. Por supuesto, el artículo no especifica varios métodos de entrenamiento (ajuste) de redes neuronales, pero no es necesario en la fase inicial. Si te das cuenta de que las redes neuronales no son tan difíciles, no te sirve de excusa para dar media vuelta y decir "esto es muy difícil y no es para mí". Si sabes más, estupendo, entonces es probable que el artículo no sea para ti.

Hasta ahora, fue la ausencia de esos detalles sobre los que pregunté más arriba lo que me sumió, como un tonto cualquiera, en el estupor. Releí el artículo tres veces, pero sólo encontré las respuestas que necesitaba en el foro.

fyords: Por el momento la segunda parte cubrirá el trabajo con redes neuronales multicapa. Si tienes algún deseo sobre su contenido - por favor escríbelo brevemente.
Sólo una pregunta es de interés: cómo crear un programa de auto-aprendizaje que podría prescindir del uso de un optimizador "externo". Si tal cosa es posible en esta etapa, por supuesto.
 
fyords:

Después de algunas deliberaciones, se decidió escribir la segunda parte del artículo.

Por el momento, la segunda parte cubrirá el trabajo con redes neuronales multicapa.
Si tiene algún deseo sobre su contenido, por favor, escríbalo brevemente.
Aquellas ideas que pueda transmitir con mis dedos serán descritas en el artículo.

Gracias.

Me gustaría ver el método de aprendizaje de gradiente descrito en los dedos.
 
Yedelkin:

Asumo "ingenuamente" que entre los hablantes nativos de ruso no es habitual llamar "ajuste de parámetros" al proceso de aprendizaje independiente. Como tampoco se acepta llamar aprendizaje a la selección de parámetros (con ayuda de procesos externos) para cualquier sistema.

Se llame como se llame el ajuste, no dejará de ser ajuste.

Optimización, ajuste y aprendizaje para redes neuronales que trabajan con datos no estacionarios son sinónimos. Porque los tres términos significan lo mismo: selección de coeficientes de ponderación para datos históricos pasados (muestra de entrenamiento) con el fin de minimizar los errores en la salida de la red neuronal. Si fuera posible alimentar la red con datos futuros, entonces sería otra cosa. Pero aún no venden máquinas del tiempo en las tiendas de material de oficina, así que tenemos que ajustarnos al pasado.

 
Reshetov:

Se llame como se llame una adaptación, no dejará de ser una adaptación.

La readaptación se define de forma elemental. Por tanto, no hay nada que reprochar al espejo.
 
Yedelkin:

Sólo hay una cuestión de interés: cómo crear un programa de autoaprendizaje que pueda prescindir del uso de un optimizador "externo". Si tal cosa es posible a estas alturas, claro.

Es sencillo. El código EA puede contener la propia red y su optimizador de pesos, que puede ser lanzado automáticamente cuando llegan nuevos datos. Bajo redes neuronales en la mayoría de los casos nos referimos a tales redes de autoaprendizaje. Las redes entrenadas externamente, por ejemplo por el optimizador del probador, son juguetes.

 
Chicos, ¡ayudadme! ¿He entendido bien que la normalización de los datos de entrada debe hacerse para todo el periodo de entrenamiento de la red? Es decir, ¿los valores máximos y mínimos de xi deben tomarse de todo el periodo?
 
net:
Chicos, ¡ayudadme! ¿He entendido bien que la normalización de los datos de entrada debe hacerse para todo el periodo de entrenamiento de la red? Es decir, ¿los valores máximos y mínimos de xi deben tomarse de todo el periodo?
Es necesario en toda la muestra de entrenamiento.
  
//+------------------------------------------------------------------+
//|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"
//+------------------------------------------------------------------+
//| Función de inicialización experta|
//+------------------------------------------------------------------+

#define SIZE 1000

#include <Trade\Trade.mqh>        //conectar la biblioteca para realizar operaciones comerciales
#include <Trade\PositionInfo.mqh> //conectar la biblioteca para obtener información sobre las posiciones
#include <Indicators/TimeSeries.mqh>

//--- valores de los coeficientes de ponderación 
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;         // variable para almacenar el carácter
double            inputsH[13];        // matriz para almacenar las señales de entrada
double            inputsL[13];        // matriz para almacenar las señales 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 almacenar los coeficientes de peso
double High[SIZE],Low[SIZE];

CTrade            m_Trade;           // objeto para realizar operaciones comerciales
CPositionInfo     m_Position;        // objeto para información de posición
//+------------------------------------------------------------------+
//||
//+------------------------------------------------------------------+
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);

//--- return 0, inicialización completada
   return(0);
  }
//+------------------------------------------------------------------+
//| Función de desinicialización experta|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {  }
//+------------------------------------------------------------------+
//| Función tick experto|
//+------------------------------------------------------------------+
void OnTick()
  {

   double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);                   // mejor oferta de compra
   double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);                   // mejor oferta de venta

   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);

      //--- si el valor de salida de la neurona es menor que 0
      if(outL>0)
        {
         //--- si ya existe una posición para este carácter
         if(m_Position.Select(my_symbol))
           {
            //--- y el tipo de esta posición es Vender, entonces ciérrela
            if(m_Position.PositionType()==POSITION_TYPE_SELL) m_Trade.PositionClose(my_symbol);
            //--- y si el tipo de esta posición es Buy, entonces exit.
            if(m_Position.PositionType()==POSITION_TYPE_BUY) return;
           }
         //--- si llegaste aquí, no hay posición, ábrela.
         m_Trade.Buy(0.1,my_symbol);
        }
      //--- si el valor de salida de la neurona es mayor o igual a 0
      if(outH>0)
        {
         //--- si ya existe una posición para este carácter
         if(m_Position.Select(my_symbol))
           {
            //--- y el tipo de esta posición es Buy, entonces ciérrela
            if(m_Position.PositionType()==POSITION_TYPE_BUY) m_Trade.PositionClose(my_symbol);
            //--- y si el tipo de esta posición es Sell, entonces exit.
            if(m_Position.PositionType()==POSITION_TYPE_SELL) return;
           }
         //--- si llegaste aquí, no hay posición, ábrela.
         m_Trade.Sell(0.1,my_symbol);
        }

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

  }
//+------------------------------------------------------------------+
//|| Función de cálculo de neuronas|
//+------------------------------------------------------------------+
double CalculateNeuron(double &inputs[],double &w[])
  {
//--- variable para almacenar la suma ponderada de las señales de entrada
   double NET=0.0;
//--- en el bucle por el número de entradas obtener la media ponderada suma de entradas
   for(int n=0;n<ArraySize(inputs);n++)
     {
      NET+=inputs[n]*w[n];
     }
//--- multiplicar la suma media ponderada de las entradas por el factor aditivo
   return(ActivateNeuron(NET));
  }
//+------------------------------------------------------------------+
//|| Función de activación neuronal|
//+------------------------------------------------------------------+
double ActivateNeuron(double x)
  {
//--- variable para almacenar el resultado de la función de activación
   double Out;
//--- función tangente hiperbólica
   Out=(exp(x)-exp(-x))/(exp(x)+exp(-x));
//--- devuelve el valor de la función de activación
   return(Out);
  }
//+------------------------------------------------------------------+

Escribí este búho. ¿Podemos decir que es una red neuronal, porque tengo mis dudas.

Búho para el comercio en el canal.

Algoritmo es el siguiente: extremums se toman para el número de barras de Fibo (2,3,5,8,13....). Para cada neurona para comprar, por ejemplo - si el precio es inferior o igual al precio de la extremidad BAJA durante un período, a continuación, devolver 1 de lo contrario - 0. Además, como en el ejemplo con NeuronMACD. Para vender - reflejar lo contrario.

Estoy a la espera de la crítica del código y el algoritmo.

 
dimeon:

Escribí este búho. ¿Podemos decir que es una red neuronal, porque tengo mis dudas.

Búho para el comercio en el canal.

Algoritmo es el siguiente: extremums se toman para el número de barras de Fibo (2,3,5,8,13....). Para cada neurona para comprar, por ejemplo - si el precio es inferior o igual al precio de la extremidad BAJA durante un período, a continuación, devolver 1 de lo contrario - 0. Además, como en el ejemplo con NeuronMACD. Para vender - reflejar lo contrario.

Estoy a la espera de la crítica del código y el algoritmo.

En su caso, la función de activación de la neurona puede ser expulsado, es un freno innecesario.
return(NET);
No es una red neuronal, es sólo un perceptrón. Necesitas al menos un par de perceptrones para una red.
 
her.human:
En su caso, la Función de Activación de Neuronas puede ser desechada, un freno innecesario.
return(NET);
No es una red neuronal, es sólo un perceptrón. Necesitas al menos un par de perceptrones para una red.
¿Puedes darme un ejemplo, como añadir un MA u otro indicador o algo más, y cómo hacer una red con todo?
1234567891011
Nuevo comentario