用ED度量神经网络简单性：多项式表示与复杂度分析

这次我们来看一个偏研究向的主题：ICML 2026 背景下，如何用 ED 度量神经网络的“简单性”，并用“多项式表示”把这件事量化下来。不是又一个开源部署工具，也不是模型压缩教程，而是一条从“结构复杂度”出发的理论分析路径。如果你关注神经网络可解释性、泛化能力分析、模型结构选择，或者想搞清楚“量化”除了 INT8、GGUF 之外还有哪些玩法，这篇内容可以直接收藏。

标题里的“量化”很容易让人想到工业界的模型量化：把 FP16 权重变成 INT8，减小显存占用、加速推理。但 ED 这个方向更接近“广义量化”——它的目标不是压缩权重，而是量化一个网络到底有多复杂、有多“简单”。也就是说，它把“简单性”本身变成一个可计算的指标，再用多项式表示作为分析工具。这种思路对做论文、做结构搜索、做可解释性分析，都可能有用。

本文会完成四件事：第一，拆解 ED 和多项式表示的思路；第二，给出一个可在本地运行的简单性度量验证流程；第三，封装成批量脚本和 API 服务；第四，汇总常见坑和排查方法。所有代码都是通用示例，具体项目参数需要按实际环境调整。

1. 核心概念速览

先把主题核心参数放出来，方便快速判断这个方向适不适合你。

从材料看，ED 的完整展开形式并没有给出，因此本文的讨论以“有效维度 / 简单性度量”这一通用理解展开，具体公式和实验结论以论文原文为准。

2. ED 简单性度量到底在量化什么

神经网络“简单性”这个概念，看起来直观，实际很难定义。一个层数很多、参数很大的网络，可能因为结构规则、冗余度低，反而表现得“简单”；一个层数很少但参数混乱的网络，也可能在行为上显得极其复杂。所以简单性不直接等于参数量，也不直接等于深度。

常见的复杂度候选指标包括：

• 权重范数，例如 L1、L2 范数；
• 有效参数数量，例如通过 Hessian 矩阵的秩估计；
• 互信息，衡量输入与特征之间的依赖强度；
• 网络结构深度和宽度；
• 多项式展开系数的稀疏程度。

ED 的切入点是“多项式表示”。神经网络中的非线性激活函数，比如 tanh、sigmoid、GELU，都可以在有限区间内用多项式近似。即使是 ReLU 这种分段线性函数，在固定输入范围内也能用多项式拟合。因此，一个网络的计算过程在数学上可以展开成一组多项式函数的组合。

如果这个网络的结构足够“简单”，那么它的多项式展开应该具备一个典型特征：低阶项系数较大，高阶项系数稀疏且数值较小。换句话说，网络的非线性行为可以用很少的高阶修正来表达。反过来，如果一个网络的行为需要大量高阶项才能拟合，那么它的计算结构就更复杂。

这种思路的意义在于：它把“简单性”从定性的经验描述，变成可计算、可比较的数值指标。有了这个指标，就能在多个候选网络之间做横向对比，甚至在训练过程中观察简单性的变化趋势。

2.1 从多项式到网络计算图

一个典型的多层感知机（MLP）可以写成如下形式：

[ h_1 = \sigma(W_1 x + b_1) ] [ h_2 = \sigma(W_2 h_1 + b_2) ] [ y = W_3 h_2 + b_3 ]

如果把激活函数 (\sigma) 在某个区间内展开成多项式：

[ \sigma(z) \approx \sum_{k=0}^{K} c_k z^k ]

那么每一层实际上就是在做“多项式嵌套”。线性层的权重和偏置会与多项式的系数相乘、相加。这里的 (b) 也就是常说的 bias，在多项式表示里对应零阶项，负责平移基线。

从这个视角看，一个神经网络的整体结构，可以理解成一个由线性映射、偏置平移、多项式非线性算子组合而成的大规模多项式系统。这种表示不会改变网络原本的计算结果，但它会把“网络结构复杂度”映射到“多项式展开的秩序”上。

2.2 与卷积、循环结构的关系

这个思路不仅能用在 MLP 上，对卷积神经网络、循环神经网络、甚至 Transformer 也有讨论空间。

卷积神经网络在多项式视角下相对友好。卷积核本质上是局部线性算子，在输入空间上做加权求和；激活函数引入非线性。卷积网络的叠层，相当于在局部感受野上反复应用多项式非线性映射。如果卷积核数量较少、激活函数的多项式阶数较低，那么整个网络的计算复杂度相对可控。

循环神经网络的重复结构则容易把多项式阶数放大。每一个时间步都应用一次非线性激活，多个时间步叠加后，等效多项式的阶数会快速升高。这也是循环网络训练不稳定、容易梯度爆炸的一个数学侧面。

Transformer 的注意力机制本身是内积加 softmax，softmax 也可以做多项式近似，但阶数往往不低。所以从多项式表示的角度，Transformer 的“简单性”通常不如小规模 MLP 直观，这也是大模型看似复杂的原因之一。

3. 多项式表示如何落地分析神经网络

有了概念，接下来要看怎么算。这一节提供一套通用分析流程，不依赖某个具体论文实现，只依赖 PyTorch 和 NumPy。核心流程是：采样输入 -> 记录激活值 -> 多项式拟合 -> 计算高阶系数占比。

3.1 激活函数的多项式拟合

先用一个最简单的问题练手：对单个激活函数做多项式拟合，观察 tanh 在 [-2, 2] 区间内的展开系数分布。

import numpy as np # 生成输入和输出样本 x = np.linspace(-2.0, 2.0, 512) y = np.tanh(x) # 5 阶多项式拟合 coeffs = np.polyfit(x, y, deg=5) # 打印从高次到低次的系数 print("coeffs high->low:", coeffs) # 计算高阶项的能量占比 abs_c = np.abs(coeffs) high_order_energy = abs_c[:3].sum() / (abs_c.sum() + 1e-8) print("high_order_energy:", high_order_energy) # 用拟合结果还原，对比残差 y_pred = np.polyval(coeffs, x) rmse = np.sqrt(np.mean((y - y_pred) ** 2)) print("rmse:", rmse)

这段代码会输出三组信息：多项式系数、高阶项占比、拟合误差。对于 tanh，低阶项通常会占主导，也就是说它在有限区间内确实可以用低阶多项式近似得很好。

3.2 对网络逐层做系数分析

单个激活函数只是一个起点。真正有价值的是对网络每一层的激活值做同样的分析。这时需要遍历模型的所有层，通过 PyTorch 的 hook 机制记录输入和输出。

import torch import torch.nn as nn import numpy as np class SimpleMLP(nn.Module): def __init__(self): super().__init__() self.fc1 = nn.Linear(16, 32) self.fc2 = nn.Linear(32, 32) self.fc3 = nn.Linear(32, 4) def forward(self, x): x = torch.tanh(self.fc1(x)) x = torch.tanh(self.fc2(x)) x = self.fc3(x) return x model = SimpleMLP() model.eval() # 注册 hook，记录每一层的输入输出 layer_io = {} def make_hook(name): def hook_fn(module, input, output): layer_io[name] = { "input": input[0].detach().cpu().numpy(), "output": output.detach().cpu().numpy() } return hook_fn model.fc1.register_forward_hook(make_hook("fc1")) model.fc2.register_forward_hook(make_hook("fc2")) # 构造一条随机输入 sample = torch.randn(1, 16) with torch.no_grad(): model(sample) # 对每一层的输入输出做多项式拟合 for name, io in layer_io.items(): x_flat = io["input"].reshape(-1) y_flat = io["output"].reshape(-1) # 取一部分点，防止样本过多 idx = np.random.choice(len(x_flat), min(256, len(x_flat)), replace=False) coeffs = np.polyfit(x_flat[idx], y_flat[idx], deg=3) abs_c = np.abs(coeffs) high_score = abs_c[:2].sum() / (abs_c.sum() + 1e-8) print(f"{name} high_order_score: {high_score:.4f}")

这个脚本的原理很清楚：每一层都会对输入做线性变换和非线性激活，通过比较该层输入与输出之间的多项式关系，可以粗略判断这一层引入了多少“额外非线性复杂度”。如果高阶项占比较高，说明这一层的非线性行为较强；反之，说明该层行为更接近线性映射。

3.3 把指标规约为一个分数

逐层比较还不够，最好能把整个网络的多项式复杂度变成一个数值。这里给出一种简化方式：把每一层的高阶项占比做加权平均，再结合网络深度做归一化。

def network_simplicity_score(model, sample_input, degrees=(3, 5)): layer_scores = [] for name, module in model.named_modules(): if isinstance(module, nn.Linear): # 这种方式更简单：直接对模块权重做多项式曲率统计 w = module.weight.detach().cpu().numpy() # 对每个输出神经元的多项式响应做拟合 # 这里为了演示，直接计算权重的稀疏度 l1 = np.abs(w).sum() l2 = np.sqrt((w ** 2).sum()) sparsity = (l1 / (l2 + 1e-8)) / np.sqrt(w.size) layer_scores.append(sparsity) if not layer_scores: return 0.0 return float(np.mean(layer_scores)) score = network_simplicity_score(model, torch.randn(1, 16)) print("network simplicity score:", score)

需要说明的是，这个简化版脚本只是为了展示思路，不是论文中的 ED 公式。真正的 ED 指标会有更严谨的数学定义，需要考虑多项式展开系数分布、泛化误差界、函数空间维度等因素。但核心验证逻辑是一致的：一个简单网络，各个度量维度上都会表现出更强的“低复杂度”特性。

4. 与工业界模型量化的关系与区别

聊到这里，必须把 ED 和传统“模型量化”区分清楚。工业界常说的量化，指 INT8、INT4、GGUF 等低比特压缩手段。大家关心的都是：vLLM 怎么量化模型、Qwen3 的量化版效果如何、.onnx 怎么做 INT8。这些问题的核心是权重精度和推理性能。

而 ED 的“量化”是另一个层面：它量化的是函数复杂度。打个比方，模型量化是把一张大图压成小图，目标是降低存储和传输成本；ED 简单性量化是分析这张图的构图是否简洁，目标是理解它的内部分布。

从研究角度看，ED 的量化结果可以影响模型量化的方式。比如，某个网络层的多项式展开系数高度集中，说明它对精度的敏感度较低，可以承担更激进的低比特量化；而某些层高阶项占比很高，说明非线性行为复杂，量化时需要保留更多精度。这个思路如果能验证，对工业界模型压缩也有参考价值。

不过要提醒一句：这是研究思路的合理延伸，不是本文材料中已经验证的结论。实际使用时要先在自己模型上做实验。

5. 本地验证实验设计

如果你想把 ED 和多项式表示用起来，建议先构建一个最小实验环境。不需要大型 GPU，CPU 就能完成第一个循环。

5.1 实验环境

• Python 3.9 或更高版本；
• PyTorch 2.x 或最新稳定版；
• NumPy、pandas、matplotlib；
• 可选：scikit-learn 用于回归对比。

安装依赖：

pip install torch numpy pandas matplotlib scikit-learn

如果显卡支持 CUDA，可以顺便装 GPU 版 PyTorch；如果只有 CPU，也不影响跑通验证流程。

5.2 实验目标

建议按顺序验证这些问题：

1. 不同激活函数的拟合系数分布差异；
2. 不同层数 MLP 的高阶项占比变化；
3. dropout 或权重裁剪对简单性分数的影响；
4. 训练过程中简单性分数如何变化；
5. 简单性分数与测试集准确率是否相关。

第一个实验中，只需要一个 Jupyter Notebook 或 Python 脚本，用 NumPy 完成。第二个实验开始引入 PyTorch 模型训练，建议在 CPU 上使用小型数据集，例如 MNIST 的随机子集。

5.3 示例：训练前后简单性对比

训练一个两层的 MLP，在训练前和训练后分别记录多项式系数和高阶项占比。

import torch import torch.nn as nn import torch.optim as optim from sklearn.datasets import fetch_openml from sklearn.model_selection import train_test_split import numpy as np # 加载一个小型数据集，这里用 sklearn 的 digits 演示 from sklearn.datasets import load_digits data = load_digits() X = data.data / 16.0 y = data.target X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42) X_t = torch.tensor(X_train, dtype=torch.float32) y_t = torch.tensor(y_train, dtype=torch.long) X_test_t = torch.tensor(X_test, dtype=torch.float32) y_test_t = torch.tensor(y_test, dtype=torch.long) model = nn.Sequential( nn.Linear(64, 64), nn.Tanh(), nn.Linear(64, 10) ) criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=1e-3) def compute_simplicity(model): scores = [] with torch.no_grad(): for layer in model: if isinstance(layer, nn.Linear): w = layer.weight.numpy() l1 = np.abs(w).sum() l2 = np.sqrt((w ** 2).sum()) sparsity = (l1 / (l2 + 1e-8)) / np.sqrt(w.size) scores.append(sparsity) return float(np.mean(scores)) print("before training simplicity:", compute_simplicity(model)) for epoch in range(30): optimizer.zero_grad() out = model(X_t) loss = criterion(out, y_t) loss.backward() optimizer.step() print("after training simplicity:", compute_simplicity(model)) with torch.no_grad(): test_out = model(X_test_t) pred = test_out.argmax(dim=1) acc = (pred == y_test_t).float().mean().item() print("test acc:", acc)

这个脚本会输出训练前后的简单性分数和测试准确率。如果训练后高阶项占比下降，说明模型在学习过程中向“低复杂度”方向演化；如果高阶项占比反而上升，说明模型在拟合更细碎的边界。

6. 批量任务与结果导出

单模型分析只是起步，真正有落地价值的是批量分析多个模型。你可以把不同随机种子、不同结构、不同激活函数训练出来的模型放在一个目录里，统一计算简单性分数，并用 CSV 记录结果。

下面的脚本展示了批量处理流程：

import os import torch import pandas as pd import numpy as np from pathlib import Path results = [] model_dir = Path("./models") for model_path in sorted(model_dir.glob("*.pt")): try: model = torch.load(model_path, map_location="cpu") model.eval() sample = torch.randn(1, 64) score = network_simplicity_score(model, sample) results.append({ "model": model_path.stem, "simplicity_score": score, "status": "ok" }) except Exception as e: results.append({ "model": model_path.stem, "simplicity_score": None, "status": f"failed: {e}" }) df = pd.DataFrame(results) df.to_csv("simplicity_results.csv", index=False) print(df)

批量任务里建议加上失败重试和日志记录。遇到某个模型读取失败时，不要整个流程中断，而是记录失败原因，继续处理下一个模型。这样排查问题会更省力。

7. 将分析流程封装成 API

研究脚本可以封装成服务，方便团队其他人使用。这里用一个 FastAPI 示例，接收模型路径和输入参数，返回简单性分数。

from fastapi import FastAPI from pydantic import BaseModel import torch import numpy as np import uvicorn app = FastAPI() class AnalysisRequest(BaseModel): model_path: str input_dim: int = 64 sample_size: int = 10 class AnalysisResponse(BaseModel): model_path: str simplicity_score: float status: str def compute_score(model, input_dim, sample_size): model.eval() scores = [] with torch.no_grad(): for _ in range(sample_size): sample = torch.randn(1, input_dim) # 这里调用前面定义的 network_simplicity_score 函数 scores.append(network_simplicity_score(model, sample)) return float(np.mean(scores)) @app.post("/analyze", response_model=AnalysisResponse) def analyze(req: AnalysisRequest): try: model = torch.load(req.model_path, map_location="cpu") score = compute_score(model, req.input_dim, req.sample_size) return AnalysisResponse(model_path=req.model_path, simplicity_score=score, status="ok") except Exception as e: return AnalysisResponse(model_path=req.model_path, simplicity_score=-1.0, status=f"failed: {e}") if __name__ == "__main__": uvicorn.run(app, host="127.0.0.1", port=8000)

启动服务后，可以用 curl 测试：

curl -X POST "http://127.0.0.1:8000/analyze" \ -H "Content-Type: application/json" \ -d '{"model_path": "./models/mlp_seed1.pt", "input_dim": 64, "sample_size": 10}'

接口服务部署时要注意两个问题：一是不要暴露到公网，默认绑定127.0.0.1即可；二是批量请求要限制并发数，避免大量模型同时加载导致内存溢出。

8. 资源占用与性能观察

这个方向对硬件要求比较友好。多项式拟合和数据采样的主要开销在 CPU 和内存，GPU 不是必需品。具体表现取决于模型规模：

• 小模型（MLP、小型 CNN）：CPU 即可完成，单次分析耗时在秒级；
• 中等模型（ResNet 等）：如果只是做激活值采样，CPU 也能跑，但建议用 GPU 加速前向推理；
• 大模型（LLM）：不建议直接全量展开到多项式，内存占用会非常高，需要先做层采样或降维。

观察资源占用时，推荐用nvidia-smi看显存，用top或htop看内存。如果你的实验脚本只做前向推理，显存占用通常不会很高；但如果一次性加载多个模型做批量分析，内存增长会比较明显，需要控制并发数。

多项式拟合本身还有一个需要注意的性能点：多项式阶数越高，数值稳定性越差。阶数超过 10 时，拟合矩阵可能接近奇异，导致系数出现大幅震荡。建议优先使用 3 到 5 阶，把高阶项单独统计。

9. 常见问题与排查方法

如果高阶多项式拟合出现剧烈震荡，可以参考 Runge 现象：在等距点上做高阶多项式插值时，区间边缘容易出现大幅振荡。解决方法是使用 Chebyshev 节点采样，或者直接降低多项式阶数，以系数稀疏度代替完全拟合精度。

10. 最佳实践与使用建议

这个方向还处于方法论探索阶段，如果你打算把它写进论文或工程报告，下面这些建议会比较有用。

第一，实验记录要完整。模型结构、输入分布、采样点数、多项式阶数、拟合误差，这些参数必须固定并记录。否则一个“简单性分数”很难解释清楚，别人也无法复现。

第二，先做单层验证。直接对一个激活函数做多项式拟合，观察系数分布，再逐步扩展到网络层。不要一开始就在完整模型上做分析，否则出了问题很难定位是哪一层引入的。

第三，多项式阶数不要盲目调高。3 到 5 阶足够观察结构趋势。高阶项占比本来就是用来衡量“是否需要更多复杂度”，如果拟合本身都失败了，这个指标就失去意义。

第四，所有代码需要有输入输出约定。定义统一的模型输入维度、采样点数量、输出字段格式，方便批量分析和后续接入接口服务。

第五，边界意识要清晰。ED 简单性分析适合做模型理解、结构比较、训练过程监控，但不等于“更简单就一定更好”。一个过于简单的模型可能欠拟合，多项式系数稀疏是特征，不是结论。

第六，合规与授权。如果使用开源模型权重做实验，要遵守对应许可证；如果涉及人脸、声音、版权内容，必须确认授权。学术场景要正确引用原始文献，工程场景要保留实验日志。

11. 总结与下一步

ED 配合多项式表示，给神经网络复杂度分析提供了一个比较自然的切入点：把“简单性”从抽象概念变成可计算指标，并能在小模型上快速验证。最值得先验证的功能，是多项式系数提取脚本能否在你本地环境稳定跑通；最容易踩的坑，是高阶多项式数值不稳定和“简单性分数”被过度解读。

下一步可以尝试的方向包括：把 ED 指标接入自动化结构搜索，用它做层数或激活函数选择；把 ED 与工业界模型量化结合，找出哪些网络层可以承担更激进的低比特压缩；或者在训练过程中持续记录 ED 分数，观察简单性变化与泛化能力之间的关系。

先把最小实验跑通，再逐步扩大模型规模。这个方向不需要昂贵硬件，需要的是清晰的问题定义和稳定的实验流程。