企业官网建设流程全解析

1. 项目概述与技术选型分析

2025年做深度学习时序建模，我身边不少朋友都在往KAN这个方向上靠。KAN的全称是Kolmogorov-Arnold Network，核心改动是把传统神经网络的"线性权重+固定激活函数"换成"可学习的激活函数"。这个设计刚提出来时还偏学术，到了2025年，围绕KAN的Python实现、工程优化以及和其他经典结构组合的案例已经非常丰富了。我今天要拆解的CNN-LSTM-KAN混合模型，就是把一维卷积、长短期记忆网络和KAN层串到一起，用于多变量时间序列预测的一套完整代码方案。

这个模型解决的典型问题是什么？举个例子。假设你有一组传感器采集到的风速、温度、湿度三条曲线，想预测未来某个关键指标。数据里既有短时间内的局部变化形态，又有跨小时级别的周期趋势，而且最终输出对各个特征的响应还高度非线性。这类问题用单一模型通常不够爽利，要么抓不住局部形态，要么记不住长期依赖，要么在最后映射时表达能力不足。CNN-LSTM-KAN三个模块各管一段，正好把这个链条补齐。

这篇文章适合正在做时间序列预测、故障诊断、能源负荷预测，或者只是想给自己的模型加一点创新点的同学。我会从选型逻辑讲到代码实现，再讲到调参和踩坑，全程按"拿过去就能跑"的标准来写。

1.1 为什么选这个组合而不是其他方案

选型这件事，我向来不喜欢跟风。2025年Transformer在序列建模上的热度依然很高，但具体到中小规模的多变量时序预测，Transformer的优势并不总是能兑现。它需要较大的数据量和较长序列才能发挥注意力机制的威力，而且推理显存开销明显。相比之下，CNN+LSTM的组合在几十到几千样本规模的数据上都能稳定工作，工程上也被验证了好几年，是性价比非常高的骨干结构。

那为什么还要加KAN？问题出在最后那个全连接层上。传统MLP的表达能力取决于层宽和层深，面对高度非线性的映射，往往需要很大的隐藏维度才能拟合。而KAN用B样条基函数让激活函数本身可学习，相当于在每个输入维度上给网络配备了可塑性更强的映射工具。我在实践中观察到，同样的拟合精度下，KAN层的参数量可以比对应MLP少一半以上，这对防止过拟合也有直接帮助。

还有一个工程上的考虑：KAN层和CNN、LSTM的拼接非常自然。CNN输出的特征序列经过LSTM编码后的向量，直接输入KAN层做映射，中间不需要额外的适配层。这种模块化的组装方式，既方便做消融实验，也方便后续把KAN层替换成其他新结构做二次创新。

1.2 KAN层到底改了什么

要理解KAN的革新，得先知道它背后的数学依据。Kolmogorov-Arnold表示定理说，任何一个多元连续函数都可以写成有限个一元函数之和。KAN把这个定理落到神经网络结构上，每一层不再是"输入加权求和后过激活函数"，而是把每个输入分量分别送入一组可学习的样条函数，再把结果线性组合起来。

我用一个生活化的比喻来解释。传统全连接层好比给你一套固定形状的积木，无论你多会拼，能搭出的轮廓总是受限；KAN层好比橡皮泥，每个输入维度都可以捏成自己需要的形状，再拼到一起，自由度完全不一样。正是因为这种逐维度的可塑性，KAN在处理多变量特征时，常常能用更少的参数实现更强的非线性映射。

当然，KAN不是没有代价。它的B样条计算比矩阵乘法复杂，社区目前也没有像cuDNN之于卷积那样成熟的底层优化。所以在训练速度上，KAN层会比同等参数量全连接层慢一些。但它的收敛速度通常更快，综合来看训练总时长往往不增反降。

2. 整体架构设计与环境准备

把三件事串成一条流水线，说起来容易，做起来需要先把各模块的输入输出尺寸对齐。这里我详细讲一下架构设计和工程准备。

2.1 三段式流水线怎么搭

这个模型的整体思路可以概括成"感知-记忆-决策"三段流水线。

第一段是CNN。我使用一维卷积在时间维度上做滑窗特征提取。卷积核每次扫过一个局部窗口，对这个窗口内各通道的数据做加权求和与非线性变换，得到的是局部响应特征。这个阶段的目标是把原始信号中短期的形态特征抓出来，比如尖峰、毛刺、短周期波动。连续两层卷积叠加，感受野进一步扩大，可以覆盖更大范围的局部上下文。中间穿插池化层，目的是降低序列长度、突出显著特征，同时减轻LSTM的计算负担。

第二段是LSTM。经过CNN处理后的特征序列，输入LSTM按时间顺序逐个处理。LSTM的内部有输入门、遗忘门和输出门三个门控，它们协同决定历史信息哪些该记住、哪些该遗忘、哪些该输出。这个机制让它天然适合捕捉时间上的长距离依赖。在时刻t，LSTM的输出综合了过去所有时刻的信息，相当于网络对整个序列形成了一个有记忆的压缩表示。

第三段是KAN。LSTM输出序列的最后一个时间步向量，输入KAN层完成从高维特征到目标值的最终映射。因为KAN的激活函数可学习，这一段能更好地拟合特征与输出之间的复杂非线性关系。

2.2 环境依赖与工程结构

先讲依赖。整个项目的运行环境我推荐Python 3.10及以上，PyTorch 2.1以上。PyTorch 2.0之后引入了编译模式和更高效的算子融合，对训练速度和显存占用都有明显改善。其他依赖包括NumPy、pandas、scikit-learn、matplotlib，这些是常规配置，直接pip安装即可。

# requirements.txt torch>=2.1.0 numpy>=1.24.0 pandas>=2.0.0 scikit-learn>=1.3.0 matplotlib>=3.7.0

工程结构上，我习惯把代码分成几个模块：数据生成或者数据加载单独放一个文件，模型定义单独放一个文件，训练和评估再单独放一个文件。这样做的好处是可以快速替换数据源，也可以在不影响训练代码的情况下做模型结构改动。今天的演示代码会把它们放在一起方便阅读，但实际项目里建议拆开。

2.3 模拟数据集构造与预处理

为了让大家能直接跑通，我构造了一份模拟的多变量时间序列回归数据。每条样本是64个时间步、3个特征的输入序列，目标是预测一个连续值。数据生成的时候引入了不同频率的正弦波、趋势项和随机噪声，整体结构比较接近真实世界中的传感器信号。

import numpy as np from sklearn.preprocessing import StandardScaler from sklearn.model_selection import train_test_split def generate_multivariate_ts(n_samples=8000, seq_len=64, n_features=3, seed=42): rng = np.random.default_rng(seed) t = np.linspace(0, 6 * np.pi, seq_len) X = np.zeros((n_samples, seq_len, n_features)) y = np.zeros((n_samples, 1)) for i in range(n_samples): f1 = rng.uniform(0.5, 2.0) f2 = rng.uniform(0.2, 1.0) phase = rng.uniform(0, 2 * np.pi) noise = rng.normal(0, 0.05, seq_len) trend = np.linspace(rng.uniform(-0.2, 0.2), rng.uniform(-0.5, 0.5), seq_len) base = np.sin(f1 * t + phase) + 0.5 * np.cos(f2 * t) X[i, :, 0] = base + trend + noise X[i, :, 1] = np.roll(base, 2) + rng.normal(0, 0.03, seq_len) X[i, :, 2] = np.roll(base, -1) + np.sin(0.5 * t + phase) * 0.3 + noise * 0.5 y[i, 0] = np.mean(base[-10:]) + 0.2 * np.max(base[-10:]) return X, y # 生成数据 X, y = generate_multivariate_ts() # 按时间顺序划分训练/验证/测试 n_train = int(len(X) * 0.7) n_val = int(len(X) * 0.15) X_train, y_train = X[:n_train], y[:n_train] X_val, y_val = X[n_train:n_train+n_val], y[n_train:n_train+n_val] X_test, y_test = X[n_train+n_val:], y[n_train+n_val:] # 按特征维度归一化 scaler_X = StandardScaler() scaler_y = StandardScaler() raw_shape = X_train.shape X_train = scaler_X.fit_transform(X_train.reshape(-1, n_features)).reshape(raw_shape) raw_shape_val = X_val.shape X_val = scaler_X.transform(X_val.reshape(-1, n_features)).reshape(raw_shape_val) raw_shape_test = X_test.shape X_test = scaler_X.transform(X_test.reshape(-1, n_features)).reshape(raw_shape_test) y_train = scaler_y.fit_transform(y_train) y_val = scaler_y.transform(y_val) y_test = scaler_y.transform(y_test)

在预处理环节，有两个容易被忽略的细节。第一，归一化必须在划分训练集、验证集之后再做，而且只用在训练集上拟合scaler，再应用到验证集和测试集，否则会造成信息泄漏。第二，归一化要按特征维度做，而不是把整条序列拉平后统一归一化。原因是不同特征的量纲可能完全不同，如果不按特征分别处理，模型会把量纲差异当成有意义的信号去学习。

3. 核心代码实现逐步拆解

下面进入正题，我把核心代码按模块拆开讲解，每一个模块解决什么问题、为什么这么写，都会交代清楚。

3.1 KAN层的B样条实现原理与代码

KAN层的核心是B样条基函数。B样条的思路是在输入区间内放置若干节点，用一组分段的低阶多项式拼接出光滑曲线。0阶B样条是最简单的分段常值函数，在某个小区间内为1，其余为0。更高阶的B样条由相邻低阶基函数加权组合而成，递归地计算下去。

实际实现KAN层时，需要在原始区间[-1, 1]两端各扩展若干个节点，这样做是为了让样条曲线在边界处依然平滑，不至于出现梯度断崖。扩展节点数取spline_order个，比如3阶样条就在两端各多放3个节点。

下面是KANLayer的完整定义：

import torch import torch.nn as nn class KANLayer(nn.Module): """ 简化版KAN层：B样条基函数 + 基础线性残差 """ def __init__(self, in_features, out_features, grid_size=5, spline_order=3): super().__init__() self.in_features = in_features self.out_features = out_features self.grid_size = grid_size self.spline_order = spline_order # 基础线性残差部分 self.base_activation = nn.SiLU() self.base_weight = nn.Parameter(torch.randn(out_features, in_features) * 0.1) self.base_bias = nn.Parameter(torch.zeros(out_features)) # 样条系数，每个输入维度独立一组基函数权重 # 基函数数量 = grid_size + spline_order self.n_basis = grid_size + spline_order self.spline_weight = nn.Parameter( torch.randn(out_features, in_features, self.n_basis) * 0.1 ) # 构建扩展网格 h = 2.0 / grid_size grid = torch.linspace(-1, 1, grid_size + 1) left = torch.linspace(-1 - spline_order * h, -1 - h, spline_order) right = torch.linspace(1 + h, 1 + spline_order * h, spline_order) full_grid = torch.cat([left, grid, right]) self.register_buffer('grid', full_grid) def forward(self, x): # x: [batch_size, in_features] base_out = self.base_activation(x) base_out = base_out @ self.base_weight.t() + self.base_bias basis = self.b_spline_basis(x) spline_out = torch.einsum('bin,oin->bo', basis, self.spline_weight) return base_out + spline_out def b_spline_basis(self, x): # 边界保护：把输入裁剪到扩展网格范围内 # 减去极小量是为了避免x等于最右侧节点时所有基函数都为零的情况 x = x.clamp(self.grid[0], self.grid[-1] - 1e-6) batch_size, in_features = x.shape # 0阶基函数：判断x落在哪个网格区间 N = (x.unsqueeze(-1) >= self.grid[:-1]).float() * (x.unsqueeze(-1) < self.grid[1:]).float() # N 的形状: [batch, in_features, num_nodes - 1] for k in range(1, self.spline_order + 1): N_prev = N N_new = torch.zeros(batch_size, in_features, N_prev.shape[-1] - 1) for i in range(N_new.shape[-1]): # 第一个系数 denom1 = self.grid[i + k] - self.grid[i] coef1 = (x - self.grid[i]) / denom1 # 第二个系数 denom2 = self.grid[i + k + 1] - self.grid[i + 1] coef2 = (self.grid[i + k + 1] - x) / denom2 N_new[:, :, i] = coef1 * N_prev[:, :, i] + coef2 * N_prev[:, :, i + 1] N = N_new return N

这段代码看似不长，但有几个容易出错的点需要特别说明。第一，样条权重spline_weight的初始化不能太大，否则训练初期输出值容易爆。我试过直接用0.5作为标准差，结果loss在一开始就是NaN。第二，einsum操作里，b对应batch维度，i对应输入特征维度，n对应基函数索引，o对应输出维度，维度对上之后计算就顺了。第三，网格必须注册为buffer，而不是Parameter，因为它不需要梯度更新，注册成buffer后会被自动移动到GPU，参与模型的state_dict保存。

还有一点需要声明：这个KANLayer是一个教学向的简化实现，去掉了标准KAN实现中的一些细节，比如自适应网格更新。如果要在生产环境中做大规模实验，建议直接使用社区里相对成熟的KAN库，把不同优化版本的实现都试一下。自己实现的好处是能彻底理解原理，排查问题也更顺手。

3.2 组装CNN-LSTM-KAN混合模型

有了KANLayer，组装整个模型就简单了。我把CNN、LSTM、KAN三个模块按顺序封装进一个类里：

class CNNLSTMKAN(nn.Module): """ CNN-LSTM-KAN混合网络 输入: [batch, seq_len, input_channels] 输出: [batch, num_classes] """ def __init__(self, input_channels, seq_len, cnn_channels=32, lstm_hidden=32, lstm_layers=2, kan_grid=5, kan_order=3, num_classes=1): super().__init__() # CNN特征提取模块 self.cnn = nn.Sequential( nn.Conv1d(input_channels, cnn_channels, kernel_size=3, padding=1), nn.BatchNorm1d(cnn_channels), nn.ReLU(), nn.MaxPool1d(2), nn.Conv1d(cnn_channels, cnn_channels * 2, kernel_size=3, padding=1), nn.BatchNorm1d(cnn_channels * 2), nn.ReLU(), nn.MaxPool1d(2), ) # 计算CNN输出后的序列长度 self.seq_len_after_cnn = seq_len // 4 self.cnn_feature_dim = cnn_channels * 2 # LSTM模块 self.lstm = nn.LSTM( input_size=self.cnn_feature_dim, hidden_size=lstm_hidden, num_layers=lstm_layers, batch_first=True, dropout=0.2 if lstm_layers > 1 else 0.0, ) # KAN输出层 self.kan = KANLayer( in_features=lstm_hidden, out_features=num_classes, grid_size=kan_grid, spline_order=kan_order, ) def forward(self, x): # x: [batch, seq_len, input_channels] x = x.permute(0, 2, 1) # [batch, input_channels, seq_len] cnn_out = self.cnn(x) # [batch, cnn_channels*2, seq_len//4] cnn_out = cnn_out.permute(0, 2, 1) # [batch, seq_len//4, cnn_channels*2] lstm_out, _ = self.lstm(cnn_out) # [batch, seq_len//4, lstm_hidden] last_hidden = lstm_out[:, -1, :] # [batch, lstm_hidden] output = self.kan(last_hidden) # [batch, num_classes] return output

模型结构里，CNN部分用了两层Conv1d加BatchNorm。BatchNorm在这里不是多余的，它能让CNN输出的特征分布更稳定，避免训练初期梯度震荡。池化用MaxPool1d(2)，序列长度每经过一次就减半，64个时间步经过两层池化后变成16个时间步，LSTM的计算量直接降到原来的四分之一。

LSTM部分，hidden_size我建议和cnn_channels保持在一个量级，不宜过大。原因很简单，LSTM的参数量是4 * hidden_size * input_size的规模，hidden翻倍，参数量翻倍还不止，训练难度会明显上升。KAN层的输入维度就是lstm_hidden，所以lstm_hidden决定了KAN对特征空间的处理规模，需要平衡。

最后加一个小细节：如果你的数据是单通道的序列，可以把input_channels设为1，模型照样跑得通。我给的示例代码用的是多变量三通道数据，更贴近真实场景。

3.3 训练循环与评估逻辑

模型的训练部分我按工程化的方式写。优化器用AdamW，学习率用1e-3起步，配合余弦退火和早停机制，这套组合在大多数时序预测任务上都能快速进入稳定收敛状态。

import torch.optim as optim from torch.utils.data import DataLoader, TensorDataset def make_loader(X, y, batch_size=64, shuffle=True): X_t = torch.FloatTensor(X) y_t = torch.FloatTensor(y) dataset = TensorDataset(X_t, y_t) return DataLoader(dataset, batch_size=batch_size, shuffle=shuffle) def train_model(model, train_loader, val_loader, epochs=120, lr=1e-3): optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4) scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs) criterion = nn.MSELoss() best_val_loss = float('inf') patience_counter = 0 patience_limit = 15 for epoch in range(epochs): model.train() total_loss = 0.0 total_count = 0 for x_batch, y_batch in train_loader: optimizer.zero_grad() pred = model(x_batch) loss = criterion(pred, y_batch) loss.backward() nn.utils.clip_grad_norm_(model.parameters(), 1.0) optimizer.step() total_loss += loss.item() * x_batch.size(0) total_count += x_batch.size(0) train_loss = total_loss / total_count # 验证阶段 model.eval() val_loss = 0.0 val_count = 0 with torch.no_grad(): for x_batch, y_batch in val_loader: pred = model(x_batch) loss = criterion(pred, y_batch) val_loss += loss.item() * x_batch.size(0) val_count += x_batch.size(0) val_loss = val_loss / val_count scheduler.step() if (epoch + 1) % 10 == 0: print(f"Epoch {epoch + 1:3d} | Train Loss: {train_loss:.4f} | Val Loss: {val_loss:.4f}") # 早停逻辑 if val_loss < best_val_loss: best_val_loss = val_loss patience_counter = 0 torch.save(model.state_dict(), "best_model.pth") else: patience_counter += 1 if patience_counter >= patience_limit: print(f"Early stopping at epoch {epoch + 1}") break return best_val_loss

训练代码里有几个设计值得解释。梯度裁剪这行，nn.utils.clip_grad_norm_(model.parameters(), 1.0)，在混合模型里特别重要，因为KAN层的B样条在初始化阶段可能产生局部较大的梯度，如果不裁剪，训练第一步就可能导致梯度爆炸。早停我设置在15个epoch没有改善就停止，目的不是为了省那几分钟训练时间，而是防止在验证集上过拟合。

训练完成后，评估指标除了均方误差（MSE），我还建议加一个对称平均绝对百分比误差。MSE对大误差敏感，在实际预测任务里容易被少数极端样本主导，加上对称平均绝对百分比误差可以更全面地反映预测质量。计算方式不复杂，就是每个样本的绝对误差除以预测值和真实值的平均值，再取平均。

4. 训练调参与对比实验

到了这个环节，模型已经能跑起来了，接下来就是把效果调到最好。这一章我给出自己的经验参数和对比实验参考。

4.1 关键超参数的经验取值

先说结论，再说原因。我把这套模型涉及的核心超参数整理成一张表：

为什么kan_grid_size不建议太大？因为B样条的基函数数量等于grid_size加spline_order，每个基函数都有自己的一套权重，网格越密，KAN层的参数量线性增长。在中小数据集上，网格过细会让模型记住训练数据中的噪声，验证集上的表现反而变差。我的习惯是从小网格开始，比如5，如果验证loss持续下降不反弹，再逐步增加网格密度。

learning_rate这个参数，我想特别提醒：用AdamW时，1e-3往往偏快，尤其是KAN层刚初始化时梯度尺度不统一，如果一上来就用大学习率，很容易在训练早期就震荡。我习惯先用1e-3跑前10个epoch观察loss曲线，如果出现剧烈波动就降一半，再跑10个epoch对比。稳妥的做法是直接设定余弦退火从1e-3衰减到1e-5，配合早停使用。

4.2 与CNN-LSTM基线对比参考

为了验证KAN层的作用，我做过一个简单的消融实验，基线是同一个模型但把KAN层替换成两层全连接层。数据用上面生成的模拟数据，其他条件保持一致。这里给出参考结果，不同随机种子下数值会有波动，但趋势是稳定的。

从表格可以看出，KAN版本参数量更少，收敛更快，验证集误差也更低。单epoch耗时略高是因为B样条计算比矩阵乘法慢，但综合收敛epoch更少，总训练时间反而更短。这个对比给我提供了一个比较扎实的判断：在输出非线性较强的任务上，KAN对MLP的替代是划算的。

如果你拿到自己的数据集，建议也做一次同样的消融实验。方法很简单，把模型定义里的self.kan替换成nn.Sequential(nn.Linear(lstm_hidden, 32), nn.ReLU(), nn.Linear(32, num_classes))，其余代码不动，分别训练后对比。这样能直观看到KAN在你的数据上是否有效，避免盲目追新。

4.3 训练曲线与模型诊断

训练过程中一定要把loss曲线画出来看，而不是只看最终的验证loss。

import matplotlib.pyplot as plt # 假设训练过程中记录了train_loss_list和val_loss_list plt.figure(figsize=(10, 4)) plt.plot(train_loss_list, label="Train Loss", linewidth=1.5) plt.plot(val_loss_list, label="Validation Loss", linewidth=1.5) plt.xlabel("Epoch") plt.ylabel("MSE") plt.legend() plt.grid(alpha=0.3) plt.tight_layout() plt.savefig("training_curve.png", dpi=150)

看曲线时重点关注两点。第一，训练loss和验证loss的间距是否越来越大，如果间距持续拉开，大概率是过拟合，这时应该增强正则或者减小网格密度。第二，验证loss是否在某一轮后不再下降甚至反弹，如果反弹明显，说明学习率退火没有跟上，或者模型容量已经到瓶颈了。

我还习惯把预测值和真实值画成散点图，直观检查预测分布。如果散点沿着对角线分布得比较紧密，说明模型预测整体可靠。如果看到系统性偏移，比如在目标值较大时预测偏低，那通常是数据分布不均或者损失函数选择不当导致的，可以尝试对目标值做对数变换。

5. 实战踩坑与排查经验

最后是干货含量最高的部分，聊聊我实际跑这个模型时踩过的坑，以及对应的排查思路。

5.1 训练不收敛的排查顺序

第一次跑这个模型，最可能遇到的就是训练loss不降或者直接变成NaN。碰到这种情况，我的排查顺序是固定的，从数据到模型再到训练设置，一步步排除。

第一步看输入数据。确认输入张量的形状是否和模型期望的一致，尤其是通道维和时间步维的顺序。PyTorch要求Conv1d的输入是[batch, channels, seq_len]，而我们的模型输入是[batch, seq_len, features]，中间有一次permute转换，写漏了的话模型结构再合理也跑不出结果。我经常看到初学者在这里翻车，模型报错说维度不匹配，实际上是忘了这个转置。

第二步看KAN层输出尺度。KAN层初始化后，如果输出值的绝对值很大，说明样条权重初始化的方差偏大。把初始化标准差从0.1降到0.01再试，通常能解决问题。另外SiLU基础激活函数在负半轴的输出不是完全为零，如果配合较大的负输入，基础残差部分可能持续放大，值得关注。

第三步看梯度裁剪和学习率。一个经验法则是：先用非常小的学习率（比如3e-5）跑20个epoch，如果loss能下降，说明代码链路没问题，问题出在优化器配置上。如果小学习率下loss还是原地不动，那就要怀疑梯度是否在KAN层就断掉了。可以在KAN层前向后面加一行打印观察梯度范数分布，但记得调试完删掉。

5.2 显存占用与推理速度优化

KAN层的B样条计算会占用额外的显存，这是混合模型绕不开的短板。不过有几个实际可用的优化技巧。

第一个技巧是先冻结CNN和LSTM，单独训练KAN层若干epoch，让样条先适应特征空间，再解锁全部层一起训练。这和迁移学习的思路类似，既省显存，也能让训练更稳定。第二个技巧是推理时把B样条基函数的结果缓存起来。因为在训练收敛后，网格和权重都是固定的，输入特征在KAN层之前的部分可以离线计算并缓存，推理时只做一次矩阵乘加，速度会明显提升。

还有一个更直接的手段：如果序列长度很长，可以把LSTM的bidirectional关掉，省下另一半显存。在时间序列预测场景，双向LSTM并不总是比单向好，因为预测时刻之后的信息在现实中未必可得。

5.3 数据泄漏与过拟合陷阱

最后想专门提醒一个问题，数据泄漏，这在时间序列建模里特别隐蔽。很多人在划分训练集和验证集时用随机划分，这在普通回归任务没问题，但在时序数据里会把未来的信息带进训练集。比如一条连续采集的传感器序列，随机划分训练集和验证集后，验证集里的某些样本可能是训练集样本之后紧邻的几条，时间上存在信息重叠，评估结果会被虚高。

正确处理方式是按照时间顺序切分，用前70%作为训练集，中间15%作为验证集，最后15%作为测试集。如果数据是多条独立序列的集合，则需要对序列ID分组切分，保证同一条序列的数据不会同时出现在训练集和验证集里。我在前面的代码示例里就是按时间顺序切的，这一点建议严格照做。

另外，KAN层参数多、自由度大，在中小规模数据集上过拟合的风险真实存在。除了控制网格密度之外，我还会在KAN层之后加一个很小的Dropout，比如0.1，实验证明能有效降低过拟合且几乎不影响收敛速度。如果你发现训练loss持续走低、验证loss却在上升，优先检查这两个地方。

到这里，CNN-LSTM-KAN这套模型的代码、原理、调参和排查思路就完整讲完了。我和KAN的第一次接触，是在对比实验中发现替换掉最后一层MLP后，验证loss居然明显下降，从那以后这个结构就成了我处理非线性时序问题的常用骨干。如果你也在尝试把新结构融进自己的模型，建议不要照搬超参数，一定要拿自己的数据先跑一遍消融实验，确认收益再决定去留。最后留一个扩展思路：KAN层也可以替换为径向基函数网络或者小波网络做对比，它们和KAN有相似的动机，但在某些数据上表现很不一样，折腾一圈对理解非线性映射的机制会有很大帮助。