深度学习 Day11——T11优化器对比实验

深度学习多卡训练GPU瓶颈诊断与全链路优化实战 GPU瓶颈并非算力不足,而是数据供给、梯度同步与计算调度失配导致的系统级等待现象。其本质是I/O带宽无法匹配GPU吞吐、NCCL通信延迟超过计算耗时、CUDA流未重叠引发空转。技术价值在于将训练吞吐从‘受制于CPU/磁盘/网络’转向‘逼近GPU理论峰值’,显著提升硬件投资回报率。典型应用场景包括分布式训练、DDP/FSDP多卡微调、大规模图像/医学影像模型训练等。本文聚焦PyTorch生态下DataLoader流水线、NUMA亲和性、NCCL环境调优、CUDA stream显式管理等可落地策略,直击GPU利 阅读详情


前言

本文将采用CNN实现好莱坞明星识别,并用两种不同的优化器用于训练,并进行对比。简单讲述实现代码与执行结果,并浅谈涉及知识点。
关键字:加载预训练的 VGG16 模型,优化器。

一、我的环境

  • 电脑系统:Windows 11
  • 语言环境:python 3.8.6
  • 编译器:pycharm2020.2.3
  • 深度学习环境:TensorFlow 2.10.1
  • 显卡:NVIDIA GeForce RTX 4070

二、代码实现与执行结果

1.引入库

from PIL import Image
import numpy as np
from pathlib import Path
import tensorflow as tf
from tensorflow.keras.layers import Dropout, Dense, BatchNormalization
from tensorflow.keras.models import Model
import matplotlib.pyplot as plt
# 支持中文
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
import warnings
warnings.filterwarnings('ignore')  # 忽略一些warning内容,无需打印

2.设置GPU(如果使用的是CPU可以忽略这步)

'''前期工作-设置GPU(如果使用的是CPU可以忽略这步)'''
# 检查GPU是否可用
print(tf.test.is_built_with_cuda())
gpus = tf.config.list_physical_devices("GPU")
print(gpus)
if gpus:
    gpu0 = gpus[0]  # 如果有多个GPU,仅使用第0个GPU
    tf.config.experimental.set_memory_growth(gpu0, True)  # 设置GPU显存用量按需使用
    tf.config.set_visible_devices([gpu0], "GPU")

执行结果

True
[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]

3.导入数据

'''前期工作-导入数据'''
data_dir = r"D:\DeepLearning\data\HollywoodStars"
data_dir = Path(data_dir)

4.查看数据

'''前期工作-查看数据'''
image_count = len(list(data_dir.glob('*/*.jpg')))
print("图片总数为:", image_count)
roses = list(data_dir.glob('Jennifer Lawrence/*.jpg'))
image = Image.open(str(roses[1]))
# 查看图像实例的属性
print(image.format, image.size, image.mode)
plt.imshow(image)
plt.show()

执行结果:

图片总数为: 1800
JPEG (474, 569) RGB

在这里插入图片描述

5.加载数据

'''数据预处理-加载数据'''
batch_size = 16
img_height = 336
img_width = 336
"""
关于image_dataset_from_directory()的详细介绍可以参考文章:https://mtyjkh.blog.youkuaiyun.com/article/details/117018789
"""
train_ds = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="training",
    seed=12,
    image_size=(img_height, img_width),
    batch_size=batch_size)
val_ds = tf.keras.preprocessing.image_dataset_from_directory(
    data_dir,
    validation_split=0.2,
    subset="validation",
    seed=12,
    image_size=(img_height, img_width),
    batch_size=batch_size)
class_names = train_ds.class_names
print(class_names)

运行结果:

Found 1800 files belonging to 17 classes.
Using 1440 files for training.
Found 1800 files belonging to 17 classes.
Using 360 files for validation.
['Angelina Jolie', 'Brad Pitt', 'Denzel Washington', 'Hugh Jackman', 'Jennifer Lawrence', 'Johnny Depp', 'Kate Winslet', 'Leonardo DiCaprio', 'Megan Fox', 'Natalie Portman', 'Nicole Kidman', 'Robert Downey Jr', 'Sandra Bullock', 'Scarlett Johansson', 'Tom Cruise', 'Tom Hanks', 'Will Smith']

6.再次检查数据

'''数据预处理-再次检查数据'''
# Image_batch是形状的张量(16, 336, 336, 3)。这是一批形状336x336x3的16张图片(最后一维指的是彩色通道RGB)。
# Label_batch是形状(16,)的张量,这些标签对应16张图片
for image_batch, labels_batch in train_ds:
    print(image_batch.shape)
    print(labels_batch.shape)
    break

运行结果

(16, 336, 336, 3)
(16,)

7.配置数据集

'''数据预处理-配置数据集'''
AUTOTUNE = tf.data.AUTOTUNE
def train_preprocessing(image, label):
    return (image / 255.0, label)
train_ds = (
    train_ds.cache()
        .shuffle(1000)
        .map(train_preprocessing)  # 这里可以设置预处理函数
        # .batch(batch_size)           # 在image_dataset_from_directory处已经设置了batch_size
        .prefetch(buffer_size=AUTOTUNE)
)
val_ds = (
    val_ds.cache()
        .shuffle(1000)
        .map(train_preprocessing)  # 这里可以设置预处理函数
        # .batch(batch_size)         # 在image_dataset_from_directory处已经设置了batch_size
        .prefetch(buffer_size=AUTOTUNE)
)

8.可视化数据

'''数据预处理-可视化数据'''
plt.figure(figsize=(10, 8))  # 图形的宽为10高为5
plt.suptitle("数据展示", fontsize=20)
for images, labels in train_ds.take(1):
    for i in range(15):
        plt.subplot(3, 5, i + 1)
        plt.xticks([])
        plt.yticks([])
        plt.grid(False)

        # 显示图片
        plt.imshow(images[i])
        # 显示标签
        plt.xlabel(class_names[np.argmax(labels[i])],fontdict={'family' : 'Times New Roman', 'size':20})
plt.show()

在这里插入图片描述

9.构建CNN网络模型

'''构建CNN网络'''
def create_model(optimizer='adam'):
    # 加载预训练模型
    vgg16_base_model = tf.keras.applications.vgg16.VGG16(weights='imagenet',
                                                         include_top=False,
                                                         input_shape=(img_width, img_height, 3),
                                                         pooling='avg')
    for layer in vgg16_base_model.layers:
        layer.trainable = False

    X = vgg16_base_model.output

    X = Dense(170, activation='relu')(X)
    X = BatchNormalization()(X)
    X = Dropout(0.5)(X)

    output = Dense(len(class_names), activation='softmax')(X)
    vgg16_model = Model(inputs=vgg16_base_model.input, outputs=output)

    vgg16_model.compile(optimizer=optimizer,
                        loss='sparse_categorical_crossentropy',
                        metrics=['accuracy'])
    return vgg16_model
model1 = create_model(optimizer=tf.keras.optimizers.Adam())
model2 = create_model(optimizer=tf.keras.optimizers.SGD())
model2.summary()

网络结构结果如下:

Model: "model_1"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 input_2 (InputLayer)        [(None, 336, 336, 3)]     0         
                                                                 
 block1_conv1 (Conv2D)       (None, 336, 336, 64)      1792      
                                                                 
 block1_conv2 (Conv2D)       (None, 336, 336, 64)      36928     
                                                                 
 block1_pool (MaxPooling2D)  (None, 168, 168, 64)      0         
                                                                 
 block2_conv1 (Conv2D)       (None, 168, 168, 128)     73856     
                                                                 
 block2_conv2 (Conv2D)       (None, 168, 168, 128)     147584    
                                                                 
 block2_pool (MaxPooling2D)  (None, 84, 84, 128)       0         
                                                                 
 block3_conv1 (Conv2D)       (None, 84, 84, 256)       295168    
                                                                 
 block3_conv2 (Conv2D)       (None, 84, 84, 256)       590080    
                                                                 
 block3_conv3 (Conv2D)       (None, 84, 84, 256)       590080    
                                                                 
 block3_pool (MaxPooling2D)  (None, 42, 42, 256)       0         
                                                                 
 block4_conv1 (Conv2D)       (None, 42, 42, 512)       1180160   
                                                                 
 block4_conv2 (Conv2D)       (None, 42, 42, 512)       2359808   
                                                                 
 block4_conv3 (Conv2D)       (None, 42, 42, 512)       2359808   
                                                                 
 block4_pool (MaxPooling2D)  (None, 21, 21, 512)       0         
                                                                 
 block5_conv1 (Conv2D)       (None, 21, 21, 512)       2359808   
                                                                 
 block5_conv2 (Conv2D)       (None, 21, 21, 512)       2359808   
                                                                 
 block5_conv3 (Conv2D)       (None, 21, 21, 512)       2359808   
                                                                 
 block5_pool (MaxPooling2D)  (None, 10, 10, 512)       0         
                                                                 
 global_average_pooling2d_1   (None, 512)              0         
 (GlobalAveragePooling2D)                                        
                                                                 
 dense_2 (Dense)             (None, 170)               87210     
                                                                 
 batch_normalization_1 (Batc  (None, 170)              680       
 hNormalization)                                                 
                                                                 
 dropout_1 (Dropout)         (None, 170)               0         
                                                                 
 dense_3 (Dense)             (None, 17)                2907      
                                                                 
=================================================================
Total params: 14,805,485
Trainable params: 90,457
Non-trainable params: 14,715,028
_________________________________________________________________

10.编译模型

# 设置初始学习率
initial_learning_rate = 1e-4

lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
        initial_learning_rate,
        decay_steps=60,      # 敲黑板!!!这里是指 steps,不是指epochs
        decay_rate=0.96,     # lr经过一次衰减就会变成 decay_rate*lr
        staircase=True)

# 将指数衰减学习率送入优化器
optimizer = tf.keras.optimizers.Adam(learning_rate=lr_schedule)

model.compile(optimizer=optimizer,
              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

11.训练模型

'''训练模型'''
NO_EPOCHS = 50

history_model1 = model1.fit(train_ds, epochs=NO_EPOCHS, verbose=1, validation_data=val_ds)
history_model2 = model2.fit(train_ds, epochs=NO_EPOCHS, verbose=1, validation_data=val_ds)

训练记录如下:

Epoch 1/50
90/90 [==============================] - 13s 99ms/step - loss: 2.7601 - accuracy: 0.1764 - val_loss: 2.7506 - val_accuracy: 0.1250
Epoch 2/50
90/90 [==============================] - 8s 86ms/step - loss: 2.0679 - accuracy: 0.3285 - val_loss: 2.4926 - val_accuracy: 0.2111
Epoch 3/50
90/90 [==============================] - 8s 86ms/step - loss: 1.7437 - accuracy: 0.4410 - val_loss: 2.2004 - val_accuracy: 0.3639
......
Epoch 49/50
90/90 [==============================] - 8s 86ms/step - loss: 0.1929 - accuracy: 0.9354 - val_loss: 2.8650 - val_accuracy: 0.4972
Epoch 50/50
90/90 [==============================] - 8s 86ms/step - loss: 0.1694 - accuracy: 0.9458 - val_loss: 2.7593 - val_accuracy: 0.4694
Epoch 1/50
90/90 [==============================] - 8s 87ms/step - loss: 3.0367 - accuracy: 0.1090 - val_loss: 2.7868 - val_accuracy: 0.1250
Epoch 2/50
90/90 [==============================] - 8s 86ms/step - loss: 2.5409 - accuracy: 0.1979 - val_loss: 2.6385 - val_accuracy: 0.1056
Epoch 3/50
90/90 [==============================] - 8s 86ms/step - loss: 2.2875 - accuracy: 0.2847 - val_loss: 2.4560 - val_accuracy: 0.2167
......


12.模型评估

'''模型评估'''
from matplotlib.ticker import MultipleLocator

plt.rcParams['savefig.dpi'] = 300  # 图片像素
plt.rcParams['figure.dpi'] = 300  # 分辨率

acc1 = history_model1.history['accuracy']
acc2 = history_model2.history['accuracy']
val_acc1 = history_model1.history['val_accuracy']
val_acc2 = history_model2.history['val_accuracy']

loss1 = history_model1.history['loss']
loss2 = history_model2.history['loss']
val_loss1 = history_model1.history['val_loss']
val_loss2 = history_model2.history['val_loss']

epochs_range = range(len(acc1))

plt.figure(figsize=(16, 4))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, acc1, label='Training Accuracy-Adam')
plt.plot(epochs_range, acc2, label='Training Accuracy-SGD')
plt.plot(epochs_range, val_acc1, label='Validation Accuracy-Adam')
plt.plot(epochs_range, val_acc2, label='Validation Accuracy-SGD')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
# 设置刻度间隔,x轴每1一个刻度
ax = plt.gca()
ax.xaxis.set_major_locator(MultipleLocator(1))

plt.subplot(1, 2, 2)
plt.plot(epochs_range, loss1, label='Training Loss-Adam')
plt.plot(epochs_range, loss2, label='Training Loss-SGD')
plt.plot(epochs_range, val_loss1, label='Validation Loss-Adam')
plt.plot(epochs_range, val_loss2, label='Validation Loss-SGD')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')

# 设置刻度间隔,x轴每1一个刻度
ax = plt.gca()
ax.xaxis.set_major_locator(MultipleLocator(1))

plt.show()


def test_accuracy_report(model):
    score = model.evaluate(val_ds, verbose=0)
    print('Loss function: %s, accuracy:' % score[0], score[1])


test_accuracy_report(model1)
test_accuracy_report(model2)

在这里插入图片描述

Loss function: 2.759303092956543, accuracy: 0.4694444537162781
Loss function: 1.3968818187713623, accuracy: 0.5805555582046509

三、知识点详解

1.加载预训练的 VGG16 模型

def create_model(optimizer='adam'):
    # 加载预训练模型
    vgg16_base_model = tf.keras.applications.vgg16.VGG16(weights='imagenet',
                                                         include_top=False,
                                                         input_shape=(img_width, img_height, 3),
                                                         pooling='avg')
    for layer in vgg16_base_model.layers:
        layer.trainable = False

    X = vgg16_base_model.output

    X = Dense(170, activation='relu')(X)
    X = BatchNormalization()(X)
    X = Dropout(0.5)(X)

    output = Dense(len(class_names), activation='softmax')(X)
    vgg16_model = Model(inputs=vgg16_base_model.input, outputs=output)

    vgg16_model.compile(optimizer=optimizer,
                        loss='sparse_categorical_crossentropy',
                        metrics=['accuracy'])
    return vgg16_model


model1 = create_model(optimizer=tf.keras.optimizers.Adam())
model2 = create_model(optimizer=tf.keras.optimizers.SGD())
model2.summary()

定义了一个名为 create_model 的函数,该函数接受一个参数 optimizer(默认为 ‘adam’)。函数内部首先使用 tf.keras.applications.vgg16.VGG16 加载了预训练的 VGG16 模型,其中 weights = ‘imagenet’ 表示使用 ImageNet 数据集的预训练权重,include_top = False 表示不包含顶层的全连接层,input_shape 设置输入图像的形状,pooling = ‘avg’ 表示使用平均池化。

然后,对 VGG16 模型的所有层进行循环遍历,将每一层的 trainable 属性设置为 False,即冻结预训练参数,使它们在训练过程中保持不变。

接下来,将 VGG16 模型的输出作为输入,并经过一系列的神经网络层进行特征提取和分类。首先是全连接层 Dense(170, activation = ‘relu’),然后是批归一化层 BatchNormalization(),最后是丢弃层 Dropout(0.5),用于防止过拟合。

最后一层是输出层 Dense(len(class_names), activation = ‘softmax’),其中 len(class_names) 是类别的数量,根据具体情况进行设置,激活函数使用 softmax。

接下来,使用 Model 函数创建了一个新的模型 vgg16_model,指定了输入和输出。这里的 vgg16_base_model.input 表示 VGG16 模型的输入,output 表示上述神经网络层的输出。

然后,使用 compile 方法编译了模型,指定了优化器、损失函数和评估指标。优化器根据传入的参数进行选择,如果没有指定,默认为 Adam 优化器。损失函数使用稀疏分类交叉熵,评估指标为准确率。

最后,函数返回创建的模型。

接下来,通过调用 create_model 函数分别创建了两个模型 model1 和 model2,分别使用了 Adam 优化器和 SGD 优化器。最后调用 model2.summary() 打印了 model2 的模型摘要信息。

参考链接:深度学习-第T11周——优化器对比实验

2 优化器

优化器是一种算法,它在模型优化过程中,动态地调整梯度的大小和方向,使模型能够收敛到更好的位置,或者用更快的速度进行收敛。

2.1 梯度下降法 (Gradient Descent)

我们可以把模型的参数空间想象成是一个曲面,曲面的高度是整体上模型预测值与真实值的误差。我们的目的就是找到整个曲面的最低点,这样我们其实就找到了模型参数的最优点。梯度下降法是最基本的优化算法之一,它让参数朝着梯度下降最大的方向去变化。

假设模型参数为 θ \theta θ,损失函数为 J ( θ ) J(\theta) J(θ) ,损失函数 J ( θ ) J(\theta) J(θ) 关于参数 θ \theta θ 的偏导数,也就是梯度为 ∇ t J ( θ ) \nabla_tJ(\theta) ∇t​J(θ) ,学习率为 α \alpha α ,则使用梯度下降法更新参数的公式为:
θ t + 1 = θ t − α ⋅ ∇ t J ( θ ) \theta_{t+1}=\theta_t-\alpha\cdot\nabla_tJ(\theta) θt+1​=θt​−α⋅∇t​J(θ)

梯度下降算法中,沿着梯度的方向不断减小模型参数,从而最小化损失函数。基本策略可以理解为”在你目光所及的范围内,不断寻找最陡最快的路径下山“

算法缺点:

  • 训练速度慢:每走一步都要计算调整下一步的方向,下山的速度变慢。在应用于大型数据集中,每输入一个样本都要更新一次参数,且每次迭代都要遍历所有的样本。会使得训练过程及其缓慢,需要花费很长时间才能得到收敛解。
  • 容易陷入局部最优解:由于是在有限视距内寻找下山的方向。当陷入平坦的洼地,会误以为到达了山地的最低点,从而不会继续往下走。

真正在使用时,主要是经过改进的以下三类方法,区别在于每次参数更新时计算的样本数据量不同:

  • 批量梯度下降法(BGD, Batch Gradient Descent)
  • 随机梯度下降法(SGD, Stochastic Gradient Descent)
  • 小批量梯度下降法(Mini-batch Gradient Descent)
2.1.1 批量梯度下降法 (Batch Gradient Descent, BGD)

  第一种很天然的想法是批量梯度下降法BGD(Batch Gradient Descent),其实就是每次用全量的数据对参数进行梯度下降。
假设训练样本总数为n,样本为 {(x1,y1), … (xn, yn)} ,模型参数为 θ \theta θ,损失函数为 J ( θ ) J(\theta) J(θ) ,损失函数 J ( θ ) J(\theta) J(θ) 关于参数 θ \theta θ 的偏导数,也就是梯度为 ∇ t J ( θ ) \nabla_tJ(\theta) ∇t​J(θ) ,学习率为 α \alpha α ,则使用BGD更新参数为:
θ t + 1 = θ t − α t ⋅ ∑ i = 1 n ∇ t J i ( θ , x i , y i ) \theta_{t+1}=\theta_t-\alpha_t\cdot\sum_{i=1}^n\nabla_tJ_i(\theta,x^i,y^i) θt+1​=θt​−αt​⋅i=1∑n​∇t​Ji​(θ,xi,yi)
由上式可以看出,每进行一次参数更新,需要计算整个数据样本集,因此导致批量梯度下降法的速度会比较慢,尤其是数据集非常大的情况下,收敛速度就会非常慢,但是由于每次的下降方向为总体平均梯度,它可能得到的会是一个全局最优解。

2.1.2随机梯度下降(Stochastic Gradient Descent, SGD)

随机梯度下降法,不像BGD每一次参数更新,需要计算整个数据样本集的梯度,而是每次参数更新时,仅仅选取一个样本(xi, yi)计算其梯度,参数更新公式为
θ t + 1 = θ t − α ⋅ ∇ t J i ( θ , x i , y i ) \theta_{t+1}=\theta_t-\alpha\cdot\nabla_tJ_i(\theta,x^i,y^i) θt+1​=θt​−α⋅∇t​Ji​(θ,xi,yi)
SGD训练速度很快,即使在样本量很大的情况下,可能只需要其中一部分样本就能迭代到最优解,由于每次迭代并不是都向着整体最优化方向,导致梯度下降的波动非常大(如下图),更容易从一个局部最优跳到另一个局部最优,准确度下降。

优点:

  • 由于每次迭代只使用了一个样本计算梯度,训练速度快,包含一定随机性,但是从期望来看,每次计算的梯度基本是正确的导数的。虽然看起来SGD波动非常大,会走很多弯路,但是对梯度的要求很低(计算梯度快),而且对于引入噪声,大量的理论和实践工作证明,只要噪声不是特别大,SGD都能很好地收敛。
  • 应用大型数据集时,训练速度很快。比如每次从百万数据样本中,取几百个数据点,算一个SGD梯度,更新一下模型参数。相比于标准梯度下降法的遍历全部样本,每输入一个样本更新一次参数,要快得多
    缺点:
  • 更新频繁,带有随机性,会造成损失函数在收敛过程中严重震荡。SGD没能单独克服局部最优解的问题(主要)
  • SGD在随机选择梯度的同时会引入噪声,使得权值更新的方向不一定正确(次要)

2.2 动量优化法(Momentum)

关于动量
动量优化法引入了物理之中的概念。动量 p=mvp=mvp=mv,当一个小球从山顶滚下,速度越来越快,动量越来越大,开始加速梯度下降,当跨越了山谷,滚到对面的坡上时,速度减小,动量减小。

带动量的小球不仅可以加速梯度;还可以借着积累的动量,冲过小的山坡,以避免落入局部最优点。

动量优化法(Momentum)提出的原因
梯度下降法容易被困在局部最小的沟壑处来回震荡,可能存在曲面的另一个方向有更小的值;有时候梯度下降法收敛速度还是很慢。动量法就是为了解决这两个问题提出的

动量优化法思想
参数更新时在一定程度上保留之前更新的方向,同时又利用当前batch的梯度微调最终的更新方向,简言之就是通过积累之前的动量来 (previous_sum_of_gradient) 加速当前的梯度。

优缺点分析

  • 优点:前后梯度一致的时候能够加速学习;前后梯度不一致的时候能够抑制震荡,越过局部极小值(加速收敛,减小震荡)
  • 缺点:多了一个超参数,增加了计算量

2.3 自适应学习率优化算法

传统的优化算法要么将学习率设置为常数要么根据训练次数调节学习率。往往忽视了学习率其他变化的可能性。学习率对模型的性能有着显著的影响,需要采取一些策略来更新学习率,进而提高训练速度与准确率。

使用统一的全局学习率的缺点可能出现的问题

  • 对于某些参数,通过算法已经优化到了极小值附近,但是有的参数仍然有着很大的梯度。
  • 如果学习率太小,则梯度很大的参数会有一个很慢的收敛速度; 如果学习率太大,则已经优化得差不多的参数可能会出现不稳定的情况。

解决方案:对每个参与训练的参数设置不同的学习率,在整个学习过程中通过一些算法自动适应这些参数的学习率。
如果损失与某一指定参数的偏导的符号相同,那么学习率应该增加; 如果损失与该参数的偏导的符号不同,那么学习率应该减小。

2.2.1 AdaGrad(Adaptive Gradient)

Adagrad其实是对学习率进行了一个约束,对于经常更新的参数,我们已经积累了大量关于它的知识,不希望被单个样本影响太大,希望学习速率慢一些;对于偶尔更新的参数,我们了解的信息太少,希望能从每个偶然出现的样本(稀疏特征的样本)身上多学一些,即学习速率大一些。该方法中开始使用的二阶动量,意味着“自适应学习率”优化算法时代的到来。

AdaGrad 算法,独立地适应所有模型参数的学习率,缩放每个参数反比于其所有梯度历史平均值总和的平方根。(知道这么回事就好,基本不用它~)
● 具有损失函数最大梯度的参数相应地有个快速下降的学习率 ● 而具有小梯度的参数在学习率上有相对较小的下降。

优点:自适应的学习率,无需人工调节
缺点:

  • 仍需要手工设置一个全局学习率 η, 如果 η 设置过大的话,会使 regularizer 过于敏感,对梯度的调节太大
  • 中后期,分母上梯度累加的平方和会越来越大,使得参数更新量趋近于0,使得训练提前结束,无法学习
2.2.2 Adadelta

由于AdaGrad调整学习率变化过于激进,我们考虑一个改变二阶动量计算方法的策略:不累积全部历史梯度,而只关注过去一段时间窗口的下降梯度,即Adadelta只累加固定大小的项,并且也不直接存储这些项,仅仅是近似计算对应的平均值(指数移动平均值),这就避免了二阶动量持续累积、导致训练过程提前结束的问题了。

优点:

  • 不依赖全局learning rate
  • 训练初中期,加速效果不错,很快

缺点: 训练后期,反复在局部最小值附近抖动

2.2.3 RMSprop

RMSprop 和 Adadelta 都是为了解决 AdaGrad 学习率急剧下降问题的,但是RMSProp算法修改了AdaGrad的梯度平方和累加为指数加权的移动平均。

指数加权平均,旨在消除梯度下降中的摆动,与Momentum的效果一样,某一维度的导数比较大,则指数加权平均就大,某一维度的导数比较小,则其指数加权平均就小,这样就保证了各维度导数都在一个量级,进而减少了摆动。

另外,指数衰减平均的方式可以淡化遥远过去的历史对当前步骤参数更新量的影响,衰减率表明的是只是最近的梯度平方有意义,而很久以前的梯度基本上会被遗忘

优点:

  • RMSprop算是Adagrad的一种发展,和Adadelta的变体,效果趋于二者之间
  • 适合处理非平稳目标(包括季节性和周期性)——对于RNN效果很好

缺点:其实RMSprop依然依赖于全局学习率 η

2.2.4 Adam(Adaptive Moment Estimation)

Adam 结合了前面方法的一阶动量和二阶动量,是前述方法的集大成者。

优点:

  • Adam梯度经过偏置校正后,每一次迭代学习率都有一个固定范围,使得参数比较平稳。
  • 结合了Adagrad善于处理稀疏梯度和RMSprop善于处理非平稳目标的优点
  • 为不同的参数计算不同的自适应学习率
  • 节省了训练集时间、训练成本

缺点: Adam 使用动量的滑动平均,可能会随着训练数据变化而抖动比较剧烈,在online场景可能波动较大,在广告场景往往效果不如 AdaGrad

Adam那么棒,为什么还对SGD念念不忘
举个栗子。很多年以前,摄影离普罗大众非常遥远。十年前,傻瓜相机开始风靡,游客几乎人手一个。智能手机出现以后,摄影更是走进千家万户,手机随手一拍,前后两千万,照亮你的美(咦,这是什么乱七八糟的)。但是专业摄影师还是喜欢用单反,孜孜不倦地调光圈、快门、ISO、白平衡……一堆自拍党从不care的名词。技术的进步,使得傻瓜式操作就可以得到不错的效果,但是在特定的场景下,要拍出最好的效果,依然需要深入地理解光线、理解结构、理解器材。
更深入的内容,可以通过文末的参考文献进入了解。
1)TensorFlow2调用
函数原型:

keras.optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)

📍官网地址:https://www.tensorflow.org/api_docs/python/tf/keras/optimizers/Adam

参数详解:

  • lr: float >= 0. 学习率。
  • beta_1: float, 0 < beta < 1. 通常接近于 1。
  • beta_2: float, 0 < beta < 1. 通常接近于 1。
  • epsilon: float >= 0. 模糊因子. 若为 None, 默认为 K.epsilon()。
  • decay: float >= 0. 每次参数更新后学习率衰减值。
  • amsgrad: boolean. 是否应用此算法的 AMSGrad 变种,来自论文 “On the Convergence of Adam and Beyond”。

调用示例:

# 设置优化器
opt = tf.keras.optimizers.Adam(learning_rate=0.001, decay=0.0)

model.compile(optimizer=opt,
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

参考文献
An overview of gradient descent optimization algorithms

Adam那么棒,为什么还对SGD念念不忘 (2)—— Adam的两宗罪

总结

通过本次的学习,了解了预加载模型的用法,了解了多种优化器。

梯度掩码压缩:让大模型微调不崩溃的可微分压缩法 模型压缩不仅是减小体积或加速推理,更本质是解决训练阶段的梯度流稳定性问题。传统剪枝与量化在微调时易引发梯度坍缩、优化器失效和精度断崖下跌,根源在于压缩操作不可导且与反向传播脱节。梯度掩码(Gradient Mask)将压缩建模为可学习、可微分的动态过程,通过hook实时调控权重梯度,实现稀疏性与训练稳定性的协同优化。该技术无需修改模型结构,兼容主流LLM架构,已在Llama-3、Qwen2等模型上验证其跨架构泛化能力,适用于边缘部署、LoRA微调、低资源适配等真实工程场景。 阅读详情

相关推荐

SQL LAG函数详解:时间序列分析与环比计算的核心窗口函数

LAG()是SQL标准中关键的窗口函数,用于在有序数据子集中获取前序行的值,其本质是在指定PARTITION BY分组和ORDER BY排序后的位置偏移运算。相比自连接或存储过程,LAG()以单次扫描、零JOIN、高可读性实现高效的时间序列分析,广泛应用于日/周/月环比计算、用户行为路径追踪、库存趋势预警及金融风控等场景。它解决了传统方法中索引失效、NULL传播、逻辑耦合等工程痛点,是现代数据分析从‘描述过程’转向‘声明意图’的重要范式升级。本文深入解析LAG()语法结构、PARTITION BY与ORDE

weixin_33798152的博客 571

Day01:使用pytorch实现Adam优化器及反向传播算法

Adam(Adaptive Moment Estimation)优化器是一种常用于训练深度学习模型的优化算法。它能够自适应调整学习率,适应不同参数的更新速度,因此它在许多深度学习任务中表现出色,尤其是在处理稀疏梯度和大规模数据时。

qq_32070449的博客 851

机器学习实战书单:9本通过代码验证的工程师工具书

机器学习不是纯数学推演,也不是API调用堆砌,而是理论、代码与工程落地的三角闭环。理解梯度下降的链式法则如何映射到autograd,掌握PyTorch DataLoader的num_workers参数为何设为CPU核心数减一,是工程师突破‘知道但不会改bug’瓶颈的关键。这类能力依赖于具备数学可验证性、代码即时可运行、项目真实可部署的高质量学习资源。本文聚焦2022年实测筛选出的9本高时效性、强实践性的ML书籍,覆盖从线性回归脚本速启、模型可解释性交付,到大模型底层逻辑迁移等典型技术路径,特别适配在职工程师

weixin_30415113的博客 403

深度学习numpy与tensor基础知识、关系与区别,通过pytorch构建网络加载数据

开局一句话 import numpy as np 1、生成numpy数组 直接转换np.array(list1) random模块生成np.random.random([3,3]) 创建特定形状np.zeros([3,3]) arange/linspace模块生成np.arange(1,4,0.5),只有一个数字的话为1-数字 2、获取元素 与python中类似,直接nd11[3:6] random.choice函数可以从指定样本中随机抽取数据 3、Numpy的数学运算 对应相乘:A*B/np.

winnerziqi的博客 3605

感知机不是SGD:pseudogradient视角下的几何收敛本质

感知机是一种基础但常被误解的线性分类器,其更新机制常被错误等同于随机梯度下降(SGD)。实际上,它既不优化光滑损失函数,也不依赖梯度可微性,而是基于pseudogradient(伪梯度)的几何纠错方法——在不可微、非凸甚至非连续场景下,通过构造保证函数值严格下降的方向向量来驱动收敛。其理论根基是数据线性可分这一几何条件,而非统计期望或损失最小化目标。这种特性赋予感知机对离群点敏感、抗噪声鲁棒、参数语义清晰等独特工程价值,成为理解SVM、次梯度法、在线学习与现代鲁棒优化的重要枢纽。

weixin_30315905的博客 386

TGNN多产品销量预测:图神经网络+时序建模实战

多变量时间序列预测是供应链智能决策的核心基础,其本质在于建模变量间的结构化依赖关系。传统LSTM、VAR等方法因缺乏显式拓扑表达能力,难以刻画产品间的替代、互补与共销逻辑,导致预测失真。图神经网络(GNN)通过节点-边结构天然适配零售系统中的品类关系,而时序建模则负责捕捉周期性、促销节奏等动态演化规律。Temporal Graph Neural Networks(TGNNs)将二者解耦协同,以GAT实现非对称影响建模,以TCN捕获周/双周等业务节律,在真实快消销售数据上显著提升MAPE并输出可解释的注意力权

weixin_34239169的博客 327

美赛B题建模思维:从公平性定义到滚动优化实战

公平性是资源分配类建模问题的核心概念,但其哲学属性需转化为可计算指标才能进入数学建模流程。本文围绕‘动态资源分配中的公平性’这一典型场景,解析如何通过时空成本与脆弱性暴露度的耦合建模,将抽象公平具象为方差最小化目标;进而结合滚动优化、Pareto前沿与混合整数规划,构建具备实时响应能力与伦理约束的三层嵌套模型。技术价值在于平衡数学严谨性与工程落地性,避免深度学习滥用或指标失真等常见陷阱。广泛适用于应急调度、公共服务配置、多目标运筹等现实决策场景,尤其为数学建模竞赛(如美赛B题、国赛C题)提供可复现的问题拆解

weixin_34337381的博客 432

基于MATLAB的LSTM时间序列预测工具箱:从原理到实战应用

时间序列预测是数据分析领域的核心任务,旨在利用历史数据推断未来趋势。其基本原理是通过挖掘数据中的时序依赖关系,构建数学模型进行外推。以长短期记忆网络(LSTM)为代表的深度学习技术,因其能有效捕捉序列中的长期依赖和非线性模式,在该领域展现出巨大技术价值。LSTM通过其独特的门控机制,克服了传统循环神经网络的梯度消失问题,特别适用于金融、工业、物联网等场景的复杂序列建模。本文聚焦于一个专为MATLAB生态开发的LSTM预测工具箱,它封装了数据预处理、模型构建、训练调优及评估可视化的完整流程,显著降低了工程实践

weixin_32075843的博客 257

pytorch(黑马程序员)

深度学习简介:

2301_81873056的博客 235

时间序列预测实战指南:从数据诊断到线上部署

时间序列分析是一种专门处理带时间戳观测数据的建模方法,其核心在于捕捉趋势性、季节性、平稳性与外生影响等动态依赖结构。不同于普通回归,它强调时间维度上的因果延续与不确定性量化,技术价值体现在为库存调度、负荷预测、异常检测等场景提供可解释、可部署的决策依据。在工程落地中,数据诊断与特征工程往往比模型选择更重要,而真实业务中的结构性断点、时区错位、概念漂移等问题,常成为预测失效的关键诱因。本文聚焦产线验证的端到端流程,覆盖STL分解、ARIMAX建模、N-BEATS多步预测及影子模式监控等关键技术实践。

abxlep7702的博客 465

工业级MLP实战手册:从梯度流到边缘部署的全链路避坑指南

多层感知机(MLP)作为最基础的前馈神经网络,其核心价值在于可控性、可解释性与轻量部署能力。它并非过时模型,而是面向中等维度(50–300维)、中小样本(1万–50万)场景下高性价比的非线性建模工具。其原理依赖于梯度稳定回传、特征尺度对齐与激活函数-初始化耦合匹配;技术价值体现在低维护成本、MCU级推理兼容性及法规友好型局部可解释性;典型应用场景覆盖工业传感器异常检测、金融信贷初筛、医疗风险预警与边缘负荷预测等需平衡精度、延迟与合规性的产线任务。本文聚焦真实数据下的MLP工程落地,系统解析权重初始化偏差、批

weixin_33951761的博客 406

无需平行语料:基于单语数据与大语言模型的机器翻译微调实践

机器翻译的核心目标在于实现不同语言间的准确、流畅转换。传统方法严重依赖大规模双语平行语料进行模型训练,这在数据获取、清洗及稀缺语言对场景下面临巨大挑战。参数高效微调(PEFT)技术,特别是LoRA(Low-Rank Adaptation),通过仅微调少量适配器参数,显著降低了模型适配下游任务的计算与存储成本,为大模型轻量化定制提供了可行路径。这一技术价值在于,开发者能够利用更易获取的单语文本数据,对预训练大语言模型进行领域自适应优化,从而低成本地提升其在特定垂直领域(如科技、医学)的翻译质量和术语准确性。小

weixin_34279246的博客 499

基于Transformer的金融时序预测与资产配置Token生成框架实践

时间序列预测是量化金融与机器学习交叉领域的核心问题,传统方法通常采用回归模型或优化算法分别处理价格预测和资产配置。随着Transformer架构在自然语言处理中的突破,其强大的序列建模能力为金融数据分析提供了新范式。该技术通过注意力机制捕捉市场数据中的长期依赖和非线性模式,将数值预测问题转化为序列生成任务,显著提升了模型对复杂金融规律的表达能力。在工程实践中,这一方法通过离散化技术将连续价格和权重映射为Token序列,利用Decoder-only的Transformer架构进行端到端训练,实现了从历史数据直

weixin_30616969的博客 400

美赛E题破局:非线性累积生态影响建模实战

生态系统响应具有非线性、滞后性与阈值突变特性,传统线性回归、ARIMA等建模方法难以刻画‘累积生态影响’与‘生态韧性衰减’等核心机制。理解这一本质,需从系统动力学视角出发,融合变化率张量、动态阈值状态机与人类-生态耦合ABM,构建可观测、可诊断、可干预的三层架构。该路径不仅支撑高精度临界点预警与政策仿真,更在湿地保护、保护区管理等真实场景中实现可解释、可部署、可迭代的工程落地。本文聚焦2024年美赛E题实战,详解如何将生态学原理转化为代码逻辑与论文叙事。

weixin_34151004的博客 586

FedAvg联邦学习实战:加权平均背后的工程逻辑与落地陷阱

联邦学习是一种在数据不出域前提下实现协同建模的分布式机器学习范式,其核心在于平衡隐私保护、通信效率与模型性能。FedAvg(Federated Averaging)作为最广泛采用的基础算法,本质是客户端本地多步训练后上传参数更新,并由服务端执行加权平均聚合——这一看似简单的操作,实则深刻回应了non-IID数据分布、边缘设备算力异构与网络带宽受限等现实约束。它不追求单点最优,而强调协作稳健性,技术价值体现在可部署性、容错性与审计友好性上。典型应用场景涵盖医疗多机构联合建模、手机输入法个性化优化及工业IoT预

cunbei2644的博客 881

【信息科学与工程学】计算机科学与自动化—第十五篇 云计算 11 算法篇02

但若第一个应用需求40GB/s,第二个10GB/s,总需求50GB/s>40GB/s,第一个得32GB/s,第二个得8GB/s,不公平。但若分区负载不均(分区1-2各有100任务/s,分区3-4各有50任务/s),A负责1-2(200/s),B负责3-4(100/s),仍均衡。任务 τi​ 的计算需求 Wi​(CPU周期),在频率 f 下执行时间 Ti​=Wi​/f,能耗 Ei​=Pdyn​⋅Ti​=Ceff​⋅V2⋅f⋅(Wi​/f)=Ceff​⋅V2⋅Wi​。若 Mneed​>Mi​,需使用远程显存。

weixin_49199313的博客 114

CNN算法实战系列05 | SE注意力机制改造 ResDenseNet

本文提出了一种结合ResNet残差连接、DenseNet密集连接和SE-Net通道注意力机制的SE-ResDenseNet模型。该模型在ResDenseNet基础上嵌入SE模块,通过对特征通道进行自适应重标定,增强关键特征并抑制冗余信息。实验结果表明,在10个epoch训练后,模型在测试集上达到89.2%的准确率,验证了SE模块的有效性。SE模块仅增加2.14%的参数量(43.5K),却显著提升了模型性能。代码实现完整展示了SE模块的设计细节及其在ResDenseNet中的嵌入位置,为注意力机制在卷积网络中

weixin_42517940的博客 233

【信息科学与工程学】【数据中心】第三十二篇 云数据中心的计算/存储/网络的核心挑战01

状态方程: SOCk+1​=SOCk​−Qn​ik​Δt​;: 三相电流变换到αβ坐标系: iα​=32​​(ia​−21​ib​−21​ic​), iβ​=32​​(23​​ib​−23​​ic​). 计算瞬时有功功率p和无功功率q,经低通滤波器分离直流分量,反变换得基波电流,差值即为谐波指令。: 节点i的信念 bi​(xi​)=ϕi​(xi​)∏j∈N(i)​mji​(xi​), 消息 mij​(xj​)=∑xi​​ϕi​(xi​)ψij​(xi​,xj​)∏k∈N(i)\j​mki​(xi​).

weixin_49199313的博客 221
上一篇: 深度学习 Day10——T10数据增强
下一篇: 深度学习 Day12——P1实现mnist手写数字识别
LittleRuby
博客等级 码龄7年 465粉丝 38原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值