Aprendizaje automático en el trading: teoría, práctica, operaciones y más - página 3256

Nuevo comentario
 
Forester #:
La correlación de la matriz de todas las filas con todas las filas se considera muchas veces más rápida que los ciclos (1 fila con cada dos filas) e incluso que el bucle (1 fila con todas las filas). Hay algún tipo de aceleración allí debido al algoritmo. Lo he comprobado en la versión alglib del cálculo de correlación.

Dame el código, vamos a comprobarlo.

 
fxsaber #:


  2. Encontramos situaciones en las que MathAbs(corr[i]) > 0,9.

MathAbs () me parece innecesario

 
fxsaber #:

Debe ser alguna peculiaridad de Python, porque el algoritmo es el mismo en MQL.

  1. Corremos a través de la 1d-array de Pos-variables.
  2. [Pos-n, Pos] - otro patrón.
  3. Aplicamos algo similar a este patrón y 1d-array.
  4. Encontramos situaciones en las que MathAbs(corr[i]) > 0.9.
  5. En estos lugares miramos m barras por delante del comportamiento del precio y lo promediamos.
  6. Encontramos muchos lugares y los promediamos bien? - guardamos los datos del patrón (valores del paso 2).
  7. Pos++ y en p.2.

Esta es una variante frontal. La criba es aún más rápida.


Supongamos un millón de barras. La longitud de la cadena es 10. Entonces 1d-array para 10 millones de valores dobles es 80 Mb. p.3. - Pues bien, que sean 500 Mb en términos de consumo de memoria. ¿Qué es lo que no he tenido en cuenta?

Yo mismo estaba desconcertado porque ninguna librería en Python puede calcularlo, así que acabé confundido.

Pandas desborda la RAM, el overhead es gigantesco.

Nampai simplemente se bloquea y mata la sesión del intérprete :) sin mostrar ningún error.

Puedes hacer un colador, tendrías que reescribir todo el código.
 
fxsaber #:

Dame el código, vamos a comprobarlo.

en statistics.mqh.

functions
PearsonCorrM - La correlación de todas las filas con todas las filas es la más 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 - Correlación fila a fila. Para una matriz completa: la 1ª fila se comprueba con todas las filas después de la 1, la 2ª fila con todas las filas después de la 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)



Y a través de PearsonCorrM2 puede escribir la matriz completa en 1 matriz y otra fila a comprobar. Pero es obvio que hay trabajo innecesario, porque para la décima fila la correlación con las filas por encima de 10 ya está calculada.

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


Compruebe en una matriz de alrededor de 5k * 20k. Si es 100*100 será rápido.
 
Numpy una matriz de 20k*20k pesa 2gb
 
Maxim Dmitrievsky #:
Una matriz Numpy de 20k*20k pesa 2gb.

400 millones de números dobles pesan 3 gigas.

 
mytarmailS #:

MathAbs () me parece redundante.

También puedes comprobar los signos por separado. No es el punto.

 
fxsaber #:

400 millones de números dobles pesan 3 gigabytes.

Es comprensible, no hay memoria suficiente para tanta alegría.

 
Forester #:
en statistics.mqh.

functions
PearsonCorrM - La correlación de todas las filas con todas las filas es la más rápida.

Mal en alguna parte, pero no lo veo. 
#include <Math\Alglib\statistics.mqh> 

void OnStart()
{
  const matrix<double> matrix1 = {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}};
  
  const CMatrixDouble Matrix1(matrix1);
  CMatrixDouble Matrix2;
    
  if (CBaseStat::PearsonCorrM(Matrix1, 3, 3, Matrix2))  
    Print(Matrix2.ToMatrix());
}
 
fxsaber #:
En algún sitio me equivoco, pero no lo veo.

Pero funciona con esta cadena

const matrix<double> matrix1 = {{2, 2, 3}, {3, 2, 3}, {1, 2, 1}};

[[1,0,0.8660254037844387]
[0,0,0]
[0.8660254037844387,0,1]]

Por lo visto, si todos los datos de una columna son iguales, se salta el cálculo.
En la 2ª columna dejé todos los datos en 2 y la 2ª fila de la matriz quedó a cero. Aunque probablemente sea correcto rellenar la diagonal con 1s.

PD. Al principio pensé que era un bug de Alglib.

En el código antiguo los valores de los elementos se establecían mediante
m[row].Set(col, val);
Y ahora
m.Set(row,col, val);

Es una pena que no haya compatibilidad hacia atrás. Bueno, a mi no me importa. Ahora no estoy trabajando con Alglib. Si los códigos antiguos de alguien dejan de funcionar, habrá que arreglarlo.
Lo más triste es que la versión antigua de

m[row].Set(col, val);

no escribe mensajes de error, simplemente no hace nada. La gente simplemente no reemplazará y no sabrá que necesita cambiar el código. Contará algo, pero con matrices sin cambiar.

1...324932503251325232533254325532563257325832593260326132623263...3399
Nuevo comentario
Razón de la queja: