深度学习之图像回归（一）

前言

图像回归任务主要是理解一个最简单的深度学习相关项目的结构，整体的思路，数据集的处理，模型的训练过程和优化处理。

因为深度学习的项目思路是差不多的，主要的区别是对于数据集的处理阶段，之后模型训练有一些小的差异。

现在以回归项目进行切入点来理解模型训练的流程。

一关于整体流程

模型训练的目的是通过训练集进行模型训练最终得到一个优化后的最佳的模型帮我们完成对数据的预测比如根据一个数据的多个描述维度最终得到标签对应的预测值

整体步骤如下：

准备数据（输入 x 和目标 y）。
初始化模型参数。
用模型预测输出 y^。
计算损失值（比如MSE）。
用梯度下降更新参数。
重复步骤3-5，直到损失值不再下降。
用测试数据评估模型性能。

简而言之就是通过对数据集训练输入x 然后经过模型训练得到对应的y 计算loss 梯度回传更新模型直到算出最好的一项

二关于数据集处理

代码

class Covid_dataset(Dataset):def __init__(self, file_path, mode):  # mode说明数据集是什么类型 训练集还是测试集with open(file_path, "r") as f:csv_data = list(csv.reader(f))data = np.array(csv_data[1:])if mode == "train":indices = [i for i in range(len(data)) if i % 5 != 0]elif mode == "val":indices = [i for i in range(len(data)) if i % 5 == 0]if mode == "test":x = data[:, 1:].astype(float)x = torch.tensor(x)else:x = data[indices, 1:-1].astype(float)x = torch.tensor(x)y = data[indices, -1].astype(float)self.y = torch.tensor(y)self.x = x - x.mean(dim=0, keepdim=True) / x.std(dim=0, keepdim=True)self.mode = modedef __getitem__(self, item):if self.mode == "test":return self.x[item].float()  # 测试集没标签。   注意data要转为模型需要的float32型else:  # 否则要返回带标签数据return self.x[item].float(), self.y[item].float()def __len__(self):return len(self.x)

实现思路

这个类有三个功能函数分别对应初始化取出特定的一个元素计算数据集长度

需要注意的是，数据的处理需要根据训练集测试集测试集三个不同的部分进行对应处理

Index	Feature1	Feature2	...	FeatureN	Label
1	0.1	0.2	...	0.3	10
2	0.4	0.5	...	0.6	20
...	...	...	...	...	...

特征部分：从第二列到倒数第二列（Feature1 到 FeatureN）。
标签部分：最后一列（Label）。

如图是一个csv格式的数据

注意事项

1 测试集训练集验证集如何划分

对于训练集和验证集按照4:1的比例进行划分

训练集需要的数据体量比较大主要是为了保证训练的准确性验证集比较小

2 测试集训练集验证集的特征值和标签

对于测试集

由于测试集主要是在模型训练完成之后评估模型性能的因此特征值需要提取第二列到最后一列，此时最后一列也作为特征被提取

不需要带标签因为测试集用来测试模型对未知数据的预测能力标签是未知的

对于验证集和训练集

需要提取第二列到倒数第二列作为特征值

同时需要提取对应的标签

是否需要标签可以类比成做练习题训练集是平时训练的题目验证集是自己做的小测试都是有答案的这样可以方便调整而测试集不带标签可以理解成最后的大考是没有答案的

3 数据的处理

为什么特征值和标签需要处理成张量的形式还需要转换成浮点数

转换为张量：是为了与 PyTorch 模型兼容，支持 GPU 加速和自动求导。
转换为浮点数：是为了确保数据在数学运算中的精度，支持梯度下降和数据标准化。

4 归一化的原因和方式

归一化（Normalization）是数据预处理中非常重要的一步，尤其是在机器学习和深度学习中。它的目的是将特征值调整到一个统一的范围内，例如 [0, 1] 或 [-1, 1]，或者使其符合某种分布（如均值为 0、标准差为 1 的正态分布）。归一化的处理可以显著提高模型的训练效率和性能。

以下是归一化处理的几个主要原因：

1. 加速模型收敛

原因：不同的特征可能有不同的量纲和数值范围。例如，一个特征的范围可能是 [0, 1]，而另一个特征的范围可能是 [0, 1000]。如果不对这些特征进行归一化，模型在训练时可能会因为特征的数值差异而难以收敛。
解释：在梯度下降过程中，数值范围大的特征可能会主导梯度的方向，导致模型的更新方向不准确。通过归一化，所有特征的数值范围被统一，梯度下降的方向更加均衡，从而加速模型的收敛。

2. 提高模型性能

原因：归一化可以减少特征之间的数值差异，使模型更容易学习到数据中的模式。
解释：对于许多机器学习算法（如线性回归、支持向量机、神经网络等），特征的数值范围会影响模型的权重更新。如果特征的数值范围差异过大，模型可能会对某些特征过于敏感，而忽略其他特征。归一化可以避免这种情况，从而提高模型的性能。

3. 防止数值计算问题

原因：在深度学习中，模型的训练过程涉及大量的矩阵运算和梯度计算。如果特征的数值范围过大，可能会导致数值计算问题，如梯度爆炸（Gradient Explosion）或梯度消失（Gradient Vanishing）。
解释：
- 梯度爆炸：当数值范围过大时，梯度可能会变得非常大，导致模型的权重更新过大，从而使模型的训练不稳定。
- 梯度消失：当数值范围过小时，梯度可能会变得非常小，导致模型的权重更新过慢，从而使模型难以收敛。

通过归一化，可以将特征值调整到一个合理的范围内，避免这些数值计算问题。

4. 提高模型的泛化能力

原因：归一化可以减少模型对数据的依赖，使模型更加鲁棒。
解释：如果特征的数值范围差异过大，模型可能会过度拟合训练数据中的数值差异，而无法泛化到新的数据。通过归一化，模型可以更好地学习数据中的模式，而不是数值差异，从而提高模型的泛化能力。

5. 常见的归一化方法

(1) Min-Max 归一化：
- 将特征值调整到 [0, 1] 范围内：
```
x_normalized = (x - x_min) / (x_max - x_min)
```
- 优点：简单直观，适用于特征值范围已知的情况。
- 缺点：对异常值敏感，如果数据中存在极端值，可能会导致归一化后的数据范围不均匀。
(2) Z-Score 标准化：
- 将特征值调整到均值为 0、标准差为 1 的分布：
```
x_normalized = (x - x_mean) / x_std
```
- 优点：对异常值不敏感，适用于特征值呈正态分布的情况。
- 缺点：如果数据不符合正态分布，归一化后的数据可能仍然存在数值范围差异。
(3) MaxAbs 归一化：
- 将特征值调整到 [-1, 1] 范围内：
```
x_normalized = x / max(abs(x))
```
- 优点：适用于稀疏数据，能够保留数据的稀疏性。
- 缺点：对异常值敏感。

6. 总结

归一化处理是机器学习和深度学习中非常重要的一步，它可以帮助：

加速模型的收敛。
提高模型的性能。
防止数值计算问题。
提高模型的泛化能力。

归一化的方法选择取决于数据的特性和任务的需求。常见的归一化方法包括 Min-Max 归一化、Z-Score 标准化和 MaxAbs 归一化。

三关于自定义的神经网络模型

class myModel(nn.Module):def __init__(self, dim):super(myModel, self).__init__()self.fc1 = nn.Linear(dim, 100)self.relu = nn.ReLU()self.fc2 = nn.Linear(100, 1)def forward(self, x):x = self.fc1(x)x = self.relu(x)x = self.fc2(x)if len(x.size()) > 1:return x.squeeze(1)else:return x

关注的问题:

1 模型结构

输入层、隐藏层（带 ReLU 激活函数）、输出层。

参数的计算以便于帮我们更好地理解模型

维度变化

层级	维度变化	参数计算式	参数量
fc1	dim → 100	(dim × 100) + 100	10100
fc2	100 → 1	(100 × 1) + 1	101
总计			10201

本质上是y=wx+b的线性计算

dim对应的是对应的特征值需要先进行线性运算映射到一个隐藏层隐藏层经过ReLU的激活改变数值的分布最后ReLU到fc2 继续线性变换后输出由于是回归任务因此是预测一个连续值需要注意的是输出的维度需要统一成一维的

2 激活函数

引入激活函数的原因

引入非线性
- 使神经网络能够拟合任意复杂函数
- 无激活函数时多层网络等价于单层线性变换
特征空间映射
- 将输入分布映射到特定输出范围（如(0,1)、(-1,1)等）在这个范围内模型表现比较好
梯度调控
- 通过导数控制反向传播的梯度流动

选择ReLU的核心原因

优势维度	具体表现	对比其他激活函数
梯度传导	正区间梯度恒为1，避免梯度消失	Sigmoid最大梯度仅0.25
计算效率	无需指数运算，速度提升约6倍	Tanh需计算双曲函数
稀疏激活	约50%神经元被抑制，提升特征选择性	Leaky ReLU保持全激活
生物学合理	近似神经元"全或无"的放电特性	更符合生物神经元工作机制

3 为什么要这样设计输出层？

统一输出形状：
- 在回归任务中，我们希望模型的输出是一个一维张量 [batch_size]，而不是二维张量 [batch_size, 1]。这样可以方便后续的计算，例如计算损失函数时，损失函数通常期望输入是一维张量。
兼容不同批量大小：
- 当批量大小为 1 时，模型的输出可能是 [1] 而不是 [1, 1]。通过这段代码，可以确保无论批量大小是多少，输出的形状始终是一致的。

四关于模型训练

# 训练函数
def train_val(model, train_loader, val_loader, device, epochs, optimizer, loss, save_path):model = model.to(device)# 记录每一轮的损失函数plt_train_loss = []plt_val_loss = []min_val_loss = 9999999999999# 训练for epoch in range(epochs):train_loss = 0.0val_loss = 0.0start_time = time.time()model.train()  # 模型调整为训练模式for batch_x, batch_y in train_loader:x, target = batch_x.to(device), batch_y.to(device)pred = model(x)  # 得到预测值train_bat_loss = loss(pred, target)train_bat_loss.backward()  # 梯度回传 更新模型optimizer.step()optimizer.zero_grad()  # 清零 训练完一轮了train_loss += train_bat_loss.cpu().item()plt_train_loss.append(train_loss / train_loader.dataset.__len__())# 验证 model.eval()with torch.no_grad():for batch_x, batch_y in val_loader:x, target = batch_x.to(device), batch_y.to(device)pred = model(x)  # 得到预测值val_bat_loss = loss(pred, target)val_loss += val_bat_loss.cpu().item()plt_val_loss.append(val_loss/val_loader.__len__())# 保存结果if val_loss < min_val_loss:torch.save(model, save_path)min_val_loss = val_lossprint('[%03d/%03d] %2.2f sec(s) TrainLoss : %.6f | valLoss: %.6f' % \(epoch, epochs, time.time() - start_time, plt_train_loss[-1], plt_val_loss[-1]))  # 打印训练结果。 注意python语法， %2.2f 表示小数位为2的浮点数， 后面可以对应。# 画图plt.plot(plt_train_loss)plt.plot(plt_val_loss)plt.title("loss图")plt.legend(["train", "val"])plt.show()

关于反向传播

因为模型不可能一次训练就得到最优秀的结果因此需要根据训练结果动态更新最后得到的一个观测值计算与标签的loss之后可以通过反向求导计算梯度之后利用梯度下降算法进行更新直到表现最优秀

关于验证集

验证集不需要进行梯度更新只有训练的时候需要

(1) 验证集的作用是评估模型

验证集用于评估模型在未见过的数据上的表现，而不是用于训练模型。如果在验证集上更新梯度，模型会逐渐适应验证集的数据，这违背了验证集的初衷。
验证集的核心目标：评估模型的泛化能力，确保模型在新的、未见过的数据上仍然表现良好。

(2) 防止过拟合

如果在验证集上更新梯度，模型可能会逐渐过拟合验证集的数据，导致模型在训练集和验证集上表现良好，但在真实数据上表现不佳。
过拟合：模型对训练数据（包括验证集）拟合得过于完美，但在新数据上表现差。

(3) 保持模型的独立性

验证集应该保持独立性，即模型在验证集上的表现应该反映其在真实数据上的表现。
如果在验证集上更新梯度，模型会逐渐依赖验证集的数据，失去独立性。

五关于模型测试

这段代码实现了一个完整的测试流程，包括：

加载模型：从指定路径加载训练好的模型。
测试阶段：对测试数据进行预测，并将预测结果存储到列表中。
保存结果：将预测结果保存到一个 CSV 文件中，格式为 [id, 预测值]。

def evaluate(save_path, device, test_loader, rel_path):model = torch.load(save_path).to(device)rel = []with torch.no_grad():for x in test_loader:pred = model(x.to(device))rel.append(pred.cpu().item())print(rel)with open(rel_path, "w", newline='') as f:csvWtiter = csv.writer(f)csvWtiter.writerow(["id", "test_positive"])for i, value in enumerate(rel):csvWtiter.writerow([str(i), str(rel[i])])print("文件已经保存到{}".format(rel_path))

六关于超参数的设置

device = "cuda" if torch.cuda.is_available() else "cpu"train_file = "covid.train.csv"
test_file = "covid.test.csv"train_data = Covid_dataset(train_file, "train")
val_data = Covid_dataset(train_file, "val")
test_data = Covid_dataset(train_file, "test")train_loader = DataLoader(train_data, batch_size=16, shuffle=True)
val_loader = DataLoader(val_data, batch_size=16, shuffle=True)
test_loader = DataLoader(test_data, batch_size=1, shuffle=False)  # 测试集的batchsize一般为1 且不可以打乱dim = 93config = {"lr": 0.001,"momentum": 0.9,"epochs": 20,"save_path": "model_save/model.pth","rel_path": "pred.csv"
}model = myModel(dim)loss = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=config["lr"], momentum=config["momentum"])  # 优化器train_val(model, train_loader, val_loader, device, config["epochs"], optimizer, loss, config["save_path"])evaluate(config["save_path"], device, test_loader, config["rel_path"])

在这段代码中，超参数（Hyperparameters）是用于控制模型训练过程和行为的关键参数。它们在训练开始之前需要手动设置，并对模型的性能和训练效率有重要影响。以下是对代码中涉及的超参数的详细解释：

1. 设备选择（Device）

device = "cuda" if torch.cuda.is_available() else "cpu"

超参数：device
作用：指定模型和数据运行的设备。
解释：
- 如果 GPU（CUDA）可用，则使用 "cuda"，否则使用 "cpu"。
- 使用 GPU 可以显著加速模型的训练和推理过程。

2. 数据加载器（DataLoader）

train_loader = DataLoader(train_data, batch_size=16, shuffle=True)
val_loader = DataLoader(val_data, batch_size=16, shuffle=True)
test_loader = DataLoader(test_data, batch_size=1, shuffle=False)

超参数：
- batch_size：每个批次的样本数量。
- shuffle：是否在每个 epoch 开始时随机打乱数据。
作用：
- batch_size：
  - 控制每次传递给模型的数据量。
  - 较大的 batch_size 可以提高训练效率，但会增加内存消耗。
  - 较小的 batch_size 可以减少内存消耗，但可能需要更多的迭代次数。
- shuffle：
  - 在训练和验证阶段，通常将数据打乱以防止模型学习到数据的顺序。
  - 在测试阶段，通常不打乱数据，以保持预测结果的顺序。

3. 模型参数

dim = 93
model = myModel(dim)

超参数：dim
作用：输入特征的维度。
解释：
- dim 是输入数据的特征数量，用于初始化模型的输入层。
- 在这个例子中，输入特征的维度是 93。

4. 训练配置（Config）

Python复制

config = {"lr": 0.001,"momentum": 0.9,"epochs": 20,"save_path": "model_save/model.pth","rel_path": "pred.csv"
}

超参数：
- lr（Learning Rate）：学习率，控制参数更新的步长。
  - 较大的学习率可能导致模型训练不稳定，较小的学习率可能导致训练速度过慢。
- momentum：动量因子，用于加速梯度下降过程，防止震荡。
  - 动量可以帮助优化器跳出局部最小值，加速收敛。
- epochs：训练的总轮数。
  - 较多的轮数可以提高模型性能，但可能导致过拟合。
- save_path：保存最佳模型的路径。
- rel_path：保存预测结果的路径。

5. 损失函数和优化器

loss = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=config["lr"], momentum=config["momentum"])

超参数：
- 损失函数（Loss Function）：
  - nn.MSELoss()：均方误差损失函数，适用于回归任务。
- 优化器（Optimizer）：
  - optim.SGD：随机梯度下降优化器。
  - lr：学习率。
  - momentum：动量因子。

6. 测试阶段

evaluate(config["save_path"], device, test_loader, config["rel_path"])

超参数：
- test_loader 的 batch_size 设为 1，因为测试集通常逐个样本进行预测。
- shuffle=False，以保持预测结果的顺序。

总结

在这段代码中，涉及的超参数包括：

设备选择：device。
数据加载器：
- batch_size：控制每个批次的样本数量。
- shuffle：是否随机打乱数据。
模型参数：
- dim：输入特征的维度。
训练配置：
- lr：学习率。
- momentum：动量因子。
- epochs：训练的总轮数。
- save_path：保存模型的路径。
- rel_path：保存预测结果的路径。
损失函数和优化器：
- 损失函数：nn.MSELoss()。
- 优化器：optim.SGD。