1D-CNN时间序列预测实战：原理、PyTorch实现与调参避坑指南

简介：面向时间序列分析与深度学习入门者的1D-CNN（一维卷积神经网络）Python实现代码包。其核心设计借鉴二维卷积网络，但卷积核仅在时间维度滑动，适合处理音频、文本、传感器数据等一维序列，可应用于语音识别、情感分析、金融时序预测等任务。包体非常轻量，共3个文件且均为Python脚本，压缩包仅3KB，分别承担网络结构搭建、训练数据预处理与模型训练、以及基于新样本的预测调用，形成完整可运行的代码链路。已有3358人学习下载，是理解一维卷积、池化下采样与全连接输出的简洁范例。通过阅读代码，既能掌握1D-CNN在时间序列分类与回归中的基本实现思路，也能直接修改参数或迁移到自己的项目中，适合希望以最小依赖快速上手时序建模的开发者。

1. 1D-CNN处理时间序列：为什么它比LSTM更能打

如果你手里有一批传感器采集的振动波形、电力负荷曲线或者股票分钟线，第一反应往往是上LSTM。但真跑过一轮对比实验的人大概率遇到过这种情况：LSTM训了上百个epoch还在震荡，而把数据切成窗口丢给一层一维卷积，几十个epoch就收敛了，效果还更好。这不是玄学，而是 1D-CNN 在处理局部时序特征时天然占优——它直接把“相邻几步之间有相关性”这件事写进了网络结构里，不需要像RNN那样一步步累积记忆。本文就顺着 1D-CNN 在时间序列分析与预测上的完整落地路径，从原理拆到代码，再拆到参数和坑，让你能照着复现并判断自己的场景适不适合它。适合正在做时间序列预测、异常检测或信号分类，又不想在循环网络上花太多训练时间的工程师。

2. 一维卷积为什么适合时序数据：从卷积核到感受野的取舍

2.1 卷积如何作用于一维信号：本质是滑动窗口加权求和

一维卷积做的事，本质上就是用一个固定长度的窗口（卷积核）在输入序列上滑动，每个位置做一次点乘加偏置。这个操作天然假设了“相邻元素之间的局部关系是可复用的”，而这恰好是绝大多数时间序列的共性：前5个采样点的走势往往决定了第6个点的大致范围，电流信号里一个短暂的尖峰可能意味着负载切换，振动信号里连续三个周期的波形形态直接对应机械状态。

和图像上的二维卷积相比，一维卷积的差异在于它只在时间轴方向滑动，所以卷积核的尺寸是一个整数 k，而不是(k, k)的矩阵。这带来一个直接影响：模型需要学习的参数大幅减少。一个用 kernel_size=7 的 64 通道一维卷积层，参数量是 7×64+64，约500个；而同样输入长度下，一个隐层维度为64的LSTM单元光是输入到隐层的权重就是 64×4×64，超过16000个。参数量少意味着在小规模时间序列数据集上更难过拟合，训练速度也快一个数量级。

但参数少不代表能力弱。多个一维卷积层堆叠之后，每一层看到的视野逐级扩大：第一层只看7个点，第二层理论上能看到约13个点，第三层约19个点。这就是感受野的概念。设计网络时，你其实是在用层数和卷积核尺寸换取不同尺度的时间依赖。短时突刺类特征适合浅层小核，长期趋势类特征需要加深或加大核。

从实际工程角度，我一般会把 1D-CNN 视作“时序特征的提取器”：它不需要像LSTM那样按时间步逐个推理，而是把整个滑窗当作一张一维的“图”一次性卷积完。这种并行计算特性，让它在GPU上的利用率远高于循环网络。你只需要记住一条原则：卷积核越大，捕获的依赖越长，但局部细节越钝；层数越深，抽象层次越高，但训练难度随之上升。

2.2 和LSTM、Transformer放在一起选型：什么场景该用1D-CNN

很多人在时间序列预测任务里一上来就选LSTM，这是惯性思维。做选型之前，先回答三个问题。第一，你的序列里是否存在足够强的局部模式？比如电力负荷有典型的“工作日早高峰”形状，滚动轴承故障信号有固定的冲击周期，这些局部模板会在序列中反复出现，卷积核就是为捕捉这种复用模式设计的。第二，你需要的依赖长度是有限的还是无限的？1D-CNN 的感受野会随层数线性增长，但不会像LSTM那样理论可以记忆任意长度；如果序列长度超过几百且存在跨窗口的长程依赖，纯 1D-CNN 会力不从心。第三，你对延迟和吞吐的要求有多高？流式预测场景中，1D-CNN 一次前向传播就能输出整个窗口的预测，LSTM 必须按时间步循环，延迟天然多出几个数量级。

下表是我在实际项目里的选型依据，虽然粗糙但决策效率很高：

还有一个经常被忽略的工程点：1D-CNN 的推理延迟是极低的。一次卷积操作在CPU上毫秒级完成，在嵌入式设备上甚至可以量化到int8后跑实时推理。相比之下，LSTM 的循环依赖让它在边缘设备上的推理效率很糟糕。如果你的目标是部署到单片机或者移动端做实时异常检测，1D-CNN 几乎是唯一现实的选择。

注意：这里不是说LSTM一无是处。在自然语言、语音等序列长度极长且依赖复杂的场景，LSTM和Transformer仍然是主流。1D-CNN 适合的是“局部模板+中等长度”的时序信号，认准这个边界。

3. 用PyTorch复现1D-CNN时间序列预测：从数据切分到训练评估

3.1 数据准备：滑窗切分与归一化的两个关键细节

时间序列预测的第一步是把原始序列切成“输入-标签”对。最常见的做法是滑窗：用过去 look_back 个点预测未来1个点。窗口大小直接决定模型能看到的上下文长度，设置时参考你对数据周期的先验知识。比如按小时采样的电力数据，日周期是24个点，窗口至少要24；如果想看到周周期，那就要168。

import numpy as np import torch from torch.utils.data import Dataset, DataLoader def create_sequences(data, look_back=24, horizon=1): """ 将一维时间序列切分为滑窗样本。 data: 已归一化的 numpy 数组，形状 (n_samples,) look_back: 输入窗口长度，即用过去多少个点预测未来 horizon: 预测步长，默认预测下一个点 返回 X: (n_samples-look_back-horizon+1, look_back, 1) y: (n_samples-look_back-horizon+1, horizon) """ X, y = [], [] for i in range(len(data) - look_back - horizon + 1): X.append(data[i:i+look_back].reshape(look_back, 1)) y.append(data[i+look_back:i+look_back+horizon]) return np.array(X), np.array(y) # 模拟一组带趋势和周期的时间序列 t = np.arange(0, 1000) data = 3.0 * np.sin(2 * np.pi * t / 40) + 0.01 * t + 0.5 * np.random.randn(1000) data = (data - np.mean(data)) / np.std(data) X, y = create_sequences(data, look_back=24, horizon=1) # 按时间顺序切分，注意不能随机打乱训练集和验证集 train_len = int(len(X) * 0.8) X_train, y_train = X[:train_len], y[:train_len] X_val, y_val = X[train_len:], y[train_len:] print(f"训练样本: {X_train.shape}, 验证样本: {X_val.shape}")

这段代码里有一个经常翻车的点：切分训练集和验证集时绝对不能随机打乱。时间序列是有顺序依赖的，如果验证集里混入了训练集时间范围之前的样本，模型等于提前看到了“未来”的分布特征，验证分数会虚高。这里按时间顺序切分，前80%训练、后20%验证。归一化必须在切分之前对整个序列做，否则验证集的均值和标准差会泄漏到训练过程里。

注意：如果你把归一化拟合在训练集上再用训练集的均值和标准差去变换验证集，遇到分布漂移时验证集会失真。稳妥做法是用整个历史数据的统计量做归一化，然后在部署阶段用同样的参数去变换新数据。

3.2 模型结构：三层卷积加全连接，参数量不到5万

1D-CNN 的基本组成是 Conv1d、BatchNorm1d、ReLU 和 MaxPool1d 的堆叠。设计时控制每层的通道数从 16 翻倍到 64，卷积核大小统一用 5，池化层把长度减半。三层之后序列长度从 24 压到 3，再展平接全连接层输出预测值。

import torch.nn as nn class TimeSeriesCNN(nn.Module): def __init__(self, input_size=1, seq_len=24, horizon=1): super().__init__() self.conv1 = nn.Sequential( nn.Conv1d(input_size, 16, kernel_size=5, padding=2), nn.BatchNorm1d(16), nn.ReLU(), nn.MaxPool1d(2) ) self.conv2 = nn.Sequential( nn.Conv1d(16, 32, kernel_size=5, padding=2), nn.BatchNorm1d(32), nn.ReLU(), nn.MaxPool1d(2) ) self.conv3 = nn.Sequential( nn.Conv1d(32, 64, kernel_size=5, padding=2), nn.BatchNorm1d(64), nn.ReLU(), nn.MaxPool1d(2) ) # 经过三层池化后序列长度: seq_len // 2 // 2 // 2 self.fc = nn.Linear(64 * (seq_len // 8), horizon) def forward(self, x): # x 形状: (batch, seq_len, input_size)，需要转成 (batch, input_size, seq_len) x = x.permute(0, 2, 1) x = self.conv1(x) x = self.conv2(x) x = self.conv3(x) x = x.flatten(1) return self.fc(x) model = TimeSeriesCNN(input_size=1, seq_len=24, horizon=1) total_params = sum(p.numel() for p in model.parameters()) print(f"模型总参数量: {total_params}")

这里有个特别容易忽略的维度细节：PyTorch 的 Conv1d 期望输入形状是 (batch, channels, seq_len)，而不是 (batch, seq_len, channels)。所以 forward 里第一步必须做 permute 把序列维度调到最后。我自己第一次写的时候就在这儿报维度错，排查了十几分钟。另外 padding 设置为 kernel_size//2（这里就是2），是为了让卷积不改变序列长度，否则三层堆叠之后长度越来越短，池化可能直接池没了。

全连接层的输入维度是 64 × (seq_len // 8)，因为三层 MaxPool1d(2) 会把长度除以8。如果你的 seq_len 不能被8整除，改窗口大小或者改变池化步长，否则维度对不上。这是 1D-CNN 设计与数据长度强耦合的一种体现，不兼容就没法跑。

3.3 训练循环与评估：用均方误差还是平均绝对误差

训练环节和一般回归任务没区别，优化器用 Adam，学习率 1e-3，损失函数用均方误差。但评估指标不能只看MSE，时间序列预测里MSE对所有点一视同仁，可实际上峰值和低谷的预测误差才是业务关心的。我习惯同时打印验证集的MSE和MAE，如果两者差距大，说明误差主要来自少数极端点。

import torch.optim as optim def train_model(model, train_loader, val_loader, epochs=50, lr=1e-3): optimizer = optim.Adam(model.parameters(), lr=lr) scheduler = optim.lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.5) criterion = nn.MSELoss() for epoch in range(epochs): model.train() train_loss = 0.0 for xb, yb in train_loader: optimizer.zero_grad() pred = model(xb) loss = criterion(pred, yb) loss.backward() optimizer.step() train_loss += loss.item() * len(xb) train_loss /= len(train_loader.dataset) model.eval() val_loss = 0.0 with torch.no_grad(): for xb, yb in val_loader: pred = model(xb) loss = criterion(pred, yb) val_loss += loss.item() * len(xb) val_loss /= len(val_loader.dataset) if (epoch + 1) % 10 == 0: print(f"Epoch {epoch+1:3d} | Train Loss: {train_loss:.6f} | Val Loss: {val_loss:.6f}") scheduler.step() return model # 构建 DataLoader train_dataset = [ (torch.tensor(X_train[i], dtype=torch.float32), torch.tensor(y_train[i], dtype=torch.float32)) for i in range(len(X_train)) ] val_dataset = [ (torch.tensor(X_val[i], dtype=torch.float32), torch.tensor(y_val[i], dtype=torch.float32)) for i in range(len(X_val)) ] train_loader = DataLoader(train_dataset, batch_size=64, shuffle=False) val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False) model = train_model(model, train_loader, val_loader, epochs=50)

这里要特别说明两点。第一，训练时的 DataLoader 里 shuffle 仍然要设成 False，理由和设备训练集切分时完全一样——相邻样本的输入窗口高度重叠，随机打乱会让模型反复看到几乎重复的数据，浪费算力且无意义。第二，lr_scheduler 每20个epoch把学习率减半，这是我处理1D-CNN训练后期loss震荡的经验做法：前20个epoch快速下降，后30个epoch在小学习率下精调。

训练完成后，用验证集尾部的一段连续预测来目视检查效果。画一条真实值与预测值的曲线，重点看峰谷是否对齐、是否有一个固定的相位偏移。如果预测曲线整体比真实曲线滞后一个固定步数，说明模型学到的更像是“复制上一个值”而不是“预测未来”，这时需要增大窗口长度或加深网络。

4. 调参让1D-CNN在时间序列上更稳：核大小、池化节奏与混合结构

4.1 卷积核大小与感受野匹配：别让模型只看局部或看得太广

卷积核大小是 1D-CNN 最重要的旋钮。核太小，比如 kernel_size=3，模型只能看到3个连续点，如果数据的基本模式是日周期24个点，那第一层根本捕捉不到任何周期结构，后面堆再多层都事倍功半。核太大，比如 kernel_size=15，虽然能覆盖更多上下文，但参数翻倍且容易过拟合小数据集。

我的经验法则是：把卷积核大小设为你期望模型在第一层就能感知到的最小模式长度。比如负荷曲线的日周期是24点，用 kernel_size=7 到 9 比较合适，让第一层看到一天中约三分之一的信息；机械振动信号的冲击周期也许只有5个采样点，那 kernel_size=5 就足够。如果想覆盖更长依赖，优先增加层数而不是盲目加大核，因为每层之后加池化，感受野会指数增长；而核大小线性增长只会线性扩展视野，性价比很低。

感受野的完整计算公式是：第 n 层感受野 = 第 n-1 层感受野 + (kernel_size - 1) × 前面所有步长的乘积。你可以用这个小公式验证自己设计的网络到底能看到多长的历史。如果三层 conv3 各带 stride=2 的池化，核大小是5，感受野是 1 + 4 + 4×2 + 4×2×2 = 29 个点，正好覆盖一个日周期加一点余量，这是非常合理的配置。

4.2 池化策略与下采样节奏：保留峰值信息比压平更重要

MaxPool1d 是 1D-CNN 默认的下采样方式，但它在时间序列上有一个隐蔽问题：最大池化只保留窗口内的最大值，如果窗口跨过一个尖峰和一个平缓段，尖峰被保留，平缓段的形态信息丢失。对异常检测这类对峰值敏感的任务，这恰恰是好事；但对趋势预测，峰值信息不如整体形态重要，这时候 AveragePooling 往往更稳定。

另一个常被忽略的参数是池化层的位置。标准做法是卷积→激活→池化，但如果你用的是 BatchNorm，池化放在BN前面还是后面会有细微差别。我习惯把池化放在BN和ReLU之后，这样激活后的特征已经做了非线性变换，池化操作的是更有判别力的特征图。如果你发现网络在训练早期loss就卡住不动，试着把池化从 stride=2 改成 stride=2 加 padding=1 的组合，有时只是边界丢弃导致的梯度稀疏问题。

实际项目中，我一般会做一个小实验：分别用 MaxPool1d 和 AveragePool1d 训练一轮对比验证集MAE，选择更小的那一个。这个实验成本极低——只需改一行代码，但经常能带来2%到3%的精度提升。

4.3 混合结构：1D-CNN+LSTM的互补搭配与参数分配

当序列里同时存在明显的局部模板和跨窗口的长程趋势时，单一 1D-CNN 可能不够。常见做法是前段用两层1D-CNN提取局部特征，把序列长度压缩到原来的一半，再把特征序列送入一层轻量LSTM建模剩余的长程依赖。这种结构既保留了CNN的并行优势和局部感知能力，又补上了CNN难以建模长期依赖的短板。

class HybridCNN_LSTM(nn.Module): def __init__(self, seq_len=72, input_size=1, cnn_out=32, lstm_hidden=16, horizon=1): super().__init__() self.conv = nn.Sequential( nn.Conv1d(input_size, 16, kernel_size=7, padding=3), nn.BatchNorm1d(16), nn.ReLU(), nn.MaxPool1d(2), nn.Conv1d(16, cnn_out, kernel_size=5, padding=2), nn.BatchNorm1d(cnn_out), nn.ReLU(), nn.MaxPool1d(2) ) # 经过两层池化后 seq_len -> seq_len // 4 self.lstm = nn.LSTM( input_size=cnn_out, hidden_size=lstm_hidden, num_layers=1, batch_first=True ) self.fc = nn.Linear(lstm_hidden, horizon) def forward(self, x): # x: (batch, seq_len, input_size) x = x.permute(0, 2, 1) # (batch, input_size, seq_len) x = self.conv(x) # (batch, cnn_out, seq_len//4) x = x.permute(0, 2, 1) # (batch, seq_len//4, cnn_out) out, _ = self.lstm(x) # out: (batch, seq_len//4, lstm_hidden) out = out[:, -1, :] # 取最后一步输出 return self.fc(out)

这个混合结构里有一个参数分配原则：CNN部分的参数占比约60%到70%，LSTM部分控制在30%左右。CNN负责把原始序列从24或72压缩到十几个特征步，LSTM只在这段短序列上建模依赖，速度和效果都比直接用LSTM处理长序列好。取LSTM最后一步的输出而不是所有步的平均，是因为在预测任务里，最后一步的隐状态包含了前序全部信息的汇总，取平均会稀释靠近当前时刻的近期模式。

如果你在混合模型上发现训练变慢且没有明显提升，先检查是不是LSTM层数设置太多了。对于压缩后的短序列，一层LSTM通常足够，两层以上不仅参数翻倍，还容易在反向传播时梯度消失。

5. 1D-CNN时间序列实战避坑：五个常见翻车点与排查

5.1 时间泄漏：验证集居然比训练集还要好

现象：训练损失正常下降，验证集loss极低，甚至低过训练集，画出曲线发现预测值和真实值几乎重合，但这种表现在新数据上一塌糊涂。

原因：数据预处理阶段用了整个时间序列的统计量做归一化，或者切分训练验证集时混入了未来的信息。具体到1D-CNN，滑动窗口里的第 t 个样本和第 t+1 个样本高度重叠，如果验证集紧挨着训练集尾部，模型看到的验证集输入其实大部分在训练集里出现过。

解决：切分时训练集和验证集之间留一段空白缓冲区间，长度等于look_back；归一化只允许用训练集部分的统计量。如果验证集仍然好得异常，把验证集起点再往后推一段距离重新测试。

5.2 模型输出比输入滞后一位：整体右移的“预测”

现象：预测曲线和真实曲线形状几乎一样，但整体滞后了一个时间步。很多人看到这个结果以为是预测成功，实际上模型学到的是“把上一时刻的值复制过来”。

原因：时间序列存在强自相关，相邻点之间数值接近，模型用MSE很容易通过近似复制未来值达到低损失。尤其当滑窗长度只有1或2时，这种现象几乎必然发生。

解决：至少保证look_back大于数据的主周期；用差分或去掉趋势让序列平稳；评估时不只算MSE，还要检查预测和一阶差分曲线是否匹配。如果滞后仍然存在，把预测目标从“下一时刻值”改为“下一时刻与当前时刻的差值”，能有效打破复制行为。

5.3 BatchNorm在小batch下失效

现象：训练时用batch_size=16或更小，模型loss在初始值附近抖动，怎么调学习率都降不下去。

原因：BatchNorm在小batch上统计的均值和方差噪声太大，导致归一化结果不稳定。1D-CNN 的时间序列输入本身较短（几十个点），batch_size又小，BN层基本在震荡。

解决：把batch_size提高到64以上，或者干脆去掉BatchNorm换成GroupNorm。时间序列模型里我用 GroupNorm 的频次越来越高，它对batch大小不敏感，部署阶段也没有训练/推理模式切换的麻烦。

5.4 多步预测的误差累积

现象：用递归方式做多步预测——把上一步的预测值作为下一步的输入，前几步误差尚可，第10步之后预测曲线变成一条直线或发散。

原因：每一步预测的误差都会累积，输入分布逐渐偏离训练时的真实数据分布，模型进入从未见过的输入区域，输出失去意义。

解决：多步预测改用直接预测所有步，即horizon设为预测步数，输出维度对应未来多个点，一步到位。或者训练时加入一定的噪声作为对抗样本，让模型对误差累积鲁棒。最后一招是用高考常用的滑窗策略：预测一步，把真实值（而非预测值）滑入窗口，但这要求你在线部署时能实时获取真实观测。

5.5 数据长度不够但强行加深网络

现象：训练集只有几千个样本，模型层数加到6层以上，训练loss降到接近0，验证loss却升高，典型的过拟合。

原因：1D-CNN 参数总数虽然比LSTM少，但六层卷积的参数总量依然足以记忆几千个样本。时间序列的样本数量远少于图像分类，而且相邻样本高度相关，有效独立样本数更少。

解决：先运行一个简单的三层基线，对比验证loss，确认增益后再加深。或者用早停法监控验证loss，一旦连续5个epoch不下降就回退到最佳模型。数据增强方面，对时间序列可以加噪声、时间轴轻微伸缩、幅度缩放，但要保证不破坏物理规律——比如电力负荷的峰谷秩序不能因为增强而颠倒。

6. 进阶用法：从单变量预测到多传感器融合与推理部署

6.1 多变量输入的通道组织方式

传感器系统往往同时采集多个物理量：电流、电压、温度、振动。它们各自是一维序列，但彼此之间可能存在联合模式。这时不要急着把几个特征拼成一个长向量，而是让它成为多个输入通道，像图像的红绿蓝三通道一样，喂给Conv1d的 input_size 维度。这样卷积核在某个时间位置会同时看到所有变量，能学到变量之间的耦合关系，比如温度升高伴随电流上升。

# 输入张量形状: (batch, seq_len, num_features) # 经过 permute 后: (batch, num_features, seq_len) # Conv1d 的 in_channels 设置为 num_features conv1 = nn.Conv1d(in_channels=num_features, out_channels=32, kernel_size=5, padding=2)

但要注意，不同物理量往往量纲不同，温度范围可能是20到80，电流可能是0到50，放在同一卷积运算里，大数值变量会主导梯度更新。需要在模型输入之前对每个特征独立做归一化，不能用同一组统计量。另外，如果一个特征基本不变（比如环境温度在短时段内恒温），它的贡献会被池化层抹掉，可以考虑给每个特征通道加一个可学习的缩放权重，但这是锦上添花的操作，普通场景不太需要。

6.2 用可视化验证模型学到了什么

深度学习模型被诟病为黑匣子，但时间序列模型有一个天然优势：可以把卷积核直接可视化。把第一层卷积核的权重画出来当波形看，如果它们看起来像平滑的差分算子或带通滤波器，说明模型确实学到了有意义的局部模式；如果核权重全是高频噪声，大概率是数据泄露或过拟合。更进一步的验证方法是激活图可视化：把训练好的模型前向跑一遍测试样本，把每一层的特征图按时间轴堆叠画成热力图，看模型在哪个时间位置产生强烈的激活，判断它关注的是尖峰、平台还是下降沿。

我实际做异常检测的时候，会在验证集上跑一批已知故障样本，画出最后一层特征图，然后人工看一眼故障窗口内的激活峰值位置是否与故障发生点对齐。对齐就说明CNN捕捉到了故障特征，不对齐就回头改核大小。这种验证比单纯看AUC更直观，也更容易向业务方解释模型的行为。

6.3 推理部署的量化与裁剪技巧

如果你要把1D-CNN模型部署到边缘设备，PyTorch自带的量化工具可以直接派上用场。CNN的卷积运算对量化误差的容忍度比RNN高得多——我见过模型在int8量化后精度损失不到1%的情况，而同样量化LSTM往往直接劣化3%以上。量化的正确做法是先准备几百条有代表性的校准数据，跑一遍模型统计每层的激活范围，然后用torch.quantization精确到单个算子。

裁剪方面，1D-CNN 的高层卷积通道存在大量冗余，可以用全局平均池化后的通道激活值排序，剪掉那些激活始终接近0的通道。一个三层结构裁剪掉30%高层通道通常不会掉点，但推理速度能提升约两成。说句实话，我过去在嵌入式设备上部署时序模型，LSTM项目折腾了两周才压到可用的延迟，换成1D-CNN加int8量化后一个下午就解决了。如果你手头的设备是树莓派或类似的ARM平台，这个方案值得优先尝试。

提示：多变量模型量化前确认各特征的归一化参数是否已经固化在模型里，不要让量化校准数据经过训练时的归一化流程，否则分布不一致会放大量化误差。

说一个我自己的教训：早期做滚动轴承故障识别时，我执着地用LSTM建模整个振动信号，结果训练时间动辄几小时且效果不稳定。后来把信号切段，用1D-CNN做段内特征提取、再让LSTM处理段间依赖，精度提升了四个百分点，训练时间缩短到原来的三分之一。从那以后我的默认方案先跑1D-CNN基线，打不过再用混合模型。这个习惯帮我省了大量无效实验，希望也能帮到你。

本文还有配套的精品资源，点击获取