一个最基本的RNN训练框架用于多元回归(基于pytorch)

本文主要描述如何搭建一个RNN的基本训练架构.主要从如何读取CSV文件中的数据,构建数据管道. 如何搭建模型,如何在主函数中开启训练.

未完，待更新

一个最简单的RNN结构展开图, X(t)表示循环神经网络在时刻t的输入,H是循环神经网络的主体结构,循环的过程就是H被不断执行的过程.O(t)代表t时刻循环神经网路的输出.

简单描述一下具体的过程:

在t时刻,H会读取输入层的输入x(t),并输出一个值O(t),同时H的状态值会从当前步传递到下一步.

也就是讲:H的输入除了来自输入层的输入x(t),还依赖于上一时刻的H(t-1).

一般情况下,输入层的x为下图所示:

为了研究方便,下文的叙述令in_putsize = 1.下面使用

2.1 数据集准备

链接：https://pan.baidu.com/s/1HorFNE5mlDgAvFXU6_JXfQ
提取码：x521
train_data: 里面包含6列数据, 每一行作为一个训练输入, 其对应的输出在train_label所对应的行.

train_label: 里面包含1列数据

2.2 设计设计pytorch的数据管道

设计dataloader    data_loader.py

import torch
import numpy as np
class ImageFolder(torch.utils.data.Dataset):
def __init__(self, train_data):
self.data_sorce = np.array(train_data.iloc[:, 0:6])
self.data_lable = np.array(train_data.iloc[:, 6:7])
def __getitem__(self, index): # index = 0
id_data = list(self.data_sorce)[index] # id_data = list(data_sorce)[index]
id_lable = list(self.data_lable)[index] # list(data_lable)[index]
data = torch.Tensor(id_data).unsqueeze(1)
label = torch.Tensor(id_lable)
return data, label
def __len__(self):
return len(list(self.data_lable))

简单讲解一些这段代码:

这个是pytorch的 快速数据管道的构造的基本 架构, 一般情况下需要重新构造下面三个方法

__init__(self, train_data):  类初始化的时候, 需要传入一个靶向文件

__getitem__(self, index):  这个方法会在程序运行的时候,自动调用函数体里面的相关内容,同样也是构造子类的输出

__len__(self): 就如同名字一样,返回的数据集的长度

搭建模型文件, modelnet.py

import torch
from torch import nn
class Rnn(nn.Module):
def __init__(self, INPUT_SIZE):
super(Rnn, self).__init__()
self.hidden_size = 20
self.num_layers = 2
self.rnn = nn.RNN(
input_size=INPUT_SIZE,
hidden_size=self.hidden_size,
num_layers=self.num_layers,
batch_first=True
)
self.out = nn.Linear(self.hidden_size, 1)
def forward(self, x):
r_out, h_state = self.rnn(x, None)#
outs = []
for time in range(r_out.size(1)):
outs.append(self.out(r_out[:, time, :]))
return torch.stack(outs, dim=1), h_state

该modelnet.py文件中的输入参数有:

INPUT_SIZE:(非超参数) 该参数应等于 输入序列的特征的维度

self.hidden_size:(超参数)=>输出结果特征层的维度

self.num_layers:(超参数)=>循环神经网络的层数

由于每个时间间隔的输入都会对应相应的输出(输出也具有维度[hadden_sizes]的向量), 本文中hadden_sizes设置大于1,

通过一个全连接层将输出的特征向量转换为标量作为最终的输出,当然可以根据具体的需求来转化.转换过程如下代码所示.

outs = []
for time in range(r_out.size(1)):
outs.append(self.out(r_out[:, time, :]))

for循环,可以得到每一个时间间隔所对应的 输出. last_result = torch.stack(outs, dim=1) 的size为[batch,time_setp,1]

下面贴主函数的代码: main.py

import numpy as np
import matplotlib.pyplot as plt
import torch
from torch import nn
from modelnet import Rnn
from sklearn.model_selection import train_test_split
import pandas as pd
from data_loader import ImageFolder
from tqdm import trange
'''1.数据准备阶段
'''
# 导入训练数据文件
data_path = './Zhou_X.csv'
label_path = './Zhou_Y.csv'
# 指定输出的文件
txt_path = 'Zhou_X.txt'
# 定义一些超参数
INPUT_SIZE = 1 # 输入序列的特征维度
LR = 0.0001 # 学习率
BATCHSIZE_PER_CARD = 1 # batch_size
total_epoch = 40 # 总的训练循环次数
# 读取csv文件, sep = ' '代表表中的数据分割方式是' ' header = None是文件中没有关键字
data_train = pd.read_csv(data_path,sep = ' ',header=None)
data_label = pd.read_csv(label_path,header=None)
# 训练数据 和 标签放在同一个容器中, axis是按列拼接
data_get = pd.concat([data_train,data_label], axis=1)
# data.iloc[:, 0:13] # 按位置取某几列
# 将数据集 划分为训练集 和测试集
train_data, test_data = train_test_split(data_get,\
train_size=0.7,random_state=0.1,\
shuffle=False)
#################################################################
'''2.开始构造 训练框架'''
# 2.1构造pipe line
train_batchsize = torch.cuda.device_count() * BATCHSIZE_PER_CARD
val_batchsize = torch.cuda.device_count() * BATCHSIZE_PER_CARD
train_dataset = ImageFolder(train_data)
test_dataset = ImageFolder(test_data)
data_loader = torch.utils.data.DataLoader(
train_dataset,
batch_size=train_batchsize,
shuffle=True,
num_workers=0)
val_data_loader = torch.utils.data.DataLoader(
test_dataset,
batch_size=val_batchsize,
shuffle=True,
num_workers=0)
# 2.2 选择模型
model = Rnn(INPUT_SIZE)
print(model)
# 2.3 定义优化器和损失函数
optimizer = torch.optim.Adam(model.parameters(), lr=LR)
loss_func = nn.MSELoss()
# loss_func = nn.CrossEntropyLoss()
# 2.4 启动训练
global_step = 1
for epoch in range(1, total_epoch + 1):
print('\n---------- Epoch:' + str(epoch) + ' ----------')
data_loader_iter = iter(data_loader)
train_epoch_loss = 0
test_epoch_loss = 0
with trange(len(data_loader_iter)) as t:
for index in t:
train_data_input, train_data_label = data_loader_iter.next()
# x = torch.from_numpy(train_data_input)

prediction, h_state = model(train_data_input)
loss = loss_func(prediction[:,-1,:][0], train_data_label[0])
optimizer.zero_grad()
loss.backward()
optimizer.step()

global_step +=1
train_epoch_loss = train_epoch_loss + loss
t.set_postfix(step= global_step,loss = loss.data.numpy(), aver_loss= train_epoch_loss.data.numpy()/(index+1), learing_rate = LR)
data_loader_iter = iter(val_data_loader)
with trange(len(data_loader_iter)) as t:
for index in t:
with torch.no_grad():
train_data_input, train_data_label = data_loader_iter.next()
prediction, h_state = model(train_data_input)
loss = loss_func(prediction[:,-1,:][0], train_data_label[0])
test_epoch_loss = test_epoch_loss + loss
t.set_postfix(step= global_step,loss = loss.data.numpy(), aver_loss= test_epoch_loss.data.numpy()/(index+1), learing_rate = LR)
# 整体预测
all_data = ImageFolder(data_get)
all_data_loader = torch.utils.data.DataLoader(
all_data,
batch_size=1,
shuffle=False,
num_workers=0)
data_loader_iter = iter(all_data_loader)
input_caclaue = []
loss_caclaue = []
result = []
with trange(len(data_loader_iter)) as t:
for index in t:
with torch.no_grad():
train_data_input, train_data_label = data_loader_iter.next()
prediction, h_state = model(train_data_input)
loss = loss_func(prediction[:,-1,:][0], train_data_label[0])

input_caclaue.append([train_data_input.data.numpy(),train_data_label.data.numpy()])
result.append(prediction[:,-1,:][0].data.numpy())
loss_caclaue.append(loss.data.numpy())
t.set_postfix(step = index,loss = loss.data.numpy(), aver_loss= test_epoch_loss/(index+1))
with open(txt_path,"w") as f:

for index in range(len(result)):
pass # index = 0
str1 = ''
for iterm in input_caclaue[index][0][0]:
str1 = str1 + str(iterm[0]) + ' '
str2 = str(input_caclaue[index][1][0][0])

str3 = str(result[index][0])

str4 = str(loss_caclaue[index])

str_all = str1 + str2 + ' ' + str3 + ' ' + str4 + '\n'

f.write(str_all) # 自带文件关闭功能，不需要再写f.close()