新冠病毒感染人数预测项目

问题描述如下：

一.导入库

import torch #张量相关操作 import matplotlib.pyplot as plt #画图的 import numpy as np #矩阵相关操作 import random #生成随机数 import csv #处理csv文件 import pandas #处理csv文件，更高级 from torch.utils.data import Dataset,DataLoader #继承类 import torch.nn as nn from torch import optim #optim 优化

依次导入张量，画图，矩阵，随机数，处理csv文件，继承类，优化器等库

二.数据模块

以下为数据模块的通用抽象模板：

它是自定义数据集的灵魂框架：继承类Dataset必须实现__init__、__getitem__、__len__三个方法，它们分工明确、缺一不可。

1.__init__：初始化与数据加载

• 作用：在创建数据集实例时一次性完成准备工作
  • 读取文件路径、加载数据到内存（如 CSV / 图片路径列表）
  • 保存特征、标签或样本索引
  • 做全局预处理（如归一化参数计算）

class CovidDataset(Dataset): #类CovidDataset继承类Dataset def __init__(self,file_path,mode): #类的初始化，需要传入数据文件路径file_path和数据类型mode with open(file_path,"r") as f: #打开数据文件，只读 reader=csv.reader(f) #将文件f中数据读出来并赋值给变量reader ori_data=list(reader) #将文件数据转化为列表并赋值给变量ori_data(原始数据） csv_data=np.array(ori_data)[1:,1:].astype(float) #将原始数据ori_data转换为矩阵（浮点型），不要第一行和第一列 #接下来要根据处理后的数据csv_data来制造出我们需要的X,Y。但是要区分数据类型： Training,Valiation,Testing #假设Valiation数据对Training数据逢5取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] #Testing数据必须得按顺序来取 elif mode=='test': indices=[i for i in range(len(csv_data))] X=torch.tensor(csv_data[indices,:93]) #如果数据类型为Training和Valiation，有Y；如果数据类型为Testing，则没有Y 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

2.__getitem__：取单个样本（核心！）

• 作用：根据索引item返回一个样本（特征 + 标签）
  • 是DataLoader批量打包的基础：DataLoader会多次调用__getitem__，把多个样本拼成一个 batch
  • 可在这一步做实时预处理（如图片 resize、文本分词、数据增强）

def __getitem__(self, item): #item指的是索引，根据索引 item 返回一个样本（特征 + 标签） if self.mode=='test': return self.X[item].float() #数据类型为Testing时，返回x else: return self.X[item].float(),self.Y[item].float() #数据类型为Training或Valiation时，返回x和y

3.__len__：返回数据集大小

• 作用：告诉 PyTorch 这个数据集有多少个样本
  • 决定了for循环遍历的次数
  • 是DataLoader计算「总批次数」的依据

def __len__(self): return len(self.X) #返回数据集大小

三.模型模块

以下为模型模块的通用抽象模板：

它是自定义模型的标准框架：继承nn.Module必须实现__init__和forward两个方法，是构建神经网络的核心约定。

1.__init__：定义模型结构与可学习参数

• 作用：在模型初始化时定义所有可学习的层和参数，需要传入输入数据的维度
  • 定义线性层（nn.Linear）、卷积层（nn.Conv2d）、激活函数（nn.ReLU）等
  • 这些层会自动维护可训练参数（权重w、偏置b），后续可被优化器更新
  • 必须调用super().__init__()来初始化父类nn.Module

class myModel(nn.Module): # myModel继承自nn.Model #在模型初始化时定义所有可学习的层和参数,需要传入输入数据的维度 def __init__(self,inDim): super(myModel,self).__init__() #必须调用 super().__init__() 来初始化父类 nn.Module self.fc1=nn.Linear(inDim,128) #定义linear1（inDim，128） self.relu1=nn.ReLU() #定义第1层的激活函数ReLU self.fc2=nn.Linear(128,1) #定义Linear2（128，1）

2.forward：定义前向传播逻辑

• 作用：描述「数据如何流经模型」，是模型的核心计算逻辑
  • 接收输入x，依次通过各层运算，最终输出预测值
  • 不要直接调用forward(x)，而是用model(x)触发

def forward(self,x): #需要传入数据x x=self.fc1(x) x=self.relu1(x) x=self.fc2(x) #通过模型计算出估计y if len(x.size())>1: x=x.squeeze(1) #如果估计y维度大于1，就去掉第2个维度 return x

四.超参量模块

定义除模型中内部参数以外的超参数。一般包括：学习率，优化器（优化算法），损失函数等。

是监控模型效果、调整超参数的环节，绝不更新模型参数

1.输入

传入各阶段所需数据

##传入各阶段所需数据## #传入相关文件路径 train_file = r"D:\桌面\课程代码\第三节，回归实战代码\regression\covid\covid.train.csv" test_file = r"D:\桌面\课程代码\第三节，回归实战代码\regression\covid\covid.test.csv" save_file = r"D:\桌面\课程代码\第三节，回归实战代\regression\covid\model_save\best_model.pth" rel_file = r"D:\桌面\课程代码\第三节，回归实战代码\regression\covid\pred.csv" #确定批次数据个数，构建本批次所需数据 batch_size=16 #每批次取16个数据 train_set=CovidDataset(train_file,'train') #传入训练数据文件train_file并构建CovidDataset类的实例train_set，即构建出Training数据集 val_set=CovidDataset(train_file,'val') #传入训练数据文件train_file并构建CovidDataset类的实例val_set，即构建出Valiation数据集 test_set=CovidDataset(test_file,'test') #传入测试数据文件test_file并构建CovidDataset类的实例test_set，即构建出Test数据集 train_loader=DataLoader(train_set,batch_size=batch_size,shuffle=True) #传入Training数据集，批次大小，并进行乱序排列。获取每批次的Training数据 val_loader=DataLoader(val_set,batch_size=batch_size,shuffle=True) #传入Valiation数据集，批次大小，并进行乱序排列。获取每批次的Valiation数据 test_loader=DataLoader(test_set,batch_size=1,shuffle=False) #传入Testing数据集，批次大小为1，并进行顺序排列。获取每批次的Testing数据

2.定义超参

定义各种超参（Loss函数，运行轮次epochs，学习率lr，运行设备，数据输入维度，优化器optimizer），并导入模型

##定义各种超参## loss=nn.MSELoss()#定义Loss函数 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) #导入模型 optimizer=optim.SGD(params=model.parameters(),lr=lr,momentum=0.9) #设置优化器

优化器SGD（随机梯度下降）：

• w：权重
• η：学习率
• ∇L：损失Loss对w的梯度

SGD + Momentum（动量 SGD）

累积之前的梯度方向，像小球下坡一样积累速度，减少震荡，加速收敛。

式：

1.先更新速度

2.再用速度去更新权重

• γ：动量系数（一般 0.9）
• v：速度（梯度累积）

动量 SGD 在 SGD 基础上引入速度项，累积历史梯度方向，形成惯性，减少梯度震荡，加速收敛，更容易冲出局部最优。

五.训练流程

1.配置与初始化

• 设备指定：将模型迁移到 GPU（如果有）或 CPU 上运行。
• 监控指标：初始化列表plt_train_loss用于记录训练损失，初始化列表plt_val_loss用于记录验证损失，min_val_loss初始化一个很大的值，用于后续保存最优模型。

def train_val(model,train_loader,val_loader,lr,optimizer,device,epochs,save_file): #传入模型，训练数据，验证数据，学习率，优化器，设备，轮次,保存路径 model=model.to(device) #把模型放入设备上 plt_train_loss=[] #记录训练过程中的loss，初始为空列表 plt_val_loss=[] #记录验证过程中的loss，初始为空列表 min_val_loss=9999999999.9 #初始化最小val_loss值

2.训练轮次循环（Epoch）

• 代码执行epochs次完整的数据集遍历。

3.训练阶段（Train Phase）

• 模式切换：model.train()启用训练模式，启用 Dropout、BatchNorm 等训练特有层。
• 批量迭代：遍历train_loader，逐个 Batch 计算：
• 前向传播：model(x)得到预测值y_pred。
• 计算损失：对比y_pred与真实标签y。
• 反向传播：backward()计算梯度。
• 参数更新：optimizer.step()更新参数。
• 损失统计：计算一个 Epoch 内的平均损失并记录。

for epoch in range(epochs): #发枪指令，冲锋的号角，模型训练的开始 #训练过程 model.train() #模型转换成train模式 start_time=time.time() train_loss=0.0 #浮点形式 for x,y in train_loader: #从训练集中读取数据x，y x,y=x.to(device),y.to(device) #将数据放入设备上 y_pred=model(x) #x通过模型得到预测值 bat_loss=loss(y_pred,y) #预测值和真实值求这一批的loss，即bat_loss bat_loss.backward() #梯度回传 optimizer.step() #优化器进行工作 optimizer.zero_grad() #梯度清零 train_loss+=bat_loss.cpu().item() #计算该批次的loss mean_train_loss=train_loss/train_loader.__len__() #计算该批loss的平均值 plt_train_loss.append(mean_train_loss) #可视化

4.验证阶段（Val Phase）

• 模式切换：model.eval()启用验证模式，固定 Dropout、BatchNorm。
• 批量迭代：遍历 val_loader，逐个 Batch 计算：
• 前向传播：model(x)得到预测值y_pred。
• 计算损失：对比y_pred与真实标签y。
• 损失统计：计算一个 Epoch 内的平均损失并记录。

#验证过程 model.eval() # 模型转换成trval模式 val_loss = 0.0 # 浮点形式 with torch.no_grad(): #验证集要经过模型，但要求不计算梯度 for val_x, val_y in val_loader: # 从训练集中读取数据x，y val_x, val_y = val_x.to(device), val_y.to(device) # 将数据放入设备上 val_y_pred = model(val_x) # x通过模型得到预测值 val_bat_loss = loss(val_y_pred, val_y) # 预测值和真实值求loss val_loss += val_bat_loss.cpu().item() plt_val_loss.append(val_loss / val_loader.__len__())

5.模型保存

• min_val_loss是 “最优模型判定标准”：只有验证集损失最低的模型才会被保存，而非训练最后一轮的模型。
• 训练后期模型会对训练集过拟合（训练损失下降，但验证损失上升），保存 “验证损失最低” 的模型，本质是选择泛化能力最强的版本，这是工业界 / 科研中最常用的 “早停” 变体。

#保存。因为模型并非越训越好，因此要保存最好的模型 if val_loss < min_val_loss: min_val_loss=val_loss torch.save(model,save_file)

6.可视化

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()

7.调用函数运行

train_val(model,train_loader,val_loader,lr,optimizer,device,epochs,save_file)

六.训练结果如下