通透！十大时间序列技术 ！！

哈喽，我是cos大壮！~

今儿再来和大家聊聊时间序列以及时间序列相关的问题，。

之前总结过一部分，但是还是不够完整，今儿把常见的时间序列模型的内容完整的总结一次，在后续的几期内容中，会把每一种方法进行详细的推理。

涉及到的有：

• 自回归模型
• 移动平均模型
• 自回归移动平均模型
• 自回归积分移动平均模型
• 季节性自回归积分移动平均模型
• 指数平滑模型
• 长短期记忆网络
• Prophet 模型
• 贝叶斯结构时间序列模型
• 卡尔曼滤波

时间序列非常重要，时间序列技术能够捕捉数据的时间依赖性和趋势，为预测和决策提供关键支持。它在金融、气候预测等领域中尤为重要，有助于处理动态变化的数据模式。通过准确的时间序列建模，组织可以更好地优化资源和减少不确定性。

下面逐一介绍每种时间序列以及相关算法~

1. 自回归模型

原理介绍

自回归模型 (AR) 是时间序列分析中的一种线性回归模型，假设时间序列的当前值可以通过前一时刻及其之前的观测值的线性组合来预测。

核心公式

自回归模型的公式为：

其中， 是当前时间点的值， 是之前的值， 是自回归系数， 是误差项。

推导：自回归模型通过最小二乘法（OLS）估计自回归系数 ，即最小化误差项  的平方和。

优缺点和适用场景

优点：

• 适用于具有平稳性的数据。
• 简单易懂，模型可解释性强。

缺点：

• 仅适用于线性数据，无法处理非线性数据。
• 对于长记忆序列的处理效果差。

适用场景：适合平稳的时间序列，如金融数据、温度变化等。

代表案例

我们生成一个 AR(2) 模型的数据，其中  和 。

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# 设置种子以确保可重复性
np.random.seed(42)

# 模拟数据 AR(2) 模型
n = 1000
y = np.zeros(n)
epsilon = np.random.normal(0, 1, n)
phi = [0.5, -0.3]

# 生成时间序列
for t in range(2, n):
    y[t] = phi[0] * y[t-1] + phi[1] * y[t-2] + epsilon[t]

# 创建一个数据框架
df = pd.DataFrame({'Time': np.arange(n), 'Value': y})

# 绘制图像：时间序列图和自相关图
fig, ax = plt.subplots(1, 2, figsize=(12, 6), dpi=120)

# 时间序列图
ax[0].plot(df['Time'], df['Value'], color='blue')
ax[0].set_title('AR(2) Time Series')
ax[0].set_xlabel('Time')
ax[0].set_ylabel('Value')

# 自相关图
pd.plotting.autocorrelation_plot(df['Value'], ax=ax[1])
ax[1].set_title('Autocorrelation of AR(2) Series')

plt.tight_layout()
plt.show()

时间序列图：展示时间序列的变化趋势，确认数据的平稳性。

自相关图 (ACF 图)：自相关图展示了不同滞后时间下序列与其自身的相关性。我们使用自相关图来验证 AR 模型的合理性，若自相关性在某些滞后期显著，则表明该模型是合理的。

• 时间序列图：显示生成的 AR(2) 模型的随机时间序列，展示了数据随时间的波动。
• 自相关图：用于验证自回归模型的滞后效应。滞后期1和2处的显著自相关性验证了 AR(2) 模型的合理性。

2. 移动平均模型

原理介绍

移动平均模型 (MA) 假设时间序列的当前值是过去误差项的线性组合。与自回归模型不同，MA 模型强调的是误差项的影响，而非时间序列自身的历史值。

核心公式

移动平均模型的公式为：

其中， 是当前时间点的值， 是白噪声误差项， 是 MA 模型的系数。

推导：通过最大似然估计法（MLE）来估计  系数，最大化误差项的似然函数。

优缺点和适用场景

优点：

• 适合捕捉随机波动。
• 简单有效，适合数据噪声较大的情况。

缺点：

• 对长期依赖关系处理不好。
• 只能建模短期的依赖关系。

适用场景：适合随机波动较强的平稳时间序列。

代表案例

我们生成一个 MA(1) 模型的数据，其中 。

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# 设置种子
np.random.seed(42)

# 模拟数据 MA(1) 模型
n = 100
epsilon = np.random.normal(0, 1, n)
y = np.zeros(n)
theta = 0.6

# 生成时间序列
for t in range(1, n):
    y[t] = epsilon[t] + theta * epsilon[t-1]

# 创建数据框架
df = pd.DataFrame({'Time': np.arange(n), 'Value': y})

# 绘制图像：时间序列图和部分自相关图
fig, ax = plt.subplots(1, 2, figsize=(12, 6), dpi=120)

# 时间序列图
ax[0].plot(df['Time'], df['Value'], color='green')
ax[0].set_title('MA(1) Time Series')
ax[0].set_xlabel('Time')
ax[0].set_ylabel('Value')

# 部分自相关图
from statsmodels.graphics.tsaplots import plot_pacf
plot_pacf(df['Value'], ax=ax[1], lags=20)
ax[1].set_title('Partial Autocorrelation of MA(1) Series')

plt.tight_layout()
plt.show()

时间序列图：展示 MA(1) 模型生成的时间序列，观察随机波动的特征。

部分自相关图 (PACF 图)：部分自相关图展示了去除自回归成分后的滞后效应。我们使用部分自相关图来验证 MA 模型的合理性，滞后期为 1 的部分自相关性应该显著。

• 时间序列图：显示 MA(1) 模型生成的时间序列，揭示了模型的随机波动特性。
• 部分自相关图：用于验证 MA 模型的滞后效应。滞后期 1 处的显著相关性验证了 MA(1) 模型的合理性。

3. 自回归移动平均模型

原理介绍

ARMA 模型结合了自回归 (AR) 和移动平均 (MA) 的思想。它通过同时考虑时间序列的自身历史值（AR部分）和过去误差的线性组合（MA部分）来进行预测。

核心公式

ARMA(p, q) 模型的公式为：

其中， 是当前时间点的值， 是 AR 部分的系数， 是 MA 部分的系

数， 是误差项。

推导：ARMA 模型是 AR 和 MA 模型的组合。AR 部分通过最小化误差平方和 (OLS) 估计，MA 部分通过最大化误差项的似然函数 (MLE) 来估计。

优缺点和适用场景

优点：

• 结合了 AR 和 MA 的优点，适合复杂的平稳数据。
• 适合有短期记忆和随机波动的序列。

缺点：

• 对非平稳数据无法直接建模。
• 参数估计复杂度较高。

适用场景：适用于平稳的时间序列，如经济数据、气象数据等。

代表案例

我们生成一个 ARMA(2, 1) 模型的数据，其中 ，，。

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

# 设置种子
np.random.seed(42)

# 模拟数据 ARMA(2,1) 模型
n = 100
y = np.zeros(n)
epsilon = np.random.normal(0, 1, n)
phi = [0.5, -0.4]
theta = 0.3

# 生成时间序列
for t in range(2, n):
    y[t] = phi[0] * y[t-1] + phi[1] * y[t-2] + epsilon[t] + theta * epsilon[t-1]

# 创建数据框架
df = pd.DataFrame({'Time': np.arange(n), 'Value': y})

# 绘制图像：时间序列图和ACF图
fig, ax = plt.subplots(1, 2, figsize=(12, 6), dpi=120)

# 时间序列图
ax[0].plot(df['Time'], df['Value'], color='purple')
ax[0].set_title('ARMA(2,1) Time Series')
ax[0].set_xlabel('Time')
ax[0].set_ylabel('Value')

# 自相关图
pd.plotting.autocorrelation_plot(df['Value'], ax=ax[1])
ax[1].set_title('Autocorrelation of ARMA(2,1) Series')

plt.tight_layout()
plt.show()

时间序列图：观察 ARMA(2, 1) 模型生成的时间序列，显示其随机波动和趋势变化。

自相关图 (ACF 图)：通过自相关图来验证 ARMA 模型中的滞后效应。如果滞后期的自相关性显著，则可以说明模型的合理性。

• 时间序列图：展示了 ARMA 模型下时间序列的波动和趋势，反映了数据的复杂性。
• 自相关图：用于识别时间序列中不同滞后期的相关性，以验证 AR 和 MA 部分的合理性。

4. 自回归积分移动平均模型

原理介绍

ARIMA 模型是 ARMA 模型的扩展，增加了一个差分项，用于处理非平稳时间序列。差分的目的是去除时间序列中的趋势和季节性波动，使其平稳。

核心公式

ARIMA(p, d, q) 模型的公式为：

其中， 表示差分操作， 表示差分的阶数。

推导：首先对非平稳序列进行  阶差分，使其成为平稳序列。然后通过 ARMA 模型对差分后的序列进行建模。

优缺点和适用场景

优点：

• 适用于非平稳数据，能够捕捉趋势和季节性。
• 灵活强大，适合各种时间序列预测任务。

缺点：

• 差分操作可能导致信息丢失。
• 参数估计复杂，计算成本较高。

适用场景：适用于非平稳数据，如股票价格、经济指标等。

代表案例

我们生成一个 ARIMA(1, 1, 1) 模型的数据，其中 ，。

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from statsmodels.tsa.arima.model import ARIMA

# 设置种子
np.random.seed(42)

# 模拟数据 ARIMA(1,1,1) 模型
n = 100
y = np.zeros(n)
epsilon = np.random.normal(0, 1, n)
phi = 0.6
theta = 0.4

# 生成时间序列 (一阶差分)
for t in range(1, n):
    y[t] = phi * y[t-1] + epsilon[t] + theta * epsilon[t-1]

# 创建数据框架
df = pd.DataFrame({'Time': np.arange(n), 'Value': y})

# 绘制图像：原始序列与差分序列
fig, ax = plt.subplots(1, 2, figsize=(12, 6), dpi=120)

# 原始序列
ax[0].plot(df['Time'], df['Value'], color='red')
ax[0].set_title('ARIMA(1,1,1) Time Series')
ax[0].set_xlabel('Time')
ax[0].set_ylabel('Value')

# 一阶差分
diff_y = np.diff(df['Value'], n=1)
ax[1].plot(df['Time'][:-1], diff_y, color='blue')
ax[1].set_title('First Difference of ARIMA(1,1,1) Series')
ax[1].set_xlabel('Time')
ax[1].set_ylabel('Differenced Value')

plt.tight_layout()
plt.show()

原始序列图：展示生成的 ARIMA(1, 1, 1) 模型的时间序列，观察其非平稳特性。

一阶差分图：通过一阶差分图显示经过差分处理后的平稳时间序列，以展示差分操作的效果。

• 原始序列图：展示 ARIMA 模型中的原始时间序列，反映非平稳趋势。
• 差分序列图：展示差分后的时间序列，确认其是否达到平稳状态。

5. 季节性自回归积分移动平均模型 (SARIMA, Seasonal ARIMA)

原理介绍

SARIMA 模型扩展了 ARIMA 模型，增加了季节性成分，用于处理具有周期性和季节性变化的时间序列。它结合了非季节性成分和季节性成分。

核心公式

 模型的公式为：

其中， 表示季节性周期， 是滞后算子，非季节性和季节性成分相互作用。

推导：非季节性成分和季节性成分分别处理，首先通过差分去除趋势和季节性，然后应用 ARMA 模型对剩余部分进行建模。

优缺点和适用场景

优点：

• 能够捕捉季节性变化和趋势。
• 灵活处理季节性数据。

缺点：

• 参数复杂，模型拟合过程较慢。
• 需要手动指定季节性周期。

适用场景：适用于季节性数据，如气象数据、销售数据等。

代表案例

我们生成一个 SARIMA(1, 1, 1)(1, 1, 1, 12) 模型的数据，其中 ，季节性周期为 12。

import numpy as np


import matplotlib.pyplot as plt
import pandas as pd
from statsmodels.tsa.statespace.sarimax import SARIMAX

# 设置种子
np.random.seed(42)

# 模拟数据 SARIMA(1,1,1)(1,1,1,12) 模型
n = 120
seasonal_period = 12
y = np.zeros(n)
epsilon = np.random.normal(0, 1, n)
phi = 0.7
theta = 0.5
Phi = 0.3
Theta = 0.2

# 生成时间序列
for t in range(1, n):
    if t >= seasonal_period:
        y[t] = phi * y[t-1] + theta * epsilon[t-1] + Phi * y[t-seasonal_period] + Theta * epsilon[t-seasonal_period] + epsilon[t]
    else:
        y[t] = phi * y[t-1] + theta * epsilon[t-1] + epsilon[t]

# 创建数据框架
df = pd.DataFrame({'Time': np.arange(n), 'Value': y})

# 绘制图像：原始序列与季节性分解
fig, ax = plt.subplots(1, 2, figsize=(12, 6), dpi=120)

# 原始序列
ax[0].plot(df['Time'], df['Value'], color='orange')
ax[0].set_title('SARIMA(1,1,1)(1,1,1,12) Time Series')
ax[0].set_xlabel('Time')
ax[0].set_ylabel('Value')

# 季节性分解图
from statsmodels.tsa.seasonal import seasonal_decompose
result = seasonal_decompose(df['Value'], period=seasonal_period, model='additive')
result.seasonal.plot(ax=ax[1], color='blue')
ax[1].set_title('Seasonal Component of SARIMA Series')
ax[1].set_xlabel('Time')

plt.tight_layout()
plt.show()

原始序列图：展示 SARIMA 模型生成的时间序列，包含季节性成分和随机波动。

季节性分解图：分离季节性成分，显示时间序列中的周期性变化，帮助识别季节性波动。

• 原始序列图：展示 SARIMA 模型中的季节性时间序列，反映其周期性变化。
• 季节性分解图：用于分离季节性成分，验证模型是否能够捕捉到周期性波动。

6. 指数平滑模型

原理介绍

指数平滑模型 (ETS, Exponential Smoothing Model)是一类用于时间序列预测的模型，其基本思想是给不同时间点的观测值赋予不同的权重，越接近当前时间点的数据，权重越大。这种加权方式可以很好地平滑时间序列中的短期波动。ETS 模型可以处理趋势和季节性成分。

核心公式

简单指数平滑 (Simple Exponential Smoothing) 的公式为：

其中， 是平滑后的值， 是原始时间序列的当前值， 是平滑系数，。

加法模型的ETS(A,A,A) 的公式为：

其中：

•  是趋势成分，
•  是趋势变化率，
•  是季节性成分，

推导：ETS 模型通过平滑操作分别计算时间序列的长期趋势、短期波动和季节性影响。通过设定不同的平滑系数来调整对各个成分的权重。

优缺点和适用场景

优点：

• 适合短期预测，特别是对季节性和趋势进行建模。
• 可以灵活处理不同的趋势和季节性。

缺点：

• 长期预测效果差，无法很好处理复杂的非线性数据。

适用场景：适合平稳数据以及含有周期性和趋势成分的时间序列，如销量预测、温度变化等。

代表案例

我们生成一个带有季节性和趋势的时间序列，并使用 ETS 模型进行预测。

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from statsmodels.tsa.holtwinters import ExponentialSmoothing

# 设置种子
np.random.seed(42)

# 生成带有趋势和季节性的时间序列数据
n = 150
time = np.arange(n)
seasonal_period = 12
trend = 0.05 * time
seasonal = 10 * np.sin(2 * np.pi * time / seasonal_period)
noise = np.random.normal(0, 2, n)
y = 20 + trend + seasonal + noise

# 创建数据框架
df = pd.DataFrame({'Time': time, 'Value': y})

# 应用ETS模型（加法模型）
model = ExponentialSmoothing(df['Value'], seasonal='add', trend='add', seasonal_periods=seasonal_period)
fit = model.fit()

# 预测未来的值
forecast = fit.forecast(steps=24)

# 绘制原始数据和预测数据
plt.figure(figsize=(12, 6), dpi=120)
plt.plot(df['Time'], df['Value'], label='Original Series', color='blue')
plt.plot(np.arange(n, n + len(forecast)), forecast, label='Forecast', color='orange')
plt.axvline(x=n, color='gray', linestyle='--', label='Prediction Start')
plt.title('ETS Model - Additive Trend and Seasonality')
plt.xlabel('Time')
plt.ylabel('Value')
plt.legend()
plt.show()

时间序列预测图：展示原始时间序列以及基于 ETS 模型的预测结果，用于展示模型在处理趋势和季节性数据时的效果。

• 时间序列预测图：展示了原始时间序列的趋势、季节性和噪声，以及 ETS 模型对未来数据的预测效果。该图显示了模型对未来时间段的平滑预测。

7. 长短期记忆网络

原理介绍

长短期记忆网络 (LSTM) 是一种特殊的循环神经网络 (RNN)，适用于处理序列数据中的长期依赖问题。它通过引入记忆单元和门控机制，能够选择性地保留或遗忘先前时间点的信息，解决了传统 RNN 中的梯度消失问题。

核心公式

LSTM 的核心组件包括遗忘门、输入门和输出门，分别控制如何处理记忆状态。

1. 遗忘门：决定哪些信息需要被遗忘。

其中， 是 Sigmoid 激活函数， 是前一时刻的隐状态， 是当前输入， 是遗忘门的输出。

2. 输入门：决定哪些信息需要被写入记忆。

其中， 是输入门输出， 是候选记忆状态。

3. 输出门：决定如何产生当前时刻的隐状态。

其中， 是当前时刻的隐状态， 是输出门的输出。

优缺点和适用场景

优点：

• 能够捕捉长期依赖关系，适合处理复杂的时间序列。
• 在处理非线性、噪声大和多维度数据方面表现优秀。

缺点：

• 训练时间较长，计算复杂度高。
• 对大量数据敏感，容易过拟合。

适用场景：适合处理复杂的时间序列数据，如股票预测、语音识别、自然语言处理等。

代表案例

使用 PyTorch 实现 LSTM 进行时间序列预测的完整代码案例。

import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
from sklearn.preprocessing import MinMaxScaler
from torch.autograd import Variable

# 设置随机种子以确保可复现性
np.random.seed(42)
torch.manual_seed(42)

# 生成正弦波数据
def generate_sine_wave(sequence_length, num_samples):
    x = np.linspace(0, 100, num_samples)
    y = np.sin(x)
    return y

# 参数
sequence_length = 50  # 序列长度
num_samples = 1000    # 样本数量

# 生成数据
data = generate_sine_wave(sequence_length, num_samples)

# 可视化数据
plt.plot(data)
plt.title("Sine Wave")
plt.show()

# 数据归一化
scaler = MinMaxScaler(feature_range=(0, 1))
data_scaled = scaler.fit_transform(data.reshape(-1, 1))

# 创建时间序列数据集
def create_dataset(data, sequence_length):
    X, y = [], []
    for i in range(len(data) - sequence_length):
        X.append(data[i:i + sequence_length, 0])
        y.append(data[i + sequence_length, 0])
    return np.array(X), np.array(y)

# 创建输入输出数据
X, y = create_dataset(data_scaled, sequence_length)

# 转换为 PyTorch 张量
X = torch.from_numpy(X).float().unsqueeze(-1)  # shape: (samples, sequence_length, 1)
y = torch.from_numpy(y).float()  # shape: (samples,)


class LSTMModel(nn.Module):
    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
        super(LSTMModel, self).__init__()
        self.hidden_size = hidden_size
        self.num_layers = num_layers

        # 定义 LSTM 层
        self.lstm = nn.LSTM(input_size, hidden_size, num_layers, batch_first=True)

        # 定义全连接层
        self.fc = nn.Linear(hidden_size, output_size)

    def forward(self, x):
        # 初始化隐状态和细胞状态
        h0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)
        c0 = torch.zeros(self.num_layers, x.size(0), self.hidden_size)

        # 前向传播 LSTM 层
        out, _ = self.lstm(x, (h0, c0))

        # 取最后一个时间步的输出
        out = out[:, -1, :]

        # 全连接层输出
        out = self.fc(out)
        return out


# 定义模型参数
input_size = 1  # 输入特征数
hidden_size = 50  # LSTM 隐藏层单元数
output_size = 1  # 输出特征数
num_layers = 1  # LSTM 层数

# 初始化模型
model = LSTMModel(input_size, hidden_size, output_size, num_layers)

# 打印模型结构
print(model)

# 定义损失函数和优化器
criterion = nn.MSELoss()  # 使用均方误差作为损失函数
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# 划分训练集和测试集
train_size = int(len(X) * 0.8)
test_size = len(X) - train_size

X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

# 训练模型
num_epochs = 100
for epoch in range(num_epochs):
    model.train()

    # 前向传播
    outputs = model(X_train)
    loss = criterion(outputs, y_train)

    # 反向传播和优化
    optimizer.zero_grad()
    loss.backward()
    optimizer.step()

    # 打印损失
    if (epoch + 1) % 10 == 0:
        print(f'Epoch [{epoch + 1}/{num_epochs}], Loss: {loss.item():.4f}')


# 进行预测
model.eval()  # 设置为评估模式
with torch.no_grad():
    predicted = model(X_test)
    predicted = predicted.detach().numpy()

# 反归一化预测值
predicted = scaler.inverse_transform(predicted)

# 反归一化真实值
y_test = y_test.detach().numpy()
y_test = scaler.inverse_transform(y_test.reshape(-1, 1))

# 可视化结果
plt.plot(y_test, label='True Value')
plt.plot(predicted, label='Predicted Value')
plt.title('LSTM Time Series Prediction')
plt.legend()
plt.show()

使用了 PyTorch 来构建 LSTM 模型，用于处理时间序列预测问题。

模型包含一个 LSTM 层和一个全连接层，通过 Adam 优化器进行训练。

使用简单的正弦波时间序列作为数据示例，训练后的模型能够预测未来的值。

8. Prophet 模型

原理介绍

Prophet 是由 Facebook 开发的一种时间序列预测模型，基于加性模型，将趋势、季节性和假期影响分解为不同的成分，能够处理非线性时间序列。

核心公式

ophet 的基本公式为：

其中：

•  是趋势项，捕捉长期的变化趋势；
•  是季节性成分，捕捉周期性的波动；
•  是假期效应；
•  是噪声项。

Prophet 将趋势项建模为线性或非线性，季节性使用傅里叶级数表示，假期使用显式的日期列表。

优缺点和适用场景

优点：

• 易于调参，适合有明确周期性和节假日影响的时间序列。
• 可解释性强，易于使用。

缺点：

• 对于无明显季节性或趋势的时间序列效果较差。

适用场景：适合社交媒体分析、销量预测、网站流量预测等周期性数据。

代表案例

我们使用 prophet 模型对带有周期性的虚拟数据进行预测。

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from prophet import Prophet

# 生成带有趋势和季节性的时间序列数据
np.random.seed(42)
n = 200
time = pd.date_range(start='2022-01-01', periods=n, freq='D')
trend = np.linspace(0, 10, n)
seasonal = 5 * np.sin(2 * np.pi * np.arange(n) / 30)
noise = np.random.normal(0, 0.5, n)
y = 20 + trend + seasonal + noise

# 创建数据框架
df = pd.DataFrame({'ds': time, 'y': y})

# Prophet 模型
model = Prophet(yearly_seasonality=False, daily_seasonality=True)
model.fit(df)

# 预测未来30天
future = model.make_future_dataframe(periods=30)
forecast = model.predict(future)

# 绘制预测结果
model.plot(forecast)
plt.title('Prophet Time Series Prediction')
plt.show()

Prophet 预测图：展示 Prophet 模型对时间序列数据的预测，包括趋势和季节性成分的分解。

• Prophet 预测图：展示 Prophet 模型对未来数据的预测，以及趋势和季节性成分的分解，反映了该模型在处理带有季节性和假期影响的时间序列中的优势。

9. 贝叶斯结构时间序列模型

原理介绍

贝叶斯结构时间序列模型基于贝叶斯方法，能够结合不同的成分（趋势、季节性等）对时间序列进行分解。它在处理非线性时间序列和捕捉不确定性方面有独特优势。

核心公式

TS 模型的基本公式为：

其中：

•  是趋势成分；
•  是季节性成分；
•  是噪声项。

通过贝叶斯推断，BSTS 能够对不同的成分进行不确定性估计。

优缺点和适用场景

优点：

• 能捕捉不确定性，并对时间序列进行灵活的分解。
• 易于解释，适合多种不同类型的时间序列。

缺点：

• 对于大型数据集，计算开销较大。

适用场景：适合金融市场、销售数据、网络流量等具有复杂特性的时间序列。

代表案例

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from bsts import BSTS

# 生成虚拟数据
np.random.seed(42)
n = 100
time = np.arange(n)
trend = 0.1 * time
noise = np.random.normal(0, 1, n)
y = trend + noise

# BSTS 模型构建与拟合
model = BSTS()
model.fit(y)

# 预测未来值
predicted = model.predict(steps=10)

# 绘制预测结果
plt.figure(figsize=(10, 6))
plt.plot(time, y, label='Original Series')
plt.plot(np.arange(n, n+10), predicted, label='BSTS Prediction', color='orange')
plt.legend()
plt.title('BSTS Time Series Prediction')
plt.show()

时间序列预测图：展示了 BSTS 模型对未来时间序列的预测，结合了趋势和噪声成分，显示其在不确定性建模中的优势。

10. 卡尔曼滤波

原理介绍

卡尔曼滤波是一种递归滤波算法，广泛用于动态系统的状态估计，能够处理噪声干扰。它通过贝叶斯推断动态调整对当前状态的估计，适合平滑和预测时间序列。

核心公式

曼滤波的更新公式为：

预测：

更新：

优缺点和适用场景

优点：

• 适合实时更新和噪声抑制。
• 对动态系统建模效果良好。

缺点：

• 对于非线性系统的处理能力有限。

适用场景：适用于实时状态估计和动态系统建模，如导航系统、金融市场等。

代表案例

import numpy as np
import matplotlib.pyplot as plt
from pykalman import KalmanFilter

# 生成时间序列数据
n = 100
time = np.arange(n)
signal = np.sin(0.1 * time)
noise = np.random.normal(0, 0.1, n)
y = signal + noise

# 卡尔曼滤波
kf = KalmanFilter(initial_state_mean=0, n_dim_obs=1)
state_means, _ = kf.smooth(y)

# 绘制原始数据和卡尔曼滤波结果
plt.figure(figsize=(10, 6))
plt.plot(time, y, label='Noisy Signal')
plt.plot(time, state_means, label='Kalman Filtered', color='red')
plt.legend()
plt.title('Kalman Filter - Time Series Smoothing')
plt.show()

时间序列平滑图：展示原始噪声数据和经过卡尔曼滤波后的平滑结果。

• 时间序列平滑图：展示了卡尔曼滤波在处理带噪声的时间序列中的平滑效果，显示其在动态系统建模中的优越性。

最后

大家有问题可以直接在评论区留言即可~