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

Nuovo commento
 
Maxim Dmitrievsky #:
Overflow di memoria su TF piccoli. La memoria trabocca con 16 osu e un file di swap (swap su un mac) di 30 giga. Ad esempio, c'è una matrice di correlazione di 50k per 50k.

A quanto pare, alcune peculiarità di Python, perché l'algoritmo è lo stesso in MQL.

  1. Esecuzione sulla matrice 1d di variabili Pos.
  2. [Pos-n, Pos] - un altro modello.
  3. Abbiamo applicato qualcosa di simile a questo schema e a 1d-array.
  4. Abbiamo trovato situazioni in cui MathAbs(corr[i]) > 0,9.
  5. In questi punti abbiamo esaminato le barre m che precedono il comportamento del prezzo e ne abbiamo fatto la media.
  6. Abbiamo trovato molti punti e ne abbiamo fatto una media? - abbiamo salvato i dati del pattern (valori del passaggio 2).
  7. Pos++ e a pag. 2.

Questa è una variante frontale. È ancora più veloce con un setaccio.


Supponiamo un milione di barre. La lunghezza della stringa è 10. Allora 1d-array per 10 milioni di doppi valori è 80 Mb. punto 3. - Bene, facciamo che sia 500 Mb in termini di consumo di memoria. Di cosa non ho tenuto conto?

 
fxsaber #:

Deve trattarsi di qualche peculiarità di Python, perché l'algoritmo è lo stesso in MQL.

  1. Eseguiamo l'array 1d di variabili Pos.
  2. [Pos-n, Pos] - un altro schema.
  3. Abbiamo applicato qualcosa di simile a questo schema e all'array 1d.
  4. Abbiamo trovato situazioni in cui MathAbs(corr[i]) > 0.9.
  5. In questi punti abbiamo esaminato le barre m che precedono il comportamento del prezzo e ne abbiamo fatto la media.
  6. Abbiamo trovato molti punti e ne abbiamo fatto una media? - abbiamo salvato i dati del pattern (valori del passaggio 2).
  7. Pos++ e su p.2.

Questa è una variante frontale. Il setaccio è ancora più veloce.


Ipotizziamo un milione di barre. La lunghezza della stringa è 10. Allora 1d-array per 10 milioni di doppi valori è di 80 Mb. p.3. - Bene, facciamo che sia 500 Mb in termini di consumo di memoria. Di cosa non ho tenuto conto?

La correlazione della matrice di tutte le righe con tutte le righe è considerata molte volte più veloce dei cicli (1 riga con ogni altra riga) o anche di un ciclo (1 riga con tutte le righe). C'è una sorta di accelerazione dovuta all'algoritmo. L'ho verificato sulla versione alglib del calcolo della correlazione.
 
Forester #:
La correlazione della matrice di tutte le righe con tutte le righe è considerata molte volte più veloce dei cicli (1 riga con ogni altra riga) e persino del ciclo (1 riga con tutte le righe). C'è una sorta di accelerazione dovuta all'algoritmo. L'ho verificato sulla versione alglib del calcolo della correlazione.

Datemi il codice e verifichiamolo.

 
fxsaber #:


  2. Sono state trovate situazioni in cui MathAbs(corr[i]) > 0,9.

MathAbs () mi sembra superfluo

 
fxsaber #:

Deve trattarsi di qualche peculiarità di Python, perché l'algoritmo è lo stesso in MQL.

  1. Eseguiamo l'array 1d di variabili Pos.
  2. [Pos-n, Pos] - un altro schema.
  3. Abbiamo applicato qualcosa di simile a questo schema e all'array 1d.
  4. Abbiamo trovato situazioni in cui MathAbs(corr[i]) > 0,9.
  5. In questi punti abbiamo esaminato le barre m che precedono il comportamento del prezzo e ne abbiamo fatto la media.
  6. Abbiamo trovato molti punti e ne abbiamo fatto una media? - abbiamo salvato i dati del pattern (valori del passaggio 2).
  7. Pos++ e su p.2.

Questa è una variante frontale. Il setaccio è ancora più veloce.


Ipotizziamo un milione di barre. La lunghezza della stringa è 10. Allora 1d-array per 10 milioni di doppi valori è di 80 Mb. p.3. - Bene, facciamo che sia 500 Mb in termini di consumo di memoria. Di cosa non ho tenuto conto?

Sono rimasto sconcertato dal fatto che nessuna libreria in Python sia in grado di calcolarlo, quindi ho finito per confondermi.

Pandas sovraccarica la RAM, l'overhead è gigantesco.

Nampai si blocca e uccide la sessione dell'interprete :) senza mostrare alcun errore.

È possibile creare un setaccio, ma bisogna riscrivere l'intero codice.
 
fxsaber #:

Dammi il codice e controlliamo.

in statistics.mqh.

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

//+------------------------------------------------------------------+
//| 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 - Correlazione riga per riga. Per una matrice completa: la prima riga viene controllata con tutte le righe successive alla prima, la seconda riga con tutte le righe successive alla seconda, ecc.

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



Tramite PearsonCorrM2 è possibile scrivere l'intera matrice in 1 matrice e un'altra riga da controllare. Ma è ovvio che si tratta di un lavoro inutile, perché per la decima riga è già stata calcolata la correlazione con le righe superiori alla decima.

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


Controllare una matrice di circa 5k*20k. Se 100*100 sarà veloce.
 
Numpy una matrice 20k*20k pesa 2gb
 
Maxim Dmitrievsky #:
Una matrice Numpy 20k*20k pesa 2gb.

400 milioni di numeri doppi pesano 3 giga.

 
mytarmailS #:

MathAbs () mi sembra ridondante.

È anche possibile controllare i segni separatamente. Non è questo il punto.

 
fxsaber #:

400 milioni di numeri doppi pesano 3 gigabyte.

È comprensibile, la memoria non è sufficiente per tutta questa gioia.

1...324932503251325232533254325532563257325832593260326132623263...3399
Nuovo commento