Dynamic time warping

This example illustrates the implementation of the dynamic time warping algorithm when the two sequences s and t are strings of discrete symbols. For two symbols x and y, d(x, y) is a distance between the symbols, e.g. d(x, y) = ${\displaystyle |x-y|}$.

int DTWDistance(s: array [1..n], t: array [1..m]) {
    DTW := array [0..n, 0..m]
    
    for i := 0 to n
        for j := 0 to m
            DTW[i, j] := infinity
    DTW[0, 0] := 0
    
    for i := 1 to n
        for j := 1 to m
            cost := d(s[i], t[j])
            DTW[i, j] := cost + minimum(DTW[i-1, j  ],    // insertion
                                        DTW[i  , j-1],    // deletion
                                        DTW[i-1, j-1])    // match
    
    return DTW[n, m]
}

where DTW[i, j] is the distance between s[1:i] and t[1:j] with the best alignment.

We sometimes want to add a locality constraint. That is, we require that if s[i] is matched with t[j], then ${\displaystyle |i-j|}$ is not greater than w, a window parameter.

We can easily modify the above algorithm to add a locality constraint (differences marked). However, the above given modification works only if ${\displaystyle |n-m|}$ is not greater than w, i.e. the end point is within the window length from diagonal. In order to make the algorithm work, the window parameter w must be adapted so that ${\displaystyle |n-m|\leq w}$ (see the line marked with (*) in the code).

int DTWDistance(s: array [1..n], t: array [1..m], w: int) {
    DTW := array [0..n, 0..m]

    w := max(w, abs(n-m)) // adapt window size (*)

    for i := 0 to n
        for j:= 0 to m
            DTW[i, j] := infinity
    DTW[0, 0] := 0
    for i := 1 to n
        for j := max(1, i-w) to min(m, i+w)
            DTW[i, j] := 0

    for i := 1 to n
        for j := max(1, i-w) to min(m, i+w)
            cost := d(s[i], t[j])
            DTW[i, j] := cost + minimum(DTW[i-1, j  ],    // insertion
                                        DTW[i  , j-1],    // deletion
                                        DTW[i-1, j-1])    // match
    return DTW[n, m]
}

The DTW algorithm produces a discrete matching between existing elements of one series to another. In other words, it does not allow time-scaling of segments within the sequence. Other methods allow continuous warping. For example, Correlation Optimized Warping (COW) divides the sequence into uniform segments that are scaled in time using linear interpolation, to produce the best matched warping. The segment scaling causes potential creation of new elements, by time-scaling segments either down or up, and thus produces a more sensitive warping than DTW's discrete matching of raw elements.

The time complexity of the DTW algorithm is ${\displaystyle O(NM)}$, where ${\displaystyle N}$ and ${\displaystyle M}$ are the lengths of the two input sequences. The 50 years old quadratic time bound was broken in 2016: an algorithm due to Gold and Sharir enables computing DTW in ${\displaystyle O({N^{2}}/\log \log N)}$ time and space for two input sequences of length ${\displaystyle N}$.[2] This algorithm can also be adapted to sequences of different lengths. Despite this improvement, it was shown that a strongly subquadratic running time of the form ${\displaystyle O(N^{2-\epsilon })}$ for some ${\displaystyle \epsilon >0}$ cannot exist unless the Strong exponential time hypothesis fails.[3][4]

While the dynamic programming algorithm for DTW requires ${\displaystyle O(NM)}$ space in a naive implementation, the space consumption can be reduced to ${\displaystyle O(\min(N,M))}$ using Hirschberg's algorithm.

Fast techniques for computing DTW include Early Abandoned and Pruned DTW,[5] PrunedDTW,[6] SparseDTW,[7] FastDTW,[8] and the MultiscaleDTW.[9][10]

A common task, retrieval of similar time series, can be accelerated by using lower bounds such as LB_Keogh,[11] LB_Improved,[12] LB_Enhanced,[13] LB_Webb[14] or LB_Petitjean.[14] However, the Early Abandon and Pruned DTW algorithm reduces the degree of acceleration that lower bounding provides and sometimes renders it ineffective.[5]

In a survey, Wang et al. reported slightly better results with the LB_Improved lower bound than the LB_Keogh bound, and found that other techniques were inefficient.[15] Subsequent to this survey, the LB_Enhanced bound was developed that is always tighter than LB_Keogh while also being more efficient to compute.[13] LB_Petitjean is the tightest known lower bound that can be computed in linear time.[14]

Averaging for dynamic time warping is the problem of finding an average sequence for a set of sequences. NLAAF[16] is an exact method to average two sequences using DTW. For more than two sequences, the problem is related to the one of the multiple alignment and requires heuristics. DBA[17] is currently a reference method to average a set of sequences consistently with DTW. COMASA[18] efficiently randomizes the search for the average sequence, using DBA as a local optimization process.

A nearest-neighbour classifier can achieve state-of-the-art performance when using dynamic time warping as a distance measure.[19]

Amerced Dynamic Time Warping (ADTW) is a variant of DTW designed to better control DTW's permissiveness in the alignments that it allows.[20] The windows that classical DTW uses to constrain alignments introduce a step function. Any warping of the path is allowed within the window and none beyond it. In contrast, ADTW employs an additive penalty that is incurred each time that the path is warped. Any amount of warping is allowed, but each warping action incurs a direct penalty. ADTW significantly outperforms DTW with windowing when applied as a nearest neighbor classifier on a set of benchmark time series classification tasks.[20]

Graphical Time Warping (GTW) is a generalized version of DTW that can align multiple pairs of time series or sequences jointly. [21] Compared with aligning multiple pairs independently through DTW, GTW considers both the alignment accuracy of each sequence pair (as DTW) and the similarity among pairs (according to the data structure or assigned by user). This can result in better alignment performance when the similarity among pairs exists.

DTW is sensitive to the distance function d(x, y) used to score matches between pairs of values across the two sequences. The original definition of DTW[22] used d(x, y) = ${\displaystyle |x-y|}$. In time series classification, d(x, y) = ${\displaystyle (x-y)^{2}}$ has become popular.[23]

Recent work[24] has shown that tuning of this distance measure can be useful for tuning DTW performance. Specifically, tuning ${\displaystyle \gamma }$ in a family of distance functions of the form d(x, y) = ${\displaystyle |x-y|^{\gamma }}$ makes DTW focus more on low amplitude effects when ${\displaystyle \gamma }$ is small and large amplitude effects when ${\displaystyle \gamma }$ is large.

In functional data analysis, time series are regarded as discretizations of smooth (differentiable) functions of time. By viewing the observed samples at smooth functions, one can utilize continuous mathematics for analyzing data.[25] Smoothness and monotonicity of time warp functions may be obtained for instance by integrating a time-varying radial basis function, thus being a one-dimensional diffeomorphism.[26] Optimal nonlinear time warping functions are computed by minimizing a measure of distance of the set of functions to their warped average. Roughness penalty terms for the warping functions may be added, e.g., by constraining the size of their curvature. The resultant warping functions are smooth, which facilitates further processing. This approach has been successfully applied to analyze patterns and variability of speech movements.[27][28]

Another related approach is hidden Markov model (HMM) and it has been shown that the Viterbi algorithm used to search for the most likely path through the HMM is equivalent to stochastic DTW.[29][30][31]

DTW and related warping methods are typically used as pre- or post-processing steps in data analyses. If both observed sequences contain random variation in their values, shape of observed sequences and random temporal misalignment, the warping may overfit to noise leading to biased results. A simultaneous model formulation with random variation in both values (vertical) and time-parametrization (horizontal) is an example of a nonlinear mixed-effects model.[32] In human movement analysis, simultaneous nonlinear mixed-effects modeling has been shown to produce superior results compared to DTW.[33]

• The tempo C++ library with Python bindings implements Early Abandoned and Pruned DTW as well as Early Abandoned and Pruned ADTW and DTW lower bounds LB_Keogh, LB_Enhanced and LB_Webb.
• The UltraFastMPSearch Java library implements the UltraFastWWSearch algorithm[34] for fast warping window tuning.
• The lbimproved C++ library implements Fast Nearest-Neighbor Retrieval algorithms under the GNU General Public License (GPL). It also provides a C++ implementation of dynamic time warping, as well as various lower bounds.
• The FastDTW library is a Java implementation of DTW and a FastDTW implementation that provides optimal or near-optimal alignments with an O(N) time and memory complexity, in contrast to the O(N²) requirement for the standard DTW algorithm. FastDTW uses a multilevel approach that recursively projects a solution from a coarser resolution and refines the projected solution.
• FastDTW fork (Java) published to Maven Central.
• time-series-classification (Java) a package for time series classification using DTW in Weka.
• The DTW suite provides Python (dtw-python) and R packages (dtw) with a comprehensive coverage of the DTW algorithm family members, including a variety of recursion rules (also called step patterns), constraints, and substring matching.
• The mlpy Python library implements DTW.
• The pydtw Python library implements the Manhattan and Euclidean flavoured DTW measures including the LB_Keogh lower bounds.
• The cudadtw C++/CUDA library implements subsequence alignment of Euclidean-flavoured DTW and z-normalized Euclidean distance similar to the popular UCR-Suite on CUDA-enabled accelerators.
• The JavaML machine learning library implements DTW.
• The ndtw C# library implements DTW with various options.
• Sketch-a-Char uses Greedy DTW (implemented in JavaScript) as part of LaTeX symbol classifier program.
• The MatchBox implements DTW to match mel-frequency cepstral coefficients of audio signals.
• Sequence averaging: a GPL Java implementation of DBA.[17]
• The Gesture Recognition Toolkit|GRT C++ real-time gesture-recognition toolkit implements DTW.
• The PyHubs software package implements DTW and nearest-neighbour classifiers, as well as their extensions (hubness-aware classifiers).
• The simpledtw Python library implements the classic O(NM) Dynamic Programming algorithm and bases on Numpy. It supports values of any dimension, as well as using custom norm functions for the distances. It is licensed under the MIT license.
• The tslearn Python library implements DTW in the time-series context.
• The cuTWED CUDA Python library implements a state of the art improved Time Warp Edit Distance using only linear memory with phenomenal speedups.
• DynamicAxisWarping.jl Is a Julia implementation of DTW and related algorithms such as FastDTW, SoftDTW, GeneralDTW and DTW barycenters.
• The Multi_DTW implements DTW to match two 1-D arrays or 2-D speech files (2-D array).

• Levenshtein distance
• Elastic matching
• Sequence alignment
• Multiple sequence alignment
• Wagner–Fischer algorithm
• Needleman–Wunsch algorithm
• Fréchet distance
• Nonlinear mixed-effects model
• Graphical time warping

• Pavel Senin, Dynamic Time Warping Algorithm Review
• Vintsyuk, T. K. (1968). "Speech discrimination by dynamic programming". Kibernetika. 4: 81–88.
• Sakoe, H.; Chiba (1978). "Dynamic programming algorithm optimization for spoken word recognition". IEEE Transactions on Acoustics, Speech, and Signal Processing. 26 (1): 43–49. doi:10.1109/tassp.1978.1163055. S2CID 17900407.
• Myers, C. S.; Rabiner, L. R. (1981). "A Comparative Study of Several Dynamic Time-Warping Algorithms for Connected-Word Recognition". Bell System Technical Journal. 60 (7): 1389–1409. doi:10.1002/j.1538-7305.1981.tb00272.x. ISSN 0005-8580. S2CID 12857347.
• Rabiner, Lawrence; Juang, Biing-Hwang (1993). "Chapter 4: Pattern-Comparison Techniques". Fundamentals of speech recognition. Englewood Cliffs, N.J.: PTR Prentice Hall. ISBN 978-0-13-015157-5.
• Müller, Meinard (2007). Dynamic Time Warping. In Information Retrieval for Music and Motion, chapter 4, pages 69-84 (PDF). Springer. doi:10.1007/978-3-540-74048-3. ISBN 978-3-540-74047-6.
• Rakthanmanon, Thanawin (September 2013). "Addressing Big Data Time Series: Mining Trillions of Time Series Subsequences Under Dynamic Time Warping". ACM Transactions on Knowledge Discovery from Data. 7 (3): 10:1–10:31. doi:10.1145/2513092.2500489. PMC 6790126. PMID 31607834.