企业官网建设流程全解析

1. 项目概览：为什么拿随机数矩阵来验证RBM和DBN

先说结论：这个项目看着像是在“用深度学习网络跑一堆没意义的数据”，但实际上它是在做一件很核心的事情——验证模型本身能不能正常收敛、会不会崩、代码逻辑对不对。RBM和DBN这类生成式模型，最怕的不是数据太复杂，而是数据太简单你都不知道它是真的学会了还是因为实现有bug而碰巧输出了一堆无效值。随机数矩阵最大的价值在于：它没有显式的结构，任何“看起来学到了规律”的现象都值得怀疑，任何收敛趋势都需要从重构误差、能量函数、分类准确率等指标上给出合理解释。

我拿到这个题目的第一反应就是，这应该是一个深度学习入门实战项目，目标是跑通受限玻尔兹曼机（Restricted Boltzmann Machine, RBM）和深度信念网络（Deep Belief Network, DBN）的完整流程，包括数据准备、预训练、微调、测试几个环节。数据库用随机数矩阵，可以减少外部数据预处理的工作量，把注意力集中在网络本身的结构和训练过程上。项目适合三类人：刚学深度学习、想理解RBM怎么工作的人；需要在matlab环境下复现经典网络、为课程作业或论文实验打基础的人；以及想快速验证自己写的RBM代码是否正确的开发者。

用matlab做这个项目还有一个现实理由：matlab在矩阵运算上有天然优势，RBM的本质就是矩阵乘法和采样操作的循环，用matlab写出来非常自然，可视化调试也方便。我在这个项目里用matlab R2023a完整跑通了训练和测试流程，下面的内容都是我在实际调试里踩过坑、改过参数之后得出来的经验。

2. 核心原理拆解：RBM的采样机制和DBN的逐层预训练思路

2.1 随机数矩阵为什么适合当验证集

很多初学者一听到“数据库是随机数矩阵”，第一反应是“这能训练出什么来”。没错，纯均匀分布的随机数矩阵确实没法学出有用特征，因为数据本身没有结构，网络只是在拟合噪声。但这个项目里的随机数矩阵，其实并不完全等于“一堆白噪声”。我在实际设计实验时，会对随机数矩阵做一点结构化处理：比如生成一半均值在0.3、一半均值在0.7的高斯随机数据，给它们打上0和1的标签。这样从分布上看它仍然是一组随机数，但数据内部已经隐含了一个简单的线性可分结构，模型是可以学到东西的。

这样做的好处非常直接：第一，你可以快速判断网络是否“死掉了”——如果连这种弱结构都拟合不出来，那跑真实数据大概率也会出问题；第二，随机数矩阵的生成过程完全可控，标签与数据之间的关系是人为设定的，你心里清楚“真实规律”是什么，这样测试阶段的准确率就有了参考基准；第三，用它做验证可以排除数据预处理带来的干扰，比如归一化、去均值这些操作如果做错了，在真实数据上不容易发现，但在随机矩阵上很容易暴露。

2.2 RBM的能量函数与条件概率

RBM是一种基于能量的模型。它把网络状态的好坏用一个能量值来衡量，能量越低，这个状态越“合理”。对于二值RBM，隐藏单元h_j和可见单元v_i之间的联合能量定义为：

E(v,h) = -Σa_i·v_i - Σb_j·h_j - ΣΣv_i·W_ij·h_j

其中a是可见层偏置，b是隐藏层偏置，W是权重矩阵。训练的目标就是最小化这个能量，让模型能“解释”输入数据的分布。推导之后可以得到两个关键条件概率：

P(h_j=1|v) = sigmoid(b_j + Σv_i·W_ij) P(v_i=1|h) = sigmoid(a_i + ΣW_ij·h_j)

这两个公式就是RBM训练的核心。前向根据可见层采样出隐藏层，反向根据隐藏层重构出可见层，一正一反就是一次吉布斯采样。matlab里实现起来非常简单，sigmoid函数加rand函数就能完成采样。

2.3 DBN的堆叠逻辑

DBN本质上就是把多个RBM逐层堆叠。第一层RBM直接学习原始输入，训练完成后固定它的权重；然后把第一层的隐藏层输出作为第二层RBM的输入，继续训练第二层；如此逐层往上。每一层都被训练成“能较好表征上一层数据分布”的模型，这样整个网络在前向传播时就是一个特征提取器，越往高层提取的特征越抽象。

堆叠完成之后，通常在顶层加一个分类层（比如softmax），然后通过反向传播对整个网络进行微调。这个过程叫做“预训练+微调”。如果没有预训练，直接用随机初始化的权重去优化深层网络，很容易陷入局部最优或者梯度消失；先逐层预训练一遍，相当于给网络一个“较好的起点”，微调阶段只需要在这个起点附近做局部搜索，训练效率和最终性能都会好很多。

3. 代码实现：matlab环境下RBM和DBN训练测试全流程

3.1 随机数矩阵数据库的生成与标签设计

我生成的训练集是1000个样本、每个样本64维的随机数矩阵，标签是2分类。为了让数据稍微有点规律，我把前500个样本的均值设定为0.3，后500个样本的均值设定为0.7，并且把数据归一化到(0,1)区间。代码是这样写的：

% 生成随机数矩阵数据库，含隐含结构 numSamples = 1000; numFeatures = 64; data = zeros(numSamples, numFeatures); labels = zeros(numSamples, 1); for i = 1:numSamples if i <= numSamples/2 data(i,:) = 0.3 + 0.1 * randn(1, numFeatures); labels(i) = 0; else data(i,:) = 0.7 + 0.1 * randn(1, numFeatures); labels(i) = 1; end end % 裁剪到0-1之间，保持数据为概率值域 data(data<0) = 0; data(data>1) = 1;

这里把数据限制在0到1之间，是因为RBM的可见层我打算用sigmoid激活和伯努利采样，输入值代表可见单元被激活的概率。当然你也可以直接把连续值喂给RBM，使用高斯-伯努利RBM，但那个要改动能量函数和采样公式，对新手来说复杂很多。我建议先跑通二值版本，再扩展连续版本。

3.2 RBM单层训练函数实现

下面这个函数是我实际使用的RBM训练函数，用的是对比散度算法（CD-k，这里k取1）。核心步骤就是三行：根据可见层采样隐藏层，根据隐藏层重构可见层，再根据重构的可见层采样隐藏层，最后用三组状态计算梯度更新权重。

function [W, a, b] = trainRBM(data, numHidden, lr, epochs, batchSize) numVisible = size(data, 2); numSamples = size(data, 1); % 初始化参数 W = 0.01 * randn(numVisible, numHidden); a = zeros(1, numVisible); b = zeros(1, numHidden); numBatches = floor(numSamples / batchSize); for epoch = 1:epochs % 打乱数据顺序 idx = randperm(numSamples); data = data(idx, :); for batch = 1:numBatches batchData = data((batch-1)*batchSize+1 : batch*batchSize, :); v0 = batchData; % 正向采样：从可见层得到隐藏层 p_h1 = 1 ./ (1 + exp(-(v0 * W + repmat(b, batchSize, 1)))); h1 = p_h1 > rand(size(p_h1)); % 反向重构：从隐藏层重构可见层 p_v1 = 1 ./ (1 + exp(-(h1 * W' + repmat(a, batchSize, 1)))); v1 = p_v1 > rand(size(p_v1)); % 再次正向采样：从重构的可见层得到隐藏层 p_h2 = 1 ./ (1 + exp(-(v1 * W + repmat(b, batchSize, 1)))); h2 = p_h2 > rand(size(p_h2)); % CD-1梯度 dW = (v0' * p_h1 - v1' * p_h2) / batchSize; da = mean(v0 - v1, 1); db = mean(p_h1 - p_h2, 1); % 更新参数 W = W + lr * dW; a = a + lr * da; b = b + lr * db; end % 计算重构误差，用于观察收敛 p_h = 1 ./ (1 + exp(-(data * W + repmat(b, numSamples, 1)))); recon = 1 ./ (1 + exp(-(p_h * W' + repmat(a, numSamples, 1)))); reconError = mean(sum((data - recon).^2, 2)); if mod(epoch, 10) == 0 fprintf('Epoch %d, Reconstruct Error: %.4f\n', epoch, reconError); end end end

这段代码里有两个细节值得说一下。第一个细节是，计算梯度时用了“采样值h1”来重构，但计算权重梯度时用的是概率值p_h1而不是采样值，这是CD算法中比较常见的处理方式，可以降低采样方差，让训练更稳定。第二个细节是，我用了批量训练而不是全量训练或单样本训练。批量大小为64，既保证梯度估计有一定统计稳定性，又不会因为全量计算导致收敛太慢。

3.3 DBN构建和逐层预训练

DBN的构建就是一个循环调用trainRBM函数的过程。由于trainRBM返回的是当前层的权重，我把上一层的隐藏层输出作为下一层的输入，循环两次就得到了两层的DBN：

% 设置网络结构 layerSizes = [64, 100, 50, 2]; % 输入64维，隐层1有100个单元，隐层2有50个单元，输出2类 % 保存每层的权重和偏置 W1 = []; b1 = []; W2 = []; b2 = []; % 第一层RBM [W1, a1, b1] = trainRBM(data, layerSizes(2), 0.01, 50, 64); % 计算第一层隐藏输出，作为第二层输入 hid1Data = 1 ./ (1 + exp(-(data * W1 + repmat(b1, size(data,1), 1)))); % 第二层RBM [W2, a2, b2] = trainRBM(hid1Data, layerSizes(3), 0.01, 50, 64);

这样训练出来之后，W1和W2就是预训练好的权重。如果真实数据维度更高、层数更多，比如MNIST那种784维输入，DBN可能有3层甚至4层隐藏层，循环调trainRBM就行了。在随机数矩阵这个项目里，2层RBM已经足够验证流程。再加一层会显著增加调试复杂度，但对最终测试准确率的提升非常有限，因为数据本身的结构非常简单。

3.4 顶层分类器和全局微调

预训练完成后，我在网络的顶层接了一个softmax分类层。softmax的输入是第二层隐藏层的输出（即50维特征），输出是2类概率。微调过程用的是标准的反向传播，损失函数是交叉熵。我在matlab里手动写了前向传播和反向传播的梯度推导，没有直接调用内置的神经网络工具箱——这样能更清楚每一层到底在算什么，也更容易定位问题。

% 预训练好的参数 % W1: 64x100, b1: 1x100 % W2: 100x50, b2: 1x50 % 随机初始化softmax层 W3 = 0.01 * randn(50, 2); b3 = zeros(1, 2); % 微调参数 finetuneLr = 0.001; finetuneEpochs = 50; batchSize = 64; numBatches = floor(size(data,1) / batchSize); for epoch = 1:finetuneEpochs totalLoss = 0; idx = randperm(size(data,1)); data = data(idx,:); labels = labels(idx,:); for batch = 1:numBatches batchData = data((batch-1)*batchSize+1 : batch*batchSize, :); batchLabels = labels((batch-1)*batchSize+1 : batch*batchSize, :); % 前向传播 h1 = 1 ./ (1 + exp(-(batchData * W1 + repmat(b1, batchSize, 1)))); h2 = 1 ./ (1 + exp(-(h1 * W2 + repmat(b2, batchSize, 1)))); out = h2 * W3 + repmat(b3, batchSize, 1); % softmax expOut = exp(out - max(out, [], 2)); probs = expOut ./ sum(expOut, 2); % 构造one-hot标签 yOneHot = zeros(batchSize, 2); for i = 1:batchSize yOneHot(i, batchLabels(i)+1) = 1; end % 交叉熵损失 loss = -sum(sum(yOneHot .* log(probs + 1e-12))) / batchSize; totalLoss = totalLoss + loss; % 反向传播梯度 dOut = (probs - yOneHot) / batchSize; dW3 = h2' * dOut; db3 = sum(dOut, 1); dh2 = dOut * W3' .* (h2 .* (1 - h2)); dW2 = h1' * dh2; db2 = sum(dh2, 1); dh1 = dh2 * W2' .* (h1 .* (1 - h1)); dW1 = batchData' * dh1; db1 = sum(dh1, 1); % 参数更新 W3 = W3 - finetuneLr * dW3; b3 = b3 - finetuneLr * db3; W2 = W2 - finetuneLr * dW2; b2 = b2 - finetuneLr * db2; W1 = W1 - finetuneLr * dW1; b1 = b1 - finetuneLr * db1; end if mod(epoch, 10) == 0 fprintf('Finetune Epoch %d, Avg Loss: %.4f\n', epoch, totalLoss/numBatches); end end

反向传播那几行，核心是链式法则的逐层展开。dh2那行里的h2.*(1-h2)是sigmoid函数的导数，这一步必须要有，否则梯度传不下去。我之前调试时把这行漏掉了，结果损失完全不动，找了一个多小时才发现问题。这种错误在matlab里不会报错，因为矩阵维度刚好能对上，但结果就是模型不学习。

3.5 测试环节：准确率评估和可视化检查

训练完以后，我重新生成了一批独立的测试数据——同样是随机数矩阵，同样的均值和噪声，但样本和之前训练用到的完全不同。前向传播得到预测类别，和真实标签对比计算准确率：

% 生成测试数据 numTest = 400; testData = zeros(numTest, numFeatures); testLabels = zeros(numTest, 1); for i = 1:numTest if i <= numTest/2 testData(i,:) = 0.3 + 0.1 * randn(1, numFeatures); testLabels(i) = 0; else testData(i,:) = 0.7 + 0.1 * randn(1, numFeatures); testLabels(i) = 1; end end testData(testData<0) = 0; testData(testData>1) = 1; % 前向传播 h1 = 1 ./ (1 + exp(-(testData * W1 + repmat(b1, numTest, 1)))); h2 = 1 ./ (1 + exp(-(h1 * W2 + repmat(b2, numTest, 1)))); out = h2 * W3 + repmat(b3, numTest, 1); [~, pred] = max(out, [], 2); pred = pred - 1; % matlab索引从1开始，转换为0/1 accuracy = sum(pred == testLabels) / numTest; fprintf('Test Accuracy: %.2f%%\n', accuracy * 100);

我实测的结果是，预训练50个epoch加微调50个epoch之后，测试准确率稳定在96%到98%之间。这个结果说明两件事：第一，RBM的CD算法和我的代码实现是正确的，数据里的弱结构确实被学到了；第二，DBN的逐层预训练加微调流程在这个简单数据集上是可以收敛的。如果准确率明显偏低或者波动很大，就要回去检查采样逻辑和数据归一化是否出了问题。

4. 参数调优与训练策略：从完全失败到稳定收敛的调试记录

4.1 学习率的选择逻辑

学习率是RBM训练里最敏感的超参数。我在调试中发现一个规律：学习率设为0.1时，重构误差在前5个epoch下降很快，但到第20个epoch左右就开始震荡，甚至上升；设为0.001时，训练非常稳定，但50个epoch之后重构误差还停留在0.15以上，收敛太慢；最后折中设为0.01，效果最好，50个epoch之后重构误差能降到0.05左右。

为什么会有这个现象？因为RBM的训练本质是在做随机梯度上升（最大化对数似然），学习率太大相当于每次迈的步子太大，容易在能量曲面的沟壑间来回跳跃，导致参数发散；学习率太小又容易卡在浅层局部最优附近。如果你想进一步改善，可以加入动量项：

momentum = 0.5; % 前5个epoch用0.5，之后可以升到0.9 W = W + lr * dW + momentum * (W_old - W_pre);

动量项的思想是让参数的更新方向不仅取决于当前梯度，还叠加一部分上一步的更新方向，相当于给训练过程加了一个“惯性”。这样既能保持较快的收敛速度，又能抑制震荡。我在训练RBM时最常用的是前5个epoch用momentum=0.5，之后momentum=0.9。微调阶段我通常不用动量，而是把学习率放到0.001，因为微调是在预训练权重附近做精细调整，步子必须小。

4.2 隐藏层单元数量的权衡

隐藏层单元数量直接决定了网络的表达能力。在这个项目里我尝试过几组配置：64-20-2（隐藏层20个单元）时测试准确率只有89%左右，说明模型容量太小，不足以充分刻画数据的分布特征；64-100-50-2时准确率能达到96%以上，已经能很好完成任务；64-300-100-2时准确率反而没明显提升，但训练时间几乎翻了三倍。

这说明一个问题：模型的容量不是越大越好，容量超出数据复杂度太多时，多出来的参数只是在拟合噪声，对泛化没有帮助。随机数矩阵生成的数据本身结构很简单，100个单元已经远远够了。在真实数据集上，判断隐藏层数量的经验法则是：第一层的隐藏单元数可以取输入维度的一半到两倍之间，后续每层逐渐递减。比如MNIST输入维度784，第一层取500，第二层取250，再往上取100或者50。

4.3 全量训练、批量训练和随机梯度训练的取舍

我在matlab里对比过三种训练模式在RBM上的效果。全量训练（每次用全部1000个样本计算梯度）收敛最稳定，但每次迭代计算量大，而且容易陷入局部最优，因为梯度方向太“平均”了，缺乏随机性；单样本随机梯度训练（每次用一个样本更新参数）收敛需要的epoch很多，噪声大，训练曲线非常颠簸；批量大小为64的mini-batch训练是三者中折中效果最好的，训练过程有一定随机性帮助跳出局部最优，梯度估计也比较稳定。

matlab里有个性能优化的细节：不要在一个双层for循环里逐样本更新参数，一定要把所有操作向量化。我第一次写RBM训练时，用了一个for循环逐样本计算梯度，1000个样本50个epoch跑了将近3分钟；改成矩阵运算批量处理之后，运行时间直接降到15秒左右。matlab的矩阵运算底层是高度优化的，向量化写法快得惊人，用for循环等于把这层优化全部浪费掉了。

4.4 正则化与Epoch之间的平衡

在随机数矩阵这样简单数据集上不太容易看出过拟合，但如果你把epoch调到200以上，会看到重构误差持续下降、可测试准确率却开始下降的情况，这就是典型的过拟合信号。我在调试时加入了一个简单的L2权重衰减，让权重的平方和作为惩罚项加进损失函数：

% 在参数更新时加入权重衰减 weightDecay = 1e-4; W = W + lr * (dW - weightDecay * W);

这样做的效果是让权重不会增长到过大的值，从而限制模型的复杂度。对RBM来说，还有一个更常用的正则化手段就是稀疏性约束，在损失函数上加一个惩罚项让隐藏单元的平均激活概率接近一个较小的目标值（比如0.1）。这对真实数据比较有效，但对随机数矩阵这个项目来说，我建议先不加，等你在真实数据上跑模型时再加稀疏约束也不迟。

5. 训练过程的可视化和关键指标解读

5.1 重构误差曲线的判断标准

训练RBM时，最需要盯住的指标就是重构误差。它的计算方式是：输入原始数据，经过一次正向采样得到隐藏层，再经过反向重构得到重构的可见层，然后计算原始数据与重构数据之间的均方误差。重构误差越低，说明RBM对输入数据分布的建模能力越强。

我在项目里训练结束后会把重构误差曲线画出来，观察它的下降趋势。正常的曲线应该是先快速下降，然后缓慢下降，最后基本平稳。如果你看到误差曲线直接横着走完全不下降，那就是学习率太小或者数据没有归一化；如果曲线先下降后突然上升，那就是学习率太大导致训练发散；如果曲线像锯齿一样剧烈震荡，那可能是batch size太小、梯度噪声太大。

绘图我用的最简单的方式，在训练循环里记录每个epoch的重构误差，训练结束后用plot画出来。matlab里顺手就能出图，非常直观。

5.2 特征可视化：随机数矩阵也能看出聚类效应

训练结束后，还有一个非常有意思的检查方法：把第二层隐藏层的输出用t-SNE降到二维，然后用散点图可视化。标签为0的测试样本和标签为1的测试样本，如果在二维平面上基本分开成两簇，那就说明DBN学到的特征具有可分性。

% 提取特征并可视化 h1 = 1 ./ (1 + exp(-(testData * W1 + repmat(b1, numTest, 1)))); h2 = 1 ./ (1 + exp(-(h1 * W2 + repmat(b2, numTest, 1)))); % 如果安装了Statistics and Machine Learning Toolbox，可以用tsne % mappedData = tsne(h2, 'NumDimensions', 2); % 如果没有，可以直接取前两个主成分做近似可视化 [coeff, score] = pca(h2); mappedData = score(:, 1:2); figure; gscatter(mappedData(:,1), mappedData(:,2), testLabels);

如果你没有tsne函数（tsne在matlab R2023a里需要Statistics Toolbox），用PCA做个近似也行。随机数矩阵生成的数据经过RBM特征提取后，PCA降维通常也能看到分离趋势，只是没有t-SNE那么明显。这个可视化步骤对验证“RBM真的学到了东西”特别有说服力，论文或报告里放一张特征聚类图，比单纯堆一堆准确率数字要直观得多。

5.3 隐藏层权重的可视化检查

如果是图像数据（比如MNIST），把第一层RBM学习到的权重矩阵W1的每一列reshape回图像，能看到各种边缘和笔画探测器。但在这个项目里，输入是64维随机数，权重没办法reshape成有意义的图像，所以可视化权重意义不大。我在调试时会用另一种方式检查权重：查看权重的分布直方图。如果权重值集中在0附近且大致成对称分布，说明训练正常；如果权重值整体偏向很大或很小，或者全部分布在某个极端值附近，那大概率是训练出了问题。

6. 常见问题与排查技巧：RBM和DBN调试实录

6.1 采样函数写错导致每次结果不变

这个问题我印象特别深刻。我第一次写RBM时，隐藏层采样用的是h1 = 1 ./ (1 + exp(-(v0 * W + b)))，忘记加随机比较的环节，直接把概率值当作二值采样结果。这样训练出去之后模型确实也在运行，重构误差也在下降，但隐藏层输出全是小数、没有真正的二值采样，模型在微调阶段表现特别差。排查了很久才发现，RBM训练的随机性全靠这一步的比较操作来保证，少了它，CD算法的梯度估计就失去了随机性，学到的特征质量会急剧下降。

正确写法一定要包含比较：

p_h1 = 1 ./ (1 + exp(-(v0 * W + repmat(b, batchSize, 1)))); h1 = p_h1 > rand(size(p_h1)); % 这一步绝对不可少

测试的时候，那个每个维度都加上repmat的操作也很容易踩坑。如果你直接用v0 * W + b，matlab自动广播机制在有些版本里可以，但R2023a之前的老版本可能会报维度不匹配。保险起见，我每次都显式用repmat把偏置扩展到和批量数据相同的行数，就是下面这个写法：

p_h1 = 1 ./ (1 + exp(-(v0 * W + repmat(b, batchSize, 1))));

这个习惯帮我避开了好多次“维度对不上”的报错。

6.2 训练不收敛时应该优先检查什么

如果你在matlab里看到重构误差居高不下，最优先检查三点。数据是否归一化到(0,1)之间——如果数据范围是0到255，sigmoid函数在输入很大时梯度接近0，训练会停滞；学习率是否过大或过小，这是最直接的影响因素，我会先固定住把0.01当作基准，观察50个epoch的误差曲线再调整；权重初始化是否合理，我习惯用0.01乘以randn，让初始权重在0附近的小范围内分布，太大会导致初始状态能量过高，训练一开始就容易震荡。

如果这些都检查过还是有问题，再检查代码里有没有把梯度正负号搞反。RBM的CD算法更新方向是“数据分布的期望减去模型分布的期望”，如果方向反了，权重更新会让模型越学越差，具体表现就是重构误差不降反升。有个土办法检查：用非常小的学习率跑50个epoch，如果误差没有变化，把dW前面的符号取反再跑一次，看哪个方向能让误差下降，就说明之前的符号写反了。

6.3 预训练和微调之间如何选择合适的学习率

RBM预训练时的学习率可以比较大（0.01到0.1），因为它的目标是学一个粗粒度的数据分布。但进入BP微调阶段，学习率一般要降一个数量级到0.001左右。这是为什么？因为预训练已经让网络处在一个比较好的初始点附近，微调阶段如果学习率太大，很容易一下跳出了预训练学到的“好区域”，反而破坏了之前学到的特征。我实际测试过：微调学习率设为0.01时，前几个epoch损失下降很快，但后面开始震荡，测试准确率反而不如预训练完直接取特征分类的结果；把学习率降到0.001后，损失平稳下降，准确率稳步上升。

6.4 epoch数量如何确定：早停法

判断该训练多少个epoch，最实用的方法是早停法。我把训练集再分成两部分：一部分参与训练，一部分留作验证。每训练完一个epoch，就在验证集上计算一次准确率或重构误差，如果连续5个epoch验证集指标不再改善，就停止训练。

matlab里写法很直接：

if epoch > 5 if valAcc(end) <= valAcc(end-5) % 连续5轮没提升 break; end end

在随机数矩阵这个项目里，预训练通常在30到50个epoch时就已经稳定，微调在20到30个epoch时基本收敛。神经网络训练之前你不知道要跑多少epoch，提前设定一个大的上限（比如200），配合早停法自动停止，既省时间又防止过拟合。

6.5 标签与数据的对应关系不能改变

有一类问题很隐蔽：数据预处理时对样本进行了重排（比如randperm打乱），但标签没有跟着一起重排，导致标签和数据的对应关系被破坏。训练时模型会发现同一份数据一会儿对应标签0一会儿对应标签1，完全没有规律可循，损失曲线会剧烈震荡，准确率永远在50%附近上不去。matlab里处理这个问题最保险的方式是：先一起重排，再划分batch。

idx = randperm(size(data,1)); data = data(idx, :); labels = labels(idx, :); % 这行一定不能少

我在很多项目里见过新手踩这个坑。你的训练集和测试集划分、每个epoch之前的数据打乱，都要保证标签跟随数据同步重排，否则模型永远学不到任何东西。

7. 经验总结：这个项目的价值不止于跑通代码

把随机数矩阵作为RBM和DBN训练测试的数据库，看起来是个很玩具的项目，但它在教学和验证场景里的价值非常高。因为数据生成方式完全可控，你可以确定地知道“真相”是什么——两簇均值不同的高斯分布、标签是0和1。这样当你训练结束，测试准确率出来之后，你能明确判断模型学到了什么、没学到什么，这比直接扔一堆真实数据让你黑盒调参要友好得多。我自己在调试RBM和DBN代码时，就经常用这种方式做冒烟测试，代码逻辑有问题、梯度方向写反了、采样写错了，在随机数矩阵上一跑就全部暴露出来。

如果你后续想在真实数据集上做实验，比如MNIST手写数字识别或者UCI数据集上的分类任务，只需要把这个项目里的数据生成部分换成真实数据的读取和预处理，网络结构稍微调整一下，训练流程完全可以复用。预训练加微调的整套框架是通用的，RBM的CD算法、softmax输出层、交叉熵损失、反向传播的实现都不会变。我想说的是，深度学习框架的代码其实不难写，难点在于你知不知道每一步在做什么；用随机数矩阵做验证，恰好就是逼着你理解每一步的最快路径。