一、项目背景

        台湾大学李宏毅老师 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 

详细原理介绍：https://blog.csdn.net/2601_95212157/article/details/158729807?spm=1001.2014.3001.5502