Confronto di due grafici di quotazione con distorsioni non lineari sull'asse X - pagina 5

Nuovo commento
 
alsu: Il codice mql probabilmente non sarà lungo))

qui sembra essere il codice sorgente http://www.bytefish.de/blog/dynamic_time_warping

 
Beh, sì, è breve, ma questo è nella versione più semplice, e ci sono alcuni altri miglioramenti per quanto riguarda la velocità dell'algoritmo e la considerazione dei vincoli...
 
Questo ha implementato il supporto per le dimensioni dei dati fino a 3 inclusi, più un metodo di stima del limite inferiore e un test associato del percorso del candidato (da quanto ho capito, questo è molto più economico di DTW completo per dimensioni >1, dove il metodo principale diventa un problema TK-completo e porta a tempi di soluzione esponenziali)
 
C'è un articolo su DTW sul sito Habrahabra http://habrahabr.ru/blogs/algorithm/135087/, sembra essere molto chiaro, ma non riesco a capire come usare DTW per OHLC, qualcuno può spiegarmelo?
 
IgorM:
C'è un articolo su DTW sul sito Habrahabra http://habrahabr.ru/blogs/algorithm/135087/, sembra essere molto chiaro, ma non riesco a capire come usare DTW per OHLC, qualcuno può spiegarmelo?

È già fatto per un prezzo unico?
 
Integer: Ha già funzionato per un prezzo?

Non ha funzionato, non è un problema portare il sorgente DTW a mql, in qualche modo: 

//+------------------------------------------------------------------+
// create cost matrix
#define costmaxM 100
#define costmaxN 100
double cost[costmaxM][costmaxN];
int costM,costN; // текущая размерность cost
//+------------------------------------------------------------------+
double dist(double x, double y){
   return(MathSqrt(MathPow((x - y), 2)));
}
//+------------------------------------------------------------------+
int dtw(double &t1[],double &t2[]) {
// возвращаемое значение -1 ошибка
// +1 массив cost[][] заполнен правильно        
                int i,j;
                costM = ArraySize(t1);
                costN = ArraySize(t2);
                if(costM>=costmaxM || costN>=costmaxN)return(-1);

                cost[0][0] = dist(t1[0], t2[0]);
                // calculate first row
                for(i = 1; i < costM; i++)
                        cost[i][0] = cost[i-1][0] + dist(t1[i], t2[0]);
                // calculate first column
                for(j = 1; j < costN; j++)
                        cost[0][j] = cost[0][j-1] + dist(t1[0], t2[j]);
                // fill matrix
                for(i = 1; i < costM; i++)
                        for(j = 1; j < costN; j++)
                                cost[i][j] = MathMin(cost[i-1][j],MathMin(cost[i][j-1], cost[i-1][j-1])) + dist(t1[i],t2[j]);
 
return(1);//            return cost[m-1][n-1];
}
//+------------------------------------------------------------------+
Il problema è che non capisco come usarlo, tutto quello che ho capito è che con DTW si possono adattare diversi periodi di tempo (BP) alla stessa scala per analisi successive, ma come... - non capire
 
IgorM:

Non ha funzionato, il sorgente DTW stesso è facile da portare su mql, in qualche modo:

il problema è che non capisco come usarlo, tutto quello che ho capito è che con DTW si possono adattare diverse sezioni temporali (BP) alla stessa scala per analisi successive, ma come... - non capire


Provato. Non sono nemmeno sicuro di come usarlo. L'output dovrebbe essere il percorso di trasformazione o i dati trasformati. Diciamo che cost[][] è una matrice di distanza. Ma dà un percorso con un ritorno (se cerchiamo il valore minimo in ogni colonna), la condizione "1. Monotonicità - il percorso non ritorna mai, cioè: entrambi gli indici, i e j, che sono usati nella sequenza, non diminuiscono mai". Inoltre, il percorso non raggiunge l'angolo opposto. In generale, non capisco bene il significato di tutte queste manipolazioni con i numeri quando si riempie l'array cost[][] - prima si contano semplicemente le distanze e poi si sommano.

Se abbiamo bisogno di contare le distanze tra ogni elemento t1 e ogni elemento t2, allora perché dovremmo eseguire così tanti calcoli, se abbiamo bisogno di soddisfare la condizione "1. Monotonicità - il percorso non ritorna mai, cioè: entrambi gli indici i e j utilizzati nella sequenza non sono mai diminuiti"?



.

 

DTW è completamente inadatto al compito da svolgere. DTW è usato per riconoscere il discorso (parole) in un flusso audio in tempo reale come segue (approssimativamente):

  1. C'è un modello (parola) - una sequenza di dati, di lunghezza N.
  2. C'è un flusso audio - una sequenza di dati, di lunghezza M >> N.
  3. Dal flusso audio vengono selezionati i pezzi di dati più esterni, di lunghezza diversa (approssimativamente).
  4. Ogni chunk viene confrontato con un modello da DTW.
  5. Se il DTW massimo supera una certa soglia, si considera che una parola è stata pronunciata.

Quindi DTW è solo un criterio per confrontare due sequenze di lunghezza diversa. Niente di più.

Per cercare le parole nella storia dell'audio, DTW non è affatto adatto, perché richiede molte risorse. Per esempio, scoprire quante volte una parola è stata detta nell'ultima ora, usando DTW, è quasi impossibile.

Una soluzione rapida a questo problema è usare un algoritmo veloce per calcolare il CQ di Pearson. Così facendo, il DTW è convertito ogni volta da uno ZigZag con diversi parametri di input. Un tale algoritmo è molto facile da parallelizzare e funzionerà quasi in tempo reale se implementato utilizzando la GPU.

Un'altra domanda è: perché ne abbiamo bisogno? Nessuno ha risolto questo compito a livello serio. Ma sono quasi sicuro che dopo averlo risolto, ci sarà un altro chiodo nella bara della solidità della teoria dei modelli.

La teoria dei modelli, così come le onde di Elliott e Fibo non è un livello di pensiero tecnocratico.

 
hrenfx:

Il DTW è totalmente inadatto al compito da svolgere...

Mostriamo prima un DTW funzionante, poi possiamo discutere cosa si adatta e cosa no.
 

Qualcosa che ho inventato io, ma non so, è una sciocchezza.

La linea gialla è quella arancione allungata su quella rossa.

123456789101112
Nuovo commento