本文共 17293 字,大约阅读时间需要 57 分钟。
欢迎来到你的第三周编程作业。是时候建立你的第一个神经网络了,它将有一个隐藏的层。您将会看到这个模型和您使用逻辑回归实现的模型有很大的不同。
在这篇文章中,我们会讲到以下的知识:
1-准备软件包
我们需要准备一些软件包:
numpy:是用Python进行科学计算的基本软件包。
sklearn:为数据挖掘和数据分析提供的简单高效的工具。 matplotlib :是一个用于在Python中绘制图表的库。 testCases:提供了一些测试示例来评估函数的正确性,参见下载的资料或者在底部查看它的代码。 planar_utils :提供了在这个任务中使用的各种有用的功能,参见下载的资料或者在底部查看它的代码。# Package importsimport numpy as npimport matplotlib.pyplot as pltfrom testCases import *import sklearnimport sklearn.datasetsimport sklearn.linear_modelfrom planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasetsfrom functools import reduceimport operator%matplotlib inlinenp.random.seed(1) # 设置一个固定的随机种子,以保证接下来的步骤中我们的结果是一致的
2 -数据集
首先,我们来看看我们将要使用的数据集, 下面的代码会将一个花的图案的二类数据集加载到变量X和Y中。
X, Y = load_planar_dataset()
把数据集加载完成了,然后使用matplotlib可视化数据集,代码如下:
# Visualize the data:plt.scatter(X[0, :], X[1, :], c=Y.reshape(-1,), s=40, cmap=plt.cm.Spectral);
结果:
数据看起来像一朵红色(y = 0)和一些蓝色(y = 1)的数据点的花朵的图案。 我们的目标是建立一个模型来适应这些数据。现在,我们已经有了以下的东西:
X:一个numpy的矩阵,包含了这些数据点的数值
Y:一个numpy的向量,对应着的是X的标签【0 | 1】(红色:0 , 蓝色 :1)练习:你有多少个训练示例?此外,变量的维度是多少?
### START CODE HERE ### (≈ 3 lines of code)shape_X = X.shapeshape_Y = Y.shapem = X.shape[1] # 训练集里面的数量### END CODE HERE ###print ('The shape of X is: ' + str(shape_X))print ('The shape of Y is: ' + str(shape_Y))print ('I have m = %d training examples!' % (m))
结果:
The shape of X is: (2, 400)The shape of Y is: (1, 400)I have m = 400 training examples!
3 -简单逻辑回归
在建立一个完整的神经网络之前,让我们先看看逻辑回归是如何处理这个问题的。您可以使用sklearn的内置函数来实现这一点。运行下面的代码,在数据集上训练逻辑回归分类器。
# Train the logistic regression classifierclf = sklearn.linear_model.LogisticRegressionCV();clf.fit(X.T, Y.T.reshape(-1,));
现在,您可以绘制这些模型的决策边界。运行下面的代码。
# 绘制决策边界plot_decision_boundary(lambda x: clf.predict(x), X, Y.reshape(-1,))plt.title("Logistic Regression") #图标题# Print accuracyLR_predictions = clf.predict(X.T) #预测结果print ('Accuracy of logistic regression: %d ' % float((np.dot(Y,LR_predictions) + np.dot(1-Y,1-LR_predictions))/float(Y.size)*100) + '% ' + "(percentage of correctly labelled datapoints)")
结果:(逻辑回归的准确性: 47 % (正确标记的数据点所占的百分比))
Accuracy of logistic regression: 47 % (percentage of correctly labelled datapoints)
解释:准确性只有47%的原因是数据集不是线性可分的,所以逻辑回归表现不佳,现在我们正式开始构建神经网络。
4 -神经网络模型
逻辑回归在“花卉数据集”上效果不佳。你要训练一个只有一个隐藏层的神经网络。
构建神经网络的一般方法是:
1. 定义神经网络结构(输入单元的数量,隐藏单元的数量等)。 2. 初始化模型的参数 3. 循环:最后我们要它们合并到一个nn_model() 函数中,当我们构建好了nn_model()并学习了正确的参数,我们就可以预测新的数据。
4.1 -定义神经网络结构
练习:定义三个变量:
提示:使用X和Y的维度来查找n_x和n_y。
# GRADED FUNCTION: layer_sizesdef layer_sizes(X, Y): """ 参数: X - 输入数据集,维度为(输入的数量,训练/测试的数量) Y - 标签,维度为(输出的数量,训练/测试数量) 返回: n_x - 输入层的数量 n_h - 隐藏层的数量 n_y - 输出层的数量 """ ### START CODE HERE ### (≈ 3 lines of code) n_x = X.shape[0] # 输入层 n_h = 4 # 隐藏层,硬编码为4 n_y = Y.shape[0] # 输出层 ### END CODE HERE ### return (n_x, n_h, n_y)
测试:
X_assess, Y_assess = layer_sizes_test_case()(n_x, n_h, n_y) = layer_sizes(X_assess, Y_assess)print("The size of the input layer is: n_x = " + str(n_x))print("The size of the hidden layer is: n_h = " + str(n_h))print("The size of the output layer is: n_y = " + str(n_y))
结果:(三个层的节点数量)
The size of the input layer is: n_x = 5The size of the hidden layer is: n_h = 4The size of the output layer is: n_y = 2
4.2 -初始化模型的参数
练习:实现函数initialize_parameters()。
说明: 确保您的参数大小正确。如果需要,请参考上面的神经网络图。
np.random.randn(a,b)* 0.01
来随机初始化一个维度为(a,b)的矩阵。np.zeros((a,b))
用零初始化矩阵(a,b)。# GRADED FUNCTION: initialize_parametersdef 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) # 指定一个随机种子,以便你的输出与我们一样 ### START CODE HERE ### (≈ 4 lines of code) 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)) ### END CODE HERE ### # 使用断言确保我的数据格式是正确的 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
测试:
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"]))
结果:
W1 = [[-0.00416758 -0.00056267] [-0.02136196 0.01640271] [-0.01793436 -0.00841747] [ 0.00502881 -0.01245288]]b1 = [[ 0.] [ 0.] [ 0.] [ 0.]]W2 = [[-0.01057952 -0.00909008 0.00551454 0.02292208]]b2 = [[ 0.]]
4.3 -循环
练习:实现前向传播函数forward_propagation()
说明: 请看上面分类器的数学表示。 我们可以使用sigmoid()函数,也可以使用np.tanh()函数。
步骤如下:使用字典类型的parameters(它是initialize_parameters() 的输出)检索每个参数。
实现向前传播, 计算Z[1],A[1],Z[2]和 A[2]( 训练集里面所有例子的预测向量)。 反向传播所需的值存储在“cache”中,cache将作为反向传播函数的输入。# GRADED FUNCTION: forward_propagationdef forward_propagation(X, parameters): """ 参数: X - 维度为(n_x,m)的输入数据。 parameters - 初始化函数(initialize_parameters)的输出 返回: A2 - 使用sigmoid()函数计算的第二次激活后的数值 cache - 包含“Z1”,“A1”,“Z2”和“A2”的字典类型变量 """ # 从字典“参数”中检索每个参数 ### START CODE HERE ### (≈ 4 lines of code) W1 = parameters["W1"] # 根据对应的键值获取相应的参数 b1 = parameters["b1"] W2 = parameters["W2"] b2 = parameters["b2"] ### END CODE HERE ### # 前向传播计算A2 ### START CODE HERE ### (≈ 4 lines of code) Z1 = np.dot(W1 , X) + b1 A1 = np.tanh(Z1) Z2 = np.dot(W2 , A1) + b2 A2 = sigmoid(Z2) ### END CODE HERE ### #使用断言确保我的数据格式是正确的 assert(A2.shape == (1, X.shape[1])) cache = {"Z1": Z1, "A1": A1, "Z2": Z2, "A2": A2} return A2, cache
测试:
X_assess, parameters = forward_propagation_test_case()A2, cache = forward_propagation(X_assess, parameters)# Note: we use the mean here just to make sure that your output matches ours. print(np.mean(cache['Z1']) ,np.mean(cache['A1']),np.mean(cache['Z2']),np.mean(cache['A2']))
结果:
-0.000499755777742 -0.000496963353232 0.000438187450959 0.500109546852
现在我们已经计算了A[2],a[2](i)包含了训练集里每个数值,现在我们就可以构建成本函数了。
练习:实现compute_cost()
来计算成本的值 J
有很多的方法都可以计算交叉熵损失,比如下面的这个公式,我们在python中可以这么实现:
logprobs = np.multiply(np.log(A2),Y)cost = - np.sum(logprobs) # 不需要使用循环就可以直接算出来。
当然,你也可以使用 np.multiply()
然后使用 np.sum()
或者直接使用 np.dot()
# GRADED FUNCTION: compute_costdef compute_cost(A2, Y, parameters): """ 计算方程(6)中给出的交叉熵成本, 参数: A2 - 使用sigmoid()函数计算的第二次激活后的数值 Y - "True"标签向量,维度为(1,数量) parameters - 一个包含W1,B1,W2和B2的字典类型的变量 返回: 成本 - 交叉熵成本给出方程(13) """ m = Y.shape[1] # number of example # 计算成本 ### START CODE HERE ### (≈ 2 lines of code) logprobs = np.multiply(np.log(A2),Y) + np.multiply(np.log(1 - A2),1 - Y) cost = - np.sum(logprobs)/m ### END CODE HERE ### cost = np.squeeze(cost) # makes sure cost is the dimension we expect. # E.g., turns [[17]] into 17 assert(isinstance(cost, float)) return cost
测试:
A2, Y_assess, parameters = compute_cost_test_case()print("cost = " + str(compute_cost(A2, Y_assess, parameters)))
结果:
cost = 0.692919893776
使用前向传播期间计算的cache,现在可以利用它实现反向传播。
练习:实现反向传播函数backward_propagation()
.
说明:反向传播通常是深度学习中最难(数学意义)部分,为了帮助你,这里有反向传播讲座的幻灯片, 由于我们正在构建向量化实现,因此我们将需要使用这下面的六个方程:
为了计算dZ1,里需要计算 g[1]′(Z[1]), g[1](...) 是tanh激活函数,如果a=g[1](z)那么g[1]′(z)=1−a2。所以我们需要使用 (1 - np.power(A1, 2))来计算g[1]′(Z[1]) 。
# GRADED FUNCTION: backward_propagationdef backward_propagation(parameters, cache, X, Y): """ 使用上述说明搭建反向传播函数。 参数: parameters - 包含我们的参数的一个字典类型的变量。 cache - 包含“Z1”,“A1”,“Z2”和“A2”的字典类型的变量。 X - 输入数据,维度为(2,数量) Y - “True”标签,维度为(1,数量) 返回: grads - 包含W和b的导数一个字典类型的变量。 """ m = X.shape[1] # First, retrieve W1 and W2 from the dictionary "parameters". ### START CODE HERE ### (≈ 2 lines of code) W1 = parameters["W1"] # 在字典中获取对应参数 W2 = parameters["W2"] ### END CODE HERE ### # Retrieve also A1 and A2 from dictionary "cache". ### START CODE HERE ### (≈ 2 lines of code) A1 = cache["A1"] A2 = cache["A2"] ### END CODE HERE ### # 反向传播:计算 dW1, db1, dW2, db2. ### START CODE HERE ### (≈ 6 lines of code, corresponding to 6 equations on slide above) dZ2 = A2 - Y dW2 = (1 / m) * np.dot(dZ2, A1.T) db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True) # keepdims是为了保持矩阵的维度特性 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) ### END CODE HERE ### grads = {"dW1": dW1, "db1": db1, "dW2": dW2, "db2": db2} return grads
测试:
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"]))
结果:
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]] # 2个[]表示维度为2db2 = [[ 0.06589489]]
练习:实施更新规则。
使用梯度下降,您必须使用(dW1,db1,dW2,db2)才能更新(W1,b1,W2,b2),更新算法如下:
我们需要选择一个良好的学习速率,我们可以看一下下面这两个图(由Adam Harley提供):
上面两个图分别代表了具有良好学习速率(收敛)和不良学习速率(发散)的梯度下降算法。
# GRADED FUNCTION: update_parametersdef update_parameters(parameters, grads, learning_rate = 1.2): """ 使用上面给出的梯度下降更新规则更新参数 参数: parameters - 包含参数的字典类型的变量。 grads - 包含导数值的字典类型的变量。 learning_rate - 学习速率 返回: parameters - 包含更新参数的字典类型的变量。 """ # Retrieve each parameter from the dictionary "parameters" ### START CODE HERE ### (≈ 4 lines of code) W1 = parameters["W1"] b1 = parameters["b1"] W2 = parameters["W2"] b2 = parameters["b2"] ### END CODE HERE ### # Retrieve each gradient from the dictionary "grads" ### START CODE HERE ### (≈ 4 lines of code) dW1 = grads["dW1"] db1 = grads["db1"] dW2 = grads["dW2"] db2 = grads["db2"] ## END CODE HERE ### # 为每个参数更新规则 ### START CODE HERE ### (≈ 4 lines of code) W1 -= learning_rate * dW1 b1 -= learning_rate * db1 W2 -= learning_rate * dW2 b2 -= learning_rate * db2 ### END CODE HERE ### parameters = {"W1": W1, "b1": b1, "W2": W2, "b2": b2} return 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"]))
结果:
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]]
4.4 -在nn_model()中集成4.1、4.2和4.3
练习:在nn_model()中建立你的神经网络模型。 说明:神经网络模型必须以正确的顺序使用前面的函数。
# GRADED FUNCTION: nn_modeldef nn_model(X, Y, n_h, num_iterations = 10000, 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] # Initialize parameters, then retrieve W1, b1, W2, b2. Inputs: "n_x, n_h, n_y". Outputs = "W1, b1, W2, b2, parameters". ### START CODE HERE ### (≈ 5 lines of code) parameters = initialize_parameters(n_x, n_h, n_y) W1 = parameters["W1"] b1 = parameters["b1"] W2 = parameters["W2"] b2 = parameters["b2"] ### END CODE HERE ### # Loop (gradient descent) for i in range(0, num_iterations): ### START CODE HERE ### (≈ 4 lines of code) # Forward propagation. Inputs: "X, parameters". Outputs: "A2, cache". A2, cache = forward_propagation(X, parameters) # Cost function. Inputs: "A2, Y, parameters". Outputs: "cost". cost = compute_cost(A2, Y, parameters) # Backpropagation. Inputs: "parameters, cache, X, Y". Outputs: "grads". grads = backward_propagation(parameters, cache, X, Y) # Gradient descent parameter update. Inputs: "parameters, grads". Outputs: "parameters". parameters = update_parameters(parameters, grads) ### END CODE HERE ### # Print the cost every 1000 iterations if print_cost and i % 1000 == 0: print ("Cost after iteration %i: %f" %(i, cost)) return parameters
测试:
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"]))
结果:
W1 = [[-4.18494482 5.33220319] [-7.52989354 1.24306197] [-4.19295428 5.32631786] [ 7.52983748 -1.24309404]]b1 = [[ 2.32926815] [ 3.7945905 ] [ 2.33002544] [-3.79468791]]W2 = [[-6033.83672179 -6008.12981272 -6033.10095329 6008.06636901]]b2 = [[-52.66607704]]
4.5-预测
练习:通过构建 predict() 来使用您的模型进行预测。使用正向传播来预测结果。
# GRADED FUNCTION: predictdef predict(parameters, X): """ 使用学习的参数,为X中的每个示例预测一个类 参数: parameters - 包含参数的字典类型的变量。 X - 输入数据(n_x,m) 返回 predictions - 我们模型预测的向量(红色:0 /蓝色:1) """ # 使用正向传播计算概率,并使用0.5作为阈值分类为0/1 ### START CODE HERE ### (≈ 2 lines of code) A2, cache = forward_propagation(X, parameters) predictions = np.round(A2) # 进行四舍五入 ### END CODE HERE ### return predictions
测试:
parameters, X_assess = predict_test_case()predictions = predict(parameters, X_assess)print("predictions mean = " + str(np.mean(predictions)))
结果:
predictions mean = 0.666666666667
现在我们把所有的东西基本都做完了,我们开始正式用浅层神经网络训练数据。
# Build a model with a n_h-dimensional hidden layerparameters = nn_model(X, Y, n_h = 4, num_iterations = 10000, print_cost=True)# 绘制边界plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y.reshape(-1,))plt.title("Decision Boundary for hidden layer size " + str(4))
Cost after iteration 0: 0.693048Cost after iteration 1000: 0.288083Cost after iteration 2000: 0.254385Cost after iteration 3000: 0.233864Cost after iteration 4000: 0.226792Cost after iteration 5000: 0.222644Cost after iteration 6000: 0.219731Cost after iteration 7000: 0.217504Cost after iteration 8000: 0.219504Cost after iteration 9000: 0.218571Text(0.5,1,'Decision Boundary for hidden layer size 4')
打印准确性
# Print accuracypredictions = predict(parameters, X)print ('Accuracy: %d' % float((np.dot(Y,predictions.T) + np.dot(1-Y,1-predictions.T))/float(Y.size)*100) + '%')
结果:
Accuracy: 90%
与逻辑回归相比,精确度非常高。这个模型已经学会了花的图案!与逻辑回归不同,神经网络甚至能够学习高度非线性的决策边界。 现在,让我们尝试几个隐藏的层大小。
4.6 -调整隐藏层大小(可选/未分级练习)
运行以下代码。可能需要1-2分钟。对于不同的隐藏层大小,您将观察到模型的不同行为。
# This may take about 2 minutes to runplt.figure(figsize=(16, 32))hidden_layer_sizes = [1, 2, 3, 4, 5, 10, 20] # 隐藏层数量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.reshape(-1,)) predictions = predict(parameters, X) accuracy = float((np.dot(Y,predictions.T) + np.dot(1-Y,1-predictions.T))/float(Y.size)*100) print ("Accuracy for {} hidden units: {} %".format(n_h, accuracy))
结果:
Accuracy for 1 hidden units: 67.5 %Accuracy for 2 hidden units: 67.25 %Accuracy for 3 hidden units: 90.75 %Accuracy for 4 hidden units: 90.5 %Accuracy for 5 hidden units: 91.25 % # 此时准确度最好Accuracy for 10 hidden units: 90.25 %Accuracy for 20 hidden units: 90.0 % # 出现过拟合的情况
解释:
较大的模型(具有更多隐藏单元)能够更好地适应训练集,直到最终的最大模型过度拟合数据。
最好的隐藏层大小似乎在n_h = 5附近。实际上,这里的值似乎很适合数据,而且不会引起过度拟合。 我们还将在后面学习有关正则化的知识,它允许我们使用非常大的模型(如n_h = 50),而不会出现太多过度拟合。
5-在其他数据集上的性能
可选问题:
如果愿意,您可以探索一些可选的/未分级的问题:
# Datasetsnoisy_circles, noisy_moons, blobs, gaussian_quantiles, no_structure = load_extra_datasets()datasets = {"noisy_circles": noisy_circles, "noisy_moons": noisy_moons, "blobs": blobs, "gaussian_quantiles": gaussian_quantiles}### START CODE HERE ### (choose your dataset)dataset = "gaussian_quantiles"### END CODE HERE ###X, Y = datasets[dataset]X, Y = X.T, Y.reshape(1, Y.shape[0])# make blobs binaryif dataset == "blobs": Y = Y%2# 可视化数据plt.scatter(X[0, :], X[1, :], c=Y.flatten(), s=40, cmap=plt.cm.Spectral);
结果:
重新运行 4.6 中的代码,得到结果:
Accuracy for 1 hidden units: 68.5 %Accuracy for 2 hidden units: 79.0 %Accuracy for 3 hidden units: 96.5 %Accuracy for 4 hidden units: 97.5 %Accuracy for 5 hidden units: 96.5 %Accuracy for 10 hidden units: 100.0 % # 当隐藏层的神经元个数>5时,准确度可以达到100%Accuracy for 20 hidden units: 100.0 %
转载地址:http://tpuvi.baihongyu.com/