基于 PyTorch 的完整机器学习 pipeline，主要用于处理一个回归任务。代码涵盖了数据预处理、特征选择、模型定义、训练、验证、评估及结果保存的全过程。

1. 代码结构概览

代码主要分为以下几个部分：

  1. 导入库与环境设置：引入 PyTorch, NumPy, Pandas, Sklearn 等库。
  2. 特征选择函数 (get_feature_importance)：使用卡方检验筛选重要特征。
  3. 数据集类 (CovidDataset)：继承 torch.utils.data.Dataset，负责读取 CSV、划分训练/验证集、归一化。
  4. 模型类 (MyModel)：一个简单的多层感知机 (MLP)。
  5. 训练与验证函数 (train_val)：执行训练循环，计算 Loss，保存最佳模型。
  6. 评估函数 (evaluate)：加载模型，在测试集上预测并保存结果。
  7. 主执行逻辑：配置超参数，实例化对象，启动流程。

2. 模块详细分析

2.1 特征选择 (get_feature_importance)
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]                  # 返回选中列的特征和他们的下标。
  • 目的：利用 Sklearn 库进行特征选择（Feature Selection）。它试图从所有输入特征中筛选出与标签相关性最高的 k 个特征。
  • 逻辑：计算每个特征与标签的相关性得分，按得分降序排列，返回选中的特征数据和列索引。
  • 代码功能逻辑逐行解析：
代码行功能解析评价
model = SelectKBest(chi2, k=k)初始化特征选择器。使用 卡方检验 (Chi-Squared) 作为评分标准，保留 k 个最佳特征。高风险：chi2 仅适用于分类问题且要求特征非负。如果是回归任务，此处逻辑错误。
feature_data = np.array(..., dtype=np.float64)将特征数据强制转换为 float64 类型的 NumPy 数组。良好实践，确保 sklearn 兼容性。
X_new = model.fit_transform(...)核心步骤：在数据上拟合选择器，并立即转换数据（只保留选中的 k 列）。fit 计算分数，transform 截取列。
scores = model.scores_获取每个特征的评分（分数越高，特征越重要）。标准用法。
indices = np.argsort(scores)[::-1]对分数进行排序，获取索引。argsort 默认升序，[::-1] 反转实现降序。逻辑正确，但下方注释有误（见后文）。
k_best_features = [column[i+1] ...]根据排序后的索引，从原始列名列表中提取对应的特征名。脆弱：i+1 是硬编码偏移量，假设特征数据从原始 CSV 的第 2 列开始。
return X_new, indices[0:k]返回筛选后的特征矩阵和选中特征的原始索引。返回结构清晰。
2.2 数据集类 (CovidDataset)
class covidDataset(Dataset):
    def __init__(self, path, mode="train", feature_dim=5, all_feature=False):
        with open(path,'r') as f:
            csv_data = list(csv.reader(f))
            column = csv_data[0]
            x = np.array(csv_data)[1:,1:-1]
            y = np.array(csv_data)[1:,-1]
            if all_feature:
                col_indices = np.array([i for i in range(0,93)])                  # 若全选，则选中所有列。
            else:
                _, col_indices = get_feature_importance(x, y, feature_dim, column)      # 选重要的dim列。
                # X_new = get_feature_importance_with_pca(x, feature_dim, column)  # 选重要的特征
            col_indices = col_indices.tolist()             # col_indices 从array 转为列表。
            csv_data = np.array(csv_data[1:])[:,1:].astype(float)       #取csvdata从第二行开始， 第二列开始的数据，并转为float
            if mode == 'train':                                # 训练数据逢5选4， 记录他们的所在行
                indices = [i for i in range(len(csv_data)) if i % 5 != 0]
                self.y = torch.tensor(csv_data[indices,-1])      # 训练标签是csvdata的最后一列。 要转化为tensor型
            elif mode == 'val':               # 验证数据逢5选1， 记录他们的所在列
                indices = [i for i in range(len(csv_data)) if i % 5 == 0]
                # data = torch.tensor(csv_data[indices,col_indices])
                self.y = torch.tensor(csv_data[indices,-1])        # 验证标签是csvdata的最后一列。 要转化为tensor型
            else:
                indices = [i for i in range(len(csv_data))]     # 测试机只有数据
                # data = torch.tensor(csv_data[indices,col_indices])
            data = torch.tensor(csv_data[indices, :])           # 根据选中行取 X , 即模型的输入特征
            self.data = data[:, col_indices]                   #  col_indices 表示了重要的K列， 根据重要性， 选中k列。
            self.mode = mode                                   # 表示当前数据集的模式

            self.data = (self.data - self.data.mean(dim=0,keepdim=True)) / self.data.std(dim=0,keepdim=True)  # 对数据进行列归一化
            assert feature_dim == self.data.shape[1]                   # 判断数据的列数是否为规定的dim列， 要不然就报错。

            print('Finished reading the {} set of COVID19 Dataset ({} samples found, each dim = {})'
                  .format(mode, len(self.data), feature_dim))             # 打印读了多少数据

    def __getitem__(self, item):               # getitem 需要完成读下标为item的数据
        if self.mode == 'test':                  # 测试集没标签。   注意data要转为模型需要的float32型
            return self.data[item].float()
        else :                                  # 否则要返回带标签数据
            return self.data[item].float(), self.y[item].float()
    def __len__(self):
        return len(self.data)                 # 返回数据长度。

1.2 __getitem__ 和 __len____

getitem__：根据索引返回数据。如果是测试集，只返回特征；否则返回特征和标签。数据被强制转为 float (默认为 float32)。

__len__：返回样本数量。

  • 功能：加载数据，进行特征筛选，划分训练/验证集，并进行标准化处理。
  • 逻辑：
    • 数据读取：跳过表头，分离特征和标签。
    • 集划分：使用 i % 5 的方式。余数不为 0 的作为训练集，为 0 的作为验证集。这是一种确定性的划分，而非随机打散。
    • 归一化：(data - mean) / std。

  •  代码功能逻辑拆解

    1.1 __init__ 初始化方法

    这是最核心的部分，执行了以下流程：

  • 读取 CSV：使用 csv.reader 读取文件，保留表头 column。

  • 提取临时数据用于特征选择：

    • x = ... [1:, 1:-1]：跳过表头、跳过 ID 列（第 1 列）、跳过标签列（最后 1 列）。

    • y = ... [1:, -1]：提取标签。

  • 特征选择：

    • 如果 all_feature=False，调用 get_feature_importance 筛选出 feature_dim 个重要特征的索引 col_indices。

  • 数据清洗与类型转换：

    • csv_data = ... [1:, 1:].astype(float)：再次读取数据（去掉表头和 ID 列），转为 float。

  • 数据集划分 (Train/Val/Test)：

    • 通过 i % 5 取模的方式确定性划分。

    • train: 余数不为 0 (80%)。

    • val: 余数为 0 (20%)。

    • test: 全部数据。

  • 特征列筛选：self.data = data[:, col_indices]，只保留选中的特征列。

  • 归一化 (Normalization)：

    • self.data = (self.data - mean) / std：对当前实例的数据进行 Z-Score 标准化。

  • 断言检查：确保最终特征维度符合预期。

2.3 模型定义 (MyModel)
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.2 前向传播 (forward)

    def forward(self, x):
        x = self.fc1(x)       # 线性变换 1
        x = self.relu1(x)     # 非线性激活
        x = self.fc2(x)       # 线性变换 2 (输出)

        # 维度压缩处理
        if len(x.size()) > 1:
            return x.squeeze(1)
        return x

2. 模型架构分析

组件

配置

作用

评价

输入层

inDim

接收特征向量

灵活，适配特征选择后的维度。

隐藏层

64 单元

提取非线性特征

对于表格数据通常够用，但固定值缺乏灵活性。

激活函数

ReLU

引入非线性

标准选择，计算快，解决梯度消失。但存在“神经元死亡”风险。

输出层

1 单元 (Linear)

输出预测值

无激活函数，适合回归。如果是分类（0-1 概率），这里应该加 Sigmoid。

正则化

无 (模型内)

防止过拟合

模型内部没有 Dropout 或 BatchNorm。正则化依赖外部 Loss 函数（之前的 L2）。

  • 功能：一个简单的全连接神经网络。是一个简单的多层感知机（MLP），专门用于解决回归任务
  • 结构：输入层 -> 隐藏层 (64 神经元，ReLU 激活) -> 输出层 (1 神经元)。

  • 1.码结构逐行解析

    1.1 类定义与初始化 (__init__)

    class MyModel(nn.Module):
    def __init__(self, inDim):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(inDim, 64)   # 输入层 -> 隐藏层 (64 神经元)
        self.relu1 = nn.ReLU()            # 激活函数
        self.fc2 = nn.Linear(64, 1)       # 隐藏层 -> 输出层 (1 神经元)

  • 继承：继承 nn.Module，这是 PyTorch 定义模型的标准方式。

  • 输入维度 (inDim)：动态传入。这与之前的 CovidDataset 中的 feature_dim（6 或 93）对应，使模型具有通用性。

  • 隐藏层：固定为 64 个神经元。这是一个超参数，决定了模型的容量。

  • 输出层：固定为 1 个神经元。关键点：输出层没有加激活函数（如 Sigmoid 或 Softmax），这意味着输出范围是 (−∞,+∞) 。这符合回归任务的要求（预测连续值）。

  • 数据流：Input -> Linear -> ReLU -> Linear -> Output。

  • 维度处理 (squeeze)：

    • PyTorch 的 Linear 层输出形状通常是 (batch_size, output_features)。这里 output_features=1，所以输出是 (N, 1)。

    • PyTorch 的 MSELoss 通常期望目标值形状为 (N,) 或 (N, 1)。为了保险起见，代码尝试将 (N, 1) 压缩为 (N,)。

    • 逻辑判断：if len(x.size()) > 1 检查维度数量。如果是 2D 张量（有 batch 维），则 squeeze(1) 去掉第 2 维；如果是 1D 张量（单样本），则直接返回。

2.4 训练循环 (train_val)
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()
  • 功能：标准的 Epoch 循环，包含前向传播、反向传播、优化器步进。
  • 逻辑：
    • 记录 Train 和 Val 的 Loss。
    • 如果 Val Loss 降低，保存模型。
    • 使用 Matplotlib 绘制 Loss 变化。
  • 代码逻辑流程解析：
    • 设备迁移：将模型移动到指定设备（CPU 或 CUDA）。
    • 初始化：准备记录训练/验证 Loss 的列表，设置最小验证 Loss 初始值为无穷大。
    • Epoch 循环：遍历指定的训练轮数。
      • 计时：记录每个 Epoch 的开始时间。
      • 训练阶段 (model.train())：
        • 遍历训练集 DataLoader。
        • 数据上设备，前向传播，计算 Loss（包含正则化）。
        • 反向传播 (backward)，更新参数 (step)，清零梯度 (zero_grad)。
        • 累加训练 Loss。
      • 验证阶段 (model.eval())：
        • 关闭梯度计算 (torch.no_grad()) 以节省内存和加速。
        • 遍历验证集，计算 Loss 并累加。
      • 模型保存：如果当前 Epoch 的验证 Loss 总和小于历史最小值，保存模型。
      • 日志打印：输出当前 Epoch 编号、耗时、平均训练 Loss 和平均验证 Loss。
    • 可视化：训练结束后，使用 matplotlib 绘制 Loss 变化曲线。

2.5 评估函数 (evaluate)
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)
  • 功能：加载模型，对测试集进行推理，将结果保存为 CSV。
  • 代码逻辑功能解析：
    代码行功能解析评价
    def evaluate(sava_path, ...)函数定义。参数 sava_path 拼写错误（应为 save_path）。命名不规范。
    model = torch.load(sava_path).to(device)加载整个模型对象并移动到设备。与训练代码的 torch.save(model) 对应，但不推荐（应保存 state_dict）。
    with torch.no_grad():关闭梯度计算。正确，推理阶段不需要梯度，节省内存。
    for x in test_loader:遍历测试数据加载器。依赖 test_loader 的返回格式。
    pred = model(x.to(device))模型前向传播。正确。x 再次 .to(device) 是安全的（如果 DataLoader 未自动迁移）。
    rel.append(pred.cpu().item())提取预测值并转为 Python 数字。高风险：.item() 仅适用于单元素张量。如果 batch_size > 1 会报错。
    csvWriter.writerow(["id","tested_positive"])写入 CSV 表头。符合常见竞赛/提交格式。
    for i, value in enumerate(rel):遍历结果，生成 ID。逻辑隐患：ID 使用循环索引 i，忽略了原始数据的真实 ID。
    csvWriter.writerow([str(i), str(value)])写入每一行结果。效率较低（逐行写入），但功能可行。

2.6 损失函数与主逻辑
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             # 返回损失。
  • 功能：自定义损失函数，在均方误差 (MSE) 基础上增加了 L2 正则化项（权重衰减），用于防止过拟合。
  • 主逻辑：
    • 配置了 feature_dim (6 或 93)。
    • 使用 SGD 优化器。
    • 设备自动选择 CUDA 或 CPU。

      • 1.代码功能逻辑解析

        代码行

        功能解析

        评价

        def mseLoss_with_reg(pred, target, model):

        函数定义，接收预测值、真实值和模型对象。

        签名清晰，但需确保训练循环中传入的 loss 函数与此一致。

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

        实例化 MSE 损失计算对象。

        低效：每次调用函数都重新创建对象，浪费资源。应在全局或类外初始化。

        regularization_loss = 0

        初始化正则化损失累加器。

        标准做法。

        for param in model.parameters():

        遍历模型的所有可学习参数（权重 weights 和偏置 biases）。

        这是手动实现正则化的核心步骤。

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

        计算参数的平方和（L2 范数的平方）。

        数学上正确。注意这里包含了偏置项（bias）。

        return loss(pred, target) + 0.00075 * regularization_loss

        返回总损失 = 数据损失 + 正则化系数 × 正则化损失。

        逻辑正确。0.00075 是正则化强度超参数（lambda）。

        2. 核心机制分析

        2.1 L2 正则化 (Weight Decay)

      • 原理：通过在 Loss 中增加参数的平方和项，迫使模型在优化过程中倾向于选择较小的权重值。

      • 作用：限制模型复杂度，平滑决策边界，有效防止过拟合。

      • 实现方式：

        • 手动实现（当前代码）：在 Loss 函数中显式计算并相加。

        • 优化器实现（推荐）：在 optim.SGD 或 optim.Adam 中设置 weight_decay 参数。PyTorch 会自动在反向传播时将正则化梯度加到参数梯度上。

      • 由于 regularization_loss 是由 model.parameters() 中的张量计算得出的，它属于计算图的一部分。

      • 当调用 train_bat_loss.backward() 时，梯度会自动通过 param ** 2 回传，实现权重的衰减更新。

3、总代码：

import matplotlib.pyplot as plt
import torch
import numpy as np
import csv
import pandas as pd
from torch.utils.data import DataLoader, Dataset
import torch.nn as nn
from torch import optim
import time
from sklearn.feature_selection import SelectKBest, chi2
import os
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"


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]                  # 返回选中列的特征和他们的下标。

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)




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


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



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)


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"
}

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"])

# 深度学习 # 回归 # 人工智能
Logo
DAMO开发者矩阵

DAMO开发者矩阵，由阿里巴巴达摩院和中国互联网协会联合发起，致力于探讨最前沿的技术趋势与应用成果，搭建高质量的交流与分享平台，推动技术创新与产业应用链接，围绕“人工智能与新型计算”构建开放共享的开发者生态。

更多推荐

2026 机器人工程实例（四）：让 G1 / T800 在 MuJoCo 中真正走起来——预训练步态、定点行走与受控停止

本文基于 MuJoCo、Python 及上游预训练步态，构建一套支持 Unitree G1 与 EngineAI T800 的独立人形机器人运动控制与验证工程。系统将目标点或手动速度指令转换为策略观测，通过 PyTorch/MNN 推理获得关节动作，再使用 PD 力矩和物理接触完成前进、转向、侧移、定点行走与动态位置保持。项目同时实现独立手动控制面板、输入超时、平滑减速、受控取消、有限推力、跌倒检

avatar DAMO开发者矩阵

【工作流】企业微信机器人 + AirScript：实现 WPS 文档实时问答

通过企业微信机器人工作流结合AirScript实时读取表格数据，再由大模型分析回答。员工@机器人即可查询售后单状态，无需打开WPS或迁移系统。架构为：WPS存数据，AirScript读数据，工作流调度，AI生成回答。

avatar DAMO开发者矩阵
cover

企业微信PC协议开发AI数字员工：突破官方API限制，实现全智能私域自动化

avatar DAMO开发者矩阵