数据分析-深度学习Pytorch Day11

news2024/12/23 18:00:30

首先要搞懂损失函数与代价函数。

损失函数是单个样本与真实值之间的差距

代价函数是整个样本集与真实值的平均差距

随机梯度下降就是不使用代价函数对参数进行更新，而是使用损失函数对参数更新。

梯度下降法( gradient descent )是一阶最优化算法，通常也称为最速下降法，是通过函数当前点对应梯度(或者是近似梯度)的反方向，使用规定步长距离进例行迭代搜索，从而找到一一个函数的局部极小值的算法，最好的情况是希望找到全局极小值。但是在使用梯度下降算法时，每次更新参数都需要使用所有的样本。如果对所有的样本均计算一次，当样本总量特别大时,对算法的速度影响非常大，所以就有了随机梯度下降(stochastic gradient descent, SGD )算法。它是对梯度下降法算法的一种改进，且每次只随机取一部分样本进行优化，样本的数量一般是2的整数次幂，取值范围是32~256,以保证计算精度的同时提升计算速度，是优化深度学习网络中最常用的一类算法。

SGD算法及其一些变种，是深度学习中应用最多的一类算法。在深度学习中，SCD通常指小批随机梯度下降( mini-batch gradient descent )算法，其在训练过程中，通常会使用一个固定的学习率进行训练。即

gt是梯度， n是学习率，学习率用来调整梯度影响大小，梯度完全依赖于batch得到的数据

由于随机梯度下降算法的缺点，动量的思想被加入到算法中：动量通过模拟物体运动的方向，在更新时会在一定程度上考虑之前参数更新的大小和方向，同时利用batch计算得到的梯度，两者结合起来计算出最终参数的大小以及方向，引入动量之后，参数更新方式为：

mt是当前动量的累加， u 是动量因子，用于调整上一步动量对参数更新时的重要程度，利用动量的方式可以使得算法跳出局部最优解的陷阱

梯度下降：

import matplotlib.pyplot as plt
import numpy as np

x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

m = len(x_data)
w = 1.0

def forward(x, w):
    return w * x

def cost_fun(x, y, w):
    cost = 0
    for x_val, y_val in zip(x, y):
        pred = forward(x_val, w)
        cost += 1 / m * (pred - y_val) ** 2
    return cost

def gradient_fun(x, y, w):
    gradient = 0
    for x_val, y_val in zip(x, y):
        pred = forward(x_val, w)
        gradient += 2 * (1 / m) * x_val * (pred - y_val)
    return gradient

print('predict before training:', 4, forward(4, w))
epoches = 20
lr = 0.03
cost_list = []
for epoch in range(epoches):
    cost_val = cost_fun(x_data, y_data, w)
    grad_val = gradient_fun(x_data, y_data, w)
    w -= lr * grad_val
    cost_list.append(cost_val)
    print('epoch:', epoch, 'w:', w, 'cost:', cost_val)

print('predict after training:', 4, forward(4, w))


# 绘图
epoch = np.arange(epoches)
plt.plot(epoch, cost_list)
plt.xlabel('epoch')
plt.ylabel('cost')
plt.show()

随机梯度下降：

import matplotlib.pyplot as plt
import numpy as np

x_data = [1.0, 2.0, 3.0]
y_data = [2.0, 4.0, 6.0]

w = 1.0
m = len(x_data)
def forward(x, w):
    return w * x

def loss_fun(x, y, w):
    pred = forward(x, w)
    loss = (pred - y) ** 2
    return loss

def gradient(x, y, w):
    pred = forward(x, w)
    grad = 2 * x * (pred - y)
    return grad

epoches = 30
lr = 0.03
loss_list = []

for epoch in np.arange(epoches):
    print('epoch:', epoch)
    loss_sum = 0
    for x_val, y_val in zip(x_data, y_data):
        grad = gradient(x_val, y_val, w)
        loss_val = loss_fun(x_val, y_val, w)
        loss_sum += loss_val
        w -= lr * grad
        print('\t', 'w:', w, 'loss:', loss_val)
    loss_list.append(loss_sum / m)
print('predict after training:', 4, forward(4, w))

epoch = np.arange(epoches)
plt.plot(epoch, loss_list)
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()

在学习率相同的情况下，采取随机梯度下降可以获得更快的收敛效果。