L'apprentissage automatique dans la négociation : théorie, modèles, pratique et algo-trading - page 3256

Nouveau commentaire
 
Maxim Dmitrievsky #:
Débordement de mémoire sur des petites TF. La mémoire déborde avec 16 osu et un fichier d'échange (swap sur un mac) de 30gig. Par exemple, il y a une matrice de corrélation de 50k par 50k.

Apparemment, quelques particularités de Python, car l'algorithme est le même dans MQL.

  1. Exécution sur le 1d-array de Pos-variable.
  2. [Pos-n, Pos] - un autre modèle.
  3. Nous avons appliqué quelque chose de similaire à ce modèle et au tableau 1d.
  4. Nous avons trouvé des situations où MathAbs(corr[i]) > 0,9.
  5. Dans ces cas, nous avons examiné les m barres précédant le comportement du prix et en avons fait la moyenne.
  6. Nous avons trouvé beaucoup d'endroits et nous avons fait une bonne moyenne ? - sauvegardé les données du modèle (valeurs de l'étape 2).
  7. Pos++ et p.2.

Il s'agit d'une variante frontale. C'est encore plus rapide avec un tamis.


Supposons un million de barres. La longueur de la chaîne est de 10. Alors 1d-array pour 10 millions de doubles valeurs est de 80 Mb. point 3. - Soit 500 Mo en termes de consommation de mémoire. Qu'est-ce que je n'ai pas pris en compte ?

 
fxsaber #:

Il doit s'agir d'une particularité de Python, car l'algorithme est le même dans MQL.

  1. Nous parcourons le tableau 1d des variables Pos.
  2. [Pos-n, Pos] - un autre modèle.
  3. Nous avons appliqué quelque chose de similaire à ce modèle et au tableau 1d.
  4. Nous avons trouvé des situations où MathAbs(corr[i]) > 0,9.
  5. Dans ces cas, nous avons examiné les m barres précédant le comportement du prix et en avons fait la moyenne.
  6. Nous avons trouvé beaucoup d'endroits et nous avons fait une bonne moyenne ? - sauvegardé les données du modèle (valeurs de l'étape 2).
  7. Pos++ et sur p.2.

Il s'agit d'une variante frontale. Le tamis est encore plus rapide.


Supposons un million de barres. La longueur de la chaîne est de 10. Alors 1d-array pour 10 millions de doubles valeurs est de 80 Mb. p.3. - Soit 500 Mo en termes de consommation de mémoire. Qu'est-ce que je n'ai pas pris en compte ?

La corrélation de la matrice de toutes les lignes à toutes les lignes est considérée comme beaucoup plus rapide que les cycles (1 ligne à chaque autre ligne) ou même une boucle (1 ligne à toutes les lignes). Il y a une sorte d'accélération due à l'algorithme. Je l'ai vérifié sur la version alglib du calcul de corrélation.
 
Forester #:
La corrélation de la matrice de toutes les lignes à toutes les lignes est considérée comme beaucoup plus rapide que les cycles (1 ligne à toutes les autres lignes) et même que la boucle (1 ligne à toutes les lignes). Il y a une sorte d'accélération due à l'algorithme. Je l'ai vérifié sur la version alglib du calcul de corrélation.

Donnez-moi le code, nous allons le vérifier.

 
fxsaber #:


  2. Nous avons trouvé des situations où MathAbs(corr[i]) > 0,9.

MathAbs () me semble inutile

 
fxsaber #:

Il doit s'agir d'une particularité de Python, car l'algorithme est le même dans MQL.

  1. Nous parcourons le tableau 1d des variables Pos.
  2. [Pos-n, Pos] - un autre modèle.
  3. Nous avons appliqué quelque chose de similaire à ce modèle et au tableau 1d.
  4. Nous avons trouvé des situations où MathAbs(corr[i]) > 0,9.
  5. Dans ces cas, nous avons examiné les m barres précédant le comportement du prix et en avons fait la moyenne.
  6. Nous avons trouvé beaucoup d'endroits et nous avons fait une bonne moyenne ? - sauvegardé les données du modèle (valeurs de l'étape 2).
  7. Pos++ et sur p.2.

Il s'agit d'une variante frontale. Le tamis est encore plus rapide.


Supposons un million de barres. La longueur de la chaîne est de 10. Alors 1d-array pour 10 millions de doubles valeurs est de 80 Mb. p.3. - Soit 500 Mo en termes de consommation de mémoire. Qu'est-ce que je n'ai pas pris en compte ?

J'étais moi-même déconcerté par le fait qu'aucune bibliothèque en Python ne puisse le calculer, et j'ai donc fini par m'y perdre.

Pandas fait déborder la RAM, l'overhead est gigantesque.

Nampai se plante simplement et tue la session de l'interpréteur :) sans afficher d'erreurs.

On peut faire un tamis, mais il faut réécrire tout le code.
 
fxsaber #:

Donnez-moi le code, nous allons vérifier.

dans statistics.mqh.

functions
PearsonCorrM - La corrélation de toutes les lignes avec toutes les lignes est la plus rapide.

//+------------------------------------------------------------------+
//| 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 - Corrélation ligne à ligne. Pour une matrice complète : la première ligne est vérifiée avec toutes les lignes après 1, la deuxième ligne avec toutes les lignes après la deuxième, 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)



Grâce à PearsonCorrM2, vous pouvez écrire la matrice complète en 1 matrice et une autre ligne à vérifier. Mais il est évident que ce travail n'est pas nécessaire, car pour la 10e ligne, la corrélation avec les lignes supérieures à la 10e est déjà calculée.

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


Vérifier sur une matrice d'environ 5k*20k. Si 100*100, ce sera rapide.
 
Numpy une matrice de 20k*20k pèse 2gb
 
Maxim Dmitrievsky #:
Une matrice Numpy de 20k*20k pèse 2 Go.

400 millions de nombres doubles pèsent 3 gigas.

 
mytarmailS #:

MathAbs () me semble redondant.

Vous pouvez également vérifier les signes séparément. Ce n'est pas la question.

 
fxsaber #:

400 millions de nombres doubles pèsent 3 gigaoctets.

C'est compréhensible, il n'y a pas assez de mémoire pour tout ce bonheur.

1...324932503251325232533254325532563257325832593260326132623263...3399
Nouveau commentaire