识别猫咪AI算法代价函数的所有求导过程

问题阐述：

1.刚学习人工智能的同学，一进来都会莫名其妙地接触到吴恩达老师的猫咪识别项目，这里将贴上一部分代码。

import  numpy as np
import matplotlib.pyplot as plt
import h5py
import skimage.transform as tf
#import torch



def load_dataset():
    train_dataset=h5py.File('datasets/train_catvnoncat.h5','r')
    trainsetX=np.array(train_dataset['train_set_x'][:])
    trainsetY=np.array(train_dataset['train_set_y'][:])

    test_dataset=h5py.File('datasets/test_catvnoncat.h5', "r")
    testsetX=np.array(test_dataset['test_set_x'][:])
    testsetY = np.array(test_dataset['test_set_y'][:])

    classes = np.array(test_dataset['list_classes'][:])

    trainsetY=trainsetY.reshape(1,trainsetY.shape[0])
    testsetY=testsetY.reshape(1,testsetY.shape[0])

    return trainsetX,trainsetY,testsetX,testsetY,classes


def sigmoid(z):

    s=1/(1+np.exp(-z))
    return s

def initdata(dim):
    w=np.zeros((dim,1))
    b=0
    return w,b

def propgate(w,b,X,Y):
    m=X.shape[1]


    A=sigmoid(np.dot(w.T,X)+b)
    cost=-np.sum(Y*np.log(A)+(1-Y)*np.log(1-A))/m


    #反向传播
    dZ=A-Y
    dw=np.dot(X,dZ.T)/m
    db=np.sum(dZ)/m
    grads={
        "dw":dw,
        "db":db
    }
    return grads,cost



train_set_x_orig, train_set_y, test_set_x_orig, test_set_y, classes = load_dataset()
train_set_x_flatten=train_set_x_orig.reshape(train_set_x_orig.shape[0],-1).T
test_set_x_flatten=test_set_x_orig.reshape(test_set_x_orig.shape[0],-1).T



train_set_x=train_set_x_flatten/255.
test_set_x=test_set_x_flatten/255.

print(test_set_x_flatten.shape)

def optimize(w,b,X,Y,num_iterations,learning_rate,print_cost=False):



    costs=[]
    for i in range(num_iterations):
        grads,cost=propgate(w,b,X,Y)

        dw=grads["dw"]
        db=grads["db"]

        w=w-learning_rate*dw
        b=b-learning_rate*db

        if i%100==0:
            costs.append(cost)
            if print_cost:
                print("优化%i次后的成本是:%f" %(i,cost))



    params={
        "w":w,
        "b":b
    }

    return  params,costs


def predict(w,b,X):
    m=X.shape[1]
    Y_prediction=np.zeros((1,m))

    A=sigmoid(np.dot(w.T,X)+b)

    for i in range(A.shape[1]):
        if A[0,i]>=0.5:
            Y_prediction[0,i]=1

    return Y_prediction



def model(X_train,Y_train,X_test,Y_test,num_iterations=2000,learning_rate=0.5,print_cost=False):
    w,b=initdata(X_train.shape[0])

    parameters,costs=optimize(w,b,X_train,Y_train,num_iterations,learning_rate,print_cost)

    w=parameters["w"]
    b=parameters["b"]

    Y_prediction_train=predict(w,b,X_train)
    Y_prediction_test=predict(w,b,X_test)


    print("对训练图片的预测准确率为: {}%".format(100 - np.mean(np.abs(Y_prediction_train - Y_train)) * 100))
    print("对测试图片的预测准确率为: {}%".format(100 - np.mean(np.abs(Y_prediction_test - Y_test)) * 100))

    d = {"costs": costs,
         "Y_prediction_test": Y_prediction_test,
         "Y_prediction_train": Y_prediction_train,
         "w": w,
         "b": b,
         "learning_rate": learning_rate,
         "num_iterations": num_iterations}

    return d


d=model(train_set_x,train_set_y,test_set_x,test_set_y,num_iterations=2000,learning_rate=0.005,print_cost=True)

问题研究：

很多人可能像小康一样，即使把整体看的明明白白，却不知道以下导数怎么求过来的，因为大多数网站和老师，都是直接选择掠过的，导致很多像小康这样的萌新学生表示摸不着头脑：

    #反向传播
    dZ=A-Y
    dw=np.dot(X,dZ.T)/m
    db=np.sum(dZ)/m

问题解决：

下面我将为大家粘出我的求解过程，过程清晰易懂，比其他博客和老师各种画饼强多了：

总结：

总的来说其实就是一步一步的链式求导法则，识别猫咪也就这里比较难懂，希望大家看小康的步骤能够理解哈。