pytorch学习day5

一、权值初始化

在深度学习中，权值初始化是神经网络训练中关键的一步。正确的权值初始化可以帮助加速收敛速度，提高模型的稳定性和泛化能力。在PyTorch中，我们可以通过torch.nn.init模块中的函数来实现不同的权值初始化方法。

1.常规初始化

PyTorch通常会自动处理权值的初始化，但我们也可以手动选择不同的初始化方法。常见的初始化方法包括正态分布和均匀分布。例如，我们可以使用torch.nn.init.normal_()来以正态分布初始化权值，或者使用torch.nn.init.uniform_()以均匀分布初始化权值。
import numpy as npdef normal_init(shape):return np.random.normal(0, 1, size=shape)# 使用正态分布初始化示例
weight_shape = (256, 784)  # 举例隐藏层到输入层权重的形状
normal_weights = normal_init(weight_shape)
print("正态分布初始化权重：", normal_weights)
2.Xavier初始化

Xavier初始化是一种常用的权值初始化方法，旨在保持每一层输入输出的方差相等。这有助于避免梯度消失或梯度爆炸问题。在PyTorch中，我们可以使用torch.nn.init.xavier_normal_()或torch.nn.init.xavier_uniform_()函数来实现Xavier初始化。
import numpy as npdef xavier_init(shape):fan_in = shape[0]fan_out = shape[1]limit = np.sqrt(6.0 / (fan_in + fan_out))return np.random.uniform(-limit, limit, size=shape)# 使用Xavier初始化示例
weight_shape = (256, 784)  # 举例隐藏层到输入层权重的形状
xavier_weights = xavier_init(weight_shape)
print("Xavier初始化权重：", xavier_weights)
3.He初始化

He初始化是专门针对ReLU激活函数设计的初始化方法，旨在更好地适应ReLU函数的性质。它可以帮助网络学习更快并提高性能。在PyTorch中，我们可以使用torch.nn.init.kaiming_normal_()或torch.nn.init.kaiming_uniform_()函数来实现He初始化。
import numpy as npdef he_init(shape):fan_in = shape[0]limit = np.sqrt(2.0 / fan_in)return np.random.normal(0, limit, size=shape)# 使用He初始化示例
weight_shape = (256, 784)  # 举例隐藏层到输入层权重的形状
he_weights = he_init(weight_shape)
print("He初始化权重：", he_weights)
实例化代码
import torch
import torch.nn as nn# 定义一个简单的神经网络模型
class SimpleNN(nn.Module):def __init__(self):super(SimpleNN, self).__init__()self.fc1 = nn.Linear(784, 256)  # 输入层到隐藏层self.fc2 = nn.Linear(256, 10)   # 隐藏层到输出层def forward(self, x):x = torch.relu(self.fc1(x))x = self.fc2(x)return x# 初始化模型并应用Xavier初始化
model = SimpleNN()
for name, param in model.named_parameters():if 'weight' in name:nn.init.xavier_normal_(param)  # 使用Xavier正态分布初始化权重# 打印模型的权重
for name, param in model.named_parameters():if 'weight' in name:print(name, param)# 模型的使用示例
input_data = torch.randn(1, 784)  # 生成随机输入数据
output = model(input_data)  # 进行模型推断print("模型输出：", output)
运行结果
fc1.weight Parameter containing:
tensor([[-0.0218,  0.0561, -0.0572,  ...,  0.0096,  0.0357,  0.0418],[ 0.0737,  0.0360,  0.0420,  ..., -0.0429,  0.0142,  0.0359],[-0.0154, -0.0540, -0.0015,  ..., -0.0066, -0.0235, -0.0340],...,[ 0.0885,  0.0019, -0.0504,  ...,  0.0129,  0.0326,  0.0029],[ 0.0311, -0.0102, -0.0469,  ...,  0.0249,  0.0527,  0.0621],[-0.0042, -0.0094, -0.0346,  ..., -0.0501, -0.0287, -0.0019]],requires_grad=True)
fc2.weight Parameter containing:
tensor([[ 0.0160, -0.0037, -0.1639,  ...,  0.0375,  0.0254, -0.1108],[ 0.0881,  0.0255, -0.0862,  ...,  0.0336,  0.0286, -0.0609],[ 0.1291,  0.0486,  0.0160,  ..., -0.0628,  0.0675,  0.0991],...,[ 0.1159, -0.0819,  0.1421,  ..., -0.0961,  0.0746, -0.0308],[ 0.0205, -0.0832,  0.0445,  ..., -0.0296,  0.0456, -0.0040],[ 0.1172,  0.2235, -0.1652,  ..., -0.1300,  0.1334, -0.0672]],requires_grad=True)
模型输出： tensor([[ 0.9630, -0.6175,  0.0708, -1.0410,  0.1289, -1.2975, -0.4868, -1.5743,-0.0070,  0.0873]], grad_fn=<AddmmBackward>)Process finished with exit code 0
权重初始化在神经网络训练中起着关键作用，PyTorch提供了多种权重初始化方法，包括针对不同激活函数和数据分布的初始化策略。以下是十种常见的权重初始化方法分类和说明：

针对饱和激活函数（sigmoid，tanh）：

Xavier均匀分布：通过均匀分布初始化权重，旨在使每一层的输出具有相同的方差，有助于缓解梯度消失或爆炸问题。

Xavier正态分布：采用正态分布初始化权重，同样是为了保持每层输入输出的方差相等，提高模型的收敛速度和性能。

针对非饱和激活函数（relu及变种）：

Kaiming均匀分布：专门为ReLU激活函数设计的初始化方法，通过均匀分布初始化权重，可以更好地适应ReLU的性质，促进模型的学习过程。

Kaiming正态分布：与Kaiming均匀分布类似，采用正态分布初始化权重，适用于带有ReLU激活函数的神经网络模型。

三个常用的分布初始化方法：

均匀分布初始化：以均匀分布方式初始化权重，是一种常见的初始化方法，可以实现权重随机初始化。

正态分布初始化：通过正态分布初始化权重，常用于初始化神经网络模型中的权重。

常数分布初始化：将权重初始化为固定的常数值，在某些情况下可以用于特定的网络结构和任务。

三个特殊的矩阵初始化方法：

正交矩阵初始化：通过正交矩阵初始化权重，可以帮助保持权重的正交性，有助于优化算法的收敛速度和稳定性。

单位矩阵初始化：将权重初始化为单位矩阵，可用于某些特殊情况下的初始化需求。

稀疏矩阵初始化：通过稀疏矩阵初始化权重，可以引入稀疏性以降低模型复杂度和计算成本。

这些权重初始化方法覆盖了不同激活函数和数据分布下的初始化需求，可以帮助优化神经网络的性能和训练效果。在实际应用中，根据具体的任务和网络结构选择合适的初始化方法是非常重要的，以确保模型能够高效地学习和泛化

二、损失函数

在深度学习中讨论损失函数时，常涉及到三个相关但不完全相同的概念：损失函数（Loss Function）、代价函数（Cost Function）和目标函数（Objective Function）。让我们来解释这三个概念的区别：

损失函数（Loss Function）：

损失函数是用来衡量模型预测结果与真实标签之间差异的函数。它通常针对单个样本进行计算，反映了模型在单个样本上的表现。损失函数越小，说明模型对该样本的预测越接近真实值。
在训练神经网络时，损失函数的值被用来衡量当前模型的性能，通过反向传播算法来调整模型的参数以降低损失函数的值，实现模型的优化。

代价函数（Cost Function）：

代价函数是损失函数的一种扩展，它是对整个训练集中所有样本损失函数值的平均或总和。代价函数反映了整个模型在训练集上的表现。
通常，神经网络的优化过程是通过最小化代价函数来进行的，即通过调整模型参数，使代价函数的值尽可能小，从而使模型在整体上达到更好的性能。

目标函数（Objective Function）：

目标函数是在机器学习任务中用来优化的函数，通常包括了代价函数以及正则化项。目标函数的优化是整个机器学习模型训练的目标，通过最小化目标函数来得到最优的模型参数。
目标函数可以由代价函数和正则化项组成，正则化项用来避免过拟合，帮助提高模型的泛化能力。

在深度学习中，损失函数、代价函数和目标函数在模型训练和优化中起着关键作用。正确选择和定义这些函数是优化模型性能和提高泛化能力的关键因素。通过合适的损失函数、代价函数和目标函数的使用，可以有效地引导模型学习并取得更好的预测结果。

常见的损失函数：

均方误差损失（MSE Loss）：适用于回归问题，通过计算预测值和真实值之间的差的平方来衡量模型的训练效果。可用于房价预测等连续数值预测任务。
import torch
import torch.nn as nn# 创建模拟的预测值和真实值
predictions = torch.randn(3, 5, requires_grad=True)
targets = torch.randn(3, 5)# 计算均方误差损失
mse_loss = nn.MSELoss()
loss_mse = mse_loss(predictions, targets)print("均方误差损失值：", loss_mse.item())
交叉熵损失（CrossEntropy Loss）：主要用于多类别分类问题，对每个类别的预测概率进行评估。在分类任务中，交叉熵损失可以衡量模型输出与真实标签之间的差距。
import torch
import torch.nn as nn# 创建模拟的预测值和真实标签
predictions = torch.randn(3, 5, requires_grad=True)
targets = torch.LongTensor([1, 0, 4])# 计算交叉熵损失
crossentropy_loss = nn.CrossEntropyLoss()
loss_ce = crossentropy_loss(predictions, targets)print("交叉熵损失值：", loss_ce.item())
KL散度损失（Kullback-Leibler Divergence Loss）：常用于度量两个概率分布之间的相似度，特别适用于生成模型的训练中，如对抗生成网络（GAN）。
import torch
import torch.nn as nn# 创建两个模拟的概率分布
p = torch.tensor([0.1, 0.4, 0.5])
q = torch.tensor([0.2, 0.3, 0.5])# 计算KL散度损失
kl_loss = nn.KLDivLoss(reduction='batchmean')
loss_kl = kl_loss(torch.log(p), q)print("KL散度损失值：", loss_kl.item())
负对数似然损失（Negative Log Likelihood Loss）：常用于多类别分类问题，与交叉熵损失类似，适用于将模型的输出解释为概率值的情况。
import torch
import torch.nn as nn# 创建模拟的预测值和真实标签
predictions = torch.randn(3, 5, requires_grad=True)
targets = torch.LongTensor([1, 0, 4])# 计算负对数似然损失
nll_loss = nn.NLLLoss()
loss_nll = nll_loss(torch.log_softmax(predictions, dim=1), targets)print("负对数似然损失值：", loss_nll.item())
自定义损失函数：

除了常见的损失函数之外，PyTorch还支持用户自定义损失函数，以适应特定的任务需求。通过定义自定义损失函数，用户可以根据具体情况设计特定的损失计算方式，从而更好地优化模型的训练效果。

损失函数的选择：

在选择损失函数时，需要根据任务类型、数据特征以及模型架构来决定哪种损失函数最适合。合适的损失函数能够引导模型学习正确的特征和进行有效的优化，从而提高模型的预测性能和泛化能力。

通过正确选择损失函数，并结合适当的权值初始化方法，可以使神经网络模型在训练过程中更加高效和稳定，从而取得更好的结果。希望这些信息能帮助您更好地理解损失函数在神经网络训练中的重要性和应用。

三、优化器

3.1优化器介绍

优化器在深度学习中扮演着关键的角色，它管理和更新模型中可学习参数的值，以使模型的输出更接近真实标签。在PyTorch中，优化器负责计算参数的梯度并更新参数值，实现模型的优化和训练。

关键概念：

导数（Derivative）：函数在指定坐标轴上的变化率。在优化过程中，通过计算损失函数关于参数的导数（梯度），可以得知在当前点下降最快的方向。

方向导数（Directional Derivative）：指定方向上的变化率，描述函数在给定方向上的变化速度。对于梯度的计算和优化器选择具有重要意义。

梯度（Gradient）：梯度是一个向量，其方向指示函数在该点变化最快的方向，大小表示变化率最大的值。在优化中，我们希望朝着梯度的负方向移动以减小损失值。

梯度下降（Gradient Descent）：梯度下降是一种常见的优化算法，通过不断沿着梯度的负方向更新模型参数，使损失函数值不断降低，帮助模型更接近最优解。

PyTorch的优化器：

在PyTorch中，优化器负责执行优化过程和参数更新。常见的优化器包括SGD、Adam、RMSprop等，每种优化器都有自己的特点和适用场景。通过选择合适的优化器和调整其超参数，可以使模型训练更加高效和稳定。

3.2优化器的属性

优化器（Optimizer）在PyTorch中提供了多种方法，用于管理和调整模型参数的优化过程。以下是一些常见的优化器方法：
step()：

优化器的主要方法之一，用于执行优化步骤，即更新模型参数。在每个训练迭代中，通常会在计算完梯度后调用step()方法来更新模型参数。

zero_grad()：

方法，用于将优化器管理的参数的梯度置零。在每个训练迭代开始时，通常会调用zero_grad()方法以清空之前的梯度信息，避免梯度累积。

state_dict() 和 load_state_dict()：

state_dict()方法可以返回当前优化器的状态字典，其中包含了当前的参数的状态信息，如动量、学习率等。
load_state_dict()方法用于加载优化器的状态字典，可以恢复优化器之前的状态，例如在模型训练中断后重新加载优化器状态。

add_param_group(param_group)：

方法，用于向优化器添加新的参数组。这使得可以在训练过程中根据需要动态调整优化器的参数设置。

get_lr() 和 set_lr()：

get_lr()方法用于获取当前优化器的学习率，而set_lr()方法则用于设置优化器的学习率，允许动态调整学习率。

step_closure(closure)：

方法，执行一个闭包函数（closure）并在其中执行优化步骤。这在需要在优化步骤中执行额外操作时非常有用。
import torch
import torch.nn as nn
import torch.optim as optim# 创建一个简单的神经网络模型
class SimpleNN(nn.Module):def __init__(self):super(SimpleNN, self).__init__()self.fc = nn.Linear(10, 5)def forward(self, x):return self.fc(x)model = SimpleNN()
optimizer = optim.SGD(model.parameters(), lr=0.01)# 优化器方法的Python代码实现示例
# 1. step() 方法执行优化步骤，即更新模型参数
optimizer.zero_grad()
output = model(torch.randn(5, 10))
loss = nn.functional.mse_loss(output, torch.randn(5, 5))
loss.backward()
optimizer.step()# 2. zero_grad() 方法将参数梯度置零
optimizer.zero_grad()# 3. state_dict() 和 load_state_dict() 方法
optimizer_state = optimizer.state_dict()
torch.save(optimizer_state, 'optimizer.pth')
optimizer_state_loaded = torch.load('optimizer.pth')
optimizer.load_state_dict(optimizer_state_loaded)# 4. add_param_group(param_group) 方法示例
param_group = {'params': model.fc.parameters(), 'lr': 0.001}
optimizer.add_param_group(param_group)# 5. get_lr() 和 set_lr() 方法示例
lr = optimizer.param_groups[0]['lr']
optimizer.param_groups[0]['lr'] = 0.001# 6. step_closure(closure) 方法示例
def closure():optimizer.zero_grad()output = model(torch.randn(5, 10))loss = nn.functional.mse_loss(output, torch.randn(5, 5))loss.backward()return lossloss = optimizer.step(closure)
3.3常用优化器
随机梯度下降优化器（SGD）：

SGD是最基本的优化算法，在每一步中根据当前梯度更新模型参数。虽然简单，但在某些情况下可能陷入局部极小值。

动量优化器（Momentum）：

动量优化器基于SGD，引入了动量的概念，可以加速收敛并帮助跳出局部极小值。有助于减少梯度震荡，特别适用于处理稀疏梯度问题。

自适应矩估计优化器（Adagrad）：

Adagrad根据参数的梯度更新学习率，对于频繁出现的参数梯度较大的情况效果更好。但会累积过去所有梯度平方，可能导致学习率衰减过快。

自适应矩估计优化器（RMSprop）：

RMSprop是对Adagrad的改进，通过引入衰减系数来控制历史梯度对学习率的影响，避免学习率过快下降。

Adam优化器：

Adam是一种结合了动量概念和自适应学习率的优化算法，结合了Momentum和RMSprop的优点，通常在实践中效果较好。

以下是五种常见优化器（SGD、Momentum、Adagrad、RMSprop、Adam）在PyTorch中的Python代码实现示例：

随机梯度下降优化器（SGD）：
import torch
import torch.nn as nn
import torch.optim as optimmodel = nn.Linear(10, 1)
criterion = nn.MSELoss()
optimizer_sgd = optim.SGD(model.parameters(), lr=0.01)
动量优化器（Momentum）：
optimizer_momentum = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)
自适应矩估计优化器（Adagrad）：
optimizer_adagrad = optim.Adagrad(model.parameters(), lr=0.01)
自适应矩估计优化器（RMSprop）：
optimizer_rmsprop = optim.RMSprop(model.parameters(), lr=0.01, alpha=0.99, eps=1e-08)
Adam优化器：
optimizer_adam = optim.Adam(model.parameters(), lr=0.001, betas=(0.9, 0.999), eps=1e-08)
这些代码示例展示了如何在PyTorch中实现随机梯度下降（SGD）、动量优化器（Momentum）、自适应矩估计优化器（Adagrad）、RMSprop和Adam优化器。通过选择合适的优化器和调整参数，可以实现更有效的模型优化和训练过程。希望这些代码对您有所帮助！