Logistic Regression with a Neural Network mindset-3

版权为吴恩达老师所有，参考Koala_Tree的博客，部分根据自己实践添加

使用bing翻译，部分手工翻译

3-学习算法的一般体系结构

是时候设计一个简单的算法来区分猫的图像与非猫图像。

你将建立一个逻辑回归, 使用神经网络思维。下图解释了为什么逻辑回归实际上是一个非常简单的神经网络!

还在路上，稍等...

算法的数学表达式:

举一个例子 $x^{(i)}$ :

$z^{(i)}=w^{T}x^{(i)}+b$ (1)

$\hat{y}^{(i)}=a^{(i)}=sigmoid(z^{(i)})$ (2)

$L(a^{(i)},y^{(i)})=-y^{(i)}log(a^{(i)})-(1-y^{(i)})log(1-a^{(i)})$ (3)

然后通过对所有训练实例计算总的成本:

$J=\frac{1}{m} \sum_{i=1}^{m}L(a^{(i)},y^{(i)})$ (4)

关键步骤:
在本练习中, 您将执行以下步骤:
-初始化模型的参数

-通过了解模型的参数来最大限度地减少成本
-使用所学参数使预测 (在测试集)
-分析结果并得出结论

4-建立我们的算法的部分 # #

构建神经网络的主要步骤有:
1. 定义模型结构 (如输入特征的数量)
2。初始化模型的参数
3。循环:
-计算当前损耗 (正向传播)

-计算当前渐变 (向后传播)

-更新参数 (渐变下降)

您通常单独构建 1-3, 并将它们集成到我们调用的model()函数中。

4.1-助手函数

练习: 使用代码来自 "Python 基础",实现。如上图所示,您需要计算做出预测。使用np.exp ()。

def sigmoid(z):
    s=1.0/(1.0+np.exp(-z))
    return s

4.2-初始化参数

练习:在下面的单元格中实现参数初始化。您必须将 w 初始化为零的向量。如果您不知道要使用什么 numpy 功能, 请在 numpy 库的文档中查找 np. zeros()。

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

    assert(w,shape==(dim,1))
    assert(isinstance(b,float) or isinstance(b,int))

    return w,b

对于图像输入, w 将是形状(num_px × num_px × 3, 1)

练习:实现计算成本propagate()函数及其梯度函数。

提示:

正向传播：

你将得到X

你将计算 $A=\sigma(w^{T}X+b)=(a^{(0)},a^{(1)},...,a^{^{(m-1)}},a^{(m)})$

计算成本函数 $J=-\frac{1}{m} \sum_{i=1}^{m}y^{(i)}log(a^{(i)})-(1-y^{(i)})log(1-a^{(i)})$

下面是要使用的两个公式:

$\frac{\partial J}{\partial w}=\frac{1}{m}X(A-Y)^{T}$

$\frac{\partial J}{\partial b}=\frac{1}{m}\sum_{i=1}^{m}(a^{(i)}-y^{(i)})$

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

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

    dw=(1.0/m)*np.dot(X,(A-Y).T)
    db=(1.0/m)*np.sum(A-Y)

    assert(dw.shape==w.shape)
    assert(db.dtype==float)
    cost=np.squeeze(cost)
    assert(cost.shape==())

    grads={"dw":dw,"db":db}
    
    return grads,cost

d) 优化

您已经初始化了参数。
您还可以计算成本函数及其梯度。
现在, 您需要使用梯度下降来更新参数。

练习:记下优化函数。目标是学习w和b通过最小化成本函数J.对于参数θ, 更新规则是θ=θ−αdθ, 其中α是学习率。

def optimize(w,b,X,Y,num_iterations,learning_rate,print_cost=False):
    costs=[]
    
    for i in range(num_iterations):
        grads,cost=propagate(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 and i%100 ==0:
            print("Cost after iteration %i: %f" %(i,cost))
        
    params={"w":w,"b":b}
    grads={"dw":dw,"db":db}

    return params,grads,costs

练习:以前的函数将输出所学 w 和 b。我们可以使用 w 和 b 来预测数据集 x 的标签,实现predict()函数,计算预测有两个步骤:

计算 $\hat{Y}=A=\sigma (w^{T}X+b)$
将 a 转换为 0 (if a < = 0.5) 或 1 (if a > 0.5), 则将预测存储在向量Y_prediction中。如果愿意, 可以在for循环中使用if/else语句 (尽管还有一种方法可以向量化此)。

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

    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
        else:
            Y_prediction[0,i]=0

    assert(Y_prediction.shape==(1,m))

    return Y_prediction

应记住的内容:
您已经实现了以下几个函数:

-初始化 (w,b)

-以迭代的形式优化损失以学习参数(w, b):

-计算成本及其梯度

-更新参数使用梯度下降
-使用已学 (w, b) 来预测给定示例集的标签

5-将所有函数合并到模型中

现在, 您将通过将所有模块 (在前面的部分中实现的函数) 组合在一起, 以正确的顺序来查看整个模型的结构。

练习:实现模型函数。使用以下记法:
-Y_prediction 为您在测试集的预测
-Y_prediction_train 为您在训练集的预测
-w,cost,grads为optimize()的输出

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

    parameters,grads,costs=optimize(w,b,X_train,Y_train,num_iterations,learning_rate,print_cost)   
    
    w=parameters["w"]
    b=parameters["b"]

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

    print("train accuracy: {} %".format(100-np.mean(np.abs(Y_prediction_train-Y_train))*100))
    print("test accuracy: {} %".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

评论: 培训的准确性接近100%。这是一个很好的健全检查: 你的模型是工作, 并有足够高的能力, 以适应培训数据。测试错误为68%。考虑到我们使用的小数据集和逻辑回归是线性分类器, 这个简单模型实际上并不坏。

# encoding:utf-8
import numpy as np
import matplotlib.pyplot as plt
import h5py
import scipy
import pylab
from PIL import Image
from scipy import ndimage
from lr_utils import load_dataset

def sigmoid(z):
    s=1.0/(1.0+np.exp(-z))
    return s

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

    assert(w.shape==(dim,1))
    assert(isinstance(b,float) or isinstance(b,int))

    return w,b

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

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

    dw=(1.0/m)*np.dot(X,(A-Y).T)
    db=(1.0/m)*np.sum(A-Y)

    assert(dw.shape==w.shape)
    assert(db.dtype==float)
    cost=np.squeeze(cost)
    assert(cost.shape==())

    grads={"dw":dw,"db":db}
    
    return grads,cost

def optimize(w,b,X,Y,num_iterations,learning_rate,print_cost = False):
    costs=[]
    
    for i in range(num_iterations):
        grads,cost=propagate(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 and i%100 ==0:
            print("Cost after iteration %i: %f" %(i,cost))
        
    params={"w":w,"b":b}
    grads={"dw":dw,"db":db}

    return params,grads,costs

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

    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
        else:
            Y_prediction[0,i]=0

    assert(Y_prediction.shape==(1,m))

    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=initialize_with_zeros(X_train.shape[0])

    parameters,grads,costs=optimize(w,b,X_train,Y_train,num_iterations,learning_rate,print_cost)   
    
    w=parameters["w"]
    b=parameters["b"]

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

    print("train accuracy: {} %".format(100-np.mean(np.abs(Y_prediction_train-Y_train))*100))
    print("test accuracy: {} %".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   

#Loading the data (cat/non-cat)
train_set_x_orig,train_set_y,test_set_x_orig,test_set_y,classes=load_dataset()

m_train=train_set_x_orig.shape[0]
m_test=test_set_x_orig.shape[0]
num_px=train_set_x_orig.shape[1]

train_set_x_flatten=train_set_x_orig.reshape(m_train,-1).T
test_set_x_flatten=test_set_x_orig.reshape(m_test,-1).T

train_set_x=train_set_x_flatten/255.0
test_set_x=test_set_x_flatten/255.0

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