Redes neurais, como dominá-las, por onde começar? - página 17

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

Em seu exemplo você tem w1 em todas as três linhas, é assim que deve ser?

Não, eu cometi um erro. Sinto muito.

Estou tentando descobrir qual será a função w0, e assumindo que é como um passo na história, sabe, como em loops, se não, explicar mais...

Imagine que você precisa considerar a textura da superfície de uma tábua pregada no telhado de uma casa. O que você faria? É isso mesmo, você sobe no telhado e examina tudo de perto e pessoalmente. Se tal tarefa for dada ao nosso NS, ele a executará com responsabilidade, não irá para debaixo do telhado, mas estudará o tabuleiro junto com toda a casa que tem o tabuleiro em seu telhado!

Assim, para excluir trabalho desnecessário do NS (e o aprendizado, o processo é muito intensivo em recursos), introduzimos um input "extra" com um offset fixo. Agora olhe: NS no próprio processo de aprendizagem irá selecionar o peso necessário para esta entrada (+/-1 ou outra), é equivalente ao fato de que você irá colocar uma escada na casa a fim de subir para sua prancha de interesse! Agora, a NS não irá ruminar pela montanha de informações desnecessárias, mas simplesmente, por fácil movimentação, tomará uma posição confortável (em seu entendimento) para uma aprendizagem mais confortável.

 
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 entrarmos com base nos resultados da barra 1, então
w6=(High[0]-Low[0])/Point*(Close[0]-Open[0])/Point;

será formada após a abertura do comércio, ou seja, esta entrada (w6) não pode influenciar de forma alguma a qualidade do comércio aberto.

Se eu entendi corretamente, w6 é introduzido para detectar de que forma o preço se movimentou após a abertura de uma negociação com base na análise das cinco barras anteriores (w1, w2, w3, w4, w5).

 

Entraremos com base nos resultados da análise das cinco barras formadas. Portanto, a barra zero não será usada como barra de entrada.

Certo:

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;

Vamos introduzir coeficientes de normalização para as séries HighLow - HL e Close-Open Series - CO. Vamos defini-los como um desvio padrão dos incrementos correspondentes com a janela de média, por exemplo 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 executar uma função normalizadora (mapeia todo o eixo numérico em um 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);
}

Em seguida, as entradas normalizadas para o NS serão contadas como se 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);

Mais uma coisa. w1...w5 não são entradas NS, eles são pesos que podem ser ajustados durante o processo de circuncisão. As entradas serão denotadas como d1, d2... d5
 

normalização de entrada = vela em 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, usaremos a normalização "fina" (onde o segmento +/-1 será preenchido de maneira uniforme). Este é um ponto de princípio.
 

Neutron, obrigado novamente por uma explicação tão detalhada.

Provavelmente vou gastar 60 minutos no que você acabou de escrever, portanto, se não for muito incômodo olhar para este tópico em uma hora.

Se eu estiver interessado nisso, posso enviar-lhe os gráficos com a descrição do algoritmo EA e a descrição dos coeficientes não-rede.

 

Sinceramente, não sou fã da comunicação privada. Se não há restrições em princípio, é melhor comunicar aqui. Além disso, posso perder o interesse neste tópico (só por precaução), portanto não estou comprometido a mantê-lo obrigatório:-)

Combinado?

 
Neutron писал(а) >>
Korey, usaremos a normalização "fina" (quando o segmento +/-1 será preenchido de maneira uniforme). Este é um ponto de princípio.

isto também preenche uniformemente, mas não há curvatura nas bordas, ou seja, a versão antiga não é um mapeamento completo em um segmento

 
Korey писал(а) >>

isto também preenche uniformemente, mas não há vincos nas bordas, ou seja, a versão antiga não é um mapeamento completo em uma seção

Sim, mas precisamos de tudo de uma só vez!

 
Neutron >> :

Sinceramente, não sou fã da comunicação privada. Se não há restrições em princípio, é melhor comunicar aqui. Além disso, posso perder o interesse neste tópico (só por precaução), portanto não estou comprometido a mantê-lo obrigatório:-)

Temos um acordo?

>> Negócio fechado.

//+------------------------------------------------------------------+
//| 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);
  }
//+------------------------------------------------------------------+