Reti neurali, come padroneggiarle, da dove cominciare? - pagina 17

Nuovo commento
 
Andrey4-min писал(а) >>

Nel tuo esempio hai w1 in tutte e tre le linee, dovrebbe essere così?

No, ho fatto un errore. Mi dispiace.

Sto cercando di capire quale funzione eseguirà w0, e si presume che sia come un passo nella storia, sapete, come nei loop, se no, spiegate meglio...

Immaginate di dover considerare la struttura superficiale di una tavola inchiodata sul tetto di una casa. Cosa faresti tu? Esatto, si sale sul tetto e si esamina tutto da vicino. Se tale compito viene dato al nostro NS, lo eseguirà con responsabilità, non andrà sotto il tetto, ma studierà la tavola insieme a tutta la casa che ha la tavola sul tetto!

Quindi, per escludere il lavoro inutile del NS (e l'apprendimento, il processo è molto dispendioso in termini di risorse), introduciamo un ingresso "extra" con un offset fisso. Ora guardate: NS nel processo di apprendimento stesso selezionerà il peso necessario a questo input (+/-1 o altro), è equivalente al fatto che metterete una scala alla casa per salire alla vostra tavola di interesse! Ora, il NS non frugherà nella montagna di informazioni inutili, ma semplicemente, con un facile movimento, prenderà una posizione comoda (nella sua comprensione) per un ulteriore comodo apprendimento.

  
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;
Se entriamo in base ai risultati della barra 1, allora 
w6=(High[0]-Low[0])/Point*(Close[0]-Open[0])/Point;

si formerà dopo l'apertura del trade, cioè questa entrata (w6) non può influenzare in alcun modo la qualità del trade aperto.

Se ho capito bene, w6 viene introdotto per rilevare da che parte si è mosso il prezzo dopo l'apertura di un trade in base all'analisi delle cinque barre precedenti (w1, w2, w3, w4, w5).

 

Entreremo in base ai risultati dell'analisi delle cinque barre formate. Pertanto, la barra zero non sarà usata come barra d'entrata.

Giusto:

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;

Introduciamo i coefficienti di normalizzazione per le serie High-Low - HL e per le serie Close-Open - CO. Definiamoli come una deviazione standard dagli incrementi corrispondenti con la finestra di media, per esempio 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);

Eseguiamo una funzione di normalizzazione (mappa l'intero asse numerico in 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);
}

Poi gli ingressi normalizzati per il NS saranno contati come segue:

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

Un'altra cosa. w1...w5 non sono input NS, sono pesi che possono essere impostati durante il processo di circoncisione. Gli ingressi saranno indicati come d1, d2... d5
 

normalizzazione dell'entrata = candela in pip

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, useremo la normalizzazione "fine" (dove il segmento +/-1 sarà riempito uniformemente). Questa è una questione di principio.
 

Neutron, grazie ancora per una spiegazione così dettagliata.

Probabilmente passerò 60 minuti su quello che hai appena scritto, quindi se non è troppo disturbo guarda questo argomento tra un'ora.

Se mi interessa, posso inviarvi i grafici con la descrizione dell'algoritmo EA e la descrizione dei coefficienti non di rete.

 

Onestamente non sono un fan della comunicazione privata. Se non ci sono restrizioni di principio, è meglio comunicare qui. Inoltre, potrei perdere interesse in questo argomento (non si sa mai), quindi non mi impegno a mantenerlo obbligatorio:-)

Affare fatto?

 
Neutron писал(а) >>
Korey, useremo una normalizzazione "sottile" (dove il segmento +/-1 sarà riempito uniformemente). Questa è una questione di principio.

anche questo si riempie uniformemente, ma non c'è curvatura ai bordi, cioè la versione antica non è una mappatura completa in un segmento

 
Korey писал(а) >>

anche questo si riempie uniformemente, ma non ci sono pieghe ai bordi, cioè la versione antica non è una mappatura completa in una sezione

Sì, ma abbiamo bisogno di tutto in una volta!

 
Neutron >> :

Onestamente non sono un fan della comunicazione privata. Se non ci sono restrizioni di principio, è meglio comunicare qui. Inoltre, potrei perdere interesse in questo argomento (non si sa mai), quindi non mi impegno a mantenerlo obbligatorio:-)

Abbiamo un accordo?

>> Affare fatto.

//+------------------------------------------------------------------+
//| 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
Nuovo commento