feat(rerank): upgrade from manual features to neural network learning

Author: Sky-Runner-Z

spx-algorithm/database/user_feedback/models.py

@@ -56,45 +56,96 @@ class PairwiseTrainingSample:
     feedback_id: int  # 原始反馈记录ID
 
     def get_feature_vector(self) -> List[float]:
-        """提取特征向量用于训练
+        """提取神经网络特征向量用于训练
         
         特征包括：
-        - query向量与better图片向量的余弦相似度
-        - query向量与worse图片向量的余弦相似度  
-        - better图片向量与worse图片向量的余弦相似度
-        - 向量间的点积、欧氏距离等交互特征
+        - 原始向量特征: query_vec, better_vec, worse_vec
+        - 交互特征: element-wise乘积和差值
+        - 对比特征: better vs worse直接对比
+        - 统计特征: 余弦相似度和欧氏距离
         """
         import numpy as np
 
         query_vec = np.array(self.query_vector)
         better_vec = np.array(self.pic_vector_better)
         worse_vec = np.array(self.pic_vector_worse)
 
-        return compute_pairwise_features(query_vec, better_vec, worse_vec)
+        return compute_neural_network_features(query_vec, better_vec, worse_vec)
 
 
-def compute_pairwise_features(query_vec, better_vec, worse_vec) -> List[float]:
+def compute_neural_network_features(query_vec, better_vec, worse_vec) -> List[float]:
     """
-    统一的pair-wise特征计算函数，供训练和预测阶段共用
+    统一的神经网络特征计算函数，供训练和预测阶段共用
     
     设计说明：
-    - 该函数计算query、better、worse三个向量之间的pair-wise特征
+    - 该函数计算query、better、worse三个向量之间的神经网络特征
     - 训练时：better是用户选择的图片，worse是未选择的图片
     - 预测时：better是当前候选图片，worse是动态参考向量（候选集合的平均向量）
     
     特征设计理由：
-    1. 相似度特征：衡量query与两个图片的语义匹配程度
-    2. 距离特征：衡量向量空间中的几何距离关系
-    3. 差异特征：直接比较better vs worse的相对优劣
-    4. 长度特征：向量的模长反映了特征的激活强度
+    1. 原始向量特征：保留完整信息，让神经网络自动学习
+    2. 交互特征：捕捉query与候选图片间的特征对应关系
+    3. 对比特征：直接比较better vs worse的相对优劣
+    4. 统计特征：传统手工特征作为补充
     
     Args:
-        query_vec: 查询向量 (numpy array)
-        better_vec: 更好的图片向量 (numpy array) 
-        worse_vec: 更差的图片向量 (numpy array)
+        query_vec: 查询向量 (numpy array, 长度d)
+        better_vec: 更好的图片向量 (numpy array, 长度d) 
+        worse_vec: 更差的图片向量 (numpy array, 长度d)
         
     Returns:
-        10维特征向量列表
+        (6d+6)维特征向量列表
+    """
+    import numpy as np
+    
+    features = []
+    
+    # 1. 原始向量特征 (3d维)
+    features.extend(query_vec.tolist())   # d维
+    features.extend(better_vec.tolist())  # d维
+    features.extend(worse_vec.tolist())   # d维
+    
+    # 2. 交互特征 (2d维)
+    # element-wise乘积 - 捕捉特征对应关系
+    element_wise_product = query_vec * better_vec
+    features.extend(element_wise_product.tolist())  # d维
+    
+    # element-wise差值 - 体现语义gap
+    element_wise_diff = query_vec - better_vec
+    features.extend(element_wise_diff.tolist())     # d维
+    
+    # 3. 对比特征 (d维)
+    # better vs worse直接对比
+    better_worse_diff = better_vec - worse_vec
+    features.extend(better_worse_diff.tolist())     # d维
+    
+    # 4. 统计特征 (6维) - 传统手工特征作为补充
+    # 余弦相似度
+    cosine_sim_query_better = np.dot(query_vec, better_vec) / (np.linalg.norm(query_vec) * np.linalg.norm(better_vec) + 1e-8)
+    cosine_sim_query_worse = np.dot(query_vec, worse_vec) / (np.linalg.norm(query_vec) * np.linalg.norm(worse_vec) + 1e-8)
+    cosine_sim_better_worse = np.dot(better_vec, worse_vec) / (np.linalg.norm(better_vec) * np.linalg.norm(worse_vec) + 1e-8)
+    
+    # 欧氏距离
+    l2_dist_query_better = np.linalg.norm(query_vec - better_vec)
+    l2_dist_query_worse = np.linalg.norm(query_vec - worse_vec)
+    l2_dist_better_worse = np.linalg.norm(better_vec - worse_vec)
+    
+    features.extend([
+        cosine_sim_query_better,
+        cosine_sim_query_worse,
+        cosine_sim_better_worse,
+        l2_dist_query_better,
+        l2_dist_query_worse,
+        l2_dist_better_worse
+    ])
+    
+    return features
+
+
+# 保留原始函数以保持向后兼容（可选）
+def compute_pairwise_features(query_vec, better_vec, worse_vec) -> List[float]:
+    """
+    旧版本pair-wise特征计算函数（保留以保持向后兼容）
     """
     import numpy as np
 

spx-algorithm/services/reranking/feature_extractor.py

@@ -6,7 +6,7 @@
 import numpy as np
 from typing import List, Dict, Any, Optional, Tuple
 from ..image_matching.clip_service import CLIPService
-from database.user_feedback.models import UserFeedback, PairwiseTrainingSample, TrainingDataset, compute_pairwise_features
+from database.user_feedback.models import UserFeedback, PairwiseTrainingSample, TrainingDataset, compute_neural_network_features
 
 logger = logging.getLogger(__name__)
 
@@ -152,14 +152,14 @@ def _get_query_vector(self, query_text: str) -> Optional[np.ndarray]:
     def extract_ranking_features(self, query_text: str, 
                                candidates: List[Dict[str, Any]]) -> List[List[float]]:
         """
-        为排序预测提取pair-wise特征，使用动态参考向量方案
+        为排序预测提取神经网络特征，使用动态参考向量方案
                 
         Args:
             query_text: 查询文本
             candidates: 候选结果列表，每个包含id, vector等字段
             
         Returns:
-            每个候选结果的pair-wise特征向量列表（10维）
+            每个候选结果的神经网络特征向量列表（6d+6维）
         """
         try:
             query_vector = self._get_query_vector(query_text)
@@ -187,7 +187,9 @@ def extract_ranking_features(self, query_text: str,
 
             if not candidate_vectors:
                 logger.error("所有候选结果都缺少向量数据")
-                return [[0.0] * 10] * len(candidates)
+                # 假设向量维度为512，神经网络特征维度为6*512+6=3078
+                feature_dim = 6 * len(query_vector) + 6 if query_vector is not None else 3078
+                return [[0.0] * feature_dim] * len(candidates)
 
             # 计算动态参考向量：候选集合的平均向量
             # 这个平均向量代表当前候选集合的"平均质量水平"
@@ -196,57 +198,73 @@ def extract_ranking_features(self, query_text: str,
             query_vec = np.array(query_vector)
             features_list = []
 
-            # 为每个候选图片计算pair-wise特征
+            # 为每个候选图片计算神经网络特征
             for i, candidate in enumerate(candidates):
                 pic_vector = candidate.get('vector', [])
                 if len(pic_vector) == 0:
                     # 对于缺少向量的候选，填充零特征向量
-                    features_list.append([0.0] * 10)
+                    feature_dim = 6 * len(query_vector) + 6
+                    features_list.append([0.0] * feature_dim)
                     continue
 
                 pic_vec = np.array(pic_vector)
 
-                # 使用统一的pair-wise特征计算函数
+                # 使用统一的神经网络特征计算函数
                 # candidate作为"better"，reference_vector作为"worse"
-                features = compute_pairwise_features(query_vec, pic_vec, reference_vector)
+                features = compute_neural_network_features(query_vec, pic_vec, reference_vector)
                 features_list.append(features)
 
-            logger.debug(f"成功提取{len(features_list)}个候选结果的pair-wise特征")
+            logger.debug(f"成功提取{len(features_list)}个候选结果的神经网络特征")
             return features_list
 
         except Exception as e:
             logger.error(f"排序特征提取失败: {e}")
-            return [[0.0] * 10] * len(candidates)
+            # 如果出错，返回合适维度的零向量
+            try:
+                feature_dim = 6 * len(query_vector) + 6 if query_vector is not None else 3078
+                return [[0.0] * feature_dim] * len(candidates)
+            except:
+                return [[0.0] * 3078] * len(candidates)
 
     def get_feature_names(self) -> List[str]:
-        """获取特征名称列表"""
-        return [
-            'query_better_similarity',
-            'query_worse_similarity', 
-            'better_worse_similarity',
-            'similarity_difference',
-            'query_better_distance',
-            'query_worse_distance',
-            'distance_difference',
-            'query_norm',
-            'better_norm',
-            'worse_norm'
-        ]
+        """获取神经网络特征名称列表"""
+        # 假设向量维度为512（从CLIP模型配置获取）
+        d = 512
+        feature_names = []
+        
+        # 原始向量特征 (3d维)
+        for i in range(d):
+            feature_names.append(f'query_vec_{i}')
+        for i in range(d):
+            feature_names.append(f'better_vec_{i}')
+        for i in range(d):
+            feature_names.append(f'worse_vec_{i}')
+        
+        # 交互特征 (2d维)
+        for i in range(d):
+            feature_names.append(f'element_wise_product_{i}')
+        for i in range(d):
+            feature_names.append(f'element_wise_diff_{i}')
+        
+        # 对比特征 (d+6维)
+        for i in range(d):
+            feature_names.append(f'better_worse_diff_{i}')
+        
+        # 统计特征 (6维)
+        feature_names.extend([
+            'cosine_sim_query_better',
+            'cosine_sim_query_worse', 
+            'cosine_sim_better_worse',
+            'l2_dist_query_better',
+            'l2_dist_query_worse',
+            'l2_dist_better_worse'
+        ])
+        
+        return feature_names
 
     def get_ranking_feature_names(self) -> List[str]:
-        """获取排序特征名称列表（与训练时保持一致的pair-wise特征）"""
-        return [
-            'query_better_similarity',  # query与候选图片相似度
-            'query_worse_similarity',   # query与参考向量相似度
-            'better_worse_similarity',  # 候选图片与参考向量相似度
-            'similarity_difference',    # 相似度差异（候选-参考）
-            'query_better_distance',    # query与候选图片距离
-            'query_worse_distance',     # query与参考向量距离
-            'distance_difference',      # 距离差异（参考-候选）
-            'query_norm',              # query向量长度
-            'better_norm',             # 候选图片向量长度
-            'worse_norm'               # 参考向量长度
-        ]
+        """获取排序特征名称列表（与训练时保持一致的神经网络特征）"""
+        return self.get_feature_names()
 
     def clear_cache(self):
         """清空向量缓存"""

spx-algorithm/services/reranking/ltr_model.py

@@ -1,5 +1,5 @@
 """
-LTR重排序模型：基于LightGBM的pair-wise学习排序
+LTR重排序模型：支持LightGBM和神经网络的统一接口
 """
 
 import logging
@@ -11,21 +11,23 @@
 
 
 class LTRModel:
-    """Learning to Rank 模型类"""
+    """Learning to Rank 模型类：支持LightGBM和神经网络"""
 
-    def __init__(self, model_path: Optional[str] = None):
+    def __init__(self, model_path: Optional[str] = None, model_type: str = "neural_network"):
         """
         初始化LTR模型
         
         Args:
             model_path: 模型文件路径
+            model_type: 模型类型，'lightgbm' 或 'neural_network'
         """
         self.model_path = model_path or "models/ltr_model.pkl"
-        self.trainer = LTRTrainer(self.model_path)
+        self.model_type = model_type
+        self.trainer = LTRTrainer(self.model_path, model_type)
         self.feature_extractor = None  # 需要在初始化时注入
         self.is_trained = False
 
-        logger.info(f"LTR模型初始化完成，模型路径: {self.model_path}")
+        logger.info(f"LTR模型初始化完成，模型类型: {model_type}, 模型路径: {self.model_path}")
 
     def set_feature_extractor(self, feature_extractor: LTRFeatureExtractor):
         """设置特征提取器"""
@@ -74,14 +76,14 @@ def predict_ranking_scores(self, query_text: str,
                 logger.error("特征提取器未设置")
                 return [0.0] * len(candidates)
 
-            # 提取排序特征
+            # 提取排序特征（神经网络或传统特征）
             features = self.feature_extractor.extract_ranking_features(query_text, candidates)
 
             if not features:
                 logger.warning("特征提取失败，返回默认分数")
                 return [candidate.get('similarity', 0.0) for candidate in candidates]
 
-            # 预测排序分数
+            # 预测排序分数（自动适配模型类型）
             scores = self.trainer.predict_ranking_scores(features)
 
             if not scores:
@@ -168,6 +170,7 @@ def get_model_info(self) -> Dict[str, Any]:
             return {
                 **trainer_info,
                 'model_path': self.model_path,
+                'model_type': self.model_type,
                 'has_feature_extractor': self.feature_extractor is not None,
                 'is_ready': self.is_trained and self.feature_extractor is not None
             }