Redes neuronales, cómo dominarlas, por dónde empezar - página 17

Nuevo comentario
 
Andrey4-min писал(а) >>

Tienes w1 en las tres líneas de tu ejemplo, ¿debería ser así?

No, he cometido un error. Lo siento.

Estoy tratando de averiguar qué función realizará w0, y supuse que es como un paso en la historia, ya sabes, como en los bucles, si no es así, explica más...

Imagínese que tiene que considerar la textura de la superficie de una tabla clavada en el tejado de una casa. ¿Qué harías tú? Así es, te subes al techo y examinas todo de cerca. Si se le da tal tarea a nuestra SN, la realizará con responsabilidad, no se meterá bajo el techo, sino que estudiará la tabla junto con toda la casa que tiene la tabla en su techo.

Así que, para excluir el trabajo innecesario de la NS (y el aprendizaje, el proceso es muy intensivo en recursos), introducimos una entrada "extra" con un desplazamiento fijo. ¡Ahora mira: NS en el propio proceso de aprendizaje seleccionará el peso necesario a esta entrada (+/-1 u otro), es equivalente al hecho de que usted pondrá una escalera a la casa con el fin de subir a su tabla de interés! Ahora, el NS no rebuscará en la montaña de información innecesaria, sino que simplemente, con un fácil movimiento, adoptará una posición cómoda (en su comprensión) para seguir aprendiendo cómodamente.

  
int    w0=1;
double w1=(High[1]-Low[1])/Point*(Close[1]-Open[1])/Point;
double w2=(High[2]-Low[2])/Point*(Close[2]-Open[2])/Point;
double w3=(High[3]-Low[3])/Point*(Close[3]-Open[3])/Point;
double w4=(High[4]-Low[4])/Point*(Close[4]-Open[4])/Point;
double w5=(High[5]-Low[5])/Point*(Close[5]-Open[5])/Point;
double w6=(High[0]-Low[0])/Point*(Close[0]-Open[0])/Point;
Si entramos en base a los resultados de la barra 1, entonces 
w6=(High[0]-Low[0])/Point*(Close[0]-Open[0])/Point;

se formará después de la apertura de la operación, es decir, esta entrada (w6) no puede influir de ninguna manera en la calidad de la operación abierta.

Si entiendo bien, w6 se introduce para detectar en qué dirección se movió el precio después de abrir una operación basándose en el análisis de las cinco barras anteriores (w1, w2, w3, w4, w5)?

 

Entraremos en función de los resultados del análisis de las cinco barras formadas. Por lo tanto, la barra cero no se utilizará como barra de entrada.

Sí:

double w0=1.;
double w1=(High[1]-Low[1])/Point*(Close[1]-Open[1])/Point;
double w2=(High[2]-Low[2])/Point*(Close[2]-Open[2])/Point;
double w3=(High[3]-Low[3])/Point*(Close[3]-Open[3])/Point;
double w4=(High[4]-Low[4])/Point*(Close[4]-Open[4])/Point;
double w5=(High[5]-Low[5])/Point*(Close[5]-Open[5])/Point;

Introduzcamos los coeficientes de normalización para las series High-Low - HL y para las series Close-Open - CO. Definámoslos como una desviación estándar de los incrementos correspondientes con la ventana de promediación, por ejemplo 100.

double HL=0.;

double CO=0.;

for(i=0;i<100;i++) {

HL=HL+(High[i] -Low[i] )*(High[i] -Low[i] );

CO=CO+(Close[i]-Open[i])*(Close[i]-Open[i]);

}

HL=MathSqrt(HL/100);

CO=MathSqrt(CO/100);

Vamos a ejecutar una función de normalización (mapea todo el eje numérico en un segmento +/-1):

double th(double x)
{
if(MathAbs(x)<100.)S=(MathExp(x)-MathExp(-x))/(MathExp(x)+MathExp(-x));
else S=MathAbs(x)/x;
return(S);
}

Entonces, las entradas normalizadas para el NS se contarán de la siguiente manera:

double d0=1.;
double d1=th((High[1]-Low[1])/HL*(Close[1]-Open[1])/CO);
double d2=th((High[2]-Low[2])/HL*(Close[2]-Open[2])/CO);
double d3=th((High[3]-Low[3])/HL*(Close[3]-Open[3])/CO);
double d4=th((High[4]-Low[4])/HL*(Close[4]-Open[4])/CO);
double d5=th((High[5]-Low[5])/HL*(Close[5]-Open[5])/CO);

Una cosa más. w1...w5 no son entradas NS, son pesos que se pueden ajustar durante el proceso de circuncisión. Las entradas se denotarán como d1, d2... d5
 

normalización de entrada = vela en pips

double a;
int CandleMax=20, CandleMin=-20, Diapazon;
Diapazon= CandleMax- CandleMin;

a=(Close[ i]-Open[ i])/Point;
if( a> CandleMax) a= CandleMax;
if( a< CandleMin) a= CandleMin;
a=( a- CandleMin)/ Diapazon;

P.S. древний вариант
 
Korey, utilizaremos la normalización "fina" (en la que el segmento +/-1 se rellenará uniformemente). Se trata de una cuestión de principios.
 

Neutrón, gracias de nuevo por una explicación tan detallada.

Seguramente dedicaré 60 minutos a lo que acabas de escribir, así que si no es mucha molestia mira este tema en una hora.

Si estoy interesado en esto, puedo enviarle los gráficos con la descripción del algoritmo de EA y la descripción de los coeficientes de no red.

 

Sinceramente, no me gusta la comunicación privada. Si en principio no hay restricciones, es mejor comunicarlo aquí. Además, es posible que pierda el interés en este hilo (por si acaso), así que no me comprometo a mantenerlo obligatoriamente:-)

¿Trato?

 
Neutron писал(а) >>
Korey, utilizaremos la normalización "fina" (cuando el segmento +/-1 se rellena uniformemente). Se trata de una cuestión de principios.

esto también llena uniformemente, pero no hay curvatura en los bordes, es decir, la versión antigua no es un mapeo completo en un segmento

 
Korey писал(а) >>

también se rellena uniformemente, pero no hay pliegues en los bordes, es decir, la versión antigua no es un mapeo completo en una sección

Sí, pero necesitamos todo a la vez.

 
Neutron >> :

Sinceramente, no me gusta la comunicación privada. Si en principio no hay restricciones, es mejor comunicarlo aquí. Además, es posible que pierda el interés en este tema (por si acaso), así que no me comprometo a mantenerlo obligatoriamente:-)

¿Tenemos un trato?

>> Trato.

//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
//----
//Введём нормировочные коэффициенты для ряда High-Low - HL и для ряда Close-Open - CO. 
//Определим их как стандартное отклонение от соответствующих приращений с окном усреднения, например 100.
double HL=0.;

double CO=0.;

for(int i=0; i<100; i++) {

HL= HL+(High[ i] -Low[ i] )*(High[ i] -Low[ i] ); //Эти значения умножаются друг на друга, 
                                             //чтобы в случае если значение будет отрицательным
CO= CO+(Close[ i]-Open[ i])*(Close[ i]-Open[ i]); //при умножении оно стало положительным?

}
HL=MathSqrt( HL/100);//Получилось среднее значение диапазона 100 последних баров
CO=MathSqrt( CO/100);//Получилось среднее значение диапазона между open b close 100 последних баров

//Ведём нормализующую функцию (отображает всю числовую ось в отрезок +/-1):
double th(double x); // что значит эта строчка?
{
if(MathAbs( x)<100.) S=(MathExp( x)-MathExp(- x))/(MathExp( x)+MathExp(- x));
else S=MathAbs( x)/ x;
return( S); // для чего вычислялась S? 
}

//Тогда нормализованные входа для НС будут считаться следующим образом:
double w0=1.; // что значит точка после числа?
double w1= th((High[1]-Low[1])/ HL*(Close[1]-Open[1])/ CO);
double w2= th((High[2]-Low[2])/ HL*(Close[2]-Open[2])/ CO);
double w3= th((High[3]-Low[3])/ HL*(Close[3]-Open[3])/ CO);
double w4= th((High[4]-Low[4])/ HL*(Close[4]-Open[4])/ CO);
double w5= th((High[5]-Low[5])/ HL*(Close[5]-Open[5])/ CO);

//И ещё. w1...w5 это не входа НС, это настраиваемые в процессе её обцчения веса. Входа будем обозначать как d1, d2... d5

   
//----
   return(0);
  }
//+------------------------------------------------------------------+
1...10111213141516171819
Nuevo comentario
Razón de la queja: