O papel das distribuições estatísticas no trabalho de negociação
1 492
0
"As regularidades tornam nossa vida mais fácil, mas é tão importante quanto se beneficiar da aleatoriedade".
(Georgiy Aleksandrov)
Introdução
Este artigo é uma continuação lógica do meu artigo de Distribuições de probabilidade estatística em MQL5 que apresenta as classes para trabalhar com algumas distribuições estatísticas teóricas. Eu achei necessário primeiro estabelecer a base nas formas de classes de distribuição, a fim de torná-las mais convenientes para um usuário utilizá-las mais tarde na prática.Distribuições de probabilidade estatística em MQL5.
Agora que temos uma base teórica, sugiro que devemos prosseguir diretamente para conjuntos de dados reais e tentar fazer algum uso informativo desta base. Ao mesmo tempo, vamos lançar uma luz sobre algumas questões relacionadas com a estatística matemática.
1. Geração de números aleatórios com uma dada distribuição
Mas antes de considerar os conjuntos de dados reais, parece muito importante ser capaz de obter um conjunto de valores que seriam estreitamente relacionados com a distribuição teórica desejada.
Em outras palavras, o usuário só deve definir os parâmetros da distribuição desejada e tamanho da amostra. Um programa (no nosso caso, uma hierarquia de classes) deve gerar e produzir tais amostras de valores para os trabalhos futuros.
Outro detalhe importante é que as amostras geradas por uma lei especificada são usadas para verificar vários testes estatísticos. A área de estatísticas matemáticas - geração de variáveis aleatórias com diferentes leis de distribuição - é bastante interessante e desafiadora.
Para os meus propósitos, eu usei um gerador de alta qualidade descrito no livro Numerical Recipes: A arte do cálculo científico [2]. Seu período é aproximadamente igual a 3.138*1057. O código C foi facilmente passado para MQL5.
E então eu criei a classe Aleatória, como segue:
//+------------------------------------------------------------------+ //| Random class definition | //+------------------------------------------------------------------+ class Random { private: ulong u, //unsigned 64-bit integers v, w; public: //+------------------------------------------------------------------+ //| The Random class constructor | //+------------------------------------------------------------------+ void Random() { randomSet(184467440737095516); } //+------------------------------------------------------------------+ //| The Random class set-method | //+------------------------------------------------------------------+ void randomSet(ulong j) { v=4101842887655102017; w=1; u=14757395258967641292; u=j^v; int64(); v = u; int64(); w = v; int64(); } //+------------------------------------------------------------------+ //| Return 64-bit random integer | //+------------------------------------------------------------------+ ulong int64() { uint k=4294957665; u=u*2862933555777941757+7046029254386353087; v^= v>> 17; v ^= v<< 31; v ^= v>> 8; w = k*(w & 0xffffffff) +(w>> 32); ulong x=u^(u<<21); x^=x>>35; x^=x<<4; return(x+v)^w; }; //+------------------------------------------------------------------+ //| Return random double-precision value in the range 0. to 1. | //+------------------------------------------------------------------+ double doub() { return 5.42101086242752217e-20*int64(); } //+------------------------------------------------------------------+ //| Return 32-bit random integer | //+------------------------------------------------------------------+ uint int32() { return(uint)int64(); } };
Podemos agora criar classes de valores amostrados de uma distribuição.
Como um exemplo, deixe-nos olhar para uma variável aleatória a partir da distribuição normal. A classe CNormaldev é, como segue:
//+------------------------------------------------------------------+ //| CNormaldev class definition | //+------------------------------------------------------------------+ class CNormaldev : public Random { public: CNormaldist N; //Normal Distribution instance //+------------------------------------------------------------------+ //| The CNormaldev class constructor | //+------------------------------------------------------------------+ void CNormaldev() { CNormaldist Nn; setNormaldev(Nn,18446744073709); } //+------------------------------------------------------------------+ //| The CNormaldev class set-method | //+------------------------------------------------------------------+ void setNormaldev(CNormaldist &Nn,ulong j) { N.mu=Nn.mu; N.sig=Nn.sig; randomSet(j); } //+------------------------------------------------------------------+ //| Return Normal deviate | //+------------------------------------------------------------------+ double dev() { double u,v,x,y,q; do { u = doub(); v = 1.7156*(doub()-0.5); x = u - 0.449871; y = fabs(v) + 0.386595; q = pow(x,2) + y*(0.19600*y-0.25472*x); } while(q>0.27597 && (q>0.27846 || pow(v,2)>-4.*log(u)*pow(u,2))); return N.mu+N.sig*v/u; } }; //+------------------------------------------------------------------+
Como pode ser visto, a classe tem um elemento de dado N do tipo CNormaldist. O código original C carecido de tal ligação com a distribuição. Eu o considerei necessário para uma variável aleatória gerada pela classe (aqui, pela classe CNormaldev) para ter uma conexão lógica e programática com a sua distribuição.
Na versão original, o tipo Normaldev foi definido, como segue:
typedef double Doub; typedef unsigned __int64 Ullong; struct Normaldev : Ran { Doub mu,sig; Normaldev(Doub mmu, Doub ssig, Ullong i) ... }
Os números aleatórios são gerados aqui a partir distribuição normal usando a relação do método uniforme do Leva.
Todas as outras classes que auxiliam no cálculo de variáveis aleatórias de várias distribuições, estão situadas no arquivo Random_class.mqh de inclusão.
Vamos agora terminar com a geração e ver, na parte prática do artigo, como criar uma matriz de valores e testar uma amostra.
2. Estimativa dos parâmetros de distribuição, hipóteses estatísticas
É claro que vamos olhar para variáveis discretas. Na prática, no entanto, se o número de variáveis discretas é significativo, é mais conveniente considerar o conjunto de variáveis discretas tais como um grupo de variáveis contínuas. Esta é uma abordagem padrão em estatísticas matemáticas. Portanto, para a sua análise, podemos usar as distribuições definidas pelas fórmulas analíticas que estão relacionadas com as variáveis contínuas.
Então, deixe-nos dar atenção a análise da distribuição empírica.
Supõe-se que uma amostra de uma população geral, cujos membros satisfazem o critério de representatividade está sob estudo. Além disso, os requisitos para as estimativas especificadas na seção 8.3 [9] são cumpridas. Os parâmetros de distribuição numérica podem ser encontrados por meio da estimação de pontos e métodos de intervalo.
2.1 Manuseio da amostra usando a classe CExpStatistics
Deve-se eliminar primeiro os chamados discrepantes da amostra, as quais são observações que se desviam significativamente a partir das observações da maior parte da amostra (tanto para cima como para baixo). Não existe nenhum método universal para eliminar os discrepantes.
Eu sugiro usar o descrito por S.V. Bulashev na seção 6.3 [5]. No fórum MQL4, uma biblioteca de funções estatísticas foi criada com base na qual o dado problema pode ser facilmente resolvido. Dito isto, vamos certamente aplicar OOP e atualizá-lo um pouco.
Liguei para a classe criada de estimativas de características estatísticas CExpStatistics (Classe de estatísticas esperadas).
Ela é aproximadamente da seguinte forma:
//+------------------------------------------------------------------+ //| Expected Statistics class definition | //+------------------------------------------------------------------+ class CExpStatistics { private: double arr[]; //initial array int N; //initial array size double Parr[]; //processed array int pN; //processed array size void stdz(double &outArr_st[],bool A); //standardization public: void setArrays(bool A,double &Arr[],int &n); //set array for processing bool isProcessed; //array processed? void CExpStatistics(){}; //constructor void setCExpStatistics(double &Arr[]); //set the initial array for the class void ZeroCheckArray(bool A); //check the input array for zero elements int get_arr_N(); //get the initial array length double median(bool A); //median double median50(bool A); //median of 50% interquantile range (midquartile range) double mean(bool A); //mean of the entire initial sample double mean50(bool A); //mean of 50% interquantile range double interqtlRange(bool A); //interquartile range double RangeCenter(bool A); //range center double meanCenter(bool A); //mean of the top five estimates double expVariance(bool A); //estimated variance double expSampleVariance(bool A); //shifted estimate of sample variance double expStddev(bool A); //estimated standard deviation double Moment(int index,bool A,int sw,double xm); //moment of distribution double expKurtosis(bool A,double &Skewness); ////estimated kurtosis and skewness double censorR(bool A); //censoring coefficient int outlierDelete(); //deletion of outliers from the sample int pArrOutput(double &outArr[],bool St); //processed array output void ~CExpStatistics(){};//destructor }; //+------------------------------------------------------------------+
A implementação de cada método pode ser estudada no arquivo incluso ExpStatistics_class.mqh, por isso vou deixá-lo aqui.
O ponto importante desta classe é que ela retorna a matriz livre de discrepantes (Parr[]), se houver. Além disso, ajuda na obtenção de algumas estatísticas descritivas de amostragem e de suas estimativas.
2.2 Criando um histograma de amostra processado
Agora que a matriz é livre de discrepantes, um histograma (distribuição de frequência), pode ser desenhado com base em seus dados. Ele nos ajudará a estimar visualmente a lei de distribuição variável aleatória. Existe um procedimento passo a passo para criar um histograma.
Deve-se primeiro calcular o número de classes obrigatórias. Neste contexto, o termo "classe" significa agrupamento, intervalo. O número de classes é calculado pela fórmula de Sturges:
Onde k é o número de classes, n é o número de observações.
Em MQL5 a fórmula pode ser representada da seguinte forma:
int Sturges(int n) /* Function for determining the number of class intervals using Sturges' rule. Variables: y is the number of sampling observations. Returned value: number of class intervals. */ { double s; // Returned value s=1.+log2(y); if(s>15) // Empirical rule s=15; return(int) floor(s); }
Quando o número necessário de classes (intervalos) foi recebido usando a fórmula de Sturges, é hora de quebrar os dados da matriz em classes. Tais dados são chamados de observações sing.(observação). O faremos usando a função Allocate, como segue:
void Allocate(double &data[],int n,double &f[],double &b[],int k) /* Function for allocating observations to classes. Variables: 1) data — initial sample (array) 2) n — sample size 3) f — calculated array of observations allocated to classes 4) b — array of class midpoints 5) k — number of classes */ { int i,j; // Loop counter double t,c; // Auxiliary variable t=data[ArrayMinimum(data)]; // Sample minimum t=t>0 ? t*0.99 : t*1.01; c=data[ArrayMaximum(data)]; // Sample maximum c=c>0 ? c*1.01 : c*0.99; c=(c-t)/k/2; // Half of the class interval b[0]=t+c; // Array of class interval midpoints f[0]= 0; for(i=1; i<k; i++) { b[i] = b[i - 1] + c + c; f[i] = 0; } // Grouping for(i=0; i<n; i++) for(j=0; j<k; j++) if(data[i]>b[j]-c && data[i]<=b[j]+c) { f[j]++; break; } }
Como pode ser visto, a função leva na matriz das observações iniciais (de dados), sua duração (n), o número de classes (k) e aloca as observações para uma determinada f[i] classe da matriz f, onde b[i] é o ponto médio f[i] da classe. Os dados do histograma estão pronto agora.
Vamos mostrar o histograma usando as ferramentas descritas no artigo mencionado anteriormente. Para este efeito, eu escrevi a função histogramSave que exibirá o histograma para a série em estudo em HTML. A função usa dois parâmetros: matriz de classes (f) e matriz de pontos médios de classe (b).
Como exemplo, eu construí um histograma a partir das diferenças absolutas entre máximos e mínimos de 500 barras do par EURUSD no prazo de quatro horas em pontos usando o script volatilityTest.mq5.
Figura 1. Histograma de dados (volatilidade absoluta do EURUSD H4)
Como mostrado no histograma (Fig. 1), a primeira classe tem 146 observações, a segunda 176, etc. A função do histograma é dar uma ideia visual da distribuição empírica da amostra em estudo.
Figura 2. Histograma de dados (retornos padronizados do EURUSD H4)
O outro histograma (Fig.2) exibe retornos logarítmicos padronizados de 500 barras do par EURUSD no período de tempo de H4. Como você pode notar, a quarta e quinta classes são as mais impressionantes como elas adquirem 244 e 124 observações, respectivamente. Este histograma foi construído usando o script returnsTest.mq5.
Assim, o histograma nos permite escolher a lei de distribuição dos parâmetros que vai ser a mais estimada. Quando não é visualmente óbvio qual distribuição preferir, você pode estimar parâmetros de várias distribuições teóricas.
Ambas as distribuições que consideramos não se assemelham aos normais em aparência, especialmente o primeiro. No entanto, não vamos confiar a representação visual e prosseguir com os números.
2.3 Hipótese de normalidade
Ela é usual para primeiramente resolver e testar a suposição (hipótese) de se a distribuição em questão é normal. Tal hipótese é chamada a hipótese principal. Um dos métodos mais populares para testar a normalidade de uma amostra é o teste Jarque-Bera.
Seu algoritmo, embora não seja mais complexo, é bastante volumoso devido a aproximação. Há algumas versões do algoritmo em C++ e outras linguagens. Uma das versões mais bem sucedidas e comprovadas é uma versão situada em uma biblioteca de análise numérica de plataforma cruzada ALGLIB. Seu autor [S.A Bochkanov] fez um trabalho enorme, especialmente na compilação da tabela quantil de test. Eu só a atualizei ligeiramente às necessidades do MQL5.
A principal função de jarqueberatest é, como se segue:
//+------------------------------------------------------------------+ // the Jarque-Bera Test | //+------------------------------------------------------------------+ void jarqueberatest(double &x[],double &p) /* The Jarque-Bera test is used to check hypothesis about the fact that a given sample xS is a sample of normal random variable with unknown mean and variance. Variables: x - sample Xs; p - p-value; */ { int n=ArraySize(x); double s; p=0.; if(n<5)//N is too small { p=1.0; return; } //N is large enough jarquebera_jarqueberastatistic(x,n,s); p=jarquebera_jarqueberaapprox(n,s); } //+------------------------------------------------------------------+
Ela trata da amostra de dados iniciais (x) e retorna ao valor-p, ou seja, um valor que caracteriza a probabilidade de rejeitar a hipótese nula se a hipótese nula for de fato verdade.
Há duas funções auxiliares no corpo da função. A primeira função - jarquebera_jarqueberastatistic - calcula a estatística Jarque-Bera, e a segunda - jarquebera_jarqueberaapprox - calcula o valor-p. Deve notar-se que a último, por sua vez, põe em ação funções auxiliares relacionadas com aproximação, que são quase 30 no algoritmo.
Logo, vamos tentar testar nossas amostras para a normalidade. Vamos usar o script returnsTest.mq5 que irá tratar a amostra dos retornos padronizados do EURUSD H4.
Como esperado, o teste mostrou que a probabilidade de rejeição de uma hipótese nula verdadeira é de 0,0000. Em outras palavras, a distribuição da amostra não pertence à família das distribuições normais. A fim de tratar a amostra de volatilidade absoluta do par EURUSD, execute o script volatilityTest.mq5. O resultado será semelhante - a distribuição não é normal.
3. Ajuste da distribuição
Há alguns métodos de estatística matemática que permitem a comparação da distribuição empírica com a distribuição normal. O maior problema é que os parâmetros de distribuição normais não são conhecidos por nós e há um pressuposto de que os dados em estudo não refletem a normalidade de uma distribuição.
Portanto, temos de usar os testes não paramétricos e preencher os parâmetros desconhecidos com as estimativas obtidas a partir da distribuição empírica.
3.1 Estimativa e testes
Um dos testes mais populares, o que é mais importante, e adequados nesta situação é o teste χ2. Ele de baseia na medida da bondade ajuste de Pearson.
Vamos realizar o teste utilizando a função chsone:
void chsone(double &f[],double &ebins[],double &df, double &chsq,double &prob,const int knstrn=1) /* 1) f — array of observations allocated to classes 2) ebins - array of expected frequencies 3) df - number of degrees of freedom 3) chsq — chi-square statistics 4) prob - probability of accepting a true null hypothesis 5) knstrn — constraint */ { CGamma gam; int j,nbins=ArraySize(bins),q,g; double temp; df=nbins-knstrn; chsq=0.0; q=nbins/2; g=nbins-1; for(j=0;j<nbins/2;j++) //passing through the left side of the distribution { if(ebins[j]<0.0 || (ebins[j]==0. && bins[j]>0.)) Alert("Bad expected number in chsone!"); if(ebins[j]<=5.0) { --df; ebins[j+1]+=ebins[j]; bins[j+1]+=bins[j]; } else { temp=bins[j]-ebins[j]; chsq+=pow(temp,2)/ebins[j]; } } for(j=nbins-1;j>nbins/2-1;j--) //passing through the right side of the distribution { if(ebins[j]<0.0 || (ebins[j]==0. && bins[j]>0.)) Alert("Bad expected number in chsone!"); if(ebins[j]<=5.0) { --df; ebins[j-1]+=ebins[j]; //starting with the last class bins[j-1]+=bins[j]; } else { temp=bins[j]-ebins[j]; chsq+=pow(temp,2)/ebins[j]; } } if(df<1)df=1; //compensate prob=gam.gammq(0.5*df,0.5*chsq); //Chi-square probability function }
Como pode ser visto na lista, uma instância da classe CGamma é usada representando a função gama incompleta, que está incluída no arquivo Distribution_class.mqh, bem como todas as distribuições mencionadas. Também deve ser notado que a matriz de frequências esperadas (ebins) serão obtidas usando as funções estimateDistribution e expFrequency.
Agora precisamos selecionar os parâmetros numéricos que estão incluídos na fórmula analítica para a distribuição teórica. O número de parâmetros depende da distribuição particular. Por exemplo, existem dois parâmetros na distribuição normal, e um parâmetro na distribuição exponencial, etc.
Ao determinar os parâmetros de distribuição geralmente usamos esses métodos de estimativas de ponto como o método dos momentos, o método quantil e o método de probabilidade máxima. O primeiro é mais simples, uma vez que implica que as estimativas de amostragem (expectativa, variância, assimetria, etc.) devem coincidir com as estimativas gerais.
Vamos tentar selecionar uma distribuição teórica para nossa amostra usando um exemplo. Vamos tomar uma série de retornos padronizados do EURUSD H4 para o qual já temos elaborado um histograma.
A primeira impressão é que a distribuição normal não é apropriada para séries como o excesso de coeficiente de curtose é observado. Como comparação, vamos tentar aplicar outra distribuição.
Então, quando se inicia o script já conhecido returnsTest.mq5, nós estamos tentando selecionar essa distribuição como Hypersec. Além disso, o script irá calcular e emitir os parâmetros de distribuição selecionados usando a função estimateDistribution e executar imediatamente o teste χ2 test. Os parâmetros de distribuição selecionados têm se concentrado, como segue:
Distribuição da secante hiperbólica: X~HS(-0.00, 1.00);
e os resultados dos testes foram, como se segue:
"Estatística qui-quadrado: 1,89; probabilidade de rejeitar uma hipótese nula verdadeira: 0,8648 "
Deve notar-se que a distribuição selecionada é um bom ajuste como o valor da estatística χ2 é muito pequeno.
Além disso, usando a função histogramSaveE um histograma duplo para os índices de frequência observados e esperados (taxa de frequência é uma frequência expressa em fração ou porcentagem) dos retornos padronizados serão sorteados (Fig. 3). Você pode ver que as barras quase se duplicam. Esta é uma prova de ajuste bem sucedido.
Figura 3. Histograma dos índices de frequência observados e esperados (retornos padronizados do EURUSD H4)
Deixe-nos realizar um procedimento semelhante para dados de volatilidade utilizando o volatilityTest.mq5 já conhecido.
Figura 4. Histograma dos índices de frequência observados e esperados (volatilidade absoluta do EURUSD H4)
Selecionei a distribuição lognormal Lognormal para testes. Como resultado, a seguinte estimativa dos parâmetros foi recebida:
Distribuição lognormal: X~Logn(6.09, 0.53);
e os resultados dos testes foram, como se segue:
"Estatística qui-quadrado: 6,17; probabilidade de rejeitar uma hipótese nula verdadeira: 0,4040 "
A distribuição teórica para esta distribuição empírica foi também selecionada com bastante êxito. Assim, pode-se considerar que a hipótese nula não pode ser rejeitada (no padrão de nível de confiança p=0.05). Pode-se ver na fig. 4 que as barras dos índices de frequência esperados e observados também são muito parecidos.
Deixe-me lembrá-lo que nós temos uma outra possibilidade de gerar uma amostra de variáveis aleatórias a partir de uma distribuição com parâmetros definidos. Para utilizar uma hierarquia de classes relacionadas a tal operação, eu escrevi o script randomTest.mq5.
No início do mesmo, precisamos introduzir os parâmetros como mostrado na Fig. 5.
Figura 5. Parâmetros de entrada do script de Test.mq5 aleatório
Aqui você pode selecionar o tipo de distribuição (tipo de distribuição), o número das variáveis aleatórias em uma amostra (tamanho da amostra), a opção de salvamento da amostra (escrever dados da amostra), o parâmetro ( para distribuição t Student) Nu, os parâmetros Mu e Sigma.
Se você definir para escrever dados da amostra de valor verdadeiro, o script irá salvar a amostra de variáveis aleatórias com os parâmetros personalizados para o arquivo Randoms.csv. Caso contrário, ele irá ler os dados da amostra deste arquivo e, em seguida, realizar testes estatísticos.
Para algumas distribuições com falta de parâmetros Mu e Sigma, eu forneci uma tabela de correlação de parâmetro para os campos na janela de início do script.
| Distribuição | Primeiro parâmetro de distribuição | Segundo parâmetro de distribuição |
|---|---|---|
| Logístico | alph --> Mu | bet --> Sigma |
| Exponencial | alph --> Mu | -- |
| Gamma | alph --> Mu | bet --> Sigma |
| Beta | alph --> Mu | bet --> Sigma |
| Laplace | alph --> Mu | bet --> Sigma |
| Binomial | alph --> Mu | pe --> Sigma |
| Poisson | alph --> Mu | -- |
Por exemplo, se a distribuição Poisson é selecionada, o parâmetro lambda será inserido através do campo de Mu, etc.
O script não estima parâmetros de distribuição t Student, porque na maioria absoluta dos casos, eles só são utilizados em alguns procedimentos estatísticos: estimativa pontual, construção de intervalos de confiança e testes de hipóteses que dizem respeito à média desconhecida de uma amostra estatística da distribuição normal.
Como exemplo, eu executei o script para a distribuição normal com os parâmetros X~Nor(3.50, 2.77) onde os dados da amostra escrita=verdadeiro. O script gerou pela primeira vez uma amostra. Após a segunda execução os dados da amostra escritos=falso, um histograma foi elaborado conforme mostrado na Fig.6.
Figura 6. A amostra de variáveis aleatórias X ~ Nor (3.50,2.77)
A informação restante exibida na janela do terminal é, como se segue:
O teste Jarque-Bera: O teste de Jarque-Bera: probabilidade de rejeitar uma hipótese nula verdadeira é 0,9381";
Estimativa do parâmetro: Distribuição normal: X~Nor(3.58, 2.94);
Resultados do teste qui-quadrado: "Estatística qui-quadrado: 0,38; probabilidade de rejeitar uma hipótese nula verdadeira: 0.9843".
E finalmente, uma outra dupla histograma dos índices de frequência observados e esperados para a amostra foi apresentado (Fig. 7).
Figura 7. Histograma dos índices de frequência observados e esperados para X ~ Nor(3.50,2.77)
Em geral, a geração da distribuição especificada foi bem sucedida.
Eu também escrevi o script fitAll.mq5 que funciona de forma semelhante ao script randomTest.mq5. A única diferença é que o primeiro tem a função fitDistributions. Eu defini a seguinte tarefa: ajustar todas as distribuições disponíveis para uma amostra de variáveis aleatórias e realizar um teste estatístico.
Nem sempre é possível ajustar uma distribuição de uma amostra devido a incompatibilidade do parâmetro que leva ao aparecimento de linhas no terminal informando que a estimativa não é possível, por exemplo, "Distribuição beta não pode ser calculada!".
Além disso, eu decidi que este script deve visualizar os resultados estatísticos na forma de um pequeno relatório HTML, um exemplo do que pode ser encontrado no artigo "Gráficos e diagramas em HTML" (Fig. 8).
Figura 8. Relatório estatístico sobre a estimação da amostra
Um histograma padrão da amostra é apresentado no quadrante superior esquerdo, o quadrante superior direito representa as estatísticas descritivas e resultado de teste Jarque-Bera, onde o valor da variável processada igual a 1 significa que os discrepantes foram excluídos, enquanto um valor 0 significa que não houve valores discrepantes.
Valores P do teste χ2 para cada distribuição selecionada são exibidos no quadrante inferior esquerdo. Aqui, a distribuição normal acabou por ser o melhor em termos de montagem (p = 0,9926). Portanto, um histograma dos índices de frequência observados e esperados foi elaborado por ele no quadrante do canto inferior direito.
Não existem tantas distribuições em minha galeria ainda. Mas esse script fará você economizar muito tempo se houver um grande número de distribuições.
Agora que sabemos exatamente os parâmetros da distribuição das amostras em estudo, podemos prosseguir com o raciocínio probabilístico.
3.2 Probabilidades de valores de variáveis aleatórias
No artigo sobre distribuições teóricas eu dei o script continuousDistribution.mq5 como exemplo. Com ele, vamos tentar exibir qualquer lei de distribuição com parâmetros conhecidos que podem ser de interesse para nós.
Assim, para os dados de volatilidade, vamos introduzir os parâmetros de distribuição lognormal obtidos anteriormente (Mu=6.09, Sigma=0.53), selecione o tipo de distribuição lognormal e o modo cdf (Fig.9).
Figura 9. Parâmetros de distribuição lognormal X ~ Logn (6.09,0.53)
O script exibirá a função de distribuição de nossa amostra. Ele aparece como mostrado na Fig. 10.
Figura 10. Função de distribuição para X~Logn(6.09,0.53)
Podemos ver no gráfico que o cursor está apontado para um ponto cujas coordenadas são aproximadamente [665;0.78]. Isto significa que existe uma probabilidade de 78% que a volatilidade do EURUSD H4 não será superior a 665 pontos. Esta informação pode vir a ser muito útil para um desenvolvedor de um Expert Advisor. Pode-se, certamente ter outros valores na curva, movendo o cursor.
Vamos supor que estamos interessados na probabilidade do evento quando o valor de volatilidade estiver no intervalo entre 500 e 750 pontos. Para este propósito a operação seguinte precisa de ser realizada:
cdf(750) - cdf(500) = 0.84 - 0.59 = 0.25.
Assim, num quarto de eventos a volatilidade do par varia no intervalo compreendido entre 500 e 750 pontos.
Deixe-nos executar o script com os mesmos parâmetros de distribuição mais uma vez apenas selecionando sf como um modo de lei de distribuição. A função de fiabilidade (sobrevivência) vai ser mostrada, como se segue (Fig. 11).
Figura 11. Função de sobrevivência para X~Logn(6.09,0.53)
O ponto marcado no gráfico de curva pode ser interpretado da seguinte maneira: podemos esperar com cerca de 75% de probabilidade de que a volatilidade do par será de 310 pontos. Quanto mais inferiormente descemos a curva, menor a probabilidade da volatilidade aumentar. Assim, a volatilidade de mais de 1000 pontos já pode ser considerada um evento raro como a probabilidade de ocorrência da mesma é inferior a 5%.
Curvas de distribuição semelhantes podem ser construídas para a amostra de retornos padronizados, bem como para outras amostras. Suponho que a metodologia é geralmente clara.
Conclusão
Deve notar-se que as derivações analíticas propostas não são totalmente bem sucedidas como as séries tendem a variar. Embora, por exemplo, ela não diga respeito a série de retornos logarítmicos. No entanto, eu não me incumbo de avaliar os métodos neste artigo definido. Sugiro que o leitor interessado teça um comentário sobre esta questão.
É importante ressaltar a necessidade de se considerar o mercado, instrumentos de mercado e especialistas em comércio a partir da perspectiva de probabilidade. Esta é a abordagem que eu tentei demonstrar. Espero que este assunto desperte o interesse do leitor e leve a uma discussão construtiva.
Localização de arquivos:
| # | Arquivo | Via | Descrição |
|---|---|---|---|
| 1 | Distribution_class.mqh | %MetaTrader%\MQL5\Include | Galeria de distribuição de classes |
| 2 | DistributionFigure_class.mqh | %MetaTrader%\MQL5\Include | Classes para exibição gráfica das distribuições |
| 3 | Random_class.mqh | %MetaTrader%\MQL5\Include | Classes para a geração de uma amostra de número aleatório |
| 4 | ExpStatistics_class.mqh | %MetaTrader%\MQL5\Include | Classe e funções da estimativa de características estatísticas |
| 5 | volatilityTest.mq5 | %MetaTrader%\MQL5\Scripts | Script para a estimativa da amostra de volatilidade EURUSD H4 |
| 6 | returnsTest.mq5 | %MetaTrader%\MQL5\Scripts | Script para a estimativa da amostra de retorno EURUSD H4 |
| 7 | randomTest.mq5 | %MetaTrader%\MQL5\Scripts | Script para a estimativa da amostra variável aleatória |
| 8 | fitAll.mq5 | %MetaTrader%\MQL5\Scripts | Script para instalação e estimativa de todas as distribuições |
| 9 | Volat.csv | %MetaTrader%\MQL5\Files | Arquivo de dados da amostra de volatilidade EURUSD H4 |
| 10 | Returns_std.csv | %MetaTrader%\MQL5\Files | Arquivo de dados da amostra de retorno EURUSD H4 |
| 11 | Randoms.csv | %MetaTrader%\MQL5\Files | Arquivo de dados variáveis aleatórios |
| 12 | Histogram.htm | %MetaTrader%\MQL5\Files | Histograma da amostra em HTML |
| 13 | Histogram2.htm | %MetaTrader%\MQL5\Files | Histograma duplo da amostra em HTML |
| 14 | chi_test.htm | %MetaTrader%\MQL5\Files | Relatório HTML estatístico da estimativa da amostra |
| 15 | dataHist.txt | %MetaTrader%\MQL5\Files | Dados para a exibição de um histograma de amostras |
| 16 | dataHist2.txt | %MetaTrader%\MQL5\Files | Dados para a exibição de um histograma duplo de amostras |
| 17 | dataFitAll.txt | %MetaTrader%\MQL5\Files | Dados para exibição do relatório HTML |
| 18 | highcharts.js | %MetaTrader%\MQL5\Files | Biblioteca JavaScript de gráficos interativos |
| 19 | jquery.min.js | %MetaTrader%\MQL5\Files | JavaScript library |
| 20. | ReturnsIndicator.mq5 | %MetaTrader%\MQL5\Indicators | Indicador de retorno logaritimético |
Materiais de Referência:
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/257
Filtragem de Sinais com Base em Dados Estatísticos de Correlação de Preço
Usando Pseudo-modelos como Alternativa para Modelos C++
3 Métodos de Aceleração de Indicadores através do Exemplo da Regressão Linear
Usando Indicadores MetaTrader 5 com Estrutura de Aprendizado de Máquina ENCOG para Previsão das Séries Temporais
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso