### 不使用 `python-dbn` 包的手动实现 DBN 深度信念网络 (DBN) 是一种由多个受限玻尔兹曼机 (RBM) 组成的生成模型。手动实现 DBN 通常涉及以下几个步骤：构建 RBM、堆叠多个 RBM 进行无监督预训练，最后通过反向传播算法进行有监督微调。 以下是一个基于 Python 3.7 的简单 DBN 实现示例，其中未使用任何专用的 DBN 库[^1]。 --- ### 示例代码：手动实现 DBN #### 1. 导入必要的库 ```python import numpy as np from sklearn.datasets import load_digits from sklearn.model_selection import train_test_split from sklearn.preprocessing import MinMaxScaler from tensorflow.keras.models import Sequential from tensorflow.keras.layers import Dense ``` #### 2. 定义 RBM 类 ```python class RestrictedBoltzmannMachine: def __init__(self, num_visible, num_hidden): self.num_visible = num_visible self.num_hidden = num_hidden # 初始化权重和偏置 self.weights = np.random.randn(num_visible, num_hidden) * 0.01 self.hidden_bias = np.zeros(num_hidden) self.visible_bias = np.zeros(num_visible) def sigmoid(self, x): return 1 / (1 + np.exp(-x)) def sample_hidden(self, visible_probabilities): hidden_activations = np.dot(visible_probabilities, self.weights) + self.hidden_bias hidden_probs = self.sigmoid(hidden_activations) return hidden_probs, np.random.binomial(n=1, p=hidden_probs) def sample_visible(self, hidden_probabilities): visible_activations = np.dot(hidden_probabilities, self.weights.T) + self.visible_bias visible_probs = self.sigmoid(visible_activations) return visible_probs, np.random.binomial(n=1, p=visible_probs) def contrastive_divergence(self, data, learning_rate=0.01, k=1): positive_hidden_probs, _ = self.sample_hidden(data) # Gibbs sampling visible_reconstructions = None for step in range(k): _, hidden_samples = self.sample_hidden(data) visible_probs, visible_reconstructions = self.sample_visible(hidden_samples) _, negative_hidden_probs = self.sample_hidden(visible_probs) # 更新权重和偏置 self.weights += learning_rate * (np.dot(data.T, positive_hidden_probs) - np.dot(visible_reconstructions.T, negative_hidden_probs)) / data.shape[0] self.visible_bias += learning_rate * np.mean(data - visible_reconstructions, axis=0) self.hidden_bias += learning_rate * np.mean(positive_hidden_probs - negative_hidden_probs, axis=0) reconstruction_error = np.mean(np.square(data - visible_reconstructions)) return reconstruction_error ``` #### 3. 构建 DBN 类 ```python class DeepBeliefNetwork: def __init__(self, layer_sizes): self.rbms = [] for i in range(len(layer_sizes) - 1): rbm = RestrictedBoltzmannMachine(layer_sizes[i], layer_sizes[i+1]) self.rbms.append(rbm) def pretrain(self, data, epochs=10, batch_size=32, learning_rate=0.01): input_data = data.copy() for rbm in self.rbms: for epoch in range(epochs): indices = np.arange(input_data.shape[0]) np.random.shuffle(indices) for start_idx in range(0, len(indices), batch_size): excerpt = indices[start_idx:start_idx + batch_size] error = rbm.contrastive_divergence(input_data[excerpt], learning_rate=learning_rate) print(f"Pretraining Layer {self.rbms.index(rbm)+1}, Epoch {epoch+1}/{epochs}, Error: {error}") # 提取高层特征作为下一层输入 _, input_data = rbm.sample_hidden(input_data) def fine_tune(self, X_train, y_train, X_val=None, y_val=None, epochs=10, batch_size=32): model = Sequential() for rbm in self.rbms[:-1]: model.add(Dense(units=rbm.num_hidden, activation='sigmoid', weights=[rbm.weights.T, rbm.hidden_bias])) # 添加最后一层全连接层 final_layer_weights = self.rbms[-1].weights.T final_layer_biases = self.rbms[-1].hidden_bias model.add(Dense(units=self.rbms[-1].num_hidden, activation='softmax', weights=[final_layer_weights, final_layer_biases])) model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy']) history = model.fit(X_train, y_train, validation_data=(X_val, y_val), epochs=epochs, batch_size=batch_size) return model, history.history ``` #### 4. 主程序逻辑 ```python if __name__ == "__main__": # 加载数据集并进行预处理 digits = load_digits() X = digits.images.reshape((len(digits.images), -1)).astype('float32') y = digits.target.astype('int') scaler = MinMaxScaler(feature_range=(0, 1)) X_scaled = scaler.fit_transform(X) X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42) # 创建 DBN 模型 dbn = DeepBeliefNetwork([64, 50, 20]) # 无监督预训练 dbn.pretrain(X_train, epochs=10, batch_size=32, learning_rate=0.01) # 有监督微调 model, history = dbn.fine_tune(X_train, y_train, X_val=X_test, y_val=y_test, epochs=100, batch_size=32) # 输出最终验证集上的准确率 val_accuracy = max(history['val_accuracy']) if 'val_accuracy' in history else 0 print(f"Validation Accuracy after Fine-Tuning: {val_accuracy:.4f}") ``` --- ### 关键点解析 1. **RBM 的实现**：通过对比散度法 (Contrastive Divergence) 训练 RBM，更新其权重和偏置。 2. **DBN 的堆叠**：将多个 RBM 堆叠在一起形成 DBN，并在每一层提取更高层次的特征。 3. **无监督预训练**：逐层训练 RBM，初始化深层网络的权重。 4. **有监督微调**：利用 Keras 的 API 构建前馈神经网络，并通过反向传播进一步优化整个网络。 --- ###