二、神经网络基础（逻辑回归和向量化）

1、二分类

  logistic回归是一个用于二分类（Binary Classification）的算法。二分类就是输出结果y只有0和1两个标签（也有-1和1的情况）。以一个图像识别为例，例如识别猫，1代表猫，0代表不是猫。用y表示输出的结果标签。

  在二分类问题中，目标是训练一个分类器，它以图片的特征向量x为输入，预测输出的结果标签y是0还是1。

2、logisitic回归

  接下来介绍如何使用逻辑回归来解决二分类问题。逻辑回归中，表示y为1的概率，取值范围是(0,1)之间。

  逻辑回归的线性预测输出可以写成如上形式，已知的特征输入向量x可能是n_x维度，logistic回归的参数w也是n_x维的向量，而b就是一个实数。所以已知输入x和参数w和b，

  值得注意的是，在很多其他机器学习资料中，可能把常数b当做w0处理，并引入x0=1。这样从维度来看，x和w都会增加一维。但是在本课程中，为了简化计算和便于理解，多使用上式的形式，将w和b分开比较好。

  注意到上式的线性输出区间为整个实数范围，而逻辑回归要求输出范围在[0,1]之间，所以需要进行转换。引入Sigmiod函数（神经网络激活函数），让输出限定在[0,1]之间。

3、logistic回归损失函数

  逻辑回归中，w和b都是未知参数，需要反复训练优化得的。为了训练logistic回归模型的参数w以及b，需要定义一个成本函数（cost function）。它是关于未知参数w和b的函数，我们的目标是在训练模型时，要找到合适的w和b，让成本函数J尽可能的小。

  Loss(error) function：损失函数（误差函数），可以用来衡量算法的运行情况。这个的直观理解就是我们通过定义这个损失函数L来衡量你的预测输出值y帽和y的实际值有多接近。

• 可以定义损失函数为y帽和y的差的平方，或者它们差的平方的1/2，但是这样做的话，会发现之后讨论的优化问题，会变成非凸的，最后会得到很多个局部最优解，梯度下降法可能找不到全局最优解。

  在logistic回归中，我们会定义一个不同的损失函数它有和误差平方相似的作用，这些会给我们一个凸的优化问题。一般而言，我们偏向研究凸函数问题。

• 对于这个损失函数，我们也想让它尽可能的小。
• 损失函数是在单个训练样本中定义的，它衡量了在单个训练样本上的表现。

  下面定义一个成本函数，它衡量的是在全体训练样本上的表现。成本函数J是根据之前得到的两个参数w和b，J(w,b)=损失函数求和/m.，即所有m个训练样本的损失函数和的平均。

4、梯度下降法（Gradient Descent）

  损失函数是衡量单一训练样例的效果，成本函数用来衡量在全部训练集上参数w和b的效果。下面我们讨论如何使用梯度下降法来训练或学习训练集上的参数w和b。

  我们希望找到使成本函数J(w,b)尽可能小的w和b。

• 通过上式不断的更新迭代w。

  由于J(w,b)是凸函数，梯度下降算法（Gradient Descent）是先随机选组一组参数w和b值，然后每次迭代的过程中分别沿着w和b的梯度（偏导数）的反方向前进一小步，不断修正w和b。每次迭代更新w和b后，都能让J(w,b)更接近全局最小值。

  梯度下降算法每次迭代更新，w和b的修正表达式为：

• alpha是学习因子（learning rate），表示梯度下降的步进长度，其值越大，w和b每次更新的“步伐”更大一些；越小，更新“步伐”更小一些。在程序代码中，我们通常使用dw来表示。

  一个神经网络的计算过程是通过正向传播（Forward Propagation）和反向传播（Back Propagation）过程来实现的，首先计算出神经网络的输出，紧接着进行一个反向传输操作，后者我们用来计算出对应的梯度或者函数。

5、课后习题

搭建一个能够**【识别猫】** 的简单的神经网络

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()
 
# index = 25
# plt.imshow(train_set_x_orig[index])
# plt.show()
# print("train_set_y=" + str(train_set_y))
 
m_train = train_set_y.shape[1]  # 训练集里图片的数量。
m_test = test_set_y.shape[1]  # 测试集里图片的数量。
num_px = train_set_x_orig.shape[1]  # 训练、测试集里面的图片的宽度和高度（均为64x64）。
 
# 现在看一看我们加载的东西的具体情况
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))
 
# 为了方便，我们要把维度为（64，64，3）的numpy数组重新构造为（64 x 64 x3，1）的数组，要乘以3的原因是每张图片是由64x64像素构成的，
# 而每个像素点由（R，G，B）三原色构成的，所以要乘以3。在此之后，我们的训练和测试数据集是一个numpy数组，
# 【每列代表一个平坦的图像】 ，应该有m_train和m_test列。
 
# 当你想将形状（a，b，c，d）的矩阵X平铺成形状（b * c * d，a）的矩阵X_flatten时，可以使用以下代码：
# X_flatten = X.reshape(X.shape [0]，-1).T ＃X.T是X的转置
# 将训练集的维度降低并转置。
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))
 
# 为了表示彩色图像，必须为每个像素指定红色，绿色和蓝色通道（RGB），因此像素值实际上是从0到255范围内的三个数字的向量。
# 机器学习中一个常见的预处理步骤是对数据集进行居中和标准化，这意味着可以减去每个示例中整个numpy数组的平均值，
# 然后将每个示例除以整个numpy数组的标准偏差。但对于图片数据集，它更简单，更方便，几乎可以将数据集的每一行除以255（像素通道的最大值），
# 因为在RGB中不存在比255大的数据，所以我们可以放心的除以255，让标准化的数据位于[0,1]之间，现在标准化我们的数据集：
train_set_x = train_set_x_flatten / 255
test_set_x = test_set_x_flatten / 255
 
# 完成了对数据的处理，我们现在开始构建神经网络。
# 构建sigmoid()
def sigmoid(z):
    s = 1 / (1 + np.exp(-z))
    return s
 
# 初始化我们需要的参数w和b
def initialize_with_zeros(dim):
    """
        此函数为w创建一个维度为（dim，1）的0向量，并将b初始化为0。
 
        参数：
            dim  - 我们想要的w矢量的大小（或者这种情况下的参数数量）
 
        返回：
            w  - 维度为（dim，1）的初始化向量。
            b  - 初始化的标量（对应于偏差）
    """
    w = np.zeros(shape=(dim, 1))
    b = 0
    # 使用断言来确保我要的数据是正确的
    assert (w.shape == (dim, 1))  # w的维度是(dim,1)
    assert (isinstance(b, float) or isinstance(b, int))  # b的类型是float或者是int
 
    return (w, b)
 
# 初始化参数的函数已经构建好了，现在就可以执行“前向”和“后向”传播步骤来学习参数。
# 我们现在要实现一个计算成本函数及其渐变的函数propagate（）。
def propagate(w, b, X, Y):
    """
        实现前向和后向传播的成本函数及其梯度。
        参数：
            w  - 权重，大小不等的数组（num_px * num_px * 3，1）
            b  - 偏差，一个标量
            X  - 矩阵类型为（num_px * num_px * 3，训练数量）
            Y  - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据数量)
 
        返回：
            cost- 逻辑回归的负对数似然成本
            dw  - 相对于w的损失梯度，因此与w相同的形状
            db  - 相对于b的损失梯度，因此与b的形状相同
    """
    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)  # 去除所有维度为1的轴，将cost转化为一个标量值
    assert(cost.shape == ())  # () 表示空的形状元组，表示这是一个零维数组，即标量。
 
    # 创建一个字典，把dw和db保存起来
    grads = {"dw": dw, "db": db}
    return (grads, cost)
 
# 构建梯度下降函数
def optimize(w, b, X, Y, num_iterations, learning_rate, print_cost = False):
    """
        此函数通过运行梯度下降算法来优化w和b
 
        参数：
            w  - 权重，大小不等的数组（num_px * num_px * 3，1）
            b  - 偏差，一个标量
            X  - 维度为（num_px * num_px * 3，训练数据的数量）的数组。
            Y  - 真正的“标签”矢量（如果非猫则为0，如果是猫则为1），矩阵维度为(1,训练数据的数量)
            num_iterations  - 优化循环的迭代次数
            learning_rate  - 梯度下降更新规则的学习率
            print_cost  - 每100步打印一次损失值
 
        返回：
            params  - 包含权重w和偏差b的字典
            grads  - 包含权重和偏差相对于成本函数的梯度的字典
            成本 - 优化期间计算的所有成本列表，将用于绘制学习曲线。
 
        提示：
        我们需要写下两个步骤并遍历它们：
            1）计算当前参数的成本和梯度，使用propagate（）。
            2）使用w和b的梯度下降法则更新参数。
    """
    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('迭代的次数：%i, 误差值： %f' % (i, cost))
 
    params = {
            "w": w,
            "b": b}
    grads = {
            "dw": dw,
            "db": db}
    return (params, grads, costs)
 
# optimize函数会输出已学习的w和b的值，我们可以使用w和b来预测数据集X的标签。
# 构建函数predict()
def predict(w, b, X):
    """
        使用学习逻辑回归参数logistic （w，b）预测标签是0还是1，
 
        参数：
            w  - 权重，大小不等的数组（num_px * num_px * 3，1）
            b  - 偏差，一个标量
            X  - 维度为（num_px * num_px * 3，训练数据的数量）的数据
 
        返回：
            Y_prediction  - 包含X中所有图片的所有预测【0 | 1】的一个numpy数组（向量）
 
    """
    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]):
        # 将概率a [0，i]转换为实际预测p [0，i]
        Y_prediction[0, i] = 1 if A[0, i] > 0.5 else 0
    # 断言
    assert (Y_prediction.shape == (1, m))
    return Y_prediction
 
# 测试predict
# print("====================测试predict====================")
# w, b, X, Y = np.array([[1], [2]]), 2, np.array([[1, 2], [3, 4]]), np.array([[1, 0]])
# print("predictions = " + str(predict(w, b, X)))
 
# 这些函数统统整合到一个model()函数
def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000 , learning_rate = 0.5 , print_cost = False):
    """
        通过调用之前实现的函数来构建逻辑回归模型
 
        参数：
            X_train  - numpy的数组,维度为（num_px * num_px * 3，m_train）的训练集
            Y_train  - numpy的数组,维度为（1，m_train）（矢量）的训练标签集
            X_test   - numpy的数组,维度为（num_px * num_px * 3，m_test）的测试集
            Y_test   - numpy的数组,维度为（1，m_test）的（向量）的测试标签集
            num_iterations  - 表示用于优化参数的迭代次数的超参数
            learning_rate  - 表示optimize（）更新规则中使用的学习速率的超参数
            print_cost  - 设置为true以每100次迭代打印成本
 
        返回：
            d  - 包含有关模型信息的字典。
    """
    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和b
    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_prediciton_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('cost')
# plt.xlabel('iterations (per hundreds)')
# plt.title("Learning rate =" + str(d["learning_rate"]))
# plt.show()
 
# 尝试使用不同初始化的learning_rates变量值，并对比结果
learning_rates = [0.01, 0.001, 0.0001]
models = {}
for i in learning_rates:
    print("learning rate is: " + str(i))
    models[str(i)] = model(train_set_x, train_set_y, test_set_x, test_set_y, num_iterations = 1500, learning_rate = i, print_cost = False)
    print('\n' + "-------------------------------------------------------" + '\n')
 
for i in learning_rates:
    plt.plot(np.squeeze(models[str(i)]["costs"]), label= str(models[str(i)]["learning_rate"]))
 
plt.ylabel('cost')
plt.xlabel('iterations')
 
legend = plt.legend(loc='upper center', shadow=True)
frame = legend.get_frame()
frame.set_facecolor('0.90')
plt.show()