Aprendizaje automático en el trading: teoría, práctica, operaciones y más - página 3256
![MQL5 - Lenguaje de estrategias comerciales para el terminal de cliente MetaTrader 5](https://c.mql5.com/i/registerlandings/logo-2.png)
Está perdiendo oportunidades comerciales:
- Aplicaciones de trading gratuitas
- 8 000+ señales para copiar
- Noticias económicas para analizar los mercados financieros
Registro
Entrada
Usted acepta la política del sitio web y las condiciones de uso
Si no tiene cuenta de usuario, regístrese
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.
MathAbs () me parece innecesario
Debe ser alguna peculiaridad de Python, porque el algoritmo es el mismo en MQL.
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.Dame el código, vamos a comprobarlo.
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.
const int n,const int m1,const int m2,
CMatrixDouble &c)
Una matriz Numpy de 20k*20k pesa 2gb.
400 millones de números dobles pesan 3 gigas.
MathAbs () me parece redundante.
También puedes comprobar los signos por separado. No es el punto.
400 millones de números dobles pesan 3 gigabytes.
Es comprensible, no hay memoria suficiente para tanta alegría.
en statistics.mqh.
functions
PearsonCorrM - La correlación de todas las filas con todas las filas es la más rápida.
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}};
[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.