Comparación de dos gráficos de cotización con distorsiones no lineales en el eje X - página 5

 
alsu: El código mql probablemente no será largo))

aquí parece estar el código fuente http://www.bytefish.de/blog/dynamic_time_warping

 
Pues sí, es corto, pero eso es en la versión más simple, y hay algunas otras mejoras en cuanto a la velocidad del algoritmo y la consideración de las restricciones...
 
Este ha implementado soporte para dimensiones de datos de hasta 3, además de un método de estimación de límites inferiores y una prueba de ruta candidata asociada (según tengo entendido, esto es mucho más barato que el DTW completo para dimensiones >1, donde el método principal se convierte en un problema TK-completo y conduce a tiempos de solución exponenciales)
 
Hay un artículo sobre DTW en la página de Habrahabra http://habrahabr.ru/blogs/algorithm/135087/, parece ser muy claro, pero no consigo averiguar cómo usar DTW para OHLC, ¿alguien me lo puede explicar?
 
IgorM:
Hay un artículo sobre DTW en la página de Habrahabra http://habrahabr.ru/blogs/algorithm/135087/, parece ser muy claro, pero no consigo averiguar cómo usar DTW para OHLC, ¿alguien me lo puede explicar?

¿Ya está hecho por un precio?
 
Integer:¿Ya ha funcionado para un precio?

No funcionó, no es un problema portar la fuente DTW a mql:

//+------------------------------------------------------------------+
// 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];
}
//+------------------------------------------------------------------+
El problema es que no entiendo cómo utilizarlo, lo único que he entendido es que con DTW se pueden ajustar diferentes periodos de tiempo (BP) a la misma escala para su posterior análisis, pero cómo... - no entienden
 
IgorM:

No funcionó, la propia fuente DTW es fácil de portar a mql, de alguna manera:

el problema es que no entiendo como utilizar esto, lo único que he entendido es que con DTW se pueden ajustar diferentes tramos de tiempo (BPs) a la misma escala para su posterior análisis, pero como... - no entienden


Lo he probado. Tampoco estoy seguro de cómo usarlo. La salida debe ser la ruta de transformación o los datos transformados. Digamos que coste[][] es una matriz de distancia. Pero da un camino con retorno (si buscamos el valor mínimo en cada columna), la condición "1. Monotonicidad - el camino nunca vuelve, es decir: los dos índices, i y j, que se utilizan en la secuencia, nunca disminuyen". Además, el camino no llega a la esquina opuesta. En general, no entiendo muy bien el sentido de todas estas manipulaciones con los números a la hora de rellenar el array cost[][] - primero se cuentan simplemente las distancias y luego se suman.

Si necesitamos contar las distancias entre cada elemento t1 y cada elemento t2, entonces ¿por qué debemos realizar tantos cálculos, si necesitamos cumplir la condición "1. Monotonicidad - el camino nunca vuelve, es decir: ambos índices, i y j, utilizados en la secuencia, nunca disminuyen"?



.

 

El DTW es completamente inadecuado para la tarea que se está llevando a cabo. DTW se utiliza para reconocer el habla (palabras) en un flujo de audio en tiempo real de la siguiente manera (a grandes rasgos):

  1. Existe un patrón (palabra) - una secuencia de datos, de longitud N.
  2. Hay un flujo de audio - una secuencia de datos, de longitud M >> N.
  3. Del flujo de audio se seleccionan los trozos de datos más externos, de diferente longitud (aproximadamente).
  4. Cada trozo se compara con una plantilla mediante DTW.
  5. Si el DTW máximo supera un determinado umbral, se considera que se ha pronunciado una palabra.

Así que DTW es sólo un criterio para comparar dos secuencias de diferente longitud. Nada más.

Para buscar palabras en el historial de audio, DTW no es en absoluto adecuado, porque consume muchos recursos. Por ejemplo, averiguar cuántas veces se ha dicho una palabra en la última hora, utilizando DTW, es casi imposible.

Una solución rápida a este problema es utilizar un algoritmo rápido para calcular el CC de Pearson. Al hacerlo, el DTW se convierte cada vez en un ZigZag con diferentes parámetros de entrada. Este algoritmo es muy fácil de paralelizar y funcionará casi en tiempo real cuando se implemente utilizando la GPU.

Otra pregunta es ¿por qué lo necesitamos? Nadie ha resuelto esta tarea a un nivel serio. Pero estoy casi seguro de que después de haberlo resuelto, habrá un clavo más en el ataúd de la solidez de la teoría de los patrones.

La teoría de los patrones, así como las ondas de Elliott y Fibo no es un nivel de pensamiento tecnocrático.

 
hrenfx:

El DTW es totalmente inadecuado para la tarea en cuestión...

Vamos a mostrarle primero un DTW que funcione, y luego podremos discutir lo que encaja y lo que no.
 

Algo que me he inventado, pero no sé, es una tontería.

La línea amarilla, es la naranja estirada sobre la roja.

Razón de la queja: