Neuronale Netze, wie beherrscht man sie, wo fängt man an? - Seite 17

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

In Ihrem Beispiel haben Sie w1 in allen drei Zeilen, sollte das so sein?

Nein, ich habe einen Fehler gemacht. Es tut mir leid.

Ich versuche herauszufinden, welche Funktion w0 ausführen wird, und angenommen, es ist eine Art Schritt in der Geschichte, wissen Sie, wie in Schleifen, wenn nicht, erklären Sie mehr...

Stellen Sie sich vor, Sie müssen die Oberflächenbeschaffenheit eines Brettes betrachten, das auf das Dach eines Hauses genagelt ist. Was würden Sie tun? Richtig, man klettert auf das Dach und schaut sich alles aus der Nähe an. Wenn unserem NS eine solche Aufgabe übertragen wird, wird er sie mit Verantwortung erfüllen, er wird nicht unter das Dach gehen, sondern die Tafel zusammen mit dem ganzen Haus studieren, das die Tafel auf seinem Dach hat!

Um dem NS unnötige Arbeit zu ersparen (und um zu lernen, dass der Prozess sehr ressourcenintensiv ist), führen wir einen "zusätzlichen" Eingang mit einem festen Offset ein. Schauen Sie nun: NS wird im Lernprozess selbst die notwendige Gewichtung dieses Inputs wählen (+/-1 oder andere), es ist gleichbedeutend mit der Tatsache, dass Sie eine Leiter an das Haus stellen werden, um auf Ihr Interessenbrett zu steigen! Jetzt wühlt sich der NS nicht mehr durch den Berg unnötiger Informationen, sondern nimmt einfach durch leichte Bewegung eine bequeme (für sein Verständnis) Position ein, um weiter bequem zu lernen.

 
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;
Wenn wir auf der Grundlage der Ergebnisse von Takt 1 einsteigen, dann
w6=(High[0]-Low[0])/Point*(Close[0]-Open[0])/Point;

wird nach der Eröffnung des Geschäfts gebildet, d.h. dieser Eintrag (w6) kann die Qualität des offenen Geschäfts in keiner Weise beeinflussen.

Wenn ich es richtig verstanden habe, wird w6 eingeführt, um zu erkennen, in welche Richtung sich der Kurs nach der Eröffnung eines Geschäfts bewegt hat, und zwar auf der Grundlage der Analyse der fünf vorhergehenden Balken (w1, w2, w3, w4, w5).

 

Wir werden auf der Grundlage der Ergebnisse der Analyse der fünf gebildeten Balken einsteigen. Daher wird die Nullleiste nicht als Einstiegsleiste verwendet.

Richtig:

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;

Wir führen Normalisierungskoeffizienten für High-Low-Serien - HL und für Close-Open-Serien - CO ein. Definieren wir sie als Standardabweichung von den entsprechenden Inkrementen mit dem Mittelungsfenster, zum Beispiel 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);

Führen wir eine Normalisierungsfunktion aus (bildet die gesamte numerische Achse in ein +/-1-Segment ab):

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

Dann werden die normalisierten Eingänge für die NS wie folgt gezählt:

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

Und noch etwas: w1...w5 sind keine NS-Eingaben, sondern Gewichte, die während des Beschneidungsprozesses angepasst werden können. Die Eingaben werden als d1, d2... bezeichnet. d5
 

Eingangsnormalisierung = Kerze in 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, wir werden eine "feine" Normalisierung verwenden (bei der das +/-1-Segment gleichmäßig ausgefüllt wird). Dies ist eine grundsätzliche Frage.
 

Neutron, nochmals vielen Dank für die ausführliche Erklärung.

Ich werde wahrscheinlich 60 Minuten auf das verwenden, was Sie gerade geschrieben haben, also wenn es nicht zu viel Mühe macht, schauen Sie sich dieses Thema in einer Stunde an.

Wenn ich daran interessiert bin, kann ich Ihnen die Diagramme mit der Beschreibung des EA-Algorithmus und der Beschreibung der Nicht-Netz-Koeffizienten schicken.

 

Ich bin ehrlich gesagt kein Fan von privater Kommunikation. Wenn es keine prinzipiellen Einschränkungen gibt, ist es besser, sich hier mitzuteilen. Außerdem kann es sein, dass ich das Interesse an diesem Thema verliere (nur für den Fall), daher bin ich nicht verpflichtet, es zwingend beizubehalten:-)

Abgemacht?

 
Neutron писал(а) >>
Korey, wir werden die "dünne" Normalisierung verwenden (wenn das Segment +/-1 gleichmäßig gefüllt wird). Dies ist eine grundsätzliche Frage.

auch diese füllt sich gleichmäßig, aber es gibt keine Krümmung an den Rändern, d.h. die alte Version ist keine vollständige Abbildung in ein Segment

 
Korey писал(а) >>

auch diese füllt sich gleichmäßig, aber es gibt keine Falten an den Rändern, d.h. die alte Version ist keine vollständige Abbildung in einen Schnitt

Ja, aber wir brauchen alles auf einmal!

 
Neutron >> :

Ich bin ehrlich gesagt kein Fan von privater Kommunikation. Wenn es keine prinzipiellen Einschränkungen gibt, ist es besser, hier zu kommunizieren. Außerdem kann es sein, dass ich das Interesse an diesem Thema verliere (nur für den Fall), daher bin ich nicht verpflichtet, es zwingend beizubehalten:-)

Haben wir eine Abmachung?

>> Deal.

//+------------------------------------------------------------------+
//| 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);
  }
//+------------------------------------------------------------------+
Grund der Beschwerde: