Python实现时序数据预测的三种方法详解

import numpy as np

# 你的数据：年份和对应值
years = np.array([2023, 2024])
values = np.array([110, 100])

# 线性拟合：y = ax + b
a, b = np.polyfit(years, values, 1)

# 预测2025年
pred_2025 = a * 2025 + b
print(f"2025年预测值：{pred_2025:.1f}")
# 输出：2025年预测值：90.0

from prophet import Prophet
import pandas as pd

# 假设你有月度数据
df = pd.DataFrame({
    'ds': pd.date_range('2023-01-01', periods=24, freq='MS'),  # 24个月
    'y':  [110, 108, 105, 103, 100, 98, 95, 97, 99, 102, 100, 98,
           96, 94, 91, 89, 88, 90, 92, 95, 93, 91, 89, 87]
})

model = Prophet(yearly_seasonality=True, weekly_seasonality=False)
model.fit(df)

future = model.make_future_dataframe(periods=12, freq='MS')  # 预测未来12个月
forecast = model.predict(future)

print(forecast[['ds', 'yhat', 'yhat_lower', 'yhat_upper']].tail(12))
model.plot(forecast)

import pandas as pd
import numpy as np

# 原始不规则数据
data = [
    ('2024-03-01', 100),
    ('2024-07-15', 90),
    ('2024-11-20', 85),
]
df = pd.DataFrame(data, columns=['date', 'value'])
df['date'] = pd.to_datetime(df['date'])

# 方法1：重采样为季度（最简单）
df_quarterly = df.set_index('date').resample('Q').mean()
print(df_quarterly)

# 方法2：线性插值补成月度
df_monthly = df.set_index('date').resample('MS').interpolate(method='linear')
print(df_monthly)

# 补完之后，就可以用Prophet或ARIMA了

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from statsmodels.tsa.stattools import adfuller
# 加载示例数据（如航空旅客数）
df = pd.read_csv('airline_passengers.csv', parse_dates=['Month'], index_col='Month')
series = df['Passengers']
# 平稳性检验
result = adfuller(series)
print(f'ADF Statistic: {result[0]}, p-value: {result[1]}')  # p>0.05 非平稳
# 一阶差分
diff_series = series.diff().dropna()

from statsmodels.tsa.arima.model import ARIMA
from sklearn.metrics import mean_absolute_error

# 拆分训练/测试（前80%训练，后20%测试）
train = series[:int(0.8*len(series))]
test = series[int(0.8*len(series)):]

# 训练 ARIMA 模型 (示例参数，实际需调优)
model = ARIMA(train, order=(5,1,0))
fitted = model.fit()

# 预测
forecast = fitted.forecast(steps=len(test))
mae = mean_absolute_error(test, forecast)
print(f'MAE: {mae:.2f}')

from statsmodels.tsa.statespace.sarimax import SARIMAX

# 季节性周期 s=12（月度数据）
model = SARIMAX(train, order=(1,1,1), seasonal_order=(1,1,1,12))
fitted = model.fit()
forecast = fitted.forecast(steps=len(test))

from statsmodels.tsa.holtwinters import ExponentialSmoothing

model = ExponentialSmoothing(train, trend='add', seasonal='add', seasonal_periods=12)
fitted = model.fit()
forecast = fitted.forecast(len(test))

import xgboost as xgb
from sklearn.model_selection import train_test_split

# 构造特征：使用过去 12 个值作为特征
def create_features(data, lookback=12):
    X, y = [], []
    for i in range(lookback, len(data)):
        X.append(data[i-lookback:i])
        y.append(data[i])
    return np.array(X), np.array(y)

values = series.values
X, y = create_features(values, lookback=12)

# 按时间顺序划分（不能打乱）
split = int(0.8 * len(X))
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

# 训练 XGBoost 模型
model = xgb.XGBRegressor(n_estimators=100, learning_rate=0.01)
model.fit(X_train, y_train)
y_pred = model.predict(X_test)

# 评估
mae = mean_absolute_error(y_test, y_pred)
print(f'XGBoost MAE: {mae:.2f}')

from sklearn.preprocessing import MinMaxScaler
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense

# 数据归一化
scaler = MinMaxScaler()
scaled = scaler.fit_transform(series.values.reshape(-1,1))

# 构造监督学习样本 (lookback=12)
lookback = 12
X, y = [], []
for i in range(lookback, len(scaled)):
    X.append(scaled[i-lookback:i, 0])
    y.append(scaled[i, 0])
X, y = np.array(X), np.array(y)

# 重塑为 LSTM 输入格式 (样本数, 时间步长, 特征数)
X = X.reshape((X.shape[0], X.shape[1], 1))

# 划分训练/测试
split = int(0.8 * len(X))
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

# 构建 LSTM 模型
model = Sequential()
model.add(LSTM(50, activation='relu', input_shape=(lookback, 1)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')

# 训练
model.fit(X_train, y_train, epochs=50, batch_size=32, verbose=0)

# 预测并反归一化
y_pred_scaled = model.predict(X_test)
y_pred = scaler.inverse_transform(y_pred_scaled)
y_true = scaler.inverse_transform(y_test.reshape(-1,1))
mae = mean_absolute_error(y_true, y_pred)
print(f'LSTM MAE: {mae:.2f}')