关于Week3编程作业：#Planar_data_classification_with_onehidden_layer#的学习总结

导入包

testCases：提供了一些测试示例来评估函数的正确性

加载并可视化数据集

#加载数据集,,,将一个花的图案的2类数据集加载到变量X和Y中
X, Y = load_planar_dataset()

# Visualize the data:
plt.scatter(X[0, :], X[1, :], c=np.squeeze(Y), s=40, cmap=plt.cm.Spectral)#np.squeeze()从数组的形状中删除单维度条目，即把shape中为1的维度去掉

注解：
1.这里关于scatter函数的各项参数及其意义借阅该篇博文：https://blog.csdn.net/qiu931110/article/details/68130199
这里主要说明：
1） X[0, :], X[1, :]表示的是shape大小为(n,)的数组，也就是我们即将绘制散点图的数据点，输入数据。
2) c表示的是色彩或颜色序列，可选，默认蓝色’b’。但是c不应该是一个单一的RGB数字，也不应该是一个RGBA的序列，因为不便区分。c可以是一个RGB或RGBA二维行数组。

3) 表示的是大小，是一个标量或者是一个shape大小为(n,)的数组，可选，默认20。

2.x[n,:]和x[:,n] 理解和实例解析
x[:,n]表示在全部数组（维）中取第n个数据，直观来说，x[:,n]就是取所有集合的第n个数据 (下标从0开始）,例如：
1） x[:,0]

import numpy as np  
X = np.array([[0,1],[2,3],[4,5],[6,7],[8,9],[10,11],[12,13],[14,15],[16,17],[18,19]])  
print X[:,0]  

输出结果：
2）x[:,1]

import numpy as np  
X = np.array([[0,1],[2,3],[4,5],[6,7],[8,9],[10,11],[12,13],[14,15],[16,17],[18,19]])  
print X[:,1]  

输出结果：
x[n,:]表示在n个数组（维）中取全部数据，直观来说，x[n,:]就是取第n集合的所有数据例如：
1） x[1,:]
输出结果：

x[:,m:n]，即取所有数据集的第m到n-1列数据
例如：输出X数组中所有行第1到2列数据

import numpy as np 
X = np.array([[0,1,2],[3,4,5],[6,7,8],[9,10,11],[12,13,14],[15,16,17],[18,19,20]]) 
print X[:,1:3]  

输出结果：

搭建神经网络

1.模型如下：2.构建步骤
1）定义神经网络结构（输入单元的数量，隐藏单元的数量等）
2）初始化模型的参数
3）循环优化参数

• 前向传播
• 计算损失函数值
• 后向传播
• 用梯度下降法更新参数

1）定义神经网络结构(大小)

def layer_sizes(X , Y):
........
*中间过程*
........
return (n_x,n_h,n_y)

2）初始化模型的参数

def initialize_parameters( n_x , n_h ,n_y):
.........
中间过程
.........
parameters = {"W1" : W1,
              "b1" : b1,
              "W2" : W2,
              "b2" : b2 }
return parameters

3)循环优化参数

• 前向传播：运用前向传播公式计算A,Z

def forward_propagation( X , parameters ):
#X - 维度为（n_x，m）的输入数据。
#parameters - 初始化函数（initialize_parameters）的输出
..........
中间运用np.dot()和tanh（）sigmoid()来表达前向传播公式
..........
cache = {"Z1": Z1,
         "A1": A1,
         "Z2": Z2,
         "A2": A2}    #缓存数据到cache中，用于之后进行反向传播求梯度
return (A2, cache)

• 计算损失函数的值

可以使用np.multiply（）然后使用np.sum（）或者直接使用np.dot（）

def compute_cost(A2,Y,parameters):
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))

return cost

• 后向传播
  
  为了计算dZ1，里需要计算 g[1]′(Z[1])g[1]′(Z[1])， g1g1 是tanh激活函数，如果a=g1a=g1 那么g[1]′(z)=1−a2g[1]′(z)=1−a2。所以我们需要使用 (1 - np.power(A1, 2))来计算g[1]′(Z[1])g[1]′(Z[1]) 。

def backward_propagation(parameters,cache,X,Y):
*******************重点代码*******************
dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2))
db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)
db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)

grads = {"dW1": dW1,
         "db1": db1,
         "dW2": dW2,
         "db2": db2 }
return grads 

• 用梯度下降法更新参数

def update_parameters(parameters,grads,learning_rate=1.2):
.........
..........
parameters = {"W1": W1,
              "b1": b1,
              "W2": W2,
              "b2": b2}
return parameters

整合函数

我们现在把上面的东西整合到nn_model()中，神经网络模型必须以正确的顺序使用先前的功能。

def nn_model(X,Y,n_h,num_iterations,print_cost=False):
# num_iterations - 梯度下降循环中的迭代次数
#print_cost - 如果为True，则每1000次迭代打印一次成本数值

#调用layer_sizes()函数为n_x,n_y赋值
n_x = layer_sizes(X, Y)[0]
n_y = layer_sizes(X, Y)[2]

#调用initialize_parameters()函数初始化参数
parameters = initialize_parameters(n_x,n_h,n_y)

#运用fao循环进行“正向传播” ， “成本计算” ， “反向传播” ， “更新参数”
 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