(一)序列模型
我们前面所讨论的模型都是和图片信息息息相关的。图片信息是一种空间信息，而我们现在处理的信息是要加上时间信息的。例如RNN，NLP。都是一种序列模型。
现实生活中，我们的很多信息都是有时序结构的，举个例子，例如电影的评分，随着时间的变化，分数会变化；音乐，语言，文本，视频都是连续的信息。
（1）对时序数据怎么建模？
在时间t观察得到了一个数据,那么得到T个不独立的随机变量
~
。使用条件概率展开(乘法法则)：
我们可以看这个公式在直观上的表达，也就是后续的概率是基于前面的概率。从公式表达来讲，当然也可以反过来观察。但是有时候不一定能知道后续序列，例如在股票预测中，我们不能用后面的信息推测前面的信息。在填空题中，我们需要观测上下文，这时候是可以使用逆向的。
（2）序列模型
那么对于神经网络要解决的问题是什么呢？就是说给定前面t-1个样本的概率预测第t个样本的概率。我们可以在前面给定的t-1个样本上建立一个模型f。那么现在预测样本t的概率被分解为了两个小问题。
- 怎么建模函数 f
- 怎么预测 p
当然这里的模型和我们之前的模型是不一样的，我们前边的大部分模型是给定一个输入，这个输入是独立同分布的，我们给他分类，输入一个图片输出一个label。但现在不同，现在的样本是不独立的，给定一个x1，输出一个x2，然后又根据x1，x2，输出x3.这就是这样的一个过程。这就叫做自回归模型。
方案1：马尔科夫假设
假设：当前数据值更过去的τ个过去的数据点有关。
我们之前说的是后面的输出回合前面所有的样本都有关，但是那样的话随着时间的变化，计算量会剧增。所以我们假设，当前数据只跟前面部分数据有关系。这样的假设也是和现实情况是相似的。
假设仅和预测位置前个信息有关，可得：
方案2：潜变量模型
引入一个潜变量来表示过去的信息
这样的话,我们可以把
看作是一个向量或者是一个数。
如果这样假设的话，h 需要跟着时间的变化而变化，他根据上一个 h 和 x 更新得到新的 h' ，然后在计算得到下一个 x' 。这样就构造了两个模型分别计算 x 和 h 。
总结：
- 时序模型中，当前数据跟之前观察得到的数据相关
- 自回归模型使用自身过去的数据来预测未来
- 马尔可夫模型假设现在的数据之和过去少量数据有关，从而简化了模型
- 潜变量模型使用潜变量来概括历史信息
（二）代码实现
我们看如何用马尔可夫假设构建一个训练模型
%matplotlib inline
import torch
from torch import nn
from d2l import torch as d2l
# 构造一个时间序列，sin函数加噪声
t = 1000
time = torch.arange(1,t+1,dtype=torch.float32)
x = torch.sin(0.01*time) + torch.normal(0,0.2,(t,))
d2l.plot(time,[x],'time','x',xlim=[0.9,1000.1],figsize=(6,3))
# 将数据映射为一个数据对
tau = 4
# features是一个序列的列表，每次预测拿前面的tau个样本预测。
# 那么预测时间一直到t，一共需要预测t-τ次，所以将数据构造成（t-tau,tau）
features = torch.zeros((t-tau,tau))
for i in range(tau):
features[:,i] = x[i:t-tau+i] # 优雅
# i=0, features[:,0] = x[0:996] 第一列填充[0-996)
# i=1, features[:,1] = x[1:997] 第一列填充[1-997)
# i=2, features[:,2] = x[2:998] 第一列填充[2-998)
# i=3, features[:,3] = x[3:999] 第一列填充[3-999)
label =x[tau:].reshape((-1,1)) # （预测值）
batch_size, n_train=16, 600
train_iter = d2l.load_array((features[:n_train],label[:n_train]),batch_size,is_train=True)
# 构建一个简单的函数
def init_weights(m):
if type(m) == nn.Linear:
nn.init.xavier_normal_(m.weight)
def get_net():
net = nn.Sequential(
nn.Linear(4,10),
nn.ReLU(),
nn.Linear(10,1)
)
net.apply(init_weights)
return net
loss = nn.MSELoss()
# 训练模型
def train(net, train_iter, loss, epochs, lr):
trainer = torch.optim.Adam(net.parameters(), lr)
for epoch in range(epochs):
for X, y in train_iter:
trainer.zero_grad()
l = loss(net(X), y)
l.sum().backward()
trainer.step()
print(f'epoch {epoch + 1}, '
f'loss: {d2l.evaluate_loss(net, train_iter, loss):f}')
net = get_net()
train(net, train_iter, loss, 5, 0.01)
# 模型预测下一步, 蓝色的线是原始数据，紫色的线是根据四个点往后预测一个值的结果
onestep_preds = net(features) # 600以后是预测值
d2l.plot([time, time[tau:]],
[x.detach().numpy(), onestep_preds.detach().numpy()], 'time',
'x', legend=['data', '1-step preds'], xlim=[1, 1000],
figsize=(6, 3))
效果还是不错的，那么现在的预测还仅仅是预测异步的结果。那么我们看看让他预测出一系列的数据藏什么样子呢？，也就是给定前4个，预测下一个，然后把预测值加到历史数据中在预测下一个。看看表现如何？
multistep_preds = torch.zeros(t)
multistep_preds[: n_train + tau] = x[: n_train + tau]# [0:604)
for i in range(n_train + tau, t): # [604,1000)
multistep_preds[i] = net( # 预测结果放进历史数据，不断地预测
multistep_preds[i - tau:i].reshape((1, -1)))
# 画图看结果
d2l.plot([time, time[tau:], time[n_train + tau:]],
[x.detach().numpy(), onestep_preds.detach().numpy(),
multistep_preds[n_train + tau:].detach().numpy()], 'time',
'x', legend=['data', '1-step preds', 'multistep preds'],
xlim=[1, 1000], figsize=(6, 3))
600以后就开始预测，结果发现错的相当离谱。（绿色的线）那么出现这种现象的原因是什么呢？
是因为我们每一次预测都会产生一些误差，然而每一次误差会叠加到下一次，一直一直叠加下去。
max_steps = 64
features = torch.zeros((t - tau - max_steps + 1, tau + max_steps))
# 列i（i<tau）是来自x的观测，其时间步从（i）到（i+T-tau-max_steps+1）
for i in range(tau):
features[:, i] = x[i: i + t - tau - max_steps + 1]
# 列i（i>=tau）是来自（i-tau+1）步的预测，其时间步从（i）到（i+T-tau-max_steps+1）
for i in range(tau, tau + max_steps):
features[:, i] = net(features[:, i - tau:i]).reshape(-1)
steps = (1, 4, 16, 64)
d2l.plot([time[tau + i - 1: t - max_steps + i] for i in steps],
[features[:, (tau + i - 1)].detach().numpy() for i in steps], 'time', 'x',
legend=[f'{i}-step preds' for i in steps], xlim=[5, 1000],
figsize=(6, 3))
这里可以看出当step=4的时候还不错，当step=16或者64的时候误差会相当大。
第一和τ的选取有关；
第二我们的模型是两层模型，非常简单比较难拟合sin函数。
所以说，序列模型对于长远的未来数据是很难预测的。
网友评论