吴恩达深度学习第一门课第二周：神经网络的编程基础

• 前言
• 一、二分类
• 二、逻辑回归
• 三、逻辑回归的代价函数
• 四、梯度下降法
• 五、导数
• 六、更多的导数例子
• 七、计算图
• 八、使用计算图求导数
• 九、逻辑回归中的梯度下降
• 十、m个样本的梯度下降
• 十一、向量化
• 十二、向量化的更多例子
• 十三、向量化逻辑回归
• 十四、向量化逻辑回归的梯度输出
• 十五、Python中的广播
• 十六、关于python_numpy向量的说明
• 第二周作业

吴恩达深度学习第一门课第二周：神经网络的编程基础

逻辑回归是一个用于二分类的算法。首先我们从一个问题开始说起，这里有一个二分类问题的例子，假如你有一张图片作为输入，比如这只猫，如果识别这张图片为猫，则输出标签1作为结果；如果识别出不是猫，那么输出标签0作为结果。
我们来看看一张图片在计算机中如何表示的，为了保存一张图片，需要保存三张矩阵，它们分别对应图中的红绿蓝三种颜色通道，如果你的图片大小为64*64像素，那么你就有三个规模为64 *64的矩阵。

为了把这些像素值放到一个特征向量中，我们需要把这些像素值提取出来，然后放入一个特征向量x。例如255、231等等，直到取完所有的红色像素，接着最后是255、134、…、255、134等等，直到得到一个特征向量。如果图片的大小为64 * 64像素，那么向量x的总维度将是64 * 64 * 3，在这个例子中结果为12288。现在我们用nx=12288来表示输入特征向量的维度，有时为了简介，我会直接用小写的n来表示输入特征向量x的维度。所以在二分类问题中，我们的目标就是习得一个分类器，它以图片的特征向量作为输入，然后预测输出结果y为1还是0，也就是预测图片中是否有猫。

接下来我们说明一些在课下课程中，需要用到的一些符号。

为了训练逻辑回归模型的参数参数w和参数b，需要一个代价函数，通过训练代价函数来得到参数w和参数b。先看一下逻辑回归的输出函数：

损失函数又叫误差函数，用来衡量算法的运行情况。我们通过将这个L称为的损失函数，来衡量预测输出值和实际值有多接近。一般我们用预测值和实际值的平方差或者它们平方差的一半，但是通常在逻辑回归中我们不这么做，因为当我们在学习逻辑回归参数的时候，会发现我们的优化目标不是凸优化，只能找到多个局部最优值，梯度下降法很可能找不到全局最优值，虽然平方差是一个不错的损失函数，但是我们在逻辑回归模型中会定义另一个损失函数。
损失函数是在单个训练样本中定义的，它衡量的是算法在单个训练样本中表现如何，为了衡量算法在全部训练样本上的表现如何，我们需要定义一个算法的代价函数。

梯度下降法的形象化说明，我们所做的就是找到使得代价函数（成本函数）J(w,b)函数值是最小值，对应的参数w和b。

如图，代价函数J（w，b）是一个凸函数，像一个大碗一样。

如图，这就与刚才的图有些相反，因为它是非凸的并且有很多不同的局部最小值。由于逻辑回归的代价函数J（w，b）特性，我们必须定义代价函数J（w，b）为凸函数。初始化w和b。可以用随机初始化的方法，对于逻辑回归几乎所有的初始化方法都有效，因为函数是凸函数，无论在哪里初始化，应该达到同一点或大致相同的点。

假设代价函数J(w)只有一个参数w，即用一维曲线代替多维曲线，这样可以更好画出图像。

a表示学习率，用来控制步长。

假设我们以如图点为初始化点，该点处的斜率的符号是正的，那么接下来会向左走一步。
假设该点处的斜率的符号是负的，接下来会向右走一步。
逻辑回归的代价函数J(w,b)是含有两个参数的。

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

a=np.random.randn(5,1)
print(a)
print(a.shape)
print(a.T)
print(np.dot(a,a.T))
assert(a.shape==(5,1))

我们要做的事是搭建一个能够**【识别猫】** 的简单的神经网络
资料包已上传百度网盘
密码为6666

import numpy as np
import matplotlib.pyplot as plt
import h5py
from lr_utils import load_dataset

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

m_train = train_set_y.shape[1]
m_test = test_set_y.shape[1]
num_px = train_set_x_orig.shape[1]

#现在看一看我们加载的东西的具体情况
print("训练集的数量：m_train="+str(m_train))
print("测试集的数量：m_test="+str(m_test))
print("每张图片的宽/高：num_px="+str(num_px))
print("每张图片的大小："+str(num_px)+","+str(num_px)+",3")
print("训练集_图片的维数："+str(train_set_x_orig.shape))
print("训练集_标签的维数："+str(train_set_y.shape))
print("测试集_图片的维数："+str(test_set_x_orig.shape))
print("测试集_标签的维数："+str(test_set_y.shape))

#将训练集的维度降低并转置
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

print("训练集降维最后的维度："+str(train_set_x_flatten.shape))
print("训练集_标签的维数："+str(train_set_y.shape))
print("测试集降维之后的维度："+str(test_set_x_flatten.shape))
print("测试集_标签的维数："+str(test_set_y.shape))

train_set_x = train_set_x_flatten/255
test_set_x = test_set_x_flatten/255

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


def initialize_with_zeros(dim):
    w=np.zeros(shape=(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/m) * np.sum(Y*np.log(A)+(1-Y)*(np.log(1-A)))
    dw = (1/m)*np.dot(X,(A-Y).T)
    db = (1/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 -= learning_rate*dw
        b -= learning_rate*db
        if i%100 ==0:
            costs.append(cost)
        if (print_cost) and (i %100==0):
            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))
    w=w.reshape(X.shape[0],1)

    A=sigmoid(np.dot(w.T,X)+b)
    for i in range(A.shape[1]):
        Y_prediction[0,i] = 1 if A[0,i]>0.5 else 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,costs=optimize(w,b,X_train,Y_train,num_iterations,learning_rate,print_cost)
    w,b=parameters["w"],parameters["b"]
    Y_prediction_test = predict(w,b,X_test)
    Y_prediction_train=predict(w,b,X_train)

    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)

costs = np.squeeze(d['costs'])
plt.plot(costs)
plt.ylabel('iterations (per hundreds)')
plt.title('Learning rate='+str(d["learning_rate"]))
plt.show()