DTW（动态时间调整）算法原理

DTW（动态时间调整）算法原理

引用

CSDN

1.

https://blog.csdn.net/weixin_44915288/article/details/136922547

动态时间规整（Dynamic Time Warping，DTW）算法是一种用于计算两个时间序列之间距离的方法。该算法可以测量两个序列之间的相似度，即使它们的长度和比例不同，并且可以在一些应用场景中对于时间序列的匹配、识别、分类等任务有很好的效果。

一、算法原理

动态时间规整（Dynamic Time Warping，DTW）算法是一种用于计算两个时间序列之间距离的方法。该算法可以测量两个序列之间的相似度，即使它们的长度和比例不同，并且可以在一些应用场景中对于时间序列的匹配、识别、分类等任务有很好的效果。

基本思想：将两个时间序列按照最优路径进行对齐，即找到一条“弯曲”的路径，让这条路径上的所有点之间的距离之和最小。

在进行动态时间规整计算时，需要执行以下步骤：

1. 定义距离度量：定义两个时间序列之间的距离度量方式，例如欧氏距离、曼哈顿距离、余弦相似度等。
2. 创建距离矩阵：通过计算两个时间序列中任意两个点之间的距离，创建一个距离矩阵。
3. 计算累积距离矩阵：从距离矩阵的左上角开始，沿着最短路径逐步计算出到达每个点时的最小距离，形成一个累积距离矩阵。
4. 选择最佳路径：从累积距离矩阵的右下角开始，回溯出一条最优路径，即最小距离的路径。

按照距离最近的原则，构建两个序列元素之间的对应的关系，评估两个长度不同的序列的相似性。

主要用于解决同一句话但说话速度不同的识别问题。

要求：

1. 单项对应，不能回头
2. 一一对应，不能有空
3. 对应之后，距离最近

上面这个正确的，第一个一定对应第一个，最后一个一定对应最后一个。

下面两个错误，不能回头，不能有空。

二、实现过程

对于A和B两个长度为10的一维序列，通过使用欧式距离dis计算累计距离矩阵。

三、代码实现

import numpy as np

def dis_abs(x, y):
    return abs(x-y)[0]

def estimate_twf(A,B,dis_func=dis_abs):
    
    N_A = len(A)
    N_B = len(B)
    
    D = np.zeros([N_A,N_B])
    D[0,0] = dis_func(A[0],B[0])
    
    # 左边一列
    for i in range(1,N_A):
        D[i,0] = D[i-1,0]+dis_func(A[i],B[0])
    # 下边一行
    for j in range(1,N_B):
        D[0,j] = D[0,j-1]+dis_func(A[0],B[j])
    # 中间部分
    for i in range(1,N_A):
        for j in range(1,N_B):        
            D[i,j] = dis_func(A[i],B[j])+min(D[i-1,j],D[i,j-1],D[i-1,j-1])
            
    # 路径回溯
    i = N_A-1
    j = N_B-1
    count =0
    d = np.zeros(max(N_A,N_B)*3)
    path = []
    while True:
        if i>0 and j>0:
            path.append((i,j))
            m = min(D[i-1, j],D[i, j-1],D[i-1,j-1])
            if m == D[i-1,j-1]:
                d[count] = D[i,j] - D[i-1,j-1]
                i = i-1
                j = j-1
                count = count+1
                
            elif m == D[i,j-1]:
                d[count] = D[i,j] - D[i,j-1]
                j = j-1
                count = count+1
    
            elif m == D[i-1, j]:
                d[count] = D[i,j] - D[i-1,j]
                i = i-1
                count = count+1
                
        elif i == 0 and j == 0:
            path.append((i,j))
            d[count] = D[i,j]
            count = count+1
            break
        
        elif i == 0:
            path.append((i,j))
            d[count] = D[i,j] - D[i,j-1]
            j = j-1
            count = count+1
        
        elif j == 0:
            path.append((i,j))
            d[count] = D[i,j] - D[i-1,j]
            i = i-1
            count = count+1
            
    mean = np.sum(d) / count
    return mean, path[::-1],D
    
if __name__=="__main__":
    a = np.array([1,3,4,9,8,2,1,5,7,3])
    b = np.array([1,6,2,3,0,9,4,1,6,3])
    a = a[:,np.newaxis]
    b = b[:,np.newaxis]
    dis,path,D = estimate_twf(a,b,dis_func=dis_abs)
    print(dis)
    print(path)
    print(D)

参考文献：DTW（动态时间规整）算法原理与应用_哔哩哔哩_bilibili