1.序列数据：
①现实生活中有很多数据是有时序结构，比如电影的评分随时间的变化而变化。
②统计学中，超出已知观测范围进行预测是外推法，在现有的观测值之间进行估计是内插法
2.统计工具：处理序列数据选用统计工具和新的深度神经网络架构
①在时间t观察到xt,那么得到T个不独立的随机变量
（x1…xT）~p(x)
②使用条件概率展开
p(a,b)=p(a)p(b|a)=p(b)p(a|b)
注：
①p(b|a)是a发生前提下b发生概率,即如果已知a发生了,则b发生的概率
②不独立的随机变量：变量之间存在某种关联
表示从x1一直到xT的方向，想要知道时序序列T时刻发生的事情：T时刻之前所有时刻发生的事情
表示先计算xT在依次计算到x1，反序。已知未来T时刻发生的事情，反推过去时刻发生的事情，物理上不一定可行。
3.序列模型
①对条件概率建模
对见过的数据建模，也称自回归模型：有一些数据，预测数据的时候，使用的是本数据样本而不是其他数据。
可以对t时刻之前的数据进行建模，使用自回归模型（给定一些数据，预测数据的时候使用的是本数据样本，而不是其他数据），表示成一个函数，可以看作是机器学习模型，在t时刻之前的数据上进行训练，然后取预测t时刻的数据。
4.各个方案
方案A—马尔科夫假设
①假设当前的数据只跟τ个过去数据点相关
假设τ=2，只跟前面2个数据相关，第3个是预测的值。所以每预测一个新数据，只需要看过去τ个数据就可以。τ越小模型简单，τ的值是固定的，不会随着时间的增大而增大（过去预测的时间越长，关联程度小）
例如在过去数据上训练一个MLP模型
方案B-潜变量模型
①引入潜变量ht来表示过去信息ht=f(x1,…, xt-1) 这样xt=p(xt|ht)
引入了潜变量h,h是不断更新的。h和前一个时刻的h和x相关。等价于两个模型：一个模型是根据前一个时刻的潜变量h和x，重新计算h1。第二个模型是根据潜变量h1，和x计算x1。拆分成两个模型，每个模型和1个或2个相关，计算容易。
【总结】
①时序模型中，当前数据跟之前观察到的数据相关
②自回归模型使用本身过去的数据去预测未来
③马尔科夫模型假设当前只跟最近少数数据相关，从而简化模型
④潜变量模型使用潜变量来概括历史信息。
【代码实现】
1.# 使用正弦函数和一些可加性噪声来生产序列数据，时间步为1，2，...1000
import torch
from torch import nn
from d2l import torch as d2l
# 使用正弦函数和一些可加性噪声来生产序列数据，时间步为1，2，...1000
T = 1000
time = torch.arange(1, T + 1, dtype=torch.float32) # time:1~1000
x = torch.sin(0.01 * time) + torch.normal(0, 0.2, (T,))
d2l.plot(time, [x], 'time', 'x', xlim=[1, 1000], figsize=(6, 3))2.
# 马尔可夫假设 将数据映射为数据对yt=xt feature-label对 # 从第五个时刻开始，每个时刻的label是该时刻的x值。该时刻的输入是前4个时刻的整体向量，训练数据996个4维数据 # 以4为长度并且滑动，每4个为特征，第5个是标签
tau = 4
features = torch.zeros((T - tau, tau)) # 996*4个训练数据
# 每4个为特征，第5个是标签
for i in range(tau): # i取值0-3
features[:, i] = x[i:T - tau + i]
labels = x[tau:].reshape((-1, 1))
batch_size, n_train = 16, 600 # 使用600个特征-标签对进行训练
train_iter = d2l.load_array((features[:n_train], labels[:n_train]),
batch_size, is_train=True)3.使用一个简单的结构：拥有两个全连接层的多层感知机
# 初始化网络权重函数
def init_weights(m):
if type(m) == nn.Linear:
nn.init.xavier_uniform(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()4.训练
# 训练
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.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)5.单步预测，检查模型预测下一个时间步的能力
onestep_preds = net(features)
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))6.多步预测
multistep_preds = torch.zeros(T)
multistep_preds[: n_train + tau] = x[: n_train + tau]
for i in range(n_train + tau, T):
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))7.K步预测
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))
