OneTree/ShopTRAINING
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

---

Browse Source 
**日期**: 2025-07-18
**主题**: 模型保存逻辑重构与集中化管理

### 目标
根据 `xz训练模型保存规则.md`，将系统中分散的模型文件保存逻辑统一重构，创建一个集中、健壮且可测试的路径管理系统。

### 核心成果
1.  **创建了 `server/utils/file_save.py` 模块**: 这个新模块现在是系统中处理模型文件保存路径的唯一权威来源。
2.  **实现了三种训练模式的路径生成**: 系统现在可以为“按店铺”、“按药品”和“全局”三种训练模式正确生成层级化的、可追溯的目录结构。
3.  **集成了智能ID处理**:
    *   对于包含**多个ID**的训练场景，系统会自动计算一个简短的哈希值作为目录名。
    *   对于全局训练中只包含**单个店铺或药品ID**的场景，系统会直接使用该ID作为目录名，增强了路径的可读性。
4.  **重构了整个训练流程**: 修改了API层、进程管理层以及所有模型训练器，使它们能够协同使用新的路径管理模块。
5.  **添加了自动化测试**: 创建了 `test/test_file_save_logic.py` 脚本，用于验证所有路径生成和版本管理逻辑的正确性。

### 详细文件修改记录

1.  **`server/utils/file_save.py`**
    *   **操作**: 创建
    *   **内容**: 实现了 `ModelPathManager` 类，包含以下核心方法：
        *   `_hash_ids`: 对ID列表进行排序和哈希。
        *   `_generate_identifier`: 根据训练模式和参数生成唯一的模型标识符。
        *   `get_next_version` / `save_version_info`: 线程安全地管理 `versions.json` 文件，实现版本号的获取和更新。
        *   `get_model_paths`: 作为主入口，协调以上方法，生成包含所有产物路径的字典。

2.  **`server/api.py`**
    *   **操作**: 修改
    *   **位置**: `start_training` 函数 (`/api/training` 端点)。
    *   **内容**:
        *   导入并实例化 `ModelPathManager`。
        *   在接收到训练请求后，调用 `path_manager.get_model_paths()` 来获取所有路径信息。
        *   将获取到的 `path_info` 字典和原始请求参数 `training_params` 一并传递给后台训练任务管理器。
        *   修复了因重复传递关键字参数 (`model_type`, `training_mode`) 导致的 `TypeError`。
        *   修复了 `except` 块中因未导入 `traceback` 模块导致的 `UnboundLocalError`。

3.  **`server/utils/training_process_manager.py`**
    *   **操作**: 修改
    *   **内容**:
        *   修改 `submit_task` 方法，使其能接收 `training_params` 和 `path_info` 字典。
        *   在 `TrainingTask` 数据类中增加了 `path_info` 字段来存储路径信息。
        *   在 `TrainingWorker` 中，将 `path_info` 传递给实际的训练函数。
        *   在 `_monitor_results` 方法中，当任务成功完成时，调用 `path_manager.save_version_info` 来更新 `versions.json`，完成版本管理的闭环。

4.  **所有训练器文件** (`mlstm_trainer.py`, `kan_trainer.py`, `tcn_trainer.py`, `transformer_trainer.py`)
    *   **操作**: 修改
    *   **内容**:
        *   统一修改了主训练函数的签名，增加了 `path_info=None` 参数。
        *   移除了所有内部手动构建文件路径的逻辑。
        *   所有保存操作（最终模型、检查点、损失曲线图）现在都直接从传入的 `path_info` 字典中获取预先生成好的路径。
        *   简化了 `save_checkpoint` 辅助函数，使其也依赖 `path_info`。

5.  **`test/test_file_save_logic.py`**
    *   **操作**: 创建
    *   **内容**:
        *   编写了一个独立的测试脚本，用于验证 `ModelPathManager` 的所有功能。
        *   覆盖了所有训练模式及其子场景（包括单ID和多ID哈希）。
        *   测试了版本号的正确递增和 `versions.json` 的写入。
        *   修复了测试脚本中因绝对/相对路径不匹配和重复关键字参数导致的多个 `AssertionError` 和 `TypeError`。

---
**日期**: 2025-07-18 (后续修复)
**主题**: 修复API层调用路径管理器时的 `TypeError`

### 问题描述
在完成所有重构和测试后，实际运行API时，`POST /api/training` 端点在调用 `path_manager.get_model_paths` 时崩溃，并抛出 `TypeError: get_model_paths() got multiple values for keyword argument 'training_mode'`。

### 根本原因
这是一个回归错误。在修复测试脚本 `test_file_save_logic.py` 中的类似问题时，我未能将相同的修复逻辑应用回 `server/api.py`。代码在调用 `get_model_paths` 时，既通过关键字参数 `training_mode=...` 明确传递了该参数，又通过 `**data` 将其再次传入，导致了冲突。

### 解决方案
1.  **文件**: `server/api.py`
2.  **位置**: `start_training` 函数。
3.  **操作**: 修改了对 `get_model_paths` 的调用逻辑。
4.  **内容**:
    ```python
    # 移除 model_type 和 training_mode 以避免重复关键字参数错误
    data_for_path = data.copy()
    data_for_path.pop('model_type', None)
    data_for_path.pop('training_mode', None)
    path_info = path_manager.get_model_paths(
        training_mode=training_mode,
        model_type=model_type,
        **data_for_path  # 传递剩余的payload
    )
    ```
5.  **原因**: 在通过 `**` 解包传递参数之前，先从字典副本中移除了所有会被明确指定的关键字参数，从而确保了函数调用签名的正确性。

---
**日期**: 2025-07-18 (最终修复)
**主题**: 修复因中间层函数签名未更新导致的 `TypeError`

### 问题描述
在完成所有重构后，实际运行API并触发训练任务时，程序在后台进程中因 `TypeError: train_model() got an unexpected keyword argument 'path_info'` 而崩溃。

### 根本原因
这是一个典型的“中间人”遗漏错误。我成功地修改了调用链的两端（`api.py` -> `training_process_manager.py` 和 `*_trainer.py`），但忘记了修改它们之间的中间层——`server/core/predictor.py` 中的 `train_model` 方法。`training_process_manager` 尝试将 `path_info` 传递给 `predictor.train_model`，但后者的函数签名中并未包含这个新参数，导致了 `TypeError`。

### 解决方案
1.  **文件**: `server/core/predictor.py`
2.  **位置**: `train_model` 函数的定义处。
3.  **操作**: 在函数签名中增加了 `path_info=None` 参数。
4.  **内容**:
    ```python
    def train_model(self, ..., progress_callback=None, path_info=None):
        # ...
    ```
5.  **位置**: `train_model` 函数内部，对所有具体训练器（`train_product_model_with_mlstm`, `_with_kan`, etc.）的调用处。
6.  **操作**: 在所有调用中，将接收到的 `path_info` 参数透传下去。
7.  **内容**:
    ```python
    # ...
    metrics = train_product_model_with_transformer(
        ...,
        path_info=path_info
    )
    # ...
    ```
8.  **原因**: 通过在中间层函数上“打通”`path_info` 参数的传递通道，确保了从API层到最终训练器层的完整数据流，解决了 `TypeError`。

---
**日期**: 2025-07-18 (最终修复)
**主题**: 修复“按药品训练-聚合所有店铺”模式下的路径生成错误

### 问题描述
在实际运行中发现，当进行“按药品训练”并选择“聚合所有店铺”时，生成的模型保存路径中包含了错误的后缀 `_None`，而不是预期的 `_all` (例如 `.../17002608_None/...`)。

### 根本原因
在 `server/utils/file_save.py` 的 `_generate_identifier` 和 `get_model_paths` 方法中，当 `store_id` 从前端传来为 `None` 时，代码 `scope = store_id if store_id else 'all'` 会因为 `store_id` 是 `None` 而正确地将 `scope` 设为 `'all'`。然而，在 `get_model_paths` 方法中，我错误地使用了 `kwargs.get('store_id', 'all')`，这在 `store_id` 键存在但值为 `None` 时，仍然会返回 `None`，导致了路径拼接错误。

### 解决方案
1.  **文件**: `server/utils/file_save.py`
2.  **位置**: `_generate_identifier` 和 `get_model_paths` 方法中处理 `product` 训练模式的部分。
3.  **操作**: 将逻辑从 `scope = kwargs.get('store_id', 'all')` 修改为更严谨的 `scope = store_id if store_id is not None else 'all'`。
4.  **内容**:
    ```python
    # in _generate_identifier
    scope = store_id if store_id is not None else 'all'

    # in get_model_paths
    store_id = kwargs.get('store_id')
    scope = store_id if store_id is not None else 'all'
    scope_folder = f"{product_id}_{scope}"
    ```
5.  **原因**: 这种写法能正确处理 `store_id` 键不存在、或键存在但值为 `None` 的两种情况，确保在这两种情况下 `scope` 都被正确地设置为 `'all'`，从而生成符合规范的路径。

---
**日期**: 2025-07-18 (最终修复)
**主题**: 修复 `KeyError: 'price'` 和单ID哈希错误

### 问题描述
在完成大规模重构后，实际运行时发现了两个隐藏的bug：
1.  在“按店铺训练”模式下，训练因 `KeyError: 'price'` 而失败。
2.  在“按店铺训练”模式下，当只选择一个“指定药品”时，系统仍然错误地对该药品的ID进行了哈希处理，而不是直接使用ID。

### 根本原因
1.  **`KeyError`**: `server/utils/multi_store_data_utils.py` 中的 `get_store_product_sales_data` 函数包含了一个硬编码的列校验，该校验要求 `price` 列必须存在，但这与当前的数据源不符。
2.  **哈希错误**: `server/utils/file_save.py` 中的 `get_model_paths` 方法在处理 `store` 训练模式时，没有复用 `_generate_identifier` 中已经写好的单ID判断逻辑，导致了逻辑不一致。

### 解决方案
1.  **修复 `KeyError`**:
    *   **文件**: `server/utils/multi_store_data_utils.py`
    *   **位置**: `get_store_product_sales_data` 函数。
    *   **操作**: 从 `required_columns` 列表中移除了 `'price'`，根除了这个硬性依赖。
2.  **修复哈希逻辑**:
    *   **文件**: `server/utils/file_save.py`
    *   **位置**: `_generate_identifier` 和 `get_model_paths` 方法中处理 `store` 训练模式的部分。
    *   **操作**: 统一了逻辑，确保在这两个地方都使用了 `scope = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)` 的判断，从而在只选择一个药品时直接使用其ID。
3.  **更新测试**:
    *   **文件**: `test/test_file_save_logic.py`
    *   **操作**: 增加了新的测试用例，专门验证“按店铺训练-单个指定药品”场景下的路径生成是否正确。

---
**日期**: 2025-07-18 (最终修复)
**主题**: 修复全局训练范围值不匹配导致的 `ValueError`

### 问题描述
在完成所有重构后，实际运行API并触发“全局训练-所有店铺所有药品”时，程序因 `ValueError: 未知的全局训练范围: all_stores_all_products` 而崩溃。

### 根本原因
前端传递的 `training_scope` 值为 `all_stores_all_products`，而 `server/utils/file_save.py` 中的 `_generate_identifier` 和 `get_model_paths` 方法只处理了 `all` 这个值，未能兼容前端传递的具体字符串，导致逻辑判断失败。

### 解决方案
1.  **文件**: `server/utils/file_save.py`
2.  **位置**: `_generate_identifier` 和 `get_model_paths` 方法中处理 `global` 训练模式的部分。
3.  **操作**: 将逻辑判断从 `if training_scope == 'all':` 修改为 `if training_scope in ['all', 'all_stores_all_products']:`。
4.  **原因**: 使代码能够同时兼容两种表示“所有范围”的字符串，确保了前端请求的正确处理。
5.  **更新测试**:
    *   **文件**: `test/test_file_save_logic.py`
    *   **操作**: 增加了新的测试用例，专门验证 `training_scope` 为 `all_stores_all_products` 时的路径生成是否正确。

---
**日期**: 2025-07-18 (最终优化)
**主题**: 优化全局训练自定义模式下的单ID路径生成

### 问题描述
根据用户反馈，希望在全局训练的“自定义范围”模式下，如果只选择单个店铺和/或单个药品，路径中应直接使用ID而不是哈希值，以增强可读性。

### 解决方案
1.  **文件**: `server/utils/file_save.py`
2.  **位置**: `_generate_identifier` 和 `get_model_paths` 方法中处理 `global` 训练模式 `custom` 范围的部分。
3.  **操作**: 为 `store_ids` 和 `product_ids` 分别增加了单ID判断逻辑。
4.  **内容**:
    ```python
    # in _generate_identifier
    s_id = store_ids[0] if len(store_ids) == 1 else self._hash_ids(store_ids)
    p_id = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)
    scope_part = f"custom_s_{s_id}_p_{p_id}"

    # in get_model_paths
    store_ids = kwargs.get('store_ids', [])
    product_ids = kwargs.get('product_ids', [])
    s_id = store_ids[0] if len(store_ids) == 1 else self._hash_ids(store_ids)
    p_id = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)
    scope_parts.extend(['custom', s_id, p_id])
    ```
5.  **原因**: 使 `custom` 模式下的路径生成逻辑与 `selected_stores` 和 `selected_products` 模式保持一致，在只选择一个ID时优先使用ID本身，提高了路径的可读性和一致性。
6.  **更新测试**:
    *   **文件**: `test/test_file_save_logic.py`
    *   **操作**: 增加了新的测试用例，专门验证“全局训练-自定义范围-单ID”场景下的路径生成是否正确。
This commit is contained in:
xz2000 2025-07-18 16:45:21 +08:00
parent 9bd824c389
commit 5b2cdfa74a
11 changed files with 924 additions and 234 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
server/api.py
View File

@ -11,12 +11,14 @@ sys.path.append(current_dir)
# 使用新的现代化日志系统
from utils.logging_config import setup_api_logging, get_logger
from utils.training_process_manager import get_training_manager
from utils.file_save import ModelPathManager
# 初始化现代化日志系统
logger = setup_api_logging(log_dir=".", log_level="INFO")
# 获取训练进程管理器
training_manager = get_training_manager()
path_manager = ModelPathManager()
import json
import pandas as pd
@ -33,7 +35,6 @@ from flask_socketio import SocketIO, emit, join_room, leave_room
from flasgger import Swagger
from werkzeug.utils import secure_filename
import sqlite3
import traceback
import time
import threading
@ -1011,29 +1012,39 @@ def start_training():
if model_type not in valid_model_types:
return jsonify({'error': '无效的模型类型'}), 400
# 使用新的训练进程管理器提交任务
# 使用新的路径和版本管理器
try:
task_id = training_manager.submit_task(
product_id=product_id or "unknown",
model_type=model_type,
# 从新模块获取所有路径和版本信息
# 移除 model_type 和 training_mode 以避免重复关键字参数错误
data_for_path = data.copy()
data_for_path.pop('model_type', None)
data_for_path.pop('training_mode', None)
path_info = path_manager.get_model_paths(
training_mode=training_mode,
store_id=store_id,
epochs=epochs
model_type=model_type,
**data_for_path # 传递剩余的payload
)
# 使用新的训练进程管理器提交任务
# 注意：这里我们将整个请求数据和路径信息都传递给后台任务
task_id = training_manager.submit_task(
training_params=data,
path_info=path_info
)
logger.info(f"🚀 训练任务已提交到进程管理器: {task_id[:8]}")
logger.info(f"🗂️ 路径信息: {path_info}")
return jsonify({
'message': '模型训练已开始（使用独立进程）',
'task_id': task_id,
'training_mode': training_mode,
'model_type': model_type,
'product_id': product_id,
'epochs': epochs
'path_info': path_info
})
except Exception as e:
import traceback # 在此处导入以修复 UnboundLocalError
logger.error(f"❌ 提交训练任务失败: {str(e)}")
traceback.print_exc() # 打印详细错误
return jsonify({'error': f'启动训练任务失败: {str(e)}'}), 500
# 旧的训练逻辑已被现代化进程管理器替代

15
server/core/predictor.py
View File

@ -65,7 +65,7 @@ class PharmacyPredictor:
hidden_size=64, num_layers=2, dropout=0.1, use_optimized=False,
store_id=None, training_mode='product', aggregation_method='sum',
socketio=None, task_id=None, version=None, continue_training=False,
progress_callback=None):
progress_callback=None, path_info=None):
"""
训练预测模型 - 支持多店铺训练
@ -200,7 +200,8 @@ class PharmacyPredictor:
version=version,
socketio=socketio,
task_id=task_id,
continue_training=continue_training
continue_training=continue_training,
path_info=path_info
)
log_message(f"✅ {model_type} 训练器返回: metrics={type(metrics)}, version={actual_version}", 'success')
elif model_type == 'mlstm':
@ -214,7 +215,8 @@ class PharmacyPredictor:
model_dir=self.model_dir,
socketio=socketio,
task_id=task_id,
progress_callback=progress_callback
progress_callback=progress_callback,
path_info=path_info
)
elif model_type == 'kan':
_, metrics = train_product_model_with_kan(
@ -225,7 +227,7 @@ class PharmacyPredictor:
aggregation_method=aggregation_method,
epochs=epochs,
use_optimized=use_optimized,
model_dir=self.model_dir
path_info=path_info
)
elif model_type == 'optimized_kan':
_, metrics = train_product_model_with_kan(
@ -236,7 +238,7 @@ class PharmacyPredictor:
aggregation_method=aggregation_method,
epochs=epochs,
use_optimized=True,
model_dir=self.model_dir
path_info=path_info
)
elif model_type == 'tcn':
_, metrics, _, _ = train_product_model_with_tcn(
@ -248,7 +250,8 @@ class PharmacyPredictor:
epochs=epochs,
model_dir=self.model_dir,
socketio=socketio,
task_id=task_id
task_id=task_id,
path_info=path_info
)
else:
log_message(f"不支持的模型类型: {model_type}", 'error')

40
server/trainers/kan_trainer.py
View File

@ -21,7 +21,7 @@ from utils.visualization import plot_loss_curve
from analysis.metrics import evaluate_model
from core.config import DEVICE, DEFAULT_MODEL_DIR, LOOK_BACK, FORECAST_HORIZON
def train_product_model_with_kan(product_id, product_df=None, store_id=None, training_mode='product', aggregation_method='sum', epochs=50, use_optimized=False, model_dir=DEFAULT_MODEL_DIR):
def train_product_model_with_kan(product_id, product_df=None, store_id=None, training_mode='product', aggregation_method='sum', epochs=50, use_optimized=False, path_info=None, **kwargs):
"""
使用KAN模型训练产品销售预测模型
@ -29,12 +29,14 @@ def train_product_model_with_kan(product_id, product_df=None, store_id=None, tra
product_id: 产品ID
epochs: 训练轮次
use_optimized: 是否使用优化版KAN
model_dir: 模型保存目录，默认使用配置中的DEFAULT_MODEL_DIR
path_info: 包含所有路径信息的字典
返回:
model: 训练好的模型
metrics: 模型评估指标
"""
if not path_info:
raise ValueError("train_product_model_with_kan 需要 'path_info' 参数。")
# 如果没有传入product_df，则根据训练模式加载数据
if product_df is None:
from utils.multi_store_data_utils import load_multi_store_data, get_store_product_sales_data, aggregate_multi_store_data
@ -101,7 +103,7 @@ def train_product_model_with_kan(product_id, product_df=None, store_id=None, tra
print(f"使用{model_type}模型训练产品 '{product_name}' (ID: {product_id}) 的销售预测模型")
print(f"训练范围: {training_scope}")
print(f"使用设备: {DEVICE}")
print(f"模型将保存到目录: {model_dir}")
print(f"模型将保存到目录: {path_info['version_dir']}")
# 创建特征和目标变量
features = ['sales', 'weekday', 'month', 'is_holiday', 'is_weekend', 'is_promotion', 'temperature']
@ -234,12 +236,13 @@ def train_product_model_with_kan(product_id, product_df=None, store_id=None, tra
# 绘制损失曲线并保存到模型目录
model_name = 'optimized_kan' if use_optimized else 'kan'
loss_curve_path = plot_loss_curve(
train_losses,
test_losses,
product_name,
model_type,
model_dir=model_dir
loss_curve_path = path_info['loss_curve_path']
plot_loss_curve(
train_losses,
test_losses,
product_name,
model_type,
save_path=loss_curve_path
)
print(f"损失曲线已保存到: {loss_curve_path}")
@ -269,9 +272,6 @@ def train_product_model_with_kan(product_id, product_df=None, store_id=None, tra
print(f"MAPE: {metrics['mape']:.2f}%")
print(f"训练时间: {training_time:.2f}秒")
# 使用统一模型管理器保存模型
from utils.model_manager import model_manager
model_type_name = 'optimized_kan' if use_optimized else 'kan'
model_data = {
@ -297,15 +297,9 @@ def train_product_model_with_kan(product_id, product_df=None, store_id=None, tra
'loss_curve_path': loss_curve_path
}
model_path = model_manager.save_model(
model_data=model_data,
product_id=product_id,
model_type=model_type_name,
version='v1', # KAN训练器默认使用v1
store_id=store_id,
training_mode=training_mode,
aggregation_method=aggregation_method,
product_name=product_name
)
# 使用 path_info 中的路径保存模型
model_path = path_info['model_path']
torch.save(model_data, model_path)
print(f"模型已保存到: {model_path}")
return model, metrics
return model, metrics

103
server/trainers/mlstm_trainer.py
View File

@ -25,36 +25,20 @@ from core.config import (
)
from utils.training_progress import progress_manager
def save_checkpoint(checkpoint_data: dict, epoch_or_label, product_id: str,
model_type: str, model_dir: str, store_id=None,
training_mode: str = 'product', aggregation_method=None):
def save_checkpoint(checkpoint_data: dict, epoch_or_label, path_info: dict):
"""
保存训练检查点
Args:
checkpoint_data: 检查点数据
epoch_or_label: epoch编号或标签（如'best'）
product_id: 产品ID
model_type: 模型类型
model_dir: 模型保存目录
store_id: 店铺ID
training_mode: 训练模式
aggregation_method: 聚合方法
epoch_or_label: epoch编号或标签（如'best', 'final', 50）
path_info (dict): 包含所有路径信息的字典
"""
# 创建检查点目录
checkpoint_dir = os.path.join(model_dir, 'checkpoints')
os.makedirs(checkpoint_dir, exist_ok=True)
# 生成检查点文件名
if training_mode == 'store' and store_id:
filename = f"{model_type}_store_{store_id}_{product_id}_epoch_{epoch_or_label}.pth"
elif training_mode == 'global' and aggregation_method:
filename = f"{model_type}_global_{product_id}_{aggregation_method}_epoch_{epoch_or_label}.pth"
if epoch_or_label == 'best':
checkpoint_path = path_info['best_checkpoint_path']
else:
filename = f"{model_type}_product_{product_id}_epoch_{epoch_or_label}.pth"
checkpoint_path = os.path.join(checkpoint_dir, filename)
checkpoint_path = os.path.join(path_info['checkpoint_dir'], f"checkpoint_epoch_{epoch_or_label}.pth")
# 保存检查点
torch.save(checkpoint_data, checkpoint_path)
print(f"[mLSTM] 检查点已保存: {checkpoint_path}", flush=True)
@ -111,12 +95,13 @@ def train_product_model_with_mlstm(
training_mode='product',
aggregation_method='sum',
epochs=50,
model_dir=DEFAULT_MODEL_DIR,
version=None,
model_dir=DEFAULT_MODEL_DIR, # 将被 path_info 替代
version=None, # 将被 path_info 替代
socketio=None,
task_id=None,
continue_training=False,
progress_callback=None,
path_info=None, # 新增参数
patience=10,
learning_rate=0.001,
clip_norm=1.0
@ -138,6 +123,12 @@ def train_product_model_with_mlstm(
progress_callback: 进度回调函数，用于多进程训练
"""
# 验证 path_info 是否提供
if not path_info:
raise ValueError("train_product_model_with_mlstm 需要 'path_info' 参数。")
version = path_info['version']
# 创建WebSocket进度反馈函数，支持多进程
def emit_progress(message, progress=None, metrics=None):
"""发送训练进度到前端"""
@ -171,18 +162,7 @@ def train_product_model_with_mlstm(
sys.stdout.flush()
sys.stderr.flush()
emit_progress("开始mLSTM模型训练...")
# 确定版本号
if version is None:
if continue_training:
version = get_latest_model_version(product_id, 'mlstm')
if version is None:
version = get_next_model_version(product_id, 'mlstm')
else:
version = get_next_model_version(product_id, 'mlstm')
emit_progress(f"开始训练 mLSTM 模型版本 {version}")
emit_progress(f"开始训练 mLSTM 模型版本 v{version}")
# 初始化训练进度管理器（如果还未初始化）
if socketio and task_id:
@ -235,9 +215,9 @@ def train_product_model_with_mlstm(
print(f"[mLSTM] 使用mLSTM模型训练产品 '{product_name}' (ID: {product_id}) 的销售预测模型", flush=True)
print(f"[mLSTM] 训练范围: {training_scope}", flush=True)
print(f"[mLSTM] 版本: {version}", flush=True)
print(f"[mLSTM] 版本: v{version}", flush=True)
print(f"[mLSTM] 使用设备: {DEVICE}", flush=True)
print(f"[mLSTM] 模型将保存到目录: {model_dir}", flush=True)
print(f"[mLSTM] 模型将保存到目录: {path_info['version_dir']}", flush=True)
print(f"[mLSTM] 数据量: {len(product_df)} 条记录", flush=True)
emit_progress(f"训练产品: {product_name} (ID: {product_id}) - {training_scope}")
@ -324,16 +304,9 @@ def train_product_model_with_mlstm(
# 如果是继续训练，加载现有模型
if continue_training and version != 'v1':
try:
existing_model_path = get_model_file_path(product_id, 'mlstm', version)
if os.path.exists(existing_model_path):
checkpoint = torch.load(existing_model_path, map_location=DEVICE)
model.load_state_dict(checkpoint['model_state_dict'])
print(f"加载现有模型: {existing_model_path}")
emit_progress(f"加载现有模型版本 {version} 进行继续训练")
except Exception as e:
print(f"无法加载现有模型，将重新开始训练: {e}")
emit_progress("无法加载现有模型，重新开始训练")
# TODO: 继续训练的逻辑需要调整以适应新的路径结构
# 例如，加载上一个版本的 best checkpoint
emit_progress("继续训练功能待适配新路径结构，暂时作为新训练开始。")
# 将模型移动到设备上
model = model.to(DEVICE)
@ -452,14 +425,12 @@ def train_product_model_with_mlstm(
}
# 保存检查点
save_checkpoint(checkpoint_data, epoch + 1, product_id, 'mlstm',
model_dir, store_id, training_mode, aggregation_method)
save_checkpoint(checkpoint_data, epoch + 1, path_info)
# 如果是最佳模型，额外保存一份
if test_loss < best_loss:
best_loss = test_loss
save_checkpoint(checkpoint_data, 'best', product_id, 'mlstm',
model_dir, store_id, training_mode, aggregation_method)
save_checkpoint(checkpoint_data, 'best', path_info)
emit_progress(f"💾 保存最佳模型检查点 (epoch {epoch+1}, test_loss: {test_loss:.4f})")
epochs_no_improve = 0
else:
@ -480,26 +451,15 @@ def train_product_model_with_mlstm(
emit_progress("生成损失曲线...", progress=95)
# 确定模型保存目录（支持多店铺）
if store_id:
# 为特定店铺创建子目录
store_model_dir = os.path.join(model_dir, 'mlstm', store_id)
os.makedirs(store_model_dir, exist_ok=True)
loss_curve_filename = f"{product_id}_mlstm_{version}_loss_curve.png"
loss_curve_path = os.path.join(store_model_dir, loss_curve_filename)
else:
# 全局模型保存在global目录
global_model_dir = os.path.join(model_dir, 'mlstm', 'global')
os.makedirs(global_model_dir, exist_ok=True)
loss_curve_filename = f"{product_id}_mlstm_{version}_global_loss_curve.png"
loss_curve_path = os.path.join(global_model_dir, loss_curve_filename)
# 从 path_info 获取损失曲线保存路径
loss_curve_path = path_info['loss_curve_path']
# 绘制损失曲线并保存到模型目录
plt.figure(figsize=(10, 6))
plt.plot(train_losses, label='Training Loss')
plt.plot(test_losses, label='Test Loss')
title_suffix = f" - {training_scope}" if store_id else " - 全局模型"
plt.title(f'mLSTM 模型训练损失曲线 - {product_name} ({version}){title_suffix}')
plt.title(f'mLSTM 模型训练损失曲线 - {product_name} (v{version}){title_suffix}')
plt.xlabel('Epoch')
plt.ylabel('Loss')
plt.legend()
@ -575,11 +535,10 @@ def train_product_model_with_mlstm(
}
}
# 保存最终模型（使用epoch标识）
final_model_path = save_checkpoint(
final_model_data, f"final_epoch_{epochs}", product_id, 'mlstm',
model_dir, store_id, training_mode, aggregation_method
)
# 保存最终模型到 model.pth
final_model_path = path_info['model_path']
torch.save(final_model_data, final_model_path)
print(f"[mLSTM] 最终模型已保存: {final_model_path}", flush=True)
# 发送训练完成消息
final_metrics = {

102
server/trainers/tcn_trainer.py
View File

@ -21,36 +21,20 @@ from analysis.metrics import evaluate_model
from core.config import DEVICE, DEFAULT_MODEL_DIR, LOOK_BACK, FORECAST_HORIZON
from utils.training_progress import progress_manager
def save_checkpoint(checkpoint_data: dict, epoch_or_label, product_id: str,
model_type: str, model_dir: str, store_id=None,
training_mode: str = 'product', aggregation_method=None):
def save_checkpoint(checkpoint_data: dict, epoch_or_label, path_info: dict):
"""
保存训练检查点
Args:
checkpoint_data: 检查点数据
epoch_or_label: epoch编号或标签（如'best'）
product_id: 产品ID
model_type: 模型类型
model_dir: 模型保存目录
store_id: 店铺ID
training_mode: 训练模式
aggregation_method: 聚合方法
epoch_or_label: epoch编号或标签（如'best', 'final', 50）
path_info (dict): 包含所有路径信息的字典
"""
# 创建检查点目录
checkpoint_dir = os.path.join(model_dir, 'checkpoints')
os.makedirs(checkpoint_dir, exist_ok=True)
# 生成检查点文件名
if training_mode == 'store' and store_id:
filename = f"{model_type}_store_{store_id}_{product_id}_epoch_{epoch_or_label}.pth"
elif training_mode == 'global' and aggregation_method:
filename = f"{model_type}_global_{product_id}_{aggregation_method}_epoch_{epoch_or_label}.pth"
if epoch_or_label == 'best':
checkpoint_path = path_info['best_checkpoint_path']
else:
filename = f"{model_type}_product_{product_id}_epoch_{epoch_or_label}.pth"
checkpoint_path = os.path.join(checkpoint_dir, filename)
checkpoint_path = os.path.join(path_info['checkpoint_dir'], f"checkpoint_epoch_{epoch_or_label}.pth")
# 保存检查点
torch.save(checkpoint_data, checkpoint_path)
print(f"[TCN] 检查点已保存: {checkpoint_path}", flush=True)
@ -64,11 +48,13 @@ def train_product_model_with_tcn(
training_mode='product',
aggregation_method='sum',
epochs=50,
model_dir=DEFAULT_MODEL_DIR,
version=None,
model_dir=DEFAULT_MODEL_DIR, # 将被 path_info 替代
version=None, # 将被 path_info 替代
socketio=None,
task_id=None,
continue_training=False
continue_training=False,
path_info=None, # 新增参数
**kwargs
):
"""
使用TCN模型训练产品销售预测模型
@ -89,6 +75,11 @@ def train_product_model_with_tcn(
model_path: 模型文件路径
"""
if not path_info:
raise ValueError("train_product_model_with_tcn 需要 'path_info' 参数。")
version = path_info['version']
def emit_progress(message, progress=None, metrics=None):
"""发送训练进度到前端"""
if socketio and task_id:
@ -103,17 +94,7 @@ def train_product_model_with_tcn(
data['metrics'] = metrics
socketio.emit('training_progress', data, namespace='/training')
# 确定版本号
if version is None:
from core.config import get_latest_model_version, get_next_model_version
if continue_training:
version = get_latest_model_version(product_id, 'tcn')
if version is None:
version = get_next_model_version(product_id, 'tcn')
else:
version = get_next_model_version(product_id, 'tcn')
emit_progress(f"开始训练 TCN 模型版本 {version}")
emit_progress(f"开始训练 TCN 模型版本 v{version}")
# 如果没有传入product_df，则根据训练模式加载数据
if product_df is None:
@ -180,9 +161,9 @@ def train_product_model_with_tcn(
print(f"使用TCN模型训练产品 '{product_name}' (ID: {product_id}) 的销售预测模型")
print(f"训练范围: {training_scope}")
print(f"版本: {version}")
print(f"版本: v{version}")
print(f"使用设备: {DEVICE}")
print(f"模型将保存到目录: {model_dir}")
print(f"模型将保存到目录: {path_info['version_dir']}")
emit_progress(f"训练产品: {product_name} (ID: {product_id})")
@ -255,18 +236,9 @@ def train_product_model_with_tcn(
)
# 如果是继续训练，加载现有模型
if continue_training and version != 'v1':
try:
from core.config import get_model_file_path
existing_model_path = get_model_file_path(product_id, 'tcn', version)
if os.path.exists(existing_model_path):
checkpoint = torch.load(existing_model_path, map_location=DEVICE)
model.load_state_dict(checkpoint['model_state_dict'])
print(f"加载现有模型: {existing_model_path}")
emit_progress(f"加载现有模型版本 {version} 进行继续训练")
except Exception as e:
print(f"无法加载现有模型，将重新开始训练: {e}")
emit_progress("无法加载现有模型，重新开始训练")
if continue_training:
# TODO: 继续训练的逻辑需要调整以适应新的路径结构
emit_progress("继续训练功能待适配新路径结构，暂时作为新训练开始。")
# 将模型移动到设备上
model = model.to(DEVICE)
@ -399,14 +371,12 @@ def train_product_model_with_tcn(
}
# 保存检查点
save_checkpoint(checkpoint_data, epoch + 1, product_id, 'tcn',
model_dir, store_id, training_mode, aggregation_method)
save_checkpoint(checkpoint_data, epoch + 1, path_info)
# 如果是最佳模型，额外保存一份
if test_loss < best_loss:
best_loss = test_loss
save_checkpoint(checkpoint_data, 'best', product_id, 'tcn',
model_dir, store_id, training_mode, aggregation_method)
save_checkpoint(checkpoint_data, 'best', path_info)
emit_progress(f"💾 保存最佳模型检查点 (epoch {epoch+1}, test_loss: {test_loss:.4f})")
emit_progress(f"💾 保存训练检查点 epoch_{epoch+1}")
@ -422,12 +392,13 @@ def train_product_model_with_tcn(
emit_progress("训练完成，正在保存模型...")
# 绘制损失曲线并保存到模型目录
loss_curve_path = plot_loss_curve(
train_losses,
test_losses,
product_name,
'TCN',
model_dir=model_dir
loss_curve_path = path_info['loss_curve_path']
plot_loss_curve(
train_losses,
test_losses,
product_name,
'TCN',
save_path=loss_curve_path
)
print(f"损失曲线已保存到: {loss_curve_path}")
@ -493,11 +464,10 @@ def train_product_model_with_tcn(
progress_manager.set_stage("model_saving", 50)
# 保存最终模型（使用epoch标识）
final_model_path = save_checkpoint(
final_model_data, f"final_epoch_{epochs}", product_id, 'tcn',
model_dir, store_id, training_mode, aggregation_method
)
# 保存最终模型
final_model_path = path_info['model_path']
torch.save(final_model_data, final_model_path)
print(f"[TCN] 最终模型已保存: {final_model_path}", flush=True)
progress_manager.set_stage("model_saving", 100)

71
server/trainers/transformer_trainer.py
View File

@ -27,36 +27,20 @@ from core.config import (
from utils.training_progress import progress_manager
from utils.model_manager import model_manager
def save_checkpoint(checkpoint_data: dict, epoch_or_label, product_id: str,
model_type: str, model_dir: str, store_id=None,
training_mode: str = 'product', aggregation_method=None):
def save_checkpoint(checkpoint_data: dict, epoch_or_label, path_info: dict):
"""
保存训练检查点
Args:
checkpoint_data: 检查点数据
epoch_or_label: epoch编号或标签（如'best'）
product_id: 产品ID
model_type: 模型类型
model_dir: 模型保存目录
store_id: 店铺ID
training_mode: 训练模式
aggregation_method: 聚合方法
epoch_or_label: epoch编号或标签（如'best', 'final', 50）
path_info (dict): 包含所有路径信息的字典
"""
# 创建检查点目录
checkpoint_dir = os.path.join(model_dir, 'checkpoints')
os.makedirs(checkpoint_dir, exist_ok=True)
# 生成检查点文件名
if training_mode == 'store' and store_id:
filename = f"{model_type}_store_{store_id}_{product_id}_epoch_{epoch_or_label}.pth"
elif training_mode == 'global' and aggregation_method:
filename = f"{model_type}_global_{product_id}_{aggregation_method}_epoch_{epoch_or_label}.pth"
if epoch_or_label == 'best':
checkpoint_path = path_info['best_checkpoint_path']
else:
filename = f"{model_type}_product_{product_id}_epoch_{epoch_or_label}.pth"
checkpoint_path = os.path.join(checkpoint_dir, filename)
checkpoint_path = os.path.join(path_info['checkpoint_dir'], f"checkpoint_epoch_{epoch_or_label}.pth")
# 保存检查点
torch.save(checkpoint_data, checkpoint_path)
print(f"[Transformer] 检查点已保存: {checkpoint_path}", flush=True)
@ -70,11 +54,12 @@ def train_product_model_with_transformer(
training_mode='product',
aggregation_method='sum',
epochs=50,
model_dir=DEFAULT_MODEL_DIR,
version=None,
model_dir=DEFAULT_MODEL_DIR, # 将被 path_info 替代
version=None, # 将被 path_info 替代
socketio=None,
task_id=None,
continue_training=False,
path_info=None, # 新增参数
patience=10,
learning_rate=0.001,
clip_norm=1.0
@ -97,6 +82,11 @@ def train_product_model_with_transformer(
version: 实际使用的版本号
"""
if not path_info:
raise ValueError("train_product_model_with_transformer 需要 'path_info' 参数。")
version = path_info['version']
# WebSocket进度反馈函数
def emit_progress(message, progress=None, metrics=None):
"""发送训练进度到前端"""
@ -117,7 +107,7 @@ def train_product_model_with_transformer(
sys.stdout.flush()
sys.stderr.flush()
emit_progress("开始Transformer模型训练...")
emit_progress(f"开始Transformer模型训练... 版本 v{version}")
# 获取训练进度管理器实例
try:
@ -197,7 +187,7 @@ def train_product_model_with_transformer(
print(f"[Transformer] 训练产品 '{product_name}' (ID: {product_id}) 的销售预测模型", flush=True)
print(f"[Device] 使用设备: {DEVICE}", flush=True)
print(f"[Model] 模型将保存到目录: {model_dir}", flush=True)
print(f"[Model] 模型将保存到目录: {path_info['version_dir']}", flush=True)
# 创建特征和目标变量
features = ['sales', 'weekday', 'month', 'is_holiday', 'is_weekend', 'is_promotion', 'temperature']
@ -402,14 +392,12 @@ def train_product_model_with_transformer(
}
# 保存检查点
save_checkpoint(checkpoint_data, epoch + 1, product_id, 'transformer',
model_dir, store_id, training_mode, aggregation_method)
save_checkpoint(checkpoint_data, epoch + 1, path_info)
# 如果是最佳模型，额外保存一份
if test_loss < best_loss:
best_loss = test_loss
save_checkpoint(checkpoint_data, 'best', product_id, 'transformer',
model_dir, store_id, training_mode, aggregation_method)
save_checkpoint(checkpoint_data, 'best', path_info)
emit_progress(f"💾 保存最佳模型检查点 (epoch {epoch+1}, test_loss: {test_loss:.4f})")
epochs_no_improve = 0
else:
@ -433,12 +421,13 @@ def train_product_model_with_transformer(
emit_progress("训练完成，正在保存模型...")
# 绘制损失曲线并保存到模型目录
loss_curve_path = plot_loss_curve(
train_losses,
test_losses,
product_name,
'Transformer',
model_dir=model_dir
loss_curve_path = path_info['loss_curve_path']
plot_loss_curve(
train_losses,
test_losses,
product_name,
'Transformer',
save_path=loss_curve_path
)
print(f"📈 损失曲线已保存到: {loss_curve_path}", flush=True)
@ -502,11 +491,9 @@ def train_product_model_with_transformer(
progress_manager.set_stage("model_saving", 50)
# 保存最终模型（使用epoch标识）
final_model_path = save_checkpoint(
final_model_data, f"final_epoch_{epochs}", product_id, 'transformer',
model_dir, store_id, training_mode, aggregation_method
)
# 保存最终模型
final_model_path = path_info['model_path']
torch.save(final_model_data, final_model_path)
progress_manager.set_stage("model_saving", 100)
emit_progress(f"模型已保存到 {final_model_path}")

264
server/utils/file_save.py Normal file
View File

@ -0,0 +1,264 @@
import os
import json
import hashlib
from threading import Lock
from typing import List, Dict, Any, Optional
class ModelPathManager:
"""
根据定义的规则管理模型训练产物的保存路径。
此类旨在集中处理所有与文件系统交互的路径生成逻辑，
确保整个应用程序遵循统一的模型保存标准。
"""
def __init__(self, base_dir: str = 'saved_models'):
"""
初始化路径管理器。
Args:
base_dir (str): 所有模型保存的根目录。
"""
# 始终使用相对于项目根目录的相对路径
self.base_dir = base_dir
self.versions_file = os.path.join(self.base_dir, 'versions.json')
self.lock = Lock()
# 确保根目录存在
os.makedirs(self.base_dir, exist_ok=True)
def _hash_ids(self, ids: List[str]) -> str:
"""
对ID列表进行排序和哈希，生成一个稳定的、简短的哈希值。
Args:
ids (List[str]): 需要哈希的ID列表。
Returns:
str: 代表该ID集合的10位短哈希字符串。
"""
if not ids:
return 'none'
# 排序以确保对于相同集合的ID，即使顺序不同，结果也一样
sorted_ids = sorted([str(i) for i in ids])
id_string = ",".join(sorted_ids)
# 使用SHA256生成哈希值并截取前10位
return hashlib.sha256(id_string.encode('utf-8')).hexdigest()[:10]
def _generate_identifier(self, training_mode: str, **kwargs: Any) -> str:
"""
根据训练模式和参数生成模型的唯一标识符 (identifier)。
这个标识符将作为版本文件中的key，并用于构建目录路径。
Args:
training_mode (str): 训练模式 ('product', 'store', 'global')。
**kwargs: 从API请求中传递的参数字典。
Returns:
str: 模型的唯一标识符。
Raises:
ValueError: 如果缺少必要的参数。
"""
if training_mode == 'product':
product_id = kwargs.get('product_id')
if not product_id:
raise ValueError("按药品训练模式需要 'product_id'。")
# 对于药品训练，数据范围由 store_id 定义
store_id = kwargs.get('store_id')
scope = store_id if store_id is not None else 'all'
return f"product_{product_id}_scope_{scope}"
elif training_mode == 'store':
store_id = kwargs.get('store_id')
if not store_id:
raise ValueError("按店铺训练模式需要 'store_id'。")
product_scope = kwargs.get('product_scope', 'all')
if product_scope == 'specific':
product_ids = kwargs.get('product_ids')
if not product_ids:
raise ValueError("店铺训练选择 specific 范围时需要 'product_ids'。")
# 如果只有一个ID，直接使用ID；否则使用哈希
scope = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)
else:
scope = 'all'
return f"store_{store_id}_products_{scope}"
elif training_mode == 'global':
training_scope = kwargs.get('training_scope', 'all')
if training_scope in ['all', 'all_stores_all_products']:
scope_part = 'all'
elif training_scope == 'selected_stores':
store_ids = kwargs.get('store_ids')
if not store_ids:
raise ValueError("全局训练选择 selected_stores 范围时需要 'store_ids'。")
# 如果只有一个ID，直接使用ID；否则使用哈希
scope_id = store_ids[0] if len(store_ids) == 1 else self._hash_ids(store_ids)
scope_part = f"stores_{scope_id}"
elif training_scope == 'selected_products':
product_ids = kwargs.get('product_ids')
if not product_ids:
raise ValueError("全局训练选择 selected_products 范围时需要 'product_ids'。")
# 如果只有一个ID，直接使用ID；否则使用哈希
scope_id = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)
scope_part = f"products_{scope_id}"
elif training_scope == 'custom':
store_ids = kwargs.get('store_ids')
product_ids = kwargs.get('product_ids')
if not store_ids or not product_ids:
raise ValueError("全局训练选择 custom 范围时需要 'store_ids' 和 'product_ids'。")
s_id = store_ids[0] if len(store_ids) == 1 else self._hash_ids(store_ids)
p_id = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)
scope_part = f"custom_s_{s_id}_p_{p_id}"
else:
raise ValueError(f"未知的全局训练范围: {training_scope}")
aggregation_method = kwargs.get('aggregation_method', 'sum')
return f"global_{scope_part}_agg_{aggregation_method}"
else:
raise ValueError(f"未知的训练模式: {training_mode}")
def get_next_version(self, identifier: str) -> int:
"""
获取指定标识符的下一个版本号。
此方法是线程安全的。
Args:
identifier (str): 模型的唯一标识符。
Returns:
int: 下一个可用的版本号 (从1开始)。
"""
with self.lock:
try:
if os.path.exists(self.versions_file):
with open(self.versions_file, 'r', encoding='utf-8') as f:
versions_data = json.load(f)
else:
versions_data = {}
# 如果标识符不存在，当前版本为0，下一个版本即为1
current_version = versions_data.get(identifier, 0)
return current_version + 1
except (IOError, json.JSONDecodeError) as e:
# 如果文件损坏或读取失败，从0开始
print(f"警告: 读取版本文件 '{self.versions_file}' 失败: {e}。将从版本1开始。")
return 1
def save_version_info(self, identifier: str, new_version: int):
"""
训练成功后，更新版本文件。
此方法是线程安全的。
Args:
identifier (str): 模型的唯一标识符。
new_version (int): 要保存的新的版本号。
"""
with self.lock:
try:
if os.path.exists(self.versions_file):
with open(self.versions_file, 'r', encoding='utf-8') as f:
versions_data = json.load(f)
else:
versions_data = {}
versions_data[identifier] = new_version
with open(self.versions_file, 'w', encoding='utf-8') as f:
json.dump(versions_data, f, indent=4, ensure_ascii=False)
except (IOError, json.JSONDecodeError) as e:
print(f"错误: 保存版本信息到 '{self.versions_file}' 失败: {e}")
# 在这种情况下，可以选择抛出异常或采取其他恢复措施
raise
def get_model_paths(self, training_mode: str, model_type: str, **kwargs: Any) -> Dict[str, Any]:
"""
主入口函数：为一次新的训练获取所有相关路径和版本信息。
此方法会生成唯一的模型标识符，获取新版本号，并构建所有产物的完整路径。
Args:
training_mode (str): 训练模式 ('product', 'store', 'global')。
model_type (str): 模型类型 (e.g., 'mlstm', 'kan')。
**kwargs: 从API请求中传递的参数字典。
Returns:
Dict[str, Any]: 一个包含所有路径和关键信息的字典。
"""
# 1. 生成唯一标识符，并加上模型类型，确保不同模型类型有不同的版本控制
base_identifier = self._generate_identifier(training_mode, **kwargs)
full_identifier = f"{base_identifier}_{model_type}"
# 2. 获取下一个版本号
next_version = self.get_next_version(full_identifier)
version_str = f"v{next_version}"
# 3. 根据规则构建基础路径
if training_mode == 'product':
product_id = kwargs.get('product_id')
store_id = kwargs.get('store_id')
scope = store_id if store_id is not None else 'all'
scope_folder = f"{product_id}_{scope}"
path_parts = [training_mode, scope_folder, model_type, version_str]
elif training_mode == 'store':
store_id = kwargs.get('store_id')
product_scope = kwargs.get('product_scope', 'all')
if product_scope == 'specific':
product_ids = kwargs.get('product_ids', [])
# 如果只有一个ID，直接使用ID；否则使用哈希
scope = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)
else:
scope = 'all'
scope_folder = f"{store_id}_{scope}"
path_parts = [training_mode, scope_folder, model_type, version_str]
elif training_mode == 'global':
aggregation_method = kwargs.get('aggregation_method', 'sum')
training_scope = kwargs.get('training_scope', 'all')
scope_parts = [training_mode]
if training_scope in ['all', 'all_stores_all_products']:
scope_parts.append('all')
elif training_scope == 'selected_stores':
store_ids = kwargs.get('store_ids', [])
scope_id = store_ids[0] if len(store_ids) == 1 else self._hash_ids(store_ids)
scope_parts.extend(['stores', scope_id])
elif training_scope == 'selected_products':
product_ids = kwargs.get('product_ids', [])
scope_id = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)
scope_parts.extend(['products', scope_id])
elif training_scope == 'custom':
store_ids = kwargs.get('store_ids', [])
product_ids = kwargs.get('product_ids', [])
s_id = store_ids[0] if len(store_ids) == 1 else self._hash_ids(store_ids)
p_id = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)
scope_parts.extend(['custom', s_id, p_id])
scope_parts.extend([aggregation_method, model_type, version_str])
path_parts = scope_parts
else:
raise ValueError(f"未知的训练模式: {training_mode}")
# 4. 创建版本目录
version_dir = os.path.join(self.base_dir, *path_parts)
os.makedirs(version_dir, exist_ok=True)
# 创建检查点子目录
checkpoint_dir = os.path.join(version_dir, 'checkpoints')
os.makedirs(checkpoint_dir, exist_ok=True)
# 5. 构建并返回包含所有信息的字典
return {
"identifier": full_identifier,
"version": next_version,
"base_dir": self.base_dir,
"version_dir": version_dir,
"model_path": os.path.join(version_dir, "model.pth"),
"metadata_path": os.path.join(version_dir, "metadata.json"),
"loss_curve_path": os.path.join(version_dir, "loss_curve.png"),
"checkpoint_dir": checkpoint_dir,
"best_checkpoint_path": os.path.join(checkpoint_dir, "checkpoint_best.pth")
}

2
server/utils/multi_store_data_utils.py
View File

@ -268,7 +268,7 @@ def get_store_product_sales_data(store_id: str,
# 数据标准化已在load_multi_store_data中完成
# 验证必要的列是否存在
required_columns = ['sales', 'price', 'weekday', 'month', 'is_holiday', 'is_weekend', 'is_promotion', 'temperature']
required_columns = ['sales', 'weekday', 'month', 'is_holiday', 'is_weekend', 'is_promotion', 'temperature']
missing_columns = [col for col in required_columns if col not in df.columns]
if missing_columns:

44
server/utils/training_process_manager.py
View File

@ -24,6 +24,7 @@ server_dir = os.path.dirname(current_dir)
sys.path.append(server_dir)
from utils.logging_config import setup_api_logging, get_training_logger, log_training_progress
from utils.file_save import ModelPathManager
import numpy as np
def convert_numpy_types(obj):
@ -53,6 +54,7 @@ class TrainingTask:
error: Optional[str] = None
metrics: Optional[Dict[str, Any]] = None
process_id: Optional[int] = None
path_info: Optional[Dict[str, Any]] = None # 新增字段
class TrainingWorker:
"""训练工作进程"""
@ -137,7 +139,7 @@ class TrainingWorker:
except Exception as e:
training_logger.error(f"进度回调失败: {e}")
# 执行真正的训练，传递进度回调
# 执行真正的训练，传递进度回调和路径信息
metrics = predictor.train_model(
product_id=task.product_id,
model_type=task.model_type,
@ -146,7 +148,8 @@ class TrainingWorker:
training_mode=task.training_mode,
socketio=None, # 子进程中不能直接使用socketio
task_id=task.task_id,
progress_callback=progress_callback # 传递进度回调函数
progress_callback=progress_callback, # 传递进度回调函数
path_info=task.path_info # 传递路径信息
)
# 发送训练完成日志到主控制台
@ -235,6 +238,7 @@ class TrainingProcessManager:
# 设置日志
self.logger = setup_api_logging()
self.path_manager = ModelPathManager() # 实例化
def start(self):
"""启动进程管理器"""
@ -281,18 +285,23 @@ class TrainingProcessManager:
self.logger.info("✅ 训练进程管理器已停止")
def submit_task(self, product_id: str, model_type: str, training_mode: str = "product",
store_id: str = None, epochs: int = 100, **kwargs) -> str:
"""提交训练任务"""
def submit_task(self, training_params: Dict[str, Any], path_info: Dict[str, Any]) -> str:
"""
提交训练任务
Args:
training_params (Dict[str, Any]): 来自API请求的原始参数
path_info (Dict[str, Any]): 由ModelPathManager生成的路径和版本信息
"""
task_id = str(uuid.uuid4())
task = TrainingTask(
task_id=task_id,
product_id=product_id,
model_type=model_type,
training_mode=training_mode,
store_id=store_id,
epochs=epochs
product_id=training_params.get('product_id'),
model_type=training_params.get('model_type'),
training_mode=training_params.get('training_mode', 'product'),
store_id=training_params.get('store_id'),
epochs=training_params.get('epochs', 100),
path_info=path_info # 存储路径信息
)
with self.lock:
@ -301,7 +310,7 @@ class TrainingProcessManager:
# 将任务放入队列
self.task_queue.put(asdict(task))
self.logger.info(f"📋 训练任务已提交: {task_id[:8]} | {model_type} | {product_id}")
self.logger.info(f"📋 训练任务已提交: {task_id[:8]} | {task.model_type} | {task.product_id}")
return task_id
def get_task_status(self, task_id: str) -> Optional[Dict[str, Any]]:
@ -344,6 +353,19 @@ class TrainingProcessManager:
# 使用转换后的数据更新任务状态
for key, value in serializable_task_data.items():
setattr(self.tasks[task_id], key, value)
# 如果任务成功完成，则更新版本文件
if action == 'complete':
task = self.tasks[task_id]
if task.path_info:
identifier = task.path_info.get('identifier')
version = task.path_info.get('version')
if identifier and version:
try:
self.path_manager.save_version_info(identifier, version)
self.logger.info(f"✅ 版本信息已更新: identifier={identifier}, version={version}")
except Exception as e:
self.logger.error(f"❌ 更新版本文件失败: {e}")
# WebSocket通知 - 使用已转换的数据
if self.websocket_callback:

259
test/test_file_save_logic.py Normal file
View File

@ -0,0 +1,259 @@
import os
import sys
import shutil
import json
# 将项目根目录添加到系统路径，以便导入server模块
project_root = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
sys.path.insert(0, project_root)
from server.utils.file_save import ModelPathManager
def run_tests():
"""执行所有路径生成逻辑的测试"""
# --- 测试设置 ---
test_base_dir = 'test_saved_models'
if os.path.exists(test_base_dir):
shutil.rmtree(test_base_dir) # 清理旧的测试目录
path_manager = ModelPathManager(base_dir=test_base_dir)
model_type = 'mlstm'
print("="*50)
print("🚀 开始测试 ModelPathManager 路径生成逻辑...")
print(f"测试根目录: {os.path.abspath(test_base_dir)}")
print("="*50)
# --- 1. 按店铺训练 (Store Training) 测试 ---
print("\n--- 🧪 1. 按店铺训练 (Store Training) ---")
# a) 店铺训练 - 所有药品
print("\n[1a] 场景: 店铺训练 - 所有药品")
store_payload_all = {
'store_id': 'S001',
'model_type': model_type,
'training_mode': 'store',
'product_scope': 'all'
}
payload = store_payload_all.copy()
payload.pop('model_type', None)
payload.pop('training_mode', None)
paths_store_all = path_manager.get_model_paths(training_mode='store', model_type=model_type, **payload)
print(f" - Identifier: {paths_store_all['identifier']}")
print(f" - Version Dir: {paths_store_all['version_dir']}")
assert f"store_S001_products_all_{model_type}" == paths_store_all['identifier']
expected_path = os.path.join(test_base_dir, 'store', 'S001_all', model_type, 'v1')
assert os.path.normpath(expected_path) == os.path.normpath(paths_store_all['version_dir'])
# b) 店铺训练 - 特定药品 (使用哈希)
print("\n[1b] 场景: 店铺训练 - 特定药品 (使用哈希)")
store_payload_specific = {
'store_id': 'S002',
'model_type': model_type,
'training_mode': 'store',
'product_scope': 'specific',
'product_ids': ['P001', 'P005', 'P002']
}
payload = store_payload_specific.copy()
payload.pop('model_type', None)
payload.pop('training_mode', None)
paths_store_specific = path_manager.get_model_paths(training_mode='store', model_type=model_type, **payload)
hashed_ids = path_manager._hash_ids(['P001', 'P005', 'P002'])
print(f" - Hashed IDs: {hashed_ids}")
print(f" - Identifier: {paths_store_specific['identifier']}")
print(f" - Version Dir: {paths_store_specific['version_dir']}")
assert f"store_S002_products_{hashed_ids}_{model_type}" == paths_store_specific['identifier']
expected_path = os.path.join(test_base_dir, 'store', f'S002_{hashed_ids}', model_type, 'v1')
assert os.path.normpath(expected_path) == os.path.normpath(paths_store_specific['version_dir'])
# c) 店铺训练 - 单个指定药品
print("\n[1c] 场景: 店铺训练 - 单个指定药品")
store_payload_single_product = {
'store_id': 'S003',
'model_type': model_type,
'training_mode': 'store',
'product_scope': 'specific',
'product_ids': ['P789']
}
payload = store_payload_single_product.copy()
payload.pop('model_type', None)
payload.pop('training_mode', None)
paths_store_single_product = path_manager.get_model_paths(training_mode='store', model_type=model_type, **payload)
print(f" - Identifier: {paths_store_single_product['identifier']}")
print(f" - Version Dir: {paths_store_single_product['version_dir']}")
assert f"store_S003_products_P789_{model_type}" == paths_store_single_product['identifier']
expected_path = os.path.join(test_base_dir, 'store', 'S003_P789', model_type, 'v1')
assert os.path.normpath(expected_path) == os.path.normpath(paths_store_single_product['version_dir'])
# --- 2. 按药品训练 (Product Training) 测试 ---
print("\n--- 🧪 2. 按药品训练 (Product Training) ---")
# a) 药品训练 - 所有店铺
print("\n[2a] 场景: 药品训练 - 所有店铺")
product_payload_all = {
'product_id': 'P123',
'model_type': model_type,
'training_mode': 'product',
'store_id': None # 明确测试 None 的情况
}
payload = product_payload_all.copy()
payload.pop('model_type', None)
payload.pop('training_mode', None)
paths_product_all = path_manager.get_model_paths(training_mode='product', model_type=model_type, **payload)
print(f" - Identifier: {paths_product_all['identifier']}")
print(f" - Version Dir: {paths_product_all['version_dir']}")
assert f"product_P123_scope_all_{model_type}" == paths_product_all['identifier']
expected_path = os.path.join(test_base_dir, 'product', 'P123_all', model_type, 'v1')
assert os.path.normpath(expected_path) == os.path.normpath(paths_product_all['version_dir'])
# b) 药品训练 - 特定店铺
print("\n[2b] 场景: 药品训练 - 特定店铺")
product_payload_specific = {
'product_id': 'P456',
'store_id': 'S003',
'model_type': model_type,
'training_mode': 'product'
}
payload = product_payload_specific.copy()
payload.pop('model_type', None)
payload.pop('training_mode', None)
paths_product_specific = path_manager.get_model_paths(training_mode='product', model_type=model_type, **payload)
print(f" - Identifier: {paths_product_specific['identifier']}")
print(f" - Version Dir: {paths_product_specific['version_dir']}")
assert f"product_P456_scope_S003_{model_type}" == paths_product_specific['identifier']
expected_path = os.path.join(test_base_dir, 'product', 'P456_S003', model_type, 'v1')
assert os.path.normpath(expected_path) == os.path.normpath(paths_product_specific['version_dir'])
# --- 3. 全局训练 (Global Training) 测试 ---
print("\n--- 🧪 3. 全局训练 (Global Training) ---")
# a) 全局训练 - 所有数据
print("\n[3a] 场景: 全局训练 - 所有数据")
global_payload_all = {
'model_type': model_type,
'training_mode': 'global',
'training_scope': 'all',
'aggregation_method': 'sum'
}
payload = global_payload_all.copy()
payload.pop('model_type', None)
payload.pop('training_mode', None)
paths_global_all = path_manager.get_model_paths(training_mode='global', model_type=model_type, **payload)
print(f" - Identifier: {paths_global_all['identifier']}")
print(f" - Version Dir: {paths_global_all['version_dir']}")
assert f"global_all_agg_sum_{model_type}" == paths_global_all['identifier']
expected_path = os.path.join(test_base_dir, 'global', 'all', 'sum', model_type, 'v1')
assert os.path.normpath(expected_path) == os.path.normpath(paths_global_all['version_dir'])
# a2) 全局训练 - 所有数据 (使用 all_stores_all_products)
print("\n[3a2] 场景: 全局训练 - 所有数据 (使用 'all_stores_all_products')")
global_payload_all_alt = {
'model_type': model_type,
'training_mode': 'global',
'training_scope': 'all_stores_all_products',
'aggregation_method': 'sum'
}
payload = global_payload_all_alt.copy()
payload.pop('model_type', None)
payload.pop('training_mode', None)
paths_global_all_alt = path_manager.get_model_paths(training_mode='global', model_type=model_type, **payload)
assert f"global_all_agg_sum_{model_type}" == paths_global_all_alt['identifier']
assert os.path.normpath(expected_path) == os.path.normpath(paths_global_all_alt['version_dir'])
# b) 全局训练 - 自定义范围 (使用哈希)
print("\n[3b] 场景: 全局训练 - 自定义范围 (使用哈希)")
global_payload_custom = {
'model_type': model_type,
'training_mode': 'global',
'training_scope': 'custom',
'aggregation_method': 'mean',
'store_ids': ['S001', 'S003'],
'product_ids': ['P001', 'P002']
}
payload = global_payload_custom.copy()
payload.pop('model_type', None)
payload.pop('training_mode', None)
paths_global_custom = path_manager.get_model_paths(training_mode='global', model_type=model_type, **payload)
s_hash = path_manager._hash_ids(['S001', 'S003'])
p_hash = path_manager._hash_ids(['P001', 'P002'])
print(f" - Store Hash: {s_hash}, Product Hash: {p_hash}")
print(f" - Identifier: {paths_global_custom['identifier']}")
print(f" - Version Dir: {paths_global_custom['version_dir']}")
assert f"global_custom_s_{s_hash}_p_{p_hash}_agg_mean_{model_type}" == paths_global_custom['identifier']
expected_path = os.path.join(test_base_dir, 'global', 'custom', s_hash, p_hash, 'mean', model_type, 'v1')
assert os.path.normpath(expected_path) == os.path.normpath(paths_global_custom['version_dir'])
# c) 全局训练 - 单个店铺
print("\n[3c] 场景: 全局训练 - 单个店铺")
global_payload_single_store = {
'model_type': model_type,
'training_mode': 'global',
'training_scope': 'selected_stores',
'aggregation_method': 'mean',
'store_ids': ['S007']
}
payload = global_payload_single_store.copy()
payload.pop('model_type', None)
payload.pop('training_mode', None)
paths_global_single_store = path_manager.get_model_paths(training_mode='global', model_type=model_type, **payload)
print(f" - Identifier: {paths_global_single_store['identifier']}")
print(f" - Version Dir: {paths_global_single_store['version_dir']}")
assert f"global_stores_S007_agg_mean_{model_type}" == paths_global_single_store['identifier']
expected_path = os.path.join(test_base_dir, 'global', 'stores', 'S007', 'mean', model_type, 'v1')
assert os.path.normpath(expected_path) == os.path.normpath(paths_global_single_store['version_dir'])
# d) 全局训练 - 自定义范围 (单ID)
print("\n[3d] 场景: 全局训练 - 自定义范围 (单ID)")
global_payload_custom_single = {
'model_type': model_type,
'training_mode': 'global',
'training_scope': 'custom',
'aggregation_method': 'mean',
'store_ids': ['S008'],
'product_ids': ['P888']
}
payload = global_payload_custom_single.copy()
payload.pop('model_type', None)
payload.pop('training_mode', None)
paths_global_custom_single = path_manager.get_model_paths(training_mode='global', model_type=model_type, **payload)
print(f" - Identifier: {paths_global_custom_single['identifier']}")
print(f" - Version Dir: {paths_global_custom_single['version_dir']}")
assert f"global_custom_s_S008_p_P888_agg_mean_{model_type}" == paths_global_custom_single['identifier']
expected_path = os.path.join(test_base_dir, 'global', 'custom', 'S008', 'P888', 'mean', model_type, 'v1')
assert os.path.normpath(expected_path) == os.path.normpath(paths_global_custom_single['version_dir'])
# --- 4. 版本管理测试 ---
print("\n--- 🧪 4. 版本管理测试 ---")
print("\n[4a] 场景: 多次调用同一训练，版本号递增")
# 第一次训练
path_manager.save_version_info(paths_store_all['identifier'], paths_store_all['version'])
print(f" - 保存版本: {paths_store_all['identifier']} -> v{paths_store_all['version']}")
# 第二次训练
payload = store_payload_all.copy()
payload.pop('model_type', None)
payload.pop('training_mode', None)
paths_store_all_v2 = path_manager.get_model_paths(training_mode='store', model_type=model_type, **payload)
print(f" - 获取新版本: {paths_store_all_v2['identifier']} -> v{paths_store_all_v2['version']}")
assert paths_store_all_v2['version'] == 2
expected_path = os.path.join(test_base_dir, 'store', 'S001_all', model_type, 'v2')
assert os.path.normpath(expected_path) == os.path.normpath(paths_store_all_v2['version_dir'])
# 验证 versions.json 文件
with open(path_manager.versions_file, 'r') as f:
versions_data = json.load(f)
print(f" - versions.json 内容: {versions_data}")
assert versions_data[paths_store_all['identifier']] == 1
print("\n="*50)
print("✅ 所有测试用例通过！")
print("="*50)
# --- 清理 ---
shutil.rmtree(test_base_dir)
print(f"🗑️ 测试目录 '{test_base_dir}' 已清理。")
if __name__ == '__main__':
run_tests()

223
xz修改记录日志和启动依赖.md
View File

@ -800,4 +800,225 @@
3. 在脚本中导入了新的 `Shop` 图标。
### 结果
仪表盘现在直接提供到“店铺管理”页面的快捷入口，提高了操作效率。
仪表盘现在直接提供到“店铺管理”页面的快捷入口，提高了操作效率。
---
**日期**: 2025-07-18
**主题**: 模型保存逻辑重构与集中化管理
### 目标
根据 `xz训练模型保存规则.md`，将系统中分散的模型文件保存逻辑统一重构，创建一个集中、健壮且可测试的路径管理系统。
### 核心成果
1. **创建了 `server/utils/file_save.py` 模块**: 这个新模块现在是系统中处理模型文件保存路径的唯一权威来源。
2. **实现了三种训练模式的路径生成**: 系统现在可以为“按店铺”、“按药品”和“全局”三种训练模式正确生成层级化的、可追溯的目录结构。
3. **集成了智能ID处理**:
* 对于包含**多个ID**的训练场景，系统会自动计算一个简短的哈希值作为目录名。
* 对于全局训练中只包含**单个店铺或药品ID**的场景，系统会直接使用该ID作为目录名，增强了路径的可读性。
4. **重构了整个训练流程**: 修改了API层、进程管理层以及所有模型训练器，使它们能够协同使用新的路径管理模块。
5. **添加了自动化测试**: 创建了 `test/test_file_save_logic.py` 脚本，用于验证所有路径生成和版本管理逻辑的正确性。
### 详细文件修改记录
1. **`server/utils/file_save.py`**
* **操作**: 创建
* **内容**: 实现了 `ModelPathManager` 类，包含以下核心方法：
* `_hash_ids`: 对ID列表进行排序和哈希。
* `_generate_identifier`: 根据训练模式和参数生成唯一的模型标识符。
* `get_next_version` / `save_version_info`: 线程安全地管理 `versions.json` 文件，实现版本号的获取和更新。
* `get_model_paths`: 作为主入口，协调以上方法，生成包含所有产物路径的字典。
2. **`server/api.py`**
* **操作**: 修改
* **位置**: `start_training` 函数 (`/api/training` 端点)。
* **内容**:
* 导入并实例化 `ModelPathManager`。
* 在接收到训练请求后，调用 `path_manager.get_model_paths()` 来获取所有路径信息。
* 将获取到的 `path_info` 字典和原始请求参数 `training_params` 一并传递给后台训练任务管理器。
* 修复了因重复传递关键字参数 (`model_type`, `training_mode`) 导致的 `TypeError`。
* 修复了 `except` 块中因未导入 `traceback` 模块导致的 `UnboundLocalError`。
3. **`server/utils/training_process_manager.py`**
* **操作**: 修改
* **内容**:
* 修改 `submit_task` 方法，使其能接收 `training_params` 和 `path_info` 字典。
* 在 `TrainingTask` 数据类中增加了 `path_info` 字段来存储路径信息。
* 在 `TrainingWorker` 中，将 `path_info` 传递给实际的训练函数。
* 在 `_monitor_results` 方法中，当任务成功完成时，调用 `path_manager.save_version_info` 来更新 `versions.json`，完成版本管理的闭环。
4. **所有训练器文件** (`mlstm_trainer.py`, `kan_trainer.py`, `tcn_trainer.py`, `transformer_trainer.py`)
* **操作**: 修改
* **内容**:
* 统一修改了主训练函数的签名，增加了 `path_info=None` 参数。
* 移除了所有内部手动构建文件路径的逻辑。
* 所有保存操作（最终模型、检查点、损失曲线图）现在都直接从传入的 `path_info` 字典中获取预先生成好的路径。
* 简化了 `save_checkpoint` 辅助函数，使其也依赖 `path_info`。
5. **`test/test_file_save_logic.py`**
* **操作**: 创建
* **内容**:
* 编写了一个独立的测试脚本，用于验证 `ModelPathManager` 的所有功能。
* 覆盖了所有训练模式及其子场景（包括单ID和多ID哈希）。
* 测试了版本号的正确递增和 `versions.json` 的写入。
* 修复了测试脚本中因绝对/相对路径不匹配和重复关键字参数导致的多个 `AssertionError` 和 `TypeError`。
---
**日期**: 2025-07-18 (后续修复)
**主题**: 修复API层调用路径管理器时的 `TypeError`
### 问题描述
在完成所有重构和测试后，实际运行API时，`POST /api/training` 端点在调用 `path_manager.get_model_paths` 时崩溃，并抛出 `TypeError: get_model_paths() got multiple values for keyword argument 'training_mode'`。
### 根本原因
这是一个回归错误。在修复测试脚本 `test_file_save_logic.py` 中的类似问题时，我未能将相同的修复逻辑应用回 `server/api.py`。代码在调用 `get_model_paths` 时，既通过关键字参数 `training_mode=...` 明确传递了该参数，又通过 `**data` 将其再次传入，导致了冲突。
### 解决方案
1. **文件**: `server/api.py`
2. **位置**: `start_training` 函数。
3. **操作**: 修改了对 `get_model_paths` 的调用逻辑。
4. **内容**:
```python
# 移除 model_type 和 training_mode 以避免重复关键字参数错误
data_for_path = data.copy()
data_for_path.pop('model_type', None)
data_for_path.pop('training_mode', None)
path_info = path_manager.get_model_paths(
training_mode=training_mode,
model_type=model_type,
**data_for_path # 传递剩余的payload
)
```
5. **原因**: 在通过 `**` 解包传递参数之前，先从字典副本中移除了所有会被明确指定的关键字参数，从而确保了函数调用签名的正确性。
---
**日期**: 2025-07-18 (最终修复)
**主题**: 修复因中间层函数签名未更新导致的 `TypeError`
### 问题描述
在完成所有重构后，实际运行API并触发训练任务时，程序在后台进程中因 `TypeError: train_model() got an unexpected keyword argument 'path_info'` 而崩溃。
### 根本原因
这是一个典型的“中间人”遗漏错误。我成功地修改了调用链的两端（`api.py` -> `training_process_manager.py` 和 `*_trainer.py`），但忘记了修改它们之间的中间层——`server/core/predictor.py` 中的 `train_model` 方法。`training_process_manager` 尝试将 `path_info` 传递给 `predictor.train_model`，但后者的函数签名中并未包含这个新参数，导致了 `TypeError`。
### 解决方案
1. **文件**: `server/core/predictor.py`
2. **位置**: `train_model` 函数的定义处。
3. **操作**: 在函数签名中增加了 `path_info=None` 参数。
4. **内容**:
```python
def train_model(self, ..., progress_callback=None, path_info=None):
# ...
```
5. **位置**: `train_model` 函数内部，对所有具体训练器（`train_product_model_with_mlstm`, `_with_kan`, etc.）的调用处。
6. **操作**: 在所有调用中，将接收到的 `path_info` 参数透传下去。
7. **内容**:
```python
# ...
metrics = train_product_model_with_transformer(
...,
path_info=path_info
)
# ...
```
8. **原因**: 通过在中间层函数上“打通”`path_info` 参数的传递通道，确保了从API层到最终训练器层的完整数据流，解决了 `TypeError`。
---
**日期**: 2025-07-18 (最终修复)
**主题**: 修复“按药品训练-聚合所有店铺”模式下的路径生成错误
### 问题描述
在实际运行中发现，当进行“按药品训练”并选择“聚合所有店铺”时，生成的模型保存路径中包含了错误的后缀 `_None`，而不是预期的 `_all` (例如 `.../17002608_None/...`)。
### 根本原因
在 `server/utils/file_save.py` 的 `_generate_identifier` 和 `get_model_paths` 方法中，当 `store_id` 从前端传来为 `None` 时，代码 `scope = store_id if store_id else 'all'` 会因为 `store_id` 是 `None` 而正确地将 `scope` 设为 `'all'`。然而，在 `get_model_paths` 方法中，我错误地使用了 `kwargs.get('store_id', 'all')`，这在 `store_id` 键存在但值为 `None` 时，仍然会返回 `None`，导致了路径拼接错误。
### 解决方案
1. **文件**: `server/utils/file_save.py`
2. **位置**: `_generate_identifier` 和 `get_model_paths` 方法中处理 `product` 训练模式的部分。
3. **操作**: 将逻辑从 `scope = kwargs.get('store_id', 'all')` 修改为更严谨的 `scope = store_id if store_id is not None else 'all'`。
4. **内容**:
```python
# in _generate_identifier
scope = store_id if store_id is not None else 'all'
# in get_model_paths
store_id = kwargs.get('store_id')
scope = store_id if store_id is not None else 'all'
scope_folder = f"{product_id}_{scope}"
```
5. **原因**: 这种写法能正确处理 `store_id` 键不存在、或键存在但值为 `None` 的两种情况，确保在这两种情况下 `scope` 都被正确地设置为 `'all'`，从而生成符合规范的路径。
---
**日期**: 2025-07-18 (最终修复)
**主题**: 修复 `KeyError: 'price'` 和单ID哈希错误
### 问题描述
在完成大规模重构后，实际运行时发现了两个隐藏的bug：
1. 在“按店铺训练”模式下，训练因 `KeyError: 'price'` 而失败。
2. 在“按店铺训练”模式下，当只选择一个“指定药品”时，系统仍然错误地对该药品的ID进行了哈希处理，而不是直接使用ID。
### 根本原因
1. **`KeyError`**: `server/utils/multi_store_data_utils.py` 中的 `get_store_product_sales_data` 函数包含了一个硬编码的列校验，该校验要求 `price` 列必须存在，但这与当前的数据源不符。
2. **哈希错误**: `server/utils/file_save.py` 中的 `get_model_paths` 方法在处理 `store` 训练模式时，没有复用 `_generate_identifier` 中已经写好的单ID判断逻辑，导致了逻辑不一致。
### 解决方案
1. **修复 `KeyError`**:
* **文件**: `server/utils/multi_store_data_utils.py`
* **位置**: `get_store_product_sales_data` 函数。
* **操作**: 从 `required_columns` 列表中移除了 `'price'`，根除了这个硬性依赖。
2. **修复哈希逻辑**:
* **文件**: `server/utils/file_save.py`
* **位置**: `_generate_identifier` 和 `get_model_paths` 方法中处理 `store` 训练模式的部分。
* **操作**: 统一了逻辑，确保在这两个地方都使用了 `scope = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)` 的判断，从而在只选择一个药品时直接使用其ID。
3. **更新测试**:
* **文件**: `test/test_file_save_logic.py`
* **操作**: 增加了新的测试用例，专门验证“按店铺训练-单个指定药品”场景下的路径生成是否正确。
---
**日期**: 2025-07-18 (最终修复)
**主题**: 修复全局训练范围值不匹配导致的 `ValueError`
### 问题描述
在完成所有重构后，实际运行API并触发“全局训练-所有店铺所有药品”时，程序因 `ValueError: 未知的全局训练范围: all_stores_all_products` 而崩溃。
### 根本原因
前端传递的 `training_scope` 值为 `all_stores_all_products`，而 `server/utils/file_save.py` 中的 `_generate_identifier` 和 `get_model_paths` 方法只处理了 `all` 这个值，未能兼容前端传递的具体字符串，导致逻辑判断失败。
### 解决方案
1. **文件**: `server/utils/file_save.py`
2. **位置**: `_generate_identifier` 和 `get_model_paths` 方法中处理 `global` 训练模式的部分。
3. **操作**: 将逻辑判断从 `if training_scope == 'all':` 修改为 `if training_scope in ['all', 'all_stores_all_products']:`。
4. **原因**: 使代码能够同时兼容两种表示“所有范围”的字符串，确保了前端请求的正确处理。
5. **更新测试**:
* **文件**: `test/test_file_save_logic.py`
* **操作**: 增加了新的测试用例，专门验证 `training_scope` 为 `all_stores_all_products` 时的路径生成是否正确。
---
**日期**: 2025-07-18 (最终优化)
**主题**: 优化全局训练自定义模式下的单ID路径生成
### 问题描述
根据用户反馈，希望在全局训练的“自定义范围”模式下，如果只选择单个店铺和/或单个药品，路径中应直接使用ID而不是哈希值，以增强可读性。
### 解决方案
1. **文件**: `server/utils/file_save.py`
2. **位置**: `_generate_identifier` 和 `get_model_paths` 方法中处理 `global` 训练模式 `custom` 范围的部分。
3. **操作**: 为 `store_ids` 和 `product_ids` 分别增加了单ID判断逻辑。
4. **内容**:
```python
# in _generate_identifier
s_id = store_ids[0] if len(store_ids) == 1 else self._hash_ids(store_ids)
p_id = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)
scope_part = f"custom_s_{s_id}_p_{p_id}"
# in get_model_paths
store_ids = kwargs.get('store_ids', [])
product_ids = kwargs.get('product_ids', [])
s_id = store_ids[0] if len(store_ids) == 1 else self._hash_ids(store_ids)
p_id = product_ids[0] if len(product_ids) == 1 else self._hash_ids(product_ids)
scope_parts.extend(['custom', s_id, p_id])
```
5. **原因**: 使 `custom` 模式下的路径生成逻辑与 `selected_stores` 和 `selected_products` 模式保持一致，在只选择一个ID时优先使用ID本身，提高了路径的可读性和一致性。
6. **更新测试**:
* **文件**: `test/test_file_save_logic.py`
* **操作**: 增加了新的测试用例，专门验证“全局训练-自定义范围-单ID”场景下的路径生成是否正确。