Etiqueta de mercado ou boas maneiras em um campo minado - página 84

Novo comentário
 

Neutron obrigado por enviar a tese


Obrigado também pelo tema levantado e pelo construtivo

Até agora tenho conseguido implementar algo semelhante usando SSAS (infelizmente, só li este fio e a tese hoje),

talvez o k.n. aprenda algo útil com isso:

1. Agrupando a faixa intradiária em vários grupos de acordo com o valor médio do castiçal H1 e dividindo o dia em intervalos de tempo (TI)

(2 clusters e 2 VV, mas um par de ienes resultou em 4 clusters e 7 VV)

2. Os modelos são criados para cada instrumento e VI:

- agrupamento de movimentos anteriores para cima e para baixo separadamente por dois parâmetros de entrada: preço e tempo

- O agrupamento de futuros movimentos para cima e para baixo separadamente por dois parâmetros de entrada: preço e tempo
(este modelo é, naturalmente, usado apenas para preparar dados para a fase de treinamento)

- modelos preditivos:
-- Bayes ingênuo

-- regra de ouro

-- regras de relacionamento

-- NS

-- árvore de decisão

3. Com base em um desvio mínimo de um extremo, construímos um ziguezague - obtemos uma estrutura f de f-estrutura monótona fracionada e, conseqüentemente, padrões de segmentosN.

Treinamos modelos de agrupamento apropriados e agrupamos os segmentos

5. Calculamos o horizonte preditivo do padrão como uma fração do comprimento do padrão ou comprimento fixo ou ao múltiplo mais próximo de uma fração maior do comprimento do padrão

6. Calcular e classificar a "previsão

7. Ensinar modelos prognósticos

Durante a operação, o Expert Advisor carrega dados no MS SQL e periodicamente gera pontos em ziguezague e previsões. Tendo-os recebido, analisa os valores de seu apoio e a validade das regras. Ele toma uma decisão com base na comparação.


Vantagens:

- É possível utilizar e comparar os resultados de vários modelos de DM

- os próprios modelos podem escolher entre uma variedade de métodos

Desvantagens:

- Menos parâmetros para a criação dos modelos

- operação com recursos intensivos de MSSQL

- Falta de uma base científica (vamos corrigir, incluindo as conclusões da dissertação acima mencionada)


Sem de forma alguma invadir a grande nuance da ciência e das provas no trabalho mencionado,

Eu gostaria muito de perguntar a todos que lêem este tópico

sobre a conveniência de usar para agregação de entradas adicionais de monotoneladas por peça, tais como volume, delta de mercado, etc.

Talvez eles possam desempenhar um papel adicional, por exemplo, de filtragem.


S.Privalov: Essencialmente este trabalho (dissertação) define uma metodologia para criar um padrão para uma previsão.

Imho, é disso que estamos falando - por exemplo, quando você recebe uma previsão por bunda. regras você pode especificar o número N de peças de padrão e pedir um número diferente de passos de previsão e obtê-los com diferentes suportes e certezas - ou seja, obtemos um modelo que pode ser usado como base para uma previsão.

Você acha que é possível/como você aplica sua idéia de usar o f. de Kalman a eles?

Ter um modelo/e seria interessante treiná-lo sob eles.


Esta é a aparência dos modelos no SSAS, para esta ferramenta 3 vi foram identificados

Aqui http://www.fxexpert.ru/forum/index.php?showtopic=656 há bibliotecas de malhas, incluindo mql e outras coisas úteis.

 

Comecei a cavar fundo na rede, tentando determinar o número ideal de neurônios escondidos. Cheguei a uma conclusão bastante interessante, à qual acho que outros já chegaram há muito tempo. Vou tentar explicar isso intuitivamente. Imagine um neurônio de camada oculta que tem 20 entradas. Com estas entradas, como tentáculos, geme sobre as entradas e no processo de ranhuramento, os pesos das entradas são otimizados para obter as saídas esperadas da rede. Agora adicionamos outro neurônio oculto, com 20 entradas conectadas às 20 entradas do primeiro neurônio, mas com pesos diferentes. Uma vez que o segundo neurônio está sondando os mesmos insumos, ele essencialmente não dá novas informações. Se isto for verdade, então o treinamento da rede levará aos mesmos pesos de entrada para ambos os neurônios. Como as saídas de ambos os neurônios são multiplicadas pelos pesos correspondentes do neurônio de saída e somadas, os pesos de entrada de ambos os neurônios ocultos podem diferir um do outro em amplitude por um fator igual à razão dos pesos dos neurônios de saída.

De qualquer forma, após o treinamento de uma rede 20-2-1, recebo estes pesos de entrada de dois neurônios escondidos:

Observe que ambos os conjuntos de pesos se comportam da mesma forma dependendo do número de entrada, exceto pelo multiplicador constante. Ou seja, ambos os neurônios dão as mesmas informações ao neurônio de saída. Talvez seja por isso que o erro de aprendizagem da minha rede dificilmente melhora depois de adicionar um segundo neurônio oculto. Aqui está outra foto de pesos de neurônios escondidos. Aqui eles diferem por um sinal, mas os sinais dos pesos dos neurônios de saída também diferem


Em geral, essa rede de duas camadas se comporta de forma semelhante a uma simples rede de camada única (modelo AR). Com esta conclusão, estou em um beco sem saída. Acontece que as redes neurais são adequadas apenas para classificação, ou seja, quando a saída tem apenas dois valores: sim ou não. Tentar usar a rede para previsão de preços leva aos mesmos resultados que o modelo AR, uma vez que as saídas de neurônio não estão saturadas e sua função de ativação não linear desempenha um papel secundário, mesmo que normalizemos os dados de entrada para -1...+1. Vou tomar uma cerveja - talvez surjam novas idéias (por exemplo, para alimentar +1 e -1 a entradas de rede?)

 
M1kha1l писал(а) >>

Até agora consegui implementar algo semelhante usando SSAS (infelizmente, só li este tópico e a tese hoje),

Aqui http://www.fxexpert.ru/forum/index.php?showtopic=656 há bibliotecas de malhas, incluindo mql e outras coisas úteis.

Obrigado, M1kha1l, por suas amáveis palavras e por compartilhar seus conhecimentos.

Seu posto precisa de algum tempo para ser compreendido. Estou lendo-o agora.

gpwr escreveu >>

Comecei a cavar fundo na rede, tentando determinar o número ideal de neurônios escondidos. Chegou a uma conclusão bastante interessante, a qual outros provavelmente chegaram há muito tempo. Vou tentar explicar isso intuitivamente. Imagine um neurônio de camada oculta que tem 20 entradas. Com estas entradas, como tentáculos, geme sobre as entradas e no processo de ranhuramento, os pesos das entradas são otimizados para obter as saídas esperadas da rede. Agora adicionamos outro neurônio oculto, com 20 entradas conectadas às 20 entradas do primeiro neurônio, mas com pesos diferentes. Uma vez que o segundo neurônio está sondando os mesmos insumos, ele essencialmente não dá novas informações. Se isto for verdade, então o treinamento da rede levará aos mesmos pesos de entrada para ambos os neurônios. Como as saídas de ambos os neurônios são multiplicadas pelos pesos correspondentes do neurônio de saída e somadas, os pesos de entrada de ambos os neurônios ocultos podem diferir um do outro em amplitude por um fator igual à razão dos pesos dos neurônios de saída.

Grande trabalho, gpwr, eu nem pensei em olhar para os pesos dos neurônios paralelos!

Vejamos o processo de redução de erros de aprendizagem (em vermelho) e redução de erros de generalização (em azul) para NS multicamadas no processo de aprendizagem:

Podemos ver que o mínimo do erro de generalização (o que nos dá a vantagem estatística na tomada de decisões) não é o mesmo que o mínimo do erro de generalização. Isto é compreensível, porque a história nem sempre se repete exatamente, ela se repete aproximadamente. E embora exista apenas um mínimo global para o aprendizado, existem muitos mínimos locais para generalização e não há maneira de escolher o melhor. Você só pode adivinhar. E é aqui que as estatísticas sob a forma de múltiplos neurônios em uma camada oculta vêm à tona. Todos eles estão um pouco subtreinados e "chafurdados" em mínimos locais, alguns no seu melhor (em termos de erro de generalização), outros no seu pior. Entendeu? Em geral, suas soluções são calculadas pela média do neurônio linear de saída e tal estimativa é a melhor. Além disso, o erro de estimativa cai como a raiz quadrada do número de neurônios na camada oculta. É por isso que o poder preditivo da NS aumenta com o número crescente de neurônios em camada oculta.

Esses dados, que você citou, dizem respeito ao retreinamento da malha e, como conseqüência, ao funcionamento sincronizado de todos os seus neurônios na camada oculta. O NS de várias camadas degenerou em um pseudônimo linear!

 
Neutron >> :

Obrigado, M1kha1l, por suas amáveis palavras e por ter escolhido compartilhar seus conhecimentos.

Leva algum tempo para compreender seu posto. Eu o li.

Grande trabalho, gpwr, eu nem pensei em olhar para os pesos dos neurônios paralelos!

Vejamos o processo de redução de erros de aprendizagem (em vermelho) e erro de generalização (em azul) para os NS multicamadas no processo de aprendizagem:

Podemos ver que o mínimo do erro de generalização (o que nos dá a vantagem estatística na tomada de decisões) não é o mesmo que o mínimo do erro de generalização. Isto é compreensível, porque a história nem sempre se repete exatamente, ela se repete aproximadamente. E embora exista apenas um mínimo global para o aprendizado, existem muitos mínimos locais para generalização e não há maneira de escolher o melhor. Você só pode adivinhar. E é aqui que as estatísticas sob a forma de múltiplos neurônios em uma camada oculta vêm à tona. Todos eles estão um pouco subtreinados e "chafurdados" em mínimos locais, alguns no seu melhor (em termos de erro de generalização), outros no seu pior. Entendeu? Em geral, suas soluções são calculadas pela média do neurônio linear de saída e tal estimativa é a melhor. Além disso, o erro de estimativa cai como a raiz quadrada do número de neurônios na camada oculta. É por isso que o poder preditivo da NS aumenta com o número crescente de neurônios em camada oculta.

Esses dados, que você citou, dizem respeito ao retreinamento da malha e, como conseqüência, ao funcionamento sincronizado de todos os seus neurônios na camada oculta. A NS multicamadas degenerou em um perseptron linear!

Minha rede recebeu 300 exemplos de treinamento e o número de pesos foi de 45. Na literatura há uma opinião de que com 5 vezes mais exemplos de treinamento do que pesos, a rede com 95% de probabilidade será generalizada. Ou seja, minha rede deve ter uma boa generalização de acordo com a teoria, mas na verdade não é assim. Foi por isso que dei exemplos para confirmar. Acho que a questão aqui não é tomar mais exemplos de treinamento. É sobre a natureza do problema que estou forçando a rede a resolver. Se você tentar fazer a rede prever o tamanho da próxima etapa do preço, então no treinamento ela tenderá a tais pesos com os quais os neurônios operam na área linear da função de ativação a fim de preservar a proporcionalidade entre a etapa prevista e as etapas anteriores de entrada. Ou seja, a tarefa em si é linear. Dado este estado de coisas, acrescentar neurônios ocultos não melhorará nada. E a própria camada oculta torna-se desnecessária. Ao experimentar minha rede, cheguei à conclusão de que uma única camada funciona bem como uma camada dupla. Eu acho que, lendo seus posts anteriores neste tópico, você chegou à mesma conclusão também para o EURUSD.

Na minha opinião, a rede deve ser utilizada para problemas altamente não lineares (como XOR ou problemas de classificação) para os quais a função de ativação do neurônio pode ser escolhida para ser escalonada.


 

Gostaria de salientar que a essência do efeito detectado pode ser explicada pelo excesso de treinamento de NS devido ao número excessivo de épocas de treinamento, e deve haver um ótimo número de épocas de treinamento Nopt (ver figura acima), que depende do coeficiente de aprendizagem. Eu não disse que devíamos "...para tomar ainda mais exemplos de treinamento. ", esta é a essência do problema do comprimento ideal da amostra de treinamento Rorth=w*w/d. É o que diz a teoria, não que "...o número de exemplos de treinamento é 5 vezes o número de pesos..." .

Estamos falando de diferentes causas para o efeito de supertreinamento da rede.

Concordo com você que a tarefa de prever o sinal e a amplitude da próxima barra é predominantemente linear e não pode haver mais nada. O mercado é tão simples quanto um pé-de-cabra e tão imprevisível quanto uma previsão do tempo. Embora, um pouco mais tarde publicarei os resultados comparativos de qualidade das previsões em barras horárias para camada única, camada dupla com dois neurônios na camada oculta e camada dupla com 4 neurônios na camada oculta. Tudo isso será apresentado em função do número de entradas d do NS. Os dados serão calculados como média de mais de 50 experimentos numéricos independentes.

 

Será que não há como... para colocar um cavalo e uma corça no mesmo carrinho? Refiro-me ao MT4 e ao MathCad. Para receber as citações atuais diretamente no MathCad e realizar toda a análise lá, e então transferir o sinal gerado para o MT4. A primeira coisa que vem à mente é o uso do arquivo, mas ambos os programas devem verificar o conteúdo de dois arquivos diferentes o tempo todo. Não é muito conveniente. Talvez haja algo mais? É uma pena que não haja interrupção no manuseio da MQL. Como tudo é feito de forma inconveniente! МТ4, este maldito... Eu poderia apenas sentar-me e estudar C++.


P.S. Estou mexendo com os dados para a rede.

 

Não, é entediante implementar todo o algoritmo de análise na MQL? Ou as dificuldades são exorbitantes de alguma forma?

P.S. E eu estou recebendo estatísticas...

 

Sim, há dificuldades com MQL a cada volta. Por exemplo, aqui está o código (indicador) mais simples para dividir um quociente em uma série de transações:

#property indicator_chart_window
#property indicator_buffers 2

#property indicator_color1 Red
#property indicator_color2 MediumBlue

extern int step = 5;
extern int sp = 3;

double Trans[], Kagi[];
int mn, mx, H, Cotir, Up, Dn;
bool set_new=false, SetMax=false, SetMin=false;

//******************************************************************************
int init() 
{ 
SetIndexBuffer(0, Trans);
SetIndexBuffer(1, Kagi);

SetIndexEmptyValue(0,0.0);
SetIndexEmptyValue(1,0.0);

SetIndexStyle(0,DRAW_ARROW);
SetIndexStyle(1,DRAW_ARROW);

SetIndexArrow(0,119);
SetIndexArrow(1,162);

IndicatorShortName ("Kagi++");
return(0); 
} 
//*******************************************************************************

int start() 
{ 
int reset, MaxBar, MaxBarJ, counted_bars=IndicatorCounted(), mx_j, mn_j;

if ( counted_bars<0)return(-1);
if ( counted_bars>0) counted_bars--;
int limit=Bars- counted_bars-1; MaxBar=Bars-2; MaxBarJ= MaxBar-30; 
if ( limit==Bars-1) limit=Bars-2;

//----+ ОСНОВНОЙ ЦИКЛ ВЫЧИСЛЕНИЯ ИНДИКАТОРА 
for(int i= limit; i>=0; i--)
   {
     Cotir = Open[ i]*MathPow(10.0,Digits);
          
     if(! set_new)
      {
        mx = Cotir;
        mn = Cotir;
        H = step* sp;
        set_new = true;
      }               
     if( Cotir - mx > 0)
      {
        mx = Cotir;
        mx_j = i;
      }  

     if( Cotir - mn < 0)
      {
        mn = Cotir;
        mn_j = i;
      }  

     if(! SetMax && Cotir <= mx - H) 
      {
         Trans[ i] = Cotir/MathPow(10.0,Digits); 
         mn = Cotir;           
         mn_j = i;
         SetMax = true;
         SetMin = false;
         Kagi[ mx_j] = mx/MathPow(10.0,Digits);
      } 
     if(! SetMin && mn + H <= Cotir) 
      {
         Trans[ i] = Cotir/MathPow(10.0,Digits); 
         mx = Cotir;       
         mx_j = i;
         SetMax = false;
         SetMin = true;
         Kagi[ mn_j] = mn/MathPow(10.0,Digits);
      } 

   }
return(0);  
}

Funciona, mas não podemos desenhar seus resultados com linhas na janela do gráfico. Além disso, (isto está além do meu entendimento) se o spread for dividido por menos de 6 spreads, ele não produz absolutamente nada, apesar do fato de que os arrays são formados corretamente. Na MQL, assim como em qualquer tecnologia homebrew, existem muitas dificuldades completamente inesperadas (começando com dupla comparação, etc...) e "peculiaridades", naturalmente sem documentação. Eu estou repreendendo, em geral...

Também entendo como verificar a grade no MathCad, mas como fazer isso no MQL - você não consegue pensar? E se eu tiver um bug em algum lugar?

 
paralocus писал(а) >>

Sim, há dificuldades com MQL a cada volta. Aqui está o código mais simples, por exemplo, para dividir um quociente em uma série de transações:

ver anexo - sacar - desfrutar

paralocus escreveu >>

Eu também sei como verificar a grade no MathCad, mas como fazê-lo no MQL - não tenho idéia. >> E se eu tiver um bug em algum lugar?

Por que não considerar o uso de NeuroShell ou Statistics? Lá você pode criar malhas e colocá-las em bibliotecas e depois treiná-las a partir da MT e monitorar seus parâmetros
Arquivos anexados:
seekminpricediv.mq4  4 kb
 

Parece que não vou poder esperar para coletar estatísticas sobre minha EM...

Acho que terei que desistir da idéia de apresentar dados de precisão de previsão em incrementos de 1 pelo número de entradas NS. Por exemplo, podemos simplificar a tarefa, tomando o número de entradas como um múltiplo de 2...

1...777879808182838485868788899091...104
Novo comentário
Razão: