浅层神经网络简介
浅层神经网络通常指仅含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 |
 |
输出可解释为概率，适合二分类输出层 | 梯度消失（当 ∣z∣∣z∣ 较大时，导数接近0）。 输出非零中心化（均值不为0），影响梯度下降效率。 |
Tanh |
 |
零中心化输出，梯度下降更稳定比Sigmoid梯度更强（导数最大值为1） |
仍有梯度消失问题（但比Sigmoid轻） |
ReLU |
 |
计算高效（无指数运算） 缓解梯度消失（正区间梯度恒为1） |
“死亡ReLU”问题（负输入永远不激活） |
浅层神经网络反向传播
反向传播是神经网络训练的核心算法，用于计算损失函数对网络参数的梯度（即权重和偏置的导数），从而通过梯度下降优化参数。
而在单隐层的浅层神经网络中，可以看作分两步进行的反向传播。
浅层神经网络python代码实现
import numpy as np
X = 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 sig
def layer_size(X, Y):
# 输入层大小(特征数量）
n_x = X.shape[1]
# 隐层大小（神经元个数）
n_h = 4
# 输出层大小
n_y = 1
return (n_x, n_h, n_y)
def initialize_parameters(n_x, n_h, n_y):
# 隐层参数w1,b1
w1 = np.random.randn(n_h, n_x) * 0.01
b1 = np.zeros((n_h, 1))
# 输出层参数w2，b2
w2 = np.random.randn(n_y, n_h) * 0.01
b2 = np.zeros((n_y, 1))
params = {"w1": w1, "b1": b1, "w2": w2, "b2": b2}
return params
def forward_propagation(X, params):
w1 = params["w1"]
b1 = params["b1"]
w2 = params["w2"]
b2 = params["b2"]
# 第一层
Z1 = np.dot(w1, X.T) + b1
A1 = np.tanh(Z1)
# 第二层
Z2 = np.dot(w2, A1) + b2
A2 = sigmoid(Z2)
cache = {"Z1": Z1,
"A1": A1,
"Z2": Z2,
"A2": A2}
return A2 , cache
def 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 cost
def 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 - Y
dw2 = 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 grads
def 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 * dw1
b1 = b1 - learning_rate * db1
w2 = w2 - learning_rate * dw2
b2 = b2 - learning_rate * db2
parameters = {"w1": w1,
"w2": w2,
"b1": b1,
"b2": b2}
return parameters
def 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 param
def 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 predictions
if __name__ == "__main__":
params = nn_model(X, Y, 1000)
predictions = predict(X , params)
print("Predictions:", predictions)