时间序列数据建模流程范例

def data_normalized(data):
    '''标准化数据

    Args:
        data(pd.DataFrame): 待标准化数据

    Returns:
        norm_data(tensor): 标准化后的数据
        scaler(MinMaxScaler): 标准化器
    '''
    __data = np.array(data)
    # 将小于 0 的值置为 0
    __data[__data < 0] = 0
    # 标准化数据
    scaler = MinMaxScaler()
    norm_data = scaler.fit_transform(__data.reshape(-1, 1))
    norm_data = torch.tensor(norm_data, dtype=torch.float32)
    return norm_data, scaler

data = pd.read_csv('TIME_SEQ_DATA.csv')
data['CreateDate'] = pd.to_datetime(data['CreateDate'])

data.dropna(inplace=True)
data.drop_duplicates(inplace=True)
data.sort_values(by=['CreateDate'], inplace=True)
data.reset_index(drop=True, inplace=True)

norm_data, scaler = data_normalized(data['Value'])

def create_dataset(data, look_back):
    dataset_x, dataset_y = [], []
    for i in range(len(data) - look_back):
        dataset_x.append(data[i:(i + look_back)])
        dataset_y.append(data[i + look_back])
    return np.array(dataset_x), np.array(dataset_y)

...
# 划分训练集和测试集
train_size = int(len(dataset_x) * 0.7)
...

from sklearn import datasets

# 根据Tensor创建数据集
iris = datasets.load_iris()
ds_iris = TensorDataset(torch.tensor(iris.data), torch.tensor(iris.target))

# 分割成训练集和预测集
n_train = int(len(ds_iris) * 0.8)
n_valid = len(ds_iris) - n_train
ds_train, ds_valid = random_split(ds_iris, [n_train, n_valid])

print(type(ds_iris))
# <class 'torch.utils.data.dataset.TensorDataset'>
print(type(ds_train))
# <class 'torch.utils.data.dataset.Subset'>

dl_train = DataLoader(ds_train, batch_size = 8)
dl_valid = DataLoader(ds_valid, batch_size = 8)

for features, labels in dl_train:
    print(features, labels)
    break

# 定义数据集
class myDataset(Dataset):
    def __init__(self, data, look_back) -> None:
        super().__init__()
        self.data = data
        self.look_back = look_back

    def __len__(self) -> int:
        return len(self.data) - self.look_back

    def __getitem__(self, index):
        feature = self.data[index:index + self.look_back]
        label = self.data[index + self.look_back]
        return feature, label

# 生成数据集
ds_data = myDataset(norm_data.view(-1).to(DEVICE), look_back=LOOK_BACK)

# 将数据集分为训练集和测试集
n_train = int(len(ds_data) * 0.8)
n_test = len(ds_data) - n_train
ds_train, ds_test = random_split(ds_data, [n_train, n_test])

dl_tarin = DataLoader(ds_train, batch_size=BATCH_SIZE, shuffle=True, drop_last=True)
dl_test = DataLoader(ds_test, batch_size=BATCH_SIZE, shuffle=False, drop_last=False)

DataLoader(
    dataset,            # 数据集
    batch_size=1,       # 批次大小
    shuffle=False,      # 是否乱序
    num_workers=0,      # 使用多进程读取数据，设置的进程数。
    drop_last=False,    # 是否丢弃最后一个样本数量不足batch_size批次数据。
    ...
)

# LSTM input shape: (seq_len, batch_size, input_size)
output, hidden = self.lstm(input)
# output shape: (seq_len, batch_size, output_size)

self.my_seq = nn.Sequential(nn.Linear(input_size, 24),
                            nn.Dropout(0.5),
                            nn.ReLU(True),
                            nn.Linear(24, 10),
                            nn.Dropout(0.5),
                            nn.ReLU(True))

# 定义模型
class LSTM(nn.Module):
    '''
    Args:
        input_size: feature size
        hidden_size: number of hidden units
        output_size: number of output
        num_layers: layers of LSTM to stack
    '''
    def __init__(self, input_size, hidden_size, output_size=1, num_layers=3):
        super(LSTM, self).__init__()
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers)
        self.linear = nn.Linear(hidden_size, output_size)

    def forward(self, input):
        # LSTM input shape: (seq_len, batch, input_size)
        output, hidden = self.lstm(input)
        output = self.linear(output[-1])
        return output

def train(dl_train):
    model = LSTM(LOOK_BACK, 64).to(DEVICE)
    criterion = nn.MSELoss()
    optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
    train_loss = []
    # 开始训练
    for e in range(EPOCH):
        __loss = 0
        for feature, label in dl_train:
            # feature: torch.Size([10, 24])     (BATCH_SIZE, LOOK_BACK)
            # label: torch.Size([10])           (BATCH_SIZE, )
            # out: torch.Size([10, 1])          (BATCH_SIZE, 1)
            out = model(feature.unsqueeze(0))
            loss = criterion(out, label.unsqueeze(1))
            # 反向传播
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            __loss += loss.item()
        train_loss.append(__loss)
        if (e + 1) % 10 == 0:  # 每 10 次输出结果
            print('Epoch: {}, Loss: {}'.format(e + 1, __loss / len(dl_train)))

    # 保存模型参数
    # torch.save(model.state_dict(), MODEL_DIR)
    return model, train_loss

model, train_loss = train(dl_tarin)

model = model.eval()
pred, actual = [], []
for feature, label in dl_test:
    # feature: torch.Size([10, 24])     (BATCH_SIZE, LOOK_BACK)
    # label: torch.Size([10])           (BATCH_SIZE, )
    # out: torch.Size([10, 1])          (BATCH_SIZE, 1)
    out = model(feature.unsqueeze(0))
    pred += out.view(-1).data.cpu().tolist()
    actual += label.view(-1).data.cpu().tolist()
pred, actual = np.array(pred), np.array(actual)

rmse = np.sqrt(mean_squared_error(actual.reshape(-1), pred.reshape(-1)))
print("根均方误差(RMSE)：" + str(rmse))