L'apprendimento automatico nel trading: teoria, modelli, pratica e algo-trading - pagina 3257

Nuovo commento
 
Forester #:
in statistics.mqh.

functions
PearsonCorrM - La correlazione di tutte le righe con tutte le righe è la più veloce.

È sbagliato da qualche parte, ma io non lo vedo. 
#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 #:
Mi sbaglio da qualche parte, ma non lo vedo.

Ma funziona con questa stringa

const matrice<doppia> matrix1 = {{2, 2, 3}, {3, 2, 3}, {1, 2, 1}};

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

A quanto pare, se tutti i dati di una colonna sono uguali, il calcolo viene saltato.
Nella seconda colonna ho lasciato tutti i dati in 2 e la seconda riga della matrice è rimasta zero. Anche se probabilmente è corretto riempire la diagonale con 1.

PS. All'inizio ho pensato che si trattasse di un bug di Alglib.

Nel vecchio codice i valori degli elementi venivano impostati tramite
m[row].Set(col, val);
E ora
m.Set(row,col, val);

È un peccato che non ci sia compatibilità all'indietro. Beh, per me non ha importanza. Non sto lavorando su Alglib ora. Se i vecchi codici di qualcuno smettono di funzionare, sarà necessario sistemarli.
La cosa più triste è che la vecchia versione di

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

non scrive messaggi di errore, semplicemente non fa nulla. Le persone non sostituiranno e non sapranno di dover cambiare il codice. Conterà qualcosa, ma con matrici invariate.

 
Forester #:

A quanto pare, se tutti i dati di una colonna sono uguali, il calcolo viene saltato.

Pearson non calcola tra le righe, ma tra le colonne?

Sembra di sì. 
const matrix<double> matrix1 = {{1, 1, 1}, {2, 2, 2}, {3, 3, 3}};
Fornisce una singola matrice.
 
fxsaber #:

Pearson non calcola tra le righe, ma tra le colonne?

ZY Sembra di sì. Produce una matrice unitaria.
È possibile trasporla.
 

Alglib è una buona libreria, ha tutto per il MO. Le reti neurali sono molto lente, lo erano già nelle prime versioni.

 
Forester #:
in statistics.mqh.

PearsonCorrM - La correlazione di tutte le righe con tutte le righe è la più veloce.

Sulla sua base ho calcolato la matrice di correlazione.

#include <Math\Alglib\statistics.mqh> // https://www.mql5.com/ru/code/11077

const matrix<double> CorrMatrix( const matrix<double> &Matrix )
{
  matrix<double> Res = {};
  
  const CMatrixDouble MatrixIn(Matrix);
  CMatrixDouble MatrixOut;  

  if (CBaseStat::PearsonCorrM(MatrixIn, MatrixIn.Rows(), MatrixIn.Cols(), MatrixOut)) // https://www.mql5.com/ru/code/11077
    Res = MatrixOut.ToMatrix();
  
  return(Res);
}


Ho misurato le prestazioni.

#property script_show_inputs

input int inRows = 100; // Длина строки
input int inCols = 15000; // Количество строк

void FillArray( double &Array[], const int Amount )
{
  for (uint i = ArrayResize(Array, Amount); (bool)i--;)
    Array[i] = MathRand();
}

bool IsEqual( matrix<double> &Matrix1, const matrix<double> &Matrix2 )
{
//  return(MathAbs((Matrix1 - Matrix2).Mean()) < 1e-15); // Дорого по памяти.
  
  Matrix1 -= Matrix2;  
  
  const bool Res = (MathAbs(Matrix1.Mean()) < 1 e-15);
  
  Matrix1 += Matrix2;
  
  return(Res);
}

#define  TOSTRING(A) #A + " = " + (string)(A) + " "

#define  BENCH(A)                                                              \
  StartMemory = MQLInfoInteger(MQL_MEMORY_USED);                              \
  StartTime = GetMicrosecondCount();                                          \
  A;                                                                          \
  Print(#A + " - " + (string)(GetMicrosecondCount() - StartTime) + " mcs, " + \
       (string)(MQLInfoInteger(MQL_MEMORY_USED) - StartMemory) + " MB"); 

void PrintCPU()
{
#ifdef _RELEASE
  Print("EX5: " + (string)__MQLBUILD__ + " " + __CPU_ARCHITECTURE__ + " Release.");
#else // #ifdef _RELEASE
  Print("EX5: " + (string)__MQLBUILD__ + " " + __CPU_ARCHITECTURE__ + " Debug.");
#endif // #ifdef _RELEASE #else
  Print(TOSTRING(TerminalInfoString(TERMINAL_CPU_NAME)));
  Print(TOSTRING(TerminalInfoInteger(TERMINAL_CPU_CORES)));
  Print(TOSTRING(TerminalInfoString(TERMINAL_CPU_ARCHITECTURE)));
}

void OnStart()
{  
  PrintCPU();
  
  double Array[];
  FillArray(Array, inRows * inCols);
  
  matrix<double> Matrix;  
  Matrix.Assign(Array);
  Matrix.Init(inCols, inRows);
  Matrix = Matrix.Transpose();
  
  ulong StartTime, StartMemory;
  
  Print(TOSTRING(inRows) + TOSTRING(inCols));

  BENCH(matrix<double> Matrix1 = CorrMatrix(Matrix)) // https://www.mql5.com/ru/code/11077
  BENCH(matrix<double> Matrix2 = Matrix.CorrCoef(false)); // https://www.mql5.com/ru/docs/basis/types/matrix_vector
//  BENCH(matrix<double> Matrix3 = CorrMatrix(Array, inRows)); // https://www.mql5.com/ru/code/17982 

  Print(TOSTRING(IsEqual(Matrix1, Matrix2)));
//  Print(TOSTRING(IsEqual(Matrix3, Matrix2)));  
}


Risultato.

EX5: 3981 AVX Release.
TerminalInfoString(TERMINAL_CPU_NAME) = Intel Core i7-2700 K  @ 3.50 GHz 
TerminalInfoInteger(TERMINAL_CPU_CORES) = 8 
TerminalInfoString(TERMINAL_CPU_ARCHITECTURE) = AVX 
inRows = 100 inCols = 15000 
matrix<double> Matrix1 = CorrMatrix(Matrix) - 14732702 mcs, 1717 MB
matrix<double> Matrix2 = Matrix.CorrCoef(false) - 40318390 mcs, 1717 MB
IsEqual(Matrix1, Matrix2) = true


Si vede bene che Alglib calcola la matrice più velocemente del metodo matriciale standard.

Tuttavia, per la ricerca di pattern, il calcolo della matrice di correlazione è folle in termini di consumo di RAM.


Quanto tempo impiega Python per leggere la stessa dimensione della matrice originale come nell'esempio precedente?

 
fxsaber #:

Tuttavia, leggere una matrice di correlazione per trovare i modelli è una follia che richiede molta RAM.

Quella integrata funziona più velocemente sul mio i7-6700.

inRows = 100 inCols = 15000 
matrix<double> Matrix1 = CorrMatrix(Matrix) - 14648864 mcs, 1717 MB
matrix<double> Matrix2 = Matrix.CorrCoef(false) - 29589590 mcs, 1717 MB
IsEqual(Matrix1, Matrix2) = true

È strano che quello nativo sia più lento, potrebbero averlo semplicemente copiato. È improbabile che Alglibe abbia un algoritmo accelerato unico sotto licenza.

Avete provato le altre due varianti di Alglib?
Se contate in loop ogni riga su ogni riga o ogni riga su tutte le righe, la memoria sarà più economica (2 righe o 1 riga + matrice). Ma ci vorrà più tempo, non ricordo esattamente, ma credo che sarà più lento della funzione integrata.

 
fxsaber #:

Tuttavia, leggere una matrice di correlazione per trovare i modelli è una follia che richiede molta RAM.

Con la memoria è ancora peggio.
Prima di lanciarlo



E durante il lavoro di Alglibov PearsonCorrM la memoria cresce continuamente: ho visto 5 gg e 4,6 sullo schermo.


e durante il lavoro di Matrix.CorrCoef standard.

A quanto pare, quello standard è ottimizzato per l'utilizzo minimo della memoria, mentre quello di Alglibov è ottimizzato per la velocità.

 
Forester #:

Ho fatto in modo che quello integrato funzionasse più velocemente: su un i7-6700.

Ho aggiunto al codice i dati della CPU e delle istruzioni EX5.
 
Forester #:

E durante l'esecuzione di PearsonCorrM di Alglib, la memoria continua a crescere: e sono stati visti 5 gg, sullo schermo ne sono apparsi 4,6

Quasi il doppio del consumo dovuto a questa riga.

Forum sul trading, sui sistemi di trading automatizzati e sulla verifica delle strategie di trading

Machine learning nel trading: teoria, modelli, pratica e algo-trading

fxsaber, 2023.09.25 18:01

#include <Math\Alglib\statistics.mqh> // https://www.mql5.com/ru/code/11077

const matrix<double> CorrMatrix( const matrix<double> &Matrix )
{
  matrix<double> Res = {};
  
  const CMatrixDouble MatrixIn(Matrix);
  CMatrixDouble MatrixOut;  

  if (CBaseStat::PearsonCorrM(MatrixIn, MatrixIn.Rows(), MatrixIn.Cols(), MatrixOut)) // https://www.mql5.com/ru/code/11077
    Res = MatrixOut.ToMatrix();
  
  return(Res);
}

Questo è solo un passaggio da CMatrixDouble a matrix<double>. Ho anche dovuto fare questo confronto tra matrici a causa della memoria.

Forum sul trading, sui sistemi di trading automatizzati e sulla verifica delle strategie di trading

Machine learning nel trading: teoria, modelli, pratica e algo-trading

fxsaber, 2023.09.25 18:01

bool IsEqual( matrix<double> &Matrix1, const matrix<double> &Matrix2 )
{
//  return(MathAbs((Matrix1 - Matrix2).Mean()) < 1e-15); // Дорого по памяти.
  
  Matrix1 -= Matrix2;  
  
  const bool Res = (MathAbs(Matrix1.Mean()) < 1 e-15);
  
  Matrix1 += Matrix2;
  
  return(Res);
}
1...325032513252325332543255325632573258325932603261326232633264...3399
Nuovo commento