嘿，我来帮你搞定这个问题！你要找的核心是时间序列对齐与最优匹配路径提取，Python里有不少成熟的工具包和方法，完全不用自己从零实现，下面给你分情况详细说明：

1. 首选：动态时间规整（DTW） #

这是处理不等长/变形时间序列相似度与对齐的标准方法，能直接找到两个序列间相似度最高的匹配路径（也就是你说的“相似度最高的对角线”，不一定是严格直线，适配序列长度差异）。

推荐工具包 #

• dtw-python：功能全面，支持自定义距离度量
• fastdtw：针对长序列优化，速度更快

代码示例（dtw-python） #

import numpy as np
from dtw import dtw
import matplotlib.pyplot as plt

# 假设t1、t2是你的时间序列（numpy数组格式）
t1 = np.random.rand(100)  # 示例序列1
t2 = np.random.rand(120)  # 示例序列2（长度不同）

# 计算DTW对齐，用欧氏距离作为相似度度量
alignment = dtw(t1, t2, dist=lambda x, y: np.linalg.norm(x - y))

# 提取你需要的x、y分量：t1的索引和对应的t2索引
x_components = alignment.index1  # 对应t1的位置
y_components = alignment.index2  # 对应t2的匹配位置

# 可视化相似度矩阵+最优路径
plt.imshow(alignment.costMatrix.T, origin='lower', cmap='Blues')
plt.plot(x_components, y_components, color='#ff4444', linewidth=2)
plt.xlabel('t1')
plt.ylabel('t2')
plt.title('DTW Similarity Matrix with Optimal Matching Path')
plt.show()

2. 同步序列偏移对齐：互相关法 #

如果你的两个时间序列形状高度相似，只是存在固定时间偏移，用互相关可以快速找到最优偏移量，生成对齐后的索引对。

代码示例（scipy+numpy） #

import numpy as np
from scipy.signal import correlate
import matplotlib.pyplot as plt

t1 = np.random.rand(100)
t2 = np.roll(np.random.rand(100), 15)  # 模拟t2相对t1偏移15步的情况

# 计算互相关，找到最优滞后量
corr_values = correlate(t2, t1, mode='full')
lags = np.arange(-len(t1)+1, len(t2))
best_lag = lags[np.argmax(corr_values)]

# 生成对齐后的索引对
if best_lag >= 0:
    x_idx = np.arange(len(t1))
    y_idx = x_idx + best_lag
    # 过滤超出t2范围的索引
    valid_mask = y_idx < len(t2)
    x_idx, y_idx = x_idx[valid_mask], y_idx[valid_mask]
else:
    y_idx = np.arange(len(t2))
    x_idx = y_idx - abs(best_lag)
    valid_mask = x_idx < len(t1)
    x_idx, y_idx = x_idx[valid_mask], y_idx[valid_mask]

# 查看结果
print("对齐后的t1索引：", x_idx[:10])
print("对应t2索引：", y_idx[:10])

3. 基于自定义相似度矩阵的路径提取 #

如果你已经有了自己实现的Similarity函数生成的相似度矩阵，可以用动态规划手动查找最优路径（最大化路径上的相似度总和）：

import numpy as np
import matplotlib.pyplot as plt

# 假设这是你的自定义相似度矩阵（形状为(len(t1), len(t2))）
similarity_matrix = np.random.rand(100, 120)
m, n = similarity_matrix.shape

# 动态规划表初始化
dp = np.zeros((m, n))
path_track = np.zeros((m, n, 2), dtype=int)

# 填充边界
dp[0, 0] = similarity_matrix[0, 0]
for i in range(1, m):
    dp[i, 0] = dp[i-1, 0] + similarity_matrix[i, 0]
    path_track[i, 0] = [i-1, 0]
for j in range(1, n):
    dp[0, j] = dp[0, j-1] + similarity_matrix[0, j]
    path_track[0, j] = [0, j-1]

# 填充动态规划表
for i in range(1, m):
    for j in range(1, n):
        max_prev = max(dp[i-1, j], dp[i, j-1], dp[i-1, j-1])
        dp[i, j] = max_prev + similarity_matrix[i, j]
        # 记录路径来源
        if max_prev == dp[i-1, j]:
            path_track[i, j] = [i-1, j]
        elif max_prev == dp[i, j-1]:
            path_track[i, j] = [i, j-1]
        else:
            path_track[i, j] = [i-1, j-1]

# 回溯获取最优路径
x_idx, y_idx = [], []
current_i, current_j = m-1, n-1
while current_i >= 0 and current_j >= 0:
    x_idx.append(current_i)
    y_idx.append(current_j)
    current_i, current_j = path_track[current_i, current_j]
x_idx.reverse()
y_idx.reverse()

# 可视化
plt.imshow(similarity_matrix.T, origin='lower', cmap='Blues')
plt.plot(x_idx, y_idx, color='#ff4444', linewidth=2)
plt.xlabel('t1')
plt.ylabel('t2')
plt.title('Optimal Path on Custom Similarity Matrix')
plt.show()

内容的提问来源于stack exchange，提问作者Basic Visual