def layer_sizes(X, Y, n_h = 4):

n_x = X.shape[0] #输入层

n_h = n_h#，隐藏层

n_y = Y.shape[0] #输出层

return (n_x,n_h,n_y)

def initialize_parameters( n_x , n_h ,n_y):

#Please add something

np.random.seed(2)

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))

parameters = {

'w1':w1,

'w2': w2,

'b1': b1,

'b2': b2,

}

return parameters

def forward_propagation( X , parameters ):

#Please add something

w1 = parameters['w1']#4*2

b1 = parameters['b1']#4*1

w2 = parameters['w2']#1*4

b2 = parameters['b2']#1*1

Z1 = np.dot(w1,X)+b1#4*400

A1 = np.tanh(Z1)#4*400

Z2 = np.dot(w2,A1)+b2#1*400

A2 = sigmoid(Z2)#1*400

cache = {

"Z1":Z1,

"A1": A1,

"Z2": Z2,

"A2": A2

}

return cache

def compute_cost(A2,Y):

"""

计算交叉熵成本，

参数：

A2 - 使用sigmoid()函数计算的第二次激活后的数值

Y - "True"标签向量,维度为（1，数量）

返回：

成本 - 交叉熵成本

"""

#Please add something

m = Y.shape[1]

first = np.multiply(-Y,np.log(A2))

second = np.multiply(1-Y,np.log(1-A2))

cost = np.sum(first-second)/m

return cost

def backward_propagation(parameters,cache,X,Y):

#Please add something

m = X.shape[1]

w1 = parameters['w1']#4*2

w2 = parameters['w2']#1*4

A1 = cache['A1']#4*400

A2 = cache['A2']#1*400

dz2 = A2-Y#1*400

dw2 = (1/m)*np.dot(dz2,A1.T)#1*4

db2 = (1/m)*np.sum(dz2,axis = 1,keepdims = True)#1*1

#最难理解的部分

dz1 = np.multiply(np.dot(w2.T,dz2),1-np.power(A1,2))#4*400

dw1 = (1/m)*np.dot(dz1,X.T)#4*2

db1 = (1/m)*np.sum(dz1,axis = 1,keepdims = True)#4*1

grads = {

'dw1':dw1,

'db1': db1,

'dw2': dw2,

'db2': db2,

}

return grads

def update_parameters(parameters,grads,learning_rate=0.1):

#Please add something

w1 = parameters['w1']

w2 = parameters['w2']

b1 = parameters['b1']

b2 = parameters['b2']

dw2 = grads['dw2']

dw1 = grads['dw1']

db2 = grads['db2']

db1 = grads['db1']

w2 = w2 - learning_rate*dw2

b2 = b2 - learning_rate * db2

w1 = w1 - learning_rate * dw1

b1 = b1 - learning_rate * db1

parameters = {

'w1': w1,

'w2': w2,

'b1': b1,

'b2': b2,

}

return parameters

def nn_model(X,Y,n_h,num_iterations,print_cost=False):

#Please add something

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']

w2 = parameters['w2']

b1 = parameters['b1']

b2 = parameters['b2']

for i in range(num_iterations):

cache = forward_propagation(X,parameters)

cost = compute_cost(cache["A2"],Y)

grads = backward_propagation(parameters,cache,X,Y)

parameters = update_parameters(parameters,grads,learning_rate=0.5)

if print_cost:

if i%100==0:

print("第",i,"次循环,成本为"+str(cost))

return parameters

def predict(parameters,X):

"""

使用学习的参数，为X中的每个示例预测一个类

参数：

parameters - 包含参数的字典类型的变量。

X - 输入数据（n_x，m）

返回

predictions - 模型预测的向量（红色：0 /蓝色：1）

"""

cache = forward_propagation(X,parameters)

predictions = np.round(cache["A2"])

return predictions

X,Y = load_planar_dataset()

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)

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 = sklearn.metrics.accuracy_score(predictions.T,Y.T)*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 %