Coutse 神经网络与深度学习 第四周

这次其实一直都比较顺利，然后到最后深度神经网络进行预测时，出现了错误

RuntimeWarning: invalid value encountered in true_divide

然后我就查了好长时间，发现有人在计算cost，以及中加上1e-8，即

原博客在[Coursera] Deep learning 系列课程作业的一些报错问题总结及作业资源_Gong Chuanyang的博客-CSDN博客

在两个 np.log() 函数里加 + 1e-8 ，即将 logprobs = np.multiply(-np.log(a3),Y) + np.multiply(-np.log(1 - a3), 1 - Y) 改为 logprobs = np.multiply(-np.log(a3 + 1e-8),Y) + np.multiply(-np.log(1 - a3 + + 1e-8), 1 - Y)

但是我使用了一下，发现没有，反倒

cost = -np.sum(np.multiply(np.log(AL+1e-1), Y) + np.multiply(np.log(1 - AL+1e-1), 1 - Y)) / m

这样更改不会报错，但是cost的值非常高，差不多到了11左右，而且预测值远远不如两层神经网络，又翻了翻评论才发现，需要

初始化深度神经网络参数时：需要除后面那个数
parameters["W"+str(l)]=np.random.randn(layers_dims[l],layers_dims[l-1])/np.sqrt(layers_dims[l-1])

然后为啥要除我也不知道，希望有大佬知道了，告诉我一声，感谢，感谢

完整代码：

##本次我们要构建两层神经网络，一个两层，一个多层
import numpy as np
import h5py
import matplotlib.pyplot as plt
import testCase
from dnn_utils import sigmoid,sigmoid_backward,relu,relu_backward
import Ir_utils

np.random.seed(1)

##初始化参数
def initialize_parametes(n_x,n_h,n_y):
    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))

    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
##对于一个L层的神经网络，我们怎么进行初始化？
##该怎么初始化就怎么初始化，加上一个for循环就行
def initialize_parameters_deep(layers_dims):
    ##layers_dims包含每个层结点数的列表
    np.random.seed(3)
    parameters={}
    L=len(layers_dims)

    #从1-l，左闭右开，循环l-1次，最后一层为输出层，
    for l in range(1,L):
        ##初始化操作
        parameters["W"+str(l)]=np.random.randn(layers_dims[l],layers_dims[l-1])/np.sqrt(layers_dims[l-1])
        parameters["b"+str(l)]=np.zeros((layers_dims[l],1))

        assert (parameters["W"+str(l)].shape==(layers_dims[l],layers_dims[l-1]))
        assert (parameters["b"+str(l)].shape==(layers_dims[l],1))

    return parameters

##前向传播：linear,action,relu/sigmoid
def linear_forward(A,W,b):
    Z=np.dot(W,A)+b
    assert (Z.shape==(W.shape[0],A.shape[1]))
    cache=(A,W,b)
    return Z,cache

def linear_activation_forward(A_prev,W,b,activation):
    if activation=="sigmoid":

        #linear_cache,A,W,b
        Z,linear_cache=linear_forward(A_prev,W,b)
        #activation_cache其实就是Z
        A,activation_cache=sigmoid(Z)
    elif activation=="relu":
        Z,linear_cache=linear_forward(A_prev,W,b)
        A,activation_cache=relu(Z)

    assert (A.shape==(W.shape[0],A_prev.shape[1]))
    cache=(linear_cache,activation_cache)

    return A,cache


#两层的神经网络简简单单，那么多层神经网络呢？
def L_model_forward(X,paerameters):
    #paerameters为初始化深度神经网络的输出，Wl，bl

    #返回AL最后的激活值，cache  l-1个relu，1个sigmoid
    caches=[]
    A=X
    L=len(paerameters)//2
    for l in range(1,L):
        A_prev=A
        A,cache=linear_activation_forward(A_prev,paerameters["W"+str(l)],paerameters["b"+str(l)],activation="relu")
        caches.append(cache)

    AL,cache=linear_activation_forward(A,paerameters["W"+str(L)],paerameters["b"+str(L)],activation="sigmoid")
    caches.append(cache)

    assert (AL.shape==(1,X.shape[1]))
    return AL,caches

def compute_cost(AL,Y):
    #AL预测值，Y实际值
    m=Y.shape[1]
    #cost=-np.sum(np.multiply(np.log(AL),Y)+np.multiply(np.log(1-AL),1-Y))/m
    cost = -np.sum(np.multiply(np.log(AL+1e-1), Y) + np.multiply(np.log(1 - AL+1e-1), 1 - Y)) / m
    cost=np.squeeze(cost)

    assert (cost.shape==())
    return cost

##实现反向传播
def linear_backward(dZ,cache):
    ##cache来自与向前传播中的cache，包括A_prev,W,b

    A_prev,W,b=cache
    m=A_prev.shape[1]

    ##接下来dW，db，dA的计算都是一些公式
    dW=np.dot(dZ,A_prev.T)/m
    db=np.sum(dZ,axis=1,keepdims=True)/m
    dA_prev=np.dot(W.T,dZ)

    assert (dA_prev.shape==A_prev.shape)
    assert (dW.shape==W.shape)
    assert (db.shape==b.shape)

    return dA_prev,dW,db

#反向传播的线性激活
def linear_activation_backward(dA,cache,activation="relu"):
    #dA激活后的梯度值，cache中是A,W,b,,,activation Z

    linear_cache,activation_cache=cache
    if activation=="relu":
        dZ=relu_backward(dA,activation_cache)
        dA_prev,dW,db=linear_backward(dZ,linear_cache)
    elif activation=="sigmoid":
        dZ=sigmoid_backward(dA,activation_cache)
        dA_prev,dW,db=linear_backward(dZ,linear_cache)

    return dA_prev,dW,db


def L_model_backward(AL,Y,caches):
    ##AL-概率向量，Y标签向量，cache-linear_activation_forward
    grads={}
    L=len(caches)
    m=AL.shape[1]
    Y=Y.reshape(AL.shape)
    dAL=-(np.divide(Y,AL+1e-8)-np.divide(1-Y+1e-8,1-AL+1e-8))

    current_cache=caches[L-1]
    grads["dA"+str(L)],grads["dW"+str(L)],grads["db"+str(L)]=linear_activation_backward(dAL,current_cache,activation="sigmoid")

    for l in reversed(range(L-1)):
        current_cache=caches[l]
        dA_prev_temp,dW_temp,db_temp=linear_activation_backward(grads["dA"+str(l+2)],current_cache,activation="relu")
        grads["dA"+str(l+1)]=dA_prev_temp
        grads["dW"+str(l+1)]=dW_temp
        grads["db"+str(l+1)]=db_temp

    return grads

#更新参数
def update_parameters(parameters,grads,learning_rate):
    L=len(parameters)//2
    for l in range(L):
        ##本来应该是0-l-1，但是神经网络为1-l
        parameters["W"+str(l+1)]=parameters["W"+str(l+1)]-learning_rate*grads["dW"+str(l+1)]
        parameters["b"+str(l+1)]=parameters["b"+str(l+1)]-learning_rate*grads["db"+str(l+1)]

    return parameters

def two_layer_model(X,Y,layer_dims,learning_rate=0.0075,num_iterations=3000,print_cost=False,is_plot=True):
    #两层循环

    ##初始化参数
    np.random.seed(1)
    grads={}
    costs=[]
    (n_x,n_h,n_y)=layer_dims

    parameters=initialize_parametes(n_x,n_h,n_y)
    W1=parameters["W1"]
    b1 = parameters["b1"]
    W2=parameters["W2"]
    b2=parameters["b2"]


    for i  in range(0,num_iterations):
        ##前向循环
        ##因为是两层神经网络，所以说比较简单，直接操作就行
        A1,cache1=linear_activation_forward(X,W1,b1,"relu")
        A2,cache2=linear_activation_forward(A1,W2,b2,"sigmoid")

        cost=compute_cost(A2,Y)

        dA2=-(np.divide(Y,A2)-np.divide(1-Y,1-A2))

        dA1,dW2,db2=linear_activation_backward(dA2,cache2,"sigmoid")
        dA0,dW1,db1=linear_activation_backward(dA1,cache1,"relu")

        ##将反向传播保存到grads中
        grads["dW1"]=dW1
        grads["db1"]=db1
        grads["dW2"]=dW2
        grads["db2"]=db2

        ##更新参数
        parameters=update_parameters(parameters,grads,learning_rate)
        W1=parameters["W1"]
        b1=parameters["b1"]
        W2=parameters["W2"]
        b2=parameters["b2"]

        if i%100==0:
            costs.append(cost)
            if print_cost:
                print("第",i,"次迭代，成本为：",np.squeeze(cost))

    ##迭代完成之后，我们开始画图
    if is_plot:
        plt.plot(np.squeeze(costs))
        plt.ylabel('cost')
        plt.xlabel('iterations(per tens)')
        plt.title("learning_rate="+str(learning_rate))
        plt.show()
    return parameters


#0.72
def predict(X,y,parameters):
    #X测试集，y标签,parameters参数
    m=X.shape[1]
    n=len(parameters)//2##神经网络的层数
    p=np.zeros((1,m))

    ##根据参数的前向传播
    #AL,
    probas,caches=L_model_forward(X,parameters)

    for i in range(0,probas.shape[1]):
        if probas[0,i]>0.5:
            p[0,i]=1
        else:
            p[0,i]=0

    print("准确度："+str(float(np.sum(p==y))/m))

    return p

def L_layer_model(X,Y,layers_dims,learning_rate=0.0075,num_iterations=3000,print_cost=False,is_plot=True):

    np.random.seed(1)
    costs=[]

    parameters=initialize_parameters_deep(layers_dims)

    for i in range(0,num_iterations):
        AL,caches=L_model_forward(X,parameters)
        cost=compute_cost(AL,Y)

        grads=L_model_backward(AL,Y,caches)

        parameters=update_parameters(parameters,grads,learning_rate)

        if i%100==0:
            costs.append(cost)

            if print_cost:
                print("第",i,"次迭代，成本为：",np.squeeze(cost))


    if is_plot:
        plt.plot(np.squeeze(costs))
        plt.ylabel('cost')
        plt.xlabel('iterations(per tens)')

        plt.title('learning_rate='+str(learning_rate))
        plt.show()


    return parameters

def main():

    train_set_x_orig , train_set_y , test_set_x_orig , test_set_y , classes = Ir_utils.load_dataset()

    train_x_flatten = train_set_x_orig.reshape(train_set_x_orig.shape[0], -1).T
    test_x_flatten = test_set_x_orig.reshape(test_set_x_orig.shape[0], -1).T

    train_x = train_x_flatten / 255
    train_y = train_set_y
    test_x = test_x_flatten / 255
    test_y = test_set_y
    layers_dims = [12288, 20, 7, 5, 1] #  5-layer model
    parameters = L_layer_model(train_x, train_y, layers_dims, num_iterations = 2500, print_cost = True,is_plot=True)

    pred_train = predict(train_x, train_y, parameters) #训练集
    pred_test = predict(test_x, test_y, parameters) #测试集

原文链接:【中文】【吴恩达课后编程作业】Course 1 - 神经网络和深度学习 - 第四周作业(1&2)_何宽的博客-CSDN博客_吴恩达课后编程作业