基于torch的神经网络实现过程

        基于torch的神经网络实现主要可以分为三部分，分别是数据处理、网络构建和模型训练过程，接下来从以下三个方面进行 

一.数据部分

        构建属于自己的数据类，基于torch.utils.data import Dataset，一般自定义Dataset包含三个部分：__init__()，__len__()，__getitem__()。

class Mydata(Dataset):
    def __init__(self, dataset, shuffle=True):
        # 继承父类Dataset
        super(Mydata, self).__init__()
        # 特征和标签（特征归一化）
        dataArray=np.array(dataset.iloc[:.:-1])
        labelArray=np.array(dataset.iloc[:.-1])
        self.data = MinMaxScaler(dataArray).tolist()
        self.label = labelArray.tolist()
        # 乱序 
        if shuffle:
            self._shuffle()
        
    # 是否打乱
    def _shuffle(self):
        buff = list(zip(self.data, self.label))
        random.shuffle(buff)
        self.data, self.label = zip(*buff)
    
    # 内置函数，返回长度
    def __len__(self):
        return len(self.label)
    
    # 创建可迭代对象，传入索引（自定义）
    def __getitem__(self, item):
        assert len(self.data) == len(self.label)
        data = self.data[item]
        label = self.label[item]
        return data, label

# 归一化
def MinMaxScaler(data, min_value=0, max_value=1):
    return (data - np.min(data, axis=0)) / (np.max(data, axis=0) - np.min(data, axis=0)) * (
            max_value - min_value) + min_value

二.模型部分

        以简单的BP为例，构建自己的模型类，基于nn.Module

class BPModel(nn.Module):
    # 传入特征数，隐藏层，输出
    def __init__(self, n_feature, n_hidden, n_output):
        super(BPModel, self).__init__()
        self.hidden = nn.Linear(n_feature, n_hidden)
        self.fc = nn.Sequential(
            nn.ReLU(),
            nn.Linear(n_hidden, n_output)
        )
    
    # 前向传播
    def forward(self, x):
        x = self.hidden(x)
        x = self.fc(x)
        return x

三.模型训练部分

        模型训练开始之前，设定好相关参数：

epoch = 100
batchSize = 16
lr = 0.001
device = 'cuda:0' if torch.cuda.is_available() else 'cpu'

        构建数据集，并划分为训练集和测试集：

# 构建数据集
trainData = Mydata(dataset)
# 切分
length = len(trainData)
trainSize = int(0.8 * length)
testSize = length - trainSize
train, test = torch.utils.data.random_split(trainData, [trainSize, testSize])

        将创建好的Dataset，传递给DataLoader。Dataset负责建立索引到样本的映射，DataLoader负责以特定的方式从数据集中迭代的产生 一个个batch的样本集合。

trainLoader = DataLoader(train, batch_size=batchSize, shuffle=False, pin_memory=True)
testLoader = DataLoader(test, batch_size=batchSize, shuffle=False, pin_memory=True)

        实例化模型，并选定优化器

model = BPModel(8, 64, 1).to(device)
lossFunc = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=lr)

        开始训练：

    for time in range(1, epoch + 1):
        print(f"第{time}轮次训练,共{epoch}轮次训练")
        for batchx, batchy in trainLoader:

            SeqData = Variable(batchx).type(torch.FloatTensor).to(device)
            output = Variable(batchy).type(torch.FloatTensor).to(device)

            predict = model(SeqData)
            lossNow = lossFunc(predict, output)
            # 梯度清零
            optimizer.zero_grad()
            # 反向传播 
            lossNow.backward()
            # 执行
            optimizer.step()

        trainLoss.append(lossNow.cpu().detach().numpy())
        print(f"训练误差  |Loss:{lossNow:.5f}")
        if time % 20 == 0:
            save_model(SavePath, time, model, 'LSTMModel')

        # 验证
        TestLoss = []
        for batchx, batchy in testLoader:
            SeqData = Variable(batchx).type(torch.FloatTensor).to(device)
            output = Variable(batchy).type(torch.FloatTensor).to(device)
            # 前向计算
            with torch.no_grad():
                predict = model(SeqData)
            TestLoss.append(lossFunc(predict, output))
        print(f'测试误差  |Loss:{torch.mean(torch.tensor(TestLoss)):.5f}\n')