1495 lines
58 KiB
Python
1495 lines
58 KiB
Python
import pandas as pd
|
||
import numpy as np
|
||
import torch
|
||
import torch.nn as nn
|
||
import torch.optim as optim
|
||
from torch.utils.data import DataLoader, TensorDataset
|
||
import matplotlib
|
||
# 设置matplotlib后端为Agg，适用于无头服务器环境
|
||
matplotlib.use('Agg')
|
||
import matplotlib.pyplot as plt
|
||
from sklearn.preprocessing import MinMaxScaler
|
||
from sklearn.model_selection import train_test_split
|
||
import os
|
||
from datetime import datetime
|
||
import json
|
||
import torch.serialization
|
||
|
||
# 添加tqdm的安全导入
|
||
try:
|
||
from tqdm import tqdm
|
||
TQDM_AVAILABLE = True
|
||
except ImportError:
|
||
# 如果没有tqdm，创建一个简单的替代品
|
||
TQDM_AVAILABLE = False
|
||
def tqdm(iterable, **kwargs):
|
||
# 简单的进度指示器
|
||
total = len(iterable) if hasattr(iterable, '__len__') else None
|
||
if total and kwargs.get('desc'):
|
||
print(f"{kwargs.get('desc')} - 共 {total} 步")
|
||
return iterable
|
||
|
||
# 添加MinMaxScaler到安全全局列表
|
||
torch.serialization.add_safe_globals(['sklearn.preprocessing._data.MinMaxScaler'])
|
||
|
||
# 设置随机种子以便结果可重现
|
||
|
||
# 导入模型模块
|
||
from models.data_utils import PharmacyDataset, create_dataset, evaluate_model
|
||
from models.transformer_model import TimeSeriesTransformer
|
||
from models.mlstm_model import MLSTMTransformer
|
||
from models.kan_model import KANForecaster
|
||
from models.utils import get_device, to_device, DeviceDataLoader
|
||
|
||
# 解决画图中文显示问题
|
||
plt.rcParams['font.sans-serif'] = ['SimHei']
|
||
plt.rcParams['axes.unicode_minus'] = False
|
||
|
||
# 获取设备（GPU或CPU）
|
||
device = get_device()
|
||
print(f"使用设备: {device}")
|
||
|
||
# 全局参数设置
|
||
look_back = 14 # 使用过去14天数据
|
||
T = 7 # 预测未来7天销量
|
||
epochs = 50 # 训练轮次
|
||
num_features = 8 # 输入特征数
|
||
embed_dim = 32 # 嵌入维度
|
||
dense_dim = 32 # 隐藏层神经元数
|
||
num_heads = 4 # 注意力头数
|
||
dropout_rate = 0.1 # 丢弃率
|
||
num_blocks = 3 # 编码器解码器数
|
||
learn_rate = 0.001 # 学习率
|
||
batch_size = 32 # 批大小
|
||
|
||
# 默认训练函数 - 使用mLSTM作为默认模型
|
||
def train_product_model(product_id, epochs=50):
|
||
"""
|
||
默认的产品销售预测模型训练函数，使用mLSTM作为默认模型
|
||
|
||
Args:
|
||
product_id: 产品ID
|
||
epochs: 训练轮次
|
||
|
||
Returns:
|
||
model: 训练好的模型
|
||
metrics: 模型评估指标
|
||
"""
|
||
return train_product_model_with_mlstm(product_id, epochs)
|
||
|
||
# 使用mLSTM模型训练的函数
|
||
def train_product_model_with_mlstm(product_id, epochs=50):
|
||
# 读取生成的药店销售数据
|
||
df = pd.read_excel('pharmacy_sales.xlsx')
|
||
|
||
# 筛选特定产品数据
|
||
product_df = df[df['product_id'] == product_id].sort_values('date')
|
||
product_name = product_df['product_name'].iloc[0]
|
||
|
||
print(f"使用mLSTM模型训练产品 '{product_name}' (ID: {product_id}) 的销售预测模型")
|
||
print(f"使用设备: {device}")
|
||
|
||
# 创建特征和目标变量
|
||
features = ['sales', 'price', 'weekday', 'month', 'is_holiday', 'is_weekend', 'is_promotion', 'temperature']
|
||
|
||
# 预处理数据
|
||
X = product_df[features].values
|
||
y = product_df[['sales']].values # 保持为二维数组
|
||
|
||
# 归一化数据
|
||
scaler_X = MinMaxScaler(feature_range=(0, 1))
|
||
scaler_y = MinMaxScaler(feature_range=(0, 1))
|
||
|
||
X_scaled = scaler_X.fit_transform(X)
|
||
y_scaled = scaler_y.fit_transform(y)
|
||
|
||
# 划分训练集和测试集（80% 训练，20% 测试）
|
||
train_size = int(len(X_scaled) * 0.8)
|
||
X_train, X_test = X_scaled[:train_size], X_scaled[train_size:]
|
||
y_train, y_test = y_scaled[:train_size], y_scaled[train_size:]
|
||
|
||
# 创建时间序列数据
|
||
trainX, trainY = create_dataset(X_train, y_train, look_back, T)
|
||
testX, testY = create_dataset(X_test, y_test, look_back, T)
|
||
|
||
# 转换为PyTorch的Tensor
|
||
trainX_tensor = torch.Tensor(trainX)
|
||
trainY_tensor = torch.Tensor(trainY)
|
||
testX_tensor = torch.Tensor(testX)
|
||
testY_tensor = torch.Tensor(testY)
|
||
|
||
# 创建数据加载器
|
||
train_dataset = PharmacyDataset(trainX_tensor, trainY_tensor)
|
||
test_dataset = PharmacyDataset(testX_tensor, testY_tensor)
|
||
|
||
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
|
||
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
|
||
|
||
# 将数据加载器包装到设备加载器中
|
||
train_loader = DeviceDataLoader(train_loader, device)
|
||
test_loader = DeviceDataLoader(test_loader, device)
|
||
|
||
# 初始化mLSTM结合Transformer模型
|
||
model = MLSTMTransformer(
|
||
num_features=num_features,
|
||
hidden_size=128,
|
||
mlstm_layers=1,
|
||
embed_dim=embed_dim,
|
||
dense_dim=dense_dim,
|
||
num_heads=num_heads,
|
||
dropout_rate=dropout_rate,
|
||
num_blocks=num_blocks,
|
||
output_sequence_length=T
|
||
)
|
||
|
||
# 将模型移动到设备上
|
||
model = model.to(device)
|
||
|
||
criterion = nn.MSELoss()
|
||
optimizer = optim.Adam(model.parameters(), lr=learn_rate)
|
||
|
||
# 训练模型
|
||
train_losses = []
|
||
test_losses = []
|
||
|
||
for epoch in range(epochs):
|
||
model.train()
|
||
epoch_loss = 0
|
||
for X_batch, y_batch in tqdm(train_loader, desc=f"Epoch {epoch+1}/{epochs}", leave=False):
|
||
# 前向传播
|
||
outputs = model(X_batch)
|
||
loss = criterion(outputs.squeeze(-1), y_batch)
|
||
|
||
# 反向传播和优化
|
||
optimizer.zero_grad()
|
||
loss.backward()
|
||
optimizer.step()
|
||
|
||
epoch_loss += loss.item()
|
||
|
||
# 计算训练损失
|
||
train_loss = epoch_loss / len(train_loader)
|
||
train_losses.append(train_loss)
|
||
|
||
# 在测试集上评估
|
||
model.eval()
|
||
test_loss = 0
|
||
with torch.no_grad():
|
||
for X_batch, y_batch in test_loader:
|
||
outputs = model(X_batch)
|
||
loss = criterion(outputs.squeeze(-1), y_batch)
|
||
test_loss += loss.item()
|
||
|
||
test_loss = test_loss / len(test_loader)
|
||
test_losses.append(test_loss)
|
||
|
||
if (epoch + 1) % 10 == 0:
|
||
print(f"Epoch {epoch+1}/{epochs}, Train Loss: {train_loss:.4f}, Test Loss: {test_loss:.4f}")
|
||
|
||
# 绘制损失曲线
|
||
plt.figure(figsize=(10, 5))
|
||
plt.plot(train_losses, label='训练损失')
|
||
plt.plot(test_losses, label='测试损失')
|
||
plt.title(f'{product_name} - mLSTM模型训练和测试损失')
|
||
plt.xlabel('Epoch')
|
||
plt.ylabel('Loss')
|
||
plt.legend()
|
||
plt.grid(True)
|
||
plt.savefig(f'{product_id}_mlstm_loss_curve.png')
|
||
|
||
# 生成预测
|
||
model.eval()
|
||
with torch.no_grad():
|
||
# 将测试数据移动到设备上
|
||
testX_device = to_device(testX_tensor, device)
|
||
y_pred_scaled = model(testX_device).squeeze(-1).cpu().numpy()
|
||
|
||
# 反归一化预测结果
|
||
y_pred = scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1)).reshape(y_pred_scaled.shape)
|
||
y_true = scaler_y.inverse_transform(testY.reshape(-1, 1)).reshape(testY.shape)
|
||
|
||
# 评估模型
|
||
metrics = evaluate_model(y_true.flatten(), y_pred.flatten())
|
||
print(f"\n{product_name} mLSTM模型评估指标:")
|
||
for metric, value in metrics.items():
|
||
print(f"{metric}: {value:.4f}")
|
||
|
||
# 绘制预测结果
|
||
plt.figure(figsize=(12, 6))
|
||
|
||
# 获取测试集的实际日期
|
||
test_dates = product_df['date'].iloc[train_size + look_back:train_size + look_back + len(y_true)].values
|
||
|
||
# 只绘制最后30天的预测
|
||
days_to_plot = min(30, len(y_true))
|
||
start_idx = max(0, len(y_true) - days_to_plot)
|
||
|
||
plt.plot(test_dates[start_idx:], y_true[start_idx:, 0], 'b-', label='实际销量')
|
||
plt.plot(test_dates[start_idx:], y_pred[start_idx:, 0], 'r--', label='mLSTM预测销量')
|
||
|
||
plt.title(f'{product_name} - mLSTM销量预测结果')
|
||
plt.xlabel('日期')
|
||
plt.ylabel('销量')
|
||
plt.legend()
|
||
plt.grid(True)
|
||
plt.xticks(rotation=45)
|
||
plt.tight_layout()
|
||
plt.savefig(f'{product_id}_mlstm_prediction.png')
|
||
|
||
# 保存预测结果到CSV
|
||
all_dates = []
|
||
num_samples = len(y_true)
|
||
for i in range(num_samples):
|
||
start_idx = train_size + i + look_back
|
||
dates = product_df['date'].iloc[start_idx : start_idx + T]
|
||
all_dates.extend(dates)
|
||
|
||
# 修正日期长度不匹配的问题
|
||
flat_y_true = y_true.flatten()
|
||
flat_y_pred = y_pred.flatten()
|
||
min_len = min(len(all_dates), len(flat_y_true))
|
||
|
||
results_df = pd.DataFrame({
|
||
'date': all_dates[:min_len],
|
||
'actual_sales': flat_y_true[:min_len],
|
||
'predicted_sales': flat_y_pred[:min_len]
|
||
})
|
||
results_df.to_csv(f'{product_id}_mlstm_prediction_results.csv', index=False)
|
||
|
||
print(f"\nmLSTM预测结果已保存到 {product_id}_mlstm_prediction_results.csv")
|
||
|
||
# 创建models目录和子目录
|
||
model_dir = 'models/mlstm'
|
||
os.makedirs(model_dir, exist_ok=True)
|
||
|
||
# 保存模型
|
||
model_path = os.path.join(model_dir, f'{product_id}_model.pt')
|
||
torch.save({
|
||
'model_state_dict': model.state_dict(),
|
||
'optimizer_state_dict': optimizer.state_dict(),
|
||
'train_loss': train_losses,
|
||
'test_loss': test_losses,
|
||
'scaler_X': scaler_X,
|
||
'scaler_y': scaler_y,
|
||
'features': features,
|
||
'look_back': look_back,
|
||
'T': T,
|
||
'model_type': 'mlstm'
|
||
}, model_path)
|
||
print(f"模型已成功保存到 {model_path}")
|
||
|
||
# 保存日志文件
|
||
log_path = os.path.join(model_dir, f'{product_id}_log.json')
|
||
log_data = {
|
||
'product_id': product_id,
|
||
'product_name': product_name,
|
||
'model_type': 'mlstm',
|
||
'training_completed_at': datetime.now().isoformat(),
|
||
'epochs': epochs,
|
||
'metrics': metrics,
|
||
'file_path': model_path
|
||
}
|
||
with open(log_path, 'w', encoding='utf-8') as f:
|
||
json.dump(log_data, f, indent=4, ensure_ascii=False)
|
||
print(f"训练日志已保存到 {log_path}")
|
||
|
||
return model, metrics
|
||
|
||
# 使用KAN模型训练的函数
|
||
def train_product_model_with_kan(product_id, epochs=50):
|
||
# 读取生成的药店销售数据
|
||
df = pd.read_excel('pharmacy_sales.xlsx')
|
||
|
||
# 筛选特定产品数据
|
||
product_df = df[df['product_id'] == product_id].sort_values('date')
|
||
product_name = product_df['product_name'].iloc[0]
|
||
|
||
print(f"使用KAN模型训练产品 '{product_name}' (ID: {product_id}) 的销售预测模型")
|
||
print(f"使用设备: {device}")
|
||
|
||
# 创建特征和目标变量
|
||
features = ['sales', 'price', 'weekday', 'month', 'is_holiday', 'is_weekend', 'is_promotion', 'temperature']
|
||
|
||
# 预处理数据
|
||
X = product_df[features].values
|
||
y = product_df[['sales']].values # 保持为二维数组
|
||
|
||
# 归一化数据
|
||
scaler_X = MinMaxScaler(feature_range=(0, 1))
|
||
scaler_y = MinMaxScaler(feature_range=(0, 1))
|
||
|
||
X_scaled = scaler_X.fit_transform(X)
|
||
y_scaled = scaler_y.fit_transform(y)
|
||
|
||
# 划分训练集和测试集（80% 训练，20% 测试）
|
||
train_size = int(len(X_scaled) * 0.8)
|
||
X_train, X_test = X_scaled[:train_size], X_scaled[train_size:]
|
||
y_train, y_test = y_scaled[:train_size], y_scaled[train_size:]
|
||
|
||
# 创建时间序列数据
|
||
trainX, trainY = create_dataset(X_train, y_train, look_back, T)
|
||
testX, testY = create_dataset(X_test, y_test, look_back, T)
|
||
|
||
# 转换为PyTorch的Tensor
|
||
trainX_tensor = torch.Tensor(trainX)
|
||
trainY_tensor = torch.Tensor(trainY)
|
||
testX_tensor = torch.Tensor(testX)
|
||
testY_tensor = torch.Tensor(testY)
|
||
|
||
# 创建数据加载器
|
||
train_dataset = PharmacyDataset(trainX_tensor, trainY_tensor)
|
||
test_dataset = PharmacyDataset(testX_tensor, testY_tensor)
|
||
|
||
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
|
||
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
|
||
|
||
# 将数据加载器包装到设备加载器中
|
||
train_loader = DeviceDataLoader(train_loader, device)
|
||
test_loader = DeviceDataLoader(test_loader, device)
|
||
|
||
# 初始化KAN模型
|
||
model = KANForecaster(
|
||
input_features=num_features,
|
||
hidden_sizes=[64, 128, 64],
|
||
output_size=1,
|
||
grid_size=5,
|
||
spline_order=3,
|
||
dropout_rate=dropout_rate,
|
||
output_sequence_length=T
|
||
)
|
||
|
||
# 将模型移动到设备上
|
||
model = model.to(device)
|
||
|
||
criterion = nn.MSELoss()
|
||
optimizer = optim.Adam(model.parameters(), lr=learn_rate)
|
||
|
||
# 训练模型
|
||
train_losses = []
|
||
test_losses = []
|
||
|
||
for epoch in range(epochs):
|
||
model.train()
|
||
epoch_loss = 0
|
||
for X_batch, y_batch in tqdm(train_loader, desc=f"Epoch {epoch+1}/{epochs}", leave=False):
|
||
# 前向传播
|
||
outputs = model(X_batch)
|
||
loss = criterion(outputs.squeeze(-1), y_batch)
|
||
|
||
# 反向传播和优化
|
||
optimizer.zero_grad()
|
||
loss.backward()
|
||
optimizer.step()
|
||
|
||
epoch_loss += loss.item()
|
||
|
||
# 计算训练损失
|
||
train_loss = epoch_loss / len(train_loader)
|
||
train_losses.append(train_loss)
|
||
|
||
# 在测试集上评估
|
||
model.eval()
|
||
test_loss = 0
|
||
with torch.no_grad():
|
||
for X_batch, y_batch in test_loader:
|
||
outputs = model(X_batch)
|
||
loss = criterion(outputs.squeeze(-1), y_batch)
|
||
test_loss += loss.item()
|
||
|
||
test_loss = test_loss / len(test_loader)
|
||
test_losses.append(test_loss)
|
||
|
||
if (epoch + 1) % 10 == 0:
|
||
print(f"Epoch {epoch+1}/{epochs}, Train Loss: {train_loss:.4f}, Test Loss: {test_loss:.4f}")
|
||
|
||
# 绘制损失曲线
|
||
plt.figure(figsize=(10, 5))
|
||
plt.plot(train_losses, label='训练损失')
|
||
plt.plot(test_losses, label='测试损失')
|
||
plt.title(f'{product_name} - KAN模型训练和测试损失')
|
||
plt.xlabel('Epoch')
|
||
plt.ylabel('Loss')
|
||
plt.legend()
|
||
plt.grid(True)
|
||
plt.savefig(f'{product_id}_kan_loss_curve.png')
|
||
|
||
# 生成预测
|
||
model.eval()
|
||
with torch.no_grad():
|
||
# 将测试数据移动到设备上
|
||
testX_device = to_device(testX_tensor, device)
|
||
y_pred_scaled = model(testX_device).squeeze(-1).cpu().numpy()
|
||
|
||
# 反归一化预测结果
|
||
y_pred = scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1)).reshape(y_pred_scaled.shape)
|
||
y_true = scaler_y.inverse_transform(testY.reshape(-1, 1)).reshape(testY.shape)
|
||
|
||
# 评估模型
|
||
metrics = evaluate_model(y_true.flatten(), y_pred.flatten())
|
||
print(f"\n{product_name} KAN模型评估指标:")
|
||
for metric, value in metrics.items():
|
||
print(f"{metric}: {value:.4f}")
|
||
|
||
# 绘制预测结果
|
||
plt.figure(figsize=(12, 6))
|
||
|
||
# 获取测试集的实际日期
|
||
test_dates = product_df['date'].iloc[train_size + look_back:train_size + look_back + len(y_true)].values
|
||
|
||
# 只绘制最后30天的预测
|
||
days_to_plot = min(30, len(y_true))
|
||
start_idx = max(0, len(y_true) - days_to_plot)
|
||
|
||
plt.plot(test_dates[start_idx:], y_true[start_idx:, 0], 'b-', label='实际销量')
|
||
plt.plot(test_dates[start_idx:], y_pred[start_idx:, 0], 'r--', label='KAN预测销量')
|
||
|
||
plt.title(f'{product_name} - KAN销量预测结果')
|
||
plt.xlabel('日期')
|
||
plt.ylabel('销量')
|
||
plt.legend()
|
||
plt.grid(True)
|
||
plt.xticks(rotation=45)
|
||
plt.tight_layout()
|
||
plt.savefig(f'{product_id}_kan_prediction.png')
|
||
|
||
# 保存预测结果到CSV
|
||
all_dates = []
|
||
num_samples = len(y_true)
|
||
for i in range(num_samples):
|
||
start_idx = train_size + i + look_back
|
||
dates = product_df['date'].iloc[start_idx : start_idx + T]
|
||
all_dates.extend(dates)
|
||
|
||
# 修正日期长度不匹配的问题
|
||
flat_y_true = y_true.flatten()
|
||
flat_y_pred = y_pred.flatten()
|
||
min_len = min(len(all_dates), len(flat_y_true))
|
||
|
||
results_df = pd.DataFrame({
|
||
'date': all_dates[:min_len],
|
||
'actual_sales': flat_y_true[:min_len],
|
||
'predicted_sales': flat_y_pred[:min_len]
|
||
})
|
||
results_df.to_csv(f'{product_id}_kan_prediction_results.csv', index=False)
|
||
|
||
print(f"\nKAN预测结果已保存到 {product_id}_kan_prediction_results.csv")
|
||
|
||
# 创建models目录和子目录
|
||
model_dir = 'models/kan'
|
||
os.makedirs(model_dir, exist_ok=True)
|
||
|
||
# 保存模型
|
||
model_path = os.path.join(model_dir, f'{product_id}_model.pt')
|
||
torch.save({
|
||
'model_state_dict': model.state_dict(),
|
||
'optimizer_state_dict': optimizer.state_dict(),
|
||
'train_loss': train_losses,
|
||
'test_loss': test_losses,
|
||
'scaler_X': scaler_X,
|
||
'scaler_y': scaler_y,
|
||
'features': features,
|
||
'look_back': look_back,
|
||
'T': T,
|
||
'model_type': 'kan'
|
||
}, model_path)
|
||
print(f"模型已成功保存到 {model_path}")
|
||
|
||
# 保存日志文件
|
||
log_path = os.path.join(model_dir, f'{product_id}_log.json')
|
||
log_data = {
|
||
'product_id': product_id,
|
||
'product_name': product_name,
|
||
'model_type': 'kan',
|
||
'training_completed_at': datetime.now().isoformat(),
|
||
'epochs': epochs,
|
||
'metrics': metrics,
|
||
'file_path': model_path
|
||
}
|
||
with open(log_path, 'w', encoding='utf-8') as f:
|
||
json.dump(log_data, f, indent=4, ensure_ascii=False)
|
||
print(f"训练日志已保存到 {log_path}")
|
||
|
||
return model, metrics
|
||
|
||
# 使用Transformer模型训练的函数
|
||
def train_product_model_with_transformer(product_id, epochs=50):
|
||
# 读取生成的药店销售数据
|
||
df = pd.read_excel('pharmacy_sales.xlsx')
|
||
|
||
# 筛选特定产品数据
|
||
product_df = df[df['product_id'] == product_id].sort_values('date')
|
||
product_name = product_df['product_name'].iloc[0]
|
||
|
||
print(f"使用Transformer模型训练产品 '{product_name}' (ID: {product_id}) 的销售预测模型")
|
||
print(f"使用设备: {device}")
|
||
|
||
# 创建特征和目标变量
|
||
features = ['sales', 'price', 'weekday', 'month', 'is_holiday', 'is_weekend', 'is_promotion', 'temperature']
|
||
|
||
# 预处理数据
|
||
X = product_df[features].values
|
||
y = product_df[['sales']].values # 保持为二维数组
|
||
|
||
# 归一化数据
|
||
scaler_X = MinMaxScaler(feature_range=(0, 1))
|
||
scaler_y = MinMaxScaler(feature_range=(0, 1))
|
||
|
||
X_scaled = scaler_X.fit_transform(X)
|
||
y_scaled = scaler_y.fit_transform(y)
|
||
|
||
# 划分训练集和测试集（80% 训练，20% 测试）
|
||
train_size = int(len(X_scaled) * 0.8)
|
||
X_train, X_test = X_scaled[:train_size], X_scaled[train_size:]
|
||
y_train, y_test = y_scaled[:train_size], y_scaled[train_size:]
|
||
|
||
# 创建时间序列数据
|
||
trainX, trainY = create_dataset(X_train, y_train, look_back, T)
|
||
testX, testY = create_dataset(X_test, y_test, look_back, T)
|
||
|
||
# 转换为PyTorch的Tensor
|
||
trainX_tensor = torch.Tensor(trainX)
|
||
trainY_tensor = torch.Tensor(trainY)
|
||
testX_tensor = torch.Tensor(testX)
|
||
testY_tensor = torch.Tensor(testY)
|
||
|
||
# 创建数据加载器
|
||
train_dataset = PharmacyDataset(trainX_tensor, trainY_tensor)
|
||
test_dataset = PharmacyDataset(testX_tensor, testY_tensor)
|
||
|
||
train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
|
||
test_loader = DataLoader(test_dataset, batch_size=batch_size, shuffle=False)
|
||
|
||
# 将数据加载器包装到设备加载器中
|
||
train_loader = DeviceDataLoader(train_loader, device)
|
||
test_loader = DeviceDataLoader(test_loader, device)
|
||
|
||
# 初始化Transformer模型
|
||
model = TimeSeriesTransformer(
|
||
num_features=num_features,
|
||
d_model=embed_dim,
|
||
nhead=num_heads,
|
||
num_encoder_layers=num_blocks,
|
||
dim_feedforward=dense_dim,
|
||
dropout=dropout_rate,
|
||
output_sequence_length=T
|
||
)
|
||
|
||
# 将模型移动到设备上
|
||
model = model.to(device)
|
||
|
||
criterion = nn.MSELoss()
|
||
optimizer = optim.Adam(model.parameters(), lr=learn_rate)
|
||
|
||
# 训练模型
|
||
train_losses = []
|
||
test_losses = []
|
||
|
||
for epoch in range(epochs):
|
||
model.train()
|
||
epoch_loss = 0
|
||
for X_batch, y_batch in tqdm(train_loader, desc=f"Epoch {epoch+1}/{epochs}", leave=False):
|
||
# 前向传播
|
||
outputs = model(X_batch)
|
||
loss = criterion(outputs.squeeze(-1), y_batch)
|
||
|
||
# 反向传播和优化
|
||
optimizer.zero_grad()
|
||
loss.backward()
|
||
optimizer.step()
|
||
|
||
epoch_loss += loss.item()
|
||
|
||
# 计算训练损失
|
||
train_loss = epoch_loss / len(train_loader)
|
||
train_losses.append(train_loss)
|
||
|
||
# 在测试集上评估
|
||
model.eval()
|
||
test_loss = 0
|
||
with torch.no_grad():
|
||
for X_batch, y_batch in test_loader:
|
||
outputs = model(X_batch)
|
||
loss = criterion(outputs.squeeze(-1), y_batch)
|
||
test_loss += loss.item()
|
||
|
||
test_loss = test_loss / len(test_loader)
|
||
test_losses.append(test_loss)
|
||
|
||
if (epoch + 1) % 10 == 0:
|
||
print(f"Epoch {epoch+1}/{epochs}, Train Loss: {train_loss:.4f}, Test Loss: {test_loss:.4f}")
|
||
|
||
# 绘制损失曲线
|
||
plt.figure(figsize=(10, 5))
|
||
plt.plot(train_losses, label='训练损失')
|
||
plt.plot(test_losses, label='测试损失')
|
||
plt.title(f'{product_name} - Transformer模型训练和测试损失')
|
||
plt.xlabel('Epoch')
|
||
plt.ylabel('Loss')
|
||
plt.legend()
|
||
plt.grid(True)
|
||
plt.savefig(f'{product_id}_transformer_loss_curve.png')
|
||
|
||
# 生成预测
|
||
model.eval()
|
||
with torch.no_grad():
|
||
# 将测试数据移动到设备上
|
||
testX_device = to_device(testX_tensor, device)
|
||
y_pred_scaled = model(testX_device).squeeze(-1).cpu().numpy()
|
||
|
||
# 反归一化预测结果
|
||
y_pred = scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1)).reshape(y_pred_scaled.shape)
|
||
y_true = scaler_y.inverse_transform(testY.reshape(-1, 1)).reshape(testY.shape)
|
||
|
||
# 评估模型
|
||
metrics = evaluate_model(y_true.flatten(), y_pred.flatten())
|
||
print(f"\n{product_name} Transformer模型评估指标:")
|
||
for metric, value in metrics.items():
|
||
print(f"{metric}: {value:.4f}")
|
||
|
||
# 绘制预测结果
|
||
plt.figure(figsize=(12, 6))
|
||
|
||
# 获取测试集的实际日期
|
||
test_dates = product_df['date'].iloc[train_size + look_back:train_size + look_back + len(y_true)].values
|
||
|
||
# 只绘制最后30天的预测
|
||
days_to_plot = min(30, len(y_true))
|
||
start_idx = max(0, len(y_true) - days_to_plot)
|
||
|
||
plt.plot(test_dates[start_idx:], y_true[start_idx:, 0], 'b-', label='实际销量')
|
||
plt.plot(test_dates[start_idx:], y_pred[start_idx:, 0], 'r--', label='Transformer预测销量')
|
||
|
||
plt.title(f'{product_name} - Transformer销量预测结果')
|
||
plt.xlabel('日期')
|
||
plt.ylabel('销量')
|
||
plt.legend()
|
||
plt.grid(True)
|
||
plt.xticks(rotation=45)
|
||
plt.tight_layout()
|
||
|
||
# 强制重新绘制图表
|
||
fig.canvas.draw()
|
||
|
||
# 将预测起始日期和预测时长添加到文件名中
|
||
start_date_str = start_date_obj.strftime('%Y%m%d')
|
||
|
||
# 保存和显示图表
|
||
forecast_chart = f'{product_id}_transformer_forecast_{start_date_str}_days{T}.png'
|
||
plt.savefig(forecast_chart)
|
||
print(f"预测图表已保存为: {forecast_chart}")
|
||
|
||
# 关闭图表以释放内存
|
||
plt.close()
|
||
|
||
# 创建预测日期范围
|
||
last_date = product_df['date'].iloc[-1]
|
||
future_dates = pd.date_range(start=last_date + pd.Timedelta(days=1), periods=T, freq='D')
|
||
|
||
# 创建预测结果DataFrame - 确保长度一致
|
||
# 使用测试集的最后T个预测作为未来预测
|
||
future_predictions = y_pred[-1, :T].flatten() # 取最后一个样本的预测序列
|
||
|
||
# 确保长度匹配
|
||
if len(future_dates) != len(future_predictions):
|
||
# 如果长度不匹配，调整future_predictions的长度
|
||
future_predictions = future_predictions[:len(future_dates)]
|
||
|
||
predictions_df = pd.DataFrame({
|
||
'date': future_dates,
|
||
'product_id': product_id,
|
||
'product_name': product_name,
|
||
'predicted_sales': future_predictions
|
||
})
|
||
|
||
print(f"\n{product_name} 未来 {T} 天销售预测 (使用Transformer模型):")
|
||
print(predictions_df[['date', 'predicted_sales']])
|
||
|
||
# 创建预测结果目录
|
||
output_dir = f'predictions/transformer/{product_id}'
|
||
os.makedirs(output_dir, exist_ok=True)
|
||
|
||
# 可视化预测结果
|
||
try:
|
||
# 1. 创建预测图表
|
||
forecast_fig, forecast_ax = plt.subplots(figsize=(12, 6))
|
||
|
||
# 显示历史数据和预测数据
|
||
history_days = 30 # 显示最近30天的历史数据
|
||
|
||
# 只选择预测起始日期之前30天的历史数据，而不是全部历史数据
|
||
history_end_date = start_date_obj - pd.Timedelta(days=1) # 预测起始日期的前一天
|
||
history_start_date = history_end_date - pd.Timedelta(days=history_days) # 向前推30天
|
||
|
||
# 过滤历史数据，只保留这个日期范围内的数据
|
||
history_df = product_df[(product_df['date'] >= history_start_date) &
|
||
(product_df['date'] <= history_end_date)][['date', 'sales']].copy()
|
||
|
||
if history_df.empty:
|
||
print(f"警告: 在日期范围 {history_start_date} 到 {history_end_date} 内没有历史数据")
|
||
# 如果没有符合条件的历史数据，就使用最近的数据
|
||
history_df = product_df.iloc[-min(history_days, len(product_df)):][['date', 'sales']].copy()
|
||
|
||
print(f"历史数据日期范围: {history_df['date'].min()} 到 {history_df['date'].max()}")
|
||
print(f"预测数据日期范围: {future_dates.min()} 到 {future_dates.max()}")
|
||
print(f"预测起始日期: {start_date_obj.strftime('%Y-%m-%d')}")
|
||
|
||
# 绘制历史数据
|
||
forecast_ax.plot(history_df['date'].values, history_df['sales'].values, 'b-', label='历史销量')
|
||
|
||
# 绘制预测数据，确保使用future_dates作为x轴
|
||
forecast_ax.plot(future_dates, future_predictions, 'r--', label=f'{model_type}预测销量')
|
||
|
||
# 强制X轴从预测起始日期的前30天开始（如果有历史数据）到预测结束日期
|
||
date_min = start_date_obj - pd.Timedelta(days=30)
|
||
date_max = future_dates.max() + pd.Timedelta(days=2)
|
||
|
||
print(f"设置X轴范围: {date_min} 到 {date_max}")
|
||
forecast_ax.set_xlim(date_min, date_max)
|
||
|
||
forecast_ax.set_title(f'{product_name} - {model_type}销量预测 (从{start_date_obj.strftime("%Y-%m-%d")}开始,预测{T}天)')
|
||
forecast_ax.set_xlabel('日期')
|
||
forecast_ax.set_ylabel('销量')
|
||
forecast_ax.legend()
|
||
forecast_ax.grid(True)
|
||
plt.xticks(rotation=45)
|
||
plt.tight_layout()
|
||
|
||
# 强制重新绘制图表
|
||
forecast_fig.canvas.draw()
|
||
|
||
# 将预测起始日期和预测时长添加到文件名中
|
||
start_date_str = start_date_obj.strftime('%Y%m%d')
|
||
|
||
# 保存预测图表
|
||
forecast_chart = f'{output_dir}/forecast_{start_date_str}_days{T}.png'
|
||
plt.savefig(forecast_chart)
|
||
print(f"预测图表已保存为: {forecast_chart}")
|
||
|
||
# 关闭图表以释放内存
|
||
plt.close(forecast_fig)
|
||
|
||
# 2. 创建历史趋势图表
|
||
try:
|
||
print("\n开始生成历史趋势图...")
|
||
history_fig, history_ax = plt.subplots(figsize=(12, 6))
|
||
|
||
# 获取预测起始日期
|
||
current_year = start_date_obj.year
|
||
current_month = start_date_obj.month
|
||
current_day = start_date_obj.day
|
||
print(f"预测起始日期: {start_date_obj}")
|
||
|
||
# 计算同期日期范围（前3天和后3天，共7天）
|
||
days_before = 3
|
||
days_after = 3
|
||
date_range_start = start_date_obj - pd.Timedelta(days=days_before)
|
||
date_range_end = start_date_obj + pd.Timedelta(days=days_after)
|
||
|
||
# 计算去年同期日期范围
|
||
last_year_start = date_range_start.replace(year=date_range_start.year-1)
|
||
last_year_end = date_range_end.replace(year=date_range_end.year-1)
|
||
|
||
# 计算上月同期日期范围
|
||
if date_range_start.month > 1:
|
||
last_month_start = date_range_start.replace(month=date_range_start.month-1)
|
||
last_month_end = date_range_end.replace(month=date_range_end.month-1)
|
||
else:
|
||
# 如果是1月，则转到上一年的12月
|
||
last_month_start = date_range_start.replace(year=date_range_start.year-1, month=12)
|
||
last_month_end = date_range_end.replace(year=date_range_end.year-1, month=12)
|
||
|
||
print(f"当前日期范围: {date_range_start} 到 {date_range_end}")
|
||
print(f"去年同期范围: {last_year_start} 到 {last_year_end}")
|
||
print(f"上月同期范围: {last_month_start} 到 {last_month_end}")
|
||
|
||
# 查找对应日期范围的数据
|
||
current_period_data = product_df[
|
||
(product_df['date'] >= date_range_start) &
|
||
(product_df['date'] <= date_range_end)
|
||
]
|
||
print(f"当前期间数据点数: {len(current_period_data)}")
|
||
|
||
last_year_period_data = product_df[
|
||
(product_df['date'] >= last_year_start) &
|
||
(product_df['date'] <= last_year_end)
|
||
]
|
||
print(f"去年同期数据点数: {len(last_year_period_data)}")
|
||
|
||
last_month_period_data = product_df[
|
||
(product_df['date'] >= last_month_start) &
|
||
(product_df['date'] <= last_month_end)
|
||
]
|
||
print(f"上月同期数据点数: {len(last_month_period_data)}")
|
||
|
||
# 绘制曲线图
|
||
has_data = False
|
||
|
||
if not current_period_data.empty:
|
||
has_data = True
|
||
# 确保日期升序排序
|
||
current_period_data = current_period_data.sort_values('date')
|
||
# 生成相对天数（以date_range_start为基准）
|
||
current_period_data['day_offset'] = (current_period_data['date'] - date_range_start).dt.days
|
||
print(f"当前期间日期: {current_period_data['date'].tolist()}")
|
||
print(f"当前期间相对天数: {current_period_data['day_offset'].tolist()}")
|
||
print(f"当前期间销量: {current_period_data['sales'].tolist()}")
|
||
|
||
history_ax.plot(
|
||
current_period_data['day_offset'],
|
||
current_period_data['sales'],
|
||
'r-',
|
||
marker='o',
|
||
linewidth=2,
|
||
label=f"当前期间 ({date_range_start.strftime('%Y-%m-%d')} 到 {date_range_end.strftime('%Y-%m-%d')})"
|
||
)
|
||
|
||
# 标记预测起始日期
|
||
current_center_point = current_period_data[current_period_data['date'] == start_date_obj]
|
||
if not current_center_point.empty:
|
||
history_ax.scatter(
|
||
current_center_point['day_offset'],
|
||
current_center_point['sales'],
|
||
color='red',
|
||
s=100,
|
||
marker='*',
|
||
zorder=10,
|
||
label=f"预测起始日 ({start_date_obj.strftime('%Y-%m-%d')})"
|
||
)
|
||
|
||
if not last_year_period_data.empty:
|
||
has_data = True
|
||
# 确保日期升序排序
|
||
last_year_period_data = last_year_period_data.sort_values('date')
|
||
last_year_period_data['day_offset'] = (last_year_period_data['date'] - last_year_start).dt.days
|
||
print(f"去年同期日期: {last_year_period_data['date'].tolist()}")
|
||
print(f"去年同期相对天数: {last_year_period_data['day_offset'].tolist()}")
|
||
print(f"去年同期销量: {last_year_period_data['sales'].tolist()}")
|
||
|
||
history_ax.plot(
|
||
last_year_period_data['day_offset'],
|
||
last_year_period_data['sales'],
|
||
'b-',
|
||
marker='s',
|
||
linewidth=2,
|
||
label=f"去年同期 ({last_year_start.strftime('%Y-%m-%d')} 到 {last_year_end.strftime('%Y-%m-%d')})"
|
||
)
|
||
|
||
if not last_month_period_data.empty:
|
||
has_data = True
|
||
# 确保日期升序排序
|
||
last_month_period_data = last_month_period_data.sort_values('date')
|
||
last_month_period_data['day_offset'] = (last_month_period_data['date'] - last_month_start).dt.days
|
||
print(f"上月同期日期: {last_month_period_data['date'].tolist()}")
|
||
print(f"上月同期相对天数: {last_month_period_data['day_offset'].tolist()}")
|
||
print(f"上月同期销量: {last_month_period_data['sales'].tolist()}")
|
||
|
||
history_ax.plot(
|
||
last_month_period_data['day_offset'],
|
||
last_month_period_data['sales'],
|
||
'g-',
|
||
marker='^',
|
||
linewidth=2,
|
||
label=f"上月同期 ({last_month_start.strftime('%Y-%m-%d')} 到 {last_month_end.strftime('%Y-%m-%d')})"
|
||
)
|
||
|
||
# 设置X轴标签为相对天数
|
||
days_labels = list(range(7))
|
||
days_offsets = list(range(7))
|
||
day_names = [(date_range_start + pd.Timedelta(days=d)).strftime('%m-%d') for d in range(7)]
|
||
|
||
history_ax.set_xticks(days_offsets)
|
||
history_ax.set_xticklabels(day_names)
|
||
|
||
# 添加垂直参考线标记预测起始日
|
||
history_ax.axvline(x=days_before, color='gray', linestyle='--', alpha=0.5)
|
||
|
||
# 美化图表
|
||
history_ax.set_title(f'{product_name} - 同期销量趋势对比 (7天)')
|
||
history_ax.set_xlabel('日期')
|
||
history_ax.set_ylabel('销量')
|
||
history_ax.grid(True, linestyle='--', alpha=0.7)
|
||
history_ax.legend(loc='best')
|
||
|
||
# 如果所有数据集都为空，显示提示
|
||
if not has_data:
|
||
history_ax.text(0.5, 0.5, '没有找到可比较的同期数据',
|
||
horizontalalignment='center', verticalalignment='center',
|
||
transform=history_ax.transAxes, fontsize=14)
|
||
|
||
plt.tight_layout()
|
||
|
||
# 强制重新绘制图表
|
||
history_fig.canvas.draw()
|
||
|
||
# 保存历史趋势图表
|
||
history_chart = f'{output_dir}/history_{start_date_str}.png'
|
||
plt.savefig(history_chart)
|
||
print(f"历史趋势图表已保存为: {history_chart}")
|
||
|
||
# 关闭图表以释放内存
|
||
plt.close(history_fig)
|
||
|
||
except Exception as e:
|
||
import traceback
|
||
print(f"生成历史趋势图时出错: {e}")
|
||
traceback.print_exc()
|
||
history_chart = None
|
||
|
||
# 创建一个包含历史和预测数据的完整DataFrame供CSV导出和API返回
|
||
history_df['data_type'] = '历史销量'
|
||
|
||
predictions_df = pd.DataFrame({
|
||
'date': future_dates,
|
||
'sales': y_pred,
|
||
'data_type': '预测销量',
|
||
'product_id': product_id,
|
||
'product_name': product_name
|
||
})
|
||
|
||
# 合并历史和预测数据
|
||
complete_df = pd.concat([
|
||
history_df[['date', 'sales', 'data_type']].assign(product_id=product_id, product_name=product_name),
|
||
predictions_df
|
||
]).sort_values('date')
|
||
|
||
except Exception as e:
|
||
import traceback
|
||
print(f"生成预测图表时出错: {e}")
|
||
traceback.print_exc()
|
||
forecast_chart = None
|
||
history_chart = None
|
||
|
||
# 出错时仍然创建预测数据
|
||
predictions_df = pd.DataFrame({
|
||
'date': future_dates,
|
||
'sales': y_pred,
|
||
'data_type': '预测销量',
|
||
'product_id': product_id,
|
||
'product_name': product_name
|
||
})
|
||
complete_df = predictions_df
|
||
|
||
# 保存预测结果到CSV
|
||
try:
|
||
forecast_csv = f'{output_dir}/forecast_{start_date_str}_days{T}.csv'
|
||
complete_df.to_csv(forecast_csv, index=False)
|
||
print(f"预测结果已保存到: {forecast_csv}")
|
||
except Exception as e:
|
||
print(f"保存CSV文件时出错: {e}")
|
||
forecast_csv = None
|
||
|
||
# 返回文件路径信息和预测数据
|
||
result = {
|
||
'predictions_df': complete_df, # 返回包含历史数据的完整DataFrame
|
||
'chart_path': forecast_chart,
|
||
'history_chart_path': history_chart,
|
||
'csv_path': forecast_csv
|
||
}
|
||
|
||
# 保存模型
|
||
model_dir = f'models/transformer'
|
||
os.makedirs(model_dir, exist_ok=True)
|
||
model_path = f'{model_dir}/{product_id}_model.pt'
|
||
|
||
# 保存模型和相关数据
|
||
checkpoint = {
|
||
'model_state_dict': model.state_dict(),
|
||
'optimizer_state_dict': optimizer.state_dict(),
|
||
'scaler_X': scaler_X,
|
||
'scaler_y': scaler_y,
|
||
'metrics': metrics,
|
||
'epochs': epochs,
|
||
'look_back': look_back,
|
||
'T': T,
|
||
'features': features
|
||
}
|
||
|
||
torch.save(checkpoint, model_path)
|
||
print(f"模型已保存到 {model_path}")
|
||
|
||
# 保存训练日志
|
||
log_path = f'{model_dir}/{product_id}_log.json'
|
||
log_data = {
|
||
'product_id': product_id,
|
||
'product_name': product_name,
|
||
'model_type': 'transformer',
|
||
'training_completed_at': datetime.now().isoformat(),
|
||
'epochs': epochs,
|
||
'metrics': metrics,
|
||
'file_path': model_path
|
||
}
|
||
with open(log_path, 'w', encoding='utf-8') as f:
|
||
json.dump(log_data, f, indent=4, ensure_ascii=False)
|
||
print(f"训练日志已保存到 {log_path}")
|
||
|
||
return model, metrics
|
||
|
||
# 加载模型并进行预测的函数
|
||
def load_model_and_predict(product_id, model_type, future_days=7, start_date=None):
|
||
"""
|
||
加载指定类型的模型并进行未来销量预测
|
||
|
||
Args:
|
||
product_id: 产品ID
|
||
model_type: 模型类型，可选 'mlstm', 'kan', 'transformer'
|
||
future_days: 预测未来天数，默认7天
|
||
start_date: 预测起始日期，格式为'YYYY-MM-DD'，默认为None表示使用数据集最后日期的下一天
|
||
"""
|
||
print("\n" + "="*80)
|
||
print(f"加载模型并预测 - 详细调试信息:")
|
||
print(f"产品ID: {product_id}, 模型类型: {model_type}, 预测天数: {future_days}, 预测起始日期: {start_date}")
|
||
print("="*80 + "\n")
|
||
|
||
model_path = f'models/{model_type}/{product_id}_model.pt'
|
||
|
||
if not os.path.exists(model_path):
|
||
print(f"错误: 未找到产品 {product_id} 的 {model_type} 模型文件")
|
||
return None
|
||
|
||
# 获取设备
|
||
device = get_device()
|
||
print(f"使用设备: {device} 进行预测")
|
||
|
||
# 加载模型和相关数据
|
||
checkpoint = torch.load(model_path, map_location=device, weights_only=False)
|
||
|
||
# 读取原始数据以获取最新的记录
|
||
df = pd.read_excel('pharmacy_sales.xlsx')
|
||
product_df = df[df['product_id'] == product_id].sort_values('date')
|
||
product_name = product_df['product_name'].iloc[0]
|
||
|
||
# 获取最近的look_back天数据
|
||
features = checkpoint['features']
|
||
look_back = checkpoint['look_back']
|
||
T = checkpoint['T']
|
||
scaler_X = checkpoint['scaler_X']
|
||
scaler_y = checkpoint['scaler_y']
|
||
|
||
last_data = product_df[features].values[-look_back:]
|
||
last_data_scaled = scaler_X.transform(last_data)
|
||
|
||
# 创建模型并加载参数
|
||
if model_type == 'mlstm':
|
||
ModelClass = MLSTMTransformer
|
||
model_params = {
|
||
'num_features': len(features),
|
||
'hidden_size': 128,
|
||
'mlstm_layers': 1,
|
||
'embed_dim': embed_dim,
|
||
'dense_dim': dense_dim,
|
||
'num_heads': num_heads,
|
||
'dropout_rate': dropout_rate,
|
||
'num_blocks': num_blocks,
|
||
'output_sequence_length': T
|
||
}
|
||
elif model_type == 'kan':
|
||
ModelClass = KANForecaster
|
||
model_params = {
|
||
'input_features': len(features),
|
||
'hidden_sizes': [64, 128, 64],
|
||
'output_size': 1,
|
||
'grid_size': 5,
|
||
'spline_order': 3,
|
||
'dropout_rate': dropout_rate,
|
||
'output_sequence_length': T
|
||
}
|
||
elif model_type == 'transformer':
|
||
ModelClass = TimeSeriesTransformer
|
||
model_params = {
|
||
'num_features': len(features),
|
||
'd_model': embed_dim,
|
||
'nhead': num_heads,
|
||
'num_encoder_layers': num_blocks,
|
||
'dim_feedforward': dense_dim,
|
||
'dropout': dropout_rate,
|
||
'output_sequence_length': T
|
||
}
|
||
else:
|
||
print(f"错误: 不支持的模型类型 '{model_type}'")
|
||
return None
|
||
|
||
model = ModelClass(**model_params)
|
||
model.load_state_dict(checkpoint['model_state_dict'])
|
||
|
||
# 将模型移动到设备上
|
||
model = model.to(device)
|
||
model.eval()
|
||
|
||
# 准备输入数据
|
||
X_input = torch.Tensor(last_data_scaled).unsqueeze(0) # 添加批次维度
|
||
X_input = X_input.to(device) # 移动到设备上
|
||
|
||
# 进行预测
|
||
with torch.no_grad():
|
||
# 获取模型默认预测长度
|
||
default_pred_length = T
|
||
print(f"模型默认预测长度: {default_pred_length}天")
|
||
|
||
# 使用模型进行预测 - 如果请求的预测天数小于模型默认值，截断结果
|
||
if future_days <= default_pred_length:
|
||
print(f"请求的预测天数 {future_days} 小于等于模型默认值 {default_pred_length}，截取需要的部分")
|
||
y_pred_scaled = model(X_input).squeeze(0).cpu().numpy()[:future_days]
|
||
else:
|
||
# 如果请求的预测天数大于模型默认值，需要多次预测并拼接结果
|
||
print(f"请求的预测天数 {future_days} 大于模型默认值 {default_pred_length}，需要多次预测")
|
||
y_pred_scaled = model(X_input).squeeze(0).cpu().numpy()
|
||
|
||
# 只取默认预测长度的结果
|
||
y_pred_scaled = y_pred_scaled[:min(future_days, default_pred_length)]
|
||
|
||
# 反归一化预测结果
|
||
y_pred = scaler_y.inverse_transform(y_pred_scaled.reshape(-1, 1)).flatten()
|
||
|
||
# 创建预测日期范围
|
||
last_date = product_df['date'].iloc[-1]
|
||
|
||
if start_date:
|
||
try:
|
||
# 使用用户指定的日期作为预测起点
|
||
start_date_obj = pd.Timestamp(start_date)
|
||
print(f"成功解析用户指定的预测起始日期: {start_date_obj.strftime('%Y-%m-%d')}")
|
||
except Exception as e:
|
||
# 如果日期格式无效，使用当前日期
|
||
start_date_obj = pd.Timestamp.now().normalize()
|
||
print(f"日期解析错误: {e}")
|
||
print(f"使用当前日期 {start_date_obj.strftime('%Y-%m-%d')} 作为预测起点")
|
||
else:
|
||
# 如果未指定日期，使用数据集最后日期的下一天
|
||
start_date_obj = last_date + pd.Timedelta(days=1)
|
||
print(f"未指定起始日期，使用数据集最后日期 {last_date.strftime('%Y-%m-%d')} 的下一天作为预测起点: {start_date_obj.strftime('%Y-%m-%d')}")
|
||
|
||
future_dates = pd.date_range(start=start_date_obj, periods=future_days, freq='D')
|
||
print(f"生成预测日期范围: {future_dates[0]} 到 {future_dates[-1]}, 共 {len(future_dates)} 天")
|
||
|
||
# 创建预测结果目录
|
||
output_dir = f'predictions/{model_type}/{product_id}'
|
||
os.makedirs(output_dir, exist_ok=True)
|
||
|
||
# 可视化预测结果
|
||
try:
|
||
# 1. 创建预测图表
|
||
forecast_fig, forecast_ax = plt.subplots(figsize=(12, 6))
|
||
|
||
# 显示历史数据和预测数据
|
||
history_days = 30 # 显示最近30天的历史数据
|
||
|
||
# 只选择预测起始日期之前30天的历史数据，而不是全部历史数据
|
||
history_end_date = start_date_obj - pd.Timedelta(days=1) # 预测起始日期的前一天
|
||
history_start_date = history_end_date - pd.Timedelta(days=history_days) # 向前推30天
|
||
|
||
# 过滤历史数据，只保留这个日期范围内的数据
|
||
history_df = product_df[(product_df['date'] >= history_start_date) &
|
||
(product_df['date'] <= history_end_date)][['date', 'sales']].copy()
|
||
|
||
if history_df.empty:
|
||
print(f"警告: 在日期范围 {history_start_date} 到 {history_end_date} 内没有历史数据")
|
||
# 如果没有符合条件的历史数据，就使用最近的数据
|
||
history_df = product_df.iloc[-min(history_days, len(product_df)):][['date', 'sales']].copy()
|
||
|
||
print(f"历史数据日期范围: {history_df['date'].min()} 到 {history_df['date'].max()}")
|
||
print(f"预测数据日期范围: {future_dates.min()} 到 {future_dates.max()}")
|
||
print(f"预测起始日期: {start_date_obj.strftime('%Y-%m-%d')}")
|
||
|
||
# 绘制历史数据
|
||
forecast_ax.plot(history_df['date'].values, history_df['sales'].values, 'b-', label='历史销量')
|
||
|
||
# 绘制预测数据，确保使用future_dates作为x轴
|
||
forecast_ax.plot(future_dates, y_pred, 'r--', label=f'{model_type}预测销量')
|
||
|
||
# 强制X轴从预测起始日期的前30天开始（如果有历史数据）到预测结束日期
|
||
date_min = start_date_obj - pd.Timedelta(days=30)
|
||
date_max = future_dates.max() + pd.Timedelta(days=2)
|
||
|
||
print(f"设置X轴范围: {date_min} 到 {date_max}")
|
||
forecast_ax.set_xlim(date_min, date_max)
|
||
|
||
forecast_ax.set_title(f'{product_name} - {model_type}销量预测 (从{start_date_obj.strftime("%Y-%m-%d")}开始,预测{future_days}天)')
|
||
forecast_ax.set_xlabel('日期')
|
||
forecast_ax.set_ylabel('销量')
|
||
forecast_ax.legend()
|
||
forecast_ax.grid(True)
|
||
plt.xticks(rotation=45)
|
||
plt.tight_layout()
|
||
|
||
# 强制重新绘制图表
|
||
forecast_fig.canvas.draw()
|
||
|
||
# 将预测起始日期和预测时长添加到文件名中
|
||
start_date_str = start_date_obj.strftime('%Y%m%d')
|
||
|
||
# 保存预测图表
|
||
forecast_chart = f'{output_dir}/forecast_{start_date_str}_days{future_days}.png'
|
||
plt.savefig(forecast_chart)
|
||
print(f"预测图表已保存为: {forecast_chart}")
|
||
|
||
# 关闭图表以释放内存
|
||
plt.close(forecast_fig)
|
||
|
||
# 2. 创建历史趋势图表
|
||
try:
|
||
print("\n开始生成历史趋势图...")
|
||
history_fig, history_ax = plt.subplots(figsize=(12, 6))
|
||
|
||
# 获取预测起始日期
|
||
current_year = start_date_obj.year
|
||
current_month = start_date_obj.month
|
||
current_day = start_date_obj.day
|
||
print(f"预测起始日期: {start_date_obj}")
|
||
|
||
# 计算同期日期范围（前3天和后3天，共7天）
|
||
days_before = 3
|
||
days_after = 3
|
||
date_range_start = start_date_obj - pd.Timedelta(days=days_before)
|
||
date_range_end = start_date_obj + pd.Timedelta(days=days_after)
|
||
|
||
# 计算去年同期日期范围
|
||
last_year_start = date_range_start.replace(year=date_range_start.year-1)
|
||
last_year_end = date_range_end.replace(year=date_range_end.year-1)
|
||
|
||
# 计算上月同期日期范围
|
||
if date_range_start.month > 1:
|
||
last_month_start = date_range_start.replace(month=date_range_start.month-1)
|
||
last_month_end = date_range_end.replace(month=date_range_end.month-1)
|
||
else:
|
||
# 如果是1月，则转到上一年的12月
|
||
last_month_start = date_range_start.replace(year=date_range_start.year-1, month=12)
|
||
last_month_end = date_range_end.replace(year=date_range_end.year-1, month=12)
|
||
|
||
print(f"当前日期范围: {date_range_start} 到 {date_range_end}")
|
||
print(f"去年同期范围: {last_year_start} 到 {last_year_end}")
|
||
print(f"上月同期范围: {last_month_start} 到 {last_month_end}")
|
||
|
||
# 查找对应日期范围的数据
|
||
current_period_data = product_df[
|
||
(product_df['date'] >= date_range_start) &
|
||
(product_df['date'] <= date_range_end)
|
||
]
|
||
print(f"当前期间数据点数: {len(current_period_data)}")
|
||
|
||
last_year_period_data = product_df[
|
||
(product_df['date'] >= last_year_start) &
|
||
(product_df['date'] <= last_year_end)
|
||
]
|
||
print(f"去年同期数据点数: {len(last_year_period_data)}")
|
||
|
||
last_month_period_data = product_df[
|
||
(product_df['date'] >= last_month_start) &
|
||
(product_df['date'] <= last_month_end)
|
||
]
|
||
print(f"上月同期数据点数: {len(last_month_period_data)}")
|
||
|
||
# 绘制曲线图
|
||
has_data = False
|
||
|
||
if not current_period_data.empty:
|
||
has_data = True
|
||
# 确保日期升序排序
|
||
current_period_data = current_period_data.sort_values('date')
|
||
# 生成相对天数（以date_range_start为基准）
|
||
current_period_data['day_offset'] = (current_period_data['date'] - date_range_start).dt.days
|
||
print(f"当前期间日期: {current_period_data['date'].tolist()}")
|
||
print(f"当前期间相对天数: {current_period_data['day_offset'].tolist()}")
|
||
print(f"当前期间销量: {current_period_data['sales'].tolist()}")
|
||
|
||
history_ax.plot(
|
||
current_period_data['day_offset'],
|
||
current_period_data['sales'],
|
||
'r-',
|
||
marker='o',
|
||
linewidth=2,
|
||
label=f"当前期间 ({date_range_start.strftime('%Y-%m-%d')} 到 {date_range_end.strftime('%Y-%m-%d')})"
|
||
)
|
||
|
||
# 标记预测起始日期
|
||
current_center_point = current_period_data[current_period_data['date'] == start_date_obj]
|
||
if not current_center_point.empty:
|
||
history_ax.scatter(
|
||
current_center_point['day_offset'],
|
||
current_center_point['sales'],
|
||
color='red',
|
||
s=100,
|
||
marker='*',
|
||
zorder=10,
|
||
label=f"预测起始日 ({start_date_obj.strftime('%Y-%m-%d')})"
|
||
)
|
||
|
||
if not last_year_period_data.empty:
|
||
has_data = True
|
||
# 确保日期升序排序
|
||
last_year_period_data = last_year_period_data.sort_values('date')
|
||
last_year_period_data['day_offset'] = (last_year_period_data['date'] - last_year_start).dt.days
|
||
print(f"去年同期日期: {last_year_period_data['date'].tolist()}")
|
||
print(f"去年同期相对天数: {last_year_period_data['day_offset'].tolist()}")
|
||
print(f"去年同期销量: {last_year_period_data['sales'].tolist()}")
|
||
|
||
history_ax.plot(
|
||
last_year_period_data['day_offset'],
|
||
last_year_period_data['sales'],
|
||
'b-',
|
||
marker='s',
|
||
linewidth=2,
|
||
label=f"去年同期 ({last_year_start.strftime('%Y-%m-%d')} 到 {last_year_end.strftime('%Y-%m-%d')})"
|
||
)
|
||
|
||
if not last_month_period_data.empty:
|
||
has_data = True
|
||
# 确保日期升序排序
|
||
last_month_period_data = last_month_period_data.sort_values('date')
|
||
last_month_period_data['day_offset'] = (last_month_period_data['date'] - last_month_start).dt.days
|
||
print(f"上月同期日期: {last_month_period_data['date'].tolist()}")
|
||
print(f"上月同期相对天数: {last_month_period_data['day_offset'].tolist()}")
|
||
print(f"上月同期销量: {last_month_period_data['sales'].tolist()}")
|
||
|
||
history_ax.plot(
|
||
last_month_period_data['day_offset'],
|
||
last_month_period_data['sales'],
|
||
'g-',
|
||
marker='^',
|
||
linewidth=2,
|
||
label=f"上月同期 ({last_month_start.strftime('%Y-%m-%d')} 到 {last_month_end.strftime('%Y-%m-%d')})"
|
||
)
|
||
|
||
# 设置X轴标签为相对天数
|
||
days_labels = list(range(7))
|
||
days_offsets = list(range(7))
|
||
day_names = [(date_range_start + pd.Timedelta(days=d)).strftime('%m-%d') for d in range(7)]
|
||
|
||
history_ax.set_xticks(days_offsets)
|
||
history_ax.set_xticklabels(day_names)
|
||
|
||
# 添加垂直参考线标记预测起始日
|
||
history_ax.axvline(x=days_before, color='gray', linestyle='--', alpha=0.5)
|
||
|
||
# 美化图表
|
||
history_ax.set_title(f'{product_name} - 同期销量趋势对比 (7天)')
|
||
history_ax.set_xlabel('日期')
|
||
history_ax.set_ylabel('销量')
|
||
history_ax.grid(True, linestyle='--', alpha=0.7)
|
||
history_ax.legend(loc='best')
|
||
|
||
# 如果所有数据集都为空，显示提示
|
||
if not has_data:
|
||
history_ax.text(0.5, 0.5, '没有找到可比较的同期数据',
|
||
horizontalalignment='center', verticalalignment='center',
|
||
transform=history_ax.transAxes, fontsize=14)
|
||
|
||
plt.tight_layout()
|
||
|
||
# 强制重新绘制图表
|
||
history_fig.canvas.draw()
|
||
|
||
# 保存历史趋势图表
|
||
history_chart = f'{output_dir}/history_{start_date_str}.png'
|
||
plt.savefig(history_chart)
|
||
print(f"历史趋势图表已保存为: {history_chart}")
|
||
|
||
# 关闭图表以释放内存
|
||
plt.close(history_fig)
|
||
|
||
except Exception as e:
|
||
import traceback
|
||
print(f"生成历史趋势图时出错: {e}")
|
||
traceback.print_exc()
|
||
history_chart = None
|
||
|
||
# 创建一个包含历史和预测数据的完整DataFrame供CSV导出和API返回
|
||
history_df['data_type'] = '历史销量'
|
||
|
||
predictions_df = pd.DataFrame({
|
||
'date': future_dates,
|
||
'sales': y_pred,
|
||
'data_type': '预测销量',
|
||
'product_id': product_id,
|
||
'product_name': product_name
|
||
})
|
||
|
||
# 合并历史和预测数据
|
||
complete_df = pd.concat([
|
||
history_df[['date', 'sales', 'data_type']].assign(product_id=product_id, product_name=product_name),
|
||
predictions_df
|
||
]).sort_values('date')
|
||
|
||
except Exception as e:
|
||
import traceback
|
||
print(f"生成预测图表时出错: {e}")
|
||
traceback.print_exc()
|
||
forecast_chart = None
|
||
history_chart = None
|
||
|
||
# 出错时仍然创建预测数据
|
||
predictions_df = pd.DataFrame({
|
||
'date': future_dates,
|
||
'sales': y_pred,
|
||
'data_type': '预测销量',
|
||
'product_id': product_id,
|
||
'product_name': product_name
|
||
})
|
||
complete_df = predictions_df
|
||
|
||
# 保存预测结果到CSV
|
||
try:
|
||
forecast_csv = f'{output_dir}/forecast_{start_date_str}_days{future_days}.csv'
|
||
complete_df.to_csv(forecast_csv, index=False)
|
||
print(f"预测结果已保存到: {forecast_csv}")
|
||
except Exception as e:
|
||
print(f"保存CSV文件时出错: {e}")
|
||
forecast_csv = None
|
||
|
||
# 返回文件路径信息和预测数据
|
||
result = {
|
||
'predictions_df': complete_df, # 返回包含历史数据的完整DataFrame
|
||
'chart_path': forecast_chart,
|
||
'history_chart_path': history_chart,
|
||
'csv_path': forecast_csv
|
||
}
|
||
|
||
return result
|
||
|
||
# 特定加载KAN模型并预测的函数
|
||
def load_kan_model_and_predict(product_id, future_days=7):
|
||
"""
|
||
加载KAN模型并进行未来销量预测，是load_model_and_predict的简化版本，固定模型类型为'kan'
|
||
|
||
Args:
|
||
product_id: 产品ID
|
||
future_days: 预测未来天数，默认7天
|
||
|
||
Returns:
|
||
预测结果字典
|
||
"""
|
||
return load_model_and_predict(product_id, model_type='kan', future_days=future_days)
|
||
|
||
if __name__ == "__main__":
|
||
# 首先生成测试数据
|
||
try:
|
||
print("正在检查是否存在模拟数据...")
|
||
df = pd.read_excel('pharmacy_sales.xlsx')
|
||
print("发现现有数据，跳过数据生成步骤。")
|
||
except:
|
||
print("未找到数据，正在生成模拟数据...")
|
||
import generate_pharmacy_data
|
||
print("数据生成完成！")
|
||
|
||
# 读取数据获取所有产品ID
|
||
df = pd.read_excel('pharmacy_sales.xlsx')
|
||
product_ids = df['product_id'].unique()
|
||
|
||
# 为每个产品训练一个模型
|
||
all_metrics = {}
|
||
for product_id in product_ids:
|
||
print(f"\n{'='*50}")
|
||
print(f"开始训练产品 {product_id} 的模型")
|
||
print(f"{'='*50}")
|
||
|
||
_, metrics = train_product_model(product_id, epochs=epochs)
|
||
all_metrics[product_id] = metrics
|
||
|
||
# 输出所有产品的评估指标
|
||
print("\n所有产品模型评估结果汇总:")
|
||
for product_id, metrics in all_metrics.items():
|
||
product_name = df[df['product_id'] == product_id]['product_name'].iloc[0]
|
||
print(f"\n{product_name} (ID: {product_id}):")
|
||
for metric, value in metrics.items():
|
||
print(f" {metric}: {value:.4f}")
|
||
|
||
print("\n模型训练和评估完成!") |