吴恩达深度学习L1W3——实现具有单个隐藏层的分类神经网络

实现具有单个隐藏层的2分类神经网络

使用具有非线性激活函数的神经元，例如tanh

一些笔记

在吴老师下一周的课程中有对前向传播和反向传播求导的结论，如图所示：

写作业

导入常用的包和老师提供的工具集

import numpy as np
import sklearn
import matplotlib.pyplot as plt
from planar_utils import plot_decision_boundary, load_planar_dataset,sigmoid,load_extra_datasets

%matplotlib inline 
#显示照片，不需要进行plt.show

获取数据

X, Y = load_planar_dataset() 
##数据可视化

plt.scatter(X[0, :], X[1, :], c=Y.reshape(X[0,:].shape), s=40, cmap=plt.cm.Spectral)

测试逻辑回归能否实现该分类

使用sklearn内置函数执行该操作（说实话没看懂这个，没有学过这个函数，www）

clf = sklearn.linear_model.LogisticRegressionCV();
clf.fit(X.T, Y.T);
## 绘制决策边界
plot_decision_boundary(lambda x: clf.predict(x), X, Y)
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)")

由于数据集线性不可分，所以逻辑回归效果不佳，接下来使用神经网络进行测试

使用的神经网络模型

建立神经网络的一般方法是：
1、定义神经网络结构
2、初始化模型参数
3、循环：前向传播、损失函数、bp求导、梯度下降

通常构建函数来实现1-3步，之后将它们合并为model()函数

定义神经网络结构

 - n_x：输入层的大小
 - n_h_1：第一个隐藏层的大小（这里只有一个隐藏层，将其设置为4）
 - n_y：输出层的大小

def layer_sizes(X,Y):
    n_x=X.shape[0]
    n_h_1=4
    n_y=Y.shape[0]
    
    return (n_x,n_h_1,n_y)

测试该函数

(n_x, n_h_1, n_y) = layer_sizes(X.T, Y.T)
print(n_x, n_h_1, n_y)

初始化模型参数

通过上面的笔记可以看出

X大小为(n_x,m),W1大小为(n_h_1,n_x),b_1大小为(n_h,1),Z1大小为(n_h_1,m),A1同Z1
W2大小为(n_y,n_h_1),b_2大小为(n_y,1),Z2大小为(n_y,m),A2同Z1同Y

权重矩阵不能跟线性回归一样设置为0，需要进步随机初始化，否则每层中不同神经元对应的Z都是一样的

使用随机值初始化权重矩阵。

 - 使用：np.random.randn（a，b）* 0.01随机初始化维度为（a，b）的矩阵。

将偏差向量初始化为零。

 - 使用：np.zeros((a,b)) 初始化维度为（a，b）零的矩阵。

def initialize_parameters(n_x, n_h, n_y):
    
    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,
                  "b1": b1,
                  "W2": W2,
                  "b2": b2}
    
    return parameters

循环梯度下降

首先实现前向传播，前向传播矩阵化见上面笔记

def forward_propagation(X, parameters):
   
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
   
    Z1 = np.dot(W1,X) + b1
    A1 = np.tanh(Z1)
    Z2 = np.dot(W2,A1) + b2
    A2 = sigmoid(Z2)
   
  
    
    cache = {
     "Z1": Z1,
             "A1": A1,
             "Z2": Z2,
             "A2": A2}
    
    return A2, cache

实现代价函数的计算：
代价函数矩阵化见作业1

def compute_cost(A2, Y, parameters):

    m = Y.shape[1] 
    logprobs = Y*np.log(A2) + (1-Y)* np.log(1-A2)
    cost = -1/m * np.sum(logprobs)
   
    cost = np.squeeze(cost)     # 去掉长度为1 的维度，turns [[17]] into 17                               
   
    return cost

实现反向传播，反向传播导数推导过程见笔记2：

def backward_propagation(parameters, cache, X, Y):
   
    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.dot(W2.T,dZ2) * (1-np.power(A1,2))#tanh 导数
    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

实现梯度下降函数：

def update_parameters(parameters, grads, learning_rate = 1.2):
  
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
  
    dW1 = grads["dW1"]
    db1 = grads["db1"]
    dW2 = grads["dW2"]
    db2 = 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

将上述函数集成到model中

def model(X,Y,n_h_1,n_iter=10000,print_cost=False):
    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_1, n_y)
    W1 = parameters["W1"]
    b1 = parameters["b1"]
    W2 = parameters["W2"]
    b2 = parameters["b2"]
    
    for i in range(0, n_iter):
        A2, cache = forward_propagation(X, parameters)
        cost = compute_cost(A2, Y, parameters)
        
        grads = backward_propagation(parameters, cache, X, Y)
 
      
        parameters = update_parameters(parameters, grads)
        
      
        if print_cost and i % 1000 == 0:
            print ("Cost after iteration %i: %f" %(i, cost))

    return parameters

通过上述模型来预测结果

def predict(parameters, X):
  
    A2, cache = forward_propagation(X, parameters)
    predictions = np.round(A2)

    return predictions

parameters = model(X, Y, n_h_1 = 4, n_iter = 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)
print ('Accuracy: %d' % float((np.dot(Y,predictions.T) + np.dot(1-Y,1-predictions.T))/float(Y.size)*100) + '%')

调整隐藏层的大小看结果

plt.figure(figsize=(16, 32))
hidden_layer_sizes = [1, 2, 3, 4, 5, 10, 20]
for i, n_h_1 in enumerate(hidden_layer_sizes):
    plt.subplot(5, 2, i+1)
    plt.title('Hidden Layer of size %d' % n_h_1)
    parameters = model(X, Y, n_h_1, n_iter = 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 ("Accuracy for {} hidden units: {} %".format(n_h_1, accuracy))

aaa

只能说自己还是太菜，如果没有网上的笔记的话，可能写不出来，已经有些思路了，大致的模型搭建已经搞懂了，就是写不出来，有的函数想自己写，但是总是没有大佬写的简洁，加油啊。。。
补补微积分和线性代数，多推导，多实践。