Stochastic Net - biblioteca para MetaTrader 4

Esta rede neural estocástica foi criada sob a forma de uma biblioteca especialmente para os Expert Advisors escritos em MQL4. A biblioteca é capaz de conter diversas redes simultaneamente. Eu tentei fazer a rede independente ao máximo, no entanto, eu decidi tirar algumas das funções para a gestão externa para ter mais controle no início. Eu represento ela desta forma. A característica desta rede é o fato de que o seu tamanho é alterado dinamicamente, dependendo da situação. A rede pode passar o treinamento primário e, em seguida, ser treinada durante o processo de trabalho. Nisso, os novos neurônios vão nascer de forma independente serem sintonizados e morrer também. A nova rede deve ser criada para cada classe. Por exemplo, para a produção dos sinais de sobrecompra e sobrevenda você deve criar uma rede para o primeiro caso e uma separada para o segundo caso.

Treinamento

A normalização do vector unidade é introduzido na rede. A saída será um número [0..1] que indica a pertinência do vetor introduzido para a classe da rede. Ao mesmo tempo, se a rede não encontrar o padrão com a probabilidade especificada durante o treinamento, então ela irá adicioná-la automaticamente para a memória pela força do novo neurônio. No caso do treinamento primário, eu recomendo executar 2-3 repetições. De qualquer maneira, quando ocorrer o momento em que a rede aprender bem a informação primária. Normalmente, isso não passa mais de 5 repetições.

Predição, ou Classificação para Ser Mais Exato

O objetivo da classificação é a apresentação do padrão introduzido para combinar a classe da rede. Se a rede aprendeu a classificar os sinais da reversão da tendência de baixa para a de alta, em seguida, essas situações devem ser acompanhados com o valor emitido alto chegando perto de 1. Eu deixo as novas ações com as respostas obtidas a partir da rede e sua integração com o EA para o parecer do escritor do Expert.

As Principais Funções Necessárias para se Trabalhar com a Rede

A função CreateNet é usada para a criação da rede.

double CreateNet(string NN, // Nós criamos a rede chamada <NN>
int InputVectorSize, // com o número de neurônios no vetor introduzido <InputVectorSize>
double MinTV, // o limiar dos conflitos do neurônio
double MaxTV, // o limiar da individualidade
double MW, // o critério da fraqueza dos neurônios
int NL); // O tempo de vida dos neurônios (em barras), se 0, então eles vão viver para sempre

Para a conveniência eu decidi advertir às redes pelos seus nomes. Eu gostaria de lembrar que você pode trabalhar com todo o conjunto de redes neurais. As definições de cada rede são especificadas durante a sua criação e permanecem despercebida até que sejam eliminadas.

O limiar de individualidade é necessário para tomar as decisões sobre o nascimento de novos neurônios durante o processo de treinamento. Normalmente, é igual a 0.95. Se o valor mais baixo é especificado (o menor grau de individualidade) a rede irá tentar modernizar-se de forma que uma grande quantidade de neurônios não irá corresponder a um maior número de variantes. Neste caso, a precisão de previsão diminui. Se o valor de MaxTV for alto, a rede irá se esforçar em criar um novo neurônio para quase todos os vetores e a rede pode se tornar muito grande. A rede esta se modernizando constantemente de modo que os neurônios não entrem em conflito uns com os outros (os padrões não devem ser análogos uns com os outros). MinTV é implementado para este fim, normalmente eu deixo este parâmetro igual a 2. É suficiente definir os parâmetros MaxTV, MinTV e MW apenas uma vez. Além disso, não é necessário aplicar a otimização para encontrar os melhores valores para os parâmetros.

A sobrevivência dos mais fortes! Este princípio é utilizado aqui também. Os neurônios fracos são aqueles cujo peso caiu abaixo do valor mínimo de MW. É mais provável que tais neurônios transportam informações prejudiciais e devem morrer para não gerar um sinal estranho.

Se necessário, você pode matar os neurônios mais velhos e assim se livrar dos "velhos estereótipos". Para fazer isso você deve especificar o tempo de vida dos neurônios em barras (NL). Quando um novo neurônio é criado, a hora de sua criação é memorizada e, no futuro, esta marca lhe permitirá excluí-lo. Assim, a especificação do fator de tempo é obrigatória quando der a entrada de qualquer tipo de dados para a rede.

Nós usamos a função DestroyNet para remover a rede. É muito simples. Não se esqueça de apagar as redes desnecessárias, caso contrário, elas irão ficar vivas na memória do PC até que o MetaTrader esteja fechado.

int DestroyNet(string NN); // Exclui a rede <NetName>, retorna o número de redes restantes

Eu não implementei a verificação da unicidade dos nomes, assim, você pode estar criando um monte de redes com o mesmo nome. No entanto as redes serão diferentes uma das outras pelo número de série.

string NetName(int i); // Retorna o nome da rede pelo número de série especificado
int GetNetsNumber(); // Retorna o número total de redes na biblioteca
int NetNumber(string NetName); // Retorna o número de série da rede <NetName> na biblioteca

Você deve treinar a rede usando a função Trainnet. A resposta certa é provavelmente necessária para se introduzir uma ordem. Por exemplo, podemos aceitar 1 para os sinais de COMPRA, e -1 para os sinais de VENDA. Tanto quanto para a COMPRA e VENDA, diferentes redes são usadas e isto não é levado em conta dentro da rede. Nós tomamos o tempo atual ou o tempo da criação barra.

double TrainNet(string NetName,
double& iX[], // o vetor de entrada normalizado do tamanho de InputVectorSize
int T, // resposta verdadeira
datetime ST); // hora de criação do vetor

Durante o processo de treinamento você pode determinar se a rede tem reconhecido o padrão e modernizado ou ela adicionou-o como um novo. Use a função SizeOfNet para este propósito.

int SizeOfNet(string NetName); // Retorna o número de neurônios Gauss

Você deve ler a resposta usando a função GetPredict. Seus parâmetros são os mesmos que do Trainnet. Se você introduzir o mesmo vetor como a rede foi ensinada então a resposta será 1.

double GetPredict(string NetName, // Fornece a probabilidade [0..1] do vetor de entrada pertencer a classe
double& iX[],
datetime sT);

E essas funções são necessárias para o funcionamento interno da rede. Apenas use-os como é mostrado no exemplo.

void Shrink(string NetName);
void WReset(string NetName);
void AEqual(string NetName);
void CW(string NetName);
void KillWeaks(string NetName);
void KillOlds(string NetName,datetime sT);

Os exemplos de uso

Exemplo do código da função init()

Print("Rede Criada com o número: ",CreateNet("OverBought",24,0.2,0.95,0.001,Period()*60*1000)); // Cria a rede para sinais de Venda
Print("Rede Criada com o número: ",CreateNet("OverSold",24,0.2,0.95,0.001,Period()*60*1000)); // Cria a rede para sinais de Compra

//~~
Print("O treinamento inicial começou...");
for (int R = 1; R <= Repetitions; R++) // Processo de treinamento primário
{ // sobre os dados do histórico
WReset("OverBought"); // Zera os valores dos pesos
InitialTraining("OverBought",HistoryBars,-1); // Executa o treinamento
Shrink("OverBought"); // Moderniza a rede
AEqual("OverBought"); // Define todos os pesos iguais a 1
CW("OverBought"); // Calcula os pesos
KillWeaks("OverBought"); // Mata os neurônios fracos
CW("OverBought"); // Calcula os pesos

WReset("OverSold"); // Zera os valores dos pesos
InitialTraining("OverSold",HistoryBars,1); // Executa o treinamento
AEqual("OverSold"); // Define todos os pesos iguais a 1
Shrink("OverSold"); // Moderniza a rede
CW("OverSold"); // Calcula os pesos
KillWeaks("OverSold"); // Mata os neurônios fracos
CW("OverSold"); // Calcula os pesos
FlushReport("OverSold",R); // Emite os relatórios para o arquivo

}

Exemplo do código da função start()

KillOlds("OverBought",iTime(Symbol(),0,1)); // Mata os neurônios antigos
PostTraining("OverBought",-1); // Continua o treinamento durante os processos
Shrink("OverBought"); // Moderniza a rede
AEqual("OverBought"); // Define todos os pesos iguais a 1
CW("OverBought"); // Calcula os pesos
KillWeaks("OverBought"); // Mata os neurônios fracos
CW("OverBought"); // Calcula os pesos

KillOlds("OverSold",iTime(Symbol(),0,1));
PostTraining("OverSold",-1); // Continua o treinamento durante os processos
AEqual("OverSold"); // Define todos os pesos iguais a 1
Shrink("OverSold"); // Moderniza a rede
CW("OverSold"); // Calcula os pesos
KillWeaks("OverSold"); // Mata os neurônios fracos
CW("OverSold"); // Calcula os pesos

//--------------------------------------------------------------------
double OverBought = Predict("OverBought");
double OverSold = Predict("OverSold");
Out = (OverBought - OverSold)/(OverBought+OverSold);

Exemplo do código da função deinit()

Print("Destruindo a rede=>",Destroy ("OverBought")); // Mata o que temos prolongado
Print("Destruindo a rede=>",Destroy ("OverSold")); // Mata o que temos prolongado

A capacidade de trabalho da rede foi verificada com êxito. Os bons resultados dependem do método de criação do vetor de entrada. É importante compreender que os vetores, que são preliminarmente conhecidos em responder às condições da classe, devem ser introduzidos durante a formação. Em uma linguagem simples, se uma rede é criada para os sinais de VENDA, em seguida, a barra do vetor de treinamento é tomada de onde deveria ter o sinal de venda, de fato. Em outro caso, a rede vai reunir os sinais contraditórios e você não irá obter o resultado desejado.

Eu convido você a discutir as seguintes questões:

1. A formação do vetor de entrada - Atualmente, eu uso 24 parâmetros (a diferença entre as médias móveis), normalizados por unidade em uma faixa de 24 barras. Ou seja, eu calculo a matriz 24x24. Então eu normalizo ela e tomo os últimos valores.

2. As determinações da "resposta certa" - ou seja, quando o vetor transmitido for o sinal. No momento eu uso a AMA. Então eu começo a saber se havia um sinal só depois de duas barras.

Isso é tudo.