Les réseaux neuronaux, comment les maîtriser, par où commencer ? - page 17

Nouveau commentaire
 
Andrey4-min писал(а) >>

Vous avez w1 dans les trois lignes de votre exemple, devrait-il l'être ?

Non, j'ai fait une erreur. Je suis désolé.

J'essaie de comprendre quelle fonction w0 va remplir, et j'ai supposé que c'est comme une étape dans l'histoire, vous savez, comme dans les boucles, si non, expliquez plus...

Imaginez que vous deviez examiner la texture de la surface d'une planche clouée sur le toit d'une maison. Que feriez-vous ? C'est ça, tu montes sur le toit et tu examines tout de près. Si une telle tâche est confiée à notre NS, il l'accomplira avec responsabilité, il ne passera pas sous le toit, mais étudiera le tableau avec toute la maison qui a le tableau sur son toit !

Ainsi, pour exclure tout travail inutile du SN (et l'apprentissage, le processus est très gourmand en ressources), nous introduisons une entrée "supplémentaire" avec un décalage fixe. Maintenant, regardez : NS dans le processus d'apprentissage lui-même va sélectionner le poids nécessaire à cette entrée (+/-1 ou autre), c'est équivalent au fait que vous allez mettre une échelle à la maison afin de monter à votre tableau d'intérêt ! Maintenant, le SN ne va pas fouiller dans la montagne d'informations inutiles, mais simplement, par un mouvement facile, prendre une position confortable (dans sa compréhension) pour un apprentissage plus confortable.

  
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 nous entrons sur la base des résultats de la barre 1, alors 
w6=(High[0]-Low[0])/Point*(Close[0]-Open[0])/Point;

sera formé après l'ouverture de la transaction, c'est-à-dire que cette entrée (w6) ne peut en aucun cas influencer la qualité de la transaction ouverte.

Si je comprends bien, w6 est introduit pour détecter dans quelle direction le prix a bougé après l'ouverture d'un trade en se basant sur l'analyse des cinq barres précédentes (w1, w2, w3, w4, w5) ?

 

Nous entrerons en fonction des résultats de l'analyse des cinq barres formées. Par conséquent, la barre de zéro ne sera pas utilisée comme barre d'entrée.

Bien :

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;

Introduisons des coefficients de normalisation pour les séries High-Low - HL et pour les séries Close-Open - CO. Définissons-les comme un écart type par rapport aux incréments correspondants avec la fenêtre de calcul de la moyenne, par exemple 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);

Exécutons une fonction de normalisation (qui transforme l'ensemble de l'axe numérique en un segment +/-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);
}

Ensuite, les entrées normalisées pour le NS seront comptées comme suit :

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

Une dernière chose. w1...w5 ne sont pas des entrées NS, ce sont des poids qui peuvent être ajustés pendant le processus de circoncision. Les entrées seront désignées par d1, d2... d5
 

normalisation de l'entrée = bougie 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, nous utiliserons la normalisation "fine" (où le segment +/-1 sera rempli uniformément). C'est une question de principe.
 

Neutron, merci encore pour cette explication si détaillée.

Je vais probablement passer 60 minutes sur ce que vous venez d'écrire, alors si cela ne vous dérange pas trop, examinez ce sujet dans une heure.

Si cela m'intéresse, je peux vous envoyer les graphiques avec la description de l'algorithme EA et la description des coefficients hors réseau.

 

Honnêtement, je ne suis pas un fan de la communication privée. S'il n'y a pas de restrictions de principe, il est préférable de communiquer ici. De plus, il se peut que je perde tout intérêt pour ce sujet (juste au cas où), donc je ne m'engage pas à le garder obligatoirement :-)

Un accord ?

 
Neutron писал(а) >>
Korey, nous utiliserons la normalisation "fine" (lorsque le segment +/-1 sera rempli uniformément). C'est une question de principe.

elle se remplit également de manière régulière, mais il n'y a pas de courbure sur les bords, c'est-à-dire que l'ancienne version n'est pas une cartographie complète dans un segment.

 
Korey писал(а) >>

cette version se remplit également de manière uniforme, mais il n'y a pas de plis sur les bords, c'est-à-dire que l'ancienne version n'est pas une cartographie complète dans une section

Oui, mais nous avons besoin de tout en même temps !

 
Neutron >> :

Honnêtement, je ne suis pas un fan de la communication privée. S'il n'y a pas de restrictions de principe, il est préférable de communiquer ici. De plus, il se peut que je perde tout intérêt pour ce sujet (juste au cas où), donc je ne m'engage pas à le garder obligatoirement :-)

Avons-nous un accord ?

>> Offre.

//+------------------------------------------------------------------+
//| 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
Nouveau commentaire