欢迎来到你的第三周编程作业。是时候建立你的第一个神经网络了,它将有一个隐藏的层。您将会看到这个模型和您使用逻辑回归实现的模型有很大的不同。
在这篇文章中,我们会讲到以下的知识:
- 构建具有单隐藏层的二分类神经网络。
- 使用具有非线性激活功能激活函数,例如tanh。
- 计算交叉熵损失(损失函数)。
- 实现向前和向后传播。
1-准备软件包
我们需要准备一些软件包:
numpy:是用Python进行科学计算的基本软件包。
sklearn:为数据挖掘和数据分析提供的简单高效的工具。
matplotlib :是一个用于在Python中绘制图表的库。
testCases:提供了一些测试示例来评估函数的正确性,参见下载的资料或者在底部查看它的代码。
planar_utils :提供了在这个任务中使用的各种有用的功能,参见下载的资料或者在底部查看它的代码。
# Package imports
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
from functools import reduce
import operator
%matplotlib inline
np.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.shape
shape_Y = Y.shape
m = 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 classifier
clf = 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 accuracy
LR_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 -定义神经网络结构
练习:定义三个变量:
- n_x: 输入层的数量
- n_h: 隐藏层的数量(这里设置为4)
- n_y: 输出层的数量
提示:使用X和Y的维度来查找n_x和n_y。
# GRADED FUNCTION: layer_sizes
def 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 = 5
The size of the hidden layer is: n_h = 4
The 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_parameters
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) # 指定一个随机种子,以便你的输出与我们一样
### 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_propagation
def 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_cost
def 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_propagation
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]
# 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个[]表示维度为2
db2 = [[ 0.06589489]]
练习:实施更新规则。
使用梯度下降,您必须使用(dW1,db1,dW2,db2)才能更新(W1,b1,W2,b2),更新算法如下:
我们需要选择一个良好的学习速率,我们可以看一下下面这两个图(由Adam Harley提供):
上面两个图分别代表了具有良好学习速率(收敛)和不良学习速率(发散)的梯度下降算法。
# GRADED FUNCTION: update_parameters
def 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_model
def 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: predict
def 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 layer
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.reshape(-1,))
plt.title("Decision Boundary for hidden layer size " + str(4))
Cost after iteration 0: 0.693048
Cost after iteration 1000: 0.288083
Cost after iteration 2000: 0.254385
Cost after iteration 3000: 0.233864
Cost after iteration 4000: 0.226792
Cost after iteration 5000: 0.222644
Cost after iteration 6000: 0.219731
Cost after iteration 7000: 0.217504
Cost after iteration 8000: 0.219504
Cost after iteration 9000: 0.218571
Text(0.5,1,'Decision Boundary for hidden layer size 4')
打印准确性
# Print accuracy
predictions = 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 run
plt.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-在其他数据集上的性能
可选问题:
如果愿意,您可以探索一些可选的/未分级的问题:
- 当改变sigmoid激活或ReLU激活的tanh激活时会发生什么?
- 改变learning_rate的数值会发生什么
- 如果我们改变数据集呢?
# Datasets
noisy_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 binary
if 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 %