本章将利用numpy搭建一个单隐层的神经网络，选择2个输入单元，4个隐藏单元和2个输出单元。
神经网络的搭建由以下六个步骤完成：
1、定义神经网络结构
2、初始化模型参数（w和b）
3、前向传播算法结构设计
4、损失函数定义
5、反向传播算法结构设计
6、权值迭代与更新算法结构设计
7、封装代码，整合模型便于直接调用
在进行神经网络的构建之前，首先需要定义神经网络的结构
网络结构的定义
伪代码
def 结构函数（样本集，标签集）
定义输入层神经元个数
定义隐层神经元个数（这里我们简单设置单元数为4）
定义输出层神经元个数
return （输入层神经元个数，隐层神经元个数，输出层神经元个数）
程序实现
def layer_sizes(X, Y):
n_x = X.shape[0]
n_h = 4
n_y = Y.shape[0]
return (n_x, n_h, n_y)
接着，需要初始化我们的模型参数
【回顾】
权值w：连接层与层之间各神经元间的权重
偏置单元b：隐层、输出层作为输出时加上的偏值
初始化模型参数
伪代码如下：
def 初始化模型参数（输入层神经元个数，隐层神经元个数，输出层神经元个数）
权值1 = <输入层单元→隐层>间的权值参数（用于计算w*x）
偏值1 = <隐层偏置单元>加上的偏值(b，用于计算w*x + b)
权值2 = <隐层→输出层>间的权值参数（用于计算w*hid_x）
偏值2 = <输出层偏置单元>加上的偏值（b2, 用于计算w*hid_x + b）
将初始化的参数放入数据字典pararameters{}
return parameters
程序实现
def initialize_parameters(n_x, n_h, n_y):
#这里之所以n_h在前，n_x在后，因为w是根据隐层单元个数决定了行数，列数由输入层单元决定
#这里在w的初始化中用到了random随机数生成方法
#在b的初始化中用到了zeros方法
W1 = np.random.randn(n_h, n_x)*0.01
b1 = np.zeros((n_h, 1))
W2 = np.random.randn(n_y, n_h)*0.01
b2 = np.zeros((n_y, 1))
assert (W1.shape == (n_h, n_x))
assert (b1.shape == (n_h, 1))
assert (W2.shape == (n_y, n_h))
assert (b2.shape == (n_y, 1))
parameters = {"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2}
return parameters
以上就是前期的准备工作，当准备工作完成后，就可以开始神经网络算法核心部分——前向传播，损失计算与反向传播的构建了
前向传播函数构建
【回顾】
隐层原始数据：接收输入层的数据X，对其作加权w1处理，并加上偏值b1
隐层**函数：选择tanh双曲正切函数
隐层输出数据：Z1 = tanh（隐层原始数据）
输出层原始数据：接收隐层传出的数据Z1，对其作加权w2处理，并加上偏值b2
输出层**函数：Sigmoid函数（可调用numpy的，也可使用自定义的）
输出层预测结果：Z2 = sigmoid（输出层原始数据）
伪代码如下：
def 前向传播算法（样本集X，初始化的字典parameters{}）
输入→隐层权值W1 = 参数字典["W1"]
隐层偏值b1 = 参数字典["b1"]
隐层→输出层权值W2 = 参数字典["W2"]
输出层偏值b2 = 参数字典["b2"]
隐层原始数据Z1 = W1 * X + b1
隐层输出数据A1 = tanh(Z1)
输出层原始数据Z2 = W2 * A1 + b2
输出层预测结果A2 = sigmoid（Z1）
将计算后的Z1, A1, Z2, A2保存到数据字典cache里
return cache
程序清单
def forward_propagation(X, parameters):
# Retrieve each parameter from the dictionary "parameters"
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
# Implement Forward Propagation to calculate A2 (probabilities)
Z1 = np.dot(W1, X) + b1
A1 = np.tanh(Z1)
Z2 = np.dot(W2, Z1) + b2
A2 = sigmoid(Z2)
assert(A2.shape == (1, X.shape[1]))
cache = {"Z1": Z1,
"A1": A1,
"Z2": Z2,
"A2": A2}
return A2, cache
损失函数计算（无正则化约束）
这里的损失函数采用交叉熵损失
伪代码如下
def 定义损失函数（预测输出A2，标签值Y，参数集合parameters）
m = 样本个数
logprobs = 计算Y*log(A2) + （1-Y）*log(1-A2)
损失函数 = -1/m * sum(logprobs)
return 损失函数
程序清单
def compute_cost(A2, Y, parameters):
m = Y.shape[1] # number of example
#计算交叉熵
logprobs = np.multiply(np.log(A2),Y) + np.multiply(np.log(1-A2), 1-Y)
cost = -1/m * np.sum(logprobs)
#对cost的结果进行处理，squeeze用于删除多余的维度
cost = np.squeeze(cost)
assert(isinstance(cost, float))
return cost
反向传播算法的实现
当前向传播和当前损失确定之后，就需要继续执行反向传播过程来调整权值和偏值了。这里涉及到了梯度下降算法，具体的公式步骤如下：
伪代码如下：
def 反向传播算法（参数字典parameters, 隐、输出层输出集合cache, 样本集X, 标签集Y）
m = 样本个数
W1 = 参数字典parameters['W1']——输入层→隐层权值W1
W2 = 参数字典parameters['W2']——隐层→输出层权值W2
A1 = 输出字典cache['A1']——隐层输出结果A1
A2 = 输出字典cache['A2']——输出层预测结果A2
#执行梯度下降
Z2偏导 = A2 - Y
W2偏导 = 1/m * (Z2偏导 * A1)
b2偏导 = 1/m * sum(Z2偏导)
Z1偏导 = W2*Z2偏导*(1-(A1^2))
W1偏导 = 1/m * (Z1偏导 * X)
b1偏导 = 1/m * sum(Z1偏导)
将结果W2偏导、W1偏导、b2偏导、b1偏导存入梯度字典grads
return grads
程序清单
def backward_propagation(parameters, cache, X, Y):
m = X.shape[1]
# 首先从参数字典parameters中提取W1和W2的权值
W1 = parameters['W1']
W2 = parameters['W2']
# 再从输出字典cache中提取隐层输出和输出层输出的输出值A1和A2
A1 = cache['A1']
A2 = cache['A2']
#反向传播（梯度下降）求解：dW1, db1, dW2, db2.
dZ2 = A2-Y
dW2 = 1/m * np.dot(dZ2, A1.T)
db2 = 1/m * np.sum(dZ2, axis=1, keepdims=True)
dZ1 = np.dot(W2.T, dZ2)*(1-np.power(A1, 2))
dW1 = 1/m * np.dot(dZ1, X.T)
db1 = 1/m * np.sum(dZ1, axis=1, keepdims=True)
#存储进梯度字典grads
grads = {"dW1": dW1,
"db1": db1,
"dW2": dW2,
"db2": db2}
return grads
将梯度下降处理后的权值更新
我们需要将已经进行梯度下降处理的新梯度反馈给隐层、输出层各神经元计算
程序清单：
def update_parameters(parameters, grads, learning_rate = 1.2):
#通过parameters字典传参给对应的权值、偏值
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
#通过grads字典传参给对应变化求导后的权值、偏值
dW1 = grads['dW1']
db1 = grads['db1']
dW2 = grads['dW2']
db2 = grads['db2']
#更新权值，步长为learning_rate=1.2
W1 -= dW1 * learning_rate
b1 -= db1 * learning_rate
W2 -= dW2 * learning_rate
b2 -= db2 * learning_rate
#将更新后的权值和偏值重新存入数据字典parameters（覆盖原来的）
parameters = {"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2}
return parameters
整合模型便于调用
def nn_model(X, Y, n_h, num_iterations = 10000, print_cost=False):
np.random.seed(3)
n_x = layer_sizes(X, Y)[0]
n_y = layer_sizes(X, Y)[2]
parameters = initialize_parameters(n_x, n_h, n_y)
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2']
#开始循环迭代使用梯度下降算法，计算最优权值和偏值
for i in range(0, num_iterations):
#调用前向传播：输入样本集X和参数字典parameters，输出A2和输出数据字典cache
A2, cache = forward_propagation(X, parameters)
# 调用损失函数：输入A2，Y和parameters，输出损失cost
cost = compute_cost(A2, Y, parameters)
#调用反向传播：输入parameters, cache, X和Y，输出梯度字典grads
grads = backward_propagation(parameters, cache, X, Y)
#梯度（参数）更新： 输入parameters, grads，输出更新后的参数字典parameters
parameters = update_parameters(parameters, grads, learning_rate=1.2)
#该过程迭代1000次
if print_cost and i % 1000 == 0:
print ("Cost after iteration %i: %f" %(i, cost))
return parameters
以上就是一套完整的利用numpy搭建单隐层神经网络的实现过程。参考于公众号：数据科学家养成记