Aprendizado de máquina no trading: teoria, prática, negociação e não só - página 3256

Novo comentário
 
Maxim Dmitrievsky #:
Estouro de memória em TFs pequenos. A memória transborda com 16 osu e arquivo de troca (swap em um mac) de 30gig. Por exemplo, há uma matriz de correlação de 50k por 50k.

Aparentemente, algumas peculiaridades do Python, pois o algoritmo é o mesmo no MQL.

  1. Executar na matriz 1d da variável Pos.
  2. [Pos-n, Pos] - outro padrão.
  3. Aplicamos algo semelhante a esse padrão e ao 1d-array.
  4. Encontramos situações em que MathAbs(corr[i]) > 0,9.
  5. Nesses locais, analisamos as barras m anteriores ao comportamento do preço e calculamos a média.
  6. Encontramos muitos lugares e calculamos a média de forma adequada? - salvamos os dados do padrão (valores da etapa 2).
  7. Pos++ e na p.2.

Essa é uma variante frontal. É ainda mais rápido com uma peneira.


Vamos supor um milhão de barras. O comprimento da string é 10. Então, 1d-array para 10 milhões de valores duplos é 80 Mb. ponto 3. - Bem, que seja 500 Mb em termos de consumo de memória. O que eu não levei em conta?

 
fxsaber #:

Deve ser alguma peculiaridade do Python, pois o algoritmo é o mesmo no MQL.

  1. Percorremos o 1d-array de variáveis Pos.
  2. [Pos-n, Pos] - outro padrão.
  3. Aplicamos algo semelhante a esse padrão e ao 1d-array.
  4. Encontramos situações em que MathAbs(corr[i]) > 0,9.
  5. Nesses locais, analisamos as barras m antes do comportamento do preço e calculamos a média.
  6. Encontramos muitos lugares e calculamos a média de forma adequada? - salvamos os dados do padrão (valores da etapa 2).
  7. Pos++ e na p.2.

Essa é uma variante frontal. A peneira é ainda mais rápida.


Vamos supor um milhão de barras. O comprimento da cadeia é 10. Então, 1d-array para 10 milhões de valores duplos é 80 Mb. p.3. - Bem, que seja 500 Mb em termos de consumo de memória. O que eu não levei em conta?

A correlação da matriz de todas as linhas com todas as linhas é considerada muitas vezes mais rápida do que os ciclos (1 linha com cada outra linha) ou até mesmo um loop (1 linha com todas as linhas). Há algum tipo de aceleração devido ao algoritmo. Verifiquei isso na versão alglib do cálculo de correlação.
 
Forester #:
A correlação da matriz de todas as linhas com todas as linhas é considerada muitas vezes mais rápida do que os ciclos (1 linha com cada outra linha) e até mesmo o loop (1 linha com todas as linhas). Há algum tipo de aceleração devido ao algoritmo. Verifiquei isso na versão alglib do cálculo de correlação.

Dê-me o código, vamos verificar.

 
fxsaber #:


  2. Encontramos situações em que MathAbs(corr[i]) > 0,9.

MathAbs () parece desnecessário para mim

 
fxsaber #:

Deve ser alguma peculiaridade do Python, pois o algoritmo é o mesmo no MQL.

  1. Percorremos o 1d-array de variáveis Pos.
  2. [Pos-n, Pos] - outro padrão.
  3. Aplicamos algo semelhante a esse padrão e ao 1d-array.
  4. Encontramos situações em que MathAbs(corr[i]) > 0,9.
  5. Nesses locais, analisamos as barras m antes do comportamento do preço e calculamos a média.
  6. Encontramos muitos lugares e calculamos a média de forma adequada? - salvamos os dados do padrão (valores da etapa 2).
  7. Pos++ e na p.2.

Essa é uma variante frontal. A peneira é ainda mais rápida.


Vamos supor um milhão de barras. O comprimento da cadeia é 10. Então, 1d-array para 10 milhões de valores duplos é 80 Mb. p.3. - Bem, que seja 500 Mb em termos de consumo de memória. O que eu não levei em conta?

Eu mesmo fiquei perplexo com o fato de nenhuma biblioteca em Python poder calcular isso, então acabei ficando confuso.

O Pandas transborda a RAM, a sobrecarga é gigantesca.

O Nampai simplesmente trava e mata a sessão do interpretador :) sem exibir nenhum erro.

Você pode fazer uma peneira, mas teria que reescrever todo o código.
 
fxsaber #:

Dê-me o código, vamos dar uma olhada.

em statistics.mqh.

functions
PearsonCorrM - A correlação de todas as linhas com todas as linhas é a mais rápida.

//+------------------------------------------------------------------+
//| Pearson product-moment correlation matrix                        |
//| INPUT PARAMETERS:                                                |
//|     X   -   array[N,M], sample matrix:                           |
//|             * J-th column corresponds to J-th variable           |
//|             * I-th row corresponds to I-th observation           |
//|     N   -   N>=0, number of observations:                        |
//|             * if given, only leading N rows of X are used        |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//|     M   -   M>0, number of variables:                            |
//|             * if given, only leading M columns of X are used     |
//|             * if not given, automatically determined from input  |
//|               size                                               |
//| OUTPUT PARAMETERS:                                               |
//|     C   -   array[M,M], correlation matrix (zero if N=0 or N=1)  |
//+------------------------------------------------------------------+
static bool CBaseStat::PearsonCorrM(const CMatrixDouble &cx,const int n,
                                    const int m,CMatrixDouble &c)

PearsonCorr2 - Correlação linha a linha. Para uma matriz completa: a 1ª linha é verificada com todas as linhas após 1, a 2ª linha com todas as linhas após a 2ª, etc.

//+------------------------------------------------------------------+
//| Pearson product-moment correlation coefficient                   |
//| Input parameters:                                                |
//|     X       -   sample 1 (array indexes: [0..N-1])               |
//|     Y       -   sample 2 (array indexes: [0..N-1])               |
//|     N       -   N>=0, sample size:                               |
//|                 * if given, only N leading elements of X/Y are   |
//|                   processed                                      |
//|                 * if not given, automatically determined from    |
//|                   input sizes                                    |
//| Result:                                                          |
//|     Pearson product-moment correlation coefficient               |
//|     (zero for N=0 or N=1)                                        |
//+------------------------------------------------------------------+
static double CBaseStat::PearsonCorr2(const double &cx[],const double &cy[],
                                      const int n)



E, por meio do PearsonCorrM2, você pode escrever a matriz completa em uma matriz e outra linha a ser verificada. Mas há um trabalho desnecessário óbvio, porque para a 10ª linha a correlação com as linhas acima de 10 já está calculada.

static bool CBaseStat::PearsonCorrM2(const CMatrixDouble &cx,const CMatrixDouble &cy,
                                     const int n,const int m1,const int m2,
                                     CMatrixDouble &c)


Verifique em uma matriz de cerca de 5k*20k. Se for 100*100, será rápido.
 
Numpy uma matriz de 20k*20k pesa 2gb
 
Maxim Dmitrievsky #:
Uma matriz Numpy de 20k*20k pesa 2gb.

400 milhões de números duplos pesam 3 gigas.

 
mytarmailS #:

MathAbs () parece redundante para mim.

Você também pode verificar os sinais separadamente. Não é esse o ponto.

 
fxsaber #:

400 milhões de números duplos pesam 3 gigabytes.

É compreensível, não há memória suficiente para toda essa alegria.

1...324932503251325232533254325532563257325832593260326132623263...3399
Novo comentário
Razão: