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模型训练和评估完成!")