深度生成模型阅读笔记（二）——自回归模型

最新推荐文章于 2023-12-15 12:10:04 发布

AI编程学编程AI

最新推荐文章于 2023-12-15 12:10:04 发布

阅读量376

点赞数

文章标签：笔记回归数据挖掘

本文链接：https://blog.csdn.net/qq_44335756/article/details/134430268

版权

本书第二章将详细介绍自回归模型，因为它的标题叫做自回归模型！！🐶🐶🐶

快速读完一遍第二章后，发现作者写作本书主要是结合使用概率论的知识进行建模，比如使用条件分布来为联合分布 $p(x)$ 建模。并且，作者在本章中对于自回归模型并没有深入基础地探讨，而是着眼于“深度”，大量的结合神经网络来举例和应用。

我们先暂时抛开本书，来具体看一下自回归模型是怎么回事。

然后马上先不要脸地请上GPT老师 😘。

直接提问：

“GPT老师您好，请介绍一下自回归模型。”

GPT老师：

“自回归模型（Autoregressive Model）是一种用于时间序列数据分析的统计模型。它基于时间序列中的自相关性，将当前变量的值与过去若干时刻的值进行线性组合，用以预测未来的值。

自回归模型的一般形式可以表示为：

Yt = β0 + β1Yt-1 + β2Yt-2 + ... + βpYt-p + εt

其中，Yt表示时间序列在时刻t的值，Yt-1、Yt-2等表示过去时刻的值，β0、β1、β2等为模型的参数，εt为误差项。

自回归模型的关键是确定滞后阶数p，即过去时刻的数量。选取合适的滞后阶数需要通过统计方法或模型选择准则进行评估。

自回归模型的参数估计通常采用最小二乘法，通过最小化观测值与模型预测值之间的残差平方和来确定参数的值。

自回归模型可以用于时间序列的预测和分析，通过分析过去的数据，可以预测未来的趋势和变化。它也可以用于探索时间序列数据之间的关系，分析变量之间的因果关系和影响程度。”

我们发现GPT老师在上面的介绍中说明了自回归模型是和时间相关的，用于时间序列数据分析，同时，它还给出了自回归模型的一般形式，这个表达式是与书中所不同的，正是我想要的（懂我的GPT老师！💓💓💓）。

书中的表达式也是用概率表示的，作者为了降低模型复杂度，假定了一个有限记忆，假设每个变量最多依赖于不超过两个的其他变量，即：

$p(x) = p(x_{1})p(x_{2}|p_{1})\prod_{d = 3}^{D}p(x_{d}|x_{d-1},x_{d-2})$

我想，如果不简化模型，表达式应该是这样的：

$p(x) = p(x_{1})p(x_{2}|p_{1})\prod_{d = 3}^{D}p(x_{d}|x_{d-1},x_{d-2}...x_{1})$

如果不对，望指正！

然后，我麻烦GPT老师对她给出的公式进行详细的数学推导和解释。

GPT老师：

“对于自回归模型的公式进行数学推导和解释，公式可以写成如下形式：

Y(t) = β0 + β1Y(t-1) + β2Y(t-2) + ... + βpY(t-p) + ε(t)

其中，Y(t)表示时间序列在时刻t的值，Y(t-1)、Y(t-2)等表示过去时刻的值，β0、β1、β2等为模型的参数，ε(t)为误差项。

为了进行推导和解释，我们首先考虑p = 1的情况，即只有一个滞后项。

Y(t) = β0 + β1Y(t-1) + ε(t)

我们可以将上式写成误差项的形式：

Y(t) - β1Y(t-1) = β0 + ε(t)

然后，我们使用数学归纳法来推导p大于1的情况。

假设对于任意的k < p，我们有：

Y(t) - β1Y(t-1) - β2Y(t-2) - ... - βkY(t-k) = β0 + ε(t)

我们将上式左侧加上β(p-1)Y(t-p+1)得到：

Y(t) - β1Y(t-1) - β2Y(t-2) - ... - βkY(t-k) + β(p-1)Y(t-p+1) = β0 + ε(t) + β(p-1)Y(t-p+1)

接下来，我们将上式中的Y(t-p+1)替换为：

Y(t-p+1) = β0 + β1Y(t-p) + β2Y(t-p-1) + ... + β(p-1)Y(t-1) + ε(t-p+1)

将这个替换后的表达式带入到前面的等式中，得到：

Y(t) - β1Y(t-1) - β2Y(t-2) - ... - βkY(t-k) + β(p-1)(β0 + β1Y(t-p) + β2Y(t-p-1) + ... + β(p-1)Y(t-1) + ε(t-p+1)) = β0 + ε(t) + β(p-1)Y(t-p+1)

化简上式，可以得到：

Y(t) = β0 + β1Y(t-1) + β2Y(t-2) + ... + βkY(t-k) + β(p-1)Y(t-p) + ε(t) + β(p-1)ε(t-p+1)

我们可以看到，时间序列Y(t)的值可以通过过去p个时刻的值Y(t-1)、Y(t-2)、...、Y(t-p)和相应的参数β1、β2、...、βp-1来预测，同时还有误差项ε(t)和β(p-1)ε(t-p+1)的影响。

自回归模型的数学推导过程就是这样。通过上述推导，我们可以看到，自回归模型使用过去时刻的值来预测当前时刻的值，通过调整参数β1、β2、...、βp-1的取值，可以更好地拟合时间序列数据。同时，模型的残差项ε(t)反映了模型无法解释的部分，通常假设残差项是独立同分布的随机变量。”

经过这么一推导，发现确实和书中的公式有异曲同工之处，GPT老师给出的公式是直接了当地对时间的值进行了建模，而作者是基于概率。

继续往下，作者开始引出了MLP，继而到了深度学习的范畴，作者称之为“由神经网络参数化的自回归模型”，同时也是本章的重点。

这里我也麻烦GPT老师帮我做了解释和讨论：

“请继续沿用上面的公式和表达式，并在此基础上继续讨论由神经网络参数化的自回归模型。”

GPT老师：

“将自回归模型参数化为神经网络模型是一种常见的方法，可以更灵活地建模复杂的非线性关系。在这种情况下，我们可以使用神经网络的隐藏层来表示过去时刻的值，并使用输出层来预测当前时刻的值。

假设我们使用一个具有L个隐藏层的前馈神经网络来参数化自回归模型，其中每个隐藏层具有m个神经元。我们可以定义每个隐藏层的输出为：

H(l)(t) = g(W(l)H(l-1)(t) + b(l)), l = 1, 2, ..., L

其中，H(l)(t)表示第l个隐藏层在时刻t的输出，H(l-1)(t)表示第l-1个隐藏层在时刻t的输出（或者当l=1时，表示输入层的输出），W(l)表示第l个隐藏层的权重矩阵，b(l)表示第l个隐藏层的偏置向量，g(·)是激活函数。

最后一个隐藏层的输出可以作为预测当前时刻的值的输入：

Y(t) = β0 + Σβ(l)H(L)(t) + ε(t)

其中，β0是偏置项，β(l)是连接最后一个隐藏层和输出层的权重参数，ε(t)是误差项。

为了训练模型，我们可以使用最小二乘法或其他优化算法来最小化观测值和模型预测值之间的误差。常见的优化算法包括梯度下降法和反向传播算法。

通过神经网络参数化的自回归模型可以更好地捕捉时间序列数据中的非线性关系和复杂模式，具有更强的拟合能力。然而，它也需要更多的计算资源和更多的参数进行训练，需要注意过拟合的问题，并且在实际应用中需要根据具体情况进行调参和选择合适的网络结构。”

这里我们可以发现，GPT老师给我们整出了神经网络最普遍的形式，输入层+隐藏层+输出层，然后套到自回归模型中，那既然如此，我们也可以参照着神经网络的反向传播算法，来对时间序列进行训练和预测了，果然，GPT老师也是这样教导我的，她还贴心地帮我画了个简图💗💗💗

GPT老师：

“推导神经网络参数化的自回归模型的训练过程需要涉及梯度下降法和反向传播算法。以下是训练模型的详细推导和简图：

定义目标函数：我们可以使用最小二乘法定义目标函数，即将观测值与模型预测值之间的平方误差最小化。目标函数为： J = Σ(Y(t) - β0 - Σβ(l)H(L)(t))^2 其中，Σ表示对所有时刻t进行求和。
使用梯度下降法更新参数：我们使用梯度下降法来最小化目标函数。首先，我们需要计算目标函数对参数β(l)和每个隐藏层的权重矩阵W(l)的偏导数。对于参数β(l)，偏导数的计算为： ∂J/∂β(l) = -2Σ(H(L)(t)(Y(t) - β0 - Σβ(l)H(L)(t))) 对于权重矩阵W(l)，偏导数的计算为： ∂J/∂W(l) = -2Σ(∂J/∂H(L)(t) * ∂H(L)(t)/∂W(l)) 其中，∂J/∂H(L)(t)可以通过链式法则计算得到。
反向传播算法：通过反向传播算法，我们可以逐层计算梯度并更新参数。算法步骤如下：

初始化参数β(l)和权重矩阵W(l)的随机值。
前向传播：计算每个隐藏层的输出H(l)(t)和模型预测值Y(t)。
计算输出层的梯度：根据目标函数的偏导数计算∂J/∂β(l)。
反向传播：从输出层开始，逐层计算梯度∂J/∂H(l)(t)和∂J/∂W(l)。
更新参数：根据梯度下降法更新参数β(l)和权重矩阵W(l)。
重复上述步骤，直到达到收敛条件或达到最大迭代次数。

以下是一个简化的图示，展示了一个具有两个隐藏层的神经网络参数化的自回归模型的训练过程：

输入层          隐藏层1         隐藏层2         输出层
   ↓               ↓               ↓               ↓
Y(t-1)  →  ...  →  H(1)(t)  →  H(2)(t)  →      Y(t)
   ↑               ↑               ↑               ↑
   Y(t-2)    ...     H(1)(t-1)   H(2)(t-1)     ε(t)
   ↑               ↑               ↑
   ...             ...             ...
   Y(t-p+1)  ...  H(1)(t-p+1)  H(2)(t-p+1)

其中，箭头表示信息传递方向，每个神经元的输出作为下一层的输入。输入层接收过去p个时刻的值，通过隐藏层传递信息并生成最终的预测值。

上述推导和图示展示了如何使用梯度下降法和反向传播算法来训练神经网络参数化的自回归模型，通过最小化目标函数来调整模型参数，以更好地拟合时间序列数据。

”

看了GPT老师的推导，知道老师是将神经网络模型带入自回归模型，我们可以很明显地看出是那个原汁原味的神经网络反向传播推导过程，但是不知道这里自回归在神经网络的神威下怎么样了，所以，我又向GPT老师发出了我的疑问：

“可以介绍下上面的推导中自回归模型的部分吗？或者自回归模型在上面推导中怎么体现的。”

GPT老师：

“在推导中，自回归模型在神经网络参数化的自回归模型中体现在以下几个方面：

输入层：输入层接收过去p个时刻的值，即Y(t-1)、Y(t-2)、...、Y(t-p+1)。这些值是自回归模型中使用的滞后项，用于预测当前时刻的值Y(t)。
隐藏层：隐藏层使用神经网络的方式来建模自回归模型中的线性组合关系。每个隐藏层的输出H(l)(t)都是过去时刻的值Y(t-1)、Y(t-2)、...、Y(t-p+1)的线性组合，通过权重参数β(l)和激活函数g(·)来计算。
输出层：输出层表示模型的预测值Y(t)。它的计算中包含了自回归模型中的线性组合关系，即β0 + Σβ(l)H(L)(t)。其中，β0是偏置项，Σβ(l)H(L)(t)表示过去时刻的值的线性组合。

通过以上方式，神经网络参数化的自回归模型能够灵活地建模时间序列数据中的自相关关系。隐藏层的输出以及输出层的计算方式，使神经网络能够通过学习调整权重参数β(l)，从而更好地拟合时间序列的非线性关系。在训练过程中，通过最小化目标函数，模型会自动学习到最优的权重参数，从而能够更准确地预测未来的值。

需要注意的是，神经网络参数化的自回归模型中，并没有直接使用到传统自回归模型中的残差项ε(t)。这是因为神经网络本身具有较强的表达能力，可以通过隐藏层和非线性激活函数来逼近复杂的时间序列模式，从而降低了对残差项的依赖。”

哦~，我大概懂了，就是Y(t)是我们要预测的当前值，可以将它作为神经网络的输出层，前面P个时刻的值，我们用作输入层和隐藏层的，加上权重参数β(l)，通过神经网络来反向调优参数，同时，神经网络也利用了自回归模型对时间序列的敏感性，来预测输出值Y(t)。

但是还是感觉不爽，GPT老师无奈地送给了我python代码（我厚着脸皮子要的🙈🙈🙈）

我还不要脸的找GPT老师分别要来数学推导的代码和神经网络参数化的代码：

GPT老师：😒😒😒

“以下是根据上面的推导生成的自回归模型的数学推导的Python代码和由神经网络参数化的自回归模型推导的Python代码示例：

自回归模型的数学推导的Python代码：

import numpy as np

def autoregressive_model(Y, p):
    n = len(Y)
    X = np.zeros((n-p, p+1))
    for i in range(n-p):
        X[i, :-1] = Y[i:i+p]
        X[i, -1] = 1
    beta = np.linalg.lstsq(X, Y[p:], rcond=None)[0]
    return beta[:-1], beta[-1]

# 示例数据
Y = np.array([1, 3, 5, 7, 9, 11])
p = 2

# 计算自回归模型参数
beta, beta0 = autoregressive_model(Y, p)

print("自回归模型参数：")
print("beta0:", beta0)
for i in range(p):
    print("beta", i+1, ":", beta[i])

神经网络参数化的自回归模型推导的Python代码：

import numpy as np
import tensorflow as tf

def neural_network_autoregressive_model(Y, p, num_hidden_units, num_hidden_layers, learning_rate, num_epochs):
    n = len(Y)
    X = np.zeros((n-p, p))
    for i in range(n-p):
        X[i] = Y[i:i+p]
    X = np.expand_dims(X, axis=-1)
    Y = Y[p:]

    model = tf.keras.Sequential()
    model.add(tf.keras.layers.Dense(num_hidden_units, input_shape=(p,), activation='relu'))
    for _ in range(num_hidden_layers-1):
        model.add(tf.keras.layers.Dense(num_hidden_units, activation='relu'))
    model.add(tf.keras.layers.Dense(1, activation='linear'))

    model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=learning_rate), loss='mse')

    model.fit(X, Y, epochs=num_epochs, verbose=0)

    return model

# 示例数据
Y = np.array([1, 3, 5, 7, 9, 11])
p = 2
num_hidden_units = 10
num_hidden_layers = 2
learning_rate = 0.001
num_epochs = 1000

# 训练神经网络参数化的自回归模型
model = neural_network_autoregressive_model(Y, p, num_hidden_units, num_hidden_layers, learning_rate, num_epochs)

# 获取模型参数
weights = model.get_weights()

# 输出模型参数
print("神经网络参数化的自回归模型参数：")
for i in range(p):
    print("beta", i+1, ":", weights[0][i])
print("beta0:", weights[1][0])

”

哎，因为我没怎么用过TensorFlow，所以我再一次又一次麻烦GPT老师帮我换个Pytorch写的代码：、

GPT老师：😤😤😤

“

import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim

class NeuralNetworkAutoregressiveModel(nn.Module):
    def __init__(self, p, num_hidden_units, num_hidden_layers):
        super(NeuralNetworkAutoregressiveModel, self).__init__()
        self.layers = nn.ModuleList()
        self.layers.append(nn.Linear(p, num_hidden_units))
        self.layers.append(nn.ReLU())
        for _ in range(num_hidden_layers-1):
            self.layers.append(nn.Linear(num_hidden_units, num_hidden_units))
            self.layers.append(nn.ReLU())
        self.layers.append(nn.Linear(num_hidden_units, 1))

    def forward(self, x):
        for layer in self.layers:
            x = layer(x)
        return x

def neural_network_autoregressive_model(Y, p, num_hidden_units, num_hidden_layers, learning_rate, num_epochs):
    n = len(Y)
    X = np.zeros((n-p, p))
    for i in range(n-p):
        X[i] = Y[i:i+p]
    X = torch.FloatTensor(X)
    Y = torch.FloatTensor(Y[p:])

    model = NeuralNetworkAutoregressiveModel(p, num_hidden_units, num_hidden_layers)

    criterion = nn.MSELoss()
    optimizer = optim.Adam(model.parameters(), lr=learning_rate)

    for epoch in range(num_epochs):
        optimizer.zero_grad()
        output = model(X)
        loss = criterion(output.squeeze(), Y)
        loss.backward()
        optimizer.step()

    return model

# 示例数据
Y = np.array([1, 3, 5, 7, 9, 11])
p = 2
num_hidden_units = 10
num_hidden_layers = 2
learning_rate = 0.001
num_epochs = 1000

# 训练神经网络参数化的自回归模型
model = neural_network_autoregressive_model(Y, p, num_hidden_units, num_hidden_layers, learning_rate, num_epochs)

# 获取模型参数
weights = model.state_dict()

# 输出模型参数
print("神经网络参数化的自回归模型参数：")
for i in range(p):
    print("beta", i+1, ":", weights['layers.{}.weight'.format(2*i)][0])
print("beta0:", weights['layers.{}.bias'.format(2*num_hidden_layers)][0])

上述代码将使用PyTorch作为深度学习库，重新实现了神经网络参数化的自回归模型的训练过程。代码中使用了PyTorch的相关类（如nn.Module、nn.Linear、nn.ReLU、nn.MSELoss、optim.Adam等）来搭建模型和计算损失，并使用PyTorch的优化器来进行参数优化。最后，通过state_dict()方法获取模型参数，并输出模型参数。

”

鉴于GPT老师可能已经对懒得搭理我了，所以今天暂时学到这里，书中的后续，下次再接着打扰GPT老师。回去赶紧复习和跑代码。。。

AI编程学编程AI

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
深度生成模型阅读笔记（二）——自回归模型

对于参数β(l)，偏导数的计算为： ∂J/∂β(l) = -2Σ(H(L)(t)(Y(t) - β0 - Σβ(l)H(L)(t))) 对于权重矩阵W(l)，偏导数的计算为： ∂J/∂W(l) = -2Σ(∂J/∂H(L)(t) * ∂H(L)(t)/∂W(l)) 其中，∂J/∂H(L)(t)可以通过链式法则计算得到。自回归模型的数学推导过程就是这样。每个隐藏层的输出H(l)(t)都是过去时刻的值Y(t-1)、Y(t-2)、...、Y(t-p+1)的线性组合，通过权重参数β(l)和激活函数g(·)来计算。
复制链接

扫一扫