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

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

文章目录

    • 1、批量梯度下降(Batch Gradient Descent,BGD)
    • 2、随机梯度下降(Stochastic Gradient Descent,SGD)
    • 3、小批量梯度下降(Mini-Batch Gradient Descent, MBGD)

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()

你可能感兴趣的:(机器学习,随机梯度下降,机器学习)