Dynamic time warping

src: www.vocal.com

In time series analysis, dynamic time warping (DTW) is one of the algorithms for measuring similarity between two temporal sequences, which may vary in speed. For instance, similarities in walking could be detected using DTW, even if one person was walking faster than the other, or if there were accelerations and decelerations during the course of an observation. DTW has been applied to temporal sequences of video, audio, and graphics data -- indeed, any data that can be turned into a linear sequence can be analyzed with DTW. A well known application has been automatic speech recognition, to cope with different speaking speeds. Other applications include speaker recognition and online signature recognition. Also it is seen that it can be used in partial shape matching application.

In general, DTW is a method that calculates an optimal match between two given sequences (e.g. time series) with certain restrictions. The sequences are "warped" non-linearly in the time dimension to determine a measure of their similarity independent of certain non-linear variations in the time dimension. This sequence alignment method is often used in time series classification. Although DTW measures a distance-like quantity between two given sequences, it doesn't guarantee the triangle inequality to hold.

In addition to a similarity measure between the two sequences, a so called "warping path" is produced, by warping according to this path the two signals may be aligned in time. The signal with an original set of points X(original), Y(original) is transformed to X(warped), Y(original). This finds applications in genetic sequence and audio synchronisation. In a related technique sequences of varying speed may be averaged using this technique see the average sequence section.

Video Dynamic time warping

Implementation

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) = $|x-y|$

  int DTWDistance(s: array [1..n], t: array [1..m]) {     DTW := array [0..n, 0..m]       for i := 1 to n         DTW[i, 0] := infinity     for i := 1 to m         DTW[0, i] := 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]  }

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

We can easily modify the above algorithm to add a locality constraint (differences marked in bold italic). However, the above given modification works only if $|n-m|$ is no larger 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 $|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)              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]  }

Maps Dynamic time warping

Fast computation

Computing the DTW requires $O(N^{2})$ in general. Fast techniques for computing DTW include PrunedDTW, SparseDTW, FastDTW, and the MultiscaleDTW. A common task, retrieval of similar time series, can be accelerated by using lower bounds such as LB_Keogh or LB_Improved. 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.

src: www.nickgillian.com

Average sequence

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

src: www.phon.ox.ac.uk

Supervised learning

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

Enhanced Dynamic Time Warping for Time series Hierarchal ...

src: i.ytimg.com

Alternative approach

An alternative technique for DTW is based on functional data analysis, in which the time series are regarded as discretizations of smooth (differentiable) functions of time and therefore continuous mathematics is applied. 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.

src: rsif.royalsocietypublishing.org

Open-source software

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.
The R package dtw implements most known variants of the DTW algorithm family, including a variety of recursion rules (also called step patterns), constraints, and substring matching.
The mlpy Python library implements DTW.
The pydtw C++/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.
C/Python library implements DTW with some variations (distance functions, step patterns and windows)
The 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).

e-Signature Verification using Dynamic Time Warping algorithm ...

src: i.ytimg.com

Applications

Spoken-word recognition

Due to different speaking rates, a non-linear fluctuation occurs in speech pattern versus time axis, which needs to be eliminated. DP matching is a pattern-matching algorithm based on dynamic programming (DP), which uses a time-normalization effect, where the fluctuations in the time axis are modeled using a non-linear time-warping function. Considering any two speech patterns, we can get rid of their timing differences by warping the time axis of one so that the maximal coincidence is attained with the other. Moreover, if the warping function is allowed to take any possible value, very less distinction can be made between words belonging to different categories. So, to enhance the distinction between words belonging to different categories, restrictions were imposed on the warping function slope.

Correlation power analysis

Unstable clocks are used to defeat naive power analysis. Several techniques are used to counter this defense, one of which is dynamic time warp.

src: www.ntt.dis.titech.ac.jp

Dynamic time warping

Minggu, 05 November 2017