一 引入
训练自己的神经网络需要选择参数的初始值，一个好的初始化方法将会有助于神经网络的训练。并且能够加速梯度下降的收敛。现在我们就通过实验来看下不同初始化方法对神经网络模型表现的影响。
二 神经网络的搭建
为了避免重复语句，我们将一些激活函数定义为函数形式。
1 sigmoid函数
def sigmoid(x):
s = 1 / (1 + np.exp(-x))
return s2 relu函数
def relu(x):
s = np.maximum(0, x)
return s神经网络训练包括前向传播和反向传播两个过程，将其定义为函数。
1 前向传播
def forward_propagation(X, parameters):
W1 = parameters["W1"] #parameters中有各层参数，下面会讲到如何初始化这些参数
b1 = parameters["b1"]
W2 = parameters["W2"]
b2 = parameters["b2"]
W3 = parameters["W3"]
b3 = parameters["b3"]
#激活函数分别是 relu relu sigmoid
z1 = np.dot(W1, X) + b1
a1 = relu(z1)
z2 = np.dot(W2, a1) + b2
a2 = relu(z2)
z3 = np.dot(W3, a2) + b3
a3 = sigmoid(z3)
#将各层参数存储到cache中,反向传播要用到这些单数
cache = (z1, a1, W1, b1, z2, a2, W2, b2, z3, a3, W3, b3)
#返回最后输出结果及cache
return a3, cache神经网络包括三层，最终输出a3。
2 反向传播
通过反向传播来更新参数，使得损失最小。
def backward_propagation(X, Y, cache):
m = X.shape[1]
(z1, a1, W1, b1, z2, a2, W2, b2, z3, a3, W3, b3) = cache
dz3 = 1. / m * (a3 - Y) #下一张图有推导 参考吴恩达深度学习课程
#求出各参数的偏导数
dW3 = np.dot(dz3, a2.T)
db3 = np.sum(dz3, axis=1, keepdims=True)
da2 = np.dot(W3.T, dz3)
dz2 = np.multiply(da2, np.int64(a2 > 0))
dW2 = np.dot(dz2, a1.T)
db2 = np.sum(dz2, axis=1, keepdims=True)
da1 = np.dot(W2.T, dz2)
dz1 = np.multiply(da1, np.int64(a1 > 0))
dW1 = np.dot(dz1, X.T)
db1 = np.sum(dz1, axis=1, keepdims=True)
#封装为字典返回
gradients = {"dz3": dz3, "dW3": dW3, "db3": db3,
"da2": da2, "dz2": dz2, "dW2": dW2, "db2": db2,
"da1": da1, "dz1": dz1, "dW1": dW1, "db1": db1}
return gradients3 更新参数
经过反向传播的计算，需要对参数进行更新。
def update_parameters(parameters, grads, learning_rate):
L = len(parameters) // 2 # 每层有两个参数
# 对每层的参数进行更新
for k in range(L):
parameters["W" + str(k + 1)] = parameters["W" + str(k + 1)] - learning_rate * grads["dW" + str(k + 1)]
parameters["b" + str(k + 1)] = parameters["b" + str(k + 1)] - learning_rate * grads["db" + str(k + 1)]
#将参数返回
return parameters 4 计算成本函数
def compute_loss(a3, Y):
m = Y.shape[1]
#利用交叉熵计算训练成本
logprobs = np.multiply(-np.log(a3), Y) + np.multiply(-np.log(1 - a3), 1 - Y)
loss = 1. / m * np.nansum(logprobs)
#返回成本
return loss5 导入数据
def load_dataset():
np.random.seed(1)
#生成样本数据
train_X, train_Y = sklearn.datasets.make_circles(n_samples=300, noise=.05)
np.random.seed(2)
test_X, test_Y = sklearn.datasets.make_circles(n_samples=100, noise=.05)
# 可视化数据
plt.scatter(train_X[:, 0], train_X[:, 1], c=train_Y, s=40, cmap=plt.cm.Spectral);
train_X = train_X.T
train_Y = train_Y.reshape((1, train_Y.shape[0]))
test_X = test_X.T
test_Y = test_Y.reshape((1, test_Y.shape[0]))
return train_X, train_Y, test_X, test_Y6 预测准确度
def predict(X, y, parameters):
m = X.shape[1]
p = np.zeros((1, m), dtype=np.int)
a3, caches = forward_propagation(X, parameters)
for i in range(0, a3.shape[1]):
if a3[0, i] > 0.5:
p[0, i] = 1
else:
p[0, i] = 0
print("Accuracy: " + str(np.mean((p[0, :] == y[0, :]))))
return p以上代码可以存放到一个init_utils.py文件中，另外加上导入的包代码。
import numpy as np
import matplotlib.pyplot as plt
import h5py
import sklearn
import sklearn.datasets
三 各种初始化方法的训练及测试
在训练和测试前，定义一个模板函数，方便调用。
import numpy as np
import matplotlib.pyplot as plt
import sklearn
import sklearn.datasets
from init_utils import sigmoid, relu, compute_loss, forward_propagation, backward_propagation
from init_utils import update_parameters, predict, load_dataset, plot_decision_boundary, predict_dec
def model(X,Y,learning_rate = 0.01,num_iterations=15000,print_cost=True,initialization = "he"):
grads = {}
costs = []
m = X.shape[1]
layers_dims = [X.shape[0],10,5,1] #神经网络各层参数维度
if initialization == "zeros": # 零值初始化
parameters = initialize_parameters_zeros(layers_dims)
elif initialization == "random": #随机初始化
parameters = initialize_parameters_random(layers_dims)
elif initialization == "he":
parameters = initialize_parameters_he(layers_dims)
for i in range(0,num_iterations): #he初始化
a3,cache = forward_propagation(X,parameters)
cost = compute_loss(a3,Y)
grads = backward_propagation(X,Y,cache)
parameters = update_parameters(parameters,grads,learning_rate)
if print_cost and i%1000 == 0:
print("Cost after iteration {}: {}".format(i, cost))
costs.append(cost)
plt.plot(costs) #画出cost随训练迭代次数
plt.ylabel('cost')
plt.xlabel('iterations (per hundreds)')
plt.title("Learning rate =" + str(learning_rate))
plt.show()
return parameters1 zeros初始化
def initialize_parameters_zeros(layers_dims):
parameters = {}
L = len(layers_dims)
for l in range(1,L):
#确定每层节点的维度 根据维度将参数初始化为0
parameters['W' + str(l)] = np.zeros((layers_dims[l], layers_dims[l - 1]))
parameters['b' + str(l)] = np.zeros((layers_dims[l], 1))
return parameters开始训练，输出训练结果。
#获取训练和测试数据
train_X, train_Y, test_X, test_Y = load_dataset()
parameters = model(train_X, train_Y, initialization = "zeros")
#输出训练结果
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
#输出测试结果
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
随着迭代次数，cost变化。
将其用图描绘出来
可以看出用zeros初始化参数，训练效果并不很好。
在训练集上准确率只有0.5，测试集上也只有0.5。在zeros初始下，所有节点学到的东西都一样，没有打破对称性。其效果并不比逻辑回归效果好多少。
2 random初始化
parameters = model(train_X, train_Y, initialization = "random")
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
parameters = initialize_parameters_random([3, 2, 1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
随着迭代次数，cost变化。
随机初始化可以看出随着迭代次数的增加，cost在减少，效果比zeros初始化明显。用图片来显示。
经过14000次迭代，loss降为0.38左右。
训练和测试准确率也分别上升到0.83和0.86。事实上随机初始化的参数过大，对性能表现也有影响。来看下这次随机初始化的参数为多少：
3 he初始化（至于为啥叫这个名字百度吧）
parameters = model(train_X, train_Y, initialization = "he")
print ("On the train set:")
predictions_train = predict(train_X, train_Y, parameters)
print ("On the test set:")
predictions_test = predict(test_X, test_Y, parameters)
parameters = initialize_parameters_he([3, 2, 1])
print("W1 = " + str(parameters["W1"]))
print("b1 = " + str(parameters["b1"]))
print("W2 = " + str(parameters["W2"]))
print("b2 = " + str(parameters["b2"]))
来看下随着迭代次数，cost如何变化。
可以看出he初始化，效果显著。
准确率也大幅度上升。
看这次参数初始化为多少：
参数比random初始化小了近10倍，可以看出，参数小效果更好。
四 总结
通过如下表格比较各初始化方法的表现
| Model | 准确率 | 问题/评论 |
| 3-layer NN with zeros initialization | 0.5 | 准确率低 |
| 3-layer NN with large random initialization | 0.83 | 权重太大 |
| 3-layer NN with He initialization | 0.99 | 值得推荐的方法 |
1 不同的初始化方法会得到不同的结果，神经网络中参数的初始值会影响最终的结果
2 随机初始化能够打破对称，且能够使隐藏层学到不同的东西
3 参数初始化的值不要过大
4 he 初始化在使用relu激活函数表现的很好