Maschinelles Lernen im Handel: Theorie, Modelle, Praxis und Algo-Trading - Seite 3256
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
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.
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?
Es muss sich um einige Besonderheiten von Python handeln, da der Algorithmus in MQL der gleiche ist.
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 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.
MathAbs () erscheint mir unnötig
Es muss sich um eine Besonderheit von Python handeln, denn der Algorithmus ist in MQL derselbe.
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.Geben Sie mir den Code, damit wir ihn überprüfen können.
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.
const int n,const int m1,const int m2,
CMatrixDouble &c)
Eine 20k*20k Numpy-Matrix wiegt 2gb.
400 Millionen doppelte Zahlen wiegen 3 Gigabyte.
MathAbs () scheint mir überflüssig zu sein.
Sie können die Vorzeichen auch separat prüfen. Das ist nicht der Punkt.
400 Millionen doppelte Zahlen wiegen 3 Gigabyte.
Das ist verständlich, denn es gibt nicht genug Speicherplatz für all diese Freude.