吴恩达深度学习Course1Week3课后编程作业

**

吴恩达深度学习course1week3编程作业

**
本文参考何宽的博客加之自己的理解而来数据下载地址百度网盘
准备工作：

import numpy as np
import matplotlib.pylab as plt
%matplotlib inline
from planar_utils import plot_decision_boundary, sigmoid, load_planar_dataset, load_extra_datasets
from testCases import *
np.random.seed(1) 
X, Y = load_planar_dataset()
plt.scatter(X[0, :], X[1, :], c=np.squeeze(Y), s=40, cmap=plt.cm.Spectral)

定义sigmoid函数：

def sigmoid(intz):
    return 1/(1+np.exp(-intz))

初始化参数：

def initial(n_x,n_h,n_y):
    np.random.seed(2)
    W1=np.random.randn(n_h,n_x)*0.01  #(4,2)
    b1=np.zeros((n_h,1))             #(4,1)
    W2=np.random.randn(1,n_h)*0.01         #(1,4)
    b2=0                             #(1,1)
    return  W1,W2,b1,b2

定义cost函数：

def cost_func(Y,A2):
    m=Y.shape[1]
    cost=Y*np.log(A2)+(1-Y)*np.log(1-A2)
    return (-1/m)*np.sum(cost)

前向传播：

def forward(X,W1,W2,b1,b2):
    Z1=np.dot(W1,X)+b1
    A1=np.tanh(Z1)
    Z2=np.dot(W2,A1)+b2
    A2=sigmoid(Z2)
    return Z1,A1,Z2,A2

后向传播：

def backword(X,Y,A1,A2,W1,W2):
    m=Y.shape[1]
    dZ2=A2-Y
    dW2=(1/m)*np.dot(dZ2,A1.T)
    db2=(1/m)*np.sum(dZ2)
    dZ1=np.multiply(np.dot(W2.T,dZ2),1-A1**2)
    dW1=(1/m)*np.dot(dZ1,X.T)
    db1=(1/m)*np.sum(dZ1)
    return dW1,dW2,db1,db2

梯度：

def gradient(alpha,W1,W2,b1,b2,dW1,dW2,db1,db2):
    W1=W1-alpha*dW1
    b1=b1-alpha*db1
    W2=W2-alpha*dW2
    b2=b2-alpha*db2
    return W1,W2,b1,b2

主函数：

def nn_model(X,Y,maxIteration,alpha,print_cost=False):
    W1,W2,b1,b2=initial(2,4,1)
    for i in range(maxIteration):
        Z1,A1,Z2,A2=forward(X,W1,W2,b1,b2)
        dW1,dW2,db1,db2=backword(X,Y,A1,A2,W1,W2)
        cost=cost_func(Y,A2)
        W1,W2,b1,b2=gradient(alpha,W1,W2,b1,b2,dW1,dW2,db1,db2)
        if print_cost:
                if i%1000 == 0:
                    print("第 ",i," 次循环，成本为："+str(cost))
    return   W1,W2,b1,b2   

W1,W2,b1,b2= nn_model(X, Y,10000,0.5 ,print_cost=True)

第 0 次循环，成本为：0.6930480201239823
第 1000 次循环，成本为：0.31095962265264243
第 2000 次循环，成本为：0.2935549168516565
第 3000 次循环，成本为：0.28443428615557553
第 4000 次循环，成本为：0.2777115293829358
第 5000 次循环，成本为：0.2714012361776102
第 6000 次循环，成本为：0.24467947308380475
第 7000 次循环，成本为：0.23767201636706753
第 8000 次循环，成本为：0.23331311077736339
第 9000 次循环，成本为：0.2302111606497552
定义预测函数：

def predict(W1,W2,b1,b2,X):

    Z1,A1,Z2,A2= forward(X,W1,W2,b1,b2)
    predictions = np.round(A2)

    return predictions

输出：

predictions=predict(W1,W2,b1,b2,X)
print ('准确率: %d' % float((np.dot(Y, predictions.T) + np.dot(1 - Y, 1 - predictions.T)) / float(Y.size) * 100)+'%')

准确率: 90%