【机器学习】时序数据与序列建模：理论与实践的全面指南

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

# 生成模拟时序数据
np.random.seed(42)
data = np.cumsum(np.random.randn(100))  # 随机生成累积序列

# 定义 ARIMA 模型
model = ARIMA(data, order=(1, 1, 1))
model_fit = model.fit()

# 预测
forecast = model_fit.forecast(steps=10)

# 可视化
plt.plot(data, label='Original Data')
plt.plot(range(len(data), len(data) + 10), forecast, label='Forecast', color='red')
plt.legend()
plt.show()

from fbprophet import Prophet
import pandas as pd

# 创建模拟数据
data = pd.DataFrame({'ds': pd.date_range(start='2020-01-01', periods=100, freq='D'),
                     'y': np.cumsum(np.random.randn(100))})

# 定义模型
model = Prophet()
model.fit(data)

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

# 可视化
model.plot(forecast)

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# 生成样本时序数据
def generate_data(sequence_length, num_samples):
    X, y = [], []
    for _ in range(num_samples):
        seq = np.sin(np.linspace(0, 10, sequence_length)) + np.random.normal(0, 0.1, sequence_length)
        X.append(seq[:-1])
        y.append(seq[1:])
    return np.array(X), np.array(y)

# 数据准备
sequence_length = 50
num_samples = 1000
X, y = generate_data(sequence_length, num_samples)
X = X.reshape((X.shape[0], X.shape[1], 1))

# 定义 LSTM 模型
model = Sequential([
    LSTM(50, activation='tanh', input_shape=(X.shape[1], X.shape[2])),
    Dense(1)
])

# 编译与训练
model.compile(optimizer='adam', loss='mse')
model.fit(X, y, epochs=20, batch_size=32, verbose=2)

# 预测
y_pred = model.predict(X[:5])
print("Predicted:", y_pred)

from tensorflow.keras.layers import MultiHeadAttention, Input, Dense, Dropout, LayerNormalization
from tensorflow.keras.models import Model

# Transformer Block
def transformer_encoder(inputs, head_size, num_heads, ff_dim, dropout=0):
    attention = MultiHeadAttention(num_heads=num_heads, key_dim=head_size)(inputs, inputs)
    attention = Dropout(dropout)(attention)
    attention = LayerNormalization(epsilon=1e-6)(attention + inputs)
    ff = Dense(ff_dim, activation="relu")(attention)
    ff = Dense(inputs.shape[-1])(ff)
    ff = Dropout(dropout)(ff)
    return LayerNormalization(epsilon=1e-6)(ff + attention)

# 定义输入
input_layer = Input(shape=(sequence_length - 1, 1))
transformer_block = transformer_encoder(input_layer, head_size=64, num_heads=2, ff_dim=128, dropout=0.1)
output_layer = Dense(1)(transformer_block)

# 定义模型
transformer_model = Model(inputs=input_layer, outputs=output_layer)
transformer_model.compile(optimizer='adam', loss='mse')

# 训练模型
transformer_model.fit(X, y, epochs=10, batch_size=32)

# 预测
transformer_pred = transformer_model.predict(X[:5])
print("Transformer Predicted:", transformer_pred)

from tensorflow.keras.layers import Masking

# 对输入数据随机掩码
masked_input = Masking(mask_value=0.0)(X)

# 定义编码器-解码器架构