• 【pytorch】构建多元时间序列数据集 Dataset
千次阅读
2020-05-21 19:19:56

假设原本数据集是如下的 csv 格式，行代表时间，列数代表变量数。

用它来构造机器学习的数据集，也就是有监督标签的样本。

# 代码一

import torch
import torch.utils.data
import os
import numpy as np
import pandas as pd

class MTSDataset(torch.utils.data.Dataset):
"""Multi-variate Time-Series Dataset for *.txt file

Returns:
[sample, label]
"""

def __init__(self,
window,
horizon,
data_name='electricity',
set_type='train',    # 'train'/'validation'/'test'
data_dir='./data'):
assert type(set_type) == type('str')
self.window = window
self.horizon = horizon
self.data_dir = data_dir
self.set_type = set_type

file_path = os.path.join(data_dir, data_name, '{}_{}.txt'.format(data_name, set_type))

self.len, self.var_num = rawdata.shape
self.sample_num = max(self.len - self.window - self.horizon + 1, 0)
self.samples, self.labels = self.__getsamples(rawdata)

def __getsamples(self, data):
X = torch.zeros((self.sample_num, self.window, self.var_num))
Y = torch.zeros((self.sample_num, 1, self.var_num))

for i in range(self.sample_num):
start = i
end = i + self.window
X[i, :, :] = torch.from_numpy(data[start:end, :])
Y[i, :, :] = torch.from_numpy(data[end+self.horizon-1, :])

return (X, Y)

def __len__(self):
return self.sample_num

def __getitem__(self, idx):
sample = [self.samples[idx, :, :], self.labels[idx, :, :]]
return sample

dataset = MTSDataset(
window=16,
horizon=3,
data_name='electricity',
set_type='train',
data_dir='.'
)
i = 0
sample = dataset[i]
print(sample[0].shape)  # torch.Size([16, 321])
print(sample[1].shape)  # torch.Size([1, 321])



# 代码二

import torch
import numpy as np

def normal_std(x):
return x.std() * np.sqrt((len(x) - 1.)/(len(x)))   # 样本标准差转化成总体标准差

class Data_utility(object):
# train and valid is the ratio of training set and validation set. test = 1 - train - valid
def __init__(self, file_name, train, valid, cuda, horizon, window, normalize = 2):
self.cuda = cuda;
self.P = window;
self.h = horizon
fin = open(file_name);
self.dat = np.zeros(self.rawdat.shape);
self.n, self.m = self.dat.shape;
self.normalize = 2
self.scale = np.ones(self.m)  # 维数等于数据列数
self._normalized(normalize)   # 当 normalize = 2, 修改 scale 为每一列的最大绝对值, 使每列数据绝对值最大值为 1
self._split(int(train * self.n), int((train+valid) * self.n), self.n)

self.scale = torch.from_numpy(self.scale).float()
tmp = self.test[1] * self.scale.expand(self.test[1].size(0), self.m)  # shape: [batch, n_var]

if self.cuda:
self.scale = self.scale.cuda();
self.scale = Variable(self.scale);

self.rse = normal_std(tmp);
self.rae = torch.mean(torch.abs(tmp - torch.mean(tmp)));

def _normalized(self, normalize):

if (normalize == 0):
self.dat = self.rawdat

#normalized by the maximum value of entire matrix.
if (normalize == 1):
self.dat = self.rawdat / np.max(self.rawdat);

#normlized by the maximum value of each column(sensor).
if (normalize == 2):
for i in range(self.m):
self.scale[i] = np.max(np.abs(self.rawdat[:,i]))
self.dat[:,i] = self.rawdat[:,i] / self.scale[i]

def _split(self, train, valid, test):

train_set = range(self.P+self.h-1, train);
valid_set = range(train, valid)
test_set = range(valid, self.n)
self.train = self._batchify(train_set, self.h)  # [batch, p, n_multiv], [batch, n_multiv]
self.valid = self._batchify(valid_set, self.h)
self.test = self._batchify(test_set, self.h)

def _batchify(self, idx_set, horizon):

n = len(idx_set);
X = torch.zeros((n,self.P,self.m));
Y = torch.zeros((n,self.m));

for i in range(n):
end = idx_set[i] - self.h + 1;
start = end - self.P;
X[i,:,:] = torch.from_numpy(self.dat[start:end, :]);
Y[i,:] = torch.from_numpy(self.dat[idx_set[i], :]);

return [X, Y];

def get_batches(self, inputs, targets, batch_size, shuffle=True):
length = len(inputs)
if shuffle:
index = torch.randperm(length)
else:
index = torch.LongTensor(range(length))
start_idx = 0
while (start_idx < length):
end_idx = min(length, start_idx + batch_size)
excerpt = index[start_idx:end_idx]
X = inputs[excerpt]; Y = targets[excerpt];
if (self.cuda):
X = X.cuda();
Y = Y.cuda();
yield Variable(X), Variable(Y);
start_idx += batch_size

data = Data_utility(file_name='solar_AL.txt', train=0.6, valid=0.2, cuda=False, horizon=12, window=24, normalize = 2)
print(data.rawdat.shape)  # (52560, 137)
print(data.train[0].shape, data.train[1].shape)  # torch.Size([31501, 24, 137]) torch.Size([31501, 137])

def train(data, X, Y, model, criterion, optim, batch_size):
model.train();
total_loss = 0;
n_samples = 0;
for X, Y in data.get_batches(X, Y, batch_size, True):   # <<< attention!
output = model(X);
scale = data.scale.expand(output.size(0), data.m)   # <<< attention!
loss = criterion(output * scale, Y * scale);
loss.backward();
total_loss += loss.item();
n_samples += (output.size(0) * data.m);


# 参考文献

1. DSANet: Dual Self-Attention Network for Multivariate Time Series Forecasting
2. Modeling Long- and Short-Term Temporal Patterns with Deep Neural Networks
更多相关内容
• 数据集描述包括样本数量、类别数、特征数、时间序列长度，除了Libras数据集时间序列长度为等长的，其他数据集时间序列长度为不等长。
• 时间序列界的“Imagnet”，发文章必跑数据集。大约有128个数据集，如ECG5000，GunPoint，coffee等数据集 相比于2015版有了大量更新，2018年秋季：该数据资源的早期工作由NSF职业奖0237918资助，并通过NSF IIS-...
• 时间序列数据集（UCR）.rar
• 电力需求分析 在时间序列数据集上分析房屋的电力需求。 还使用基于电力需求的 K-Means 聚类创建了电器检测系统。
• 单变量时间序列公开数据集，格式.csv,字段Datetime和AEP_MW，时间间隔为小时！
• 城市轨道客流时间序列数据集
• 超级商店时间序列数据集。超市购买的时间序列数据，可以训练和测试您的模型。 superstore_test.csv test_result.csv superstore_train.csv
• 前言数据是驱动科技发展的源泉，平时我们科研中也经常需要在各种开源数据上验证自己模型的效果。那时间序列目前可以使用的开源数据集有哪些呢？本期为大家做一次较为全面的整理汇总。UCR Time ...

前言

数据是驱动科技发展的源泉，平时我们科研中也经常需要在各种开源数据上验证自己模型的效果。那时间序列目前可以使用的开源数据集有哪些呢？本期为大家做一次较为全面的整理汇总。

UCR Time Series

UCR时间序列数据集是时序领域的“Imagnet”，涵盖医疗/电力/地理 等诸多领域，目前全量数据有128种。涉及时间序列预测、回归、聚类等诸多任务，可以说是发Paper必跑数据集，由加州大学河滨分校计算机系的教授 Eamonn Keogh 所在的课题组维护。

http://www.cs.ucr.edu/~eamonn/time_series_data/

FigShare

figShare是一个研究成果共享平台，这里向全世界开放免费的研究成果及科学数据。

https://figshare.com/

Awesome Public Datasets

该项目提供了一个非常全面的数据获取渠道，包含各个细分领域的数据库资源，自然科学和社会科学的覆盖都很全面，适合做研究和数据分析的人员。

https://github.com/awesomedata/awesome-public-datasets

服务监控数据集

该数据集是由人工神经网络公司Numenta所提供的，包含互联网服务场景下的各种流式数据与评测脚本。NAB是用于评估数据流实时应用中异常检测算法的新颖基准，它由50多个带有标签的真实世界和人工时间序列数据文件以及为实时应用程序设计的新颖评分机制组成。

https://github.com/numenta/NAB

音乐数据库

这个数据集包含了海量的公开音乐数据库，适用于包含音乐推荐、分类在内的各种任务

http://millionsongdataset.com/

mir_datas

国家经济数据库

国家统计局经常会统计涉及经济民生等多个方面的指标，提供了非常丰富的开源时间序列数据。这里简单为大家列举一些可以获取这些数据的渠道：

#### 国家数据

数据来源中华人民共和国国家统计局，包含了我国经济民生等多个方面的数据，并且在月度、季度、年度都有覆盖，较为全面。

https://data.stats.gov.cn/

#### CEIC

涵盖超过195个国家400多万个时间序列的数据源，最完整的一套超过128个国家的经济数据，能够精确查找GDP、CPI、进口、出口、外资直接投资、零售、销售以及国际利率等深度数据。

https://www.ceicdata.com/zh-hans

#### 万得

被誉为中国的Bloomberg，在金融业有着全面的数据覆盖，金融数据的类目更新非常快，据说很受国内的商业分析者和投资人的亲睐。

https://www.wind.com.cn/

#### 中国统计信息网

国家统计局的官方网站，汇集了全国各级政府各年度的国民经济和社会发展统计信息，建立了以统计公报为主，统计年鉴、阶段发展数据、统计分析、经济新闻、主要统计指标排行等。

http://www.tjcn.org/

政府开放数据

除了上述国家经济数据库以外，各地方也有自己的开放数据。这里简单列举：

· 北京市政务数据资源网：包含竞技、交通、医疗、天气等数据。

https://data.beijing.gov.cn/

· 深圳市政府数据开放平台：交通、文娱、就业、基础设施等数据。

https://opendata.sz.gov.cn/

· 上海市政务数据服务网：覆盖经济建设、文化科技、信用服务、交通出行等12个重点领域数据。

https://data.sh.gov.cn/

· 贵州省政府数据开放平台：贵州省在政务数据开放方面做的确实不错。

http://data.guizhou.gov.cn/

· Data.Gov：美国政府开放数据，包含气候、教育、能源金融等各领域数据。

https://www.data.gov/

ts_0.

数据竞赛平台

除了上面整理的常用的开源时间序列数据以外，我们如果想获取针对特定任务的时间序列数据，还可以通过各种竞赛平台获取数据。这些数据集通常干净且科研性非常高。包括：

• DataCastle：专业的数据科学竞赛平台

https://js.dclab.run/v2/index.html

• Kaggle：全球最大的数据竞赛平台

https://www.kaggle.com/

• 天池：阿里旗下数据科学竞赛平台

https://tianchi.aliyun.com/

• Datafountain：CCF制定大数据竞赛平台

https://www.datafountain.cn/

展开全文
• 数据是驱动科技发展的源泉，我们平常科研中也常常需要在各种开源数据上验证自己模型的效果。时间序列目前可以使用的开源数据集有哪些呢？本期为大家做一次梳理。

关注微信公众号“时序人”获取更好的阅读体验

#### 时间序列学术前沿

数据是驱动科技发展的源泉，我们平常科研中也常常需要在各种开源数据上验证自己模型的效果。时间序列目前可以使用的开源数据集有哪些呢？本期为大家做一次梳理。

### UCR Time Series

UCR时间序列数据集是时序领域的“Imagnet”，涵盖医疗/电力/地理 等诸多领域，目前全量数据有128种。涉及时间序列预测，回归，聚类等诸多任务，可以说是发Paper必跑数据集，由加州大学河滨分校计算机系的教授 Eamonn Keogh 所在的课题组维护

http://www.cs.ucr.edu/~eamonn/time_series_data/

### FigShare

这是一个研究成果共享平台，这里向全世界开放免费的研究成果及科学数据。

https://figshare.com/

### Awesome Public Datasets

该项目提供了一个非常全面的数据获取渠道，包含各个细分领域的数据库资源，自然科学和社会科学的覆盖都很全面，适合做研究和数据分析的人员。

https://github.com/awesomedata/awesome-public-datasets

### 服务监控数据集

该数据集是由人工神经网络公司Numenta所提供的，包含互联网服务场景下的各种流式数据与评测脚本。 NAB是用于评估数据流实时应用中异常检测算法的新颖基准，它由50多个带有标签的真实世界和人工时间序列数据文件以及为实时应用程序设计的新颖评分机制组成。

https://github.com/numenta/NAB

### 音乐数据库

这是数据集包含了海量的公开音乐数据库，适用于包含音乐推荐、分类在内的各种任务

http://millionsongdataset.com/

### 国家经济数据

国家统计局经常会统计涉及经济民生等多个方面的指标，提供了非常丰富的开源时间序列数据。这里简单为大家列举一些可以获取这些数据的渠道：

##### 国家数据

数据来源中华人民共和国国家统计局，包含了我国经济民生等多个方面的数据，并且在月度、季度、年度都有覆盖，较为全面。

https://data.stats.gov.cn/

##### CEIC

涵盖超过195个国家400多万个时间序列的数据源，最完整的一套超过128个国家的经济数据，能够精确查找GDP、CPI、进口、出口、外资直接投资、零售、销售以及国际利率等深度数据。

https://www.ceicdata.com/zh-hans

##### 万得

被誉为中国的Bloomberg，在金融业有着全面的数据覆盖，金融数据的类目更新非常快，据说很受国内的商业分析者和投资人的亲睐。

https://www.wind.com.cn/

##### 中国统计信息网

国家统计局的官方网站，汇集了全国各级政府各年度的国民经济和社会发展统计信息，建立了以统计公报为主，统计年鉴、阶段发展数据、统计分析、经济新闻、主要统计指标排行等。

http://www.tjcn.org/

### 数据竞赛网站

除了上面整理的常用的开源时间序列数据以外，如果我们想获取针对特定任务的时间序列数据，我们常常可以通过各种竞赛平台获取数据。这些数据集通常干净且科研性非常高。包括：

更多原创内容与系列分享，欢迎关注微信公众号“时序人”获取。

展开全文
• 截止到目前最新整理的的UCR数据集（UCRArchive）。这是以一个完整的压缩包，共有129个数据集。压缩包没有解压码。
• 非线性时间序列 建模 预测>>书的数据集以及代码
• 通过数学模型介绍了，非常热门，应用广泛，高大上的一些机器学习模型
• 第1章 数据集 1.1 数据集概述 1.2 从文件中读取数据 1.3 提取有效数据 第2章 全连接网络的拟合 2.1 定义全连接网络 2.2 定义loss与优化器 2.3 训练前准备 2.4 开始训练 2.5 loss显示 2.6 结果分析 第3章...

目录

第1章 概述

1.1 业务需求概述

1.2 业务分析

1.3 导入库

第1章 数据集

1.1 数据集概述

1.2 从文件中读取数据

1.3 提取有效数据

第2章 全连接网络的拟合

2.1 定义全连接网络

2.2 定义loss与优化器

2.3 训练前准备

2.4 开始训练

2.5 loss显示

2.6 结果分析

第3章 RNN网络的拟合

3.1 定义RNN网络

3.2 生成网络

3.3 定义loss与优化器

3.4 训练前的准备

3.5 开始训练

3.6 显示loss

3.7 分析

## 第1章 概述

### 1.1 业务需求概述

有一批最近52周的销售数据，希望能够根据这些数据，预测未来几周销售数据。

### 1.2 业务分析

这是一个线性拟合的问题，那么每周的数据之间是独立的？还是每周的数据之间有时间的相关性？

本文就采用层数的全连接网络和RNN网络对数据进行拟合与比较。

如果全连接网络的拟合度比RNN网络好，则证明每周的数据是独立无关的。

如果全连接网络的拟合度没有RNN网络好，则证明每周的数据是具有时间相关性。

### 1.3 导入库

%matplotlib inline
import torch
import torch.nn as nn
from torch.nn import functional as F
from torch import optim

import numpy as np
import math, random
import matplotlib.pyplot as plt
import pandas as pd

from torch.utils.data import Dataset


## 第1章 数据集

### 1.1 数据集概述

销售数据是通过Excel存放的：包含多个样本数据，每个样本包含52周的数据，如下图所示：

横轴：不同的样本

纵轴：每个样本包含的序列52周的销售数据。

### 1.2 从文件中读取数据

# 从excel文件中数据

sales_data.head()

### 1.3 提取有效数据

# 提取有效数据
source_data = sales_data
source_data.values.shape
source_data.values
array([[0.00000000e+00, 2.29157429e+00, 2.88283833e+00, ...,
2.52078778e+00, 2.63721001e+00, 2.74892268e+00],
[1.00000000e+00, 6.09664112e-01, 2.52360427e+00, ...,
1.66285479e+00, 2.48192522e+00, 2.41120153e+00],
[2.00000000e+00, 3.42279275e+00, 1.81265116e+00, ...,
1.72005177e+00, 2.16993942e+00, 2.16170153e+00],
...,
[1.50490000e+04, 3.83370716e+00, 3.54807088e+00, ...,
3.03134190e+00, 1.85208859e+00, 3.00563077e+00],
[1.50500000e+04, 3.18643937e+00, 1.70323164e+00, ...,
1.19605309e+00, 3.34099104e+00, 2.92155740e+00],
[1.50510000e+04, 3.10427003e+00, 2.82717086e+00, ...,
1.33781619e+00, 2.71468770e+00, 2.34349413e+00]])
# 显示数据集数据
source_data
Unnamed: 0week_1week_2week_3week_4week_5week_6week_7week_8week_9...week_43week_44week_45week_46week_47week_48week_49week_50week_51week_52
002.2915742.8828383.5818054.0138751.1099242.8342472.6250452.1968844.208887...1.2422502.7710723.7781433.1616343.7926452.0154812.8261842.5207882.6372102.748923
110.6096642.5236042.6095373.6959973.3992722.6166121.6519351.3482953.862523...2.4775052.2845133.4617833.1010523.4424201.9157762.4261681.6628552.4819252.411202
223.4227931.812651-0.0979661.7240643.0936601.7812782.8499462.9497073.560835...2.2196672.3598341.9320292.7319471.8362451.2199331.2227401.7200522.1699392.161702
333.3722832.5772543.8543083.4496792.5176762.6356792.3527062.8562161.948434...1.6709120.9091133.2166521.7753463.2704842.3997093.0320711.7036661.7505851.821736
442.9977271.7994153.6480902.3915672.3767781.8647170.4080622.3467263.260303...2.3040583.0389052.0387332.8251862.2329372.5090502.881796-1.7121312.1403661.926818
..................................................................
15047150471.9527261.5476371.9027890.8132612.6009792.9106382.8783960.5942163.526187...0.4860733.3362523.3072703.0268351.4721163.2207922.6640441.5461533.0269482.611774
15048150480.6528243.5891913.2577072.8212762.1859372.534801-0.7743753.8356953.776809...2.6841531.3849123.1845702.8329412.0920332.6061980.7531933.1605993.0858002.814394
15049150493.8337073.5480713.1941601.9934373.0135471.8250472.3051960.5224753.126647...2.9289371.6337543.0785982.4665630.4893803.5187253.4064663.0313421.8520893.005631
15050150503.1864391.7032323.1965912.407803-0.4743703.8799433.7624083.4156691.790529...1.6426122.3877702.1498930.6884633.1508053.2422092.9727281.1960533.3409912.921557
15051150513.1042702.8271711.1764283.2749672.9346552.3491882.4129351.2190542.843297...2.5512590.8192033.4165323.2420212.8101772.0374872.6816941.3378162.7146882.343494

15052 rows × 53 columns

## 第2章 全连接网络的拟合

### 2.1 定义全连接网络

class FullyConnected(nn.Module):
def __init__(self, x_size, hidden_size, output_size):
super(FullyConnected, self).__init__()
self.hidden_size = hidden_size

self.linear_with_tanh = nn.Sequential(
nn.Linear(10, self.hidden_size),
nn.Tanh(),
nn.Linear(self.hidden_size, self.hidden_size),
nn.Tanh(),
nn.Linear(self.hidden_size, output_size)
)

def forward(self, x):
yhat = self.linear_with_tanh(x)

return yhat
# 输入样本的size
x_size = 1

# 隐藏层的size：try to change this parameters
hidden_size = 2

#数据特征的size
output_size = 10

fc_model = FullyConnected(x_size = x_size, hidden_size = hidden_size, output_size = output_size)
print(fc_model)

fc_model = fc_model.double()
print(fc_model)
FullyConnected(
(linear_with_tanh): Sequential(
(0): Linear(in_features=10, out_features=2, bias=True)
(1): Tanh()
(2): Linear(in_features=2, out_features=2, bias=True)
(3): Tanh()
(4): Linear(in_features=2, out_features=10, bias=True)
)
)


fc_model.state_dict()['linear_with_tanh.0.weight']
tensor([[ 0.2028,  0.0721,  0.0101,  0.2866, -0.3106,  0.1612,  0.0082, -0.1394,
0.2630, -0.2903],
[ 0.0596, -0.2646,  0.2036, -0.2676, -0.0198,  0.2969,  0.2596,  0.0965,
0.0746, -0.0195]], dtype=torch.float64)

### 2.2 定义loss与优化器

#定义loss函数
criterion = nn.MSELoss()

# 使用 Adam 优化器 比课上使用的 SGD 优化器更加稳定
optimizer = optim.AdamW(fc_model.parameters(), lr=0.01) 

### 2.3 训练前准备

n_epochs = 30
n_layers = 1
batch_size = seq_length
seq_length = 10

fc_losses = np.zeros(n_epochs)

print(data_loader.batch_size )

### 2.4 开始训练

# 开始训练
for epoch in range(n_epochs):
# 定义用于每个epoch的平均loss
epoch_losses = []

# 读取batch数据
#当读到数据不足batch size时，跳过batch size
if data.shape[0] != batch_size:
continue

#随机的获取长度=seq_length的数据
random_index = random.randint(0, data.shape[-1] - seq_length - 1)
train_x = data[:, random_index: random_index+seq_length]
#train_y = data[:, random_index + 1: random_index + seq_length + 1]
train_y = train_x

#进行前向运算
outputs = fc_model(train_x.double())

#复位梯度

#求此次前向运算的loss
loss = criterion(outputs, train_y)

#反向求导
loss.backward()

#梯度迭代
optimizer.step()

#
epoch_losses.append(loss.detach())

if iter_  == 0:
plt.clf();
plt.ion()
plt.title("Epoch {}, iter {}".format(epoch, iter_))
plt.plot(torch.flatten(train_y),'c-',linewidth=1,label='Label')
#plt.plot(torch.flatten(train_x),'g-',linewidth=1,label='Input')
plt.plot(torch.flatten(outputs.detach()),'r-',linewidth=1,label='Output')
plt.draw();
plt.pause(0.05);
fc_losses[epoch] = np.mean(epoch_losses)

................................................................

### 2.5 loss显示

plt.plot(fc_losses)

### 2.6 结果分析

全连接网络应对这种时序序列问题，拟合性不是很好。

## 第3章 RNN网络的拟合

### 3.1 定义RNN网络

class SimpleRNN(nn.Module):
def __init__(self, x_size, hidden_size, n_layers, batch_size, output_size):
super(SimpleRNN, self).__init__()
self.hidden_size = hidden_size
self.n_layers = n_layers
self.batch_size = batch_size
#self.inp = nn.Linear(1, hidden_size)
self.rnn = nn.RNN(x_size, hidden_size, n_layers, batch_first=True)
self.out = nn.Linear(hidden_size, output_size) # 10 in and 10 out

def forward(self, inputs, hidden=None):
hidden = self.__init__hidden()
#print("Forward hidden {}".format(hidden.shape))
#print("Forward inps {}".format(inputs.shape))
output, hidden = self.rnn(inputs.float(), hidden.float())
#print("Out1 {}".format(output.shape))
output = self.out(output.float());
#print("Forward outputs {}".format(output.shape))

return output, hidden

def __init__hidden(self):
hidden = torch.zeros(self.n_layers, self.batch_size, self.hidden_size, dtype=torch.float64)
return hidden

### 3.2 生成网络

x_size = 1
hidden_size = 2 # try to change this parameters
n_layers = 1
seq_length = 10
output_size = 1

#rnn_model = SimpleRNN(x_size, hidden_size, n_layers, seq_length, output_size)
rnn_model = SimpleRNN(x_size, hidden_size, n_layers, seq_length, output_size)

print(rnn_model)
SimpleRNN(
(rnn): RNN(1, 2, batch_first=True)
(out): Linear(in_features=2, out_features=1, bias=True)
)

### 3.3 定义loss与优化器

# 定义loss
criterion = nn.MSELoss()

#定义优化器
optimizer = optim.AdamW(rnn_model.parameters(), lr=0.01) # 使用 Adam 优化器 比课上使用的 SGD 优化器更加稳定 

### 3.4 训练前的准备

# 训练前的准备
n_epochs = 30
rnn_losses = np.zeros(n_epochs)

data_loader = torch.utils.data.DataLoader(source_data.values, batch_size=seq_length, shuffle=True)

### 3.5 开始训练

# 开始训练
for epoch in range(n_epochs):
if t.shape[0] != seq_length: continue

random_index = random.randint(0, t.shape[-1] - seq_length - 1)
train_x = t[:, random_index: random_index+seq_length]
#train_y = t[:, random_index + 1: random_index + seq_length + 1]
train_y = train_x

#获取输出
outputs, hidden = rnn_model(train_x.double().unsqueeze(2), hidden_size)

#梯度复位

#定义损失函数
loss = criterion(outputs.double(), train_y.double().unsqueeze(2))

# 反向求导
loss.backward()

#梯度迭代
optimizer.step()

#记录loss
epoch_losses.append(loss.detach())

#显示拟合图像
if iter_ == 0:
plt.clf();
plt.ion()
plt.title("Epoch {}, iter {}".format(epoch, iter_))
plt.plot(torch.flatten(train_y),'c-',linewidth=1,label='Label')
plt.plot(torch.flatten(train_x),'g-',linewidth=1,label='Input')
plt.plot(torch.flatten(outputs.detach()),'r-',linewidth=1,label='Output')
plt.draw();
plt.pause(0.05);
rnn_losses[epoch] = np.mean(epoch_losses)


### 3.7 分析

RNN网络在第一个epoch完成后，拟合度就非常好。

展开全文
• 时间序列有高度的自相关性，所以我不能随机打乱。 如果1-6月训练，7、8验证，9、10测试的话，实验结果表明测试精度远差于验证逻辑上很好解释，中间差了两个月，市场行情发生了很大的变化，模型没见过跟不...
• 下载地址：laiguokun/multivariate-time-series-data. electricity (行，列) = (26304, 321) 每日的用电量有一定的季节性，图中只画出 10 列 exchange_rate (行，列) = (7588, 8) solar-energy ...
• ## 时间序列数据简介

千次阅读 2021-08-11 19:14:18
前言 1. 引言 1.1 时间序列定义 1.2 应用场景 1.3研究方法的递进 2. 时间序列数据 2.1 数据的获取 2.2 数据时间轴的确定 2.3 时间序列遇到问题
• 时间序列数据集有一个额外的维度——时间。 我们可以将其视为 3D 数据集。 比如说，我们有一个包含 5 个特征和 5 个输入实例的数据集。 那么时间序列数据基本上是该表在第 3 维的扩展，其中每个新表只是新时间步长...
• 时间序列数据必须经过变换才能用来拟合有监督的学习模型。在这种形式下，数据可以立即用于拟合有监督的机器学习算法，甚至多层感知器神经...本文介绍了如何将时间序列数据集转换为三维结构，以便适合CNN或LSTM模型。
• 用Pandas和Streamlit对时间序列数据集进行可视化过滤 介绍 我们每天处理的数据最多的类型可能是时间序列数据。基本上，使用日期，时间或两者同时索引的任何内容都可以视为时间序列数据集。在我们工作中，可能经常...
• MATLAB实现ARIMA时间序列预测数据集
• 可用于进行序列预测的一维数据集，取自某支股票的某时间段内的价格。
• MATLAB时间序列回归Data_TSReg2数据集
• 为了在接下来的程序中对这些时间序列进行聚类以及评估聚类效果，需要读取这些数据，并且将状态（分类）作为标签附在每一段数据上。鉴于标签和时间序列的格式不一致，本人采用了字典格式。 具体代码如下： def ...
• MATLAB实现RNN(循环神经网络)时间序列预测数据集
• data = pd.read_excel(r'你的数据位置',index_col=0)#读取数据 data data1 = data.values[:,:]#截取所需要的数据 data1.shape import numpy as np X = []#开一个空的东西用来存数据 for i in range(0,n，m):#n是你所...
• 提出的TSkmeans算法可以有效地利用时间序列数据集的固有子空间信息来增强聚类性能。 更具体地说，平滑子空间由加权时间戳表示，加权时间戳指示这些时间戳对于聚类对象的相对判别力。 我们工作的主要贡献包括设计一...
• 时间序列数据在许多不同的行业中都非常重要。它在研究、金融行业、制药、社交媒体、网络服务等领域尤为重要。对时间序列数据的分析也变得越来越重要。在分析中有什么比一些好的可视化效果更好呢?没有一些视觉效果，...
• 时间序列预测可以被构造为一个监督学习问题。通过对时间序列数据的重构，可以针对不同问题使用相关的机器学习算法。本文介绍了如何将时间序列问题重新构造为机器学习中的监督学习问题。

...