【吴恩达深度学习编程作业】1.3浅层神经网络——单隐藏层的平面数据分类

第二次跟着 带有一个隐藏层的平面数据分类 把作业代码码了一遍，感觉思路更加清晰了。今天刚刚填报了国家保研系统中的基本信息，最近的学习状态很差，是时候沉下心来认真学习了。

main.py

# 搭建一个单隐藏层的神经网络 import numpy as np import matplotlib.pyplot as plt import sklearn # 为数据挖掘和数据分析提供的简单高效的工具 import sklearn.datasets import sklearn.linear_model from Deep_Learning.testCases import * # 提供一些测试示例来评估函数的正确性 from Deep_Learning.planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets # 提供在本实例中使用的各种有用的功能 np.random.seed(1) # 设置一个固定的随机种子，以保证接下来的步骤中我们的结果是一致的 # 加载和查看数据集 # 将一个花的图案的2类数据集加载到变量X和Y中 X, Y = load_planar_dataset() # 可视化数据集 plt.scatter(X[0, :], X[1, :], c=np.squeeze(Y), s=40, cmap=plt.cm.Spectral) # 绘制散点图 plt.show() # 数据看起来是由红色（y=0）和蓝色（y=1）的数据点的组成的花朵，我们的目标是建立一个模型适应这些数据 # 我们已有X（一个numpy的矩阵，包含这些数据点的数值），Y：（一个numpy的向量，对应着的是X的标签【0|1】（红色：0，蓝色：1）） shape_X = X.shape shape_Y = Y.shape m = Y.shape[1] # 训练集里面的数量 print("X的维度为：" + str(shape_X)) print("Y的维度为：" + str(shape_Y)) print("数据集里面的数据有：" + str(m)) # 训练数据集上的逻辑回归分类器 clf = sklearn.linear_model.LogisticRegressionCV() clf.fit(X.T, Y.T) # 绘制逻辑分类器的分类 plot_decision_boundary(lambda x: clf.predict(x), X, np.squeeze(Y)) # 绘制决策边界 plt.title("Logistic Regression") # 图标题 LR_predictions = clf.predict(X.T) # 预测结果 plt.show() 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): """ :param X: -输入数据集，维度为（输入的数量，训练/测试的数量） :param Y: -标签，维度为（输出的数量，训练/测试数量） :return: 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)) # 初始化模型的参数 def initialize_parameters(n_x, n_h, n_y): """ :param n_x: -输入层节点的数量 :param n_h: -隐藏层节点的数量 :param n_y: -输出层节点的数量 :return: 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.rand(n_h, n_x) * 0.01 b1 = np.zeros(shape=(n_h, 1)) W2 = np.random.rand(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"])) # 实现前向传播 def forword_propagation(X, parameters): """ :param X: -维度为（n_x, m）的输入数据 :param parameters: -初始化函数（initialize_parameters）的输出 :return: 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) # 测试forword_propagation print("=======================测试forword_propagation=====================") X_asses, parameters = forward_propagation_test_case() A2, cache = forword_propagation(X_asses, parameters) print(np.mean(cache["Z1"]), np.mean(cache["A1"]), np.mean(cache["Z2"]), np.mean(cache["A2"])) # 计算损失 # 计算交叉熵损失 # logprobs = np.multiply(np.log(A2), Y) # cost = -np.sum(logprobs) # 不需要使用循环就可以直接计算 # 构建计算成本函数 def compute_cost(A2, Y, parameters): """ :param A2: -使用sigmoid函数计算的第二次激活后的数值 :param Y: -"True"标签向量，维度为（1，数量） :param parameters: -一个包含W1,b1,W2,b2的字典类型的变量 :return: cost -交叉熵成本 """ m = Y.shape[1] W1 = parameters["W1"] W2 = parameters["W2"] # 计算成本 logprobs = np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2)) np.seterr(divide='ignore', invalid='ignore') # 忽略除以0的情况，消除警告 cost = - np.sum(logprobs) / m cost = float(np.squeeze(cost)) assert (isinstance(cost, float)) return cost # 测试compute_cost print("========================测试compute_cost======================") A2, Y_asses, parameters = compute_cost_test_case() print("cost = " + str(compute_cost(A2, Y_asses, parameters))) # 反向传播 def backward_propagation(parameters, cache, X, Y): """ :param parameters: -包含我们的参数的一个字典类型的变量 :param cache: -包含"Z1","A1","Z2","A2"的字典类型的变量 :param X: -输入数据，维度为（2，数量） :param Y: -"True"标签向量，维度为（1，数量） :return: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)) # 激活函数为tanh，其导数为1-a^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_asses, Y_asses = backward_propagation_test_case() grads = backward_propagation(parameters, cache, X_asses, Y_asses) print("dW1 = " + str(grads["dW1"])) print("db1 = " + str(grads["db1"])) print("dW2 = " + str(grads["dW2"])) print("db2 = " + str(grads["db2"])) # 更新参数 def update_parameters(parameters, grads, learning_rate=1.2): """ 使用梯度下降更新规则更新参数 :param parameters: -包含参数的字典类型的变量 :param grads: -包含导数值的字典类型的变量 :param learning_rate: -学习速率 :return: 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 * db2 parameters = {"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"])) # 将所有的函数整合到一个model中 def nn_model(X, Y, n_h, num_iterations, print_cost=False): """ :param X: -数据集，维度为（2，示例数） :param Y: -标签，维度为（1，示例数） :param n_h: -隐藏层的数量 :param num_iterations: -梯度下降循环中的迭代次数 :param print_cost: -如果为True，则每1000次迭代打印一次成本数值 :return: 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 = forword_propagation(X, parameters) cost = compute_cost(A2, Y, parameters) grads = backward_propagation(parameters, cache, X, Y) parameters = update_parameters(parameters, grads, learning_rate=1.2) if print_cost: if i % 1000 == 0: print("第", i, "次循环，成本为：" + str(cost)) return parameters # 测试nn_model print("====================测试nn_model=======================") X_asses, Y_asses = nn_model_test_case() parameters = nn_model(X_asses, Y_asses, 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"])) # 使用前向传播预测结果 def predict(parameters, X): """ 使用学习的参数，为X中的每一个示例预测一个类 :param parameters: -包含参数的字典类型的变量 :param X: -输入数据（n_x, m） :return: predictions -模型预测的向量（红色：0|蓝色：1） """ A2, cache = forword_propagation(X, parameters) predictions = np.round(A2) # round函数近似取值 return predictions # 测试predict print("=======================测试predict======================") parameters, X_asses = predict_test_case() predictions = predict(parameters, X_asses) print("预测的平均值 = " + str(np.mean(predictions))) # 正式运行 parameters = nn_model(X, Y, n_h=4, num_iterations=10000, print_cost=True) # 绘制边界 plot_decision_boundary(lambda x: predict(parameters, x.T), X, np.squeeze(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) + '%') plt.show() # 更改隐藏层节点数量，以上测试中隐藏层节点数为4 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(3, 3, 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)) plt.show() # 较大的模型（具有更多隐藏单元）能够更好地适应训练集，直到最终的最大模型过度拟合数据。 # 最好的隐藏层大小似乎在n_h = 5附近，这里的值似乎很适合数据，而且不会引起过度拟合。

planar_utils.py

import matplotlib.pyplot as plt import numpy as np import sklearn import sklearn.datasets import sklearn.linear_model def plot_decision_boundary(model, X, y): # Set min and max values and give it some padding x_min, x_max = X[0, :].min() - 1, X[0, :].max() + 1 y_min, y_max = X[1, :].min() - 1, X[1, :].max() + 1 h = 0.01 # Generate a grid of points with distance h between them xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h)) # Predict the function value for the whole grid Z = model(np.c_[xx.ravel(), yy.ravel()]) Z = Z.reshape(xx.shape) # Plot the contour and training examples plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral) plt.ylabel('x2') plt.xlabel('x1') plt.scatter(X[0, :], X[1, :], c=np.squeeze(y), cmap=plt.cm.Spectral) def sigmoid(x): """ 当x是一个非常小的负数时，exp(-x)会过大，导致溢出，下面进行优化： 原式分子分母同乘exp(x)这个很小的数，可以防止数据溢出 """ # if x >= 0: # s = 1.0 / (1 + np.exp(-x)) # else: # s = np.exp(x) / (1 + np.exp(x)) s = 1 / (1 + np.exp(-x)) return s def load_planar_dataset(): np.random.seed(1) m = 400 # number of examples N = int(m/2) # number of points per class D = 2 # dimensionality X = np.zeros((m,D)) # data matrix where each row is a single example Y = np.zeros((m,1), dtype='uint8') # labels vector (0 for red, 1 for blue) a = 4 # maximum ray of the flower for j in range(2): ix = range(N*j,N*(j+1)) t = np.linspace(j*3.12,(j+1)*3.12,N) + np.random.randn(N)*0.2 # theta r = a*np.sin(4*t) + np.random.randn(N)*0.2 # radius X[ix] = np.c_[r*np.sin(t), r*np.cos(t)] Y[ix] = j X = X.T Y = Y.T return X, Y def load_extra_datasets(): N = 200 noisy_circles = sklearn.datasets.make_circles(n_samples=N, factor=.5, noise=.3) noisy_moons = sklearn.datasets.make_moons(n_samples=N, noise=.2) blobs = sklearn.datasets.make_blobs(n_samples=N, random_state=5, n_features=2, centers=6) gaussian_quantiles = sklearn.datasets.make_gaussian_quantiles(mean=None, cov=0.5, n_samples=N, n_features=2, n_classes=2, shuffle=True, random_state=None) no_structure = np.random.rand(N, 2), np.random.rand(N, 2) return noisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure

testCases.py

#-*- coding: UTF-8 -*- """ # WANGZHE12 """ import numpy as np def layer_sizes_test_case(): np.random.seed(1) X_assess = np.random.randn(5, 3) Y_assess = np.random.randn(2, 3) return X_assess, Y_assess def initialize_parameters_test_case(): n_x, n_h, n_y = 2, 4, 1 return n_x, n_h, n_y def forward_propagation_test_case(): np.random.seed(1) X_assess = np.random.randn(2, 3) parameters = {'W1': np.array([[-0.00416758, -0.00056267], [-0.02136196, 0.01640271], [-0.01793436, -0.00841747], [ 0.00502881, -0.01245288]]), 'W2': np.array([[-0.01057952, -0.00909008, 0.00551454, 0.02292208]]), 'b1': np.array([[ 0.], [ 0.], [ 0.], [ 0.]]), 'b2': np.array([[ 0.]])} return X_assess, parameters def compute_cost_test_case(): np.random.seed(1) Y_assess = np.random.randn(1, 3) parameters = {'W1': np.array([[-0.00416758, -0.00056267], [-0.02136196, 0.01640271], [-0.01793436, -0.00841747], [ 0.00502881, -0.01245288]]), 'W2': np.array([[-0.01057952, -0.00909008, 0.00551454, 0.02292208]]), 'b1': np.array([[ 0.], [ 0.], [ 0.], [ 0.]]), 'b2': np.array([[ 0.]])} a2 = (np.array([[ 0.5002307 , 0.49985831, 0.50023963]])) return a2, Y_assess, parameters def backward_propagation_test_case(): np.random.seed(1) X_assess = np.random.randn(2, 3) Y_assess = np.random.randn(1, 3) parameters = {'W1': np.array([[-0.00416758, -0.00056267], [-0.02136196, 0.01640271], [-0.01793436, -0.00841747], [ 0.00502881, -0.01245288]]), 'W2': np.array([[-0.01057952, -0.00909008, 0.00551454, 0.02292208]]), 'b1': np.array([[ 0.], [ 0.], [ 0.], [ 0.]]), 'b2': np.array([[ 0.]])} cache = {'A1': np.array([[-0.00616578, 0.0020626 , 0.00349619], [-0.05225116, 0.02725659, -0.02646251], [-0.02009721, 0.0036869 , 0.02883756], [ 0.02152675, -0.01385234, 0.02599885]]), 'A2': np.array([[ 0.5002307 , 0.49985831, 0.50023963]]), 'Z1': np.array([[-0.00616586, 0.0020626 , 0.0034962 ], [-0.05229879, 0.02726335, -0.02646869], [-0.02009991, 0.00368692, 0.02884556], [ 0.02153007, -0.01385322, 0.02600471]]), 'Z2': np.array([[ 0.00092281, -0.00056678, 0.00095853]])} return parameters, cache, X_assess, Y_assess def update_parameters_test_case(): parameters = {'W1': np.array([[-0.00615039, 0.0169021 ], [-0.02311792, 0.03137121], [-0.0169217 , -0.01752545], [ 0.00935436, -0.05018221]]), 'W2': np.array([[-0.0104319 , -0.04019007, 0.01607211, 0.04440255]]), 'b1': np.array([[ -8.97523455e-07], [ 8.15562092e-06], [ 6.04810633e-07], [ -2.54560700e-06]]), 'b2': np.array([[ 9.14954378e-05]])} grads = {'dW1': np.array([[ 0.00023322, -0.00205423], [ 0.00082222, -0.00700776], [-0.00031831, 0.0028636 ], [-0.00092857, 0.00809933]]), 'dW2': np.array([[ -1.75740039e-05, 3.70231337e-03, -1.25683095e-03, -2.55715317e-03]]), 'db1': np.array([[ 1.05570087e-07], [ -3.81814487e-06], [ -1.90155145e-07], [ 5.46467802e-07]]), 'db2': np.array([[ -1.08923140e-05]])} return parameters, grads def nn_model_test_case(): np.random.seed(1) X_assess = np.random.randn(2, 3) Y_assess = np.random.randn(1, 3) return X_assess, Y_assess def predict_test_case(): np.random.seed(1) X_assess = np.random.randn(2, 3) parameters = {'W1': np.array([[-0.00615039, 0.0169021 ], [-0.02311792, 0.03137121], [-0.0169217 , -0.01752545], [ 0.00935436, -0.05018221]]), 'W2': np.array([[-0.0104319 , -0.04019007, 0.01607211, 0.04440255]]), 'b1': np.array([[ -8.97523455e-07], [ 8.15562092e-06], [ 6.04810633e-07], [ -2.54560700e-06]]), 'b2': np.array([[ 9.14954378e-05]])} return parameters, X_assess

运行结果

X的维度为：(2, 400) Y的维度为：(1, 400) 数据集里面的数据有：400 F:\Python\lib\site-packages\sklearn\utils\validation.py:73: 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(). return f(**kwargs) 逻辑回归的准确性：47%(正确标记的数据点所占的百分比) ========================测试layer_sizes=========================== 输入层的节点数量为：n_x = 5 隐藏层的节点数量为：n_h = 4 输出层的节点数量为：n_y = 2 =====================测试initialize_parameters========================= W1 = [[0.00435995 0.00025926] [0.00549662 0.00435322] [0.00420368 0.00330335] [0.00204649 0.00619271]] b1 = [[0.] [0.] [0.] [0.]] W2 = [[0.00299655 0.00266827 0.00621134 0.00529142]] b2 = [[0.]] =======================测试forword_propagation===================== -0.0004997557777419913 -0.0004969633532317802 0.0004381874509591466 0.500109546852431 ========================测试compute_cost====================== cost = 0.6929198937761266 =======================测试backward_propagation====================== dW1 = [[ 0.01018708 -0.00708701] [ 0.00873447 -0.0060768 ] [-0.00530847 0.00369379] [-0.02206365 0.01535126]] db1 = [[-0.00069728] [-0.00060606] [ 0.000364 ] [ 0.00151207]] dW2 = [[ 0.00363613 0.03153604 0.01162914 -0.01318316]] db2 = [[0.06589489]] ======================测试update_parameters====================== W1 = [[-0.00643025 0.01936718] [-0.02410458 0.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.04463285 0.01758031 0.04747113]] b2 = [[0.00010457]] ====================测试nn_model======================= G:\Project\PYTHON\Demo01\Deep_Learning\planar_utils.py:33: RuntimeWarning: overflow encountered in exp s = 1 / (1 + np.exp(-x)) W1 = [[ 7.52965472 -1.24309301] [ 4.21291395 -5.31399817] [ 7.52966135 -1.2431499 ] [ 4.21397291 -5.31333161]] b1 = [[-3.79468532] [-2.32838083] [-3.79485646] [-2.3283009 ]] W2 = [[6006.88570125 6032.88338564 6007.41279754 6032.66790904]] b2 = [[-53.17690741]] =======================测试predict====================== 预测的平均值 = 0.6666666666666666 第 0 次循环，成本为：0.6931586620054873 第 1000 次循环，成本为：0.289307766073059 第 2000 次循环，成本为：0.2738595561686524 第 3000 次循环，成本为：0.238115797061788 第 4000 次循环，成本为：0.22810205919496226 第 5000 次循环，成本为：0.22331808633565126 第 6000 次循环，成本为：0.220192917928194 第 7000 次循环，成本为：0.21786964182913665 第 8000 次循环，成本为：0.21603567135242685 第 9000 次循环，成本为：0.21863707045894862 准确率：90% 隐藏层的节点数量：1，准确率67.5% 隐藏层的节点数量：2，准确率67.25% 隐藏层的节点数量：3，准确率90.75% 隐藏层的节点数量：4，准确率90.75% 隐藏层的节点数量：5，准确率91.25% 隐藏层的节点数量：20，准确率90.0% 隐藏层的节点数量：50，准确率91.0%

依次显示的图片

原始数据集： 简单逻辑回归分类： 四个隐藏层的神经网络分类结果： 不同隐藏层的神经网络分类结果：

目前仍然存在的问题：

sigmoid函数需要优化

RuntimeWarning: overflow encountered in exp s = 1 / (1 + np.exp(-x))

代码存在警告，但可以正常运行

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(). return f(**kwargs)