Merge branch 'master' into feature_20260706_multi_tab

recommend-server-service/src/main/java/com/tzld/piaoquan/recommend/server/service/rank/strategy/RankStrategy4RegionMergeModelV562.java

@@ -40,10 +40,10 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
     private FeatureService featureService;
 
     /**
-     * V562 个性化召回白名单 (6 路: V566 基础 6 路)：召回 key 含 mid/uid，依赖该用户行为信号。
+     * V562 个性化召回白名单 (7 路: V566 基础 6 路 + 1 路 dk_elements 画像路实验)：召回 key 含 mid/uid，
+     * 依赖该用户行为信号。
+     * V562 实验路径: UserProfileDkElements (用户元素画像 s_z_y_s/zt_gyf)
      * 注：YearReturnCate2 因线上效果不佳, 2026-06-04 起移到非个性化白名单。
-     * 注：YearShareDkElements (dk_elements 行为路实验) 2026-06-18 起改为保送 (独立配额, 不参与粗排截断)，
-     *     不再属于个性化/非个性化白名单, 见 mergeAndRankRovRecall 里 dkElementsBaosongTopN 段。
      */
     private static final Set<String> PERSONAL_RECALL_PUSH_FROMS = new HashSet<>(Arrays.asList(
             UserCate1RecallStrategy.PUSH_FORM,
@@ -51,7 +51,8 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
             Return1Cate2RosRecallStrategy.PUSH_FORM,
             Return1Cate2StrRecallStrategy.PUSH_FORM,
             YearShareCate1RecallStrategy.PUSH_FROM,
-            YearShareCate2RecallStrategy.PUSH_FROM
+            YearShareCate2RecallStrategy.PUSH_FROM,
+            UserProfileDkElementsFXRecallStrategy.PUSH_FROM
     ));
 
     /**
@@ -78,7 +79,7 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
             YearReturnCate2RecallStrategy.PUSH_FROM
     ));
 
-    /** PERSONAL ∪ NON_PERSONAL = 22 路（参与粗排截断竞争的路）。 */
+    /** PERSONAL ∪ NON_PERSONAL = 23 路。用于 fetchCoarseRankScores 跳过流量池等不参与截断的 vid。 */
     private static final Set<String> ALL_ROV_PUSH_FROMS;
     static {
         Set<String> all = new HashSet<>(PERSONAL_RECALL_PUSH_FROMS);
@@ -86,22 +87,10 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
         ALL_ROV_PUSH_FROMS = Collections.unmodifiableSet(all);
     }
 
-    /**
-     * 粗排分拉取范围 = 22 路截断 + dk 保送路。dk 保送虽不参与截断竞争，但其 top-10 也按粗排分挑，
-     * 故需为它拉粗排分。仍跳过流量池 3 路（独立通道，不需要粗排分）。
-     */
-    private static final Set<String> COARSE_RANK_FETCH_PUSH_FROMS;
-    static {
-        Set<String> s = new HashSet<>(ALL_ROV_PUSH_FROMS);
-        s.add(YearShareDkElementsRecallStrategy.PUSH_FROM);
-        COARSE_RANK_FETCH_PUSH_FROMS = Collections.unmodifiableSet(s);
-    }
-
     /*
      * 设计要点：
      *   - fail-closed 白名单：RecallService 未来加新路不会自动进 V562，避免污染 vs V568 AB 对比
      *   - 流量池 3 路 (flow_pool / quick_flow_pool / recall_strategy_hotspot) 不在任何名单——独立通道
-     *   - dk_elements 行为路保送：独立配额 (默认 10)，叠加在两路截断之后(不扰动前两路, 便于单路增益 AB)，不在个性化/非个性化名单
      *   - 调用顺序 = 个性化优先：同 vid 双类命中时归个性化，保护用户兴趣信号
      */
 
@@ -143,26 +132,6 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
         log.info("coarse_rank_summary exp=562 quota={} pc={} ps={} nc={} ns={}",
                 totalTopN, personalCandidates, personalActual, nonPersonalCandidates, nonPersonalActual);
 
-        // ============================================================
-        // V562 实验：dk_elements 行为路保送 (独立配额, 叠加在两路截断之后)。
-        // 跑在最后面：个性化/非个性化先按基线行为选完, 不被这一路扰动；
-        // 现有日志/过程数据/归因均不改, 只把这一路纯叠加进来。
-        // top-N 选择口径由 Apollo 开关 dkBaosongUseCoarseScore 控制 (默认 1=粗排分; 0=dk 自身 rovn 分),
-        // 选择不受 setVideo 影响, 插入时仅跳过已在池中的 vid 以避免重复视频, 不回填后续名次。
-        // 观测单独打一条新日志, 不污染上面的 coarse_rank_summary。
-        // ============================================================
-        int dkElementsBaosongTopN = mergeWeight.getOrDefault("dkElementsBaosongTopN", 10.0).intValue();
-        // 1=按粗排分挑 (与两路截断同口径)；0=按 dk 自身召回 rovn 分。传空 map 即回退到 rovScore 排序且不覆盖。
-        boolean dkBaosongUseCoarse = mergeWeight.getOrDefault("dkBaosongUseCoarseScore", 1.0) > 0.5;
-        Map<Long, Double> baosongScoreMap = dkBaosongUseCoarse ? coarseRankMap : Collections.emptyMap();
-        int sizeBeforeBaosong = rovRecallRank.size();
-        RecallUtils.extractRecallGuaranteed(dkElementsBaosongTopN, param, YearShareDkElementsRecallStrategy.PUSH_FROM, setVideo, rovRecallRank, baosongScoreMap);
-        int baosongActual = rovRecallRank.size() - sizeBeforeBaosong;
-        // 保送观测日志开关: 默认 0=不打; 1=打 (Apollo dkBaosongLog)
-        if (mergeWeight.getOrDefault("dkBaosongLog", 0.0) > 0.5) {
-            log.info("baosong_summary exp=562 dk_quota={} dk_actual={} use_coarse={}", dkElementsBaosongTopN, baosongActual, dkBaosongUseCoarse);
-        }
-
         // 记录召回源中的视频
         this.rankBeforePostProcessor(rovRecallRank);
 
@@ -461,10 +430,10 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
         double w24h = mergeWeight.getOrDefault("coarseRovn24hW", 0.5);
         double plus1h = mergeWeight.getOrDefault("coarseRovn1hSmoothPlus", 30.0);
         double plus24h = mergeWeight.getOrDefault("coarseRovn24hSmoothPlus", 30.0);
-        // 对参与统一截断的 22 路 + dk 保送路 vid 拉粗排分（跳过流量池 3 路，省 proto + RPC 延迟）
+        // 只对参与统一截断的 23 路 vid 拉粗排分（跳过流量池 3 路，省 proto + RPC 延迟）
         List<String> vids = param.getRecallResult().getData().stream()
                 .filter(d -> d != null && CollectionUtils.isNotEmpty(d.getVideos()))
-                .filter(d -> COARSE_RANK_FETCH_PUSH_FROMS.contains(d.getPushFrom()))
+                .filter(d -> ALL_ROV_PUSH_FROMS.contains(d.getPushFrom()))
                 .flatMap(d -> d.getVideos().stream())
                 .map(v -> String.valueOf(v.getVideoId()))
                 .distinct()

recommend-server-service/src/main/java/com/tzld/piaoquan/recommend/server/service/rank/strategy/RankStrategy4RegionMergeModelV568.java

@@ -7,7 +7,9 @@ import com.tzld.piaoquan.recommend.server.common.base.RankItem;
 import com.tzld.piaoquan.recommend.server.model.MachineInfo;
 import com.tzld.piaoquan.recommend.server.model.Video;
 import com.tzld.piaoquan.recommend.server.service.FeatureService;
+import com.tzld.piaoquan.recommend.server.service.funnel.FunnelContext;
 import com.tzld.piaoquan.recommend.server.service.rank.RankParam;
+import com.tzld.piaoquan.recommend.server.service.rank.RankResult;
 import com.tzld.piaoquan.recommend.server.service.rank.bo.UserShareReturnProfile;
 import com.tzld.piaoquan.recommend.server.service.rank.extractor.ExtractVideoMergeCate;
 import com.tzld.piaoquan.recommend.server.service.rank.tansform.FeatureV6;
@@ -17,6 +19,7 @@ import com.tzld.piaoquan.recommend.server.util.*;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.lang3.RandomUtils;
 import org.apache.commons.lang3.StringUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
@@ -36,6 +39,61 @@ public class RankStrategy4RegionMergeModelV568 extends RankStrategy4RegionMergeM
     @Autowired
     private FeatureService featureService;
 
+    /**
+     * V565 个性化召回白名单 (7 路: V566 基础 6 路 + 1 路 dk_elements 画像路实验)：召回 key 含 mid/uid，
+     * 依赖该用户行为信号。
+     * V565 实验路径: UserProfileDkElements (用户元素画像 s_z_y_s/zt_gyf)
+     * 注：YearReturnCate2 因线上效果不佳, 2026-06-04 起移到非个性化白名单。
+     */
+    private static final Set<String> PERSONAL_RECALL_PUSH_FROMS = new HashSet<>(Arrays.asList(
+            UserCate1RecallStrategyV568.PUSH_FORM,
+            UserCate2RecallStrategyV568.PUSH_FORM,
+            Return1Cate2RosRecallStrategy.PUSH_FORM,
+            Return1Cate2StrRecallStrategy.PUSH_FORM,
+            YearShareCate1RecallStrategy.PUSH_FROM,
+            YearShareCate2RecallStrategy.PUSH_FROM,
+            UserProfileDkElementsRecallStrategy.PUSH_FROM
+    ));
+
+    /**
+     * V565 非个性化召回白名单 (17 路)：只依赖 headVid + 地域/品类/相似度（vid-vid CF 也归此类）。
+     * 含 5 路旧地域、新地域、城市、head province/cate、先验省份、return 相似、scene CF、YearReturnCate2。
+     */
+    private static final Set<String> NON_PERSONAL_RECALL_PUSH_FROMS = new HashSet<>(Arrays.asList(
+            RegionHRecallStrategy.PUSH_FORM,
+            RegionHDupRecallStrategy.PUSH_FORM,
+            Region24HRecallStrategy.PUSH_FORM,
+            RegionRelative24HRecallStrategy.PUSH_FORM,
+            RegionRelative24HDupRecallStrategy.PUSH_FORM,
+            RegionRealtimeRecallStrategyV1.PUSH_FORM,
+            CityRovnRecallStrategy.PUSH_FROM,
+            HeadProvinceCate1RecallStrategy.PUSH_FORM,
+            HeadProvinceCate2RecallStrategy.PUSH_FORM,
+            HeadCate2RovRecallStrategy.PUSH_FROM,
+            PrioriProvinceRovnRecallStrategy.PUSH_FROM,
+            PrioriProvinceStrRecallStrategy.PUSH_FROM,
+            PrioriProvinceRosRecallStrategy.PUSH_FROM,
+            ReturnVideoRecallStrategy.PUSH_FORM,
+            SceneCFRovnRecallStrategy.PUSH_FORM,
+            SceneCFRosnRecallStrategy.PUSH_FORM,
+            YearReturnCate2RecallStrategy.PUSH_FROM
+    ));
+
+    /** PERSONAL ∪ NON_PERSONAL = 23 路。用于 fetchCoarseRankScores 跳过流量池等不参与截断的 vid。 */
+    private static final Set<String> ALL_ROV_PUSH_FROMS;
+    static {
+        Set<String> all = new HashSet<>(PERSONAL_RECALL_PUSH_FROMS);
+        all.addAll(NON_PERSONAL_RECALL_PUSH_FROMS);
+        ALL_ROV_PUSH_FROMS = Collections.unmodifiableSet(all);
+    }
+
+    /*
+     * 设计要点：
+     *   - fail-closed 白名单：RecallService 未来加新路不会自动进 V565，避免污染 vs V568 AB 对比
+     *   - 流量池 3 路 (flow_pool / quick_flow_pool / recall_strategy_hotspot) 不在任何名单——独立通道
+     *   - 调用顺序 = 个性化优先：同 vid 双类命中时归个性化，保护用户兴趣信号
+     */
+
     @Override
     public List<Video> mergeAndRankRovRecall(RankParam param) {
         Map<String, Double> mergeWeight = this.mergeWeight != null ? this.mergeWeight : new HashMap<>(0);
@@ -49,42 +107,30 @@ public class RankStrategy4RegionMergeModelV568 extends RankStrategy4RegionMergeM
         Set<Long> setVideo = new HashSet<>();
         setVideo.add(param.getHeadVid());
         List<Video> rovRecallRank = new ArrayList<>();
-        // -------------------5路特殊旧召回------------------
-        RecallUtils.extractOldSpecialRecall(mergeWeight.getOrDefault("oldSpecialN", (double) param.getSize()).intValue(), param, setVideo, rovRecallRank);
-        //-------------------return相似召回------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("v6", 5.0).intValue(), param, ReturnVideoRecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
-        //-------------------新地域召回------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("v1", 5.0).intValue(), param, RegionRealtimeRecallStrategyV1.PUSH_FORM, setVideo, rovRecallRank);
-        //-------------------scene cf rovn------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("sceneCFRovn", 5.0).intValue(), param, SceneCFRovnRecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
-        //-------------------scene cf rosn------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("sceneCFRosn", 5.0).intValue(), param, SceneCFRosnRecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
-        // -------------------user cate1------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("cate1RecallN", 5.0).intValue(), param, UserCate1RecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
-        // -------------------user cate2------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("cate2RecallN", 5.0).intValue(), param, UserCate2RecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
-        // -------------------head province cate1------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("headCate1RecallN", 3.0).intValue(), param, HeadProvinceCate1RecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
-        // -------------------head province cate2------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("headCate2RecallN", 3.0).intValue(), param, HeadProvinceCate2RecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
-        //-------------------head cate2 of rovn------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("headCate2Rov", 5.0).intValue(), param, HeadCate2RovRecallStrategy.PUSH_FROM, setVideo, rovRecallRank);
-        //-------------------city rovn------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("cityRov", 5.0).intValue(), param, CityRovnRecallStrategy.PUSH_FROM, setVideo, rovRecallRank);
-        //-------------------priori province rovn------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("prioriProvinceRov", 3.0).intValue(), param, PrioriProvinceRovnRecallStrategy.PUSH_FROM, setVideo, rovRecallRank);
-        //-------------------priori province str------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("prioriProvinceStr", 1.0).intValue(), param, PrioriProvinceStrRecallStrategy.PUSH_FROM, setVideo, rovRecallRank);
-        //-------------------priori province ros------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("prioriProvinceRos", 1.0).intValue(), param, PrioriProvinceRosRecallStrategy.PUSH_FROM, setVideo, rovRecallRank);
-        //-------------------return1 cate2 ros------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("return1Cate2Ros", 5.0).intValue(), param, Return1Cate2RosRecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
-        //-------------------return1 cate2 str------------------
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("return1Cate2Str", 5.0).intValue(), param, Return1Cate2StrRecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
-
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("yearShareCate1", 5.0).intValue(), param, YearShareCate1RecallStrategy.PUSH_FROM, setVideo, rovRecallRank);
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("yearShareCate2", 5.0).intValue(), param, YearShareCate2RecallStrategy.PUSH_FROM, setVideo, rovRecallRank);
-        RecallUtils.extractRecall(mergeWeight.getOrDefault("yearReturnCate2", 5.0).intValue(), param, YearReturnCate2RecallStrategy.PUSH_FROM, setVideo, rovRecallRank);
+
+        // ============================================================
+        // V565 实验：统一粗排分截断 (个性化 / 非个性化 两配额, 动态补足)
+        // 总配额 coarseRankTopN，个性化占 personalRatio。先个性化按上限抢位，
+        // 个性化不足时剩余名额转给非个性化，保证精排算力满载。
+        //
+        // 粗排分 = alg_vid_recommend_exp_feature_20250212.rovn_1h / rovn_24h 平均
+        // ============================================================
+        int totalTopN = mergeWeight.getOrDefault("coarseRankTopN", 80.0).intValue();
+        double personalRatio = mergeWeight.getOrDefault("personalRatio", 0.8);
+        int personalTopN = (int) Math.round(totalTopN * personalRatio);
+        Map<Long, Double> coarseRankMap = fetchCoarseRankScores(param);
+
+        int personalCandidates = RecallUtils.countDistinctCandidates(param, setVideo, PERSONAL_RECALL_PUSH_FROMS);
+        int sizeBeforePersonal = rovRecallRank.size();
+        RecallUtils.extractAllAndTruncateByCoarseRank(personalTopN, param, setVideo, rovRecallRank, coarseRankMap, PERSONAL_RECALL_PUSH_FROMS);
+        int personalActual = rovRecallRank.size() - sizeBeforePersonal;
+        int nonPersonalBudget = totalTopN - personalActual;  // 个性化不足时, 名额转给非个性化
+        int nonPersonalCandidates = RecallUtils.countDistinctCandidates(param, setVideo, NON_PERSONAL_RECALL_PUSH_FROMS);
+        int sizeBeforeNonPersonal = rovRecallRank.size();
+        RecallUtils.extractAllAndTruncateByCoarseRank(nonPersonalBudget, param, setVideo, rovRecallRank, coarseRankMap, NON_PERSONAL_RECALL_PUSH_FROMS);
+        int nonPersonalActual = rovRecallRank.size() - sizeBeforeNonPersonal;
+        log.info("coarse_rank_summary exp=565 quota={} pc={} ps={} nc={} ns={}",
+                totalTopN, personalCandidates, personalActual, nonPersonalCandidates, nonPersonalActual);
 
         // 记录召回源中的视频
         this.rankBeforePostProcessor(rovRecallRank);
@@ -289,6 +335,148 @@ public class RankStrategy4RegionMergeModelV568 extends RankStrategy4RegionMergeM
         return result;
     }
 
+    /**
+     * 同 V567 极简 fusion：只保留"流量池相关 + 兜底相关"逻辑
+     *   1. rov 空兜底：rov 池为空时流量池直接顶上 (Basic 段 1)
+     *   7. 流量池按比例强插：topK 头部锁 rov + topK..size 按 flowPoolP / newFlowPoolSelectRate 概率门
+     *      混入 flowVideos / douHotFlowPoolVideos，否则用 rov 中段；一侧用光时另一侧兜底回填 (Basic 段 7)
+     *
+     * 删除（相对 Basic）：标签 filter / rov boost / 强插 / 品类降权 / 节日降权 / 密度控制
+     */
+    @Override
+    public RankResult mergeAndSort(RankParam param, List<Video> rovVideos, List<Video> flowVideos, List<Video> douHotFlowPoolVideos) {
+
+        // 1 兜底策略，rov池子不足时，用冷启池填补。直接返回。
+        if (CollectionUtils.isEmpty(rovVideos)) {
+            if (param.getSize() < flowVideos.size()) {
+                return new RankResult(flowVideos.subList(0, param.getSize()));
+            } else {
+                return new RankResult(flowVideos);
+            }
+        }
+
+        // 7 流量池按比例强插
+        FunnelContext funnelCtx = param.getFunnelContext();
+        List<Video> result = new ArrayList<>();
+        for (int i = 0; i < param.getTopK() && i < rovVideos.size(); i++) {
+            result.add(rovVideos.get(i));
+        }
+        double flowPoolP = getFlowPoolP(param);
+        int flowPoolIndex = 0;
+        int rovPoolIndex = param.getTopK();
+        for (int i = 0; i < param.getSize() - param.getTopK(); i++) {
+            double rand = RandomUtils.nextDouble(0, 1);
+            if (rand < flowPoolP) {
+                if (flowPoolIndex < flowVideos.size()) {
+                    Video v = flowVideos.get(flowPoolIndex++);
+                    result.add(v);
+                    markColdStartInserted(funnelCtx, v);
+                } else {
+                    break;
+                }
+            } else if (this.isInsertDouHotFlowPoolVideo()) {
+                if (flowPoolIndex < douHotFlowPoolVideos.size()) {
+                    Video v = douHotFlowPoolVideos.get(flowPoolIndex++);
+                    result.add(v);
+                    markColdStartInserted(funnelCtx, v);
+                } else {
+                    break;
+                }
+            } else {
+                if (rovPoolIndex < rovVideos.size()) {
+                    result.add(rovVideos.get(rovPoolIndex++));
+                } else {
+                    break;
+                }
+            }
+        }
+        if (rovPoolIndex >= rovVideos.size()) {
+            for (int i = flowPoolIndex; i < flowVideos.size() && result.size() < param.getSize(); i++) {
+                Video v = flowVideos.get(i);
+                result.add(v);
+                markColdStartInserted(funnelCtx, v);
+            }
+        }
+        if (flowPoolIndex >= flowVideos.size()) {
+            for (int i = rovPoolIndex; i < rovVideos.size() && result.size() < param.getSize(); i++) {
+                result.add(rovVideos.get(i));
+            }
+        }
+
+        return new RankResult(result);
+    }
+
+    /**
+     * V565 实验：拉取粗排分（按 vid → score 返回）。
+     *
+     * 数据源：alg_vid_recommend_exp_feature_20250212。
+     * 表里没有现成 rovn 字段，需要从原子字段 (return_n_uv_*, exp_*) 用 plusSmooth 算出来。
+     * 公式 = FeatureV6.oneTypeStatFeature 同口径：rovn = plusSmooth(return_n_uv, exp, plus, 1)
+     * 默认 plus=30 与 FeatureV6.largerSmoothPlus 对齐，AB 对比不会因口径不同污染结论。
+     *
+     * Apollo 可调维度：
+     *   - coarseRovn1hW / coarseRovn24hW：1h 和 24h 的加权（默认 0.5/0.5）
+     *   - coarseRovn1hSmoothPlus / coarseRovn24hSmoothPlus：贝叶斯平滑系数（默认 30/30）
+     *
+     * 缺失自动归一化：单值缺失时剩下的撑起全部权重；两值都缺失则 caller 兜底 RovScore。
+     */
+    private Map<Long, Double> fetchCoarseRankScores(RankParam param) {
+        if (param == null || param.getRecallResult() == null
+                || CollectionUtils.isEmpty(param.getRecallResult().getData())) {
+            return Collections.emptyMap();
+        }
+        Map<String, Double> mergeWeight = this.mergeWeight != null ? this.mergeWeight : Collections.emptyMap();
+        double w1h = mergeWeight.getOrDefault("coarseRovn1hW", 0.5);
+        double w24h = mergeWeight.getOrDefault("coarseRovn24hW", 0.5);
+        double plus1h = mergeWeight.getOrDefault("coarseRovn1hSmoothPlus", 30.0);
+        double plus24h = mergeWeight.getOrDefault("coarseRovn24hSmoothPlus", 30.0);
+        // 只对参与统一截断的 23 路 vid 拉粗排分（跳过流量池 3 路，省 proto + RPC 延迟）
+        List<String> vids = param.getRecallResult().getData().stream()
+                .filter(d -> d != null && CollectionUtils.isNotEmpty(d.getVideos()))
+                .filter(d -> ALL_ROV_PUSH_FROMS.contains(d.getPushFrom()))
+                .flatMap(d -> d.getVideos().stream())
+                .map(v -> String.valueOf(v.getVideoId()))
+                .distinct()
+                .collect(Collectors.toList());
+        if (vids.isEmpty()) return Collections.emptyMap();
+
+        Map<String, Map<String, Map<String, String>>> feats = featureService.getVideoCoarseRankFeature(vids);
+        Map<Long, Double> result = new HashMap<>(vids.size());
+        for (String vid : vids) {
+            Map<String, String> row = feats.getOrDefault(vid, Collections.emptyMap())
+                    .getOrDefault("alg_vid_recommend_exp_feature_20250212", Collections.emptyMap());
+            Double rovn1h = computeRovn(row, "1h", plus1h);
+            Double rovn24h = computeRovn(row, "24h", plus24h);
+            // 加权平均，缺失自动归一化
+            double sumW = (rovn1h != null ? w1h : 0) + (rovn24h != null ? w24h : 0);
+            if (sumW <= 0) continue;
+            double sumWS = (rovn1h != null ? rovn1h * w1h : 0) + (rovn24h != null ? rovn24h * w24h : 0);
+            try {
+                result.put(Long.parseLong(vid), sumWS / sumW);
+            } catch (NumberFormatException ignore) { }
+        }
+        return result;
+    }
+
+    /**
+     * 与 FeatureV6.oneTypeStatFeature 同口径：rovn = plusSmooth(return_n_uv, exp, plus, 1)
+     *
+     * 字段语义（区分 0 vs null）：
+     *   - exp 是 period 有效性 anchor：null 或 ≤0 → 整个 period 无效（return null）
+     *   - return_n_uv 缺失视为 0（真实信号"无回访"）：rovn=0，参与加权（不会让另一时段兜底）
+     */
+    private static Double computeRovn(Map<String, String> row, String period, double smoothPlus) {
+        Double exp = parseDoubleOrNull(row.get("exp_" + period));
+        if (exp == null || exp <= 0) return null;
+        Double returnNuv = parseDoubleOrNull(row.get("return_n_uv_" + period));
+        return FeatureUtils.plusSmooth(returnNuv != null ? returnNuv : 0, exp, smoothPlus, 1);
+    }
+
+    private static Double parseDoubleOrNull(String s) {
+        if (StringUtils.isBlank(s)) return null;
+        try { return Double.parseDouble(s); } catch (NumberFormatException e) { return null; }
+    }
+
     private UserShareReturnProfile parseUserProfile(Map<String, Map<String, String>> userOriginInfo) {
         if (null != userOriginInfo) {
             Map<String, String> c9 = userOriginInfo.get("alg_recsys_feature_user_share_return_stat");

recommend-server-service/src/main/java/com/tzld/piaoquan/recommend/server/service/rank/strategy/RankStrategy4RegionMergeModelV569.java

@@ -40,10 +40,10 @@ public class RankStrategy4RegionMergeModelV569 extends RankStrategy4RegionMergeM
     private FeatureService featureService;
 
     /**
-     * V569 个性化召回白名单 (6 路)：召回 key 含 mid/uid，依赖该用户行为信号。
+     * V569 个性化召回白名单 (7 路: V566 基础 6 路 + 1 路 dk_elements 画像路实验)：召回 key 含 mid/uid，
+     * 依赖该用户行为信号。
+     * V569 实验路径: UserProfileDkElements (用户元素画像 s_z_y_s/zt_gyf)
      * 注：YearReturnCate2 因线上效果不佳, 2026-06-04 起移到非个性化白名单。
-     * 注：V569 相对 V562 的实验差异点 = dk_elements 召回换用 click (回流) 触发版
-     *     (YearReturnDkElementsRecallStrategy) 并移到非个性化白名单。
      */
     private static final Set<String> PERSONAL_RECALL_PUSH_FROMS = new HashSet<>(Arrays.asList(
             UserCate1RecallStrategy.PUSH_FORM,
@@ -51,12 +51,13 @@ public class RankStrategy4RegionMergeModelV569 extends RankStrategy4RegionMergeM
             Return1Cate2RosRecallStrategy.PUSH_FORM,
             Return1Cate2StrRecallStrategy.PUSH_FORM,
             YearShareCate1RecallStrategy.PUSH_FROM,
-            YearShareCate2RecallStrategy.PUSH_FROM
+            YearShareCate2RecallStrategy.PUSH_FROM,
+            UserProfileDkElementsXFRecallStrategy.PUSH_FROM
     ));
 
     /**
-     * V569 非个性化召回白名单 (18 路)：只依赖 headVid + 地域/品类/相似度（vid-vid CF 也归此类）。
-     * 含 5 路旧地域、新地域、城市、head province/cate、先验省份、return 相似、scene CF、YearReturnCate2、YearReturnDkElements。
+     * V569 非个性化召回白名单 (17 路)：只依赖 headVid + 地域/品类/相似度（vid-vid CF 也归此类）。
+     * 含 5 路旧地域、新地域、城市、head province/cate、先验省份、return 相似、scene CF、YearReturnCate2。
      */
     private static final Set<String> NON_PERSONAL_RECALL_PUSH_FROMS = new HashSet<>(Arrays.asList(
             RegionHRecallStrategy.PUSH_FORM,
@@ -75,8 +76,7 @@ public class RankStrategy4RegionMergeModelV569 extends RankStrategy4RegionMergeM
             ReturnVideoRecallStrategy.PUSH_FORM,
             SceneCFRovnRecallStrategy.PUSH_FORM,
             SceneCFRosnRecallStrategy.PUSH_FORM,
-            YearReturnCate2RecallStrategy.PUSH_FROM,
-            YearReturnDkElementsRecallStrategy.PUSH_FROM
+            YearReturnCate2RecallStrategy.PUSH_FROM
     ));
 
     /** PERSONAL ∪ NON_PERSONAL = 23 路。用于 fetchCoarseRankScores 跳过流量池等不参与截断的 vid。 */

recommend-server-service/src/main/java/com/tzld/piaoquan/recommend/server/service/recall/RecallService.java

@@ -186,6 +186,12 @@ public class RecallService implements ApplicationContextAware {
             // }
         }
 
+        boolean isHit568Exp = experimentService.judgeHitAlgoExp(param.getAppType(), param.getRootSessionId(), abExpCodes, "568");
+        if (isHit568Exp) {
+            strategies.add(strategyMap.get(UserCate1RecallStrategyV568.class.getSimpleName()));
+            strategies.add(strategyMap.get(UserCate2RecallStrategyV568.class.getSimpleName()));
+        }
+
         boolean isHit842Exp = experimentService.judgeHitAlgoExp(param.getAppType(), param.getRootSessionId(), abExpCodes, "842");
         if (isHit842Exp) {
             strategies.add(strategyMap.get(UserDeconstructionKeywordsRecallStrategy.class.getSimpleName()));
@@ -202,10 +208,9 @@ public class RecallService implements ApplicationContextAware {
         //                                    形成"分享 vs 有效播放"双行为 dk_elements 召回 AB 对照.
         //   V565 → UserProfileDkElements:  用户元素画像 (s_z_y_s/zt_gyf)         -> elements_rovn_recall 倒排
         //   V569 → YearReturnDkElements:   用户近期 click 回流行为 join dk_elements -> elements_rovn_recall 倒排
-        boolean isHit562Exp = experimentService.judgeHitAlgoExp(param.getAppType(), param.getRootSessionId(), abExpCodes, "562");
         boolean isHit536Exp = experimentService.judgeHitAlgoExp(param.getAppType(), param.getRootSessionId(), abExpCodes, "536");
         boolean isHit839Exp = experimentService.judgeHitAlgoExp(param.getAppType(), param.getRootSessionId(), abExpCodes, "839");
-        if (isHit562Exp || isHit536Exp) {
+        if (isHit536Exp) {
             strategies.add(strategyMap.get(YearShareDkElementsRecallStrategy.class.getSimpleName()));
         }
         if (isHit839Exp) {
@@ -215,9 +220,13 @@ public class RecallService implements ApplicationContextAware {
         if (isHit565Exp) {
             strategies.add(strategyMap.get(UserProfileDkElementsRecallStrategy.class.getSimpleName()));
         }
+        boolean isHit562Exp = experimentService.judgeHitAlgoExp(param.getAppType(), param.getRootSessionId(), abExpCodes, "562");
+        if (isHit562Exp) {
+            strategies.add(strategyMap.get(UserProfileDkElementsFXRecallStrategy.class.getSimpleName()));
+        }
         boolean isHit569Exp = experimentService.judgeHitAlgoExp(param.getAppType(), param.getRootSessionId(), abExpCodes, "569");
         if (isHit569Exp) {
-            strategies.add(strategyMap.get(YearReturnDkElementsRecallStrategy.class.getSimpleName()));
+            strategies.add(strategyMap.get(UserProfileDkElementsXFRecallStrategy.class.getSimpleName()));
         }
 
         // V564 实验：召回侧不做任何剔除/新增——让所有公共池召回都跑，

recommend-server-service/src/main/java/com/tzld/piaoquan/recommend/server/service/recall/strategy/UserCate1RecallStrategyV568.java

@@ -0,0 +1,148 @@
+package com.tzld.piaoquan.recommend.server.service.recall.strategy;
+
+import com.tzld.piaoquan.recommend.server.model.Video;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterParam;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterResult;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterService;
+import com.tzld.piaoquan.recommend.server.service.rank.bo.UserShareReturnProfile;
+import com.tzld.piaoquan.recommend.server.service.rank.bo.VideoAttrSRBO;
+import com.tzld.piaoquan.recommend.server.service.recall.FilterParamFactory;
+import com.tzld.piaoquan.recommend.server.service.recall.RecallParam;
+import com.tzld.piaoquan.recommend.server.service.recall.RecallStrategy;
+import com.tzld.piaoquan.recommend.server.util.FeatureUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.math3.util.Pair;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * V568 实验专属：UserCate1RecallStrategy 的 topN=100 变体。
+ * 与原版共用同一 Redis key 前缀，仅拉取更多 cate 达到扩大召回量的效果。
+ * 使用独立 PUSH_FORM 避免污染其他实验组。
+ */
+@Component
+@Slf4j
+public class UserCate1RecallStrategyV568 implements RecallStrategy {
+    private final String CLASS_NAME = this.getClass().getSimpleName();
+    @Autowired
+    private FilterService filterService;
+    @Autowired
+    @Qualifier("redisTemplate")
+    public RedisTemplate<String, String> redisTemplate;
+
+    public static final int topN = 100;
+    public static final String PUSH_FORM = "recall_strategy_user_cate1_v568";
+    public static final String redisKeyPrefix = "merge_cate_recall:cate1";
+
+    @Override
+    public String pushFrom() {
+        return PUSH_FORM;
+    }
+
+    @Override
+    public List<Video> recall(RecallParam param) {
+        List<Video> videosResult = new ArrayList<>();
+        try {
+            UserShareReturnProfile userProfile = param.getUserProfile();
+            if (null != userProfile && null != userProfile.getC1_s()) {
+                List<String> keys = getRedisKey(userProfile.getC1_s());
+                if (!keys.isEmpty()) {
+                    List<String> values = redisTemplate.opsForValue().multiGet(keys);
+                    List<Long> ids = recall(param.getVideoId(), values);
+                    Map<Long, Double> scoresMap = FilterParamFactory.positionScores(ids);
+                    FilterParam filterParam = FilterParamFactory.create(param, ids, pushFrom(), scoresMap);
+                    FilterResult filterResult = filterService.filter(filterParam);
+                    if (filterResult != null && CollectionUtils.isNotEmpty(filterResult.getVideoIds())) {
+                        for (Long vid : filterResult.getVideoIds()) {
+                            Video video = new Video();
+                            video.setVideoId(vid);
+                            video.setRovScore(scoresMap.getOrDefault(vid, 0.0));
+                            video.setPushFrom(pushFrom());
+                            videosResult.add(video);
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            log.error("recall is wrong in {}, error={}", CLASS_NAME, e);
+        }
+        return videosResult;
+    }
+
+    private List<Long> recall(Long headVid, List<String> values) {
+        List<Long> vidList = new ArrayList<>();
+        if (null != values && !values.isEmpty()) {
+            Set<Long> hits = new HashSet<>();
+            hits.add(headVid);
+            List<Pair<Long, Double>> list = new ArrayList<>();
+            for (String value : values) {
+                if (null != value && !value.isEmpty()) {
+                    String[] cells = value.split("\t");
+                    if (2 == cells.length) {
+                        List<Long> ids = Arrays.stream(cells[0].split(",")).map(Long::valueOf).collect(Collectors.toList());
+                        List<Double> scores = Arrays.stream(cells[1].split(",")).map(Double::valueOf).collect(Collectors.toList());
+                        if (!ids.isEmpty() && ids.size() == scores.size()) {
+                            for (int i = 0; i < ids.size(); ++i) {
+                                long id = ids.get(i);
+                                double score = scores.get(i);
+                                if (hits.contains(id)) {
+                                    continue;
+                                }
+                                hits.add(id);
+                                list.add(Pair.create(id, score));
+                            }
+                        }
+                    }
+                }
+            }
+            if (!list.isEmpty()) {
+                list.sort(Comparator.comparingDouble(o -> -o.getSecond()));
+                for (Pair<Long, Double> pair : list) {
+                    vidList.add(pair.getFirst());
+                }
+            }
+        }
+        return vidList;
+    }
+
+    private List<String> getRedisKey(Map<String, VideoAttrSRBO> map) {
+        List<String> keys = new ArrayList<>();
+        if (null != map) {
+            List<Pair<String, Double>> cateList = getOrderedList(map);
+            for (Pair<String, Double> pair : cateList) {
+                keys.add(String.format("%s:%s", redisKeyPrefix, pair.getFirst()));
+                if (keys.size() >= topN) {
+                    break;
+                }
+            }
+        }
+        return keys;
+    }
+
+    private List<Pair<String, Double>> getOrderedList(Map<String, VideoAttrSRBO> map) {
+        List<Pair<String, Double>> pairList = new ArrayList<>();
+        if (null != map) {
+            for (Map.Entry<String, VideoAttrSRBO> entry : map.entrySet()) {
+                String name = entry.getKey();
+                VideoAttrSRBO videoAttrSRBO = entry.getValue();
+                if (null != videoAttrSRBO && videoAttrSRBO.getRu() > 0) {
+                    long sharePv = videoAttrSRBO.getSp();
+                    long returnUv = videoAttrSRBO.getRu();
+                    double score = FeatureUtils.plusSmooth(returnUv, sharePv, 5);
+                    Pair<String, Double> pair = Pair.create(name, score);
+                    pairList.add(pair);
+                }
+            }
+            if (pairList.size() > 1) {
+                pairList.sort(Comparator.comparingDouble(o -> -o.getSecond()));
+            }
+        }
+        return pairList;
+    }
+}

recommend-server-service/src/main/java/com/tzld/piaoquan/recommend/server/service/recall/strategy/UserCate2RecallStrategyV568.java

@@ -0,0 +1,148 @@
+package com.tzld.piaoquan.recommend.server.service.recall.strategy;
+
+import com.tzld.piaoquan.recommend.server.model.Video;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterParam;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterResult;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterService;
+import com.tzld.piaoquan.recommend.server.service.rank.bo.UserShareReturnProfile;
+import com.tzld.piaoquan.recommend.server.service.rank.bo.VideoAttrSRBO;
+import com.tzld.piaoquan.recommend.server.service.recall.FilterParamFactory;
+import com.tzld.piaoquan.recommend.server.service.recall.RecallParam;
+import com.tzld.piaoquan.recommend.server.service.recall.RecallStrategy;
+import com.tzld.piaoquan.recommend.server.util.FeatureUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.math3.util.Pair;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * V568 实验专属：UserCate2RecallStrategy 的 topN=100 变体。
+ * 与原版共用同一 Redis key 前缀，仅拉取更多 cate 达到扩大召回量的效果。
+ * 使用独立 PUSH_FORM 避免污染其他实验组。
+ */
+@Component
+@Slf4j
+public class UserCate2RecallStrategyV568 implements RecallStrategy {
+    private final String CLASS_NAME = this.getClass().getSimpleName();
+    @Autowired
+    private FilterService filterService;
+    @Autowired
+    @Qualifier("redisTemplate")
+    public RedisTemplate<String, String> redisTemplate;
+
+    public static final int topN = 100;
+    public static final String PUSH_FORM = "recall_strategy_user_cate2_v568";
+    public static final String redisKeyPrefix = "merge_cate_recall:cate2";
+
+    @Override
+    public String pushFrom() {
+        return PUSH_FORM;
+    }
+
+    @Override
+    public List<Video> recall(RecallParam param) {
+        List<Video> videosResult = new ArrayList<>();
+        try {
+            UserShareReturnProfile userProfile = param.getUserProfile();
+            if (null != userProfile && null != userProfile.getC2_s()) {
+                List<String> keys = getRedisKey(userProfile.getC2_s());
+                if (!keys.isEmpty()) {
+                    List<String> values = redisTemplate.opsForValue().multiGet(keys);
+                    List<Long> ids = recall(param.getVideoId(), values);
+                    Map<Long, Double> scoresMap = FilterParamFactory.positionScores(ids);
+                    FilterParam filterParam = FilterParamFactory.create(param, ids, pushFrom(), scoresMap);
+                    FilterResult filterResult = filterService.filter(filterParam);
+                    if (filterResult != null && CollectionUtils.isNotEmpty(filterResult.getVideoIds())) {
+                        for (Long vid : filterResult.getVideoIds()) {
+                            Video video = new Video();
+                            video.setVideoId(vid);
+                            video.setRovScore(scoresMap.getOrDefault(vid, 0.0));
+                            video.setPushFrom(pushFrom());
+                            videosResult.add(video);
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+            log.error("recall is wrong in {}, error={}", CLASS_NAME, e);
+        }
+        return videosResult;
+    }
+
+    private List<Long> recall(Long headVid, List<String> values) {
+        List<Long> vidList = new ArrayList<>();
+        if (null != values && !values.isEmpty()) {
+            Set<Long> hits = new HashSet<>();
+            hits.add(headVid);
+            List<Pair<Long, Double>> list = new ArrayList<>();
+            for (String value : values) {
+                if (null != value && !value.isEmpty()) {
+                    String[] cells = value.split("\t");
+                    if (2 == cells.length) {
+                        List<Long> ids = Arrays.stream(cells[0].split(",")).map(Long::valueOf).collect(Collectors.toList());
+                        List<Double> scores = Arrays.stream(cells[1].split(",")).map(Double::valueOf).collect(Collectors.toList());
+                        if (!ids.isEmpty() && ids.size() == scores.size()) {
+                            for (int i = 0; i < ids.size(); ++i) {
+                                long id = ids.get(i);
+                                double score = scores.get(i);
+                                if (hits.contains(id)) {
+                                    continue;
+                                }
+                                hits.add(id);
+                                list.add(Pair.create(id, score));
+                            }
+                        }
+                    }
+                }
+            }
+            if (!list.isEmpty()) {
+                list.sort(Comparator.comparingDouble(o -> -o.getSecond()));
+                for (Pair<Long, Double> pair : list) {
+                    vidList.add(pair.getFirst());
+                }
+            }
+        }
+        return vidList;
+    }
+
+    private List<String> getRedisKey(Map<String, VideoAttrSRBO> map) {
+        List<String> keys = new ArrayList<>();
+        if (null != map) {
+            List<Pair<String, Double>> cateList = getOrderedList(map);
+            for (Pair<String, Double> pair : cateList) {
+                keys.add(String.format("%s:%s", redisKeyPrefix, pair.getFirst()));
+                if (keys.size() >= topN) {
+                    break;
+                }
+            }
+        }
+        return keys;
+    }
+
+    private List<Pair<String, Double>> getOrderedList(Map<String, VideoAttrSRBO> map) {
+        List<Pair<String, Double>> pairList = new ArrayList<>();
+        if (null != map) {
+            for (Map.Entry<String, VideoAttrSRBO> entry : map.entrySet()) {
+                String name = entry.getKey();
+                VideoAttrSRBO videoAttrSRBO = entry.getValue();
+                if (null != videoAttrSRBO && videoAttrSRBO.getRu() > 0) {
+                    long sharePv = videoAttrSRBO.getSp();
+                    long returnUv = videoAttrSRBO.getRu();
+                    double score = FeatureUtils.plusSmooth(returnUv, sharePv, 5);
+                    Pair<String, Double> pair = Pair.create(name, score);
+                    pairList.add(pair);
+                }
+            }
+            if (pairList.size() > 1) {
+                pairList.sort(Comparator.comparingDouble(o -> -o.getSecond()));
+            }
+        }
+        return pairList;
+    }
+}

recommend-server-service/src/main/java/com/tzld/piaoquan/recommend/server/service/recall/strategy/UserProfileDkElementsFXRecallStrategy.java

@@ -0,0 +1,181 @@
+package com.tzld.piaoquan.recommend.server.service.recall.strategy;
+
+import com.tzld.piaoquan.recommend.server.model.Video;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterParam;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterResult;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterService;
+import com.tzld.piaoquan.recommend.server.service.recall.FilterParamFactory;
+import com.tzld.piaoquan.recommend.server.service.recall.RecallParam;
+import com.tzld.piaoquan.recommend.server.service.recall.RecallStrategy;
+import com.tzld.piaoquan.recommend.server.util.FeatureUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.math.NumberUtils;
+import org.apache.commons.lang3.tuple.Pair;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 用户画像 实质元素 rovn 召回
+ *   数据源: param.userNetworkSeqFeature 里的 s_z_y_s (元素列表) + zt_gyf (归一分列表)
+ *           上游 alg_user_network_seq_feature 已新增, 来自 user_element_profile_hot
+ *           top_elements = UNION ALL(positive_ranked, negative_ranked), 所以归一分可能为负
+ *
+ *   逻辑: (element, score) pair 按 score DESC 取前 topN=30 正向元素 -> 一次 multiGet
+ *         elements_rovn_recall:{kw} 倒排 -> 同 vid 取 max score -> 排序 -> filter
+ *   只取正向 (score > 0), 避免召回用户厌恶元素
+ *
+ *   跟 YearShareDkElementsRecallStrategy 共用 Redis 倒排 key, 仅用户兴趣源 + 取法不同
+ */
+@Slf4j
+@Component
+public class UserProfileDkElementsFXRecallStrategy implements RecallStrategy {
+
+    @Autowired
+    @Qualifier("redisTemplate")
+    private RedisTemplate<String, String> redisTemplate;
+
+    @Autowired
+    private FilterService filterService;
+
+    private final String CLASS_NAME = this.getClass().getSimpleName();
+
+    public static final int topN = 30;
+    public static final String PUSH_FROM = "recall_user_profile_dk_elements_fx";
+    public static final String redisKeyPrefix = "elements_rovn_recall";
+
+    public static final String KEY_ELEMENTS = "s_z_y_s_fx";
+    public static final String KEY_SCORES = "fx_gyf";
+
+    @Override
+    public String pushFrom() {
+        return PUSH_FROM;
+    }
+
+    @Override
+    public List<Video> recall(RecallParam param) {
+        List<Video> videosResult = new ArrayList<>();
+        try {
+            if (MapUtils.isEmpty(param.getUserNetworkSeqFeature())) {
+                return videosResult;
+            }
+
+            List<String> elements = FeatureUtils.extractVidsFromUserNetworkSeqFeature(param.getUserNetworkSeqFeature(), KEY_ELEMENTS);
+            List<String> scores = FeatureUtils.extractVidsFromUserNetworkSeqFeature(param.getUserNetworkSeqFeature(), KEY_SCORES);
+            if (CollectionUtils.isEmpty(elements) || elements.size() != scores.size()) {
+                return videosResult;
+            }
+
+            List<String> topElements = pickTopPositiveElements(elements, scores);
+            if (CollectionUtils.isEmpty(topElements)) {
+                return videosResult;
+            }
+
+            List<String> keys = getRedisKey(topElements);
+            List<String> values = redisTemplate.opsForValue().multiGet(keys);
+
+            // 保留 Redis 倒排的真实 rovn 分 (而非位置分): scoresMap 的 score 会写到 Video.rovScore,
+            // 粗排截断 coarseMap miss 的 vid 会 fallback 用 Video.rovScore 排序, 真实分更有信号.
+            Map<Long, Double> scoresMap = recall(param.getVideoId(), values);
+            List<Long> ids = scoresMap.entrySet().stream()
+                    .sorted(Comparator.comparingDouble((Map.Entry<Long, Double> e) -> e.getValue()).reversed())
+                    .map(Map.Entry::getKey)
+                    .collect(Collectors.toList());
+
+            FilterParam filterParam = FilterParamFactory.create(param, ids, pushFrom(), scoresMap);
+            FilterResult filterResult = filterService.filter(filterParam);
+            if (filterResult != null && CollectionUtils.isNotEmpty(filterResult.getVideoIds())) {
+                for (Long vid : filterResult.getVideoIds()) {
+                    Video video = new Video();
+                    video.setVideoId(vid);
+                    video.setRovScore(scoresMap.getOrDefault(vid, 0.0));
+                    video.setPushFrom(pushFrom());
+                    videosResult.add(video);
+                }
+            }
+        } catch (Exception e) {
+            log.error("recall is wrong in {}, error={}", CLASS_NAME, e);
+        }
+        return videosResult;
+    }
+
+    /** 组对 + 过滤负向 + 按归一分降序 + 取前 topN 个 element */
+    private List<String> pickTopPositiveElements(List<String> elements, List<String> scores) {
+        List<Pair<String, Double>> pairs = new ArrayList<>();
+        for (int i = 0; i < elements.size(); i++) {
+            String element = elements.get(i);
+            if (StringUtils.isBlank(element)) {
+                continue;
+            }
+            double score = NumberUtils.toDouble(scores.get(i), 0.0);
+            if (score <= 0) {
+                continue;
+            }
+            pairs.add(Pair.of(element, score));
+        }
+        if (pairs.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return pairs.stream()
+                .sorted(Comparator.comparingDouble((Pair<String, Double> p) -> p.getValue()).reversed())
+                .map(Pair::getKey)
+                .distinct()
+                .limit(topN)
+                .collect(Collectors.toList());
+    }
+
+    private List<String> getRedisKey(List<String> elementList) {
+        List<String> keys = new ArrayList<>();
+        for (String element : elementList) {
+            keys.add(String.format("%s:%s", redisKeyPrefix, element));
+        }
+        return keys;
+    }
+
+    /**
+     * 解析 multiGet 拿到的 N 个 Redis value, 拼成 vid -> 真实 score map.
+     * value 格式: vid1,vid2,...\tscore1,score2,...  (rovn 真实分)
+     * 同 vid 在多个 element 倒排里出现时, 取 max score (跟 AbstractRedisRecallStrategy 一致).
+     */
+    private Map<Long, Double> recall(Long headVid, List<String> values) {
+        Map<Long, Double> scoresMap = new HashMap<>();
+        if (CollectionUtils.isEmpty(values)) {
+            return scoresMap;
+        }
+        for (String value : values) {
+            if (StringUtils.isBlank(value)) {
+                continue;
+            }
+            String[] cells = value.split("\t");
+            if (cells.length != 2) {
+                continue;
+            }
+            List<Long> ids;
+            List<Double> scores;
+            try {
+                ids = Arrays.stream(cells[0].split(",")).map(Long::valueOf).collect(Collectors.toList());
+                scores = Arrays.stream(cells[1].split(",")).map(Double::valueOf).collect(Collectors.toList());
+            } catch (NumberFormatException nfe) {
+                continue;
+            }
+            if (ids.isEmpty() || ids.size() != scores.size()) {
+                continue;
+            }
+            for (int i = 0; i < ids.size(); i++) {
+                long id = ids.get(i);
+                if (headVid != null && headVid == id) {
+                    continue;
+                }
+                scoresMap.merge(id, scores.get(i), Math::max);
+            }
+        }
+        return scoresMap;
+    }
+}

recommend-server-service/src/main/java/com/tzld/piaoquan/recommend/server/service/recall/strategy/UserProfileDkElementsXFRecallStrategy.java

@@ -0,0 +1,181 @@
+package com.tzld.piaoquan.recommend.server.service.recall.strategy;
+
+import com.tzld.piaoquan.recommend.server.model.Video;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterParam;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterResult;
+import com.tzld.piaoquan.recommend.server.service.filter.FilterService;
+import com.tzld.piaoquan.recommend.server.service.recall.FilterParamFactory;
+import com.tzld.piaoquan.recommend.server.service.recall.RecallParam;
+import com.tzld.piaoquan.recommend.server.service.recall.RecallStrategy;
+import com.tzld.piaoquan.recommend.server.util.FeatureUtils;
+import lombok.extern.slf4j.Slf4j;
+import org.apache.commons.collections4.CollectionUtils;
+import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.lang3.StringUtils;
+import org.apache.commons.lang3.math.NumberUtils;
+import org.apache.commons.lang3.tuple.Pair;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * 用户画像 实质元素 rovn 召回
+ *   数据源: param.userNetworkSeqFeature 里的 s_z_y_s (元素列表) + zt_gyf (归一分列表)
+ *           上游 alg_user_network_seq_feature 已新增, 来自 user_element_profile_hot
+ *           top_elements = UNION ALL(positive_ranked, negative_ranked), 所以归一分可能为负
+ *
+ *   逻辑: (element, score) pair 按 score DESC 取前 topN=30 正向元素 -> 一次 multiGet
+ *         elements_rovn_recall:{kw} 倒排 -> 同 vid 取 max score -> 排序 -> filter
+ *   只取正向 (score > 0), 避免召回用户厌恶元素
+ *
+ *   跟 YearShareDkElementsRecallStrategy 共用 Redis 倒排 key, 仅用户兴趣源 + 取法不同
+ */
+@Slf4j
+@Component
+public class UserProfileDkElementsXFRecallStrategy implements RecallStrategy {
+
+    @Autowired
+    @Qualifier("redisTemplate")
+    private RedisTemplate<String, String> redisTemplate;
+
+    @Autowired
+    private FilterService filterService;
+
+    private final String CLASS_NAME = this.getClass().getSimpleName();
+
+    public static final int topN = 30;
+    public static final String PUSH_FROM = "recall_user_profile_dk_elements_xf";
+    public static final String redisKeyPrefix = "elements_rovn_recall";
+
+    public static final String KEY_ELEMENTS = "s_z_y_s_xf";
+    public static final String KEY_SCORES = "xf_gyf";
+
+    @Override
+    public String pushFrom() {
+        return PUSH_FROM;
+    }
+
+    @Override
+    public List<Video> recall(RecallParam param) {
+        List<Video> videosResult = new ArrayList<>();
+        try {
+            if (MapUtils.isEmpty(param.getUserNetworkSeqFeature())) {
+                return videosResult;
+            }
+
+            List<String> elements = FeatureUtils.extractVidsFromUserNetworkSeqFeature(param.getUserNetworkSeqFeature(), KEY_ELEMENTS);
+            List<String> scores = FeatureUtils.extractVidsFromUserNetworkSeqFeature(param.getUserNetworkSeqFeature(), KEY_SCORES);
+            if (CollectionUtils.isEmpty(elements) || elements.size() != scores.size()) {
+                return videosResult;
+            }
+
+            List<String> topElements = pickTopPositiveElements(elements, scores);
+            if (CollectionUtils.isEmpty(topElements)) {
+                return videosResult;
+            }
+
+            List<String> keys = getRedisKey(topElements);
+            List<String> values = redisTemplate.opsForValue().multiGet(keys);
+
+            // 保留 Redis 倒排的真实 rovn 分 (而非位置分): scoresMap 的 score 会写到 Video.rovScore,
+            // 粗排截断 coarseMap miss 的 vid 会 fallback 用 Video.rovScore 排序, 真实分更有信号.
+            Map<Long, Double> scoresMap = recall(param.getVideoId(), values);
+            List<Long> ids = scoresMap.entrySet().stream()
+                    .sorted(Comparator.comparingDouble((Map.Entry<Long, Double> e) -> e.getValue()).reversed())
+                    .map(Map.Entry::getKey)
+                    .collect(Collectors.toList());
+
+            FilterParam filterParam = FilterParamFactory.create(param, ids, pushFrom(), scoresMap);
+            FilterResult filterResult = filterService.filter(filterParam);
+            if (filterResult != null && CollectionUtils.isNotEmpty(filterResult.getVideoIds())) {
+                for (Long vid : filterResult.getVideoIds()) {
+                    Video video = new Video();
+                    video.setVideoId(vid);
+                    video.setRovScore(scoresMap.getOrDefault(vid, 0.0));
+                    video.setPushFrom(pushFrom());
+                    videosResult.add(video);
+                }
+            }
+        } catch (Exception e) {
+            log.error("recall is wrong in {}, error={}", CLASS_NAME, e);
+        }
+        return videosResult;
+    }
+
+    /** 组对 + 过滤负向 + 按归一分降序 + 取前 topN 个 element */
+    private List<String> pickTopPositiveElements(List<String> elements, List<String> scores) {
+        List<Pair<String, Double>> pairs = new ArrayList<>();
+        for (int i = 0; i < elements.size(); i++) {
+            String element = elements.get(i);
+            if (StringUtils.isBlank(element)) {
+                continue;
+            }
+            double score = NumberUtils.toDouble(scores.get(i), 0.0);
+            if (score <= 0) {
+                continue;
+            }
+            pairs.add(Pair.of(element, score));
+        }
+        if (pairs.isEmpty()) {
+            return Collections.emptyList();
+        }
+        return pairs.stream()
+                .sorted(Comparator.comparingDouble((Pair<String, Double> p) -> p.getValue()).reversed())
+                .map(Pair::getKey)
+                .distinct()
+                .limit(topN)
+                .collect(Collectors.toList());
+    }
+
+    private List<String> getRedisKey(List<String> elementList) {
+        List<String> keys = new ArrayList<>();
+        for (String element : elementList) {
+            keys.add(String.format("%s:%s", redisKeyPrefix, element));
+        }
+        return keys;
+    }
+
+    /**
+     * 解析 multiGet 拿到的 N 个 Redis value, 拼成 vid -> 真实 score map.
+     * value 格式: vid1,vid2,...\tscore1,score2,...  (rovn 真实分)
+     * 同 vid 在多个 element 倒排里出现时, 取 max score (跟 AbstractRedisRecallStrategy 一致).
+     */
+    private Map<Long, Double> recall(Long headVid, List<String> values) {
+        Map<Long, Double> scoresMap = new HashMap<>();
+        if (CollectionUtils.isEmpty(values)) {
+            return scoresMap;
+        }
+        for (String value : values) {
+            if (StringUtils.isBlank(value)) {
+                continue;
+            }
+            String[] cells = value.split("\t");
+            if (cells.length != 2) {
+                continue;
+            }
+            List<Long> ids;
+            List<Double> scores;
+            try {
+                ids = Arrays.stream(cells[0].split(",")).map(Long::valueOf).collect(Collectors.toList());
+                scores = Arrays.stream(cells[1].split(",")).map(Double::valueOf).collect(Collectors.toList());
+            } catch (NumberFormatException nfe) {
+                continue;
+            }
+            if (ids.isEmpty() || ids.size() != scores.size()) {
+                continue;
+            }
+            for (int i = 0; i < ids.size(); i++) {
+                long id = ids.get(i);
+                if (headVid != null && headVid == id) {
+                    continue;
+                }
+                scoresMap.merge(id, scores.get(i), Math::max);
+            }
+        }
+        return scoresMap;
+    }
+}