为什么大扩散模型不会背诵训练数据：两个时间尺度的隐式正则化

2023 年 Carlini 等人做了一件让 Stable Diffusion 团队和版权律师同时紧张的事：他们用一种"提示词反演"的攻击方法，从 Stable Diffusion 中逐像素重建出了部分训练图像，包括有身份的人脸和受版权保护的画作 [Carlini et al. 2023, USENIX]。论文里一张攻击图与训练原图的对照让人发凉——大模型确实在"背诵"。

但这件事和大家的日常使用经验是矛盾的：日常用 Stable Diffusion 生成的图绝大多数都是合理的新样本——动物在新姿态下、风景在新光照下、人脸是不存在的脸，看不出是哪张训练图的副本。如果模型在"背诵"，这个矛盾如何解释？经典统计学习理论的预言更让人困惑——扩散模型动辄上亿参数，训练数据只有几十万到几千万张，按"过参数化 + 有限数据 = 过拟合"的传统逻辑，模型应该直接记住所有训练样本才对。

NeurIPS 2025 Best Paper Why Diffusion Models Don’t Memorize: The Role of Implicit Dynamical Regularization in Training（Bonnaire, Urfin, Biroli, Mézard）给了这个矛盾一个干净的答案：扩散模型训练存在两个高度分离的时间尺度——泛化窗口 $\tau_{\text{gen}}$ 和记忆窗口 $\tau_{\text{mem}}$ 。在 $[\tau_{\text{gen}}, \tau_{\text{mem}}]$ 这段安全窗口里，模型生成质量已经达到峰值，但还没开始 memorize 训练样本。关键结论是 $\tau_{\text{mem}}$ 与数据集规模 $n$ 成线性关系：数据集越大，安全窗口越长——这正是大型 diffusion 模型在实践中默认表现为泛化而非记忆的根本原因。

本文从这个矛盾切入，详解两个时间尺度的实验发现、 $\tau_{\text{mem}} \propto n$ 的推导路径、神经网络 spectral bias 在背后扮演的角色，以及对训练实践的启示。

矛盾的起点：Carlini 攻击与泛化经验

理解这篇论文的位置，先要看清它要解释的两个看似冲突的事实。

事实一：[Carlini et al. 2023] 的攻击证明 Stable Diffusion 确实存在 memorization。攻击流程：（1）从训练集 caption 中选一张图，（2）用相同 prompt 让模型生成 $k$ 次，（3）测量这 $k$ 个生成结果之间的两两距离——如果模型在 memorize，那么不同采样路径会塌缩到同一个训练图附近。Carlini 团队对 350 万张 LAION 训练子集做了这个测试，发现 109 张图被精确重建。

事实二：但同样这个模型，用户日常生成的几亿张图里，只有极少数能被识别为训练样本的副本。其它的看起来是合理的新组合——动物在新姿态下、风景在新光照下、人脸是不存在的脸。

这两个事实都是真的。问题在于：什么决定了一个特定训练步上的 Stable Diffusion 表现得像"事实一"还是"事实二"？

经典统计学习理论给的答案是模型容量 vs 样本数 $n$ 的比值。但实际观测和这个理论不符：[Somepalli et al. 2023a, CVPR] 系统测量了 Stable Diffusion 不同训练阶段的 memorization 比率，发现 memorization 强度随训练时长呈非平凡变化——早期几乎不 memorize，到了某个阶段开始爬升。这意味着真实的控制变量是训练动力学，而不是单纯的容量。

Bonnaire et al. 2025 沿着这条线深挖，给出了控制变量的精确形式。

两个时间尺度：泛化窗口与记忆窗口

论文的核心实证发现可以用一张图概括：训练动力学被两个明显分离的特征时间尺度切成三段（论文 Fig. 1 左）。

第一阶段： $\tau < \tau_{\text{gen}}$ ，模型快速学习生成。FID 从随机值快速下降到接近最优值，记忆度量 $f_{\text{mem}}$ 保持为 0。

第二阶段： $\tau_{\text{gen}} < \tau < \tau_{\text{mem}}$ ，泛化窗口。FID 已经稳定在最优附近，模型生成高质量样本但完全不 memorize。

第三阶段： $\tau > \tau_{\text{mem}}$ ， $f_{\text{mem}}$ 开始单调上升——模型逐步把训练样本背下来。

记忆度量 $f_{\text{mem}}$ 怎么定义？论文 Eq. (6) 给出一个最近邻比值：

\mathbb{E}_{x_\tau}\left[\frac{\|x_\tau - a^{\mu_1}\|_2}{\|x_\tau - a^{\mu_2}\|_2}\right] < k

其中 $a^{\mu_1}, a^{\mu_2}$ 是训练集中离生成样本 $x_\tau$ 最近的两个点， $k$ 是阈值（论文取 $k = 1/3$ ）。直观含义：如果生成样本远比次近邻更靠近最近邻，那就算 memorize 了一个训练样本。论文验证 $k$ 取 $1/2$ 或 $1/4$ 不影响标度律结论。

实证设置：CelebA 32×32 灰度数据集，训练集规模 $n$ 在 $128$ 到 $32768$ 之间扫描；U-Net 基础宽度 $W \in \{8, 16, 32, 48, 64\}$ 对应总参数量 $p \in \{0.26, 1, 4, 9, 16\} \times 10^6$ ；SGD 优化器， $\eta = 0.01$ ，动量 $0.95$ 。

这种现象不限于真实图像数据。论文 Appendix B 用 8 维高斯混合模型（两个均衡高斯 $\pm \mu$ ，单位协方差）+ 102K 参数的 MLP 重做实验，得到同样的两阶段结构，确认这是 score matching 训练动力学的本质特征，不是 U-Net 架构的副作用。

数据集规模决定一切： $\tau_{\text{mem}} \propto n$ 的核心标度律

两个时间尺度的存在本身就有意义，但更关键的是它们随数据集规模 $n$ 的依赖关系。

论文的关键操作是坍缩曲线：把不同 $n$ 下测到的 $f_{\text{mem}}(\tau)$ 曲线，横轴从 $\tau$ rescale 到 $\tau / n$ ，所有曲线完美塌缩到同一条曲线。论文 Fig. 2 给出了这一证据，并测出坍缩常数：

\tau_{\text{mem}} / n \approx 3 \times 10^5 \text{ steps per sample}

即 $\tau_{\text{mem}} \approx 300{,}000 \cdot n$ 。同时论文测出 $\tau_{\text{gen}}$ 与 $n$ 几乎无关（更准确地说，依赖很弱）。

把模型宽度 $W$ 也放进来：

W \cdot \tau_{\text{gen}} \approx 3 \times 10^6 \text{ steps} \cdot \text{width}, \qquad W \cdot \tau_{\text{mem}} \approx \text{const} \cdot n

两个时间尺度都按 $W^{-1}$ 缩放，所以两者的比值 $\tau_{\text{mem}} / \tau_{\text{gen}}$ 只由 $n$ 决定，与 $W$ 无关。这条结论对工程实践很重要：扩大模型不会让安全窗口变窄；只有扩大数据集才能延长安全窗口。

这个图像和经典统计学习理论的预言完全不同。经典理论给的图像是：过参数化网络一旦容量够，就会收敛到训练集的内插函数，memorization 是固定容量门槛的副产品。Bonnaire et al. 的图像是：训练时长比容量是更关键的调节器，时长本身被 $n$ 标定为线性可拉伸的尺子——数据集翻倍，安全训练步数翻倍。

调节器	经典统计学习理论	Bonnaire et al. 2025
memorization 控制变量	模型容量 $p$ vs $n$ 比值	训练时长 $\tau$ vs $\tau_{\text{mem}}(n)$
与 $n$ 的关系	渐近不依赖（一旦容量够大）	$\tau_{\text{mem}} \propto n$ 线性放大
与 $W$ 的关系	容量正比，强依赖	$\tau_{\text{mem}} \propto W^{-1}$ ，但与 $\tau_{\text{gen}}$ 比例不变
工程含义	模型够大就一定 memorize	数据够大就有安全训练窗口

机制：spectral bias 引发的隐式动力学正则化

时间尺度分离的背后机制是神经网络梯度流的 spectral bias——大特征值方向先衰减，小特征值方向后衰减。这是"低频先学，高频后学"在数学层面的精确表述。

要看清这一点，先回顾 score matching 的训练目标：扩散模型学习的是噪声水平 $t$ 下的 score function $\nabla_x \log p_t(x)$ 。给定有限训练集，empirical score 和 population score 形态非常不同：

\nabla_x \log p_t^{\text{emp}}(x) = \frac{\sum_{i=1}^n \mathcal{N}(x; a^i, \sigma_t^2 I) \cdot (a^i - x) / \sigma_t^2}{\sum_{i=1}^n \mathcal{N}(x; a^i, \sigma_t^2 I)}

在小噪声 $t \to 0$ 极限下，每个训练样本 $a^i$ 周围都形成一个尖刺——empirical score 把 $x$ 强烈推向最近的训练点。这就是 memorization 的几何根源：如果模型完美拟合 empirical score，它生成的就是训练样本本身。

population score 在同样的小噪声下是平滑的——它是真实数据分布的 score function，光滑反映数据分布的全局几何（关于 score 函数的几何意义，见概率流 ODE 与 score function）。

这个差别在 3D 里能一眼看出来：把 40 个训练点摆在一条螺旋（一段 1D 流形）上，把 KDE 估计的密度 $p(x)$ 画成淡紫色点云，把 score $\nabla \log p(x)$ 画成青色箭头。旋转看一圈，箭头从空间各处都指向那条螺旋管道——指向密度局部增加的方向，也就是流形的法向。一颗孤立训练点的位置在这张图里几乎没有局部影响力。这就是为什么过早 / 不足收敛到 empirical score 不会让模型背诵单个样本。

训练点 + 密度场 + score 向量场：旋转看一圈，箭头指向流形的局部法向

Loading 3D scene...

40 个白色小球是螺旋上的训练样本（θ ∈ [0, 4π]），紫色点云是 KDE 密度 p(x) = Σ exp(-‖x-x_i‖²/(2σ²)), σ=0.35，颜色越亮密度越高；青色箭头是 ∇log p(x) = (Σ w_i (x_i - x)/σ²) / Σ w_i 的方向（仅在密度高于阈值的区域绘制）。拖拽旋转一周，可以看到箭头从空间各处都指向那条螺旋管道——指向密度局部增加的方向，也就是流形的法向。

const W = container.clientWidth;
const H = container.clientHeight || 540;

const scene = new THREE.Scene();
scene.background = new THREE.Color(0x0f1018);

const camera = new THREE.PerspectiveCamera(45, W / H, 0.1, 100);
camera.position.set(4.5, 3.6, 5.6);

const renderer = new THREE.WebGLRenderer({ antialias: true });
renderer.setPixelRatio(Math.min(window.devicePixelRatio || 1, 2));
renderer.setSize(W, H);
renderer.domElement.style.display = 'block';
container.appendChild(renderer.domElement);

const controls = new OrbitControls(camera, renderer.domElement);
controls.enableDamping = true;
controls.dampingFactor = 0.08;
controls.minDistance = 3;
controls.maxDistance = 18;
controls.target.set(0, 0, 0);

// Bounding box wireframe [-2,2]^3
const boxGeom = new THREE.BoxGeometry(4, 4, 4);
const boxEdges = new THREE.EdgesGeometry(boxGeom);
const boxLines = new THREE.LineSegments(boxEdges, new THREE.LineBasicMaterial({ color: 0x334155 }));
scene.add(boxLines);

// Floor grid + axes
const grid = new THREE.GridHelper(4, 8, 0x2a3142, 0x1a1f2e);
grid.position.y = -2;
scene.add(grid);
const axes = new THREE.AxesHelper(2.3);
scene.add(axes);

// --- 40 training points along a helix θ ∈ [0, 4π] ---
const SIGMA = 0.35;
const SIGMA2 = SIGMA * SIGMA;
const N = 40;
const trainPts = [];
for (let i = 0; i < N; i++) {
    const theta = (i / (N - 1)) * 4 * Math.PI;
    const x = Math.sin(theta) * 1.2;
    const y = Math.cos(theta) * 1.2;
    const z = theta / (2 * Math.PI) - 1;
    trainPts.push(new THREE.Vector3(x, y, z));
}

// --- Closed-form Gaussian KDE density and score ---
function densityAt(x, y, z) {
    let p = 0;
    for (let i = 0; i < trainPts.length; i++) {
        const tp = trainPts[i];
        const dx = x - tp.x, dy = y - tp.y, dz = z - tp.z;
        p += Math.exp(-(dx * dx + dy * dy + dz * dz) / (2 * SIGMA2));
    }
    return p;
}
function scoreAt(x, y, z) {
    let sx = 0, sy = 0, sz = 0, wsum = 0;
    for (let i = 0; i < trainPts.length; i++) {
        const tp = trainPts[i];
        const dx = tp.x - x, dy = tp.y - y, dz = tp.z - z;
        const r2 = dx * dx + dy * dy + dz * dz;
        const w = Math.exp(-r2 / (2 * SIGMA2));
        wsum += w;
        sx += w * dx / SIGMA2;
        sy += w * dy / SIGMA2;
        sz += w * dz / SIGMA2;
    }
    if (wsum < 1e-12) return [0, 0, 0];
    return [sx / wsum, sy / wsum, sz / wsum];
}

// --- Density cloud on 18^3 lattice in [-2,2]^3 ---
const DENS_RES = 18;
const DENS_THRESH = 0.05; // relative to pmax
let pmax = 0;
const samples = [];
for (let i = 0; i < DENS_RES; i++) {
    for (let j = 0; j < DENS_RES; j++) {
        for (let k = 0; k < DENS_RES; k++) {
            const x = -2 + 4 * i / (DENS_RES - 1);
            const y = -2 + 4 * j / (DENS_RES - 1);
            const z = -2 + 4 * k / (DENS_RES - 1);
            const p = densityAt(x, y, z);
            samples.push([x, y, z, p]);
            if (p > pmax) pmax = p;
        }
    }
}

const positions = [];
const colors = [];
const colorLow = new THREE.Color(0x3b1e6e);
const colorHigh = new THREE.Color(0xe879f9);
for (let s = 0; s < samples.length; s++) {
    const [x, y, z, p] = samples[s];
    const pn = p / pmax;
    if (pn < DENS_THRESH) continue;
    positions.push(x, y, z);
    const c = colorLow.clone().lerp(colorHigh, Math.min(1, Math.pow(pn, 0.7)));
    colors.push(c.r, c.g, c.b);
}
const densityGeom = new THREE.BufferGeometry();
densityGeom.setAttribute('position', new THREE.Float32BufferAttribute(positions, 3));
densityGeom.setAttribute('color', new THREE.Float32BufferAttribute(colors, 3));
const densityMat = new THREE.PointsMaterial({
    size: 0.06,
    vertexColors: true,
    transparent: true,
    opacity: 0.75,
    depthWrite: false
});
const densityPoints = new THREE.Points(densityGeom, densityMat);
scene.add(densityPoints);

// --- Score arrows on 8^3 lattice, only where density is meaningful ---
const ARR_RES = 8;
const ARR_THRESH = 0.05;
const arrowsGroup = new THREE.Group();
const arrowColor = 0x22d3ee;
for (let i = 0; i < ARR_RES; i++) {
    for (let j = 0; j < ARR_RES; j++) {
        for (let k = 0; k < ARR_RES; k++) {
            const x = -1.8 + 3.6 * i / (ARR_RES - 1);
            const y = -1.8 + 3.6 * j / (ARR_RES - 1);
            const z = -1.8 + 3.6 * k / (ARR_RES - 1);
            const p = densityAt(x, y, z);
            if (p / pmax < ARR_THRESH) continue;
            const sv = scoreAt(x, y, z);
            const mag = Math.sqrt(sv[0] * sv[0] + sv[1] * sv[1] + sv[2] * sv[2]);
            if (mag < 1e-6) continue;
            const dir = new THREE.Vector3(sv[0] / mag, sv[1] / mag, sv[2] / mag);
            const len = Math.min(mag * 0.05, 0.4);
            if (len < 0.05) continue;
            const arr = new THREE.ArrowHelper(
                dir,
                new THREE.Vector3(x, y, z),
                len,
                arrowColor,
                Math.min(0.09, len * 0.4),
                Math.min(0.05, len * 0.25)
            );
            arrowsGroup.add(arr);
        }
    }
}
scene.add(arrowsGroup);

// --- UI ---
const ctrlBar = document.createElement('div');
ctrlBar.className = 'three-viz-controls';
container.appendChild(ctrlBar);
function mkBtn(label, fn) {
    const b = document.createElement('button');
    b.textContent = label;
    b.addEventListener('click', fn);
    ctrlBar.appendChild(b);
    return b;
}
const ptsBtn = mkBtn('隐藏训练点', () => {
    pointsGroup.visible = !pointsGroup.visible;
    ptsBtn.textContent = pointsGroup.visible ? '隐藏训练点' : '显示训练点';
});
const densBtn = mkBtn('隐藏密度场', () => {
    densityPoints.visible = !densityPoints.visible;
    densBtn.textContent = densityPoints.visible ? '隐藏密度场' : '显示密度场';
});
const arrBtn = mkBtn('隐藏 score 箭头', () => {
    arrowsGroup.visible = !arrowsGroup.visible;
    arrBtn.textContent = arrowsGroup.visible ? '隐藏 score 箭头' : '显示 score 箭头';
});
mkBtn('重置视角', () => {
    camera.position.set(4.5, 3.6, 5.6);
    controls.target.set(0, 0, 0);
    controls.update();
});

const hint = document.createElement('div');
hint.className = 'three-viz-hint';
hint.textContent = '拖拽=旋转  滚轮=缩放  右键=平移';
container.appendChild(hint);

// --- Render loop ---
let raf = 0;
function animate() {
    raf = requestAnimationFrame(animate);
    controls.update();
    renderer.render(scene, camera);
}
animate();

// --- Resize + dispose hooks ---
window['_threeViz_diffusion-score-field'] = {
    onResize(w, h) {
        if (!w || !h) return;
        camera.aspect = w / h;
        camera.updateProjectionMatrix();
        renderer.setSize(w, h, false);
    },
    dispose() {
        cancelAnimationFrame(raf);
        controls.dispose();
        renderer.dispose();
        scene.traverse(o => {
            if (o.geometry) o.geometry.dispose();
            if (o.material) {
                if (Array.isArray(o.material)) o.material.forEach(m => m.dispose());
                else o.material.dispose();
            }
        });
    }
};

训练数据足够多时（ $n$ 足够大），empirical score 在很多区域接近 population score（中心极限定理给的）；只在训练样本周围有尖刺。这两类成分对应不同的"频率"：

低频成分：population score 的平滑部分，对应训练损失 Hessian 的大特征值方向
高频成分：empirical score 的尖刺部分，对应 Hessian 的小特征值方向

梯度下降在这两类方向上的衰减速率不同。Random Feature Network 分析（论文 Appendix D）给出梯度流的闭式：参数沿 Hessian 特征值 $\lambda$ 的方向按 $e^{-\lambda \tau}$ 衰减—— $\lambda$ 越大，越早学到； $\lambda$ 越小，越晚学到。

这就解释了两个时间尺度：

$\tau_{\text{gen}}$ ：大 $\lambda$ 方向衰减完成，模型学到了 population score 的平滑成分，足以生成新样本
$\tau_{\text{mem}}$ ：小 $\lambda$ 方向也衰减完成，模型开始贴合 empirical score 的尖刺，背诵训练样本

为什么 $\tau_{\text{mem}} \propto n$ ？因为 empirical score 尖刺方向上的最小 Hessian 特征值 $\lambda_{\min}$ 随训练样本数 $n$ 的增长而收缩。论文 Appendix D 给出的关系是 $\lambda_{\min} \sim 1/n$ ，所以 $\tau_{\text{mem}} \sim 1/\lambda_{\min} \sim n$ 。

直观看：训练样本越多，每个样本周围的尖刺密度更高、相对幅度更小（被周围样本"平滑"了），模型需要更精细地分辨这些尖刺，因此学到 memorization 需要的步数也更多。

这种现象论文称为 implicit dynamical regularization——隐式动力学正则化。它的来源是梯度流本身的频谱特性自动屏蔽 memorization，这一过程不需要 weight decay、dropout 这类显式正则项参与。

与扩散数学基础的对接

要把这篇论文的结果放进现有数学骨架，三个对接点：

对接一：score matching 训练目标。Bonnaire et al. 的分析是建立在 score matching 损失上的，因此自然衔接 Score Matching 与 GAN 的分布距离对偶给出的去噪 score matching（DSM）框架。论文证明的"隐式动力学正则化"是 DSM 在过参数化条件下的副产品，不是 DSM 损失函数本身的性质。

对接二：DDPM 变分目标。DDPM 的 ELBO 通过变换最终等价于 weighted score matching loss（见 DDPM 变分下界）。这意味着 Bonnaire et al. 的结论可以直接迁移到 DDPM 训练上。论文 Eq. (5) 写出的 empirical score 形式与 DDPM 的去噪目标在 $t \to 0$ 极限下完全一致。

对接三：概率流 ODE / Fokker-Planck。Score function 在 SDE 框架下决定了反向 SDE 的漂移项（见 SDE 与 ODE 的统一）。Bonnaire et al. 的发现给概率流采样一个新视角：早期训练学到的 score 函数对应平滑的 population score，生成的是泛化样本；晚期训练学到的 score 对应 spiky empirical score，生成的是 memorization。

如果用 Flow Matching 与一致性模型的视角看，flow matching 学的是 velocity field 而非 score function。Bonnaire et al. 的具体分析不直接适用于 flow matching，但 spectral bias 论证的核心（神经网络梯度流的频谱选择性）是通用的，因此类似的两个时间尺度现象很可能在 flow matching 训练上也成立——这是一个值得后续验证的预测。

在 memorization 文献中的位置

这篇论文不是孤立工作，它在一条快速演进的研究线索上。把同领域几篇关键 paper 放一起看：

论文	角度	核心贡献
Carlini et al. 2023, USENIX arXiv:2301.13188	实证攻击	证明 Stable Diffusion 存在 memorization；从 LAION 子集恢复 109 张训练图
Somepalli et al. 2023a, CVPR arXiv:2212.03860	实证测量	系统量化 SD 复现率，发现训练步数是关键控制变量
Somepalli et al. 2023b, NeurIPS arXiv:2305.20086	缓解策略	prompt 多样性 + 训练数据去重等工程方法
Kadkhodaie & Simoncelli 2024, ICLR arXiv:2310.02557	几何解释	泛化来自神经网络学到的 geometry-adaptive harmonic representations
Bonnaire et al. 2025, NeurIPS	理论 + 标度律	两个时间尺度 + $\tau_{\text{mem}} \propto n$ 精确预测

Bonnaire et al. 与 Kadkhodaie-Simoncelli 是两条互补的解释路径：前者从训练动力学（when）入手，后者从表征几何（what）入手。它们都试图回答"为什么 diffusion 不 memorize"，但切入维度不同——理论上应该可以打通。

工程启示：什么时候停训

最直接的启示是给训练时长一个新的 stopping criterion：确保训练落在 $[\tau_{\text{gen}}, \tau_{\text{mem}}]$ 区间内。具体操作：

操作一：监控 $f_{\text{mem}}$ 而不是只看 val loss。传统做法是看 val loss 平台或 FID 平台来决定 stopping。但 val loss 在 $\tau_{\text{gen}}$ 之后变化很小，看不出 memorization 是否已经开始。直接监控 Eq. (6) 的 $f_{\text{mem}}$ （在 holdout 上比较生成样本与训练集的最近邻距离）能更早预警。

操作二：数据集规模直接换算成训练预算。根据 $\tau_{\text{mem}} \approx 3 \times 10^5 \cdot n$ （CelebA 32×32 + U-Net 上的数字，其他设置需要重新校准），可以估算给定数据集下的最大安全训练步数。

操作三：扩展数据 > 扩展模型来安全延长训练。如前面表格指出，模型扩张不延长安全窗口；数据扩张延长。这与 Chinchilla scaling laws 给出的"数据应该 scale up to match compute"建议方向一致，但理由不同——Chinchilla 是 val loss 最小化角度，Bonnaire 给的是 memorization 安全性角度。

工程上一个开放问题：现在 Stable Diffusion 类大模型都用 Adam 训练，但论文的理论结果是基于 SGD 推导的（spectral bias 在 Adam 下的形式不同）。论文 Section 4 明确承认这是限制：“While we derived our results under SGD optimization, most DMs are trained in practice with Adam.” 推广到 Adam 是直接的后续工作。

局限

论文自己列出了几条限制（Section 4）：

架构范围：参数量 $p$ 在 $10^6$ 到 $1.6 \times 10^7$ 之间，没覆盖 Stable Diffusion 量级的 $10^9$ 。
数据范围：CelebA 32×32 + 合成 GMM，没覆盖 ImageNet 或真实 LAION 规模数据。
优化器：理论用 SGD，实际 Adam 推广未做。
任务范围：unconditional diffusion only，没覆盖 conditional / text2image。

这些限制让"Stable Diffusion 实际跑到 $\tau_{\text{mem}}$ 了吗"这个具体问题没有定量答案。但定性结论——两个时间尺度的存在 + $\tau_{\text{mem}} \propto n$ 关系——在 GMM 合成数据上和 CelebA 上都重现，spectral bias 论证又不依赖架构细节，所以核心机制大概率推广得到 Stable Diffusion。剩下的是数字校准而不是图像翻转。

后续方向

把 Bonnaire et al. 当起点，向外延伸至少有三条线：

第一条：把 Adam 加进来。Adam 的自适应学习率会改变 spectral bias 的形态（小特征值方向被自适应放大）。直觉上，Adam 训练下 $\tau_{\text{mem}}$ 应该更短——更快 memorize。这是个可测量假设。

第二条：conditional diffusion 上 prompt 信息如何参与时间尺度？给 model 加 text condition 后，empirical score 的尖刺被 prompt 切片成更细的子集。可能的图像：prompt 多样性 → 每个 prompt 下的有效 $n$ 较小 → 该 prompt 的 $\tau_{\text{mem}}$ 较小 → 更容易 memorize。这正好解释了为什么 Somepalli 等人发现 Stable Diffusion 的 memorization 强度与 prompt 的稀有度强相关。

第三条：flow matching 与 consistency 模型上的类比。Flow matching 学的是 velocity field，consistency models 学的是 end-to-end 映射。Spectral bias 的具体形态会变，但"低频先学、高频后学"的核心结构应该保留。若类比成立，这套理论框架就从扩散模型推广到了整个 SDE-based 生成范式。

小结

Bonnaire et al. 2025 给"大扩散模型为什么不 memorize"提供了一个有力的解释：训练动力学存在两个分离的时间尺度， $\tau_{\text{gen}}$ 之后模型已经能生成高质量样本， $\tau_{\text{mem}}$ 之前模型还没开始背训练数据。两者之间是安全窗口。关键标度律 $\tau_{\text{mem}} \propto n$ 说明：数据集越大，安全窗口越长——这是大型 diffusion 模型在实践中默认表现为泛化的根本机制。

背后机制是神经网络梯度流的 spectral bias：训练损失 Hessian 的大特征值方向先衰减（学到 population score 的平滑成分），小特征值方向后衰减（开始贴合 empirical score 的尖刺）。Empirical score 的最小特征值 $\lambda_{\min} \sim 1/n$ ，因此 $\tau_{\text{mem}} \sim 1/\lambda_{\min} \sim n$ 。

工程上：监控 $f_{\text{mem}}$ 而不是只看 val loss；用 $\tau_{\text{mem}}(n)$ 估算安全训练预算；扩展数据 vs 扩展模型对安全窗口的影响完全不同。

理论上：与 Kadkhodaie-Simoncelli 的几何解释互补；Adam / conditional / flow matching 三个推广方向值得后续工作；标度律的 $300{,}000$ 这个常数在不同数据集和架构下的具体值是个未完成的实证地图。

参考文献

Bonnaire, T., Urfin, R., Biroli, G., & Mézard, M. (2025). Why Diffusion Models Don’t Memorize: The Role of Implicit Dynamical Regularization in Training. NeurIPS 2025 Best Paper. arXiv:2505.17638
Carlini, N., et al. (2023). Extracting Training Data from Diffusion Models. USENIX Security 2023. arXiv:2301.13188
Somepalli, G., Singla, V., Goldblum, M., Geiping, J., & Goldstein, T. (2023a). Diffusion Art or Digital Forgery? Investigating Data Replication in Diffusion Models. CVPR 2023. arXiv:2212.03860
Somepalli, G., et al. (2023b). Understanding and Mitigating Copying in Diffusion Models. NeurIPS 2023. arXiv:2305.20086
Kadkhodaie, Z., Guth, F., Mallat, S., & Simoncelli, E. P. (2024). Generalization in Diffusion Models Arises from Geometry-Adaptive Harmonic Representations. ICLR 2024. arXiv:2310.02557
Ho, J., Jain, A., & Abbeel, P. (2020). Denoising Diffusion Probabilistic Models. NeurIPS 2020. arXiv:2006.11239
Song, Y., et al. (2021). Score-Based Generative Modeling Through Stochastic Differential Equations. ICLR 2021. arXiv:2011.13456
苏剑林. 生成扩散模型漫谈系列. https://kexue.fm/category/Diffusion-Models

矛盾的起点：Carlini 攻击与泛化经验#

两个时间尺度：泛化窗口与记忆窗口#

数据集规模决定一切：τmem∝n\tau_{\text{mem}} \propto n 的核心标度律#

机制：spectral bias 引发的隐式动力学正则化#

与扩散数学基础的对接#

在 memorization 文献中的位置#

工程启示：什么时候停训#

局限#

后续方向#

小结#

相关概念#

参考文献#

相关文章