1.2.神经网络基础

1.2.1.Logistic回归

1.2.2 梯度下降算法

1.2.3 导数

1.2.4 向量化编程

1.2.5 正向传播与反向传播

1.2.6.练习

1.2.神经网络基础

1.2.1.Logistic回归

1.2.1.1.Logistic回归

逻辑回归是一个主要用于二分分类类的算法。那么逻辑回归是给定一个x , 输出一个该样本属于1对应类别的预测概率y^=P(y=1∣x)。

Logistic 回归中使用的参数如下：

输入的特征向量：x∈Rnx,x是一个nx维的特征数量，用于训练的标签：y∈0,1
参数：权重：w∈Rnx, 偏置：b∈R
输出预测结果：
- Sigmoid 函数：
- 如果z的结果非常大，那么S的结果接近于1
- 如果 z的结果较小或者是非常大的负数，那么S的结果接近于0

$e_{}^{-z}$ 的函数如下

例如：

1.2.2.1.逻辑回归损失函数

损失函数（loss function）用于衡量预测结果与真实值之间的误差。最简单的损失函数定义方式为平方差损失：

逻辑回归一般使用：

该式子的理解：

如果y=1,损失为−logy^，那么要想损失越小，y^的值必须越大，即越趋近于或者等于1
如果y=0,损失为-log(1−y^),那么要想损失越小，那么y^的值越小，即趋近于或者等于0

损失函数是在单个训练样本中定义的，它衡量了在单个训练样本上的表现。代价函数（cost function）衡量的是在全体训练样本上的表现，即衡量参数 w 和 b 的效果，所有训练样本的损失平均值

1.2.2.梯度下降算法

目的：使损失函数的值找到最小值

方式：梯度下降

函数的梯度（gradient）指出了函数的最陡增长方向。梯度的方向走，函数增长得就越快。那么按梯度的负方向走，函数值自然就降低得最快了。模型的训练目标即是寻找合适的 w 与 b 以最小化代价函数值。假设 w 与 b 都是一维实数，那么可以得到如下的 J 关于 w 与 b 的图：

可以看到，成本函数 J 是一个凸函数，与非凸函数的区别在于其不含有多个局部最低。

参数w和b的更新公式为：

注：其中 α 表示学习速率，即每次更新的 w 的步伐长度。当 w 大于最优解 w′ 时，导数大于 0，那么 w 就会向更小的方向更新。反之当 w 小于最优解 w′ 时，导数小于 0，那么 w 就会向更大的方向更新。迭代直到收敛。

通过平面来理解梯度下降过程：

1.2.3.导数

理解梯度下降的过程之后，我们通过例子来说明梯度下降在计算导数意义或者说这个导数的意义。

1.2.3.1.导数

导数也可以理解成某一点处的斜率。斜率这个词更直观一些。

各点处的导数值一样

我们看到这里有一条直线，这条直线的斜率为4。我们来计算一个例子

例：取一点为a=2,那么y的值为8，我们稍微增加a的值为a=2.001,那么y的值为8.004，也就是当a增加了0.001，随后y增加了0.004，即4倍

那么我们的这个斜率可以理解为当一个点偏移一个不可估量的小的值，所增加的为4倍。

可以记做

各点的导数值不全一致
例：取一点为a=2,那么y的值为4，我们稍微增加a的值为a=2.001,那么y的值约等于4.004（4.004001），也就是当a增加了0.001，随后y增加了4倍

取一点为a=5,那么y的值为25，我们稍微增加a的值为a=5.001,那么y的值约等于25.01（25.010001），也就是当a增加了0.001，随后y增加了10倍

1.2.3.2 导数计算图

那么接下来我们来看看含有多个变量的到导数流程图，假设J(a,b,c)=3(a+bc)

我们以下面的流程图代替

这样就相当于从左到右计算出结果，然后从后往前计算出导数

导数计算

问题：那么现在我们要计算J相对于三个变量a,b,c的导数？

假设b=4,c=2,a=7,u=8,v=15,j=45

增加v从15到15.001，那么J≈45.003

增加a从7到7.001,那么v=≈15.001，J≈45.003

这里也涉及到链式法则

1.2.3.3 链式法则

1.2.3.4 逻辑回归的梯度下降

逻辑回归的梯度下降过程计算图，首先从前往后的计算图得出如下

那么计算图从前向过程为,假设样本有两个特征

问题：计算出J 关于z的导数

所以我们这样可以求出总损失相对于w1,w2,b参数的某一点导数，从而可以更新参数

相信上面的导数计算应该都能理解了，所以当我们计算损失函数的某个点相对于�1,�2,�w1,w2,b的导数之后，就可以更新这次优化后的结果。

1.2.4.向量化编程

每更新一次梯度时候，在训练期间我们会拥有m个样本，那么这样每个样本提供进去都可以做一个梯度下降计算。所以我们要去做在所有样本上的计算结果、梯度等操作

计算参数的梯度为：这样，我们想要得到最终的dw1,dw2,db，如何去设计一个算法计算？伪代码实现：

1.2.4.1 向量化优势

什么是向量化

由于在进行计算的时候，最好不要使用for循环去进行计算，因为有Numpy可以进行更加快速的向量化计算。

import numpy as np
import time
a = np.random.rand(100000)
b = np.random.rand(100000)

第一种方法

# 第一种for 循环
c = 0
start = time.time()
for i in range(100000):
    c += a[i]*b[i]
end = time.time()

print("计算所用时间%s " % str(1000*(end-start)) + "ms")

第二种向量化方式使用np.dot

# 向量化运算
start = time.time()
c = np.dot(a, b)
end = time.time()
print("计算所用时间%s " % str(1000*(end-start)) + "ms")

Numpy能够充分的利用并行化，Numpy当中提供了很多函数使用

函数	作用
np.ones or np.zeros	全为1或者0的矩阵
np.exp	指数计算
np.log	对数计算
np.abs	绝对值计算

所以上述的m个样本的梯度更新过程，就是去除掉for循环。原本这样的计算

1.2.4.2 向量化实现伪代码

思路

可以变成这样的计算

注：w的形状为(n,1), x的形状为(n, m)，其中n为特征数量，m为样本数量

我们可以让，得出的结果为(1, m)大小的矩阵注：大写的W,X为多个样本表示

实现多个样本向量化计算的伪代码

这相当于一次使用了M个样本的所有特征值与目标值，那我们知道如果想多次迭代，使得这M个样本重复若干次计算

1.2.5.正向传播与反向传播

前面我们所做的整个过程分为两个部分，一个是从前往后的计算出梯度与损失，另外一部分是从后往前计算参数的更新梯度值。所以在神经网络当中会经常出现两个概念，正向传播与反向传播。

正向传播是神经网络从输入到输出的过程，主要用于计算输出结果。

反向传播是根据输出和目标值之间的差距调整网络参数的过程，主要用于优化网络的权重和偏置。这两个过程交替进行，直到网络的损失函数最小化，达到训练目标。

1.2.6.练习

1.使用np.exp()实现sigmoid function和sigmoid gradient（梯度）

import numpy as np
def basic_sigmoid(x):
    """
    计算sigmoid函数
    """
    s = 1 / (1 + np.exp(-x))
    
    return s

def sigmoid_derivative(x):
    """
    计算sigmoid function函数相对于其输入x的梯度（也称为斜率或者导数）.
    """
    s=basic_sigmoid(x)
    ds=s*(1-s)
   
    return ds

2.实现单神经元网络

import numpy as np
import h5py
import scipy
from PIL import Image
from scipy import ndimage
from data import load_dataset
#%% md
## 要求
实现一个学习算法的整体结构
* 获取并定义模型输入
* 初始化参数
* 计算成本函数及其梯度
* 使用优化算法（梯度下降）
    * 循环：
    * 计算当前损失（正向传播）
    * 计算当前梯度（反向传播）
    * 更新参数（梯度下降）

请实现相关函数，其中读取数据不需要实现。并在主模型函数中编写逻辑。
#%% md
### 读取数据
1、按照向量化伪代码实现的形状要求将样本数据进行转换
2、标准化数据处理
#%%
train_x, train_y, test_x, test_y, classes = load_dataset()
print ("训练集的样本数: ", train_x.shape[0])
print ("测试集的样本数: " , test_x.shape[0])
print ("train_x形状: ", train_x.shape)
print ("train_y形状: ", train_y.shape)
print ("test_x形状: ", test_x.shape)
print ("test_x形状: ", test_y.shape)
#%%
train_y
#%%
train_x = train_x.reshape(train_x.shape[0], -1).T
test_x = test_x.reshape(test_x.shape[0], -1).T
print(train_x.shape, test_x.shape)
#%%
train_x = train_x/255.
test_x = test_x/255.
#%%
def basic_sigmoid(x):
    """
    计算sigmoid函数
    """
    
    ### 开始
    s = 1 / (1 + np.exp(-x))
    ### 结束
    
    return s
#%% md
### 算法结构实现
分别构建算法的不同模块
* 初始化参数
* 计算成本函数及其梯度
* 使用优化算法（梯度下降）
    * 循环：
    * 计算当前损失（正向传播）
    * 计算当前梯度（反向传播）
    * 更新参数（梯度下降）
 
 <img src="images/题目逻辑.png" style="width:600px;height:550px;">
#%% md
### 初始化网络参数
#%%
def initialize_with_zeros(shape):
    """
    创建一个形状为 (shape, 1) 的w参数和b=0.
    return:w, b
    """
    
    ### 开始
    w = np.zeros((shape, 1))
    b = 0

    ### 结束

    assert(w.shape == (shape, 1))
    assert(isinstance(b, float) or isinstance(b, int))
    
    return w, b
#%% md
### 前向和反向传播
根据损失函数、前后传播向量化代码
#%%
def propagate(w, b, X, Y):
    """
    参数：w,b,X,Y：网络参数和数据
    Return:
    损失cost、参数W的梯度dw、参数b的梯度db
    """
    m = X.shape[1]
    
    # 前向传播
    ### 开始
    # w (n,1), x (n, m)
    A = basic_sigmoid(np.dot(w.T, X) + b)
    # 计算损失
    cost = -1 / m * np.sum(Y * np.log(A) + (1 - Y) * np.log(1 - A))
    ### 结束

    # 反向传播
    ### 开始
    dz = A - Y
    dw = 1 / m * np.dot(X, dz.T)
    db = 1 / m * np.sum(dz)
    ### 结束

    assert(dw.shape == w.shape)
    assert(db.dtype == float)
    cost = np.squeeze(cost)
    assert(cost.shape == ())
    
    grads = {"dw": dw,
             "db": db}
    
    return grads, cost
#%% md
### 优化过程
实现优化函数. 全局的参数随着 $w$  $b$ 对损失 $J$进行优化改变. 对参数 $\theta$实行 $ \theta = \theta - \alpha \text{ } d\theta$, 并制定 $\alpha$ 学习率。
#%%
def optimize(w, b, X, Y, num_iterations, learning_rate):
    """
    参数：
    w:权重,b:偏置,X特征,Y目标值,num_iterations总迭代次数,learning_rate学习率
    Returns:
    params:更新后的参数字典
    grads:梯度
    costs:损失结果
    """
    
    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 i % 100 == 0:
            print("损失结果 %i: %f" %(i, cost))
            print(b)
    
    params = {"w": w,
              "b": b}
    
    grads = {"dw": dw,
             "db": db}
    
    return params, grads, costs
#%% md
### 预测函数（不用实现）
利用得出的参数来进行测试得出准确率
#%%
def predict(w, b, X):
    '''
    利用训练好的参数预测
    
    return：预测结果
    '''
    
    m = X.shape[1]
    Y_prediction = np.zeros((1,m))
    w = w.reshape(X.shape[0], 1)
    
    # 计算结果
    ### 开始
    A = basic_sigmoid(np.dot(w.T, X) + b)
    ### 结束

    for i in range(A.shape[1]):
        
        ### 开始
        if A[0, i] <= 0.5:
            Y_prediction[0, i] = 0
        else:
            Y_prediction[0, i] = 1
        ### 结束
    
    assert(Y_prediction.shape == (1, m))
    
    return Y_prediction
#%% md
### 整体逻辑实现
#%%
def model(X_train, Y_train, X_test, Y_test, num_iterations = 2000, learning_rate = 0.5):
    """
    """
    
    ### 开始
    
    # 初始化参数
    w, b = initialize_with_zeros(X_train.shape[0])

    # 梯度下降
    # params:更新后的网络参数
    # grads:最后一次梯度
    # costs:每次更新的损失列表
    params, grads, costs = optimize(w, b, X_train, Y_train, num_iterations, learning_rate)
    
    # 获取训练的参数
    # 预测结果
    w = params['w']
    b = params['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
#%% md
### 测试
#%%
d = model(train_x, train_y, test_x, test_y, num_iterations = 2000, learning_rate = 0.005)

data.py

import numpy as np
import h5py
    
    
def load_dataset():
    train_dataset = h5py.File('datasets/train_catvnoncat.h5', "r")
    train_set_x_orig = np.array(train_dataset["train_set_x"][:]) # your train set features
    train_set_y_orig = np.array(train_dataset["train_set_y"][:]) # your train set labels

    test_dataset = h5py.File('datasets/test_catvnoncat.h5', "r")
    test_set_x_orig = np.array(test_dataset["test_set_x"][:]) # your test set features
    test_set_y_orig = np.array(test_dataset["test_set_y"][:]) # your test set labels

    classes = np.array(test_dataset["list_classes"][:]) # the list of classes
    
    train_set_y_orig = train_set_y_orig.reshape((1, train_set_y_orig.shape[0]))
    test_set_y_orig = test_set_y_orig.reshape((1, test_set_y_orig.shape[0]))
    
    return train_set_x_orig, train_set_y_orig, test_set_x_orig, test_set_y_orig, classes