NNDL 实验八 网络优化与正则化（3）不同优化算法比较

最新推荐文章于 2024-05-20 19:08:38 发布
最新推荐文章于 2024-05-20 19:08:38 发布
阅读量325 收藏
点赞数 1
分类专栏： 深度学习 文章标签： 人工智能
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52086410/article/details/128183680
版权

目录

7.3 不同优化算法的比较分析

7.3.1 优化算法的实验设定

 7.3.1.1 2D可视化实验

 7.3.1.2 简单拟合实验

 7.3.2 学习率调整

 7.3.2.1 AdaGrad算法

 7.3.2.2 RMSprop算法

 7.3.3 梯度估计修正

 7.3.3.1 动量法

 7.3.3.2 Adam算法

7.3.4 不同优化器的3D可视化对比 

参考 

7.3 不同优化算法的比较分析

除了批大小对模型收敛速度的影响外，学习率和梯度估计也是影响神经网络优化的重要因素。

神经网络优化中常用的优化方法也主要是如下两方面的改进，包括：

  • 学习率调整：通过自适应地调整学习率使得优化更稳定。AdaGrad、RMSprop、AdaDelta算法等。
  • 梯度估计修正：通过修正每次迭代时估计的梯度方向来加快收敛速度。动量法、Nesterov加速梯度方法等。

本节还会介绍综合学习率调整和梯度估计修正的优化算法，如Adam算法。

7.3.1 优化算法的实验设定

 7.3.1.1 2D可视化实验

为了更好地展示不同优化算法的能力对比，我们选择一个二维空间中的凸函数，然后用不同的优化算法来寻找最优解，并可视化梯度下降过程的轨迹。

 

 被优化函数 选择Sphere函数作为被优化函数，并对比它们的优化效果。Sphere函数的定义为：

 sphere(x)=\sum_{d=1}^{D}x_{d}^{2} =x^{2}

其中x\in \mathbb{R} ^{D}，x^{2}表示逐元素平方。Sphere函数有全局的最优点x^{*}=0。

这里为了展示方便，我们使用二维的输入并略微修改Sphere函数，定义sphere(x)=w^{T}x^{2}，并根据梯度下降公式计算对x的偏导

 \frac{\partial sphere(x)}{\partial x} =2w\odot x

其中⊙表示逐元素积。

 将被优化函数实现为OptimizedFunction算子，其forward方法是Sphere函数的前向计算，backward方法则计算被优化函数对xx的偏导。代码实现如下：

from nndl.op import Op
import torch
import numpy as np
from matplotlib import pyplot as plt
 
 
class OptimizedFunction(Op):
    def __init__(self, w):
        super(OptimizedFunction, self).__init__()
        self.w = w
        self.params = {'x': 0}
        self.grads = {'x': 0}
 
    def forward(self, x):
        self.params['x'] = x
        return torch.matmul(self.w.T, torch.tensor(torch.square(self.params['x']), dtype=torch.float32))
 
    def backward(self):
        self.grads['x'] = 2 * torch.multiply(self.w.T, self.params['x'])

 其中的op

import torch
import os
from activation import softmax
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE" # 这里报错
torch.manual_seed(10) #设置随机种子

class Op(object):
    def __init__(self):
        pass

    def __call__(self, inputs):
        return self.forward(inputs)

    def forward(self, inputs):
        raise NotImplementedError

    def backward(self, inputs):
        raise NotImplementedError

 小批量梯度下降优化器 复用3.1.4.3节定义的梯度下降优化器SimpleBatchGD。按照梯度下降的梯度更新公式\theta _{t}\longleftarrow \theta _{t-1}-\alpha g_{t}进行梯度更新。

import copy
def train_f(model, optimizer, x_init, epoch):
 
    x = x_init
    all_x = []
    losses = []
    for i in range(epoch):
        all_x.append(copy.copy(x.numpy()))
        loss = model(x)
        losses.append(loss)
        model.backward()
        optimizer.step()
        x = model.params['x']
        print(all_x)
    return torch.tensor(all_x), losses

 可视化函数 定义一个Visualization类，用于绘制x的更新轨迹。代码实现如下：

import numpy as np
import matplotlib.pyplot as plt
 
 
class Visualization(object):
    def __init__(self):
        """
        初始化可视化类
        """
        # 只画出参数x1和x2在区间[-5, 5]的曲线部分
        x1 = np.arange(-5, 5, 0.1)
        x2 = np.arange(-5, 5, 0.1)
        x1, x2 = np.meshgrid(x1, x2)
        self.init_x = torch.tensor([x1, x2])
 
    def plot_2d(self, model, x, fig_name):
        """
        可视化参数更新轨迹
        """
        fig, ax = plt.subplots(figsize=(10, 6))
        cp = ax.contourf(self.init_x[0], self.init_x[1], model(self.init_x.transpose(0, 1)),
                         colors=['#e4007f', '#f19ec2', '#e86096', '#eb7aaa', '#f6c8dc', '#f5f5f5', '#000000'])
        c = ax.contour(self.init_x[0], self.init_x[1], model(self.init_x.transpose(0, 1)), colors='black')
        cbar = fig.colorbar(cp)
        ax.plot(x[:, 0], x[:, 1], '-o', color='#000000')
        ax.plot(0, 'r*', markersize=18, color='#fefefe')
 
        ax.set_xlabel('$x1$')
        ax.set_ylabel('$x2$')
 
        ax.set_xlim((-2, 5))
        ax.set_ylim((-2, 5))
        plt.savefig(fig_name)

 定义train_and_plot_f函数，调用train_f和Visualization，训练模型并可视化参数更新轨迹。代码实现如下：

import numpy as np
 
 
def train_and_plot_f(model, optimizer, epoch, fig_name):
    """
    训练模型并可视化参数更新轨迹
    """
    # 设置x的初始值
    x_init = torch.tensor([3, 4], dtype=torch.float32)
    print('x1 initiate: {}, x2 initiate: {}'.format(x_init[0].numpy(), x_init[1].numpy()))
    x, losses = train_f(model, optimizer, x_init, epoch)
    print(x)
    losses = np.array(losses)
 
    # 展示x1、x2的更新轨迹
    vis = Visualization()
    vis.plot_2d(model, x, fig_name)

模型训练与可视化 指定Sphere函数中ww的值，实例化被优化函数，通过小批量梯度下降法更新参数，并可视化x的更新轨迹。

from nndl.opitimizer import SimpleBatchGD
 
# 固定随机种子
torch.manual_seed(0)
w = torch.tensor([0.2, 2])
model = OptimizedFunction(w)
opt = SimpleBatchGD(init_lr=0.2, model=model)
train_and_plot_f(model, opt, epoch=20, fig_name='opti-vis-para.pdf')

 其中opitimizer

class Optimizer(object):
    def __init__(self, init_lr, model):
        """
        优化器类初始化
        """
        #初始化学习率，用于参数更新的计算
        self.init_lr = init_lr
        #指定优化器需要优化的模型
        self.model = model

    @abstractmethod
    def step(self):
        """
        定义每次迭代如何更新参数
        """
        pass


#新增梯度下降法优化器
class SimpleBatchGD(Optimizer):
    def __init__(self, init_lr, model):
        super(SimpleBatchGD, self).__init__(init_lr=init_lr, model=model)

    def step(self):
        #参数更新
        #遍历所有参数，按照公式(3.8)和(3.9)更新参数
        if isinstance(self.model.params, dict):
            for key in self.model.params.keys():
                self.model.params[key] = self.model.params[key] - self.init_lr * self.model.grads[key]

 运行结果

 

 输出图中不同颜色代表f(x_{1},x_{2})的值，具体数值可以参考图右侧的对应表，比如深粉色区域代表f(x_{1},x_{2})在0～8之间，不同颜色间黑色的曲线是等值线，代表落在该线上的点对应的f(x_{1},x_{2})的值都相同。

 7.3.1.2 简单拟合实验

这里我们随机生成一组数据作为数据样本，再构建一个简单的单层前馈神经网络，用于前向计算。

 数据集构建，代码实现如下：

# 固定随机种子
torch.manual_seed(0)
# 随机生成shape为（1000，2）的训练数据
X = torch.randn([1000, 2])
w = torch.tensor([0.5, 0.8])
w = torch.unsqueeze(w, axis=1)
noise = 0.01 * torch.rand([1000])
noise = torch.unsqueeze(noise, axis=1)
# 计算y
y = torch.matmul(X, w) + noise
# 打印X, y样本
print('X: ', X[0].numpy())
print('y: ', y[0].numpy())

# X，y组成训练样本数据
data = torch.concat((X, y), axis=1)
print('input data shape: ', data.shape)
print('data: ', data[0].numpy())

运行结果

 

 定义Linear算子，实现一个线性层的前向和反向计算。代码实现如下：

class Linear(Op):
    def __init__(self, input_size, weight_init=torch.randn, bias_init=torch.zeros):
        super(Linear, self).__init__()
        self.params = {}
        self.params['W'] = weight_init(size=[input_size, 1])
        self.params['b'] = bias_init(size=[1])
        self.inputs = None
        self.grads = {}
 
    def forward(self, inputs):
        self.inputs = inputs
        self.outputs = torch.matmul(self.inputs, self.params['W']) + self.params['b']
        return self.outputs
 
    def backward(self, labels):
        K = self.inputs.shape[0]
        self.grads['W'] = 1. / K * torch.matmul(self.inputs.T, (self.outputs - labels))
        self.grads['b'] = 1. / K * torch.sum(self.outputs - labels, dim=0)

这里backward函数中实现的梯度并不是forward函数对应的梯度，而是最终损失关于参数的梯度．由于这里的梯度是手动计算的，所以直接给出了最终的梯度。 

 训练函数 在准备好样本数据和网络以后，复用优化器SimpleBatchGD类，使用小批量梯度下降来进行简单的拟合实验。

模型训练train函数的代码实现如下： 

 

def train(data, num_epochs, batch_size, model, calculate_loss, optimizer, verbose=False):
 
    # 记录每个回合损失的变化
    epoch_loss = []
    # 记录每次迭代损失的变化
    iter_loss = []
    N = len(data)
    for epoch_id in range(num_epochs):
        # np.random.shuffle(data) #不再随机打乱数据
        # 将训练数据进行拆分，每个mini_batch包含batch_size条的数据
        mini_batches = [data[i:i+batch_size] for i in range(0, N, batch_size)]
        for iter_id, mini_batch in enumerate(mini_batches):
            # data中前两个分量为X
            inputs = mini_batch[:, :-1]
            # data中最后一个分量为y
            labels = mini_batch[:, -1:]
            # 前向计算
            outputs = model(inputs)
            # 计算损失
            loss = calculate_loss(outputs, labels).numpy()
            # 计算梯度
            model.backward(labels)
            # 梯度更新
            optimizer.step()
            iter_loss.append(loss)
        # verbose = True 则打印当前回合的损失
        if verbose:
            print('Epoch {:3d}, loss = {:.4f}'.format(epoch_id, np.mean(iter_loss)))
        epoch_loss.append(np.mean(iter_loss))
    return iter_loss, epoch_loss

 优化过程可视化 定义plot_loss函数，用于绘制损失函数变化趋势。代码实现如下：

def plot_loss(iter_loss, epoch_loss, fig_name):
    """
    可视化损失函数的变化趋势
    """
    plt.figure(figsize=(10, 4))
    ax1 = plt.subplot(121)
    ax1.plot(iter_loss, color='#e4007f')
    plt.title('iteration loss')
    ax2 = plt.subplot(122)
    ax2.plot(epoch_loss, color='#f19ec2')
    plt.title('epoch loss')
    plt.savefig(fig_name)
    plt.show()

对于使用不同优化器的模型训练，保存每一个回合损失的更新情况，并绘制出损失函数的变化趋势，以此验证模型是否收敛。定义train_and_plot函数，调用train和plot_loss函数，训练并展示每个回合和每次迭代(Iteration)的损失变化情况。在模型训练时，使用paddle.nn.MSELoss()计算均方误差。代码实现如下：
 

import torch.nn as nn
def train_and_plot(optimizer, fig_name):
    # 定义均方差损失
    mse = nn.MSELoss()
    iter_loss, epoch_loss = train(data, num_epochs=30, batch_size=64, model=model, calculate_loss=mse, optimizer=optimizer)
    plot_loss(iter_loss, epoch_loss, fig_name)

训练网络并可视化损失函数的变化趋势。代码实现如下：

# 固定随机种子
torch.manual_seed(0)
# 定义网络结构
model = Linear(2)
# 定义优化器
opt = SimpleBatchGD(init_lr=0.01, model=model)
train_and_plot(opt, 'opti-loss.pdf')

运行结果

 从输出结果看，loss在不断减小，模型逐渐收敛。

与Torch API对比，验证正确性

 分别实例化自定义SimpleBatchGD优化器和调用torch.optim.SGD API, 验证自定义优化器的正确性

torch.manual_seed(0)
 
x = data[0, :-1].unsqueeze(0)
y = data[0, -1].unsqueeze(0)
 
model1 = Linear(2)
print('model1 parameter W: ', model1.params['W'].numpy())
opt1 = SimpleBatchGD(init_lr=0.01, model=model1)
output1 = model1(x)
 
model2 = nn.Linear(2, 1)
model2.weight=torch.nn.Parameter(torch.tensor(model1.params['W'].T))
print('model2 parameter W: ', model2.state_dict()['weight'].numpy())
output2 = model2(x)
 
model1.backward(y)
opt1.step()
print('model1 parameter W after train step: ', model1.params['W'].numpy())
 
opt2 = torch.optim.SGD(lr=0.01, params=model2.parameters())
loss = torch.nn.functional.mse_loss(output2, y) / 2
loss.backward()
opt2.step()
opt2.zero_grad()
print('model2 parameter W after train step: ', model2.state_dict()['weight'].numpy())

 运行结果

 从输出结果看，在一次梯度更新后，两个模型的参数值保持一致，证明优化器实现正确。

 7.3.2 学习率调整

学习率是神经网络优化时的重要超参数。在梯度下降法中，学习率α的取值非常关键，如果取值过大就不会收敛，如果过小则收敛速度太慢。

常用的学习率调整方法包括如下几种方法：

  • 学习率衰减：如分段常数衰减（Piecewise Constant Decay）、余弦衰减（Cosine Decay）等；
  • 学习率预热：如逐渐预热(Gradual Warmup) 等；
  • 周期性学习率调整：如循环学习率等；
  • 自适应调整学习率的方法：如AdaGrad、RMSprop、AdaDelta等。自适应学习率方法可以针对每个参数设置不同的学习率。

 7.3.2.1 AdaGrad算法

构建优化器 定义Adagrad类，继承Optimizer类。定义step函数调用adagrad进行参数更新。代码实现如下：

class Adagrad(Optimizer):
    def __init__(self, init_lr, model, epsilon):
        """
        Adagrad 优化器初始化
        输入：
            - init_lr： 初始学习率
            - model：模型，model.params存储模型参数值
            - epsilon：保持数值稳定性而设置的非常小的常数
        """
        super(Adagrad, self).__init__(init_lr=init_lr, model=model)
        self.G = {}
        for key in self.model.params.keys():
            self.G[key] = 0
        self.epsilon = epsilon
 
    def adagrad(self, x, gradient_x, G, init_lr):
        """
        adagrad算法更新参数，G为参数梯度平方的累计值。
        """
        G += gradient_x ** 2
        x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
        return x, G
 
    def step(self):
        """
        参数更新
        """
        for key in self.model.params.keys():
            self.model.params[key], self.G[key] = self.adagrad(self.model.params[key],
                                                               self.model.grads[key],
                                                               self.G[key],
                                                               self.init_lr)

 2D可视化实验 使用被优化函数展示Momentum算法的参数更新轨迹。

torch.manual_seed(0)
w = torch.tensor([0.2, 2])
model = OptimizedFunction(w)
opt = Adagrad(init_lr=0.5, model=model, epsilon=1e-7)
train_and_plot_f(model, opt, epoch=50, fig_name='opti-vis-para2.pdf')
plt.show()

这里的 Optimizer类上面已经给出，这里就不再重复。

运行结果

 

 从输出结果看，AdaGrad算法在前几个回合更新时参数更新幅度较大，随着回合数增加，学习率逐渐缩小，参数更新幅度逐渐缩小。在AdaGrad算法中，如果某个参数的偏导数累积比较大，其学习率相对较小。相反，如果其偏导数累积较小，其学习率相对较大。但整体随着迭代次数的增加，学习率逐渐缩小。该算法的缺点是在经过一定次数的迭代依然没有找到最优点时，由于这时的学习率已经非常小，很难再继续找到最优点。
简单拟合实验 训练单层线性网络，验证损失是否收敛。代码实现如下：

# 固定随机种子
torch.manual_seed(0)
# 定义网络结构
model = Linear(2)
# 定义优化器
opt = Adagrad(init_lr=0.1, model=model, epsilon=1e-7)
train_and_plot(opt, 'opti-loss2.pdf')

运行结果 

 7.3.2.2 RMSprop算法

构建优化器 定义RMSprop类，继承Optimizer类。定义step函数调用rmsprop更新参数。代码实现如下：

class RMSprop(Optimizer):
    def __init__(self, init_lr, model, beta, epsilon):
        """
        RMSprop优化器初始化
        输入：
            - init_lr：初始学习率
            - model：模型，model.params存储模型参数值
            - beta：衰减率
            - epsilon：保持数值稳定性而设置的常数
        """
        super(RMSprop, self).__init__(init_lr=init_lr, model=model)
        self.G = {}
        for key in self.model.params.keys():
            self.G[key] = 0
        self.beta = beta
        self.epsilon = epsilon

    def rmsprop(self, x, gradient_x, G, init_lr):
        """
        rmsprop算法更新参数，G为迭代梯度平方的加权移动平均
        """
        G = self.beta * G + (1 - self.beta) * gradient_x ** 2
        x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
        return x, G

    def step(self):
        """参数更新"""
        for key in self.model.params.keys():
            self.model.params[key], self.G[key] = self.rmsprop(self.model.params[key], 
                                                               self.model.grads[key],
                                                               self.G[key], 
                                                               self.init_lr)

 2D可视化实验 使用被优化函数展示RMSprop算法的参数更新轨迹。代码实现如下：

w = torch.tensor([0.2, 2])
model = OptimizedFunction(w)
opt = RMSprop(init_lr=0.1, model=model, beta=0.9, epsilon=1e-7)
train_and_plot_f(model, opt, epoch=50, fig_name='opti-vis-para3.pdf')
plt.show()

运行结果

 

简单拟合实验 训练单层线性网络，进行简单的拟合实验。代码实现如下：

# 定义网络结构
model = Linear(2)
# 定义优化器
opt = RMSprop(init_lr=0.1, model=model, beta=0.9, epsilon=1e-7)
train_and_plot(opt, 'opti-loss3.pdf')

运行结果

 7.3.3 梯度估计修正

除了调整学习率之外，还可以进行梯度估计修正。在小批量梯度下降法中，由于每次迭代的样本具有一定的随机性，因此每次迭代的梯度估计和整个训练集上的最优梯度并不一致。如果每次选取样本数量比较小，损失会呈振荡的方式下降。
一种有效地缓解梯度估计随机性的方式是通过使用最近一段时间内的平均梯度来代替当前时刻的随机梯度来作为参数更新的方向，从而提高优化速度。

 7.3.3.1 动量法

构建优化器 定义Momentum类，继承Optimizer类。定义step函数调用momentum进行参数更新。代码实现如下：

class Momentum(Optimizer):
    def __init__(self, init_lr, model, rho):
        """
        Momentum优化器初始化
        输入：
            - init_lr：初始学习率
            - model：模型，model.params存储模型参数值
            - rho：动量因子
        """
        super(Momentum, self).__init__(init_lr=init_lr, model=model)
        self.delta_x = {}
        for key in self.model.params.keys():
            self.delta_x[key] = 0
        self.rho = rho

    def momentum(self, x, gradient_x, delta_x, init_lr):
        """
        momentum算法更新参数，delta_x为梯度的加权移动平均
        """
        delta_x = self.rho * delta_x - init_lr * gradient_x
        x += delta_x
        return x, delta_x

    def step(self):
        """参数更新"""
        for key in self.model.params.keys():
            self.model.params[key], self.delta_x[key] = self.momentum(self.model.params[key], 
                                                                      self.model.grads[key], 
                                                                      self.delta_x[key], 
                                                                      self.init_lr)

 2D可视化实验 使用被优化函数展示Momentum算法的参数更新轨迹。

# 固定随机种子
w = torch.tensor([0.2, 2])
model = OptimizedFunction(w)
opt = Momentum(init_lr=0.01, model=model, rho=0.9)
train_and_plot_f(model, opt, epoch=50, fig_name='opti-vis-para4.pdf')
plt.show()

运行结果

 

简单拟合实验 训练单层线性网络，进行简单的拟合实验。代码实现如下：


# 定义网络结构
model = Linear(2)
# 定义优化器
opt = Momentum(init_lr=0.01, model=model, rho=0.9)
train_and_plot(opt, 'opti-loss4.pdf')

运行结果

 7.3.3.2 Adam算法

 Adam算法（Adaptive Moment Estimation Algorithm，自适应矩估计算法）可以看作动量法和RMSprop算法的结合，不但使用动量作为参数更新方向，而且可以自适应调整学习率。

构建优化器 定义Adam类，继承Optimizer类。定义step函数调用adam函数更新参数。代码实现如下： 

class Adam(Optimizer):
    def __init__(self, init_lr, model, beta1, beta2, epsilon):
        """
        Adam优化器初始化
        输入：
            - init_lr：初始学习率
            - model：模型，model.params存储模型参数值
            - beta1, beta2：移动平均的衰减率
            - epsilon：保持数值稳定性而设置的常数
        """
        super(Adam, self).__init__(init_lr=init_lr, model=model)
        self.beta1 = beta1
        self.beta2 = beta2
        self.epsilon = epsilon
        self.M, self.G = {}, {}
        for key in self.model.params.keys():
            self.M[key] = 0
            self.G[key] = 0
        self.t = 1

    def adam(self, x, gradient_x, G, M, t, init_lr):
        """
        adam算法更新参数
        输入：
            - x：参数
            - G：梯度平方的加权移动平均
            - M：梯度的加权移动平均
            - t：迭代次数
            - init_lr：初始学习率
        """
        M = self.beta1 * M + (1 - self.beta1) * gradient_x
        G = self.beta2 * G + (1 - self.beta2) * gradient_x ** 2
        M_hat = M / (1 - self.beta1 ** t)
        G_hat = G / (1 - self.beta2 ** t)
        t += 1
        x -= init_lr / torch.sqrt(G_hat + self.epsilon) * M_hat
        return x, G, M, t

    def step(self):
        """参数更新"""
        for key in self.model.params.keys():
            self.model.params[key], self.G[key], self.M[key], self.t = self.adam(self.model.params[key], 
                                                                                 self.model.grads[key],
                                                                                 self.G[key], 
                                                                                 self.M[key],
                                                                                 self.t, 
                                                                                 self.init_lr)

 2D可视化实验 使用被优化函数展示Adam算法的参数更新轨迹。代码实现如下：

w = torch.tensor([0.2, 2])
model = OptimizedFunction(w)
opt = Adam(init_lr=0.2, model=model, beta1=0.9, beta2=0.99, epsilon=1e-7)
train_and_plot_f(model, opt, epoch=20, fig_name='opti-vis-para5.pdf')
plt.show()

运行结果

 

简单拟合实验 训练单层线性网络，进行简单的拟合实验。代码实现如下：

# 定义网络结构
model = Linear(2)
# 定义优化器
opt = Adam(init_lr=0.1, model=model, beta1=0.9, beta2=0.99, epsilon=1e-7)
train_and_plot(opt, 'opti-loss5.pdf')

 运行结果

 

7.3.4 不同优化器的3D可视化对比 

定义OptimizedFunction3D算子，表示被优化函数f(x)=x\left [ 0 \right ]^{2}+ x\left [ 1 \right ]^{2}+x\left [ 1 \right ]^{3}+x\left [ 0 \right ]\ast x\left [ 1 \right ]，其中x\left [ 0 \right ], x\left [ 1 \right ]代表两个参数。该函数在(0,0)处存在鞍点，即一个既不是极大值点也不是极小值点的临界点。希望训练过程中，优化算法可以使参数离开鞍点，向模型最优解收敛。代码实现如下： 

import torch
import numpy as np
import copy
from matplotlib import pyplot as plt
from matplotlib import animation
from itertools import zip_longest
 
 
class Op(object):
    def __init__(self):
        pass
 
    def __call__(self, inputs):
        return self.forward(inputs)
 
    # 输入：张量inputs
    # 输出：张量outputs
    def forward(self, inputs):
        # return outputs
        raise NotImplementedError
 
    # 输入：最终输出对outputs的梯度outputs_grads
    # 输出：最终输出对inputs的梯度inputs_grads
    def backward(self, outputs_grads):
        # return inputs_grads
        raise NotImplementedError
 
 
class Optimizer(object):  # 优化器基类
    def __init__(self, init_lr, model):
        """
        优化器类初始化
        """
        # 初始化学习率，用于参数更新的计算
        self.init_lr = init_lr
        # 指定优化器需要优化的模型
        self.model = model
 
    def step(self):
        """
        定义每次迭代如何更新参数
        """
        pass
 
 
class SimpleBatchGD(Optimizer):
    def __init__(self, init_lr, model):
        super(SimpleBatchGD, self).__init__(init_lr=init_lr, model=model)
 
    def step(self):
        # 参数更新
        if isinstance(self.model.params, dict):
            for key in self.model.params.keys():
                self.model.params[key] = self.model.params[key] - self.init_lr * self.model.grads[key]
 
 
class Adagrad(Optimizer):
    def __init__(self, init_lr, model, epsilon):
        """
        Adagrad 优化器初始化
        输入：
            - init_lr： 初始学习率 - model：模型，model.params存储模型参数值  - epsilon：保持数值稳定性而设置的非常小的常数
        """
        super(Adagrad, self).__init__(init_lr=init_lr, model=model)
        self.G = {}
        for key in self.model.params.keys():
            self.G[key] = 0
        self.epsilon = epsilon
 
    def adagrad(self, x, gradient_x, G, init_lr):
        """
        adagrad算法更新参数，G为参数梯度平方的累计值。
        """
        G += gradient_x ** 2
        x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
        return x, G
 
    def step(self):
        """
        参数更新
        """
        for key in self.model.params.keys():
            self.model.params[key], self.G[key] = self.adagrad(self.model.params[key],
                                                               self.model.grads[key],
                                                               self.G[key],
                                                               self.init_lr)
 
 
class RMSprop(Optimizer):
    def __init__(self, init_lr, model, beta, epsilon):
        """
        RMSprop优化器初始化
        输入：
            - init_lr：初始学习率
            - model：模型，model.params存储模型参数值
            - beta：衰减率
            - epsilon：保持数值稳定性而设置的常数
        """
        super(RMSprop, self).__init__(init_lr=init_lr, model=model)
        self.G = {}
        for key in self.model.params.keys():
            self.G[key] = 0
        self.beta = beta
        self.epsilon = epsilon
 
    def rmsprop(self, x, gradient_x, G, init_lr):
        """
        rmsprop算法更新参数，G为迭代梯度平方的加权移动平均
        """
        G = self.beta * G + (1 - self.beta) * gradient_x ** 2
        x -= init_lr / torch.sqrt(G + self.epsilon) * gradient_x
        return x, G
 
    def step(self):
        """参数更新"""
        for key in self.model.params.keys():
            self.model.params[key], self.G[key] = self.rmsprop(self.model.params[key],
                                                               self.model.grads[key],
                                                               self.G[key],
                                                               self.init_lr)
 
 
class Momentum(Optimizer):
    def __init__(self, init_lr, model, rho):
        """
        Momentum优化器初始化
        输入：
            - init_lr：初始学习率
            - model：模型，model.params存储模型参数值
            - rho：动量因子
        """
        super(Momentum, self).__init__(init_lr=init_lr, model=model)
        self.delta_x = {}
        for key in self.model.params.keys():
            self.delta_x[key] = 0
        self.rho = rho
 
    def momentum(self, x, gradient_x, delta_x, init_lr):
        """
        momentum算法更新参数，delta_x为梯度的加权移动平均
        """
        delta_x = self.rho * delta_x - init_lr * gradient_x
        x += delta_x
        return x, delta_x
 
    def step(self):
        """参数更新"""
        for key in self.model.params.keys():
            self.model.params[key], self.delta_x[key] = self.momentum(self.model.params[key],
                                                                      self.model.grads[key],
                                                                      self.delta_x[key],
                                                                      self.init_lr)
 
 
class Adam(Optimizer):
    def __init__(self, init_lr, model, beta1, beta2, epsilon):
        """
        Adam优化器初始化
        输入：
            - init_lr：初始学习率
            - model：模型，model.params存储模型参数值
            - beta1, beta2：移动平均的衰减率
            - epsilon：保持数值稳定性而设置的常数
        """
        super(Adam, self).__init__(init_lr=init_lr, model=model)
        self.beta1 = beta1
        self.beta2 = beta2
        self.epsilon = epsilon
        self.M, self.G = {}, {}
        for key in self.model.params.keys():
            self.M[key] = 0
            self.G[key] = 0
        self.t = 1
 
    def adam(self, x, gradient_x, G, M, t, init_lr):
        """
        adam算法更新参数
        输入：
            - x：参数
            - G：梯度平方的加权移动平均
            - M：梯度的加权移动平均
            - t：迭代次数
            - init_lr：初始学习率
        """
        M = self.beta1 * M + (1 - self.beta1) * gradient_x
        G = self.beta2 * G + (1 - self.beta2) * gradient_x ** 2
        M_hat = M / (1 - self.beta1 ** t)
        G_hat = G / (1 - self.beta2 ** t)
        t += 1
        x -= init_lr / torch.sqrt(G_hat + self.epsilon) * M_hat
        return x, G, M, t
 
    def step(self):
        """参数更新"""
        for key in self.model.params.keys():
            self.model.params[key], self.G[key], self.M[key], self.t = self.adam(self.model.params[key],
                                                                                 self.model.grads[key],
                                                                                 self.G[key],
                                                                                 self.M[key],
                                                                                 self.t,
                                                                                 self.init_lr)
 
 
class OptimizedFunction3D(Op):
    def __init__(self):
        super(OptimizedFunction3D, self).__init__()
        self.params = {'x': 0}
        self.grads = {'x': 0}
 
    def forward(self, x):
        self.params['x'] = x
        return x[0] ** 2 + x[1] ** 2 + x[1] ** 3 + x[0] * x[1]
 
    def backward(self):
        x = self.params['x']
        gradient1 = 2 * x[0] + x[1]
        gradient2 = 2 * x[1] + 3 * x[1] ** 2 + x[0]
        grad1 = torch.Tensor([gradient1])
        grad2 = torch.Tensor([gradient2])
        self.grads['x'] = torch.cat([grad1, grad2])
 
 
class Visualization3D(animation.FuncAnimation):
    """    绘制动态图像，可视化参数更新轨迹    """
 
    def __init__(self, *xy_values, z_values, labels=[], colors=[], fig, ax, interval=600, blit=True, **kwargs):
        """
        初始化3d可视化类
        输入：
            xy_values：三维中x,y维度的值
            z_values：三维中z维度的值
            labels：每个参数更新轨迹的标签
            colors：每个轨迹的颜色
            interval：帧之间的延迟（以毫秒为单位）
            blit：是否优化绘图
        """
        self.fig = fig
        self.ax = ax
        self.xy_values = xy_values
        self.z_values = z_values
 
        frames = max(xy_value.shape[0] for xy_value in xy_values)
        self.lines = [ax.plot([], [], [], label=label, color=color, lw=2)[0]
                      for _, label, color in zip_longest(xy_values, labels, colors)]
        super(Visualization3D, self).__init__(fig, self.animate, init_func=self.init_animation, frames=frames,
                                              interval=interval, blit=blit, **kwargs)
 
    def init_animation(self):
        # 数值初始化
        for line in self.lines:
            line.set_data([], [])
        return self.lines
 
    def animate(self, i):
        # 将x,y,z三个数据传入，绘制三维图像
        for line, xy_value, z_value in zip(self.lines, self.xy_values, self.z_values):
            line.set_data(xy_value[:i, 0], xy_value[:i, 1])
            line.set_3d_properties(z_value[:i])
        return self.lines
 
 
def train_f(model, optimizer, x_init, epoch):
    x = x_init
    all_x = []
    losses = []
    for i in range(epoch):
        all_x.append(copy.deepcopy(x.numpy())) 
        loss = model(x)
        losses.append(loss)
        model.backward()
        optimizer.step()
        x = model.params['x']
    return torch.Tensor(np.array(all_x)), losses
 
 
# 构建5个模型，分别配备不同的优化器
model1 = OptimizedFunction3D()
opt_gd = SimpleBatchGD(init_lr=0.01, model=model1)
 
model2 = OptimizedFunction3D()
opt_adagrad = Adagrad(init_lr=0.5, model=model2, epsilon=1e-7)
 
model3 = OptimizedFunction3D()
opt_rmsprop = RMSprop(init_lr=0.1, model=model3, beta=0.9, epsilon=1e-7)
 
model4 = OptimizedFunction3D()
opt_momentum = Momentum(init_lr=0.01, model=model4, rho=0.9)
 
model5 = OptimizedFunction3D()
opt_adam = Adam(init_lr=0.1, model=model5, beta1=0.9, beta2=0.99, epsilon=1e-7)
 
models = [model1, model2, model3, model4, model5]
opts = [opt_gd, opt_adagrad, opt_rmsprop, opt_momentum, opt_adam]
 
x_all_opts = []
z_all_opts = []
 
# 使用不同优化器训练
 
for model, opt in zip(models, opts):
    x_init = torch.FloatTensor([2, 3])
    x_one_opt, z_one_opt = train_f(model, opt, x_init, 150)  # epoch
    # 保存参数值
    x_all_opts.append(x_one_opt.numpy())
    z_all_opts.append(np.squeeze(z_one_opt))
 
 
x1 = np.arange(-3, 3, 0.1)
x2 = np.arange(-3, 3, 0.1)
x1, x2 = np.meshgrid(x1, x2)
init_x = torch.Tensor(np.array([x1, x2]))
 
model = OptimizedFunction3D()
 
# 绘制 f_3d函数 的 三维图像
fig = plt.figure()
ax = plt.axes(projection='3d')
X = init_x[0].numpy()
Y = init_x[1].numpy()
Z = model(init_x).numpy()  # 改为 model(init_x).numpy() David 2022.12.4
ax.plot_surface(X, Y, Z, cmap='rainbow')
 
ax.set_xlabel('x1')
ax.set_ylabel('x2')
ax.set_zlabel('f(x1,x2)')
 
labels = ['SGD', 'AdaGrad', 'RMSprop', 'Momentum', 'Adam']
colors = ['#f6373c', '#f6f237', '#45f637', '#37f0f6', '#000000']
 
animator = Visualization3D(*x_all_opts, z_values=z_all_opts, labels=labels, colors=colors, fig=fig, ax=ax)
ax.legend(loc='upper left')
 
plt.show()
animator.save('animation.gif')

运行结果

 

参考 

NNDL 实验7 - HBU_DAVID - 博客园 (cnblogs.com)

NNDL 实验八 网络优化与正则化（3）不同优化算法比较

五元钱
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
邱锡鹏著 《神经网络与深度学习》案例与实践实验1-5中所需的nndl包
11-10
如出现如下问题均可导入nndl包均...1、实验中出现from nndl.dataset import load_data报错的 2、No module named 'nndl' 3、运行是显示ModuleNotFoundError: No module named 'nndl' 去下载nndl这个模块的时候显示没有
shape 函数，以及shape(2,)和shape（2，1）区别
热门推荐
weixin_38859557的博客
06-22 1万+
1：一般的数组如：【22，33】 shape是（2，）：他表示他是一个一维数组，数组中有两个元素；注意他和shape（2，1）的区别，他两个不一样。2：[[22],[33]]  他的shape是(2,1),表示二维数组，每行有一个元素3：[[22,33]] shape是（1，2） 他表示一个二维数组，每行有两个元素...
NNDL:神经网络与深度学习
03-07
NNDL:神经网络与深度学习
实验环境5-1所需要的nndl包
10-28
实验环境5-1所需要的nndl包
NNDL2018_神经网络与深度学习_deeplearning_cv_
10-01
Neural Networks and DeepLearningA Textbook
NNDL:神经网络和深度学习课程回购
04-12
神经网络神经网络和深度学习课程库。 它包含以下问题：找到函数f（x）= x 4 + 3 * x 2 + 10的全局最小值。作业2： 它包含以下问题：找到函数f（x，y）= x 2 + y 2 + 10的x和y的全局最优点。作业3： 它包括对点采样的...
智能决策引擎架构设计
猫七姑娘的小博客
05-15 1422
智能决策引擎系统是在大数据支撑下，根据行业专家经验制定规则策略、以及机器学习/深度学习/AI领域建立的模型运算，对当前的业务进行全面的评估，并给出决策结果的一套系统。一套商业决策引擎系统动辄百万而且需要不断加钱定制，大多数企业最终仍会走上自研道路，市场上有些开源规则引擎项目可参考，比较出名的开源规则引擎有drools、urule，都是基于Rete算法，都是基于java代码实现，一些企业会进行二次开发落地生产。而这类引擎功能强大但也比较“笨重”，易用性以及定制性并不够好，对其他语言栈二次开发困难。
RANSAC算法概述
最新发布
点云侠的博客
05-20 429
RANSAC算法概述
2024第二届全国人工智能应用场景创新挑战赛
audyxiao001的博客
05-14 776
本文从竞赛模式、参赛组别和条件、参赛注意事项以及赛程设置四个角度介绍了第二届全国人工智能应用场景创新挑战赛，并给出大赛官网，以便读者了解更多详细信息。
使用多实例学习进行乳腺癌组织病理学图像分类和定位
qq_47896523的博客
05-16 1092
乳腺癌是女性最主要的死亡原因，病理学家根据病理切片中观察到的各种视觉特征（例如细胞核的形态特征、细胞核的微观和宏观结构等）做出决定。计算机辅助诊断（CAD）系统可以帮助病理学家自动做出决策。卷积神经网络是最广泛使用的深度学习框架，用于学习图像类别之间的复杂判别特征。多年来，VGG16 [3] 和 ResNet18 [4] 等各种 CNN 架构在海量 ImageNet 数据集上产生了出色的结果。CNN 被用于医学图像以产生最先进的结果。为图像中存在的所有类别提供了定位信息。
长江商学院隽永参访实在智能，沉浸体验实在Agent
SHIZAIZHINENG的博客
05-16 536
长江隽永是中国首个全方位关注并赋能“她价值”的女性成长平台，此次参访实在智能，旨在深入学习并交流最前沿的Agent技术，引导企业进行科学决策和组织变革，从而帮助企业从个体成长跃升为具有全球视野的数字化领导者。随着数字化技术的不断发展，人工智能、虚拟现实等新技术的的应用已经深入社会的方方面面，并在不断地释放着创新的活力，AI+RPA技术的涌现，外加人力成本的大幅度增加，使得企业对智能数字员工的服务需求越来越大。实在智能创始人、CEO孙林君和实在伙伴一同接待。
四非、双非计算机保研夏令营入营情况
小蒋的博客
05-19 576
厦大 信息学院，电影学院，CS，人工智能浙软（海营，预推免入场券）、工程师华东科技大学网安中国科学技术大学 先进技术研究院，空间应用工程与技术中心，信工所，软件所，计算与网络中心，计算技术研究所北京师范大学 认知神经科学与学习国家重点实验室山东大学 网络空间与安全学院，SE天津大学 智能与计算机学部华中师范大学 计算机学院、大数据北航计算机南开计算机，SE吉大计算机、SE、人工智能湖南信息山大计院（不发offer），网安成电计算机，网安。
2024成都现代职业教育及装备展6月1日举办 免费参观
wb253228的博客
05-14 698
2024成都现代职业教育及装备展6月1日举办 免费参观同期举办：中国西部职业教育产教融合高峰论坛 主办单位： 中国西部教体融合博览会组委会承办单位：重庆港华展览有限公司博览会主题：责任教育 职教兴邦组委会：交易会159交易会2351交易会9466展会和论坛背景：为推动中国职业教育产业新发展、满足时代新需求，2024第16届中国西部（成都和重庆）现代职业教育及装备博览会及中国现代职业教育产教融合国际高峰论坛在西部重镇成都举办。立足西部，覆盖全球，打造世界职业教育产业链上下游的合作、交流平台，促进产教融合和
AIGC是什么?
米的
05-15 1292
AIGC，全称为Artificial Intelligence Generated Content，即人工智能生成内容，是当前AI技术发展的一个重要方向。这项技术利用机器学习、深度学习、自然语言处理以及其他高级算法，使计算机系统能够自动或辅助生成包括文字、图像、音频、视频、3D模型等多种形式的创意内容。AIGC不仅代表了从人工智能1.0向2.0时代的转变，还标志着AI在认知智能层面的巨大进步，为内容创造开启了全新的可能性。
[数据集][目标检测]抽烟喝酒检测数据集VOC+YOLO格式1026张2类别
FL1623863129的博客
05-18 268
数据集格式：Pascal VOC格式+YOLO格式(不包含分割路径的txt文件，仅仅包含jpg图片以及对应的VOC格式xml文件和yolo格式txt文件)特别声明：本数据集不对训练的模型或者权重文件精度作任何保证，数据集只提供准确且合理标注。标注类别名称:[“drinking”,“smoking”]图片数量(jpg文件个数)：1026。标注数量(xml文件个数)：1026。标注数量(txt文件个数)：1026。使用标注工具：labelImg。标注规则：对类别进行画矩形框。
多式联运奇迹：探索 GPT-4o 的尖端功能
weixin_46083783的博客
05-16 1251
GPT-4o，即 GPT-4 Omni，是 OpenAI 开发的领先的人工智能模型。该先进系统旨在完美处理文本、音频和视觉输入，使其成为真正的多模式。与其前身不同，GPT-4o 跨文本、视觉和音频进行端到端训练，使所有输入和输出都能由相同的处理器处理。神经网络。这种整体方法增强了其功能并促进更自然的交互。借助 GPT-4o，用户可以预期更高的参与度，因为它会生成文本、音频和图像输出的各种组合，反映人类交流。
不戴头盔监控智能喊话系统
燧机科技的博客
05-19 276
不戴头盔监控智能喊话系统基于神经网络机器视觉技术，不戴头盔监控智能喊话系统通过十字路口的摄像头对来往的电动车等车辆人员进行实时监测。系统使用高性能摄像头对十字路口进行全方位监控，利用神经网络算法分析图像和视频数据，精确识别骑车人员是否佩戴头盔。不戴头盔监控智能喊话系统一旦系统检测到未佩戴头盔的骑车人员，立即进行抓拍告警，并通过喇叭或扬声器进行现场喊话提醒，提醒骑车人员佩戴头盔以确保出行安全。
如何通过店铺集群实现高效库存规划
第七在线（7thonline）
05-17 969
在这种情况下，商品管理人员无需对每家具有相似特征的店铺单独规划，而可以在更高的集群层级——如温度带、商圈和店铺类型（如旗舰店与常规店铺）上，进行统一的商品组货和投放决策。此外，店铺规模的大小也是不容忽视的因素，因为大型店铺和小型店铺在容量和运营上往往存在显著差异。理想情况下，在每个计划周期（如每个季节）之初，应更新集群以反映店铺的新增、关闭，店铺的销售能力以及客户偏好的动态变化。在第七在线， 当零售商的店铺数量超过10家，或者开始观察到店铺之间在销售绩效上存在显著差异时，可考虑引入店铺集群的概念。
环境光遮蔽技术在AI去衣应用中的创新探索
AI开源工具分享
05-15 562
环境光遮蔽技术是一种用于增强图像真实感的技术，通过模拟光线在场景中的传播和反射，计算出物体表面各点的光照强度，从而得到更加真实的光影效果。而在AI去衣应用中，这一技术主要用于模拟人体皮肤表面的光线变化，确保去除衣物后的图像仍然具有高度的真实感和自然的光影效果。环境光遮蔽技术在AI去衣应用中的作用不可小觑，它不仅提高了图像处理的效率和质量，还为AI去衣技术的发展提供了坚实的基础。随着技术的不断进步，我们有理由相信，环境光遮蔽技术将在AI去衣领域发挥更大的作用，推动相关应用向更高的水平发展。
神经网络NNDL二分类代码
11-28
以下是一个简单的二分类神经网络的代码示例，其中包括两个线性层和一个Logistic算子（Sigmoid激活函数）： ```python import torch class TwoLayerNet(torch.nn.Module): def __init__(self, input_size, hidden_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值