一、项目背景
台湾大学李宏毅老师 2021 春季机器学习课程的作业竞赛：“ML2021Spring-hw1”， 项目所需数据可点击链接下载，链接如下：
https://www.kaggle.com/competitions/ml2021spring-hw1
二、代码解析
代码涵盖了深度学习项目从数据加载、模型定义、训练、验证到最终结果评估的完整流程，实现了一个基于 PyTorch 框架的深度学习模型，用于处理一个与 COVID-19 相关的数据集，旨在预测预测美国 40 个州第三天的新冠病毒检测阳性率。（代码下载链接在文末，也可逐段复制）
1、库导入
import torch
import matplotlib.pyplot as plt # 画图
import matplotlib
import numpy as np # 矩阵相关
import csv # 处理csv文件
import pandas # csv文件
# 方便的 Dataset, DataLoader 的使用
from torch.utils.data import Dataset, DataLoader
import torch.nn as nn
# 方便的 optim 的使用
from torch import optim
import time
2、数据集定义：CovidDataset 类
class CovidDataset(Dataset):
def __init__(self, file_path, mode):
with open(file_path, "r") as f:
ori_data = list(csv.reader(f))
csv_data = np.array(ori_data)[1:, 1:].astype(float) #不要第一行和第一列
#逢五取1，不推荐
if mode == "train":
indices = [i for i in range(len(csv_data)) if i % 5 != 0]
elif mode == "val":
indices = [i for i in range(len(csv_data)) if i % 5 == 0]
elif mode == "test":
indices = [i for i in range(len(csv_data))]
X = torch.tensor(csv_data[indices, :93])
if mode != "test":
self.Y = torch.tensor(csv_data[indices, -1])
self.X = (X – X.mean(dim=0, keepdim=True)) / X.std(dim=0, keepdim=True)
self.mode = mode
def __getitem__(self, item):
if self.mode == "test":
return self.X[item].float()
else:
return self.X[item].float(), self.Y[item].float()
def __len__(self):
return len(self.X)
__init__(self, file_path, mode) 方法的作用：
1、数据加载：使用 csv.reader 读取 CSV 文件内容，并转换为 NumPy 数组 csv_data，并跳过了第一行、第一列的无效数据。 2、数据划分：根据 mode 参数（ train、val、test）来划分数据集。训练集 (train) 包含所有索引不能被 5 整除的数据，验证集 (val) 包含所有索引能被 5 整除的数据，测试集 (test) 包含所有数据。 3、特征与标签分离：将前 93 列数据作为特征 X，将最后一列数据作为标签 Y。这表明该数据集有 93 个特征，并且是一个回归任务，因为标签是连续值。 4、数据标准化：对特征数据 X 进行了标准化处理，将其缩放到均值为 0、标准差为 1 的范围，有助于加速模型收敛，并防止某些特征的数值范围过大对模型训练产生主导作用。
__getitem__(self, item) 方法： 这是 Dataset 类必须实现的方法之一，用于根据给定的索引 item 返回一个数据样本。在训练和验证模式下，它返回特征 self.X[item] 和标签 self.Y[item]；在测试模式下，由于测试集没有标签，它只返回特征 self.X[item]。
__len__(self) 方法：这是 Dataset 类必须实现的另一个方法，返回数据集中样本的总数，即 self.X 的长度。
3、模型定义：myModel 类
class myModel(nn.Module):
def __init__(self, inDim):
super(myModel, self).__init__()
self.fc1 = nn.Linear(inDim, 128)
self.relu1 = nn.ReLU()
self.fc2 = nn.Linear(128, 1)
def forward(self, x):
x = self.fc1(x)
x = self.relu1(x)
x = self.fc2(x)
if len(x.size()) > 1:
x = x.squeeze(1) #如果维度大于1， 就去掉第二个维度
return x
__init__(self, inDim) 方法：
1、super(myModel, self).__init__()：调用父类 nn.Module 的构造函数 2、self.fc1 = nn.Linear(inDim, 128)：定义第一个全连接层（线性层）。inDim 是输入特征的维度（在本例中是 93）；128 是该层的输出维度，即隐藏层神经元的数量。全连接层的作用是将输入数据通过线性变换映射到另一个特征空间。 3、self.relu1 = nn.ReLU()：定义 ReLU 激活函数。ReLU 是一种常用的非线性激活函数，它能够引入非线性，使得神经网络可以学习更复杂的模式。 4、self.fc2 = nn.Linear(128, 1)：定义第二个全连接层。输入维度是前一层的输出维度 128，输出维度是 1，因为这是一个回归任务，最终需要预测一个单一的连续值。
forward(self, x) 方法：
1、这是 nn.Module 子类必须实现的方法，定义了数据在模型中前向传播的计算过程。当模型被调用时（例如 model(x)），实际上就是执行这个 forward 方法。 2、x = self.fc1(x)：输入 x 首先通过第一个全连接层。 3、x = self.relu1(x)：然后通过 ReLU 激活函数，引入非线性。 4、x = self.fc2(x)：接着通过第二个全连接层，得到模型的最终输出。 5、if len(x.size()) > 1: x = x.squeeze(1)：这行代码用于处理输出张量的维度。如果模型的输出 x 的维度大于 1（例如，形状为 [batch_size, 1]），则使用 squeeze(1) 去掉第二个维度，使其形状变为 [batch_size]。这通常是为了确保模型的输出与标签的维度一致，方便后续损失计算。
4、训练与验证函数：train_val
train_val 函数封装了模型的训练和验证逻辑，是深度学习模型训练的核心部分。
def train_val(model, train_loader, val_loader, lr, optimizer, device,
epochs, save_path):
model = model.to(device) #防止意外
plt_train_loss = [] #总训练loss
plt_val_loss = []
min_val_loss = 999999999999999999.9
for epoch in range(epochs): #发枪指令， 冲锋的号角， 模型训练的开始
model.train()
start_time = time.time()
train_loss = 0.0 #浮点形式
for x, y in train_loader:
x, y = x.to(device), y.to(device)
y_pred = model(x)
bat_loss = loss(y_pred, y, model)
bat_loss.backward()
optimizer.step()
optimizer.zero_grad()
train_loss += bat_loss.cpu().item()
plt_train_loss.append(train_loss/train_loader.__len__())
model.eval()
val_loss = 0.0
with torch.no_grad():
for val_x, val_y in val_loader:
val_x, val_y = val_x.to(device), val_y.to(device)
val_pred_y = model(val_x)
val_bat_loss = loss(val_pred_y, val_y, model)
val_loss += val_bat_loss.cpu().item()
plt_val_loss.append(val_loss / val_loader.__len__())
#保存
if val_loss < min_val_loss:
min_val_loss = val_loss
torch.save(model, save_path)
print("[%03d/%03d] %2.2f sec(s) train_loss: %.6f val_loss: %.6f" % \\
(epoch, epochs, time.time()-start_time,
plt_train_loss[-1], plt_val_loss[-1]))
plt.plot(plt_train_loss)
plt.plot(plt_val_loss)
plt.title("loss")
plt.legend(["train", "val"])
plt.show()
训练循环 (for epoch in range(epochs))：
1.model.train()：将模型设置为训练模式。这会启用 Dropout 和 BatchNorm 等层的功能，这些层在训练和评估模式下的行为不同。
2.start_time = time.time()：记录每个 epoch 开始的时间，用于计算该 epoch 的耗时。
3.训练阶段 (for x, y in train_loader)：
（1）x, y = x.to(device), y.to(device)：将输入特征 x 和标签 y 移动到指定设备上进行计算。
（2）y_pred = model(x)：前向传播。将输入 x 传递给模型，得到模型的预测输出 y_pred。
（3） bat_loss = loss(y_pred, y, model)：计算当前批次的损失。这里使用了自定义的 loss 函数，它包含了均方误差和 L2 正则化项。
（4） bat_loss.backward()：反向传播。计算损失相对于模型所有可训练参数的梯度。这是深度学习中优化模型参数的关键步骤，它利用链式法则计算每个参数对损失的贡献。
（5） optimizer.step()：参数更新。根据计算出的梯度和优化器的策略来更新模型的参数，使损失函数减小
（6） optimizer.zero_grad()：梯度清零。在每次反向传播之前，需要将模型参数的梯度清零。因为 PyTorch 默认会累积梯度，如果不清零，则梯度会叠加，导致错误的参数更新。 （7）train_loss += bat_loss.cpu().item()：累加每个批次的损失，并将其从设备（如 GPU）移动到 CPU，并转换为 Python 标量。
4.plt_train_loss.append(train_loss/train_loader.__len__())：记录每个 epoch 的平均训练损失。
5.验证阶段：
（1）model.eval()：将模型设置为评估模式。这会禁用 Dropout 等层，确保模型在评估时行为一致。 （2）with torch.no_grad():：在此上下文管理器中，PyTorch 不会计算和存储梯度。这在验证和测试阶段非常重要，可以节省内存并加速计算，因为此时不需要进行反向传播。 （3）验证循环 (for val_x, val_y in val_loader) 的逻辑与训练阶段类似，但没有反向传播和参数更新。 （4） plt_val_loss.append(val_loss / val_loader.__len__())：记录每个 epoch 的平均验证损失。 6.模型保存： （1）if val_loss < min_val_loss:：如果当前 epoch 的验证损失低于历史最低验证损失，则更新 min_val_loss 并保存当前模型。这种策略称为“早停”（Early Stopping），它有助于防止模型过拟合，即在验证集上表现最好的模型通常具有更好的泛化能力。 （2）torch.save(model, save_path)：保存整个模型的状态。 7.进度打印与可视化： （1）print(…)：打印每个 epoch 的训练损失、验证损失和耗时，方便监控训练进度。 （2）plt.plot(…) 和 plt.show()：在训练结束后，绘制训练损失和验证损失随 epoch 变化的曲线图，直观展示模型的学习情况
5、评估函数：evaluate
evaluate 函数用于加载训练好的模型，对测试集进行预测，并将预测结果保存到 CSV 文件中。
def evaluate(model_path, test_loader, rel_path, device):
model = torch.load(model_path).to(device)
rel = [] #记录预测结果
model.eval()
with torch.no_grad():
for x in test_loader:
x = x.to(device)
pred = model(x)
rel.append(pred.cpu().item())
with open(rel_path, "w", newline="") as f:
csv_writer = csv.writer(f)
csv_writer.writerow(["id", "tested_positive"])
for i, pred in enumerate(rel): #同时得到 第几个 和第几个的结果
csv_writer.writerow([str(i), str(pred)])
print("结果保存到了"+rel_path)
6、损失函数定义：mseLoss
mseLoss 函数定义了带有 L2 正则化的均方误差（Mean Squared Error, MSE）损失函数。这是回归任务中常用的损失函数。
def mseLoss(pred, target, model):
loss = nn.MSELoss(reduction=\\'mean\\') #平方差损失
\\'\\'\\' Calculate loss \\'\\'\\'
regularization_loss = 0 # 正则项
for param in model.parameters():
# TODO: you may implement L1/L2 regularization here
# 使用L2正则项
# regularization_loss += torch.sum(abs(param))
regularization_loss += torch.sum(param ** 2)
# 计算所有参数平方
return loss(pred, target) + 0.00075 * regularization_loss
# 返回损失。
7、主程序执行部分
这部分代码负责设置超参数、实例化数据集和模型、定义优化器，并调用训练和评估函数，是整个程序的入口。
注意：
train_file = r"/Users/mastery/Lxy/Deep_Learning/LiGe/第三节，回归实战代\\n码/regression/covid/covid.train.csv" test_file = r"/Users/mastery/Lxy/Deep_Learning/LiGe/第三节，回归实战代码\\n/regression/covid/covid.test.csv"
要改成您自己存放train.csv和test.csv的文件路径
train_file = r"/Users/mastery/Lxy/Deep_Learning/LiGe/第三节，回归实战代\\n码/regression/covid/covid.train.csv"
test_file = r"/Users/mastery/Lxy/Deep_Learning/LiGe/第三节，回归实战代码\\n/regression/covid/covid.test.csv"
batch_size = 16
train_set = CovidDataset(train_file, "train")
val_set = CovidDataset(train_file, "val")
test_set = CovidDataset(test_file, "test")
train_loader = DataLoader(train_set, batch_size=batch_size,
shuffle=True)
val_loader = DataLoader(val_set, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_set, batch_size=1, shuffle=False)
loss = mseLoss
epochs = 20 #运行轮次
lr = 0.001 #学习率
device = "cuda" if torch.cuda.is_available() else "cpu"
print(device)
data_dim = 93
model = myModel(data_dim).to(device)
save_path = "model_save/best_model.pth"
rel_path = "pred.csv"
optimizer = optim.SGD(params=model.parameters(), lr=lr, momentum=0.9)
train_val(model, train_loader, val_loader, lr, optimizer, device,
epochs, save_path)
#提交
evaluate(save_path, test_loader, rel_path, device)
三、代码下载
通过网盘分享的文件：回归实战：新冠病毒感染人数预测 链接: https://pan.baidu.com/s/17XfOi1X3ANCewa1-RJWqEw?pwd=z57b 提取码: z57b
