机器学习周报-文献阅读

商道如狼道 · 2025-4-21 15:20:10

摘要

本周阅读了一篇基于深度分解布局和自相关的大规模水质猜测的论文，文章介绍了一种大规模水质猜测模型–SVD-Autoformer。该算法结合了Savitzky-Golay（SG）滤波器、变分模式分解（VMD）、自相关机制和深度分解布局，并在Transformer改造中实现。第一，SG滤波器去除噪声，同时保留有代价的数据特征。SVDAutoformer采用SG滤波器作为数据预处置惩罚工具，以淘汰噪声并防止非线性模型过拟合。其次，VMD提取了信号的重要模态及其中心频率，从而为猜测提供了更丰富的特征。第三，具有嵌入式分解模块的深度分解架构答应在猜测过程期间举行渐进分解。SVD-Autoformer使用该架构从复杂的水质时间序列中提取出更具可猜测性的成分，用于长期猜测。末了，使用自相关机制捕捉时间相关性，提高信息使用率。
Abstract

This week, I read a paper on large-scale water quality prediction based on deep decomposition structures and autocorrelation. The paper introduces a large-scale water quality prediction model called SVD-Autoformer. This algorithm integrates the Savitzky-Golay (SG) filter, Variational Mode Decomposition (VMD), autocorrelation mechanisms, and deep decomposition structures, implemented within a Transformer framework. First, the SG filter removes noise while preserving valuable data features. SVD-Autoformer employs the SG filter as a data preprocessing tool to reduce noise and prevent overfitting in nonlinear models. Second, VMD extracts the main modes of the signal and their central frequencies, providing richer features for prediction. Third, a deep decomposition architecture with an embedded decomposition module enables progressive decomposition during the prediction process. SVD-Autoformer leverages this architecture to extract more predictable components from complex water quality time series for long-term forecasting. Finally, the autocorrelation mechanism is used to capture temporal dependencies, improving information utilization.
1 文章内容

1.1 相关工作

1.1.1 时间序列猜测模型

该研究中的SG滤波器在消除噪声的同时有效地保留了根本的时间序列特征。外部分解模块的VMD提高了时间序列中信息的使用率。深度分解架构的内部序列分解模块使用数据的抽象特征。这些优点的结合使得模型能有效提高猜测精度。;
1.1.2 时间序列的降噪

该研究使用SG滤波器作为数据预处置惩罚工具来降低噪声。它可以成功地消除噪声分量，同时保留数据的特征。另一方面，SG滤波器提供了一种计算复杂度低的线性方法，特别是在处置惩罚大规模时间序列数据时。相比之下，小波变换和履历模式分解（EMD）涉及多级分解和重构过程，具有更高的计算复杂度。
1.1.3 时间序列的分解

该研究创新性地计划了外部和内部分解模块。
在外部分解模块中采用了自适应信号分解方法VMD。它捕捉时间序列中的局部变化，并为后续的猜测建模提供更丰富的特征。
在内部分解模块中，我们引入了深度分解架构，它可以更好地捕获时间序列中更可猜测的成分。 提出的模型中，外部分解模块的VMD更好地捕捉了时间序列中的局部变化。内部分解模块的深度分崩溃系布局进一步使用数据的抽象特征来更好地表示全局特征。这两个分解模块相互增补，从而增强了模型的猜测性能。
1.2 模型框架

水质猜测涉及使用水质指标传感器网络数据，然后分析历史时间序列数据以猜测这些指标的未来趋势。使用水质指标，如pH值，电导率（EC），总氮（TN）和溶解氧（DO）。传感器定期对这些指标举行采样，以监测水质。设 Y = y 1 ， y 2 ， . . . ， y l Y = {y_1，y_2，...，y_l} Y=y1，y2，...，yl表示来自过去l个时间点的水质时间序列,SG滤波器应用于Y，产生 Y ˉ = y ˉ 1 ， y ˉ 2 ， . . . ， y ˉ l \bar Y = {\bar y_1，\bar y_2，...，\bar y_l} Yˉ=yˉ1，yˉ2，...，yˉl表示过去l个时间点的噪声降低后的水质指标。该研究猜测了接下来n个时间点的数据，表示为 H ^ n = h ^ l + 1 ， h ^ l + 2 ， . . . ， h ^ l + n \hat H_n = {\hat h_{l+1}，\hat h_{l+2}，...， \hat h_{l+n}} H^n=h^l+1，h^l+2，...，h^l+n。此外， H ^ n = h ^ l + 1 ， h l + 2 ， . . . ， h l + n \hat H_n = {\hat h_{l+1}，h_{l+2}，...，h_{l+n}} H^n=h^l+1，hl+2，...，hl+n}表示真实的未来水质指标。
1.2.1 SG Filter

噪声的存在会导致非线性方法过拟合。使用SG滤波器对原始数据举行平滑处置惩罚，从而降低噪声并防止非线性模型过度拟合。SG滤波器应用线性最小二乘法将低阶多项式拟合到相邻数据点的一连子集，如下所示

其中， y ^ ζ \hat y_\zeta y^ζ表示经过SG滤波器处置惩罚后的水质指标数据， y ^ j + ζ \hat y_{j+\zeta} y^j+ζ表示窗口中的水质指标，s和l表示SG过滤器的尺寸和水指示器的长度。采用s卷积系数最小二乘法拟合水质时间序列指标 y ^ j + ζ \hat y_{j+\zeta} y^j+ζ
1.2.2 变分模式分解(VMD)

时间序列数据通常包含差别尺度和频率的各种成分，例如趋势，季节，周期项和噪声。这些组成部分相互作用，使时间序列猜测变得复杂和困难。基于时频的分解可以将时间序列数据分解为一组固有模态函数（IMF）和残差，从而更好地表示差别尺度的分量。常用的分解方法是EMD，它将时间序列分解为差别频率范围的IMF。每个IMF代表一个局部振动模式，因此，EMD可以适应非光滑和非线性时间序列。然而，EMD有可能在包含大量噪声的时间序列中产生模态混叠，从而影响最终分解数据的可用性。
为了降服EMD的范围性，这项工作引入VMD方法作为一个更有利的分解技能。VMD可以提取信号的中心模式函数及其各自的中心频率。它是一种非递归的信号分解技能，每个模式重要集中在中心频率四周。在变分框架中，信号分解的题目被转化为约束变分模型的最优解，如下所示

1.2.3 SVD-Autoformer Model

如图所示，深度分解架构包罗内部分解模块、自相关机制以及相关联的编码器和解码器组件。深度分解架构基于Transformer 。编码器-解码器架构在布局内具有显著变化。首先，将添加的分解模块嵌入内部。此外，自相关机制被用来代替Transformer的自我留意机制。
首先，SG过滤器实行对水质时间序列举行去噪处置惩罚。VMD用于分解，以获得更丰富的猜测特征。此外，SVD-Autoform的编码器还包含自相关机制和分解模块。它通过内部序列分解模块对趋势周期分量举行分解，并对残差举行分析。末了，季节分量被送入解码器，并与编码器中的趋势周期分量累积，以创建未来猜测。此外，SVD-Autoform的伪代码和总体流程图分别如算法1和图2所示。
1.内部序列分解
  时间序列数据可以被认为是几个组成部分的组合，表示如下：                                           Y                         l                               =                                  C                         l                               +                                  T                         l                               +                                  R                         l                                     Y_l=C_l+T_l+R_l                Yl=Cl+Tl+Rl，其中，                                           Y                         l                                     Y_l                Yl表示水质指标的时间序列数据，                                           C                         l                                     C_l                Cl表示趋势-周期分量，                                           T                         l                                     T_l                Tl表示季节分量，                                           R                         l                                     R_l                Rl表示残差分量。
一般来说，猜测方法使用分解作为时间序列数据的预处置惩罚步调，但这种操作错过了未来时间序列中组件之间的相互作用。相比之下，SVD-Autoformer使用分解作为嵌入式操作模块，从复杂的水质时间序列中提取更有代价的特征。首先，SVDAutoformer应用移动平均线来平滑周期性颠簸，突出长期趋势。然后，应用填充操作以保持序列长度的一致性。这里，                                  Y                      =                      {                                  y                         1                               ，                                  y                         2                               ，                      .                      .                      .                      ，                                  y                         l                               }                            Y = \{y_1，y_2，...，y_l \}                Y={y1，y2，...，yl}表示长度为l的水质指标时间序列。分解过程形貌如下：
                                          Y                         c                               =                      A                      v                      g                      P                      o                      o                      l                      (                      P                      a                      d                      d                      i                      n                      g                      (                      Y                      )                      )                            Y_c=AvgPool(Padding(Y))                Yc=AvgPool(Padding(Y))
                                          Y                         t                               =                      Y                      −                                  Y                         c                                     Y_t=Y-Y_c                Yt=Y−Yc
其中                                           Y                         c                                     Y_c                Yc表示趋势周期分量，使用AvgPool（·）导出，并举行填充以保留时间序列长度。                                           Y                         t                                     Y_t                Yt表示季节分量，由Y去除                                           Y                         c                                     Y_c                Yc得出。
2.Encoder
  编码层由两个内部序列分解模块组成。首先，编码器输入长度为L的时间序列Y，两个模块使用AvgPool(·)去除趋势周期分量。然后，编码器分离出剩余的分量，去除趋势周期分量，并专注于对季节分量举行建模。编码器的输出分量由季节分量组成，其用于在解码器中细化猜测效果。第1个编码器可以表示为                                           Y                                     e                            n                                     j                               =                      E                      n                      c                      o                      d                      e                      r                      （                                  Y                                     e                            n                                              j                            −                            1                                           ）                            Y^j_{en} = Encoder（Y^{j-1 }_{en}）                Yenj=Encoder（Yenj−1）。编码器的过程如下所示：
                                          T                                     e                            n                                              j                            ,                            1                                           =                      D                      e                      c                      o                      m                      p                      (                      A                      u                      t                      o                      −                      C                      o                      r                      r                      e                      l                      a                      t                      i                      o                      n                      (                                  Y                                     e                            n                                              j                            −                            1                                           )                      +                                  Y                                     e                            n                                              j                            −                            1                                           )                            T^{j,1}_{en}=Decomp(Auto-Correlation(Y^{j-1}_{en})+Y^{j-1}_{en})                Tenj,1=Decomp(Auto−Correlation(Yenj−1)+Yenj−1)
                                          T                                     d                            e                                              j                            ,                            2                                           =                      D                      e                      c                      o                      m                      p                      (                      F                      e                      e                      d                      F                      o                      r                      a                      w                      r                      d                      (                                  T                                     e                            n                                              j                            ,                            1                                           )                      +                                  T                                     e                            n                                              j                            ,                            1                                           )                            T^{j,2}_{de}=Decomp(FeedForawrd(T^{j,1}_{en})+T^{j,1}_{en})                Tdej,2=Decomp(FeedForawrd(Tenj,1)+Tenj,1)
其中                                           T                                     e                            n                                              j                            ,                            k                                              T^{j,k}_{en}                Tenj,k表示第j层编码器中第k级数分解模块提取的季节分量，其中j∈[1，…，P]和k∈[1，2]。                                           Y                                     e                            n                                     j                                     Y^{j}_{en}                Yenj表示第j层编码器的效果
3.Decoder
  解码器的输入包罗两个分量，即，趋势-周期成分和从内部序列分解获得的季节成分。解码器的左侧部分侧重于通过将剩余分量与趋势周期性分量分离来细化趋势。右侧部分累积来自编码器的细化趋势和趋势循环分量。解码器的过程如下：
                                          T                                     d                            e                                              j                            ,                            1                                           ,                                  C                                     d                            e                                              j                            ,                            1                                           =                      D                      e                      c                      o                      m                      p                      (                      A                      u                      t                      o                      −                      C                      o                      r                      r                      e                      l                      a                      t                      i                      o                      n                      (                                  Y                                     d                            e                                              j                            −                            1                                           )                      +                                  Y                                     d                            e                                              j                            −                            1                                           )                            T^{j,1}_{de},C^{j,1}_{de}=Decomp(Auto-Correlation(Y^{j-1}_{de})+Y^{j-1}_{de})                Tdej,1,Cdej,1=Decomp(Auto−Correlation(Ydej−1)+Ydej−1)
                                          T                                     d                            e                                              j                            ,                            2                                           ,                                  C                                     d                            e                                              j                            ,                            2                                           =                      D                      e                      c                      o                      m                      p                      (                      A                      u                      t                      o                      −                      C                      o                      r                      r                      e                      l                      a                      t                      i                      o                      n                      (                                  T                                     d                            e                                              j                            ,                            1                                           ,                                  Y                                     e                            n                                     p                               )                      +                                  T                                     d                            e                                              j                            ,                            1                                           )                            T^{j,2}_{de},C^{j,2}_{de}=Decomp(Auto-Correlation(T^{j,1}_{de},Y^{p}_{en})+T^{j,1}_{de})                Tdej,2,Cdej,2=Decomp(Auto−Correlation(Tdej,1,Yenp)+Tdej,1)
                                          T                                     d                            e                                              j                            ,                            3                                           ,                                  C                                     d                            e                                              j                            ,                            3                                           =                      D                      e                      c                      o                      m                      p                      (                      F                      e                      e                      d                      F                      o                      r                      w                      a                      r                      d                      (                                  T                                     d                            e                                              j                            ,                            2                                           )                      +                                  T                                     d                            e                                              j                            ,                            2                                           )                            T^{j,3}_{de},C^{j,3}_{de}=Decomp(FeedForward(T^{j,2}_{de})+T^{j,2}_{de})                Tdej,3,Cdej,3=Decomp(FeedForward(Tdej,2)+Tdej,2)
其中                                           T                                     d                            e                                              j                            ,                            k                                              T^{j,k}_{de}                Tdej,k和                                           C                                     d                            e                                              j                            ,                            k                                              C^{j,k}_{de}                Cdej,k表示第j层解码器中的第k个系列分解模块的季节性和趋势循环分量，其中j∈[1，…，Q]和k∈[1，2，3]。                                           Y                                     d                            e                                     j                                     Y^{j}_{de}                Ydej表示第j层解码器的输出。P表示编码器的数目。                                           Y                                     e                            n                                     P                                     Y^P_{en}                YenP表示具有P层的编码器的输出。

其中 V j , k V_{j,k} Vj,k表示第j层解码器中的趋势投影，其中k个系列分解模块细化趋势。表示第j层解码器中累积的趋势循环分量。Q表示解码器的数目。 T d e Q T^Q_{de} TdeQ和 C d e Q C^Q_{de} CdeQ表示季节性分量和趋势周期性分量，它们在由第Q层解码器处置惩罚后获得的。 Υ \Upsilon Υ表示通过累积Q层解码器的趋势循环和季节分量而获得的未来猜测。
4.自相关机制(Auto-correlation Mechanism)
自相关机制可以提供基于时间序列数据的周期性的序列级连接，这扩展了信息使用。首先，我们使用快速傅立叶变换来计算自相关系数，从而捕获时延相似性。自相关机制通过计算序列自相关来识别基于周期的依赖性，并最终通过期延聚合来组合相似的依赖性。随机过程理论表明，对于离散时间过程，可以获得自相关系数，其中：

其中 R X X ( τ ) R_{XX}(τ) RXX(τ)表示自相关系数。 X t X_t Xt和 τ τ τ表示离散时间过程和时间延迟。
1.3 实验

两个真实天下的水质数据集被用来验证SVD的猜测性能。京津冀和亚拉巴马数据集：数据1和数据2。京津冀数据集来自国家地表水水质主动实时监测系统。该数据集涵盖2018年8月至2022年12月。它包罗每四小时采集的大约8000个样本。水质指标包罗pH、EC、TN和DO。在多指标猜测中，使用这四个水质指标对TN的未来值举行猜测。亚拉巴马数据集记录了美国亚拉巴马的卡哈巴河的水质数据。数据集涵盖2017年5月至2019年8月。它包罗每小时采集的约20，000个样本。水质指标为DO，该数据集用于在单指标猜测中猜测未来的DO。按照70%、10%和20%的比例，数据集被分为训练集、验证集和测试集。
1.3.1 评估指标

为了评估SVD-Autoformer和代表性方法的正确性，我们采用了三个评估指标，包罗均方根误差（RMSE），平均绝对百分比误差（MAPE），平均绝对误差（MAE）。这些指标的值越低，表示猜测性能越好。它们被界说为：

RMSE = 1 L ∑ l = 1 L ( y l − y ^ l ) 2 \text{RMSE} = \sqrt{\frac{1}{L}\sum_{l=1}^{L} (y_l - \hat{y}_l)^2} RMSE=L1∑l=1L(yl−y^l)2
MAPE = 1 L ∑ l = 1 L ∣ y l − y ^ l y l ∣ × 100 % \text{MAPE} = \frac{1}{L}\sum_{l=1}^{L} \left| \frac{y_l - \hat{y}_l}{y_l} \right| \times 100\% MAPE=L1∑l=1L ylyl−y^l ×100%
MAE = 1 L ∑ l = 1 L ∣ y l − y ^ l ∣ \text{MAE} = \frac{1}{L}\sum_{l=1}^{L} |y_l - \hat{y}_l| MAE=L1∑l=1L∣yl−y^l∣

其中L表示原始数据的总数。 y l y_l yl和 y ^ l \hat y_l y^l表示地面实况和猜测值。
1.3.2 实验对比

数据预处置惩罚
首先，我们使用z分数标准化方法对数据举行标准化，该方法将数据转换为均值为0、方差为1的标准正态分布。这里，y表示原始数据，y '表示标准化数据，μ表示原始数据的平均值，σ表示原始数据的标准差。公式如下： y ′ = y − μ σ y'=\frac{y-\mu}{\sigma} y′=σy−μ。然后，我们应用SG滤波器来降低数据噪声。证实SG滤波器在增强模型猜测方面优于其他滤波器方法，我们将其与典范的移动平均（MA）滤波器和移动中值（MM）滤波器。我们在数据1和数据2上举行实验以比力SG、MM和MA滤波器。表I给出了具有差别窗口巨细的三个滤波器的RMSE值。SG滤波器对于各种窗口巨细具有最低的RMSE值，表明模型猜测改进更好。
为了优化SG滤波器的降噪能力，我们采用差别多项式阶数（k）的SG滤波器，窗口巨细对数据1和数据2实行实验。表II给出了差别k和s的RMSE值。效果表明，对于数据1（数据2），当k =3和s =5（k =3和s =7）时，SVD-Autoformer具有最佳猜测。

如图显示了SVD主动天生器对长期猜测的评价指标。实验效果表明，SVD-Autoformer在长步长猜测方面优于其他基准模型。例如，在一步猜测中，RMSE、MAE和MAPE值分别下降了61%、65%和73%。它们在五步、十步和十五步猜测中也有显著下降。
为了直观地显示SVD-Autoformer具有更好的猜测性能，文章中将猜测步长的长度设置为1。然后，对SG-Autoformer和SVD-Autoformer举行了对比实验。上图（a）和上图（c）示出了数据1的实际TN值和猜测TN值的拟合效果。红色曲线表示猜测值，而蓝色曲线表示实际值.SVD-Autoformer的TN猜测值与真实值之间具有较好的拟合性能。在差别的迭代中，SVD主动天生器和基准模型的训练损失值如下图所示。SVD-Autoformer的训练损失值较低，且随着迭代次数的增加而保持稳定。

2 相关知识

2.1 变分模式分解（VMD）

变分模式分解（Variational Mode Decomposition, VMD）是一种用于信号处置惩罚的自适应信号分解方法，特别适用于处置惩罚非平稳和非线性信号。VMD通过将信号分解为多个固有模态函数（Intrinsic Mode Functions, IMFs），每个IMF具有差别的中心频率和带宽，从而能够有效地提取信号中的多尺度特征。
VMD的焦点头脑是通过变分优化题目来寻找信号的最佳分解方式，确保每个IMF在频域上是紧凑的，并且能够很好地表示信号的局部特征。
VMD的根本原理
VMD的目标是将一个输入信号 f ( t ) f(t) f(t)分解为K个IMF，每个IMF u k ( t ) u_k(t) uk(t)都具有明白的中心频率 w k w_k wk。VMD通过求解一个约束变分题目来实现这一目标，详细步调如下：

希尔伯特变换：首先对每个IMF                                                 u                            k                                     (                         t                         )                               u_k(t)                   uk(t) 举行希尔伯特变换，得到其分析信号：
                                                (                            δ                            (                            t                            )                            +                                        j                                              π                                  t                                                    )                                     ∗                                     u                            k                                     (                         t                         )                               \left(\delta(t) + \frac{j}{\pi t}\right) * u_k(t)                   (δ(t)+πtj)∗uk(t)
其中，                                     δ                               \delta                   δ是单位脉冲函数，                                     j                               j                   j是虚数单位，*表示卷积运算。
频率调制：对每个IMF的分析信号举行频率调制，将其频谱移动到基带：
[ ( δ ( t ) + j π t ) ∗ u k ( t ) ] e − j ω k t \left[ \left(\delta(t) + \frac{j}{\pi t}\right) * u_k(t) \right] e^{-j\omega_k t} [(δ(t)+πtj)∗uk(t)]e−jωkt
其中， w k w_k wk是第k个IMF的中心频率。
带宽约束：通过施加带宽约束，确保每个IMF在频域上是紧凑的。VMD的约束变分题目可以表示为：
                                                            min                               ⁡                                                    {                                              u                                  k                                           }                               ,                               {                                              ω                                  k                                           }                                                          {                                        ∑                               k                                                                ∥                                                 ∂                                     t                                                             [                                                    (                                        δ                                        (                                        t                                        )                                        +                                                          j                                                             π                                              t                                                                         )                                                    ∗                                                    u                                        k                                                    (                                     t                                     )                                     ]                                                             e                                                    −                                        j                                                          ω                                           k                                                       t                                                             ∥                                           2                               2                                        }                                           \min_{\{u_k\},\{\omega_k\}} \left\{ \sum_k \left\| \partial_t \left[ \left(\delta(t) + \frac{j}{\pi t}\right) * u_k(t) \right] e^{-j\omega_k t} \right\|_2^2 \right\}                   min{uk},{ωk}{∑k                ∂t[(δ(t)+πtj)∗uk(t)]e−jωkt                22}
约束条件为：                                                 ∑                            k                                              u                            k                                     =                         f                         (                         t                         )                               \sum_k u_k = f(t)                   ∑kuk=f(t)
其中，                                                 ∂                            t                                           \partial_t                   ∂t表示时间导数，                                        ∣                                     ∣                            2                            2                                           ||_2^2                   ∣∣22表示                                                 L                            2                                           L_2                   L2范数
增广拉格朗日函数：为了求解上述约束变分题目，引入增广拉格朗日函数 L：
L ( { u k } , { ω k } , λ ) = α ∑ k ∥ ∂ t [ ( δ ( t ) + j π t ) ∗ u k ( t ) ] e − j ω k t ∥ 2 2 + ∥ f ( t ) − ∑ k u k ( t ) ∥ 2 2 + ⟨ λ ( t ) , f ( t ) − ∑ k u k ( t ) ⟩ \begin{aligned} \mathcal{L}(\{u_k\},\{\omega_k\},\lambda) &= \alpha \sum_k \left\|\partial_t \left[ (\delta(t)+\frac{j}{\pi t})*u_k(t) \right] e^{-j\omega_k t}\right\|_2^2 \\ &\quad + \left\| f(t) - \sum_k u_k(t) \right\|_2^2 \\ &\quad + \langle \lambda(t), f(t) - \sum_k u_k(t) \rangle \end{aligned} L({uk},{ωk},λ)=αk∑ ∂t[(δ(t)+πtj)∗uk(t)]e−jωkt 22+ f(t)−k∑uk(t) 22+⟨λ(t),f(t)−k∑uk(t)⟩
其中， α \alpha α是惩罚因子， λ ( t ) \lambda(t) λ(t)是拉格朗日乘子。

VMD的优点

自适应性强：VMD不需要预先设定基函数，能够根据信号的特征自适应地分解出多个IMF，每个IMF都具有明白的物理意义。
抗噪能力强：VMD通过带宽约束和频率调制，能够有效克制噪声，提取信号中的有用信息。
避免模态混叠：与履历模态分解（EMD）相比，VMD能够有效避免模态混叠题目，确保每个IMF在频域上是紧凑的。

变分模式分解（VMD）是一种强大的信号分解方法，能够有效处置惩罚非平稳和非线性信号。通过将信号分解为多个IMF，VMD能够提取信号中的多尺度特征，降低信号的复杂性和非平稳性。在风电功率猜测中，VMD能够显著提高猜测模型的精度和稳定性。只管VMD存在参数选择和计算复杂度较高的范围性，但其在信号处置惩罚范畴的应用前景广阔，特别是在处置惩罚复杂信号和噪声克制方面体现精彩。
相关代码

import torch
import torch.fft
import numpy as np
import matplotlib
matplotlib.use('TkAgg') # 切换到 TkAgg 后端
import matplotlib.pyplot as plt
def vmd(signal, num_modes=3, alpha=2000, tau=0, max_iter=500, tol=1e-7):
"""
Variational Mode Decomposition (VMD) using PyTorch.
参数:
signal (torch.Tensor): 输入信号 (1D tensor)
num_modes (int): 分解的模态数量 K
alpha (float): 带宽惩罚参数
tau (float): 时间步长参数 (通常设为 0)
max_iter (int): 最大迭代次数
tol (float): 收敛容差
返回:
u (torch.Tensor): 分解得到的模态分量 (num_modes x signal_length)
omega (torch.Tensor): 每个模态的中心频率
"""
# 确保输入信号是 PyTorch 张量
if not torch.is_tensor(signal):
signal = torch.tensor(signal, dtype=torch.float32)
signal = signal.to(torch.float32)
N = signal.shape[0] # 信号长度
# 初始化模态分量和中心频率
u = torch.zeros((num_modes, N), dtype=torch.float32) # 模态分量
omega = torch.linspace(0, 0.5, num_modes, dtype=torch.float32) # 初始中心频率
lambda_ = torch.zeros(N, dtype=torch.float32) # 拉格朗日乘子
# 计算单边频谱
f = torch.fft.rfft(signal)
freqs = torch.fft.rfftfreq(N)
# 迭代优化
for _ in range(max_iter):
u_old = u.clone()
for k in range(num_modes):
# 更新每个模态分量
# 计算残差
residual = signal - torch.sum(u, dim=0) + u[k]
# 傅里叶变换
u_hat = torch.fft.rfft(residual)
lambda_hat = torch.fft.rfft(lambda_) # 对 lambda_ 进行傅里叶变换
# 频域更新公式
denominator = 1 + 2 * alpha * (freqs - omega[k]) ** 2
u_hat_k = (u_hat - lambda_hat / 2) / denominator
# 逆傅里叶变换回到时域
u[k] = torch.fft.irfft(u_hat_k, n=N)
# 更新中心频率
for k in range(num_modes):
u_hat_k = torch.fft.rfft(u[k])
power_spectrum = torch.abs(u_hat_k) ** 2
omega[k] = torch.sum(freqs * power_spectrum) / torch.sum(power_spectrum)
# 更新拉格朗日乘子（时域）
lambda_ = lambda_ + tau * (torch.sum(u, dim=0) - signal)
# 检查收敛
if torch.norm(u - u_old) / torch.norm(u_old) < tol:
break
return u, omega
# 示例使用
# 示例使用
if __name__ == "__main__":
# 生成一个测试信号
t = torch.linspace(0, 1, 1000)
signal = (torch.sin(2 * np.pi * 5 * t) +
0.5 * torch.sin(2 * np.pi * 15 * t) +
0.2 * torch.randn(1000))
# 运行 VMD
num_modes = 2
u, omega = vmd(signal, num_modes=num_modes, alpha=2000, tau=0)
# 打印结果
print("模态分量形状:", u.shape)
print("中心频率:", omega)
# 可视化
plt.figure(figsize=(10, 6))
plt.subplot(num_modes + 1, 1, 1)
plt.plot(signal.numpy(), label="Original Signal")
plt.legend()
for k in range(num_modes):
plt.subplot(num_modes + 1, 1, k + 2)
plt.plot(u[k].numpy(), label=f"Mode {k + 1}")
plt.legend()
plt.tight_layout()
plt.show()

复制代码

其中，对于模态分量形状，2表示指定的模态数目，1000为输入信号的长度。中心频率是每个模态分量在频域中的重要振荡频率。VMD 通过优化算法调整这些频率，使每个模态的带宽最小化，同时保持分解的有效性。

原始信号（第一张子图）：显示输入信号的波形，例如一个包含 5 Hz 和 15 Hz 正弦波以及噪声的混淆信号。
分解后的模态分量（后续子图），每个模态单独绘制，展示它们各自的波形。
2.2 SVD-Autoformer代码

SVD-Autoformer伪代码

import torch
import torch.nn as nn
import math
class SVDAutoformer(nn.Module):
def __init__(self, input_length, num_encoder_layers, num_decoder_layers, d_model=512):
super(SVDAutoformer, self).__init__()
self.input_length = input_length
self.d_model = d_model
self.num_encoder_layers = num_encoder_layers
self.num_decoder_layers = num_decoder_layers
# Embedding layers
self.encoder_embedding = nn.Linear(1, d_model)
self.decoder_embedding = nn.Linear(1, d_model)
# Encoder and Decoder layers
self.encoder_layers = nn.ModuleList([
AutoCorrelationLayer(d_model) for _ in range(num_encoder_layers)
])
self.decoder_layers = nn.ModuleList([
DecoderLayer(d_model) for _ in range(num_decoder_layers)
])
# Final output layer
self.output_layer = nn.Linear(d_model, 1)
def decompose(self, x):
U, S, V = torch.svd(x)
return U, S, V
def forward(self, Y):
# Step 1: Decompose input series
Y_ens, Y_ent = self.decompose(Y[:, :self.input_length//2])
# Step 2: Concatenate with placeholders
Y0 = torch.zeros_like(Y_ent)
Y_mean = torch.mean(Y_ent, dim=1, keepdim=True)
Y_des = torch.cat([Y_ent, Y0], dim=1)
Y_det = torch.cat([Y_ent, Y_mean], dim=1)
# Step 3: Embed encoder input
Y_en = self.encoder_embedding(Y[:, :, None])
# Step 4-7: Encoder layers
for j in range(self.num_encoder_layers):
# Auto-Correlation
Tj1 = self.encoder_layers[j].auto_correlation(Y_en) + Y_en
# Feed Forward
Tj2 = self.encoder_layers[j].feed_forward(Tj1) + Tj1
Y_en = Tj2
# Step 9: Embed decoder input
Y_de = self.decoder_embedding(Y_des[:, :, None])
C0_de = torch.zeros_like(Y_de)
# Step 10-15: Decoder layers
for j in range(self.num_decoder_layers):
# Auto-Correlation
Tj1, Cj1 = self.decoder_layers[j].auto_correlation(Y_de) + Y_de
# Cross Attention
Tj2, Cj2 = self.decoder_layers[j].cross_attention(Tj1, Y_en) + Tj1
# Feed Forward
Tj3, Cj3 = self.decoder_layers[j].feed_forward(Tj2) + Tj2
Y_de = Tj3
C_de = Cj1 + Tj1 * Cj1 + Tj2 * Cj2 + Tj3 * Cj3
# Step 16-17: Final output
Y_pred = self.output_layer(Y_de)
Y_pred = Y_pred.squeeze(-1) + C_de
return Y_pred
class AutoCorrelationLayer(nn.Module):
def __init__(self, d_model, num_heads=8):
super(AutoCorrelationLayer, self).__init__()
self.d_model = d_model
self.num_heads = num_heads
self.query_projection = nn.Linear(d_model, d_model)
self.key_projection = nn.Linear(d_model, d_model)
self.value_projection = nn.Linear(d_model, d_model)
self.out_projection = nn.Linear(d_model, d_model)
self.feed_forward = nn.Sequential(
nn.Linear(d_model, d_model * 4),
nn.ReLU(),
nn.Linear(d_model * 4, d_model)
)
def auto_correlation(self, x):
batch_size, seq_len, _ = x.size()
Q = self.query_projection(x)
K = self.key_projection(x)
V = self.value_projection(x)
# Reshape for multi-head attention
Q = Q.view(batch_size, seq_len, self.num_heads, -1).transpose(1, 2)
K = K.view(batch_size, seq_len, self.num_heads, -1).transpose(1, 2)
V = V.view(batch_size, seq_len, self.num_heads, -1).transpose(1, 2)
# Scaled dot-product attention
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_model // self.num_heads)
attention = torch.softmax(scores, dim=-1)
out = torch.matmul(attention, V)
out = out.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model)
out = self.out_projection(out)
return out
def feed_forward(self, x):
return self.feed_forward(x)
class DecoderLayer(AutoCorrelationLayer):
def __init__(self, d_model, num_heads=8):
super(DecoderLayer, self).__init__(d_model, num_heads)
self.cross_query = nn.Linear(d_model, d_model)
self.cross_key = nn.Linear(d_model, d_model)
self.cross_value = nn.Linear(d_model, d_model)
self.cross_out = nn.Linear(d_model, d_model)
def cross_attention(self, x, encoder_output):
Q = self.cross_query(x)
K = self.cross_key(encoder_output)
V = self.cross_value(encoder_output)
batch_size, seq_len, _ = x.size()
Q = Q.view(batch_size, seq_len, self.num_heads, -1).transpose(1, 2)
K = K.view(batch_size, seq_len, self.num_heads, -1).transpose(1, 2)
V = V.view(batch_size, seq_len, self.num_heads, -1).transpose(1, 2)
scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(self.d_model // self.num_heads)
attention = torch.softmax(scores, dim=-1)
out = torch.matmul(attention, V)
out = out.transpose(1, 2).contiguous().view(batch_size, seq_len, self.d_model)
out = self.cross_out(out)
return out, attention
# Example usage:
if __name__ == "__main__":
input_length = 96
num_encoder_layers = 2
num_decoder_layers = 2
model = SVDAutoformer(input_length, num_encoder_layers, num_decoder_layers)
# Dummy input (batch_size, sequence_length)
Y = torch.randn(32, input_length)
output = model(Y)
print(output.shape) # Should be [32, 96]

复制代码

总结

猜测水质并实时采取举措至关重要。然而，传统的猜测方法不能有效地捕捉时间序列中的时间相关性，并且容易受到噪声的干扰。文章所提出的SVD-自整定器结合了Savitzky-Golay滤波器、变分模式分解、自相关机制和改进的Transformer。其SG滤波和VMD能有效地降低噪声干扰，提取水质数据的非线性特征。此外，SVD-Autoformer使用深度分解架构和自相关机制。一方面，从水质数据中分解出更多的可猜测成分。另一方面，实现了序列级链接，提高了信息使用率。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

		自动登录	找回密码
密码			立即注册

机器学习周报-文献阅读

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云