L'Apprentissage Automatique dans le trading : théorie, modèles, pratique et trading algo - page 3258

Nouveau commentaire
 
fxsaber #:
Presque le double de la consommation due à cette ligne.

Il s'agit simplement d'une transition de CMatrixDouble à matrix<double>. J'ai même dû faire cette comparaison de matrices à cause de la mémoire.

Et le temps est augmenté de 40% par cette conversion. Commenté // Res = MatrixOut.ToMatrix() ;

matrix<double> Matrix1 = CorrMatrix(Matrix) - 10482307 mcs, 0 MB
matrix<double> Matrix2 = Matrix.CorrCoef(false) - 28882536 mcs, 1717 MB

C'est à dire que si vous ne travaillez qu'avec Alglibov fnctionnel (sans convertir ses matrices en matrices terminales), ce sera plus rapide.

 
fxsaber #:

Combien de temps faut-il à Python pour calculer la même taille de la matrice originale que dans l'exemple ci-dessus ?

import numpy as np
import time

def calc_corr_matrix():
    arr = np.random.rand(15000, 100).astype(np.float32)
    corr_matrix = np.corrcoef(arr)
    size_in_mb = corr_matrix.nbytes / 1024**2
    print("Array size:", size_in_mb, "MB")
    return corr_matrix

start_time = time.time()
corr_matrix = calc_corr_matrix()
end_time = time.time()

print("Time taken:", end_time - start_time, "seconds")
Array size: 1716.61376953125 MB
Time taken: 2.08686900138855 seconds

Mesure du temps en considérant la création de la matrice

 

jetez vos pierres )



 
Maxim Dmitrievsky #:

Mesure du temps en tenant compte de la création de la matrice

Array size: 1716.61376953125 MB
Time taken: 4.784467697143555 seconds

Ceci sur un vieux FX-8350.

 
fxsaber #:

Sur cette base, j'ai calculé la matrice de corrélation.

J'ai mesuré la performance.

Pour les statistiques, voici le résultat que j'ai obtenu

2023.09.26 06:28:23.304 Test_Corr (USDJPY,H1)   EX5: 3981 AVX Release.
2023.09.26 06:28:23.304 Test_Corr (USDJPY,H1)   TerminalInfoString(TERMINAL_CPU_NAME) = AMD FX-8350 Eight-Core 
2023.09.26 06:28:23.304 Test_Corr (USDJPY,H1)   TerminalInfoInteger(TERMINAL_CPU_CORES) = 8 
2023.09.26 06:28:23.304 Test_Corr (USDJPY,H1)   TerminalInfoString(TERMINAL_CPU_ARCHITECTURE) = AVX 
2023.09.26 06:28:23.332 Test_Corr (USDJPY,H1)   inRows = 100 inCols = 15000 
2023.09.26 06:28:45.032 Test_Corr (USDJPY,H1)   matrix<double> Matrix1 = CorrMatrix(Matrix) - 21700095 mcs, 1717 MB
2023.09.26 06:29:48.495 Test_Corr (USDJPY,H1)   matrix<double> Matrix2 = Matrix.CorrCoef(false) - 63460976 mcs, 1717 MB
2023.09.26 06:29:50.225 Test_Corr (USDJPY,H1)   IsEqual(Matrix1, Matrix2) = true 

2023.09.26 06:34:21.572	Test_Corr (USDJPY,H1)	EX5: 3981 X64 Regular Release.
2023.09.26 06:34:21.572	Test_Corr (USDJPY,H1)	TerminalInfoString(TERMINAL_CPU_NAME) = AMD FX-8350 Eight-Core 
2023.09.26 06:34:21.572	Test_Corr (USDJPY,H1)	TerminalInfoInteger(TERMINAL_CPU_CORES) = 8 
2023.09.26 06:34:21.572	Test_Corr (USDJPY,H1)	TerminalInfoString(TERMINAL_CPU_ARCHITECTURE) = AVX 
2023.09.26 06:34:21.600	Test_Corr (USDJPY,H1)	inRows = 100 inCols = 15000 
2023.09.26 06:34:42.908	Test_Corr (USDJPY,H1)	matrix<double> Matrix1 = CorrMatrix(Matrix) - 21308403 mcs, 1717 MB
2023.09.26 06:35:46.736	Test_Corr (USDJPY,H1)	matrix<double> Matrix2 = Matrix.CorrCoef(false) - 63826475 mcs, 1717 MB
2023.09.26 06:35:48.481	Test_Corr (USDJPY,H1)	IsEqual(Matrix1, Matrix2) = true
Il est clair que Python est beaucoup plus rapide. Cela signifie que le C sera également plus rapide, donc il s'avère que MQ ne nous dit pas grand-chose en promettant des performances comparables....

Je dois noter que Python a une petite parallélisation lors de l'exécution du code - pendant une demi-seconde pour environ deux cœurs, le reste est compté sur un seul cœur.

 
La bibliothèque NumPy est écrite en C
 
Maxim Dmitrievsky #:
la bibliothèque NumPy est écrite en C.

Oui, c'est logique. C'est pourquoi j'ai mentionné que le wrapper python est plus rapide qu'un compilateur C comme MQL5.

 

Ici sur les offres de R ChatGPT

set.seed(123)  #  Задаем зерно для воспроизводимости результатов

calc_corr_matrix <- function() {
  #arr <- matrix(runif(15000 * 100), nrow = 15000, ncol = 100)
  arr <- matrix(runif(100 * 15000), nrow = 100, ncol = 15000)
  corr_matrix <- cor(arr)
  size_in_mb <- object.size(corr_matrix) / 1024^2
  cat("Array size:", size_in_mb, "MB\n")
  return(corr_matrix)
}

start_time <- Sys.time()
corr_matrix <- calc_corr_matrix()
end_time <- Sys.time()

cat("Time taken:", as.numeric(end_time - start_time), "seconds\n")

Résultat

> set.seed(123)  #  Задаем зерно для воспроизводимости результатов

> calc_corr_matrix <- function() {
+   #arr <- matrix(runif(15000 * 100), nrow = 15000, ncol = 100)
+   arr <- matrix(runif(100 * 15000), nrow = 100,  .... [TRUNCATED] 

> start_time <- Sys.time()

> corr_matrix <- calc_corr_matrix()
Array size: 1716.614 MB

> end_time <- Sys.time()

> cat("Time taken:", as.numeric(end_time - start_time), "seconds\n")
Time taken: 27.92359 seconds
>
 

Si j'ai bien compris, python peut travailler avec une matrice d'entiers et les vitesses ici sont d'un ordre différent ici

import numpy as np
import time

def calc_corr_matrix():
    arr = np.random.randint(1, 101, size=(15000, 100), dtype=np.int32)
    corr_matrix = np.corrcoef(arr, rowvar=False)
    size_in_mb = corr_matrix.nbytes / 1024**2
    print("Array size:", size_in_mb, "MB")
    return corr_matrix

np.random.seed(123)  #  Задаем зерно для воспроизводимости результатов

start_time = time.time()
corr_matrix = calc_corr_matrix()
end_time = time.time()

print("Time taken:", end_time - start_time, "seconds")

Si le code est correct, le résultat est le suivant

Array size: 0.0762939453125 MB
Time taken: 0.5172276496887207 seconds

La question de la précision/comparabilité des résultats des calculs doit être vérifiée.

 
fxsaber #:

Il s'agit simplement d'une transition de CMatrixDouble à matrix<double>.

Il faut 20% de temps d'exécution en plus pour convertir les formats dans les deux sens. Mais il est encore beaucoup plus lent (> 3 fois) que NumPy.

1...325132523253325432553256325732583259326032613262326332643265...3399
Nouveau commentaire