神经网络|吴恩达深度学习 1.3神经网络和深度学习-浅层神经网络神经网络|深度学习

1. 知识点：

神经网络的表示：输入层、隐藏层、输出层???????

??????????????

文章图片
???????

文章图片

???????????

文章图片
(应该用上标表示神经网络的层，上面手写的不规范)的维度，以

文章图片
为例，应为（4,3），4为隐藏层神经元的个数，3为输入层神经元的个数。??????????????

神经网络的梯度下降法

参数：

文章图片

【神经网络|吴恩达深度学习 1.3神经网络和深度学习-浅层神经网络】输入层元素个数：

文章图片

隐藏层神经元个数：

文章图片

输出层神经元个数：

文章图片

文章图片
的维度应为（

文章图片
）,以实现W可以和i-1层神经元进行运算，并得到i层神经元个数。
参数和中间变量的偏导数，吴恩达老师给出了公式。其推导过程和逻辑回归相似，即对构造的损失函数一层一层求导。道理我都懂，但自己盲推推导不出来。先参考公式吧。??????????????

文章图片
??????? ?????????????????????????????????????????????

激活函数tanh、sigmoid、ReLU、Leaky ReLU

文章图片

2. 编程实例：用逻辑回归和浅层神经网络预测平面上点的分类。

实现思路：

用逻辑回归（sklearn包）训练样本数据，预测平面上点的分类，计算预测准确率。
搭建浅层神经网络，训练样本数据，预测平面上点的分类，计算预测准确率：

1)定义输入层、隐藏层、输出层神经元（无素）的个数。
2)由每一层神经元的个数，初如化模型参数W、b。
3)前向传播，由输入数据X和参数W、b，计算输出A2，其中间步骤的输出Z1?A1?Z2。
4)计算成本，依然用交叉熵cost=-1/m(Ylog(A2)+(1-Y)log(1-A2))。
5)后向传播，计算参数W、b的导数值（用知识点里的公式）。
6)梯度下降，用计算出的参数导数值更新参数W、b。
7)用训练好的模型预测平面上点的分布。
8)调整隐藏层神经元的个数，感受隐藏层神经元的个数对训练结果的影响。

#引入包计算、绘图 sklearn包 import numpy as np import matplotlib.pyplot as plt from testCases import * import sklearn import sklearn.datasets import sklearn.linear_model from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets#%matplotlib inline #如果你使用用的是Jupyter Notebook的话请取消注释。np.random.seed(1) #设置一个固定的随机种子，以保证接下来的步骤中我们的结果是一致的。

#加载数据生成和加载数据的方法由吴恩达老师提供，网上可下载 X, Y = load_planar_dataset()

#plt.scatter(X[0, :], X[1, :], c=Y, s=40, cmap=plt.cm.Spectral) #绘制散点图# 上一语句如出现问题，请使用下面的语句： plt.scatter(X[0, :], X[1, :], c=np.squeeze(Y), s=40, cmap=plt.cm.Spectral) #绘制散点图

文章图片

shape_X = X.shape shape_Y = Y.shape m = Y.shape[1]# 训练集里面的数量print ("X的维度为: " + str(shape_X)) #print ("X=: " ) #print(X) print ("Y的维度为: " + str(shape_Y)) print ("数据集里面的数据有：" + str(m) + " 个")

X的维度为: (2, 400) Y的维度为: (1, 400) 数据集里面的数据有：400 个

#用sklearn的逻辑回归模型 clf = sklearn.linear_model.LogisticRegressionCV()#用前面加载的数据训练模型 clf.fit(X.T,Y.T)

/usr/local/lib/python3.7/site-packages/sklearn/utils/validation.py:760: DataConversionWarning: A column-vector y was passed when a 1d array was expected. Please change the shape of y to (n_samples, ), for example using ravel(). y = column_or_1d(y, warn=True)
Out[5]:

LogisticRegressionCV(Cs=10, class_weight=None, cv=None, dual=False, fit_intercept=True, intercept_scaling=1.0, l1_ratios=None, max_iter=100, multi_class='auto', n_jobs=None, penalty='l2', random_state=None, refit=True, scoring=None, solver='lbfgs', tol=0.0001, verbose=0)

#由逻辑回归训练出的模型估计X、Y区域内点的分类 plot_decision_boundary(lambda x: clf.predict(x), X, Y) #绘制决策边界 plt.title("Logistic Regression") #图标题 LR_predictions= clf.predict(X.T) #预测结果 print ("逻辑回归的准确性： %d " % float((np.dot(Y, LR_predictions) + np.dot(1 - Y,1 - LR_predictions)) / float(Y.size) * 100) + "% " + "(正确标记的数据点所占的百分比)")

逻辑回归的准确性： 47 % (正确标记的数据点所占的百分比)

文章图片
???????

#定义浅层神经网络每一层神经元的数量 def layer_sizes(X , Y): """ 参数： X - 输入数据集,维度为（输入的数量，训练/测试的数量） Y - 标签，维度为（输出的数量，训练/测试数量）返回： n_x - 输入层的数量 n_h - 隐藏层的数量 n_y - 输出层的数量 """ n_x = X.shape[0] #输入层 n_h = 4 #，隐藏层，硬编码为4 n_y = Y.shape[0] #输出层return (n_x,n_h,n_y)

#测试layer_sizes print("=========================测试layer_sizes=========================") X_asses , Y_asses = layer_sizes_test_case() (n_x,n_h,n_y) =layer_sizes(X_asses,Y_asses) print("输入层的节点数量为: n_x = " + str(n_x)) print("隐藏层的节点数量为: n_h = " + str(n_h)) print("输出层的节点数量为: n_y = " + str(n_y))

=========================测试layer_sizes========================= 输入层的节点数量为: n_x = 5 隐藏层的节点数量为: n_h = 4 输出层的节点数量为: n_y = 2

#由每一层神经元的个数，定义和初始化模型参数 def initialize_parameters( n_x , n_h ,n_y): """ 参数： n_x - 输入层节点的数量 n_h - 隐藏层节点的数量 n_y - 输出层节点的数量返回： parameters - 包含参数的字典： W1 - 权重矩阵,维度为（n_h，n_x） b1 - 偏向量，维度为（n_h，1） W2 - 权重矩阵，维度为（n_y，n_h） b2 - 偏向量，维度为（n_y，1）""" np.random.seed(2) #指定一个随机种子，以便你的输出与我们的一样。 W1 = np.random.randn(n_h,n_x) * 0.01 b1 = np.zeros(shape=(n_h, 1)) W2 = np.random.randn(n_y,n_h) * 0.01 b2 = np.zeros(shape=(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

#测试initialize_parameters print("=========================测试initialize_parameters=========================") n_x , n_h , n_y = initialize_parameters_test_case() parameters = initialize_parameters(n_x , n_h , n_y) print("W1 = " + str(parameters["W1"])) print("b1 = " + str(parameters["b1"])) print("W2 = " + str(parameters["W2"])) print("b2 = " + str(parameters["b2"]))

=========================测试initialize_parameters========================= W1 = [[-0.00416758 -0.00056267] [-0.021361960.01640271] [-0.01793436 -0.00841747] [ 0.00502881 -0.01245288]] b1 = [[0.] [0.] [0.] [0.]] W2 = [[-0.01057952 -0.009090080.005514540.02292208]] b2 = [[0.]]

#浅层神经网络的前向传播 def forward_propagation( X , parameters ): """ 参数： X - 维度为（n_x，m）的输入数据。 parameters - 初始化函数（initialize_parameters）的输出返回： A2 - 使用sigmoid()函数计算的第二次激活后的数值 cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典类型变量 """ W1 = parameters["W1"] b1 = parameters["b1"] W2 = parameters["W2"] b2 = parameters["b2"] #前向传播计算A2 Z1 = np.dot(W1 , X) + b1 A1 = np.tanh(Z1) Z2 = np.dot(W2 , A1) + b2 A2 = sigmoid(Z2) #使用断言确保我的数据格式是正确的 assert(A2.shape == (1,X.shape[1])) cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2}return (A2, cache)

#测试forward_propagation print("=========================测试forward_propagation=========================") X_assess, parameters = forward_propagation_test_case() A2, cache = forward_propagation(X_assess, parameters) print(np.mean(cache["Z1"]), np.mean(cache["A1"]), np.mean(cache["Z2"]), np.mean(cache["A2"])) #print("W1.shape="+str(W1.shape)) print("X=",X_assess) print("X.shape="+str(X_assess.shape)) #print("X.shape[1]="+str(X_assess.shape[1])) print("A1.shape="+str(cache["A1"].shape)) print("A2.shape="+str(A2.shape)) #print("X=",X) print("A2=",A2)

=========================测试forward_propagation========================= -0.0004997557777419913 -0.0004969633532317802 0.0004381874509591466 0.500109546852431 X= [[ 1.62434536 -0.61175641 -0.52817175] [-1.072968620.86540763 -2.3015387 ]] X.shape=(2, 3) A1.shape=(4, 3) A2.shape=(1, 3) A2= [[0.50023070.49985831 0.50023963]]

#计算损失函数 def compute_cost(A2,Y,parameters): """ 计算交叉熵成本，参数： A2 - 使用sigmoid()函数计算的第二次激活后的数值 Y - "True"标签向量,维度为（1，数量） parameters - 一个包含W1，B1，W2和B2的字典类型的变量返回：成本 - 交叉熵成本给出方程（13） """m = Y.shape[1] W1 = parameters["W1"] W2 = parameters["W2"]#计算成本 logprobs = logprobs = np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2)) cost = - np.sum(logprobs) / m cost = float(np.squeeze(cost))assert(isinstance(cost,float))return cost

#测试compute_cost print("=========================测试compute_cost=========================") A2 , Y_assess , parameters = compute_cost_test_case() print("cost = " + str(compute_cost(A2,Y_assess,parameters)))

=========================测试compute_cost========================= cost = 0.6929198937761266

#反向传播，即用知识点里给出的公式，计算模型参数的导数 def backward_propagation(parameters,cache,X,Y): """ 使用上述说明搭建反向传播函数。参数： parameters - 包含我们的参数的一个字典类型的变量。 cache - 包含“Z1”，“A1”，“Z2”和“A2”的字典类型的变量。 X - 输入数据，维度为（2，数量） Y - “True”标签，维度为（1，数量）返回： grads - 包含W和b的导数一个字典类型的变量。 """ m = X.shape[1]W1 = parameters["W1"] W2 = parameters["W2"]A1 = cache["A1"] A2 = cache["A2"]dZ2= A2 - Y dW2 = (1 / m) * np.dot(dZ2, A1.T) db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True) dZ1 = np.multiply(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 = {"dW1": dW1, "db1": db1, "dW2": dW2, "db2": db2 }return grads

#测试backward_propagation print("=========================测试backward_propagation=========================") parameters, cache, X_assess, Y_assess = backward_propagation_test_case()grads = backward_propagation(parameters, cache, X_assess, Y_assess) print ("dW1 = "+ str(grads["dW1"])) print ("db1 = "+ str(grads["db1"])) print ("dW2 = "+ str(grads["dW2"])) print ("db2 = "+ str(grads["db2"]))

=========================测试backward_propagation========================= dW1 = [[ 0.01018708 -0.00708701] [ 0.00873447 -0.0060768 ] [-0.005308470.00369379] [-0.022063650.01535126]] db1 = [[-0.00069728] [-0.00060606] [ 0.000364] [ 0.00151207]] dW2 = [[ 0.003636130.031536040.01162914 -0.01318316]] db2 = [[0.06589489]]

#用计算出的模型参数导数更新参数值 def update_parameters(parameters,grads,learning_rate=1.2): """ 使用上面给出的梯度下降更新规则更新参数参数： parameters - 包含参数的字典类型的变量。 grads - 包含导数值的字典类型的变量。 learning_rate - 学习速率返回： parameters - 包含更新参数的字典类型的变量。 """ W1,W2 = parameters["W1"],parameters["W2"] b1,b2 = parameters["b1"],parameters["b2"]dW1,dW2 = grads["dW1"],grads["dW2"] db1,db2 = grads["db1"],grads["db2"]W1 = W1 - learning_rate * dW1 b1 = b1 - learning_rate * db1 W2 = W2 - learning_rate * dW2 b2 = b2 - learning_rate * db2parameters = {"W1": W1, "b1": b1, "W2": W2, "b2": b2}return parameters

#测试update_parameters print("=========================测试update_parameters=========================") parameters, grads = update_parameters_test_case() parameters = update_parameters(parameters, grads)print("W1 = " + str(parameters["W1"])) print("b1 = " + str(parameters["b1"])) print("W2 = " + str(parameters["W2"])) print("b2 = " + str(parameters["b2"]))

=========================测试update_parameters========================= W1 = [[-0.006430250.01936718] [-0.024104580.03978052] [-0.01653973 -0.02096177] [ 0.01046864 -0.05990141]] b1 = [[-1.02420756e-06] [ 1.27373948e-05] [ 8.32996807e-07] [-3.20136836e-06]] W2 = [[-0.01041081 -0.044632850.017580310.04747113]] b2 = [[0.00010457]]

#整合浅层神经网络模型 def nn_model(X,Y,n_h,num_iterations,print_cost=False): """ 参数： X - 数据集,维度为（2，示例数） Y - 标签，维度为（1，示例数） n_h - 隐藏层的数量 num_iterations - 梯度下降循环中的迭代次数 print_cost - 如果为True，则每1000次迭代打印一次成本数值返回： parameters - 模型学习的参数，它们可以用来进行预测。 """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(num_iterations): #正向 A2 , cache = forward_propagation(X,parameters)#损失函数 cost = compute_cost(A2,Y,parameters)#计算梯度 grads = backward_propagation(parameters,cache,X,Y)#梯度下降 parameters = update_parameters(parameters,grads,learning_rate = 0.5)if print_cost: if i%1000 == 0: print("第 ",i," 次循环，成本为："+str(cost)) return parameters

#测试nn_model print("=========================测试nn_model=========================") X_assess, Y_assess = nn_model_test_case()parameters = nn_model(X_assess, Y_assess, 4, num_iterations=10000, print_cost=False) print("W1 = " + str(parameters["W1"])) print("b1 = " + str(parameters["b1"])) print("W2 = " + str(parameters["W2"])) print("b2 = " + str(parameters["b2"]))

=========================测试nn_model=========================

/usr/local/lib/python3.7/site-packages/ipykernel_launcher.py:19: RuntimeWarning: divide by zero encountered in log /Users/shucl/wuenda/planar_utils.py:30: RuntimeWarning: overflow encountered in exp s = 1/(1+np.exp(-x))

W1 = [[-3.891677674.77541602] [-6.779603381.20272585] [-3.883389664.78028666] [ 6.77958203 -1.20272574]] b1 = [[ 2.11530892] [ 3.41221357] [ 2.11585732] [-3.41221322]] W2 = [[-2512.9093032-2502.70799785 -2512.016559692502.65264416]] b2 = [[-22.29071761]]

#用训练好的模型预测平面上点的分类 def predict(parameters,X): """ 使用学习的参数，为X中的每个示例预测一个类参数： parameters - 包含参数的字典类型的变量。 X - 输入数据（n_x，m）返回 predictions - 我们模型预测的向量（红色：0 /蓝色：1）""" A2 , cache = forward_propagation(X,parameters) predictions = np.round(A2)return predictions

#测试predict print("=========================测试predict=========================")parameters, X_assess = predict_test_case()predictions = predict(parameters, X_assess) print("预测的平均值 = " + str(np.mean(predictions)))

=========================测试predict========================= 预测的平均值 = 0.6666666666666666

parameters = nn_model(X, Y, n_h = 4, num_iterations=10000, print_cost=True)#绘制边界 plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y) plt.title("Decision Boundary for hidden layer size " + str(4))predictions = predict(parameters, X) print ('准确率: %d' % float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100) + '%')

第0次循环，成本为：0.6930480201239823 第1000次循环，成本为：0.3098018601352803 第2000次循环，成本为：0.2924326333792646 第3000次循环，成本为：0.2833492852647412 第4000次循环，成本为：0.27678077562979253 第5000次循环，成本为：0.2634715508859331 第6000次循环，成本为：0.24204413129940774 第7000次循环，成本为：0.23552486626608768 第8000次循环，成本为：0.2314096450985428 第9000次循环，成本为：0.22846408048352365 准确率: 90%

文章图片

#感受隐藏层神经元的个数对模型训练效果的影响 plt.figure(figsize=(16, 32)) hidden_layer_sizes = [1, 2, 3, 4, 5, 20, 50] #隐藏层数量 for i, n_h in enumerate(hidden_layer_sizes): plt.subplot(5, 2, i + 1) plt.title('Hidden Layer of size %d' % n_h) parameters = nn_model(X, Y, n_h, num_iterations=5000) plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y) predictions = predict(parameters, X) accuracy = float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100) print ("隐藏层的节点数量： {}，准确率: {} %".format(n_h, accuracy))

隐藏层的节点数量： 1，准确率: 67.25 % 隐藏层的节点数量： 2，准确率: 66.5 % 隐藏层的节点数量： 3，准确率: 89.25 % 隐藏层的节点数量： 4，准确率: 90.0 % 隐藏层的节点数量： 5，准确率: 89.75 % 隐藏层的节点数量： 20，准确率: 90.0 % 隐藏层的节点数量： 50，准确率: 89.75 %

文章图片
???????