Maschinelles Lernen im Handel: Theorie, Modelle, Praxis und Algo-Trading - Seite 3256

Neuer Kommentar
 
Maxim Dmitrievsky #:
Speicherüberlauf bei kleinen TFs. Der Speicher überläuft bei 16 osu und Auslagerungsdatei (Swap auf einem Mac) 30gig. Zum Beispiel gibt es eine 50k x 50k Korrelationsmatrix.

Offenbar einige Besonderheiten von Python, weil der Algorithmus ist der gleiche in MQL.

  1. Führen Sie auf die 1d-Array von Pos-Variable.
  2. [Pos-n, Pos] - ein anderes Muster.
  3. Wir haben etwas Ähnliches auf dieses Muster und 1d-Array angewendet.
  4. Wir fanden Situationen, in denen MathAbs(corr[i]) > 0,9.
  5. An diesen Stellen schauten wir uns m Balken vor dem Preisverhalten an und bildeten den Durchschnitt.
  6. Wir haben viele Stellen gefunden und einen guten Mittelwert gebildet? - speicherte die Musterdaten (Werte aus Schritt 2).
  7. Pos++ und auf S.2.

Dies ist eine frontale Variante. Mit einem Sieb geht es noch schneller.


Gehen wir von einer Million Takte aus. Die Länge des Strings ist 10. Dann ist 1d-array für 10 Millionen Doppelwerte 80 Mb. Punkt 3. - Nun, lassen Sie es 500 Mb in Bezug auf den Speicherverbrauch sein. Was habe ich nicht bedacht?

 
fxsaber #:

Es muss sich um einige Besonderheiten von Python handeln, da der Algorithmus in MQL der gleiche ist.

  1. Wir durchlaufen die 1d-Reihe von Pos-Variablen.
  2. [Pos-n, Pos] - ein anderes Muster.
  3. Wir haben etwas Ähnliches auf dieses Muster und 1d-array angewandt.
  4. Wir fanden Situationen, in denen MathAbs(corr[i]) > 0,9.
  5. An diesen Stellen schauten wir uns m Balken vor dem Preisverhalten an und bildeten den Durchschnitt.
  6. Wir haben viele Stellen gefunden und einen guten Mittelwert gebildet? - speicherte die Musterdaten (Werte aus Schritt 2).
  7. Pos++ und auf S.2.

Dies ist eine frontale Variante. Das Sieb ist noch schneller.


Gehen wir von einer Million Takte aus. Die Länge der Zeichenkette ist 10. Dann ist 1d-array für 10 Millionen Doppelwerte 80 Mb. p.3. - Nun, lassen Sie es 500 Mb in Bezug auf den Speicherverbrauch sein. Was habe ich nicht bedacht?

Die Korrelation der Matrix aller Zeilen zu allen Zeilen ist um ein Vielfaches schneller als Zyklen (1 Zeile zu jeder anderen Zeile) oder sogar eine Schleife (1 Zeile zu allen Zeilen). Es gibt also eine Art Beschleunigung durch den Algorithmus. Ich habe es mit der Alglib-Version der Korrelationsberechnung überprüft.
 
Forester #:
Die Korrelation der Matrix aller Zeilen mit allen Zeilen ist um ein Vielfaches schneller als Zyklen (1 Zeile mit jeder anderen Zeile) und sogar Schleifen (1 Zeile mit allen Zeilen). Es gibt also eine Art Beschleunigung durch den Algorithmus. Ich habe es mit der Alglib-Version der Korrelationsberechnung überprüft.

Geben Sie mir den Code, damit wir es überprüfen können.

 
fxsaber #:


  2. Wir haben Situationen gefunden, in denen MathAbs(corr[i]) > 0,9 war.

MathAbs () erscheint mir unnötig

 
fxsaber #:

Es muss sich um eine Besonderheit von Python handeln, denn der Algorithmus ist in MQL derselbe.

  1. Wir durchlaufen die 1d-Reihe von Pos-Variablen.
  2. [Pos-n, Pos] - ein anderes Muster.
  3. Wir haben etwas Ähnliches auf dieses Muster und 1d-array angewandt.
  4. Wir fanden Situationen, in denen MathAbs(corr[i]) > 0,9.
  5. An diesen Stellen schauten wir uns m Balken vor dem Preisverhalten an und bildeten den Durchschnitt.
  6. Wir haben viele Stellen gefunden und einen guten Mittelwert gebildet? - speicherte die Musterdaten (Werte aus Schritt 2).
  7. Pos++ und auf S.2.

Dies ist eine frontale Variante. Das Sieb ist noch schneller.


Gehen wir von einer Million Takte aus. Die Länge der Zeichenkette ist 10. Dann ist 1d-array für 10 Millionen Doppelwerte 80 Mb. p.3. - Nun, lassen Sie es 500 Mb in Bezug auf den Speicherverbrauch sein. Was habe ich nicht bedacht?

Ich war selbst verblüfft, dass keine Bibliothek in Python das berechnen kann, also war ich am Ende verwirrt.

Pandas überläuft den RAM, der Overhead ist gigantisch.

Nampai stürzt einfach ab und beendet die Interpreter-Session :) ohne Fehler anzuzeigen.

Man kann ein Sieb machen, aber man müsste den ganzen Code neu schreiben.
 
fxsaber #:

Geben Sie mir den Code, damit wir ihn überprüfen können.

in statistics.mqh.

functions
PearsonCorrM - Die Korrelation aller Zeilen zu allen Zeilen ist am schnellsten.

//+------------------------------------------------------------------+
//| 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 - Korrelation Zeile zu Zeile. Für eine vollständige Matrix: die 1. Zeile wird mit allen Zeilen nach 1 geprüft, die 2.

//+------------------------------------------------------------------+
//| 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)



Und durch PearsonCorrM2 können Sie die vollständige Matrix in 1 Matrix und eine weitere zu prüfende Zeile schreiben. Aber es gibt offensichtlich unnötige Arbeit, weil für die 10. Zeile die Korrelation mit den Zeilen über 10 bereits berechnet ist.

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


Überprüfen Sie eine Matrix von etwa 5k*20k. Bei 100*100 wird es schnell gehen.
 
Numpy eine 20k*20k Matrix wiegt 2gb
 
Maxim Dmitrievsky #:
Eine 20k*20k Numpy-Matrix wiegt 2gb.

400 Millionen doppelte Zahlen wiegen 3 Gigabyte.

 
mytarmailS #:

MathAbs () scheint mir überflüssig zu sein.

Sie können die Vorzeichen auch separat prüfen. Das ist nicht der Punkt.

 
fxsaber #:

400 Millionen doppelte Zahlen wiegen 3 Gigabyte.

Das ist verständlich, denn es gibt nicht genug Speicherplatz für all diese Freude.

1...324932503251325232533254325532563257325832593260326132623263...3399
Neuer Kommentar
Grund der Beschwerde: