回归任务实战

1、导库

import matplotlib.pyplot as plt #用于绘图
import torch    #导入PyTorch深度学习框架
import numpy as np #导入numpy模块，用于数值计算
import csv #导入csv模块，用于读取和写入csv文件
import pandas as pd #导入pandas模块，用于数据处理
from torch.utils.data import DataLoader, Dataset#从 torch.utils.data 中导入 DataLoader 和        
                                                      #Dataset，用于定义数据集和数据加载器。
import torch.nn as nn #导入 PyTorch 的神经网络模块
from torch import optim #导入 PyTorch 的优化器模块
import time #导入 time 模块，用于记录时间
from sklearn.feature_selection import SelectKBest, chi2 #从 sklearn.feature_selection 中导入 
                                                          #SelectKBest 和 chi2，用于特征选择

import os 
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
#设置环境变量，解决 Intel MKL 库的重复加载问题
#"KMP_DUPLICATE_LIB_OK"：环境变量名称
#"TRUE"：环境变量的值，表示允许重复加载库

2、编写特征选择函数

def get_feature_importance(feature_data, label_data, k =4,column = None):
    """
    此处省略 feature_data, label_data 的生成代码。
    如果是 CSV 文件，可通过 read_csv() 函数获得特征和标签。
    这个函数的目的是， 找到所有的特征种， 比较有用的k个特征， 并打印这些列的名字。
    """
    model = SelectKBest(chi2, k=k)      #定义一个选择k个最佳特征的函数
    feature_data = np.array(feature_data, dtype=np.float64)
    # label_data = np.array(label_data, dtype=np.float64)
    X_new = model.fit_transform(feature_data, label_data)   #用这个函数选择k个最佳特征
    #feature_data是特征数据，label_data是标签数据，该函数可以选择出k个特征
    print('x_new', X_new)
    scores = model.scores_                # scores即每一列与结果的相关性
    # 按重要性排序，选出最重要的 k 个
    indices = np.argsort(scores)[::-1]        #[::-1]表示反转一个列表或者矩阵。
    # argsort这个函数， 可以矩阵排序后的下标。 比如 indices[0]表示的是，scores中最小值的下标。

    if column:                            # 如果需要打印选中的列
        k_best_features = [column[i+1] for i in indices[0:k].tolist()]         # 选中这些列 打印
        print('k best features are: ',k_best_features)
    return X_new, indices[0:k]                  # 返回选中列的特征和他们的下标。

1、 def get_feature_importance(feature_data, label_data, k =4,column = None):

功能：定义一个函数，用于选择最重要的 k 个特征。
参数：
feature_data：特征数据，二维数组或矩阵。
label_data：标签数据，一维数组。
k：选择的特征数量，默认为 4。
column：特征的列名，默认为 None。

2、 model = SelectKBest(chi2, k=k)

功能：创建一个 SelectKBest 对象，使用卡方检验（chi2）作为特征选择的评分函数。
参数：
- chi2：评分函数，用于评估特征与标签之间的相关性。
- k：选择的特征数量。

3、 feature_data = np.array(feature_data, dtype=np.float64)

功能：将特征数据转换为 numpy 数组，并指定数据类型为 float64。
参数：
- feature_data：输入的特征数据。
- dtype：数据类型，np.float64 表示 64 位浮点数。

4、 X_new = model.fit_transform(feature_data, label_data)

功能：使用 fit_transform 方法拟合模型并选择 k 个最佳特征。
参数：
- feature_data：特征数据。
- label_data：标签数据。

5、 scores = model.scores_

功能：获取每个特征的评分值

6、 indices = np.argsort(scores)[::-1]

功能：对评分值进行排序，并返回索引。[::-1] 表示降序排列。
参数：
- scores：评分值数组。

7、 if column:
k_best_features = [column[i+1] for i in indices[0:k].tolist()]
print('k best features are: ', k_best_features)

功能：如果提供了列名，打印出最重要的 k 个特征的名称。
参数：
- column：特征的列名。
- indices：排序后的索引数组。
- k：选择的特征数量。

8、 return X_new, indices[0:k]

功能：返回选择后的特征数据和这些特征的索引。
参数：
- X_new：选择后的特征数据。
- indices[0:k]：最重要的 k 个特征的索引。

3、编写数据集类

class CovidDataset(Dataset):
    def __init__(self, file_path, mode="train", all_feature=False, feature_dim=6):
        with open(file_path, "r") as f:
            ori_data = list(csv.reader(f))
            column = ori_data[0]
            csv_data = np.array(ori_data[1:])[:, 1:].astype(float)
        feature = np.array(ori_data[1:])[:, 1:-1]
        label_data = np.array(ori_data[1:])[:, -1]
        if all_feature:
            col = np.array([i for i in range(0, 93)])
        else:
            _, col = get_feature_importance(feature, label_data, feature_dim, column)
        col = col.tolist()
        if mode == "train":        #逢5取1.
            indices = [i for i in range(len(csv_data)) if i % 5 != 0]
            data = torch.tensor(csv_data[indices, :-1])
            self.y = torch.tensor(csv_data[indices, -1])
        elif mode == "val":
            indices = [i for i in range(len(csv_data)) if i % 5 == 0]
            data = torch.tensor(csv_data[indices, :-1])
            self.y = torch.tensor(csv_data[indices, -1])
        else:
            indices = [i for i in range(len(csv_data))]
            data = torch.tensor(csv_data[indices])
        data = data[:, col]
        self.data = (data- data.mean(dim=0, keepdim=True))/data.std(dim=0, keepdim=True)
        self.mode = mode
    def __getitem__(self, idx):
        if self.mode != "test":
            return self.data[idx].float(),  self.y[idx].float()
        else:
            return self.data[idx].float()

    def __len__(self):
        return len(self.data)

1、class CovidDataset(Dataset):

功能：定义一个自定义数据集类，继承自 Dataset。

2、 def __init__(self, file_path, mode="train", all_feature=False, feature_dim=6):

功能：初始化数据集类。
参数：
- file_path：CSV 文件路径。
- mode：数据集模式，可以是 "train"、"val" 或 "test"，默认为 "train"。
- all_feature：是否使用所有特征，默认为 False。
- feature_dim：选择的特征数量，默认为 6。

3、 with open(file_path, "r") as f:
        ori_data = list(csv.reader(f))
        column = ori_data[0]
          csv_data = np.array(ori_data[1:])[:, 1:].astype(float)

功能：读取 CSV 文件，并将数据转换为 numpy 数组。
参数：
- file_path：CSV 文件路径。
- "r"：以只读模式打开文件。
- csv.reader(f)：读取 CSV 文件内容。
- ori_data：原始数据，包括表头和数据行。
- column：表头，即特征名称。
- csv_data：数据部分，排除表头，并转换为浮点数类型。

4、 feature = np.array(ori_data[1:])[:, 1:-1]
label_data = np.array(ori_data[1:])[:, -1]

功能：提取特征和标签数据。
参数：
- ori_data[1:]：从第二行开始的数据行。
- [:, 1:-1]：提取从第二列到倒数第二列的数据作为特征。
- [:, -1]：提取最后一列的数据作为标签。

5、 if all_feature:
col = np.array([i for i in range(0, 93)])
else:
_, col = get_feature_importance(feature, label_data, feature_dim, column)

功能：根据 all_feature 参数决定是否选择所有特征，否则调用 get_feature_importance 选择重要特征。
参数：
- all_feature：是否使用所有特征。
- feature：特征数据。
- label_data：标签数据。
- feature_dim：选择的特征数量。
- column：特征的列名。

6、 col = col.tolist()

功能：将特征索引数组转换为列表。
参数：
- col：特征索引数组。

7、 if mode == "train":
          indices = [i for i in range(len(csv_data)) if i % 5 != 0]
        data = torch.tensor(csv_data[indices, :-1])
        self.y = torch.tensor(csv_data[indices, -1])

功能：如果模式为训练模式，选择 80% 的数据作为训练集。
参数：
- mode：数据集模式。
- len(csv_data)：数据行数。
- i % 5 != 0：选择索引不是 5 的倍数的行。
- csv_data[indices, :-1]：提取训练集的特征数据。
- csv_data[indices, -1]：提取训练集的标签数据。
- torch.tensor()：将数据转换为 PyTorch 张量。

8、 elif mode == "val":
          indices = [i for i in range(len(csv_data)) if i % 5 == 0]
        data = torch.tensor(csv_data[indices, :-1])
        self.y = torch.tensor(csv_data[indices, -1])

功能：如果模式为验证模式，选择 20% 的数据作为验证集。
参数：
- mode：数据集模式。
- len(csv_data)：数据行数。
- i % 5 == 0：选择索引是 5 的倍数的行。
- csv_data[indices, :-1]：提取验证集的特征数据。
- csv_data[indices, -1]：提取验证集的标签数据。
- torch.tensor()：将数据转换为 PyTorch 张量。

9、 else:
indices = [i for i in range(len(csv_data))]
data = torch.tensor(csv_data[indices])

功能：如果模式为测试模式，选择所有数据作为测试集。
参数：
- mode：数据集模式。
- len(csv_data)：数据行数。
- csv_data[indices]：提取测试集的特征数据。
- torch.tensor()：将数据转换为 PyTorch 张量。

10、 data = data[:, col]

功能：根据特征索引选择特定的特征列。
参数：
- data：数据张量。
- col：特征索引列表。

11、 self.data = (data - data.mean(dim=0, keepdim=True)) / data.std(dim=0, keepdim=True)

功能：对数据进行标准化处理（减去均值，除以标准差）。
参数：
- data：数据张量。
- dim=0：沿列方向计算均值和标准差。
- keepdim=True：保持维度不变。

12、 self.mode = mode

参数：
- mode：数据集模式。

13、 def __getitem__(self, idx):
        if self.mode != "test":
          return self.data[idx].float(), self.y[idx].float()
        else:
          return self.data[idx].float()

功能：定义如何获取单个样本数据。
参数：
- idx：样本索引。
- self.data[idx]：根据索引获取特征数据。
- self.y[idx]：根据索引获取标签数据。
- .float()：将数据转换为浮点数类型。

14、 def __len__(self):
return len(self.data)

功能：定义数据集的大小。
参数：
- self.data：数据张量。

4、编写神经网络模型

class MyModel(nn.Module):
    def __init__(self, inDim):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(inDim, 64)
        self.relu1 = nn.ReLU()
        self.fc2 = nn.Linear(64, 1)

    def forward(self, x):      #模型前向过程
        x = self.fc1(x)
        x = self.relu1(x)
        x = self.fc2(x)

        if len(x.size()) > 1:
            return x.squeeze(1)

        return x

1、class MyModel(nn.Module):

功能：定义一个神经网络模型类，继承自 nn.Module。

2、 def __init__(self, inDim):
super(MyModel, self).__init__()

功能：初始化模型类。
参数：
- inDim：输入特征的维度

3、 self.fc1 = nn.Linear(inDim, 64)

功能：定义第一个全连接层，输入维度为 inDim，输出维度为 64。
参数：
- inDim：输入特征的维度。
- 64：输出特征的维度。

4、 self.relu1 = nn.ReLU()

功能：定义 ReLU 激活函数。

5、 self.fc2 = nn.Linear(64, 1)

功能：定义第二个全连接层，输入维度为 64，输出维度为 1。
参数：
- 64：输入特征的维度。
- 1：输出特征的维度。

7、 def forward(self, x):

功能：定义模型的前向传播过程。
参数：
- x：输入数据。

8、 x = self.fc1(x)

功能：将输入数据通过第一个全连接层。
参数：
- x：输入数据。

9、 x = self.relu1(x)

功能：对第一个全连接层的输出应用 ReLU 激活函数。
参数：
- x：第一个全连接层的输出

10、 x = self.fc2(x)

功能：将 ReLU 激活后的数据通过第二个全连接层。
参数：
- x：ReLU 激活后的数据。

11、 if len(x.size()) > 1:
return x.squeeze(1)
return x

功能：如果输出是二维张量，使用 squeeze 去掉多余的维度。
参数：
- x：第二个全连接层的输出。
- .squeeze(1)：去掉第二个维度。

5、编写训练与验证函数

def train_val(model, train_loader, val_loader, device, epochs, optimizer, loss, save_path):
    model = model.to(device)

    plt_train_loss = [] #记录所有轮次的loss
    plt_val_loss = []

    min_val_loss = 9999999999999

    for epoch in range(epochs):   #冲锋的号角
        train_loss = 0.0
        val_loss = 0.0
        start_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,model)
            train_bat_loss.backward()
            optimizer.step() #更新模型的作用
            optimizer.zero_grad()
            train_loss += train_bat_loss.cpu().item()
        plt_train_loss.append(train_loss / train_loader.__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,model)
                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_loss

        print("[%03d/%03d] %2.2f sec(s) Trainloss: %.6f |Valloss: %.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()

1、def train_val(model, train_loader, val_loader, device, epochs, optimizer, loss, save_path):

功能：定义训练和验证函数。
参数：
- model：神经网络模型。
- train_loader：训练数据加载器。
- val_loader：验证数据加载器。
- device：设备（cuda 或 cpu）。
- epochs：训练轮数。
- optimizer：优化器。
- loss：损失函数。
- save_path：模型保存路径。

2、 model = model.to(device)

功能：将模型移动到指定设备（GPU 或 CPU）。
参数：
- device：设备（cuda 或 cpu）。

3、 plt_train_loss = []
plt_val_loss = []

功能：初始化训练和验证损失列表，用于记录每个 epoch 的损失。

4、 min_val_loss = 9999999999999

功能：初始化最小验证损失，用于保存最佳模型。

5、 for epoch in range(epochs):

功能：开始训练循环，遍历每个 epoch。
参数：
- epochs：训练轮数。

6、 train_loss = 0.0
val_loss = 0.0
start_time = time.time()

功能：初始化训练和验证损失，记录开始时间。

7、 model.train()

功能：将模型设置为训练模式。

8、 for batch_x, batch_y in train_loader:

功能：遍历训练数据加载器，获取每个批次的数据。
参数：
- train_loader：训练数据加载器。

9、 x, target = batch_x.to(device), batch_y.to(device)

功能：将数据移动到指定设备（GPU 或 CPU）。
参数：
- device：设备（cuda 或 cpu）。

10、 pred = model(x)

功能：进行前向传播，获取模型预测值。
参数：
- x：输入数据。

11、 train_bat_loss = loss(pred, target, model)

功能：计算训练批次的损失。
参数：
- pred：模型预测值。
- target：真实标签值。
- model：神经网络模型。

12、 train_bat_loss.backward()

功能：进行反向传播，计算梯度。

13、 optimizer.step()

功能：更新模型参数。

14、 optimizer.zero_grad()

功能：清空梯度。

15、 train_loss += train_bat_loss.cpu().item()

功能：累加训练损失。
参数：
- .cpu()：将数据移动到 CPU。
- .item()：获取标量值。

16、 plt_train_loss.append(train_loss / train_loader.__len__())

功能：计算平均训练损失，并记录到列表中。
参数：
- train_loader.__len__()：训练数据加载器的批次数量。

17、 model.eval()

功能：将模型设置为评估模式。

18、 with torch.no_grad():
for batch_x, batch_y in val_loader:

功能：遍历验证数据加载器，获取每个批次的数据，并禁用梯度计算。
参数：
- val_loader：验证数据加载器。

19、 x, target = batch_x.to(device), batch_y.to(device)

功能：将数据移动到指定设备（GPU 或 CPU）。
参数：
- device：设备（cuda 或 cpu）。

20、 pred = model(x)

功能：进行前向传播，获取模型预测值。
参数：
- x：输入数据。

21、 val_bat_loss = loss(pred, target, model)

功能：计算验证批次的损失。
参数：
- pred：模型预测值。
- target：真实标签值。
- model：神经网络模型。

22、 val_loss += val_bat_loss.cpu().item()

功能：累加验证损失。
参数：
- .cpu()：将数据移动到 CPU。
- .item()：获取标量值。

23、 plt_val_loss.append(val_loss / val_loader.__len__())

功能：计算平均验证损失，并记录到列表中。
参数：
- val_loader.__len__()：验证数据加载器的批次数量。

24、 if val_loss < min_val_loss:
torch.save(model, save_path)
min_val_loss = val_loss

功能：如果当前验证损失是最低的，保存模型。
参数：
- save_path：模型保存路径。

25、 print("[%03d/%03d] %2.2f sec(s) Trainloss: %.6f |Valloss: %.6f" % \
(epoch, epochs, time.time() - start_time, plt_train_loss[-1], plt_val_loss[-1]))

功能：打印当前 epoch 的训练和验证损失。
参数：
- epoch：当前 epoch。
- epochs：总 epoch 数。
- time.time() - start_time：当前 epoch 所需时间。
- plt_train_loss[-1]：当前 epoch 的平均训练损失。
- plt_val_loss[-1]：当前 epoch 的平均验证损失。

26、 plt.plot(plt_train_loss)
          plt.plot(plt_val_loss)
          plt.title("loss")
          plt.legend(["train", "val"])
          plt.show()

功能：绘制训练和验证损失曲线。
参数：
- plt_train_loss：训练损失列表。
- plt_val_loss：验证损失列表。
- "loss"：图表标题。
- ["train", "val"]：图例标签。

6、编写评估函数

def evaluate(sava_path, test_loader,device,rel_path ):   #得出测试结果文件
    model = torch.load(sava_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:
        csvWriter = csv.writer(f)
        csvWriter.writerow(["id","tested_positive"])
        for i, value in enumerate(rel):
            csvWriter.writerow([str(i), str(value)])
    print("文件已经保存到"+rel_path)

1、def evaluate(save_path, test_loader, device, rel_path):

功能：定义评估函数，对测试集进行预测。
参数：
- save_path：模型保存路径。
- test_loader：测试数据加载器。
- device：设备（cuda 或 cpu）。
- rel_path：预测结果保存路径。

2、 model = torch.load(save_path).to(device)

功能：加载保存的模型，并移动到指定设备。
参数：
- save_path：模型保存路径。
- device：设备（cuda 或 cpu）。

3、 rel = []

功能：初始化预测结果列表。

4、 with torch.no_grad():
for x in test_loader:

功能：遍历测试数据加载器，禁用梯度计算。
参数：
- test_loader：测试数据加载器。

5、 pred = model(x.to(device))

功能：进行前向传播，获取模型预测值。
参数：
- x：输入数据。

6、 rel.append(pred.cpu().item())

功能：将预测值添加到结果列表中。
参数：
- .cpu()：将数据移动到 CPU。
- .item()：获取标量值。

7、 print(rel)

功能：打印预测结果。

8、 with open(rel_path, "w", newline='') as f:

功能：打开文件以写入预测结果。
参数：
- rel_path：预测结果保存路径。
- "w"：写入模式。
- newline=''：防止在 Windows 系统上写入多余的空行。

9、 csvWriter = csv.writer(f)
csvWriter.writerow(["id", "tested_positive"])

功能：创建 CSV 写入器，并写入表头。
参数：
- f：文件对象。
- ["id", "tested_positive"]：表头内容。

10、 for i, value in enumerate(rel):
csvWriter.writerow([str(i), str(value)])

功能：遍历预测结果，写入每一行。
参数：
- i：样本索引。
- value：预测值。

11、 print("文件已经保存到" + rel_path)

功能：打印文件保存路径。
参数：
- rel_path：预测结果保存路径。

7、数据集实例化和数据加载器

all_feature = False
if all_feature:
    feature_dim = 93
else:
    feature_dim = 6

train_file = "covid.train.csv"
test_file = "covid.test.csv"

train_dataset = CovidDataset(train_file, "train",all_feature=all_feature, feature_dim=feature_dim)
val_dataset = CovidDataset(train_file, "val",all_feature=all_feature, feature_dim=feature_dim)
test_dataset = CovidDataset(test_file, "test",all_feature=all_feature, feature_dim=feature_dim)

batch_size = 16
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False)
# for batch_x, batch_y in train_loader:
#     print(batch_x, batch_y)

#
# predy = model(batch_x)

#
# file = pd.read_csv(train_file)
# print(file.head())


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

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

1、all_feature = False
      if all_feature:
        feature_dim = 93
else:
          feature_dim = 6

功能：根据是否使用所有特征，设置特征维度。
参数：
- all_feature：是否使用所有特征。
- feature_dim：特征维度。

2、train_file = "covid.train.csv"
test_file = "covid.test.csv"

功能：定义训练集和测试集的文件路径。

3、 train_dataset = CovidDataset(train_file, "train", all_feature=all_feature,          feature_dim=feature_dim)
val_dataset = CovidDataset(train_file, "val", all_feature=all_feature,    feature_dim=feature_dim)
test_dataset = CovidDataset(test_file, "test", all_feature=all_feature,          feature_dim=feature_dim)

功能：创建训练集、验证集和测试集实例。
参数：
- train_file：训练集文件路径。
- "train"：训练模式。
- all_feature：是否使用所有特征。
- feature_dim：特征维度。
- test_file：测试集文件路径。
- "test"：测试模式。

4、batch_size = 16

功能：设置批量大小。

5、train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=True)
test_loader = DataLoader(test_dataset, batch_size=1, shuffle=False)

功能：创建数据加载器。
参数：
- train_dataset：训练集实例。
- batch_size：批量大小。
- shuffle：是否随机打乱数据。
- test_dataset：测试集实例。

8、模型训练和评估

def mseLoss_with_reg(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             # 返回损失。
model = MyModel(inDim=feature_dim).to(device)
loss = mseLoss_with_reg
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"], test_loader, device, config["rel_path"])

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

功能：检查是否有可用的 GPU，否则使用 CPU。

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

功能：定义配置参数。
参数：
- "lr"：学习率。
- "epochs"：训练轮数。
- "momentum"：动量。
- "save_path"：模型保存路径。
- "rel_path"：预测结果保存路径。

3、def mseLoss_with_reg(pred, target, model):

功能：定义带正则化的均方误差损失函数。
参数：
- pred：模型预测值。
- target：真实标签值。
- model：神经网络模型。

4、 loss = nn.MSELoss(reduction='mean')

功能：初始化均方误差损失函数。
参数：
- reduction='mean'：计算平均损失。

5、 regularization_loss = 0

功能：初始化正则化损失。

6、 for param in model.parameters():

功能：遍历模型的参数。
参数：
- model.parameters()：模型参数。

7、 regularization_loss += torch.sum(param ** 2)

功能：计算 L2 正则化损失。
参数：
- param ** 2：参数的平方。

8、 return loss(pred, target) + 0.00075 * regularization_loss

功能：返回总损失，包括均方误差损失和正则化损失。
参数：
- loss(pred, target)：均方误差损失。
- 0.00075 * regularization_loss：正则化损失。

9、model = MyModel(inDim=feature_dim).to(device)

功能：创建模型实例，并移动到指定设备。
参数：
- inDim=feature_dim：输入特征维度。
- device：设备（cuda 或 cpu）。

10、loss = mseLoss_with_reg

功能：设置损失函数为带正则化的均方误差损失函数。

11、optimizer = optim.SGD(model.parameters(), lr=config["lr"], momentum=config["momentum"])

功能：初始化随机梯度下降优化器。
参数：
- model.parameters()：模型参数。
- lr=config["lr"]：学习率。
- momentum=config["momentum"]：动量。

12、train_val(model, train_loader, val_loader, device, config["epochs"], optimizer, loss, config["save_path"])

功能：调用训练和验证函数。
参数：
- model：神经网络模型。
- train_loader：训练数据加载器。
- val_loader：验证数据加载器。
- device：设备（cuda 或 cpu）。
- config["epochs"]：训练轮数。
- optimizer：优化器。
- loss：损失函数。
- config["save_path"]：模型保存路径。

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

功能：调用评估函数，对测试集进行预测。
参数：
- config["save_path"]：模型保存路径。
- test_loader：测试数据加载器。
- device：设备（cuda 或 cpu）。
- config["rel_path"]：预测结果保存路径。

9、总结

整章代码实现了一个完整的机器学习流程，包括数据预处理、特征选择、模型定义、训练与验证、评估和结果保存。适合用于处理 COVID 数据集或其他类似的回归任务。