From a02bc11921693c3548cc442c912732fd96adae97 Mon Sep 17 00:00:00 2001
From: xz2000 <xz20000522@163.com>
Date: Thu, 24 Jul 2025 17:55:10 +0800
Subject: [PATCH] =?UTF-8?q?=E5=B0=86=E8=AE=AD=E7=BB=83=E6=A8=A1=E5=9E=8B?=
 =?UTF-8?q?=E4=BF=A1=E6=81=AF=E4=BF=9D=E5=AD=98=E5=88=B0=E6=95=B0=E6=8D=AE?=
 =?UTF-8?q?=E5=BA=93?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 UI/src/views/ManagementView.vue               |  87 ++-
 UI/src/views/NewPredictionView.vue            | 120 +---
 .../views/prediction/StorePredictionView.vue  |  35 +-
 UI/src/views/training/GlobalTrainingView.vue  |  33 +-
 UI/src/views/training/ProductTrainingView.vue |  21 +-
 UI/src/views/training/StoreTrainingView.vue   |  23 +-
 prediction_history.db                         | Bin 167936 -> 167936 bytes
 server/api.py                                 | 673 ++++++------------
 server/api_backup.py                          |  16 +-
 server/core/config.py                         |  12 +-
 server/core/predictor.py                      |  10 +-
 .../trainers/cnn_bilstm_attention_trainer.py  |  98 ++-
 server/trainers/kan_trainer.py                |  81 ++-
 server/trainers/mlstm_trainer.py              |  87 ++-
 server/trainers/tcn_trainer.py                |  63 +-
 server/trainers/transformer_trainer.py        |  64 +-
 server/trainers/xgboost_trainer.py            |  67 +-
 server/utils/database_utils.py                | 162 +++++
 server/utils/model_manager.py                 |  30 +-
 server/utils/training_process_manager.py      |  41 +-
 server/utils/visualization.py                 |  32 +-
 xz数据库2025_07_24.md                         |  54 ++
 22 files changed, 1017 insertions(+), 792 deletions(-)
 create mode 100644 server/utils/database_utils.py
 create mode 100644 xz数据库2025_07_24.md

diff --git a/UI/src/views/ManagementView.vue b/UI/src/views/ManagementView.vue
index 7c251f4..b8f5ccc 100644
--- a/UI/src/views/ManagementView.vue
+++ b/UI/src/views/ManagementView.vue
@@ -35,49 +35,50 @@
     </el-form>
 
     <el-table :data="models" stripe v-loading="loading">
-      <el-table-column prop="model_id" label="模型ID" min-width="150">
+      <el-table-column prop="display_name" label="模型名称" min-width="180">
+        <template #default="{ row }">
+          <el-tooltip :content="`UID: ${row.model_uid}`" placement="top">
+            <span>{{ row.display_name }}</span>
+          </el-tooltip>
+        </template>
+      </el-table-column>
+      <el-table-column prop="model_type" label="模型类型" min-width="120">
         <template #default="{ row }">
           <el-tag size="small" :type="getModelTagType(row.model_type)">
             {{ row.model_type }}
           </el-tag>
-          <span style="margin-left: 8px">{{ row.product_id }}</span>
         </template>
       </el-table-column>
-      <el-table-column prop="product_name" label="产品名称" min-width="120"></el-table-column>
+      <el-table-column prop="training_mode" label="训练模式" min-width="120"></el-table-column>
       <el-table-column prop="created_at" label="创建时间" min-width="160">
         <template #default="{ row }">
           {{ formatDateTime(row.created_at) }}
         </template>
       </el-table-column>
-      <el-table-column label="评估指标" min-width="200">
-            <template #default="{ row }">
-              <div class="metrics-display">
-                <el-tooltip effect="dark" content="R平方值" placement="top">
-                  <div class="metric-item">
-                    <span class="metric-label">R²:</span>
-                    <span class="metric-value">{{ row.metrics?.R2?.toFixed(4) || 'N/A' }}</span>
-                  </div>
-                </el-tooltip>
-                <el-tooltip effect="dark" content="均方根误差" placement="top">
-                  <div class="metric-item">
-                    <span class="metric-label">RMSE:</span>
-                    <span class="metric-value">{{ row.metrics?.RMSE?.toFixed(4) || 'N/A' }}</span>
-                  </div>
-                </el-tooltip>
-                 <el-tooltip effect="dark" content="平均绝对误差" placement="top">
-                  <div class="metric-item">
-                    <span class="metric-label">MAE:</span>
-                    <span class="metric-value">{{ row.metrics?.MAE?.toFixed(4) || 'N/A' }}</span>
-                  </div>
-                </el-tooltip>
-                <el-tooltip effect="dark" content="平均绝对百分比误差" placement="top">
-                  <div class="metric-item">
-                    <span class="metric-label">MAPE:</span>
-                    <span class="metric-value">{{ row.metrics?.MAPE?.toFixed(2) || 'N/A' }}%</span>
-                  </div>
-                </el-tooltip>
+      <el-table-column label="评估指标" min-width="220">
+        <template #default="{ row }">
+          <div class="metrics-display" v-if="row.performance_metrics && Object.keys(row.performance_metrics).length > 0">
+            <el-tooltip effect="dark" content="R平方值" placement="top">
+              <div class="metric-item">
+                <span class="metric-label">R²:</span>
+                <span class="metric-value">{{ row.performance_metrics.R2?.toFixed(4) || 'N/A' }}</span>
               </div>
-            </template>
+            </el-tooltip>
+            <el-tooltip effect="dark" content="均方根误差" placement="top">
+              <div class="metric-item">
+                <span class="metric-label">RMSE:</span>
+                <span class="metric-value">{{ row.performance_metrics.RMSE?.toFixed(4) || 'N/A' }}</span>
+              </div>
+            </el-tooltip>
+            <el-tooltip effect="dark" content="平均绝对误差" placement="top">
+              <div class="metric-item">
+                <span class="metric-label">MAE:</span>
+                <span class="metric-value">{{ row.performance_metrics.MAE?.toFixed(4) || 'N/A' }}</span>
+              </div>
+            </el-tooltip>
+          </div>
+          <span v-else>无</span>
+        </template>
       </el-table-column>
       <el-table-column label="操作" width="280" fixed="right">
         <template #default="{ row }">
@@ -254,7 +255,7 @@ const fetchModels = async () => {
     const response = await axios.get('/api/models', { params })
     if (response.data.status === 'success') {
       models.value = response.data.data.map(model => {
-        model.metrics = normalizeMetricsKeys(model.metrics);
+        model.performance_metrics = normalizeMetricsKeys(model.performance_metrics);
         return model;
       });
       
@@ -291,7 +292,23 @@ const viewDetails = async (model) => {
   detailsDialogVisible.value = true;
   selectedModelDetails.value = null; // 重置
   try {
-    const response = await axios.get(`/api/models/${model.model_type}/${model.product_id}/details`);
+    // 新逻辑: 直接使用行数据，因为列表API已返回足够信息
+    const details = {
+      model_info: {
+        model_id: model.model_uid,
+        model_type: model.model_type,
+        product_name: model.display_name,
+        created_at: model.created_at,
+      },
+      training_metrics: model.performance_metrics,
+      chart_data: {
+        loss_chart: model.artifacts?.loss_curve_data || { epochs: [], train_loss: [], test_loss: [] }
+      }
+    };
+    selectedModelDetails.value = details;
+    nextTick(() => {
+      initLossChart();
+    });
     if (response.data.status === 'success') {
       const details = response.data.data;
       details.training_metrics = normalizeMetricsKeys(details.training_metrics);
@@ -311,7 +328,7 @@ const viewDetails = async (model) => {
 
 const deleteModel = async (model) => {
   try {
-    const response = await axios.delete(`/api/models/${model.model_id}`)
+    const response = await axios.delete(`/api/models/${model.model_uid}`)
     if (response.data.status === 'success') {
       ElMessage.success('模型删除成功')
       fetchModels()
@@ -325,7 +342,7 @@ const deleteModel = async (model) => {
 
 const exportModel = async (model) => {
   try {
-    const response = await axios.get(`/api/models/${model.model_id}/export`, { responseType: 'blob' })
+    const response = await axios.get(`/api/models/${model.model_uid}/export`, { responseType: 'blob' })
     const url = window.URL.createObjectURL(new Blob([response.data]))
     const link = document.createElement('a')
     link.href = url
diff --git a/UI/src/views/NewPredictionView.vue b/UI/src/views/NewPredictionView.vue
index a1681c3..329eeab 100644
--- a/UI/src/views/NewPredictionView.vue
+++ b/UI/src/views/NewPredictionView.vue
@@ -96,17 +96,18 @@
             <el-col :span="6">
               <el-form-item label="模型版本">
                 <el-select
-                  v-model="form.version"
-                  placeholder="选择版本"
+                  v-model="form.model_uid"
+                  placeholder="选择一个具体的模型"
                   style="width: 100%"
                   :disabled="!availableVersions.length"
                   :loading="versionsLoading"
+                  value-key="model_uid"
                 >
                   <el-option
-                    v-for="version in availableVersions"
-                    :key="version"
-                    :label="version"
-                    :value="version"
+                    v-for="model in availableVersions"
+                    :key="model.model_uid"
+                    :label="`${model.display_name} (v${model.version})`"
+                    :value="model.model_uid"
                   />
                 </el-select>
                 <div class="version-info">
@@ -176,16 +177,6 @@
           开始预测
         </el-button>
         
-        <el-button
-          v-if="predictionResult"
-          type="success"
-          size="large"
-          @click="savePrediction"
-          :loading="saving"
-        >
-          <el-icon><Download /></el-icon>
-          保存结果
-        </el-button>
       </div>
     </el-card>
 
@@ -274,7 +265,7 @@ const form = reactive({
   product_id: '',
   store_id: '',
   model_type: '',
-  version: '',
+  model_uid: '',
   future_days: 7,
   start_date: '',
   analyze_result: true
@@ -282,18 +273,8 @@ const form = reactive({
 
 // 计算属性
 const canPredict = computed(() => {
-  const baseCheck = form.training_mode && form.model_type && form.version
-  
-  if (form.training_mode === 'product') {
-    return baseCheck && form.product_id
-  } else if (form.training_mode === 'store') {
-    return baseCheck && form.store_id
-  } else if (form.training_mode === 'global') {
-    return baseCheck
-  }
-  
-  return false
-})
+  return !!form.model_uid;
+});
 
 const predictionTableData = computed(() => {
   if (!predictionResult.value || !predictionResult.value.predictions) return []
@@ -329,24 +310,21 @@ const fetchAvailableVersions = async () => {
   }
 
   try {
-    versionsLoading.value = true
-    let url = ''
-    
-    if (form.training_mode === 'product' && form.product_id) {
-      url = `/api/models/${form.product_id}/${form.model_type}/versions`
-    } else if (form.training_mode === 'store' && form.store_id) {
-      url = `/api/models/store/${form.store_id}/${form.model_type}/versions`
-    } else if (form.training_mode === 'global') {
-      url = `/api/models/global/${form.model_type}/versions`
-    }
-    
-    if (url) {
-      const response = await axios.get(url)
-      if (response.data.status === 'success') {
-        availableVersions.value = response.data.data.versions || []
-        if (response.data.data.latest_version) {
-          form.version = response.data.data.latest_version
-        }
+    versionsLoading.value = true;
+    const params = {
+      training_mode: form.training_mode,
+      model_type: form.model_type,
+      product_id: form.training_mode === 'product' ? form.product_id : undefined,
+      store_id: form.training_mode === 'store' ? form.store_id : undefined,
+      page_size: 100 // 获取足够多的模型以供选择
+    };
+
+    const response = await axios.get('/api/models', { params });
+    if (response.data.status === 'success') {
+      availableVersions.value = response.data.data || [];
+      if (availableVersions.value.length > 0) {
+        // 默认选中第一个模型
+        form.model_uid = availableVersions.value[0].model_uid;
       }
     }
   } catch (error) {
@@ -361,22 +339,22 @@ const handleTrainingModeChange = () => {
   form.product_id = ''
   form.store_id = ''
   form.model_type = ''
-  form.version = ''
+  form.model_uid = ''
   availableVersions.value = []
 }
 
 const handleProductChange = () => {
-  form.version = ''
+  form.model_uid = ''
   fetchAvailableVersions()
 }
 
 const handleStoreChange = () => {
-  form.version = ''
+  form.model_uid = ''
   fetchAvailableVersions()
 }
 
 const handleModelTypeChange = () => {
-  form.version = ''
+  form.model_uid = ''
   fetchAvailableVersions()
 }
 
@@ -385,21 +363,14 @@ const startPrediction = async () => {
     predicting.value = true
     
     const payload = {
-      model_type: form.model_type,
-      version: form.version,
+      model_uid: form.model_uid,
       future_days: form.future_days,
       start_date: form.start_date,
-      analyze_result: form.analyze_result
-    }
+      include_visualization: form.analyze_result, // 后端现在叫 include_visualization
+      history_lookback_days: 30
+    };
     
-    // 根据训练模式添加相应参数
-    if (form.training_mode === 'product') {
-      payload.product_id = form.product_id
-    } else if (form.training_mode === 'store') {
-      payload.store_id = form.store_id
-    }
-    
-    const response = await axios.post('/api/predict', payload)
+    const response = await axios.post('/api/prediction', payload);
     
     if (response.data.status === 'success') {
       predictionResult.value = response.data.data
@@ -470,29 +441,6 @@ const renderChart = () => {
   })
 }
 
-const savePrediction = async () => {
-  try {
-    saving.value = true
-    
-    const saveData = {
-      ...predictionResult.value,
-      training_mode: form.training_mode,
-      parameters: { ...form }
-    }
-    
-    const response = await axios.post('/api/predictions/save', saveData)
-    
-    if (response.data.status === 'success') {
-      ElMessage.success('预测结果已保存')
-    } else {
-      ElMessage.error('保存失败')
-    }
-  } catch (error) {
-    ElMessage.error('保存请求失败')
-  } finally {
-    saving.value = false
-  }
-}
 
 // 辅助方法
 const getPredictionInfoText = () => {
diff --git a/UI/src/views/prediction/StorePredictionView.vue b/UI/src/views/prediction/StorePredictionView.vue
index 25aad44..88f6b93 100644
--- a/UI/src/views/prediction/StorePredictionView.vue
+++ b/UI/src/views/prediction/StorePredictionView.vue
@@ -129,33 +129,20 @@ const pagination = reactive({
   pageSize: 8
 })
 
-const storeNameMap = computed(() => {
-  return stores.value.reduce((acc, store) => {
-    acc[store.store_id] = store.store_name
-    return acc
-  }, {})
-})
-
-const modelsWithNames = computed(() => {
-  return modelList.value.map(model => ({
-    ...model,
-    store_name: storeNameMap.value[model.store_id] || model.store_id
-  }))
-})
-
 const filteredModelList = computed(() => {
-  return modelsWithNames.value.filter(model => {
-    const storeMatch = !filters.store_id || model.store_id === filters.store_id
-    const modelTypeMatch = !filters.model_type || model.model_type === filters.model_type.id
-    return storeMatch && modelTypeMatch
-  })
-})
+  return modelList.value.filter(model => {
+    // 简化逻辑：直接使用后端返回的数据进行筛选
+    const storeMatch = !filters.store_id || (model.training_scope?.store?.id === filters.store_id);
+    const modelTypeMatch = !filters.model_type || model.model_type === filters.model_type.id;
+    return storeMatch && modelTypeMatch;
+  });
+});
 
 const paginatedModelList = computed(() => {
-  const start = (pagination.currentPage - 1) * pagination.pageSize
-  const end = start + pagination.pageSize
-  return filteredModelList.value.slice(start, end)
-})
+  const start = (pagination.currentPage - 1) * pagination.pageSize;
+  const end = start + pagination.pageSize;
+  return filteredModelList.value.slice(start, end);
+});
 
 const handlePageChange = (page) => {
   pagination.currentPage = page
diff --git a/UI/src/views/training/GlobalTrainingView.vue b/UI/src/views/training/GlobalTrainingView.vue
index fd398f4..4669a23 100644
--- a/UI/src/views/training/GlobalTrainingView.vue
+++ b/UI/src/views/training/GlobalTrainingView.vue
@@ -604,14 +604,45 @@ const startTraining = async () => {
         ? "/api/training/retrain"
         : "/api/training";
     
+    // 构造 training_scope 对象
+    const training_scope = {
+      stores: "all",
+      products: "all"
+    };
+
+    if (form.training_scope === 'selected_stores' || form.training_scope === 'custom') {
+      if (form.store_ids.length > 0) {
+        training_scope.stores = form.store_ids.map(sid => {
+          const store = stores.value.find(s => s.store_id === sid);
+          return { id: sid, name: store ? store.store_name : sid };
+        });
+      } else {
+        // 如果没有选择店铺，则默认为 all
+        training_scope.stores = "all";
+      }
+    }
+
+    if (form.training_scope === 'selected_products' || form.training_scope === 'custom') {
+      if (form.product_ids.length > 0) {
+        training_scope.products = form.product_ids.map(pid => {
+          const product = products.value.find(p => p.product_id === pid);
+          return { id: pid, name: product ? product.product_name : pid };
+        });
+      } else {
+        // 如果没有选择药品，则默认为 all
+        training_scope.products = "all";
+      }
+    }
+
     const payload = {
       model_type: form.model_type,
       epochs: form.epochs,
       training_mode: 'global',  // 标识这是全局训练模式
-      training_scope: form.training_scope,
+      training_scope: training_scope, // 使用新构建的对象
       aggregation_method: form.aggregation_method
     };
 
+    // 为了向后兼容或调试，仍然可以发送原始ID列表
     if (form.store_ids.length > 0) {
       payload.store_ids = form.store_ids;
     }
diff --git a/UI/src/views/training/ProductTrainingView.vue b/UI/src/views/training/ProductTrainingView.vue
index e5740a3..a934c50 100644
--- a/UI/src/views/training/ProductTrainingView.vue
+++ b/UI/src/views/training/ProductTrainingView.vue
@@ -541,12 +541,31 @@ const startTraining = async () => {
         ? "/api/training/retrain"
         : "/api/training";
     
+    // 构造 training_scope 对象
+    const selectedProduct = products.value.find(p => p.product_id === form.product_id);
+    const training_scope = {
+      product: {
+        id: form.product_id,
+        name: selectedProduct ? selectedProduct.product_name : form.product_id
+      },
+      stores: "all"
+    };
+
+    if (form.data_scope === 'specific' && form.store_id) {
+      const selectedStore = stores.value.find(s => s.store_id === form.store_id);
+      training_scope.stores = [{
+        id: form.store_id,
+        name: selectedStore ? selectedStore.store_name : form.store_id
+      }];
+    }
+
     const payload = {
       product_id: form.product_id,
       store_id: form.data_scope === 'global' ? null : form.store_id,
       model_type: form.model_type,
       epochs: form.epochs,
-      training_mode: 'product'  // 标识这是药品训练模式
+      training_mode: 'product',  // 标识这是药品训练模式
+      training_scope: training_scope // 添加符合新后端要求的 training_scope
     };
 
     if (form.training_type === "retrain") {
diff --git a/UI/src/views/training/StoreTrainingView.vue b/UI/src/views/training/StoreTrainingView.vue
index 29558a6..ee9d29c 100644
--- a/UI/src/views/training/StoreTrainingView.vue
+++ b/UI/src/views/training/StoreTrainingView.vue
@@ -588,12 +588,33 @@ const startTraining = async () => {
         ? "/api/training/retrain"
         : "/api/training";
     
+    // 构造 training_scope 对象
+    const selectedStore = stores.value.find(s => s.store_id === form.store_id);
+    const training_scope = {
+      store: {
+        id: form.store_id,
+        name: selectedStore ? selectedStore.store_name : form.store_id
+      },
+      products: "all"
+    };
+
+    if (form.product_scope === 'specific' && form.product_ids.length > 0) {
+      training_scope.products = form.product_ids.map(pid => {
+        const product = storeProducts.value.find(p => p.product_id === pid);
+        return {
+          id: pid,
+          name: product ? product.product_name : pid
+        };
+      });
+    }
+
     const payload = {
       store_id: form.store_id,
       model_type: form.model_type,
       epochs: form.epochs,
       training_mode: 'store',  // 标识这是店铺训练模式
-      product_scope: form.product_scope
+      product_scope: form.product_scope,
+      training_scope: training_scope // 添加符合新后端要求的 training_scope
     };
 
     if (form.product_scope === 'specific') {
diff --git a/prediction_history.db b/prediction_history.db
index 64b4d8102e34fb1b4dc79b138c3fceb344566fc2..75a2a128203ef5436e137ded173ee0d42bb0a3ee 100644
GIT binary patch
literal 167936
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

literal 167936
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

diff --git a/server/api.py b/server/api.py
index 27702b2..130781b 100644
--- a/server/api.py
+++ b/server/api.py
@@ -65,6 +65,7 @@ from core.config import (
 from utils.multi_store_data_utils import (
     get_available_stores, get_available_products, get_sales_statistics
 )
+from utils.database_utils import query_models_from_db, find_model_by_uid, save_prediction_to_db
 
 # 导入数据库初始化工具
 from init_multi_store_db import get_db_connection
@@ -118,61 +119,69 @@ def init_db():
     """初始化数据库"""
     conn = sqlite3.connect('prediction_history.db')
     cursor = conn.cursor()
-    
-    # 创建预测历史表
+
+    # 废弃旧的 model_versions 表
+    cursor.execute('DROP TABLE IF EXISTS model_versions')
+
+    # 创建新的 models 表
     cursor.execute('''
-    CREATE TABLE IF NOT EXISTS prediction_history (
+    CREATE TABLE IF NOT EXISTS models (
         id INTEGER PRIMARY KEY AUTOINCREMENT,
-        prediction_id TEXT UNIQUE NOT NULL,
-        product_id TEXT NOT NULL,
-        product_name TEXT NOT NULL,
-        model_type TEXT NOT NULL,
-        model_id TEXT NOT NULL,
-        start_date TEXT,
-        future_days INTEGER,
-        created_at TEXT NOT NULL,
-        predictions_data TEXT,
-        metrics TEXT,
-        chart_data TEXT,
-        analysis TEXT,
-        file_path TEXT
-    )
-    ''')
-    
-    # 创建模型版本表
-    cursor.execute('''
-    CREATE TABLE IF NOT EXISTS model_versions (
-        id INTEGER PRIMARY KEY AUTOINCREMENT,
-        product_id TEXT NOT NULL,
+        model_uid TEXT UNIQUE NOT NULL,
+        display_name TEXT,
         model_type TEXT NOT NULL,
+        training_mode TEXT NOT NULL,
+        training_scope TEXT,
+        parent_model_id INTEGER,
         version TEXT NOT NULL,
-        file_path TEXT NOT NULL,
-        created_at TEXT NOT NULL,
-        metrics TEXT,
-        is_active INTEGER DEFAULT 1,
-        UNIQUE(product_id, model_type, version)
+        status TEXT DEFAULT 'active',
+        training_params TEXT,
+        performance_metrics TEXT,
+        artifacts TEXT,
+        created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+        FOREIGN KEY (parent_model_id) REFERENCES models (id)
     )
     ''')
+
+    # 更新 prediction_history 表
+    # 为了平滑过渡，我们先检查表是否存在，然后尝试添加新列
+    cursor.execute("PRAGMA table_info(prediction_history)")
+    columns = [row[1] for row in cursor.fetchall()]
     
-    # 创建索引以提高查询性能
-    cursor.execute('''
-    CREATE INDEX IF NOT EXISTS idx_prediction_product_model 
-    ON prediction_history(product_id, model_type)
-    ''')
-    
-    cursor.execute('''
-    CREATE INDEX IF NOT EXISTS idx_model_versions_product_type 
-    ON model_versions(product_id, model_type)
-    ''')
-    
-    cursor.execute('''
-    CREATE INDEX IF NOT EXISTS idx_model_versions_active 
-    ON model_versions(product_id, model_type, is_active)
-    ''')
-    
+    if 'prediction_uid' not in columns:
+        # 如果表结构很旧，重建它
+        cursor.execute('DROP TABLE IF EXISTS prediction_history')
+        cursor.execute('''
+        CREATE TABLE prediction_history (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            prediction_uid TEXT UNIQUE NOT NULL,
+            model_id TEXT NOT NULL,
+            model_type TEXT,
+            product_name TEXT,
+            prediction_scope TEXT,
+            prediction_params TEXT,
+            metrics TEXT,
+            result_file_path TEXT,
+            created_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        )
+        ''')
+    else:
+        # 否则，只添加缺失的列
+        if 'prediction_scope' not in columns:
+            cursor.execute('ALTER TABLE prediction_history ADD COLUMN prediction_scope TEXT')
+        if 'result_file_path' not in columns:
+            cursor.execute('ALTER TABLE prediction_history ADD COLUMN result_file_path TEXT')
+        # 确保 model_id 字段存在且类型正确
+        # 在SQLite中修改列类型比较复杂，通常建议重建。此处简化处理。
+
+    # 创建索引
+    cursor.execute('CREATE INDEX IF NOT EXISTS idx_models_uid ON models(model_uid)')
+    cursor.execute('CREATE INDEX IF NOT EXISTS idx_models_type_mode ON models(model_type, training_mode)')
+    cursor.execute('CREATE INDEX IF NOT EXISTS idx_prediction_history_model_id ON prediction_history(model_id)')
+
     conn.commit()
     conn.close()
-    print("数据库初始化完成，包含模型版本管理表")
+    print("数据库初始化完成，已更新为新的 `models` 和 `prediction_history` 表结构。")
 
 # 自定义JSON编码器来处理Pandas的Timestamp和NumPy类型
 class CustomJSONEncoder(json.JSONEncoder):
@@ -219,6 +228,8 @@ def convert_numpy_types_for_json(obj):
         return obj
 
 app = Flask(__name__)
+# 解决jsonify中文显示为unicode的问题
+app.config['JSON_AS_ASCII'] = False
 # 设置自定义JSON编码器
 app.json_encoder = CustomJSONEncoder
 app.config['SECRET_KEY'] = 'pharmacy_prediction_secret_key'
@@ -874,7 +885,7 @@ def start_training():
     product_ids = data.get('product_ids', [])
     store_ids = data.get('store_ids', [])
     product_scope = data.get('product_scope', 'all')
-    training_scope = data.get('training_scope', 'all_stores_all_products')
+    # training_scope = data.get('training_scope', 'all_stores_all_products') # 已废弃，由下面的 training_scope_obj 替代
     aggregation_method = data.get('aggregation_method', 'sum')
 
     if not model_type:
@@ -896,12 +907,18 @@ def start_training():
     
     # 使用新的训练进程管理器提交任务
     try:
+        # 修正: 直接从请求中获取完整的 training_scope 对象
+        training_scope_obj = data.get('training_scope')
+        if not training_scope_obj or not isinstance(training_scope_obj, dict):
+            return jsonify({'error': '请求体中缺少有效(必须是JSON对象)的 training_scope 参数'}), 400
+
         task_id = training_manager.submit_task(
             product_id=product_id or "unknown",
             model_type=model_type,
             training_mode=training_mode,
             store_id=store_id,
-            epochs=epochs
+            epochs=epochs,
+            training_scope=training_scope_obj
         )
         
         logger.info(f"🚀 训练任务已提交到进程管理器: {task_id[:8]}")
@@ -1273,8 +1290,8 @@ def get_training_status(task_id):
 @app.route('/api/prediction', methods=['POST'])
 @swag_from({
     'tags': ['模型预测'],
-    'summary': '使用模型进行预测',
-    'description': '使用指定模型预测未来销售数据',
+    'summary': '使用模型进行预测 (v2)',
+    'description': '使用指定模型UID预测未来销售数据',
     'parameters': [
         {
             'name': 'body',
@@ -1283,165 +1300,61 @@ def get_training_status(task_id):
             'schema': {
                 'type': 'object',
                 'properties': {
-                    'product_id': {'type': 'string'},
-                    'model_type': {'type': 'string', 'enum': ['mlstm', 'transformer', 'kan', 'optimized_kan', 'tcn']},
-                    'store_id': {'type': 'string', 'description': '店铺ID，如 S001。为空时使用全局模型'},
-                    'version': {'type': 'string'},
-                    'future_days': {'type': 'integer'},
-                    'include_visualization': {'type': 'boolean'},
-                    'start_date': {'type': 'string', 'description': '预测起始日期，格式为YYYY-MM-DD'}
+                    'model_uid': {'type': 'string', 'description': '要用于预测的模型的唯一ID'},
+                    'future_days': {'type': 'integer', 'default': 7},
+                    'start_date': {'type': 'string', 'description': '预测起始日期 (YYYY-MM-DD)'},
+                    'include_visualization': {'type': 'boolean', 'default': True},
+                    'history_lookback_days': {'type': 'integer', 'default': 30}
                 },
-                'required': ['product_id', 'model_type']
+                'required': ['model_uid']
             }
         }
     ],
     'responses': {
-        200: {
-            'description': '预测成功',
-            'schema': {
-                'type': 'object',
-                'properties': {
-                    'status': {'type': 'string'},
-                    'data': {
-                        'type': 'object',
-                        'properties': {
-                            'product_id': {'type': 'string'},
-                            'product_name': {'type': 'string'},
-                            'model_type': {'type': 'string'},
-                            'predictions': {'type': 'array'},
-                            'visualization': {'type': 'string'}
-                        }
-                    }
-                }
-            }
-        },
-        400: {
-            'description': '请求错误，缺少必要参数或参数格式错误'
-        },
-        404: {
-            'description': '产品或模型不存在'
-        },
-        500: {
-            'description': '服务器内部错误'
-        }
+        200: {'description': '预测成功'},
+        400: {'description': '请求错误'},
+        404: {'description': '模型不存在'},
+        500: {'description': '服务器内部错误'}
     }
 })
 def predict():
     """
-    使用指定的模型进行预测
-    ---
-    tags:
-      - 模型预测
-    parameters:
-      - in: body
-        name: body
-        schema:
-          type: object
-          required:
-            - product_id
-            - model_type
-          properties:
-            product_id:
-              type: string
-              description: 产品ID
-            model_type:
-              type: string
-              description: "模型类型 (mlstm, kan, transformer)"
-            version:
-              type: string
-              description: "模型版本 (v1, v2, v3 等)，如果不指定则使用最新版本"
-            future_days:
-              type: integer
-              description: 预测未来天数
-              default: 7
-            start_date:
-              type: string
-              description: 预测起始日期，格式为YYYY-MM-DD
-              default: ''
-    responses:
-      200:
-        description: 预测成功
-      400:
-        description: 请求参数错误
-      404:
-        description: 模型文件未找到
+    使用指定的模型进行预测 (v2 - 基于数据库)
     """
     try:
         data = request.json
-        model_type = data.get('model_type')
-        version = data.get('version')
+        model_uid = data.get('model_uid')
+        if not model_uid:
+            return jsonify({"status": "error", "message": "缺少 'model_uid' 参数"}), 400
+
+        # 从数据库查找模型记录
+        model_record = find_model_by_uid(model_uid)
+        if not model_record:
+            return jsonify({"status": "error", "message": f"模型UID '{model_uid}' 不存在"}), 404
+
+        # 解析必要的模型元数据
+        model_type = model_record.get('model_type')
+        training_mode = model_record.get('training_mode')
+        version = model_record.get('version')
+        
+        # 解析 artifacts 找到模型文件路径
+        artifacts = json.loads(model_record.get('artifacts', '{}'))
+        model_file_path = artifacts.get('best_model') or artifacts.get('versioned_model')
+        if not model_file_path or not os.path.exists(model_file_path):
+            return jsonify({"status": "error", "message": "找不到模型文件或文件路径无效"}), 404
+
+        # 解析 training_scope 获取 product_id 或 store_id
+        training_scope = json.loads(model_record.get('training_scope', '{}'))
+        product_id = training_scope.get('product', {}).get('id')
+        store_id = training_scope.get('store', {}).get('id')
+
+        # 获取其他预测参数
         future_days = int(data.get('future_days', 7))
         start_date = data.get('start_date', '')
-        include_visualization = data.get('include_visualization', False)
-        history_lookback_days = int(data.get('history_lookback_days', 30)) # 新增参数
+        include_visualization = data.get('include_visualization', True)
+        history_lookback_days = int(data.get('history_lookback_days', 30))
 
-        # 确定训练模式和标识符
-        training_mode = data.get('training_mode', 'product')
-        product_id = data.get('product_id')
-        store_id = data.get('store_id')
-
-        # v2版：根据训练模式和ID构建模型标识符
-        aggregation_method = data.get('aggregation_method', 'sum') # 全局模式需要
-        if training_mode == 'global':
-            model_identifier = f"global_{aggregation_method}"
-            product_name = f"全局聚合数据 ({aggregation_method})"
-        elif training_mode == 'store':
-            if not store_id:
-                return jsonify({"status": "error", "error": "店铺模式需要 store_id"}), 400
-            model_identifier = f"store_{store_id}"
-            product_name = f"店铺 {store_id} 整体"
-        else:  # 默认为 'product' 模式
-            if not product_id:
-                return jsonify({"status": "error", "error": "药品模式需要 product_id"}), 400
-            model_identifier = product_id
-            product_name = get_product_name(product_id) or product_id
-
-        print(f"API接收到预测请求: mode={training_mode}, model_identifier='{model_identifier}', model_type='{model_type}', version='{version}'")
-
-        if not model_type:
-            return jsonify({"status": "error", "error": "model_type 是必需的"}), 400
-
-        # 获取模型版本
-        if not version:
-            version = get_latest_model_version(model_identifier, model_type)
-        
-        if not version:
-            return jsonify({"status": "error", "error": f"未找到标识符为 {model_identifier} 的 {model_type} 类型模型"}), 404
-
-        # v2版：使用 ModelManager 查找模型文件，不再使用旧的 get_model_file_path
-        from utils.model_manager import model_manager
-        
-        # 智能修正 training_mode (兼容前端可能发送的错误模式)
-        if model_identifier.startswith('store_'):
-            training_mode = 'store'
-            store_id = model_identifier.split('_')[1]
-        elif model_identifier.startswith('global_'):
-            training_mode = 'global'
-        
-        # 使用 model_manager 查找模型
-        models_result = model_manager.list_models(
-            model_type=model_type,
-            store_id=store_id if training_mode == 'store' else None,
-            product_id=product_id if training_mode == 'product' else None,
-            training_mode=training_mode
-        )
-        
-        found_model = None
-        for model in models_result.get('models', []):
-            if model.get('version') == version:
-                found_model = model
-                break
-        
-        if not found_model or not found_model.get('file_path'):
-            error_msg = f"在系统中未找到匹配的模型: mode={training_mode}, type={model_type}, id='{model_identifier}', version={version}"
-            print(error_msg)
-            return jsonify({"status": "error", "error": error_msg}), 404
-            
-        model_file_path = found_model['file_path']
-        
-        model_id = f"{model_identifier}_{model_type}_{version}"
-        
-        # v3版：直接调用核心预测函数
+        # 调用核心预测函数
         prediction_result = load_model_and_predict(
             model_path=model_file_path,
             product_id=product_id,
@@ -1456,49 +1369,36 @@ def predict():
         )
 
         if prediction_result is None:
-            return jsonify({"status": "error", "error": "预测失败，核心预测器返回None"}), 500
+            return jsonify({"status": "error", "message": "预测失败，核心预测器返回None"}), 500
 
-        # 核心函数已处理好所有数据格式，此处直接构建最终响应
-        response_data = {
-            'status': 'success',
-            'data': prediction_result, # 包含所有信息的完整结果
-            'history_data': prediction_result.get('history_data', []),
-            'prediction_data': prediction_result.get('prediction_data', [])
-        }
+        # 保存预测记录到数据库
+        prediction_uid = str(uuid.uuid4())
+        result_file_path = os.path.join('saved_predictions', f'prediction_{prediction_uid}.json')
+        os.makedirs(os.path.dirname(result_file_path), exist_ok=True)
         
-        # 调试日志
-        print("=== 预测API响应数据结构 (v3) ===")
-        print(f"history_data 长度: {len(response_data['history_data'])}")
-        print(f"prediction_data 长度: {len(response_data['prediction_data'])}")
-        print("================================")
+        with open(result_file_path, 'w', encoding='utf-8') as f:
+            json.dump(prediction_result, f, ensure_ascii=False, cls=CustomJSONEncoder)
 
-        # 重新加入保存预测结果的逻辑
-        try:
-            model_id_to_save = f"{model_identifier}_{model_type}_{version}"
-            product_name_to_save = prediction_result.get('product_name', product_id or store_id or 'global')
-            
-            # 调用辅助函数保存结果
-            save_prediction_result(
-                prediction_result=prediction_result.copy(),
-                product_id=product_id or store_id or 'global',
-                product_name=product_name_to_save,
-                model_type=model_type,
-                model_id=model_id_to_save,
-                start_date=start_date,
-                future_days=future_days
-            )
-            print(f"✅ 预测结果已成功保存到历史记录。")
-        except Exception as e:
-            print(f"⚠️ 警告: 保存预测结果到历史记录失败: {str(e)}")
-            traceback.print_exc()
-            # 不应阻止向用户返回结果，因此只打印警告
+        db_payload = {
+            "prediction_uid": prediction_uid,
+            "model_id": model_uid,
+            "model_type": model_type,
+            "product_name": model_record.get('display_name'),
+            "prediction_scope": {"product_id": product_id, "store_id": store_id},
+            "prediction_params": {"future_days": future_days, "start_date": start_date},
+            "metrics": prediction_result.get('analysis', {}).get('metrics', {}),
+            "result_file_path": result_file_path
+        }
+        save_prediction_to_db(db_payload)
+
+        return jsonify({
+            'status': 'success',
+            'data': prediction_result
+        })
 
-        return jsonify(response_data)
     except Exception as e:
-        print(f"预测失败: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return jsonify({"status": "error", "error": str(e)}), 500
+        logger.error(f"预测失败: {e}\n{traceback.format_exc()}")
+        return jsonify({"status": "error", "message": str(e)}), 500
 
 @app.route('/api/prediction/compare', methods=['POST'])
 @swag_from({
@@ -2042,154 +1942,87 @@ def delete_prediction(prediction_id):
 })
 def list_models():
     """
-    列出所有可用的模型 - 使用统一模型管理器
-    ---
-    tags:
-      - 模型管理
-    parameters:
-      - name: product_id
-        in: query
-        type: string
-        required: false
-        description: 按产品ID筛选
-      - name: model_type
-        in: query
-        type: string
-        required: false
-        description: "按模型类型筛选 (mlstm, kan, transformer, tcn)"
-      - name: store_id
-        in: query
-        type: string
-        required: false
-        description: 按店铺ID筛选
-      - name: training_mode
-        in: query
-        type: string
-        required: false
-        description: "按训练模式筛选 (product, store, global)"
-    responses:
-      200:
-        description: 模型列表
-        schema:
-          type: object
-          properties:
-            status:
-              type: string
-              example: success
-            data:
-              type: array
-              items:
-                type: object
-                properties:
-                  model_id:
-                    type: string
-                  product_id:
-                    type: string
-                  product_name:
-                    type: string
-                  model_type:
-                    type: string
-                  training_mode:
-                    type: string
-                  store_id:
-                    type: string
-                  version:
-                    type: string
-                  created_at:
-                    type: string
-                  metrics:
-                    type: object
+    列出所有可用的模型 - v2版，从数据库查询
     """
     try:
-        from utils.model_manager import ModelManager
-        
-        # 创建新的ModelManager实例以避免缓存问题
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        project_root = os.path.dirname(current_dir)  # 向上一级到项目根目录
-        model_dir = os.path.join(project_root, 'saved_models')
-        model_manager = ModelManager(model_dir)
-        
-        logger.info(f"[API] 获取模型列表请求")
-        logger.info(f"[API] 模型管理器目录: {model_manager.model_dir}")
-        logger.info(f"[API] 目录存在: {os.path.exists(model_manager.model_dir)}")
-        
         # 获取查询参数
-        product_id_filter = request.args.get('product_id')
-        model_type_filter = request.args.get('model_type')
-        store_id_filter = request.args.get('store_id')
-        training_mode_filter = request.args.get('training_mode')
-        
+        filters = {
+            'product_id': request.args.get('product_id'),
+            'model_type': request.args.get('model_type'),
+            'store_id': request.args.get('store_id'),
+            'training_mode': request.args.get('training_mode')
+        }
+        # 移除值为None的过滤器
+        filters = {k: v for k, v in filters.items() if v is not None}
+
         # 获取分页参数
-        page = request.args.get('page', type=int)
-        page_size = request.args.get('page_size', type=int, default=10)
+        page = request.args.get('page', 1, type=int)
+        page_size = request.args.get('page_size', 10, type=int)
+
+        # 调用新的数据库查询函数
+        result = query_models_from_db(filters=filters, page=page, page_size=page_size)
         
-        logger.info(f"[API] 分页参数: page={page}, page_size={page_size}")
-        
-        # 使用模型管理器获取模型列表
-        result = model_manager.list_models(
-            product_id=product_id_filter,
-            model_type=model_type_filter,
-            store_id=store_id_filter,
-            training_mode=training_mode_filter,
-            page=page,
-            page_size=page_size
-        )
-        
-        models = result['models']
-        pagination = result['pagination']
-        
-        # 格式化响应数据
+        models = result.get('models', [])
+        pagination = result.get('pagination', {})
+
+        # 格式化响应数据，解析JSON字段
         formatted_models = []
         for model in models:
-            # 生成唯一且有意义的model_id
-            model_id = model.get('filename', '').replace('.pth', '')
-            if not model_id:
-                # 备用方案：基于模型信息生成ID
-                product_id = model.get('product_id', 'unknown')
-                model_type = model.get('model_type', 'unknown')
-                version = model.get('version', 'v1')
-                training_mode = model.get('training_mode', 'product')
-                store_id = model.get('store_id')
+            try:
+                model['training_scope'] = json.loads(model['training_scope']) if model.get('training_scope') else {}
+                model['training_params'] = json.loads(model['training_params']) if model.get('training_params') else {}
+                model['performance_metrics'] = json.loads(model['performance_metrics']) if model.get('performance_metrics') else {}
+                model['artifacts'] = json.loads(model['artifacts']) if model.get('artifacts') else {}
+                # =================================================================
+                # 核心修复 v4：精确提供前端所需的 product_name 和 store_name 字段
+                # =================================================================
+                scope = model.get('training_scope', {})
+                mode = model.get('training_mode')
                 
-                if training_mode == 'store' and store_id:
-                    model_id = f"{model_type}_store_{store_id}_{product_id}_{version}"
-                elif training_mode == 'global':
-                    aggregation_method = model.get('aggregation_method', 'mean')
-                    model_id = f"{model_type}_global_{product_id}_{aggregation_method}_{version}"
-                else:
-                    model_id = f"{model_type}_product_{product_id}_{version}"
-            
-            formatted_model = {
-                'model_id': model_id,
-                'filename': model.get('filename', ''),
-                'product_id': model.get('product_id', ''),
-                'product_name': model.get('product_name', model.get('product_id', '')),
-                'model_type': model.get('model_type', ''),
-                'training_mode': model.get('training_mode', 'product'),
-                'store_id': model.get('store_id'),
-                'aggregation_method': model.get('aggregation_method'),
-                'version': model.get('version', 'v1'),
-                'created_at': model.get('created_at', model.get('modified_at', '')),
-                'file_size': model.get('file_size', 0),
-                'metrics': model.get('metrics', {}),
-                'config': model.get('config', {})
-            }
-            formatted_models.append(formatted_model)
-        
-        logger.info(f"[API] 成功获取 {len(formatted_models)} 个模型")
-        for i, model in enumerate(formatted_models):
-            logger.info(f"[API] 模型 {i+1}: id='{model.get('model_id', 'EMPTY')}', filename='{model.get('filename', 'MISSING')}'")
-        
-        # Manually convert numpy types to prevent JSON serialization errors
-        processed_models = convert_numpy_types_for_json(formatted_models)
-        
+                # 初始化所有可能的名称字段
+                model['product_name'] = None
+                model['store_name'] = None
+                model['display_name'] = model.get('display_name') # 优先使用数据库值
+
+                if isinstance(scope, dict):
+                    product_info = scope.get('product')
+                    store_info = scope.get('store')
+                    
+                    if mode == 'product' and isinstance(product_info, dict):
+                        model['product_name'] = product_info.get('name')
+                        model['display_name'] = model['product_name']
+                    
+                    elif mode == 'store' and isinstance(store_info, dict):
+                        model['store_name'] = store_info.get('name')
+                        model['display_name'] = model['store_name'] # 默认显示店铺名
+                    
+                    elif mode == 'global':
+                        model['display_name'] = "全局模型"
+
+                # 提供最终的后备方案
+                if not model.get('display_name'):
+                    model['display_name'] = "信息不完整"
+                # =================================================================
+                
+                formatted_models.append(model)
+            except (json.JSONDecodeError, TypeError) as e:
+                logger.error(f"解析模型JSON数据失败 (model_uid: {model.get('model_uid')}): {e}")
+                # 即使解析失败，也添加部分数据
+                model['training_scope'] = {"error": "invalid json"}
+                model['performance_metrics'] = {"error": "invalid json"}
+                model['artifacts'] = {"error": "invalid json"}
+                model['display_name'] = "元数据解析失败"
+                model['product_name'] = "N/A"
+                model['store_name'] = "N/A"
+                formatted_models.append(model)
+
         return jsonify({
             "status": "success",
-            "data": processed_models,
+            "data": formatted_models,
             "pagination": pagination
         })
     except Exception as e:
-        print(f"获取模型列表失败: {e}")
+        logger.error(f"获取模型列表失败: {e}\n{traceback.format_exc()}")
         return jsonify({
             "status": "error",
             "message": f"获取模型列表失败: {str(e)}",
@@ -3061,103 +2894,6 @@ def analyze_prediction(prediction_result):
         traceback.print_exc()
         return None
 
-# 保存预测结果的辅助函数
-def save_prediction_result(prediction_result, product_id, product_name, model_type, model_id, start_date, future_days):
-    """
-    保存预测结果到文件和数据库
-    
-    返回:
-    (prediction_id, file_path) - 预测ID和文件路径
-    """
-    try:
-        # 生成唯一的预测ID
-        prediction_id = str(uuid.uuid4())
-        
-        # 确保目录存在
-        os.makedirs('static/predictions', exist_ok=True)
-        
-        # 限制数据量
-        if 'history_data' in prediction_result and isinstance(prediction_result['history_data'], list):
-            history_data = prediction_result['history_data']
-            if len(history_data) > 30:
-                print(f"保存时历史数据超过30天，进行裁剪，原始数量: {len(history_data)}")
-                prediction_result['history_data'] = history_data[-30:]  # 只保留最近30天
-        
-        if 'prediction_data' in prediction_result and isinstance(prediction_result['prediction_data'], list):
-            prediction_data = prediction_result['prediction_data']
-            if len(prediction_data) > 7:
-                print(f"保存时预测数据超过7天，进行裁剪，原始数量: {len(prediction_data)}")
-                prediction_result['prediction_data'] = prediction_data[:7]  # 只保留前7天
-        
-        # 处理预测结果中可能存在的NumPy类型
-        def convert_numpy_types(obj):
-            if isinstance(obj, dict):
-                return {k: convert_numpy_types(v) for k, v in obj.items()}
-            elif isinstance(obj, list):
-                return [convert_numpy_types(item) for item in obj]
-            elif isinstance(obj, pd.DataFrame):
-                return obj.to_dict(orient='records')
-            elif isinstance(obj, pd.Series):
-                return obj.to_dict()
-            elif isinstance(obj, np.generic):
-                return obj.item()  # 将NumPy标量转换为Python原生类型
-            elif isinstance(obj, np.ndarray):
-                return obj.tolist()
-            elif pd.isna(obj):
-                return None
-            else:
-                return obj
-        
-        # 转换整个预测结果对象
-        prediction_result = convert_numpy_types(prediction_result)
-        
-        # 保存预测结果到JSON文件
-        file_name = f"prediction_{prediction_id}.json"
-        file_path = os.path.join('static/predictions', file_name)
-        
-        with open(file_path, 'w', encoding='utf-8') as f:
-            json.dump(prediction_result, f, ensure_ascii=False, cls=CustomJSONEncoder)
-        
-        # 将预测记录保存到数据库
-        try:
-            conn = get_db_connection()
-            cursor = conn.cursor()
-
-            # 提取并序列化需要存储的数据
-            predictions_data_json = json.dumps(prediction_result.get('prediction_data', []), cls=CustomJSONEncoder)
-            
-            # 从分析结果中获取指标，如果分析结果不存在，则使用空字典
-            analysis_data = prediction_result.get('analysis', {})
-            metrics_data = analysis_data.get('metrics', {}) if isinstance(analysis_data, dict) else {}
-            metrics_json = json.dumps(metrics_data, cls=CustomJSONEncoder)
-            
-            chart_data_json = json.dumps(prediction_result.get('chart_data', {}), cls=CustomJSONEncoder)
-            analysis_json = json.dumps(analysis_data, cls=CustomJSONEncoder)
-
-            cursor.execute('''
-            INSERT INTO prediction_history (
-                prediction_id, product_id, product_name, model_type, model_id,
-                start_date, future_days, created_at, file_path,
-                predictions_data, metrics, chart_data, analysis
-            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-            ''', (
-                prediction_id, product_id, product_name, model_type, model_id,
-                start_date if start_date else datetime.now().strftime('%Y-%m-%d'),
-                future_days, datetime.now().isoformat(), file_path,
-                predictions_data_json, metrics_json, chart_data_json, analysis_json
-            ))
-
-            conn.commit()
-            conn.close()
-        except Exception as e:
-            print(f"保存预测记录到数据库失败: {str(e)}")
-            traceback.print_exc()
-        
-        return prediction_id, file_path
-    except Exception as e:
-        print(f"保存预测结果失败: {str(e)}")
-        traceback.print_exc()
-        return None, None
 
 # 添加模型性能分析接口
 @app.route('/api/models/analyze-metrics', methods=['POST'])
@@ -4391,13 +4127,10 @@ def test_models_fix():
         from utils.model_manager import ModelManager
         import os
         
-        # 强制创建新的ModelManager实例
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        project_root = os.path.dirname(current_dir)
-        model_dir = os.path.join(project_root, 'saved_models')
-        manager = ModelManager(model_dir)
+        # 修正: 直接使用默认的相对路径
+        manager = ModelManager()
         
-        models = manager.list_models()
+        models = manager.list_models()['models']
         
         # 简化的响应格式
         test_result = {
diff --git a/server/api_backup.py b/server/api_backup.py
index e70195e..3c800e5 100644
--- a/server/api_backup.py
+++ b/server/api_backup.py
@@ -2178,11 +2178,8 @@ def list_models():
     try:
         from utils.model_manager import ModelManager
         
-        # 创建新的ModelManager实例以避免缓存问题
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        project_root = os.path.dirname(current_dir)  # 向上一级到项目根目录
-        model_dir = os.path.join(project_root, 'saved_models')
-        model_manager = ModelManager(model_dir)
+        # 修正: 直接使用默认的相对路径
+        model_manager = ModelManager()
         
         logger.info(f"[API] 获取模型列表请求")
         logger.info(f"[API] 模型管理器目录: {model_manager.model_dir}")
@@ -4465,13 +4462,10 @@ def test_models_fix():
         from utils.model_manager import ModelManager
         import os
         
-        # 强制创建新的ModelManager实例
-        current_dir = os.path.dirname(os.path.abspath(__file__))
-        project_root = os.path.dirname(current_dir)
-        model_dir = os.path.join(project_root, 'saved_models')
-        manager = ModelManager(model_dir)
+        # 修正: 直接使用默认的相对路径
+        manager = ModelManager()
         
-        models = manager.list_models()
+        models = manager.list_models()['models']
         
         # 简化的响应格式
         test_result = {
diff --git a/server/core/config.py b/server/core/config.py
index b9e828b..933944f 100644
--- a/server/core/config.py
+++ b/server/core/config.py
@@ -10,13 +10,6 @@ import os
 import re
 import glob
 
-# 项目根目录
-# __file__ 是当前文件 (config.py) 的路径
-# os.path.dirname(__file__) 是 server/core
-# os.path.join(..., '..') 是 server
-# os.path.join(..., '..', '..') 是项目根目录
-PROJECT_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', '..'))
-
 # 解决画图中文显示问题
 plt.rcParams['font.sans-serif'] = ['SimHei']
 plt.rcParams['axes.unicode_minus'] = False
@@ -34,8 +27,9 @@ DEVICE = get_device()
 
 # 数据相关配置
 # 使用 os.path.join 构造跨平台的路径
-DEFAULT_DATA_PATH = os.path.join(PROJECT_ROOT, 'data', 'timeseries_training_data_sample_10s50p.parquet')
-DEFAULT_MODEL_DIR = os.path.join(PROJECT_ROOT, 'saved_models')
+# 修正: 改为相对路径
+DEFAULT_DATA_PATH = os.path.join('data', 'timeseries_training_data_sample_10s50p.parquet')
+DEFAULT_MODEL_DIR = 'saved_models'
 DEFAULT_FEATURES = ['sales', 'price', 'weekday', 'month', 'is_holiday', 'is_weekend', 'is_promotion', 'temperature']
 
 # 时间序列参数
diff --git a/server/core/predictor.py b/server/core/predictor.py
index 6d232a0..6e90eca 100644
--- a/server/core/predictor.py
+++ b/server/core/predictor.py
@@ -225,11 +225,13 @@ class PharmacyPredictor:
             result = trainer_function(**valid_args)
             
             # 根据返回值的数量解析metrics
-            if isinstance(result, tuple) and len(result) >= 2:
-                metrics = result[1] # 通常第二个返回值是metrics
+            if isinstance(result, tuple) and len(result) >= 3:
+                metrics = result[1] # 第二个返回值是metrics
+                artifacts = result[2] # 第三个返回值是artifacts
             else:
-                log_message(f"⚠️ 训练器返回格式未知，无法直接提取metrics: {type(result)}", 'warning')
+                log_message(f"⚠️ 训练器返回格式未知，无法直接提取metrics和artifacts: {type(result)}", 'warning')
                 metrics = None
+                artifacts = None
 
             
             # 检查和打印返回的metrics
@@ -249,7 +251,7 @@ class PharmacyPredictor:
             else:
                 log_message(f"⚠️ metrics为空或None", 'warning')
             
-            return metrics
+            return metrics, artifacts
             
         except Exception as e:
             log_message(f"模型训练失败: {e}", 'error')
diff --git a/server/trainers/cnn_bilstm_attention_trainer.py b/server/trainers/cnn_bilstm_attention_trainer.py
index c8d4147..c8a1eea 100644
--- a/server/trainers/cnn_bilstm_attention_trainer.py
+++ b/server/trainers/cnn_bilstm_attention_trainer.py
@@ -65,9 +65,21 @@ def train_with_cnn_bilstm_attention(product_id, model_identifier, product_df, st
 
     # --- 3. 训练循环与早停 ---
     print("开始训练 CNN-BiLSTM-Attention 模型 (含早停)...")
+    
+    # 版本锁定：在训练开始前确定本次训练的版本号
+    current_version = model_manager.peek_next_version(
+        model_type='cnn_bilstm_attention',
+        product_id=product_id,
+        store_id=store_id,
+        training_mode=training_mode,
+        aggregation_method=aggregation_method
+    )
+    print(f"🔒 本次训练版本锁定为: {current_version}")
+
     loss_history = {'train': [], 'val': []}
     best_val_loss = float('inf')
     best_model_state = None
+    best_model_path = None # 用于存储最佳模型的路径
     patience = kwargs.get('patience', 15)
     patience_counter = 0
 
@@ -99,6 +111,31 @@ def train_with_cnn_bilstm_attention(product_id, model_identifier, product_df, st
             best_model_state = copy.deepcopy(model.state_dict())
             patience_counter = 0
             print(f"✨ 新的最佳模型! Epoch: {epoch+1}, Val Loss: {best_val_loss:.4f}")
+            
+            # 立即保存最佳模型
+            best_model_data = {
+                'model_state_dict': best_model_state,
+                'scaler_X': scaler_X,
+                'scaler_y': scaler_y,
+                'config': {
+                    'model_type': 'cnn_bilstm_attention',
+                    'input_dim': input_dim,
+                    'output_dim': forecast_horizon,
+                    'sequence_length': sequence_length,
+                    'features': features
+                },
+                'epoch': epoch + 1
+            }
+            best_model_path, _ = model_manager.save_model(
+                model_data=best_model_data,
+                product_id=product_id,
+                model_type='cnn_bilstm_attention',
+                store_id=store_id,
+                training_mode=training_mode,
+                aggregation_method=aggregation_method,
+                product_name=product_name,
+                version=f"{current_version}_best"
+            )
         else:
             patience_counter += 1
             if patience_counter >= patience:
@@ -128,17 +165,32 @@ def train_with_cnn_bilstm_attention(product_id, model_identifier, product_df, st
     print("\n最佳模型评估指标:")
     print(f"MSE: {metrics['mse']:.4f}, RMSE: {metrics['rmse']:.4f}, MAE: {metrics['mae']:.4f}, R²: {metrics['r2']:.4f}, MAPE: {metrics['mape']:.2f}%")
 
-    # 绘制损失曲线
+    # --- 5. 保存工件 ---
+
+    # 准备 scope 和 identifier 以生成标准化的文件名
+    scope = training_mode
+    if scope == 'product':
+        identifier = product_id
+    elif scope == 'store':
+        identifier = store_id
+    elif scope == 'global':
+        identifier = aggregation_method
+    else:
+        identifier = product_name # 后备方案
+
+    # 绘制带有版本号的损失曲线图
     loss_curve_path = plot_loss_curve(
-        loss_history['train'],
-        loss_history['val'],
-        product_name,
-        'cnn_bilstm_attention',
+        train_losses=loss_history['train'],
+        val_losses=loss_history['val'],
+        model_type='cnn_bilstm_attention',
+        scope=scope,
+        identifier=identifier,
+        version=current_version, # 使用锁定的版本
         model_dir=model_dir
     )
-    print(f"📈 损失曲线已保存到: {loss_curve_path}")
+    print(f"📈 带版本号的损失曲线已保存: {loss_curve_path}")
 
-    # --- 5. 模型保存 ---
+    # 准备要保存的最终模型数据
     model_data = {
         'model_state_dict': best_model_state, # 保存最佳模型的状态
         'scaler_X': scaler_X,
@@ -151,11 +203,11 @@ def train_with_cnn_bilstm_attention(product_id, model_identifier, product_df, st
             'features': features
         },
         'metrics': metrics,
-        'loss_history': loss_history, # 保存损失历史
-        'loss_curve_path': loss_curve_path # 添加损失图路径
+        'loss_history': loss_history,
+        'loss_curve_path': loss_curve_path # 直接包含路径
     }
-    
-    # 保存最终版本模型
+
+    # 使用模型管理器保存最终模型
     final_model_path, final_version = model_manager.save_model(
         model_data=model_data,
         product_id=product_id,
@@ -163,24 +215,20 @@ def train_with_cnn_bilstm_attention(product_id, model_identifier, product_df, st
         store_id=store_id,
         training_mode=training_mode,
         aggregation_method=aggregation_method,
-        product_name=product_name
+        product_name=product_name,
+        version=current_version # 使用锁定的版本号
     )
     print(f"✅ CNN-BiLSTM-Attention 最终模型已保存，版本: {final_version}")
 
-    # 保存最佳版本模型
-    best_model_path, best_version = model_manager.save_model(
-        model_data=model_data,
-        product_id=product_id,
-        model_type='cnn_bilstm_attention',
-        store_id=store_id,
-        training_mode=training_mode,
-        aggregation_method=aggregation_method,
-        product_name=product_name,
-        version='best' # 明确指定版本为 'best'
-    )
-    print(f"✅ CNN-BiLSTM-Attention 最佳模型已保存，版本: {best_version}")
+    # 组装返回的工件
+    artifacts = {
+        "versioned_model": final_model_path,
+        "loss_curve_plot": loss_curve_path,
+        "best_model": best_model_path,
+        "version": final_version
+    }
     
-    return model, metrics, final_version, final_model_path
+    return model, metrics, artifacts
 
 # --- 关键步骤: 将训练器注册到系统中 ---
 register_trainer('cnn_bilstm_attention', train_with_cnn_bilstm_attention)
\ No newline at end of file
diff --git a/server/trainers/kan_trainer.py b/server/trainers/kan_trainer.py
index 0d71e7d..7b5b400 100644
--- a/server/trainers/kan_trainer.py
+++ b/server/trainers/kan_trainer.py
@@ -165,10 +165,22 @@ def train_product_model_with_kan(product_id, model_identifier, product_df=None,
     optimizer = optim.Adam(model.parameters(), lr=0.001)
     
     # 训练模型
+    from utils.model_manager import model_manager
+    model_type_name = 'optimized_kan' if use_optimized else 'kan'
+    current_version = model_manager.peek_next_version(
+        model_type=model_type_name,
+        product_id=model_identifier,
+        store_id=store_id,
+        training_mode=training_mode,
+        aggregation_method=aggregation_method
+    )
+    print(f"🔒 本次训练版本锁定为: {current_version}")
+
     train_losses = []
     test_losses = []
     start_time = time.time()
     best_loss = float('inf')
+    best_model_path = None
     
     for epoch in range(epochs):
         model.train()
@@ -253,7 +265,7 @@ def train_product_model_with_kan(product_id, model_identifier, product_df=None,
             
             # 使用模型管理器保存 'best' 版本
             from utils.model_manager import model_manager
-            model_manager.save_model(
+            best_model_path, _ = model_manager.save_model(
                 model_data=best_model_data,
                 product_id=model_identifier, # 修正：使用唯一的标识符
                 model_type=model_type_name,
@@ -261,7 +273,7 @@ def train_product_model_with_kan(product_id, model_identifier, product_df=None,
                 training_mode=training_mode,
                 aggregation_method=aggregation_method,
                 product_name=product_name,
-                version='best'  # 显式覆盖版本为'best'
+                version=f"{current_version}_best"
             )
         
         if (epoch + 1) % 10 == 0:
@@ -271,15 +283,6 @@ def train_product_model_with_kan(product_id, model_identifier, product_df=None,
     training_time = time.time() - start_time
     
     # 绘制损失曲线并保存到模型目录
-    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
-    )
-    print(f"损失曲线已保存到: {loss_curve_path}")
     
     # 评估模型
     model.eval()
@@ -307,11 +310,33 @@ def train_product_model_with_kan(product_id, model_identifier, product_df=None,
     print(f"MAPE: {metrics['mape']:.2f}%")
     print(f"训练时间: {training_time:.2f}秒")
     
-    # 使用统一模型管理器保存模型
-    from utils.model_manager import model_manager
-    
+    # --- 5. 保存工件 ---
     model_type_name = 'optimized_kan' if use_optimized else 'kan'
-    
+
+    # 准备 scope 和 identifier 以生成标准化的文件名
+    scope = training_mode
+    if scope == 'product':
+        identifier = model_identifier
+    elif scope == 'store':
+        identifier = store_id
+    elif scope == 'global':
+        identifier = aggregation_method
+    else:
+        identifier = product_name # 后备方案
+
+    # 绘制带有版本号的损失曲线图
+    loss_curve_path = plot_loss_curve(
+        train_losses=train_losses,
+        val_losses=test_losses,
+        model_type=model_type_name,
+        scope=scope,
+        identifier=identifier,
+        version=current_version, # 使用锁定的版本
+        model_dir=model_dir
+    )
+    print(f"📈 带版本号的损失曲线已保存: {loss_curve_path}")
+
+    # 准备要保存的最终模型数据
     model_data = {
         'model_state_dict': model.state_dict(),
         'scaler_X': scaler_X,
@@ -332,24 +357,32 @@ def train_product_model_with_kan(product_id, model_identifier, product_df=None,
             'test': test_losses,
             'epochs': list(range(1, epochs + 1))
         },
-        'loss_curve_path': loss_curve_path
+        'loss_curve_path': loss_curve_path # 直接包含路径
     }
-    
-    # 保存最终模型，让 model_manager 自动处理版本号
+
+    # 使用模型管理器保存最终模型
+    from utils.model_manager import model_manager
     final_model_path, final_version = model_manager.save_model(
         model_data=model_data,
-        product_id=model_identifier, # 修正：使用唯一的标识符
+        product_id=model_identifier,
         model_type=model_type_name,
         store_id=store_id,
         training_mode=training_mode,
         aggregation_method=aggregation_method,
-        product_name=product_name
-        # 注意：此处不传递version参数，由管理器自动生成
+        product_name=product_name,
+        version=current_version # 使用锁定的版本
     )
+    print(f"✅ {model_type_name} 最终模型已保存，版本: {final_version}")
+
+    # 组装返回的工件
+    artifacts = {
+        "versioned_model": final_model_path,
+        "loss_curve_plot": loss_curve_path,
+        "best_model": best_model_path,
+        "version": final_version
+    }
     
-    print(f"最终模型已保存，版本: {final_version}, 路径: {final_model_path}")
-    
-    return model, metrics
+    return model, metrics, artifacts
 
 # --- 将此训练器注册到系统中 ---
 from models.model_registry import register_trainer
diff --git a/server/trainers/mlstm_trainer.py b/server/trainers/mlstm_trainer.py
index d3d0bf1..abc20dc 100644
--- a/server/trainers/mlstm_trainer.py
+++ b/server/trainers/mlstm_trainer.py
@@ -255,6 +255,16 @@ def train_product_model_with_mlstm(
     emit_progress("数据预处理完成，开始模型训练...", progress=10)
     
     # 训练模型
+    # 版本锁定
+    current_version = model_manager.peek_next_version(
+        model_type='mlstm',
+        product_id=model_identifier,
+        store_id=store_id,
+        training_mode=training_mode,
+        aggregation_method=aggregation_method
+    )
+    print(f"🔒 本次训练版本锁定为: {current_version}")
+
     train_losses = []
     test_losses = []
     start_time = time.time()
@@ -263,6 +273,7 @@ def train_product_model_with_mlstm(
     checkpoint_interval = max(1, epochs // 10)  # 每10%进度保存一次，最少每1个epoch
     best_loss = float('inf')
     epochs_no_improve = 0
+    best_model_path = None
     
     emit_progress(f"开始训练 - 总epoch: {epochs}, 检查点间隔: {checkpoint_interval}, 耐心值: {patience}")
     
@@ -365,7 +376,7 @@ def train_product_model_with_mlstm(
             # 如果是最佳模型，额外保存一份
             if test_loss < best_loss:
                 best_loss = test_loss
-                model_manager.save_model(
+                best_model_path, _ = model_manager.save_model(
                     model_data=checkpoint_data,
                     product_id=model_identifier, # 修正：使用唯一的标识符
                     model_type='mlstm',
@@ -373,7 +384,7 @@ def train_product_model_with_mlstm(
                     training_mode=training_mode,
                     aggregation_method=aggregation_method,
                     product_name=product_name,
-                    version='best'
+                    version=f"{current_version}_best"
                 )
                 emit_progress(f"💾 保存最佳模型检查点 (epoch {epoch+1}, test_loss: {test_loss:.4f})")
                 epochs_no_improve = 0
@@ -391,37 +402,6 @@ def train_product_model_with_mlstm(
     # 计算训练时间
     training_time = time.time() - start_time
     
-    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)
-    
-    # 绘制损失曲线并保存到模型目录
-    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.xlabel('Epoch')
-    plt.ylabel('Loss')
-    plt.legend()
-    plt.grid(True)
-    plt.savefig(loss_curve_path, dpi=300, bbox_inches='tight')
-    plt.close()
-    
-    print(f"损失曲线已保存到: {loss_curve_path}")
-    
     emit_progress("模型评估中...", progress=98)
     
     # 评估模型
@@ -475,7 +455,7 @@ def train_product_model_with_mlstm(
             'model_type': 'mlstm'
         },
         'metrics': metrics,
-        'loss_curve_path': loss_curve_path,
+        'metrics': metrics,
         'training_info': {
             'product_id': product_id,
             'product_name': product_name,
@@ -488,6 +468,31 @@ def train_product_model_with_mlstm(
         }
     }
     
+    # 准备 scope 和 identifier 以生成标准化的文件名
+    scope = training_mode
+    if scope == 'product':
+        identifier = model_identifier
+    elif scope == 'store':
+        identifier = store_id
+    elif scope == 'global':
+        identifier = aggregation_method
+    else:
+        identifier = product_name # 后备方案
+
+    # 绘制带有版本号的损失曲线图
+    loss_curve_path = plot_loss_curve(
+        train_losses=train_losses,
+        val_losses=test_losses,
+        model_type='mlstm',
+        scope=scope,
+        identifier=identifier,
+        version=current_version, # 使用锁定的版本
+        model_dir=model_dir
+    )
+    print(f"📈 带版本号的损失曲线已保存: {loss_curve_path}")
+
+    # 更新模型数据中的损失图路径
+    final_model_data['loss_curve_path'] = loss_curve_path
     # 保存最终模型，让 model_manager 自动处理版本号
     final_model_path, final_version = model_manager.save_model(
         model_data=final_model_data,
@@ -496,7 +501,8 @@ def train_product_model_with_mlstm(
         store_id=store_id,
         training_mode=training_mode,
         aggregation_method=aggregation_method,
-        product_name=product_name
+        product_name=product_name,
+        version=current_version
     )
     
     # 发送训练完成消息
@@ -514,7 +520,16 @@ def train_product_model_with_mlstm(
     
     emit_progress(f"✅ mLSTM模型训练完成！版本 {final_version} 已保存", progress=100, metrics=final_metrics)
     
-    return model, metrics, epochs, final_model_path
+    # 组装 artifacts 字典
+    artifacts = {
+        "versioned_model": final_model_path,
+        "loss_curve_plot": loss_curve_path,
+        # 假设 best model 的路径可以从 model_manager 获取或推断
+        "best_model": best_model_path,
+        "version": final_version
+    }
+    
+    return model, metrics, artifacts
 
 # --- 将此训练器注册到系统中 ---
 from models.model_registry import register_trainer
diff --git a/server/trainers/tcn_trainer.py b/server/trainers/tcn_trainer.py
index 34f10ba..a26ed1d 100644
--- a/server/trainers/tcn_trainer.py
+++ b/server/trainers/tcn_trainer.py
@@ -164,8 +164,19 @@ def train_product_model_with_tcn(
     test_losses = []
     start_time = time.time()
     
+    # 版本锁定
+    current_version = model_manager.peek_next_version(
+        model_type='tcn',
+        product_id=model_identifier,
+        store_id=store_id,
+        training_mode=training_mode,
+        aggregation_method=aggregation_method
+    )
+    print(f"🔒 本次训练版本锁定为: {current_version}")
+
     checkpoint_interval = max(1, epochs // 10)
     best_loss = float('inf')
+    best_model_path = None
     
     progress_manager.set_stage("model_training", 0)
     emit_progress(f"开始训练 - 总epoch: {epochs}, 检查点间隔: {checkpoint_interval}")
@@ -269,7 +280,7 @@ def train_product_model_with_tcn(
             
             if test_loss < best_loss:
                 best_loss = test_loss
-                model_manager.save_model(
+                best_model_path, _ = model_manager.save_model(
                     model_data=checkpoint_data,
                     product_id=model_identifier, # 修正：使用唯一的标识符
                     model_type='tcn',
@@ -277,7 +288,7 @@ def train_product_model_with_tcn(
                     training_mode=training_mode,
                     aggregation_method=aggregation_method,
                     product_name=product_name,
-                    version='best'
+                    version=f"{current_version}_best"
                 )
                 emit_progress(f"💾 保存最佳模型检查点 (epoch {epoch+1}, test_loss: {test_loss:.4f})")
         
@@ -289,14 +300,6 @@ def train_product_model_with_tcn(
     progress_manager.set_stage("model_saving", 0)
     emit_progress("训练完成，正在保存模型...")
     
-    loss_curve_path = plot_loss_curve(
-        train_losses, 
-        test_losses, 
-        product_name, 
-        'TCN', 
-        model_dir=model_dir
-    )
-    print(f"损失曲线已保存到: {loss_curve_path}")
     
     model.eval()
     with torch.no_grad():
@@ -340,7 +343,7 @@ def train_product_model_with_tcn(
             'model_type': 'tcn'
         },
         'metrics': metrics,
-        'loss_curve_path': loss_curve_path,
+        'metrics': metrics,
         'training_info': {
             'product_id': product_id,
             'product_name': product_name,
@@ -361,7 +364,8 @@ def train_product_model_with_tcn(
         store_id=store_id,
         training_mode=training_mode,
         aggregation_method=aggregation_method,
-        product_name=product_name
+        product_name=product_name,
+        version=current_version
     )
     
     progress_manager.set_stage("model_saving", 100)
@@ -379,7 +383,40 @@ def train_product_model_with_tcn(
     
     emit_progress(f"模型训练完成！版本 {final_version} 已保存", progress=100, metrics=final_metrics)
     
-    return model, metrics, epochs, final_model_path
+    # 准备 scope 和 identifier 以生成标准化的文件名
+    scope = training_mode
+    if scope == 'product':
+        identifier = model_identifier
+    elif scope == 'store':
+        identifier = store_id
+    elif scope == 'global':
+        identifier = aggregation_method
+    else:
+        identifier = product_name # 后备方案
+
+    # 绘制带有版本号的损失曲线图
+    loss_curve_path = plot_loss_curve(
+        train_losses=train_losses,
+        val_losses=test_losses,
+        model_type='tcn',
+        scope=scope,
+        identifier=identifier,
+        version=current_version, # 使用锁定的版本
+        model_dir=model_dir
+    )
+    print(f"📈 带版本号的损失曲线已保存: {loss_curve_path}")
+
+    # 更新模型数据中的损失图路径
+    final_model_data['loss_curve_path'] = loss_curve_path
+
+    artifacts = {
+        "versioned_model": final_model_path,
+        "loss_curve_plot": loss_curve_path,
+        "best_model": best_model_path,
+        "version": final_version
+    }
+    
+    return model, metrics, artifacts
 
 # --- 将此训练器注册到系统中 ---
 from models.model_registry import register_trainer
diff --git a/server/trainers/transformer_trainer.py b/server/trainers/transformer_trainer.py
index 06d6af3..ce2ce9a 100644
--- a/server/trainers/transformer_trainer.py
+++ b/server/trainers/transformer_trainer.py
@@ -187,9 +187,20 @@ def train_product_model_with_transformer(
     test_losses = []
     start_time = time.time()
     
+    # 版本锁定
+    current_version = model_manager.peek_next_version(
+        model_type='transformer',
+        product_id=model_identifier,
+        store_id=store_id,
+        training_mode=training_mode,
+        aggregation_method=aggregation_method
+    )
+    print(f"🔒 本次训练版本锁定为: {current_version}")
+
     checkpoint_interval = max(1, epochs // 10)
     best_loss = float('inf')
     epochs_no_improve = 0
+    best_model_path = None
     
     progress_manager.set_stage("model_training", 0)
     emit_progress(f"开始训练 - 总epoch: {epochs}, 检查点间隔: {checkpoint_interval}, 耐心值: {patience}")
@@ -289,7 +300,8 @@ def train_product_model_with_transformer(
             
             if test_loss < best_loss:
                 best_loss = test_loss
-                model_manager.save_model(
+                # 修正: 保存最佳模型路径
+                best_model_path, _ = model_manager.save_model(
                     model_data=checkpoint_data,
                     product_id=model_identifier, # 修正：使用唯一的标识符
                     model_type='transformer',
@@ -297,7 +309,7 @@ def train_product_model_with_transformer(
                     training_mode=training_mode,
                     aggregation_method=aggregation_method,
                     product_name=product_name,
-                    version='best'
+                    version=f"{current_version}_best"
                 )
                 emit_progress(f"💾 保存最佳模型检查点 (epoch {epoch+1}, test_loss: {test_loss:.4f})")
                 epochs_no_improve = 0
@@ -316,14 +328,6 @@ def train_product_model_with_transformer(
     progress_manager.set_stage("model_saving", 0)
     emit_progress("训练完成，正在保存模型...")
     
-    loss_curve_path = plot_loss_curve(
-        train_losses, 
-        test_losses, 
-        product_name, 
-        'Transformer', 
-        model_dir=model_dir
-    )
-    print(f"📈 损失曲线已保存到: {loss_curve_path}", flush=True)
     
     model.eval()
     with torch.no_grad():
@@ -366,7 +370,7 @@ def train_product_model_with_transformer(
             'model_type': 'transformer'
         },
         'metrics': metrics,
-        'loss_curve_path': loss_curve_path,
+        'metrics': metrics,
         'training_info': {
             'product_id': product_id,
             'product_name': product_name,
@@ -387,7 +391,8 @@ def train_product_model_with_transformer(
         store_id=store_id,
         training_mode=training_mode,
         aggregation_method=aggregation_method,
-        product_name=product_name
+        product_name=product_name,
+        version=current_version
     )
     
     progress_manager.set_stage("model_saving", 100)
@@ -406,7 +411,40 @@ def train_product_model_with_transformer(
         'version': final_version
     }
     
-    return model, final_metrics, epochs
+    # 准备 scope 和 identifier 以生成标准化的文件名
+    scope = training_mode
+    if scope == 'product':
+        identifier = model_identifier
+    elif scope == 'store':
+        identifier = store_id
+    elif scope == 'global':
+        identifier = aggregation_method
+    else:
+        identifier = product_name # 后备方案
+
+    # 绘制带有版本号的损失曲线图
+    loss_curve_path = plot_loss_curve(
+        train_losses=train_losses,
+        val_losses=test_losses,
+        model_type='transformer',
+        scope=scope,
+        identifier=identifier,
+        version=current_version, # 使用锁定的版本
+        model_dir=model_dir
+    )
+    print(f"📈 带版本号的损失曲线已保存: {loss_curve_path}")
+
+    # 更新模型数据中的损失图路径
+    final_model_data['loss_curve_path'] = loss_curve_path
+
+    artifacts = {
+        "versioned_model": final_model_path,
+        "loss_curve_plot": loss_curve_path,
+        "best_model": best_model_path,
+        "version": final_version
+    }
+    
+    return model, final_metrics, artifacts
 
 # --- 将此训练器注册到系统中 ---
 from models.model_registry import register_trainer
diff --git a/server/trainers/xgboost_trainer.py b/server/trainers/xgboost_trainer.py
index 425c3bf..83294ec 100644
--- a/server/trainers/xgboost_trainer.py
+++ b/server/trainers/xgboost_trainer.py
@@ -76,6 +76,17 @@ def train_product_model_with_xgboost(product_id, model_identifier, product_df, s
     n_estimators = kwargs.get('n_estimators', 500)
 
     print("开始训练XGBoost模型 (使用核心xgb.train API)...")
+    
+    # 版本锁定
+    current_version = model_manager.peek_next_version(
+        model_type='xgboost',
+        product_id=product_id,
+        store_id=store_id,
+        training_mode=training_mode,
+        aggregation_method=aggregation_method
+    )
+    print(f"🔒 本次训练版本锁定为: {current_version}")
+
     start_time = time.time()
     
     evals_result = {}
@@ -109,16 +120,33 @@ def train_product_model_with_xgboost(product_id, model_identifier, product_df, s
     # 提取损失并绘制曲线
     train_losses = evals_result['train']['rmse']
     test_losses = evals_result['test']['rmse']
+
+    # --- 5. 保存工件 ---
+
+    # 准备 scope 和 identifier 以生成标准化的文件名
+    scope = training_mode
+    if scope == 'product':
+        identifier = product_id
+    elif scope == 'store':
+        identifier = store_id
+    elif scope == 'global':
+        identifier = aggregation_method
+    else:
+        identifier = product_name # 后备方案
+
+    # 绘制带有版本号的损失曲线图
     loss_curve_path = plot_loss_curve(
-        train_losses,
-        test_losses,
-        product_name,
-        'xgboost',
+        train_losses=train_losses,
+        val_losses=test_losses,
+        model_type='xgboost',
+        scope=scope,
+        identifier=identifier,
+        version=current_version, # 使用锁定的版本
         model_dir=model_dir
     )
-    print(f"📈 损失曲线已保存到: {loss_curve_path}")
+    print(f"📈 带版本号的损失曲线已保存: {loss_curve_path}")
 
-    # --- 5. 模型保存 (借道 utils.model_manager) ---
+    # 准备要保存的最终模型数据
     model_data = {
         'model_state_dict': model, # 直接保存模型对象
         'scaler_X': scaler_X,
@@ -132,7 +160,7 @@ def train_product_model_with_xgboost(product_id, model_identifier, product_df, s
         },
         'metrics': metrics,
         'loss_history': evals_result,
-        'loss_curve_path': loss_curve_path # 添加损失图路径
+        'loss_curve_path': loss_curve_path # 直接包含路径
     }
 
     # 保存最终版本模型
@@ -143,12 +171,14 @@ def train_product_model_with_xgboost(product_id, model_identifier, product_df, s
         store_id=store_id,
         training_mode=training_mode,
         aggregation_method=aggregation_method,
-        product_name=product_name
+        product_name=product_name,
+        version=current_version
     )
-    print(f"✅ XGBoost最终模型已通过统一管理器保存，版本: {final_version}, 路径: {final_model_path}")
+    print(f"✅ XGBoost最终模型已通过统一管理器保存，版本: {final_version}")
 
-    # 保存最佳版本模型
-    best_model_path, best_version = model_manager.save_model(
+    # XGBoost的 `best_model` 就是它自己，因为 `xgb.train` 内部处理了早停。
+    # 我们创建一个指向最终模型的 "best" 版本文件，以保持接口一致性。
+    best_model_path, _ = model_manager.save_model(
         model_data=model_data,
         product_id=product_id,
         model_type='xgboost',
@@ -156,12 +186,19 @@ def train_product_model_with_xgboost(product_id, model_identifier, product_df, s
         training_mode=training_mode,
         aggregation_method=aggregation_method,
         product_name=product_name,
-        version='best' # 明确指定版本为 'best'
+        version=f"{current_version}_best"
     )
-    print(f"✅ XGBoost最佳模型已通过统一管理器保存，版本: {best_version}, 路径: {best_model_path}")
+    print(f"✅ XGBoost最佳模型引用已创建，版本: {current_version}_best")
 
-    # 返回值遵循统一格式
-    return model, metrics, final_version, final_model_path
+    # 组装返回的工件
+    artifacts = {
+        "versioned_model": final_model_path,
+        "loss_curve_plot": loss_curve_path,
+        "best_model": best_model_path,
+        "version": final_version
+    }
+    
+    return model, metrics, artifacts
 
 # --- 将此训练器注册到系统中 ---
 register_trainer('xgboost', train_product_model_with_xgboost)
\ No newline at end of file
diff --git a/server/utils/database_utils.py b/server/utils/database_utils.py
new file mode 100644
index 0000000..27b2a0a
--- /dev/null
+++ b/server/utils/database_utils.py
@@ -0,0 +1,162 @@
+import sqlite3
+import json
+import uuid
+from datetime import datetime
+
+def get_db_connection():
+    """获取数据库连接"""
+    conn = sqlite3.connect('prediction_history.db', check_same_thread=False)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+def save_model_to_db(model_data: dict):
+    """
+    将训练完成的模型元数据保存到数据库的 models 表中。
+    """
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    
+    try:
+        # 生成唯一的模型UID
+        model_uid = f"{model_data.get('training_mode', 'model')}_{model_data.get('model_type', 'default')}_{uuid.uuid4().hex[:8]}"
+
+        cursor.execute(
+            """
+            INSERT INTO models (
+                model_uid, display_name, model_type, training_mode, 
+                training_scope, parent_model_id, version, status, 
+                training_params, performance_metrics, artifacts, created_at
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                model_uid,
+                model_data.get('display_name'),
+                model_data.get('model_type'),
+                model_data.get('training_mode'),
+                json.dumps(model_data.get('training_scope')),
+                model_data.get('parent_model_id'),
+                model_data.get('version'),
+                'active',
+                json.dumps(model_data.get('training_params')),
+                json.dumps(model_data.get('performance_metrics')),
+                json.dumps(model_data.get('artifacts')),
+                datetime.now().isoformat()
+            )
+        )
+        conn.commit()
+        print(f"✅ 模型元数据已成功保存到数据库，UID: {model_uid}")
+        return model_uid
+    except Exception as e:
+        print(f"❌ 保存模型元数据到数据库失败: {e}")
+        conn.rollback()
+        return None
+    finally:
+        conn.close()
+
+def query_models_from_db(filters: dict, page: int = 1, page_size: int = 10):
+    """
+    从数据库查询模型列表，支持筛选和分页。
+    """
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    
+    try:
+        query = "SELECT * FROM models"
+        conditions = []
+        params = []
+        
+        if filters.get('product_id'):
+            conditions.append("json_extract(training_scope, '$.product.id') = ?")
+            params.append(filters['product_id'])
+        
+        if filters.get('model_type'):
+            conditions.append("model_type = ?")
+            params.append(filters['model_type'])
+        
+        if filters.get('store_id'):
+            conditions.append("json_extract(training_scope, '$.store.id') = ?")
+            params.append(filters['store_id'])
+            
+        if filters.get('training_mode'):
+            conditions.append("training_mode = ?")
+            params.append(filters['training_mode'])
+            
+        if conditions:
+            query += " WHERE " + " AND ".join(conditions)
+            
+        # 获取总数
+        count_query = query.replace("*", "COUNT(*)")
+        cursor.execute(count_query, params)
+        total_count = cursor.fetchone()[0]
+        
+        # 添加分页
+        offset = (page - 1) * page_size
+        query += " ORDER BY created_at DESC LIMIT ? OFFSET ?"
+        params.extend([page_size, offset])
+        
+        cursor.execute(query, params)
+        models = [dict(row) for row in cursor.fetchall()]
+        
+        return {
+            "models": models,
+            "pagination": {
+                "total": total_count,
+                "page": page,
+                "page_size": page_size,
+                "total_pages": (total_count + page_size - 1) // page_size
+            }
+        }
+        
+    except Exception as e:
+        print(f"❌ 从数据库查询模型失败: {e}")
+        return {"models": [], "pagination": {}}
+    finally:
+        conn.close()
+
+def save_prediction_to_db(prediction_data: dict):
+    """
+    将单次预测记录保存到数据库。
+    """
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute('''
+            INSERT INTO prediction_history (
+                prediction_uid, model_id, model_type, product_name,
+                prediction_scope, prediction_params, metrics, result_file_path
+            ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+        ''', (
+            prediction_data.get('prediction_uid'),
+            prediction_data.get('model_id'), # This should be the model_uid from the 'models' table
+            prediction_data.get('model_type'),
+            prediction_data.get('product_name'),
+            json.dumps(prediction_data.get('prediction_scope')),
+            json.dumps(prediction_data.get('prediction_params')),
+            json.dumps(prediction_data.get('metrics')),
+            prediction_data.get('result_file_path')
+        ))
+        conn.commit()
+        print(f"✅ 预测记录 {prediction_data.get('prediction_uid')} 已保存到数据库。")
+    except Exception as e:
+        print(f"❌ 保存预测记录到数据库失败: {e}")
+        conn.rollback()
+    finally:
+        conn.close()
+
+def find_model_by_uid(model_uid: str):
+    """
+    根据 model_uid 从数据库中查找模型。
+    """
+    conn = get_db_connection()
+    cursor = conn.cursor()
+    try:
+        cursor.execute("SELECT * FROM models WHERE model_uid = ?", (model_uid,))
+        model_record = cursor.fetchone()
+        if model_record:
+            return dict(model_record)
+        return None
+    except Exception as e:
+        print(f"❌ 根据UID查找模型失败: {e}")
+        return None
+    finally:
+        conn.close()
diff --git a/server/utils/model_manager.py b/server/utils/model_manager.py
index 5c352e1..e44035d 100644
--- a/server/utils/model_manager.py
+++ b/server/utils/model_manager.py
@@ -42,12 +42,26 @@ class ModelManager:
         
         max_version = 0
         for f in existing_files:
-            match = re.search(r'_v(\d+)\.pth$', os.path.basename(f))
+            # 修正: 同时匹配 _v1.pth 和 _v1_best.pth 这样的文件名
+            match = re.search(r'_v(\d+)(_best)?\.pth$', os.path.basename(f))
             if match:
                 max_version = max(max_version, int(match.group(1)))
         
         return max_version + 1
 
+    def peek_next_version(self, model_type: str, product_id: Optional[str] = None, store_id: Optional[str] = None, training_mode: str = 'product', aggregation_method: Optional[str] = None) -> str:
+        """
+        预览下一个版本号字符串 (e.g., 'v3')，但不进行任何文件操作。
+        """
+        next_version_num = self._get_next_version(
+            model_type=model_type,
+            product_id=product_id,
+            store_id=store_id,
+            training_mode=training_mode,
+            aggregation_method=aggregation_method
+        )
+        return f"v{next_version_num}"
+
     def generate_model_filename(self,
                                model_type: str,
                                version: str,
@@ -92,7 +106,9 @@ class ModelManager:
         返回:
         (模型文件路径, 使用的版本号)
         """
+        # 修正: 简化版本处理逻辑，由调用方明确提供版本字符串
         if version is None:
+            # 如果未提供版本，则自动生成新版本
             next_version_num = self._get_next_version(
                 model_type=model_type,
                 product_id=product_id,
@@ -102,6 +118,7 @@ class ModelManager:
             )
             version_str = f"v{next_version_num}"
         else:
+            # 直接使用调用方提供的版本字符串 (e.g., 'v3', 'v3_best')
             version_str = version
 
         filename = self.generate_model_filename(
@@ -212,7 +229,8 @@ class ModelManager:
                 
                 # 添加文件信息
                 model_info['filename'] = filename
-                model_info['file_path'] = model_file
+                # 修正: 确保返回的是相对路径
+                model_info['file_path'] = os.path.join(self.model_dir, filename)
                 model_info['file_size'] = os.path.getsize(model_file)
                 model_info['modified_at'] = datetime.fromtimestamp(
                     os.path.getmtime(model_file)
@@ -343,9 +361,5 @@ class ModelManager:
 
 
 # 全局模型管理器实例
-# 确保使用项目根目录的saved_models，而不是相对于当前工作目录
-import os
-current_dir = os.path.dirname(os.path.abspath(__file__))
-project_root = os.path.dirname(os.path.dirname(current_dir))  # 向上两级到项目根目录
-absolute_model_dir = os.path.join(project_root, 'saved_models')
-model_manager = ModelManager(absolute_model_dir)
\ No newline at end of file
+# 修正: 直接使用在config.py中定义的相对路径
+model_manager = ModelManager()
\ No newline at end of file
diff --git a/server/utils/training_process_manager.py b/server/utils/training_process_manager.py
index d95cbcf..d1bc625 100644
--- a/server/utils/training_process_manager.py
+++ b/server/utils/training_process_manager.py
@@ -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.database_utils import save_model_to_db
 import numpy as np
 
 def convert_numpy_types(obj):
@@ -45,6 +46,8 @@ class TrainingTask:
     training_mode: str
     store_id: Optional[str] = None
     epochs: int = 100
+    training_scope: Optional[Dict[str, Any]] = None # 新增
+    artifacts: Optional[Dict[str, Any]] = None # 新增
     status: str = "pending"  # pending, running, completed, failed
     start_time: Optional[str] = None
     end_time: Optional[str] = None
@@ -138,7 +141,7 @@ class TrainingWorker:
                         training_logger.error(f"进度回调失败: {e}")
                 
                 # 执行真正的训练，传递进度回调
-                metrics = predictor.train_model(
+                metrics, artifacts = predictor.train_model(
                     product_id=task.product_id,
                     model_type=task.model_type,
                     epochs=task.epochs,
@@ -181,6 +184,7 @@ class TrainingWorker:
             task.end_time = time.strftime('%Y-%m-%d %H:%M:%S')
             task.progress = 100.0
             task.metrics = metrics
+            task.artifacts = artifacts if artifacts else {}
             task.message = "训练完成"
             
             training_logger.success(f"✅ 训练任务完成 - 耗时: {task.end_time}")
@@ -281,8 +285,8 @@ 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, product_id: str, model_type: str, training_mode: str = "product",
+                   store_id: str = None, epochs: int = 100, training_scope: dict = None, **kwargs) -> str:
         """提交训练任务"""
         task_id = str(uuid.uuid4())
         
@@ -292,7 +296,8 @@ class TrainingProcessManager:
             model_type=model_type,
             training_mode=training_mode,
             store_id=store_id,
-            epochs=epochs
+            epochs=epochs,
+            training_scope=training_scope
         )
         
         with self.lock:
@@ -371,6 +376,34 @@ class TrainingProcessManager:
                                 'product_id': serializable_task_data.get('product_id'),
                                 'model_type': serializable_task_data.get('model_type')
                             })
+                            
+                            # 在此处调用函数，将模型元数据保存到数据库
+                            # 注意：我们需要从task_data中构建一个符合save_model_to_db期望的字典
+                            # 这是一个简化的示例，实际可能需要传递更多参数
+                            # 构建一个更完整的模型数据字典用于保存
+                            # 从 artifacts 中获取版本号
+                            version = serializable_task_data.get('artifacts', {}).get('version')
+                            
+                            # 构建带有版本号的 display_name
+                            base_display_name = f"{serializable_task_data.get('product_id', 'N/A')} - {serializable_task_data.get('model_type')}"
+                            display_name_with_version = f"{base_display_name} ({version})" if version else base_display_name
+
+                            model_to_save = {
+                                'model_uid': f"{serializable_task_data.get('training_mode')}_{serializable_task_data.get('model_type')}_{str(uuid.uuid4())[:8]}",
+                                'display_name': display_name_with_version,
+                                'model_type': serializable_task_data.get('model_type'),
+                                'training_mode': serializable_task_data.get('training_mode'),
+                                'training_scope': serializable_task_data.get('training_scope'),
+                                'version': version,
+                                'status': 'active',
+                                'training_params': {
+                                    'epochs': serializable_task_data.get('epochs')
+                                },
+                                'performance_metrics': serializable_task_data.get('metrics'),
+                                'artifacts': serializable_task_data.get('artifacts')
+                            }
+                            save_model_to_db(model_to_save)
+
                         elif action == 'error':
                             # 训练失败
                             self.websocket_callback('training_update', {
diff --git a/server/utils/visualization.py b/server/utils/visualization.py
index 1def7b6..2eb01ea 100644
--- a/server/utils/visualization.py
+++ b/server/utils/visualization.py
@@ -16,37 +16,45 @@ except ImportError:
         # 后备方案：使用默认值
         DEFAULT_MODEL_DIR = "saved_models"
 
-def plot_loss_curve(train_losses, val_losses, product_name, model_type, save_path=None, model_dir=DEFAULT_MODEL_DIR):
+def plot_loss_curve(train_losses, val_losses, model_type: str, scope: str, identifier: str, version: str = None, save_path=None, model_dir=DEFAULT_MODEL_DIR):
     """
-    绘制训练和验证损失曲线
-    
+    绘制训练和验证损失曲线，并根据scope和identifier生成标准化的文件名。
+
     参数:
     train_losses: 训练损失列表
     val_losses: 验证损失列表
-    product_name: 产品名称
-    model_type: 模型类型
+    model_type: 模型类型 (e.g., 'xgboost')
+    scope: 训练范围 ('product', 'store', 'global')
+    identifier: 范围对应的标识符 (产品名, 店铺ID, 或聚合方法)
+    version: (可选) 模型版本号，用于生成唯一的文件名
     save_path: 保存路径，如果为None则自动生成路径
-    model_dir: 模型保存目录，默认使用配置中的DEFAULT_MODEL_DIR
+    model_dir: 模型保存目录
     """
     plt.figure(figsize=(10, 5))
     plt.plot(train_losses, label='训练损失')
     plt.plot(val_losses, label='验证损失')
-    plt.title(f'{product_name} - {model_type}模型训练和验证损失')
+    
+    # 动态生成标题
+    title_identifier = identifier.replace('_', ' ')
+    title = f'{title_identifier} - {model_type} ({scope}) 模型训练和验证损失'
+    plt.title(title)
+    
     plt.xlabel('Epoch')
     plt.ylabel('Loss')
     plt.legend()
     plt.grid(True)
     
     if save_path:
-        # 如果提供了完整路径，直接使用
         full_path = save_path
     else:
-        # 否则生成默认路径
-        # 确保模型目录存在
         os.makedirs(model_dir, exist_ok=True)
         
-        # 构建文件名：模型类型_产品名_loss_curve.png
-        filename = f"{model_type}_product_{product_name.replace(' ', '_')}_loss_curve.png"
+        # 标准化文件名生成逻辑，与 ModelManager 对齐
+        version_str = f"_{version}" if version else ""
+        # 清理标识符中的非法字符
+        safe_identifier = identifier.replace(' ', '_').replace('/', '_').replace('\\', '_')
+        
+        filename = f"{model_type}_{scope}_{safe_identifier}{version_str}_loss_curve.png"
         full_path = os.path.join(model_dir, filename)
     
     plt.savefig(full_path)
diff --git a/xz数据库2025_07_24.md b/xz数据库2025_07_24.md
new file mode 100644
index 0000000..218a29f
--- /dev/null
+++ b/xz数据库2025_07_24.md
@@ -0,0 +1,54 @@
+# 数据库设计方案 (最终版)
+
+本文档定义了项目重构后的核心数据库结构，旨在实现对机器学习模型和预测历史的统一、高效管理。该设计方案结合了业务需求、前端UI逻辑、后端代码实现以及现有数据库结构，并经过了多次迭代确认。
+
+## 设计原则
+
+- **模型集中化**: 所有模型的元数据统一存储，摆脱对文件系统的依赖。
+- **数据一致性**: 通过逻辑外键确保预测记录与模型版本精确关联。
+- **查询高性能**: 通过冗余关键字段，避免在查询列表时进行不必要的`JOIN`操作。
+- **可扩展性**: 使用JSON字段存储灵活、复杂的范围定义和文件路径，适应未来业务变化。
+- **结构清晰**: 物理文件（模型、日志、预测结果）与数据库记录分离，数据库只存元数据和路径，保持自身轻量。
+
+---
+
+## 表结构定义
+
+### 表1：`models`
+
+这张表是模型管理的核心，负责存储所有模型版本的全生命周期信息。
+
+| 字段名 | 类型 | 确认理由与说明 |
+| :--- | :--- | :--- |
+| `id` | INTEGER | 主键，系统内部使用。 |
+| `model_uid` | TEXT | **[关键]** 用户可见的唯一ID，由后端生成，用于API调用和逻辑关联。 |
+| `display_name` | TEXT | **[建议新增]** 用户可自定义的别名，如“夏季促销模型”，提升易用性。 |
+| `model_type` | TEXT | **已确认.** 核心参数，如 `mlstm`, `kan`。 |
+| `training_mode` | TEXT | **已确认.** 模型的训练范围: `product`, `store`, `global`。 |
+| `training_scope` | TEXT (JSON) | **[最终版]** **精确描述训练范围，并包含中文名。**<br/>- **按药品训练**: `{"product": {"id": "P001", "name": "阿莫西林"}, "stores": "all"}` 或 `{"product": {"id": "P001", "name": "阿莫西林"}, "stores": [{"id": "S001", "name": "城西店"}]}`<br/>- **按店铺训练**: `{"store": {"id": "S001", "name": "城西店"}, "products": "all"}` 或 `{"store": {"id": "S001", "name": "城西店"}, "products": [{"id": "P001", "name": "阿莫西林"}, {"id": "P002", "name": "布洛芬"}]}`<br/>- **全局训练**: `{"stores": "all", "products": "all"}` 或 `{"stores": [{"id": "S001", "name": "城西店"}], "products": [{"id": "P001", "name": "阿莫西林"}]}` |
+| `parent_model_id` | INTEGER | **已确认.** 外键，指向自身 `id`，用于实现“继续训练”功能，形成版本链。 |
+| `version` | TEXT | **已确认.** 模型版本号，如 `v1`, `v2`。 |
+| `status` | TEXT | **已确认.** 模型状态，如 `active`, `archived`，用于控制模型是否可用。 |
+| `training_params` | TEXT (JSON) | **已确认.** 存储训练时的超参数，如 `{"epochs": 50, "aggregation_method": "sum"}`。 |
+| `performance_metrics` | TEXT (JSON) | **已确认.** 存储性能指标，如 `{"R2": 0.85, "RMSE": ...}`。 |
+| `artifacts` | TEXT (JSON) | **[采纳建议]** **存储与模型相关的所有文件路径。** 所有文件均采用**扁平化结构**存放在 `saved_models/` 目录下。示例：<br/>`{"best_model": "saved_models/product_P001_mlstm_best.pth", "versioned_model": "saved_models/product_P001_mlstm_v1.pth", "loss_curve_plot": "saved_models/product_P001_mlstm_v1_loss.png", "loss_curve_data": "saved_models/product_P001_mlstm_v1_history.json"}` |
+| `created_at` | DATETIME | **已确认.** 模型的创建时间。 |
+
+---
+
+### 表2：`prediction_history`
+
+这张表用于记录每一次预测任务的结果，其结构在现有基础上进行了优化，以实现高效查询和完整追溯。
+
+| 字段名 | 类型 | 确认理由与说明 |
+| :--- | :--- | :--- |
+| `id` | INTEGER | **已确认.** 主键，自增。 |
+| `prediction_uid` | TEXT | **已确认.** 唯一的预测ID (UUID)，用于API调用。 |
+| `model_id` | TEXT | **[核心变更]** **使用的模型的唯一标识符。** 在重构后，此字段的值应该与 `models` 表中的某条记录的 `model_uid` 相对应，从而建立起逻辑关联。 |
+| `model_type` | TEXT | **已确认 (冗余).** 冗余存储模型类型（如 `mlstm`），用于在不关联查询的情况下快速筛选历史记录。 |
+| `product_name` | TEXT | **已确认 (冗余).** **冗余存储产品/店铺的中文名**，用于在列表页快速展示，极大提升查询性能。 |
+| `prediction_scope` | TEXT (JSON) | **[新增]** 描述本次预测的范围，与 `models` 表的 `training_scope` 结构类似，指明是为哪个产品/店铺做的预测。 |
+| `prediction_params` | TEXT (JSON) | **已确认.** 存储预测参数，如 `{"start_date": "...", "future_days": 7}`。 |
+| `metrics` | TEXT (JSON) | **已确认 (冗余).** 缓存的性能指标，用于列表展示和排序。 |
+| `result_file_path` | TEXT | **[已采纳您的规范]** 指向预测结果JSON文件的**相对路径**。文件存储在 `saved_predictions/` 目录下，并根据模型名和时间戳命名，例如：`saved_predictions/cnn_bilstm_attention_global_sum_v6_pred_20250724111600.json`。 |
+| `created_at` | DATETIME | **已确认.** 记录的创建时间。 |