整合 逻辑回归 BGD(批量)+MBGD(小批量)+SGD(随机)底层实现 优缺点以及代码实现

梯度下降法作为机器学习中较常使用的优化算法，其有着三种不同的形式

1、批量梯度下降（Batch Gradient Descent，BGD）

批量梯度下降法是最原始的形式，它是指在每一次迭代时使用所有样本来进行梯度的更新。
 优点：
 （1）一次迭代是对所有样本进行计算，此时利用矩阵进行操作，实现了并行。
 （2）由全数据集确定的方向能够更好地代表样本总体，从而更准确地朝向极值所在的方向。当目标函数为凸函数时，BGD一定能够得到全局最优。
 缺点：
 （1）当样本数目 mm 很大时，每迭代一步都需要对所有样本计算，训练过程会很慢。
  从迭代的次数上来看，BGD迭代的次数相对较少。其迭代的收敛曲线示意图可以表示如下：

2、随机梯度下降（Stochastic Gradient Descent，SGD）

随机梯度下降法不同于批量梯度下降，随机梯度下降是每次迭代使用一个样本来对参数进行更新。使得训练速度加快。
 　优点：
  （1）由于不是在全部训练数据上的损失函数，而是在每轮迭代中，随机优化某一条训练数据上的损失函数，这样每一轮参数的更新速度大大加快。
  缺点：
  （1）准确度下降。由于即使在目标函数为强凸函数的情况下，SGD仍旧无法做到线性收敛。
  （2）可能会收敛到局部最优，由于单个样本并不能代表全体样本的趋势。
  （3）不易于并行实现。

解释一下为什么SGD收敛速度比BGD要快：
  答：这里我们假设有30W个样本，对于BGD而言，每次迭代需要计算30W个样本才能对参数进行一次更新，需要求得最小值可能需要多次迭代（假设这里是10）；而对于SGD，每次更新参数只需要一个样本，因此若使用这30W个样本进行参数更新，则参数会被更新（迭代）30W次，而这期间，SGD就能保证能够收敛到一个合适的最小值上了。也就是说，在收敛时，BGD计算了 10×30W10×30W 次，而SGD只计算了 1×30W1×30W 次。

从迭代的次数上来看，SGD迭代的次数较多，在解空间的搜索过程看起来很盲目。其迭代的收敛曲线示意图可以表示如下：

3、小批量梯度下降（Mini-Batch Gradient Descent, MBGD）

小批量梯度下降，是对批量梯度下降以及随机梯度下降的一个折中办法。其思想是：每次迭代 使用 ** batch_size** 个样本来对参数进行更新。
  
  优点：
  （1）通过矩阵运算，每次在一个batch上优化神经网络参数并不会比单个数据慢太多。
  （2）每次使用一个batch可以大大减小收敛所需要的迭代次数，同时可以使收敛到的结果更加接近梯度下降的效果。(比如上例中的30W，设置batch_size=100时，需要迭代3000次，远小于SGD的30W次)
  （3）可实现并行化。
  缺点：
  （1）batch_size的不当选择可能会带来一些问题。

batcha_size的选择带来的影响：
  (1)在合理地范围内，增大batch_size的好处：
    a. 内存利用率提高了，大矩阵乘法的并行化效率提高。
    b. 跑完一次 epoch（全数据集）所需的迭代次数减少，对于相同数据量的处理速度进一步加快。
    c. 在一定范围内，一般来说 Batch_Size 越大，其确定的下降方向越准，引起训练震荡越小。
  （2）盲目增大batch_size的坏处：
    a. 内存利用率提高了，但是内存容量可能撑不住了。
    b. 跑完一次 epoch（全数据集）所需的迭代次数减少，要想达到相同的精度，其所花费的时间大大增加了，从而对参数的修正也就显得更加缓慢。
    c. Batch_Size 增大到一定程度，其确定的下降方向已经基本不再变化。

具体代码如下：

import numpy as np
from numpy import *
import matplotlib.pyplot as plt
from sklearn import linear_model

'''
BGD: 批量梯度下降
MBGD：小批量梯度下降
SGD：随机梯度下降
'''
# 显示中文
from pylab import *  # 显示中文

mpl.rcParams['font.sans-serif'] = ['SimHei']  # 显示中文

# 画图中显示负号
import matplotlib

matplotlib.rcParams['axes.unicode_minus'] = False

# 数据预处理
# 数据加载
data = np.loadtxt('ex1data1.txt', delimiter=',');
print(data)
# order=np.random.permutation(data.shape[0])
# data=data[order]
# 提取数据X,y
X = data[:, :-1];
print(X)
y = data[:, -1];
print(y)

# 数据的初始化/标准化
m = X.shape[0]  # 样本个数m
X = np.c_[np.ones(m), X];
print(X)
y = np.c_[y];
print(y)


# 定义模型model
def model(X, theta):
    return np.dot(X, theta)


# 定义代价函数costFunction
def costFunction(h, y):
    m = y.shape[0]
    J = 1.0 / (2 * m) * np.dot((h - y).T, (h - y))  # J.shape=(1,1) 当h.shape=(2,1),y.shape=(2,1)
    # J = 1.0 / (2.0 * m) * np.sum((h - y) * (h - y))
    return J


# 计算精度的函数
def score(X, y, theta):
    h = model(X, theta)
    y_mean = np.mean(y)
    u = np.sum((h - y) ** 2)  # 计算预测值与真实值的方差
    v = np.sum((y - y_mean) ** 2)  # 计算真实值方差
    score = 1 - u / v
    return score


# 定义梯度下降算法gradDesc：BS-批量大小；epsilon-两次theta误差
def gradDesc(X, y, epoch=150, alpha=0.005, epsilon=1e-330, BS=97):
    m, n = X.shape  # 样本个数m，列数n
    theta = np.zeros((n, 1))  # 初始化theta为0
    J_history = []  # 初始化历史代价记录

    theta_old = theta  # 初始化theta前值
    # isStop=False   #终止标志
    count = 0  # 记录迭代步数

    # 梯度下降算法
    for j in range(epoch):

        # 每次全部样本训练完后，重新洗牌
        order = np.random.permutation(m)
        X, y = X[order], y[order]

        # 每次选取BS(batch_size)个样本进行梯度下降
        b = int(np.ceil(m / BS))  # 批次数b:batches
        for i in range(b):

            # if (m%BS!=0 and i==b):
            #     X_B, y_B = X[i * BS:m], y[i * BS:m]
            # elif (i < b):
            #     X_B, y_B = X[i * BS:(i + 1) * BS], y[i * BS:(i + 1) * BS]
            # elif (m%BS==0 and i==b):
            #     break

            batch_id = BS * i  # batch_id代表每个批次里样本的id
            X_B = X[batch_id: min(batch_id + BS, len(X))]
            y_B = y[batch_id: min(batch_id + BS, len(y))]

            h = model(X_B, theta)  # 预测值
            J_history.append(costFunction(h, y_B))  # 记录代价

            # 计算梯度，更新theta
            delta_theta = 1.0 / len(X_B) * np.dot(X_B.T, (h - y_B))  # 计算梯度
            theta -= alpha * delta_theta  # 更新theta

            count += 1  # 记录迭代次数
            if np.linalg.norm(theta - theta_old) < epsilon:  # 若满足两次theta差小于epsilon
                # isStop=True
                break
            else:
                theta_old = theta

    return theta, J_history, count


# 调用梯度下降算法
theta, J_history, count = gradDesc(X, y, BS=1)     # BS=1 随机梯度下降  BS=97批量梯度下降
print(theta)

# 画代价曲线
plt.figure('代价曲线')
plt.title('代价曲线')
plt.xlabel('迭代次数')
plt.ylabel('代价')
plt.plot(np.squeeze(J_history))  # np.array(J_history).shape(150,1,1)
plt.show()

# 计算精度并输出
score = score(X, y, theta)
print('精度=', score * 100, '%')

# 画出所有的样本及回归直线
plt.figure('样本及回归直线')
plt.title('样本及回归直线：精度=' + str(round(score, 3)))
plt.scatter(X[:, 1], y[:, 0], c='r', marker='x')
h = model(X, theta)
plt.plot(X[:, 1], h[:, 0])
plt.xlabel('X1')
plt.ylabel('X2')
plt.show()