Conselheiros em redes neurais, compartilhando experiências. - página 9
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Eu também tentei implementar um algoritmo semelhante em 2013. Mas eu usei 7 indicadores, e o Zigzag foi usado para formar um vetor para o treinamento do NS. Mas a essência é a mesma - eu estava procurando posições invertidas... Quando comecei a usar o Zigzag, não tinha idéia do que fazer com ele. até que, acidentalmente, me deparei com alguns padrões. Isso mudou radicalmente o meu TS. Agora meu algoritmo é muito mais simples:
1. Cálculo de padrões de minutos e horas, ao longo do último ano;
2. Fazer um dicionário de pontos de viragem (pares "padrão minuto - padrão hora") ;
3. Ensinar NS usando o dicionário de pontos de inclinação (em 150-160 pares);
Este é o resultado da minha abordagem:
Às desvantagens da minha abordagem:
1) Alto risco do TS - como não é possível determinar o valor exato do preço de parada, o TS coloca 9 pedidos pendentes com lotes: 1, 1, 3, 6, 14, 31, 70, 158, 355;
2) Difícil de implementar um algoritmo de saída (TS de arrasto);
Assim, NS pode ser usado para comércio, a única questão é o que ensinar NS...
P/s: Por padrões eu entendo os padrões de A. Merrill's (M & W) .
É uma abordagem inteligente. E os padrões foram descritos simplesmente como a posição das barras na matriz, sem levar em conta o delta de preço real - apenas a posição relativa?
Tenho uma idéia, para tentar os indicadores padrão, mas com um quadro diferente - as primeiras cinco barras analisamos os indicadores nos últimos 5 indicadores, e os dois indicadores para análise de tendências - analisamos em incrementos de 10 e levamos em conta as mudanças absolutas.
O zig-zag é uma idéia inteligente, mas como é que os picos se filtram das oscilações planas que lá podem haver falsos pontos de mudança de tendência?
Uma abordagem sensata. E os padrões descritos simplesmente como a posição das barras na matriz, sem levar em conta o delta de preço real - apenas a posição relativa?
Tenho uma idéia, para tentar os indicadores padrão, mas com um quadro diferente - as primeiras cinco barras analisamos os indicadores nos últimos 5 indicadores, e dois indicadores para análise de tendências - analisamos em etapas de 10 e ao mesmo tempo levamos em conta as mudanças absolutas.
Sobre o zig-zag é uma idéia inteligente, mas como os picos filtrados das oscilações planas podem ser falsos pontos de mudança de tendência?
Eu o faço desta maneira:
Há uma matriz dinâmica que armazena exclusivamente pares de padrões (chamo-lhe um dicionário), se um par de padrões entrar no dicionário uma segunda vez eu não o escrevo; e duas matrizes de contadores de tempo sênior e júnior - eles contam quantas vezes um padrão foi envolvido na formação de pares, mesmo que não tenha sido escrito no dicionário.
O vetor de treinamento é formado de acordo com o dicionário, o peso de um padrão individual = padrão_contador_máximo_contador. Ou seja, o padrão, que participa mais frequentemente da formação de pares, é igual a 1, e todos os outros padrões são inferiores a 1. Esta é a tabela que você recebe depois de ensinar a NS:
Estrutura dos NS: 64 neurônios de entrada, 4 internos, 1 de saída. Ou seja, um neurônio de entrada descreve um padrão. A grade leva 40-50 minutos para treinar, e o erro da NS não excede 0,00001.
Assim, tenho um modelo que pode prever o significado dos pares de padrões, mesmo que não estivesse no dicionário antes.
Tenho lutado com picos planos e falsos durante muito tempo, mas estou trabalhando no nível de cálculo de ZigZaga. Eu modifiquei ligeiramente o código de um Zigzag padrão, ou seja, implementei a porcentagem ZZ em sua base. Até o momento, o código parece mais ou menos como se segue:
int MyCExtremum::GetCombiZigzag(const double &high[], // буфер цен high
const double &low[], // буфер цен low
const datetime &time[], // буфер время
int ExtDepth, // глубина поиска экстремумов(первого прохода)
double ExtDeviation,// "пороговое значение": жесткая ступенька + % роста цены
int ExtBackstep // глубина поиска экстремумов(второго прохода)
)
{
//--- value
int shift=0, whatlookfor=0, lasthighpos=0, lastlowpos=0, Deviat=1;
double lasthigh=0.0, lastlow=0.0, percent=0.0;
int rates_total = ArraySize(time); // размер входных таймсерий
int limit = rates_total - ExtDepth; // лимит на расчеты...
//+---------------------------------------------------------------+
//| ОЧЕНЬ ВАЖНАЯ ПРОВЕРКА ВЛИЯЮЩАЯ НА КОРРЕКТНОСТЬ ВЫЧИСЛЕНИЙ! |
//+---------------------------------------------------------------+
if(ArrayIsSeries(high)) ArraySetAsSeries(high,false);
if(ArrayIsSeries(low)) ArraySetAsSeries(low,false);
if(ArrayIsSeries(time)) ArraySetAsSeries(time,false);
//+---------------------------------------------------------------+
//| ПРОВЕРКИ ВХОДНЫХ ПЕРЕМЕННЫХ |
//+---------------------------------------------------------------+
if(rates_total<20)
{
Print(__FUNCTION__," ERROR: the small size of the buffer.");
return(-1);
}
if(ExtDeviation<0 || ExtDeviation>100)
{
Print(__FUNCTION__," ERROR: Is\'not correct a Deviation. The value of Deviation should be in the interval [0..100].");
return(-1);
}
//--- Проверка: Depth and Backstep
if((ExtDepth < ExtBackstep)||(ExtDepth < 2))
{
Print(__FUNCTION__+" ERROR: Is\'not correct a Depth and Backstep. The value of Depth should be greater than Backstep.");
return(-1);
}
//--- готовим буфер ZigzagBuffer[]
if(ArraySize(ZigzagBuffer)>0) ArrayFree(ZigzagBuffer); // Удаляем старые данные
ArrayResize(ZigzagBuffer,rates_total, EXTREMUM_RESERVE);
ArrayFill(ZigzagBuffer,0,rates_total,0.0);
if(ArrayIsSeries(ZigzagBuffer)) ArraySetAsSeries(ZigzagBuffer, false);
//---
if(ArraySize(HighMapBuffer)>0) ArrayFree(HighMapBuffer); // Удаляем старые данные
ArrayResize(HighMapBuffer,rates_total, EXTREMUM_RESERVE);
ArrayFill(HighMapBuffer,0,rates_total,0.0);
if(ArrayIsSeries(HighMapBuffer)) ArraySetAsSeries(HighMapBuffer, false);
//---
if(ArraySize(LowMapBuffer)>0) ArrayFree(LowMapBuffer); // Удаляем старые данные
ArrayResize(LowMapBuffer,rates_total, EXTREMUM_RESERVE);
ArrayFill(LowMapBuffer,0,rates_total,0.0);
if(ArrayIsSeries(LowMapBuffer)) ArraySetAsSeries(LowMapBuffer, false);
//---
if(ArraySize(TimeBuffer)>0) ArrayFree(TimeBuffer); // Удаляем старые данные
ArrayResize(TimeBuffer, rates_total, EXTREMUM_RESERVE);
ArrayFill(TimeBuffer, 0, rates_total, 0);
if(ArrayIsSeries(TimeBuffer)) ArraySetAsSeries(TimeBuffer, false);
//--- корректировка Deviation
if(ExtDeviation < 1)
{
Deviat = 1;
}else
{
Deviat = (int)ExtDeviation;
}
//--- получаем "свежие" минимумы и максимумы
if(GetHighMapZigzag(high,ExtDepth,Deviat,ExtBackstep) < 0) return(0);
if(GetLowMapZigzag(low,ExtDepth,Deviat,ExtBackstep) < 0) return(0);
//--- final rejection
for(shift=ExtDepth;shift<rates_total;shift++)
{
switch(whatlookfor)
{
case Start: // search for peak or lawn
if(lastlow==0 && lasthigh==0)
{
if(HighMapBuffer[shift]!=0)
{
lasthigh=high[shift];
lasthighpos=shift;
whatlookfor=Sill;
ZigzagBuffer[shift]=lasthigh;
TimeBuffer[shift]=time[shift];
}
if(LowMapBuffer[shift]!=0)
{
lastlow=low[shift];
lastlowpos=shift;
whatlookfor=Pike;
ZigzagBuffer[shift]=lastlow;
TimeBuffer[shift]=time[shift];
}
}
break;
case Pike: // search for peak
if(LowMapBuffer[shift]!=0.0 && LowMapBuffer[shift]<lastlow && HighMapBuffer[shift]==0.0)
{
//---
ZigzagBuffer[lastlowpos] = 0.0;
TimeBuffer[lastlowpos] = 0;
//---
lastlowpos=shift;
lastlow=LowMapBuffer[shift];
ZigzagBuffer[shift]=lastlow;
TimeBuffer[shift]=time[shift];
//--- Обязательно: покинуть switch
break;
}
//--- Обход "двойственности"
if(LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]<lastlow)
{
//---
ZigzagBuffer[lastlowpos] = 0.0;
TimeBuffer[lastlowpos] = 0;
//---
lastlowpos=shift;
lastlow=LowMapBuffer[shift];
ZigzagBuffer[shift]=lastlow;
TimeBuffer[shift]=time[shift];
//--- Обязательно: покинуть switch
break;
}
if(HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]==0.0)
{
//--- Проверка: % роста цены
percent = (HighMapBuffer[shift]-lastlow)/(lastlow/100);
if(percent > ExtDeviation)
{
lasthigh=HighMapBuffer[shift];
lasthighpos=shift;
ZigzagBuffer[shift]=lasthigh;
TimeBuffer[shift]=time[shift];
whatlookfor=Sill;
}
percent = 0.0;
}
break;
case Sill: // search for lawn
if(HighMapBuffer[shift]!=0.0 && HighMapBuffer[shift]>lasthigh && LowMapBuffer[shift]==0.0)
{
//---
ZigzagBuffer[lasthighpos] = 0.0;
TimeBuffer[lasthighpos] = 0;
//---
lasthighpos=shift;
lasthigh=HighMapBuffer[shift];
ZigzagBuffer[shift]=lasthigh;
TimeBuffer[shift]=time[shift];
//--- Обязательно: покинуть switch
break;
}
if(HighMapBuffer[shift]!=0.0 && LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]>lasthigh)
{
//---
ZigzagBuffer[lasthighpos] = 0.0;
TimeBuffer[lasthighpos] = 0;
//---
lasthighpos=shift;
lasthigh=HighMapBuffer[shift];
ZigzagBuffer[shift]=lasthigh;
TimeBuffer[shift]=time[shift];
//--- Обязательно: покинуть switch
break;
}
if(LowMapBuffer[shift]!=0.0 && HighMapBuffer[shift]==0.0)
{
//--- Проверка: % роста цены
percent = (lasthigh-LowMapBuffer[shift])/(lasthigh/100);
if(percent > ExtDeviation)
{
lastlow=LowMapBuffer[shift];
lastlowpos=shift;
ZigzagBuffer[shift]=lastlow;
TimeBuffer[shift]=time[shift];
whatlookfor=Pike;
}
percent = 0.0;
}
break;
default:
return(-1);
}
}
//--- return value of prev_calculated for next call
return(rates_total);
}
MyCExtremum é uma classe para calcular o ZigZag.
Uma abordagem sensata. E os padrões descritos simplesmente como a posição das barras na matriz, sem levar em conta o delta de preço real - apenas a posição relativa?
Tenho uma idéia, para tentar os indicadores padrão, mas com um quadro diferente - as primeiras cinco barras analisamos os indicadores nos últimos 5 indicadores, e dois indicadores para análise de tendências - analisamos em etapas de 10 e ao mesmo tempo levamos em conta as mudanças absolutas.
O zig-zag é uma idéia inteligente, mas como é que os picos se filtram das oscilações planas que lá podem haver falsos pontos de mudança de tendência?
Andrey Emelyanov:
Estrutura dos NS: 64 neurônios de entrada, 4 internos, 1 de saída. Ou seja, um neurônio de entrada descreve um padrão.
Eu faço o seguinte:
Há uma matriz dinâmica que armazena exclusivamente pares de padrões (chamo-lhe o dicionário), se um par de padrões entrasse no dicionário uma segunda vez eu não o escrevia; e duas matrizes de alto prazo e contador de baixo prazo - contam quantas vezes um padrão foi envolvido na formação de pares, mesmo que não tenha sido escrito no dicionário.
O vetor de treinamento é formado de acordo com o dicionário, o peso de um padrão individual = padrão_contador_máximo_contador. Ou seja, o padrão, que participa mais frequentemente da formação de pares, é igual a 1, e todos os outros padrões são inferiores a 1. Esta é a tabela que você recebe depois de ensinar a NS:
Estrutura dos NS: 64 neurônios de entrada, 4 internos, 1 de saída. Ou seja, um neurônio de entrada descreve um padrão. A grade leva 40-50 minutos para treinar, e o erro da NS não excede 0,00001.
Assim, tenho um modelo que pode prever o significado dos pares de padrões, mesmo que não estivesse no dicionário antes.
Tenho lutado com picos planos e falsos durante muito tempo, mas estou calculando ZigZaga. Eu modifiquei ligeiramente o código de um Zigzag padrão, ou seja, implementei a porcentagem ZZ em sua base. Até o momento, o código parece mais ou menos como se segue:
A matriz é uma solução interessante. Existem diferenças nas estatísticas entre pares/períodos, qual é a estabilidade em geral da variabilidade da freqüência de ocorrência de um padrão dando um resultado de previsão positivo?
Sobre o zig-zag, também tenho uma solução percentual, mas também utilizo um histórico mais profundo para calcular uma seção de referência do zig-zag, contra a qual comparo a mudança percentual em outros.
Quanto a analisar indicadores com padrões - isso é muito interessante... Eu acho que há menos ruído nos indicadores, mas você tem que escolher indicadores para que um suprima "baixo ruído" e o outro "alto ruído", então você tem um multifiltro.
Você está esperando resultados com este modelo? Sua camada interna atua como um compressor intermediário, não como um classificador.
A matriz é uma solução interessante. Existe alguma diferença nas estatísticas entre pares/períodos, qual é a estabilidade em geral da variabilidade de frequência de ocorrência de padrões que dá um resultado de previsão positivo?
Sobre o zig-zag, também tenho uma solução percentual, mas também utilizo um histórico mais profundo para calcular uma seção de referência do zig-zag, contra a qual comparo a mudança percentual em outros.
Como todos sabem, os padrões de A. Merrill não dão uma resposta exata se o padrão se desenvolverá mais (manter a tendência) ou se mudará para outro padrão (ricochete de preço). Foi por isso que decidi procurar a resposta usando dois períodos de tempo - uma hora e um minuto. Eu recolho estatísticas sobre a recorrência de pares e ainda não tenho um dicionário de treinamento universal. No entanto, tenho certeza de que essa conexão deve existir... Caso contrário, não haveria modelos harmoniosos: borboletas, morcegos, etc.
Meu bebê ainda é burro e chato, mas está chegando a algum lugar... 8 indicadores de entrada, 1 de saída, 15 neurônios na camada coberta. 2000 vetores de entrada, 10.000 épocas de treinamento.
Este é na verdade o terceiro ou quarto, todos obtendo praticamente os mesmos resultados. Acho que preciso de mais neurônios e vetor de entrada, mas leva muito tempo para treinar.
Tenho uma idéia aproximada do padrão que deve pegar, selecionei indicadores de diferentes prazos e os resultados parecem ter informações significativas.