深度学习-回归实战-新冠预测

神经网络

x 为feature已知量

其余量都是需要学习的参数

深度学习的训练过程

1.前向过程，计算loss，到最后一层，计算的loss对上一层w进行求偏导数，根据梯度下降算法更新w。

2.梯度回传过程，回传loss，继续更新上一层的w。

梯度：对每个参数求偏导。

事情不会这么简单

数据集

class CustomDataset(Dataset):
    def __init__(self, file_path, mode, dim=4, all_feature=False):
        # 在这里实现你的构造函数
        pass

    def __getitem__(self, item):
        # 在这里实现__getitem__方法
        pass

    def __len__(self):
        # 在这里实现__len__方法
        pass

数据集类结构，pass表示具体内容

class covidDataset(Dataset):
    def __init__(self, file_path, mode, dim=4, all_feature=False):
        with open(file_path, "r") as f:
            csv_data = list(csv.reader(f))
            data = np.array(csv_data[1:])              # 1: 第一行后面的，去掉第一行，第一行为标题，将数据转化为numpy
            if mode == "train":                      # 训练数据逢5选4， 记录他们的所在行
                indices = [i for i in range(len(data)) if i % 5 !=0]          #1，2，3，4， 6，7，8，9
            elif mode == "val":                           # 验证数据逢5选1， 记录他们的所在列
                indices = [i for i in range(len(data)) if i % 5 ==0]

            if all_feature:
                col_idx = [i for i in range(0,93)]       # 若全选，则选中所有列。
            else:
                _, col_idx = get_feature_importance(data[:,1:-1], data[:,-1], k=dim,column =csv_data[0][1:-1]) # 选重要的dim列。


            if mode == "test":
                x = data[:, 1:].astype(float)          #测试集没标签，取第二列开始的数据，并转为float
                x = torch.tensor(x[:, col_idx])              #  col_idx表示了选取的列，转为张量
            else:
                x = data[indices, 1:-1].astype(float)
                x = torch.tensor(x[:, col_idx])
                y = data[indices, -1].astype(float)      #训练接和验证集有标签，取最后一列的数据，并转为float
                self.y = torch.tensor(y)              #转为张量
            self.x = (x-x.mean(dim=0,keepdim=True))/x.std(dim=0,keepdim=True)        # 对数据进行列归一化 0正太分布
            self.mode = mode              # 表示当前数据集的模式
    def __getitem__(self, item):
        if self.mode == "test":
            return self.x[item].float()         # 测试集没标签。   注意data要转为模型需要的float32型
        else:                            # 否则要返回带标签数据
            return self.x[item].float(), self.y[item].float()
    def __len__(self):
        return len(self.x)             # 返回数据长度。

数据的csv文件中，每一行为一组数据，前面的列对应了x1,x2,x3,x4，最后一列为y。

数据处理：

处理行和列，行为一组数据，需要进行训练集与验证集的划分。

列为数据，需要转化为张量。

1.行处理

训练集与数据集：

mode，训练集与测试集。验证集为训练集中的一部分，如何得到验证集：5选1。训练集：5选4

            if mode == "train":                      # 训练数据逢5选4， 记录他们的所在行
                 indices = [i for i in range(len(data)) if i % 5 !=0]    

2.列处理

            if mode == "test":
                x = data[:, 1:].astype(float)          #测试集没标签，取第二列开始的数据，并转为float
                x = torch.tensor(x[:, col_idx])              #  col_idx表示了选取的列，转为张量

如果是测试集：需要去掉第一列（因为第一列为序号，无意义），并且将字符串形式的内容转化为float形式，并且转化为张量。

            if mode == "test":
                x = data[:, 1:].astype(float)          #测试集没标签，取第二列开始的数据，并转为float
                x = torch.tensor(x[:, col_idx])              #  col_idx表示了选取的列，转为张量
            else:
                x = data[indices, 1:-1].astype(float)
                x = torch.tensor(x[:, col_idx])
                y = data[indices, -1].astype(float)      #训练接和验证集有标签，取最后一列的数据，并转为float
                self.y = torch.tensor(y)              #转为张量
            self.x = (x-x.mean(dim=0,keepdim=True))/x.std(dim=0,keepdim=True)        # 对数据进行列归一化 0正太分布
            self.mode = mode              # 表示当前数据集的模式

如果是train与val集，需要取出x与y（标签，在最后一列，为新冠感染人数），而在test集中，无y，因为这个在test中是未知的。

模型

模型类的组成：1.定义与激活函数。2.定义forword令数据通过

class myNet(nn.Module):
    def __init__(self, inDim):
        super(myNet,self).__init__()
        self.fc1 = nn.Linear(inDim, 128)              # 全连接
        self.relu = nn.ReLU()                        # 激活函数 ,添加非线性
        # self.fc3 = nn.Linear(128, 128)
        self.fc2 = nn.Linear(128,1)                     # 全连接             设计模型架构。 他没有数据

    def forward(self, x):                     #forward， 即模型前向过程
        x = self.fc1(x)
        x = self.relu(x)
        # x = self.fc3(x)
        x = self.fc2(x)
        if len(x.size()) > 1:
            return x.squeeze(1)
        else:
            return x

定义部分关键：维度转化

mynet继承了nn.Module类

维度转化，将张量维度降低一维。将x降维的目的是与y保持一个维度。此处先查看了y的维度，再确定x的维度

超参数的设定

1.设备的选择cpu或gpu

2.训练的文件

3.定义训练集、验证集、测试集三个数据集

device = 'cuda' if torch.cuda.is_available() else 'cpu'       #选择使用cpu还是gpu计算。
print(device)
train_path = 'covid.train.csv'                     # 训练数据路径
test_path = 'covid.test.csv'              # 测试数据路径
file = pd.read_csv(train_path)
file. Head()  

config = {
    'n_epochs': 50,                # maximum number of epochs
    'batch_size': 32,               # mini-batch size for dataloader
    'optimizer': 'SGD',              # optimization algorithm (optimizer in torch.optim)
            # hyper-parameters for the optimizer (depends on which optimizer you are using)
    'lr': 0.0001,                 # learning rate of SGD
    'momentum': 0.9,             # momentum for SGD
    'early_stop': 200,               # early stopping epochs (the number epochs since your model's last improvement)
    'save_path': 'model_save/model.pth',  # your model will be saved here
}

model = myNet(feature_dim).to(device)                      # 实例化模型

optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)             # 定义优化器  动量
trainloader = DataLoader(trainset, batch_size=config['batch_size'], shuffle=True)
valloader = DataLoader(valset, batch_size=config['batch_size'], shuffle=True)  # 将数据装入loader 方便取一个batch的数据
      

`DataLoader` 是 PyTorch 中用于加载数据的工具。它可以对数据进行批次处理（batching）、打乱数据顺序（shuffling）和并行加载数据等操作，方便训练神经网络模型。

在你提供的代码中，`DataLoader` 被用于加载训练数据集 (`trainset`) 和验证数据集 (`valset`)。具体来说，它有以下作用：

1. **批次处理（Batching）：** `batch_size` 参数指定了每个批次中包含的样本数目。`DataLoader` 会将数据划分成大小为 `batch_size` 的小批次，便于模型对一批数据进行处理。

2. **数据打乱（Shuffling）：** `shuffle=True` 参数表示在每个 epoch 开始时是否打乱数据集的顺序。这有助于模型更好地学习，避免模型过度依赖于数据的顺序。

3. **并行加载数据（Parallel Loading）：** `DataLoader` 可以使用多个进程并行加载数据，加快数据加载的速度，特别是当数据集较大时。

在训练神经网络时，通常会使用 `DataLoader` 来迭代地获取数据批次，将其输入模型进行训练。这样的数据加载方式有助于提高训练效率和模型的泛化能力。

LOSS函数

loss =  nn.MSELoss()     

loss函数是定义好的，直接用就好

优化器

from torch import optim
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9) 
#momentum为动量

部分结语

以上的三个部分，所有部分完成，接下来导入进训练流程中即可。

训练流程

train_val(model, trainloader, valloader, optimizer, loss, config['n_epochs'], device,save_=config['save_path'])

1.模型model

2.训练集数据加载器trainloader

3.valloader

4.优化器optimzer

5.loss函数

6.config字典

7.device 设备cpu或gpu

8.保存路径

train_val的定义细节

def train_val(model, trainloader, valloader,optimizer, loss, epoch, device, save_):

    # trainloader = DataLoader(trainset,batch_size=batch,shuffle=True)
    # valloader = DataLoader(valset,batch_size=batch,shuffle=True)
    model = model.to(device)                # 模型和数据 ，要在一个设备上。  cpu - gpu
    plt_train_loss = []
    plt_val_loss = []
    val_rel = []
    min_val_loss = 100000                 # 记录训练验证loss 以及验证loss和结果

    for i in range(epoch):                 # 训练epoch 轮
        start_time = time.time()             # 记录开始时间
        model.train()                         # 模型设置为训练状态      结构
        train_loss = 0.0               
        val_loss = 0.0
        for data in trainloader:                     # 从训练集取一个batch的数据
            optimizer.zero_grad()                   # 梯度清0
            x, target = data[0].to(device), data[1].to(device)       # 将数据放到设备上
            pred = model(x)                          # 用模型预测数据
            bat_loss = loss(pred, target)       # 计算loss
            bat_loss.backward()                        # 梯度回传， 反向传播。
            optimizer.step()                            #用优化器更新模型。  轮到SGD出手了
            train_loss += bat_loss.detach().cpu().item()             #记录loss和

        plt_train_loss. append(train_loss/trainloader.dataset.__len__())   #记录loss到列表。注意是平均的loss ，因此要除以数据集长度。

        model.eval()                 # 模型设置为验证状态
        with torch.no_grad():                    # 模型不再计算梯度
            for data in valloader:                      # 从验证集取一个batch的数据
                val_x , val_target = data[0].to(device), data[1].to(device)          # 将数据放到设备上
                val_pred = model(val_x)                 # 用模型预测数据
                val_bat_loss = loss(val_pred, val_target)          # 计算loss
                val_loss += val_bat_loss.detach().cpu().item()                  # 计算loss
                val_rel.append(val_pred)                 #记录预测结果
        if val_loss < min_val_loss:
            torch.save(model, save_)               #如果loss比之前的最小值小， 说明模型更优， 保存这个模型

        plt_val_loss.append(val_loss/valloader.dataset.__len__())  #记录loss到列表。注意是平均的loss ，因此要除以数据集长度。
        #
        print('[%03d/%03d] %2.2f sec(s) TrainLoss : %.6f | valLoss: %.6f' % \
              (i, epoch, time.time()-start_time, plt_train_loss[-1], plt_val_loss[-1])
              )              #打印训练结果。 注意python语法， %2.2f 表示小数位为2的浮点数， 后面可以对应。


        # print('[%03d/%03d] %2.2f sec(s) TrainLoss : %3.6f | valLoss: %.6f' % \
        #       (i, epoch, time.time()-start_time, 2210.2255411, plt_val_loss[-1])
        #       )              #打印训练结果。 注意python语法， %2.2f 表示小数位为2的浮点数， 后面可以对应。
    plt.plot(plt_train_loss)              # 画图， 向图中放入训练loss数据
    plt.plot(plt_val_loss)                # 画图， 向图中放入训练loss数据
    plt.title('loss')                      # 画图， 标题
    plt.legend(['train', 'val'])             # 画图， 图例
    plt.show()                                 # 画图， 展示

plt_train_loss = []
    plt_val_loss = []

记录loss值

1.用于记录每轮的loss值：例如图中loss=1.9

train_loss = 0.0
val_loss = 0.0

2.记录开始时间：

start_time = time.time() 

3.将模型调整为train模式：

model.train() 

4.从训练集中取数据：
 

for data in trainloader:

5.将数据也放在设备上：

x, target = data[0].to(device), data[1].to(device) 

6.输出预测值：前向过程
 

pred = model(x)  

7.计算loss值：

bat_loss = loss(pred, target) 

8.梯度回传：算出所有参数的梯度
 

bat_loss.backward() 

9.优化器步骤：更新参数
 

optimizer.step()  

10.将所有梯度归零：

11.记录一批的总loss，并求平均值：例如图中的loss=4.48
 

train_loss += bat_loss.detach().cpu().item() 这么写因为要进行数据的转换，先从cpu上取下来。

plt_train_loss. append(train_loss/trainloader.dataset.__len__())

12.验证环节，训练一轮就要进行一轮验证：
 

model.eval() 设置为训练模式

with torch.no_grad():                    # 模型不再计算梯度

for data in valloader:                      # 从验证集取一个batch的数据
    val_x , val_target = data[0].to(device), data[1].to(device)          # 将数据放到设备上
    val_pred = model(val_x)                 # 用模型预测数据
    val_bat_loss = loss(val_pred, val_target)          # 计算loss
    val_loss += val_bat_loss.detach().cpu().item()                  # 计算loss
    val_rel.append(val_pred)    

如果val_loss小于minloss，要进行保存：

if val_loss < min_val_loss:
    torch.save(model, save_)               #如果loss比之前的最小值小， 说明模型更优， 保存这个模型

plt_val_loss.append(val_loss/valloader.dataset.__len__()) 

13.打印部分结果：

print('[%03d/%03d] %2.2f sec(s) TrainLoss : %.6f | valLoss: %.6f' % \
      (i, epoch, time.time()-start_time, plt_train_loss[-1], plt_val_loss[-1])
      )  

14.完成多轮训练后进行画图

plt.plot(plt_train_loss)              # 画图， 向图中放入训练loss数据
plt.plot(plt_val_loss)                # 画图， 向图中放入训练loss数据
plt.title('loss')                      # 画图， 标题
plt.legend(['train', 'val'])             # 画图， 图例
plt.show()    

测试集-进行提交

def evaluate(model_path, testset, rel_path ,device):
    model = torch.load(model_path).to(device)                     # 模型放到设备上。  加载模型
    testloader = DataLoader(testset, batch_size=1, shuffle=False)         # 将验证数据放入loader 验证时， 一般batch为1
    val_rel = []  #结果保存在这里
    model.eval()               # 模型设置为验证状态
    with torch.no_grad():               # 模型不再计算梯度
        for data in testloader:                 # 从测试集取一个batch的数据
            x = data.to(device)                # 将数据放到设备上，这个过程有梯度，但是不能计算，所以上面有torch.no grad():
            pred = model(x)                        # 用模型预测数据
            val_rel.append(pred.item())                #记录预测结果
    print(val_rel)                                     #打印预测结果
    with open(rel_path, 'w') as f:                        #打开保存的文件
        csv_writer = csv.writer(f)                           #初始化一个写文件器 writer
        csv_writer.writerow(['id','tested_positive'])         #在第一行写上 “id” 和 “tested_positive”
        for i in range(len(testset)):                           # 把测试结果的每一行放入输出的excel表中。
            csv_writer.writerow([str(i),str(val_rel[i])])
    print("rel已经保存到"+ rel_path)

项目创新点

1.正则化：loss=loss+w*w

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             # 返回损失。

loss =  mseLoss           # 定义mseloss 即 平方差损失，

正则化：使模型平滑，防止过度拟合，消除loss过大的离群点的贡献率。

2.相关系数：线性相关

本来用前面93列预测最后一列，哪里列有用？只调出有用的列，有许多方法，根本是降维。

相关系数法、主成分分析PCA方法等。

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2

def get_feature_importance(feature_data, label_data, k =4,column = None):
    """
    feature_data, label_data 要求字符串形式
    k为选择的特征数量
    如果需要打印column，需要传入行名
    此处省略 feature_data, label_data 的生成代码。
    如果是 CSV 文件，可通过 read_csv() 函数获得特征和标签。
    这个函数的目的是， 找到所有的特征种， 比较有用的k个特征， 并打印这些列的名字。
    """
    model = SelectKBest(chi2, k=k)      #定义一个选择k个最佳特征的函数
    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] for i in indices[0:k].tolist()]         # 选中这些列 打印
        print('k best features are: ',k_best_features)
    return X_new, indices[0:k]                  # 返回选中列的特征和他们的下标。

需要改造数据集，需要将dim设为变量。

            if all_feature:
                col_idx = [i for i in range(0,93)]       # 若全选，则选中所有列。
            else:
                _, col_idx = get_feature_importance(data[:,1:-1], data[:,-1], k=dim,column =csv_data[0][1:-1]) # 选重要的dim列。

总结

深度学习关键为数据集部分，模型部分通用