当前位置：首页 > news >正文

深度学习4(浅层神经网络)

news 2025/7/6 6:42:26

浅层神经网络简介

浅层神经网络通常指仅含1个隐藏层的神经网络，是早期神经网络的基础形态。其结构为：输入层 → 隐藏层 → 输出层。

其隐藏层一般含有多个神经元，输出层有一个神经元。为方便理解，每个神经元都可看作一次逻辑回归（可能不准确，但方便理解）。

输入层（Input Layer）：接收原始数据（如图像像素、数值特征等）。
隐藏层（Hidden Layer）：仅1层，由多个神经元（Neurons）组成，每个神经元对输入数据进行加权求和并应用激活函数（如Sigmoid、ReLU）。
输出层（Output Layer）：根据任务类型（分类/回归）选择不同的激活函数：

浅层神经网络的前向传播

宏观上看，输入层输入样本；隐层接受样本，输出第一次处理的数据；输出层接受数据，输出最终结果。这是正向传播的大概流程。

微观上来说，每个神经元接收到上一层的输出时，进行一次线性变换(加权求和,z=Wx+b)和非线性变换(激活函数，如sigmoid、tanh等)。

浅层神经网络向量化表示

由于加入了多个神经元，为了能使用numpy并行运算，提高效率，我们依然要使用向量化表示。而整个过程出现了两个权重矩阵（w1,w2）和偏置矩阵（b1,b2），且他们作用的地方输入输出都不相同，形状也不相同。

设隐层有h个神经元，m个样本，n个特征

样本矩阵X：m行n列，每一行为一个样本，每一列是同一特征

权重矩阵w1：h行，n列，（每个隐藏层神经元需要 n 个权重）

偏置矩阵b1：h行，1列，（因为每个隐藏层神经元有一个偏置）

权重矩阵w2：1行，h列，（只有 1 个输出神经元 → 1 行）

权重矩阵b2：1行，1列，（输出层只有一个神经元，只有一个偏置）

激活函数的介绍与选择

激活函数是神经网络的核心组件之一，它决定了神经元的输出形式，并赋予网络非线性建模能力。

涉及到网络的优化时候，会有不同的激活函数选择。有一个问题是神经网络的隐藏层和输出单元用什么激活函数。之前我们都是选用 sigmoid 函数，但有时其他函数的效果会好得多，大多数通过实践得来，没有很好的解释性。

名称	公式	优点	缺点
Sigmoid	$\sigma(z)=\frac{1}{1+e^{-z} }$	输出可解释为概率，适合二分类输出层	梯度消失（当 ∣z∣∣z∣ 较大时，导数接近0）。输出非零中心化（均值不为0），影响梯度下降效率。
Tanh	$\tanh (z)=\frac{e^{z}-e^{-z}}{e^{z}+e^{-z}}$	零中心化输出，梯度下降更稳定比Sigmoid梯度更强（导数最大值为1）	仍有梯度消失问题（但比Sigmoid轻）
ReLU	$ReLU(z)=max(0,z)$	计算高效（无指数运算）缓解梯度消失（正区间梯度恒为1）	“死亡ReLU”问题（负输入永远不激活）

浅层神经网络反向传播

反向传播是神经网络训练的核心算法，用于计算损失函数对网络参数的梯度（即权重和偏置的导数），从而通过梯度下降优化参数。

而在单隐层的浅层神经网络中，可以看作分两步进行的反向传播。

浅层神经网络python代码实现

import numpy as npX = np.array([[0.5, 1.5],  # 样本 1[1.0, 0.8],  # 样本 2[-0.5, 0.2],  # 样本 3[0.0, -1.0]  # 样本 4
])Y = np.array([[1, 1, 0, 0]])  # 二分类标签def sigmoid(x):sig = 1 / (1 + np.exp(-x))return sigdef layer_size(X, Y):# 输入层大小(特征数量）n_x = X.shape[1]# 隐层大小（神经元个数）n_h = 4# 输出层大小n_y = 1return (n_x, n_h, n_y)def initialize_parameters(n_x, n_h, n_y):# 隐层参数w1,b1w1 = np.random.randn(n_h, n_x) * 0.01b1 = np.zeros((n_h, 1))# 输出层参数w2，b2w2 = np.random.randn(n_y, n_h) * 0.01b2 = np.zeros((n_y, 1))params = {"w1": w1, "b1": b1, "w2": w2, "b2": b2}return paramsdef forward_propagation(X, params):w1 = params["w1"]b1 = params["b1"]w2 = params["w2"]b2 = params["b2"]# 第一层Z1 = np.dot(w1, X.T) + b1A1 = np.tanh(Z1)# 第二层Z2 = np.dot(w2, A1) + b2A2 = sigmoid(Z2)cache = {"Z1": Z1,"A1": A1,"Z2": Z2,"A2": A2}return A2 , cachedef compute_cost(A2, Y, params):m = X.shape[0]cost = -1 / m * (np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2)))return costdef backward_propagation(params, cache, X, Y):w1 = params["w1"]w2 = params["w2"]Z1 = cache["Z1"]Z2 = cache["Z2"]A1 = cache["A1"]A2 = cache["A2"]m = X.shape[0]# 输出层反向dz2 = A2 - Ydw2 = 1 / m * np.dot(dz2, A1.T)db2 = 1 / m * np.sum(dz2, axis=1)# 隐层反向dz1 = np.dot(w2.T, dz2) * (1 - np.power(A1, 2))dw1 = 1 / m * np.dot(dz1, X)db1 = 1 / m * np.sum(dz1, axis=1)grads = {"dw1": dw1, "db1": db1, "dw2": dw2, "db2": db2}return gradsdef update_parameters(params, grads, learning_rate=0.005):w1 = params["w1"]w2 = params["w2"]b1 = params["b1"]b2 = params["b2"]dw1 = grads["dw1"]dw2 = grads["dw2"]db1 = grads["db1"]db2 = grads["db2"]# 更新w1 = w1 - learning_rate * dw1b1 = b1 - learning_rate * db1w2 = w2 - learning_rate * dw2b2 = b2 - learning_rate * db2parameters = {"w1": w1,"w2": w2,"b1": b1,"b2": b2}return parametersdef nn_model(X, Y, num_iterations=1000):n_x, n_h, n_y = layer_size(X, Y)param = initialize_parameters(n_x, n_h, n_y)for i in range(0, num_iterations):# 前向A2, cache = (forward_propagation(X, param))# 计算损失cost = compute_cost(A2, Y, param)# 反向grads = backward_propagation(param, cache, X, Y)# 更新param = update_parameters(param, grads)return paramdef predict(X, parameters):A2, cache = (forward_propagation(X, parameters))predictions = np.array([1 if x>0.5 else 0 for x in A2.reshape(-1 , 1)]).reshape(A2.shape)print(A2)return predictionsif __name__ == "__main__":params = nn_model(X, Y, 1000)predictions = predict(X , params)print("Predictions:", predictions)