recommend-server-service/src/main/java/com/tzld/piaoquan/recommend/server/model/Video.java

@@ -2,10 +2,7 @@ package com.tzld.piaoquan.recommend.server.model;
 
 import lombok.Data;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 
 /**
  * @author dyp
@@ -29,6 +26,9 @@ public class Video {
     // video的特征 tag
     private List<String> tags = new ArrayList<>();
 
+    // 视频的品类
+    private Set<String> mergeCateList = new HashSet<>();
+
     // video的模型打分
     public double scoreRos = 0.0D;
     public double scoreStr = 0.0D;

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

@@ -9,11 +9,7 @@ import com.tzld.piaoquan.recommend.server.service.rank.RankResult;
 import com.tzld.piaoquan.recommend.server.service.rank.RankService;
 import com.tzld.piaoquan.recommend.server.service.rank.extractor.ExtractorUtils;
 import com.tzld.piaoquan.recommend.server.service.rank.extractor.RankExtractorItemTags;
-import com.tzld.piaoquan.recommend.server.service.rank.processor.RankProcessorBoost;
-import com.tzld.piaoquan.recommend.server.service.rank.processor.RankProcessorDensity;
-import com.tzld.piaoquan.recommend.server.service.rank.processor.RankProcessorInsert;
-import com.tzld.piaoquan.recommend.server.service.rank.processor.RankProcessorTagFilter;
-import com.tzld.piaoquan.recommend.server.util.CommonCollectionUtils;
+import com.tzld.piaoquan.recommend.server.service.rank.processor.*;
 import com.tzld.piaoquan.recommend.server.util.JSONUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
@@ -315,9 +311,6 @@ public abstract class RankStrategy4RegionMergeModelBasic extends RankService {
     }
 
     protected double handleVor(double originVor, double calcVorMode, RankItem item, Map<String, Double> mergeWeight) {
-        if (originVor == 0) {
-            return 0;
-        }
         double vor = originVor;
         if (calcVorMode == 1d) {
             vor = ExtractorUtils.calLog(originVor);
@@ -329,6 +322,8 @@ public abstract class RankStrategy4RegionMergeModelBasic extends RankService {
             double vorPower = mergeWeight.getOrDefault("vor_power", 0d);
             item.getScoresMap().put("vorPower", vorPower);
             vor = Math.pow(originVor, vorPower);
+        }else if (calcVorMode == 4d){
+            vor = 1.0;
         }
 
         return vor;

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

@@ -10,13 +10,15 @@ import com.tzld.piaoquan.recommend.server.service.rank.extractor.ExtractorUtils;
 import com.tzld.piaoquan.recommend.server.service.recall.strategy.*;
 import com.tzld.piaoquan.recommend.server.service.score.ScorerUtils;
 import com.tzld.piaoquan.recommend.server.util.CommonCollectionUtils;
+import com.tzld.piaoquan.recommend.server.util.DateUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.MapUtils;
+import org.apache.commons.lang3.StringUtils;
 import org.apache.commons.math3.util.Pair;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
+import java.time.LocalDateTime;
 import java.util.*;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
@@ -28,12 +30,17 @@ public class RankStrategy4RegionMergeModelV536 extends RankStrategy4RegionMergeM
     @ApolloJsonValue("${rank.score.merge.weightv536:}")
     private Map<String, Double> mergeWeight;
 
+    @ApolloJsonValue("${rank.score.reduce.config.v536:}")
+    private Map<String, List<Map<String, String>>> reduceConfigMap;
+
     @Autowired
     private FeatureService featureService;
 
     @Override
     public List<Video> mergeAndRankRovRecall(RankParam param) {
         Map<String, Double> mergeWeight = this.mergeWeight != null ? this.mergeWeight : new HashMap<>(0);
+        Map<String, List<Map<String, String>>> reduceConfigMap = this.reduceConfigMap != null ? this.reduceConfigMap : new HashMap<>(0);
+
         //-------------------融-------------------
         //-------------------合-------------------
         //-------------------逻-------------------
@@ -66,6 +73,18 @@ public class RankStrategy4RegionMergeModelV536 extends RankStrategy4RegionMergeM
         v1 = v1.subList(0, Math.min(mergeWeight.getOrDefault("v1", 5.0).intValue(), v1.size()));
         rovRecallRank.addAll(v1);
         setVideo.addAll(v1.stream().map(Video::getVideoId).collect(Collectors.toSet()));
+        //-------------------scene cf rovn------------------
+        List<Video> sceneCFRovn = extractAndSort(param, SceneCFRovnRecallStrategy.PUSH_FORM);
+        sceneCFRovn = sceneCFRovn.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
+        sceneCFRovn = sceneCFRovn.subList(0, Math.min(mergeWeight.getOrDefault("sceneCFRovn", 5.0).intValue(), sceneCFRovn.size()));
+        rovRecallRank.addAll(sceneCFRovn);
+        setVideo.addAll(sceneCFRovn.stream().map(Video::getVideoId).collect(Collectors.toSet()));
+        //-------------------scene cf rosn------------------
+        List<Video> sceneCFRosn = extractAndSort(param, SceneCFRosnRecallStrategy.PUSH_FORM);
+        sceneCFRosn = sceneCFRosn.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
+        sceneCFRosn = sceneCFRosn.subList(0, Math.min(mergeWeight.getOrDefault("sceneCFRosn", 5.0).intValue(), sceneCFRosn.size()));
+        rovRecallRank.addAll(sceneCFRosn);
+        setVideo.addAll(sceneCFRosn.stream().map(Video::getVideoId).collect(Collectors.toSet()));
 
         //-------------------排-------------------
         //-------------------序-------------------
@@ -313,16 +332,25 @@ public class RankStrategy4RegionMergeModelV536 extends RankStrategy4RegionMergeM
             item.getScoresMap().put("fmRovOrigin", fmRovOrigin);
             double fmRov = restoreScore(fmRovOrigin);
             item.getScoresMap().put("fmRov", fmRov);
+
             double hasReturnRovScore = Double.parseDouble(vid2MapFeature.getOrDefault(item.getVideoId() + "", new HashMap<>()).getOrDefault("rov", "0"));
             item.getScoresMap().put("hasReturnRovScore", hasReturnRovScore);
+
             double vor = Double.parseDouble(vid2MapFeature.getOrDefault(item.getVideoId() + "", new HashMap<>()).getOrDefault("vor", "0"));
             item.getScoresMap().put("vor", vor);
-            score = fmRov * (0.1 + hasReturnRovScore) * (0.1 + vor);
+
+            String vidStr = String.valueOf(item.getVideo().getVideoId());
+            String mergeCate2 = this.parseMergeCate2(vidStr, featureOriginVideo);
+            double reduceCoefficient = this.parseReduceCoefficient(mergeCate2, reduceConfigMap);
+            item.getScoresMap().put("reduceCoefficient", reduceCoefficient);
+
+            score = fmRov * (0.1 + hasReturnRovScore) * (0.1 + vor) * reduceCoefficient;
             Video video = item.getVideo();
             video.setScore(score);
             video.setSortScore(score);
             video.setScoresMap(item.getScoresMap());
             video.setAllFeatureMap(item.getAllFeatureMap());
+            video.getMergeCateList().add(mergeCate2);
             if (MapUtils.isNotEmpty(feature.getVideoFeature()) && MapUtils.isNotEmpty(feature.getVideoFeature().get(item.getVideoId() + ""))) {
                 video.getMetaFeatureMap().putAll(feature.getVideoFeature().get(item.getVideoId() + ""));
             }
@@ -334,4 +362,82 @@ public class RankStrategy4RegionMergeModelV536 extends RankStrategy4RegionMergeM
         result.sort(Comparator.comparingDouble(o -> -o.getSortScore()));
         return result;
     }
+
+
+    public double parseReduceCoefficient(String mergeCate2, Map<String, List<Map<String, String>>> reduceConfigMap) {
+        if (StringUtils.isBlank(mergeCate2) || MapUtils.isEmpty(reduceConfigMap)) {
+            return 1d;
+        }
+
+        List<Map<String, String>> configMaps = reduceConfigMap.getOrDefault(mergeCate2, new ArrayList<>());
+        for (Map<String, String> configMap : configMaps) {
+            boolean currentHourIsNeedReduce = currentHourIsNeedReduce(configMap);
+            boolean currentDateIsNeedReduce = currentDateIsNeedReduce(configMap);
+            if (currentHourIsNeedReduce || currentDateIsNeedReduce) {
+                return Double.parseDouble(configMap.getOrDefault("reduce_coefficient", "1"));
+            }
+        }
+
+        return 1d;
+    }
+
+
+    /**
+     * 当前小时是否需要降权
+     */
+    private boolean currentHourIsNeedReduce(Map<String, String> configMap) {
+        if (!configMap.containsKey("reduce_hour")) {
+            return false;
+        }
+        try {
+
+            int currentHour = LocalDateTime.now().getHour();
+            String[] reduceHours = configMap.get("reduce_hour").split(",");
+            for (String hourRange : reduceHours) {
+                String[] split = hourRange.split("-");
+                int h1 = Integer.parseInt(split[0]);
+                int h2 = (split.length == 2) ? Integer.parseInt(split[1]) : h1;
+
+                if (currentHour >= h1 && currentHour <= h2) {
+                    return true;
+                }
+            }
+        } catch (Exception e) {
+            log.error("536 error parse reduce hour config error. config content: {}, \n", configMap, e);
+        }
+        return false;
+    }
+
+    /**
+     * 当前时间段是否需要降权
+     */
+    private boolean currentDateIsNeedReduce(Map<String, String> configMap) {
+        if (!configMap.containsKey("reduce_date")) {
+            return false;
+        }
+
+        String[] reduceDates = configMap.get("reduce_date").split(",");
+        for (String s : reduceDates) {
+            if (DateUtils.ifTimeRangeInNow(s)) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+
+    private String parseMergeCate2(String vidStr, Map<String, Map<String, Map<String, String>>> featureMap) {
+        if (!featureMap.containsKey(vidStr)) {
+            return "";
+        }
+
+        Map<String, Map<String, String>> vidFeature = featureMap.get(vidStr);
+        if (!vidFeature.containsKey("alg_vid_feature_basic_info")) {
+            return "";
+        }
+
+        Map<String, String> basicInfoMap = vidFeature.get("alg_vid_feature_basic_info");
+        return basicInfoMap.getOrDefault("merge_second_level_cate", "");
+    }
 }

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

@@ -38,6 +38,7 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
         //-------------------逻-------------------
         //-------------------辑-------------------
 
+        //-------------------老地域召回------------------
         List<Video> oldRovs = new ArrayList<>();
         oldRovs.addAll(extractAndSort(param, RegionHRecallStrategy.PUSH_FORM));
         oldRovs.addAll(extractAndSort(param, RegionHDupRecallStrategy.PUSH_FORM));
@@ -46,36 +47,34 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
         oldRovs.addAll(extractAndSort(param, RegionRelative24HDupRecallStrategy.PUSH_FORM));
         removeDuplicate(oldRovs);
         int sizeReturn = param.getSize();
-        List<Video> v0 = oldRovs.size() <= sizeReturn
-                ? oldRovs
-                : oldRovs.subList(0, sizeReturn);
+        List<Video> v0 = oldRovs.size() <= sizeReturn ? oldRovs : oldRovs.subList(0, sizeReturn);
         Set<Long> setVideo = new HashSet<>();
         this.duplicate(setVideo, v0);
         setVideo.addAll(v0.stream().map(Video::getVideoId).collect(Collectors.toSet()));
-        List<Video> rovRecallRank = new ArrayList<>(v0);
+        List<Video> recallVideos4Rank = new ArrayList<>(v0);
         //-------------------return相似召回------------------
         List<Video> v6 = extractAndSort(param, ReturnVideoRecallStrategy.PUSH_FORM);
         v6 = v6.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
         v6 = v6.subList(0, Math.min(mergeWeight.getOrDefault("v6", 5.0).intValue(), v6.size()));
-        rovRecallRank.addAll(v6);
+        recallVideos4Rank.addAll(v6);
         setVideo.addAll(v6.stream().map(Video::getVideoId).collect(Collectors.toSet()));
         //-------------------新地域召回------------------
         List<Video> v1 = extractAndSort(param, RegionRealtimeRecallStrategyV1.PUSH_FORM);
         v1 = v1.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
         v1 = v1.subList(0, Math.min(mergeWeight.getOrDefault("v1", 5.0).intValue(), v1.size()));
-        rovRecallRank.addAll(v1);
+        recallVideos4Rank.addAll(v1);
         setVideo.addAll(v1.stream().map(Video::getVideoId).collect(Collectors.toSet()));
         //-------------------scene cf rovn------------------
         List<Video> sceneCFRovn = extractAndSort(param, SceneCFRovnRecallStrategy.PUSH_FORM);
         sceneCFRovn = sceneCFRovn.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
         sceneCFRovn = sceneCFRovn.subList(0, Math.min(mergeWeight.getOrDefault("sceneCFRovn", 5.0).intValue(), sceneCFRovn.size()));
-        rovRecallRank.addAll(sceneCFRovn);
+        recallVideos4Rank.addAll(sceneCFRovn);
         setVideo.addAll(sceneCFRovn.stream().map(Video::getVideoId).collect(Collectors.toSet()));
         //-------------------scene cf rosn------------------
         List<Video> sceneCFRosn = extractAndSort(param, SceneCFRosnRecallStrategy.PUSH_FORM);
         sceneCFRosn = sceneCFRosn.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
         sceneCFRosn = sceneCFRosn.subList(0, Math.min(mergeWeight.getOrDefault("sceneCFRosn", 5.0).intValue(), sceneCFRosn.size()));
-        rovRecallRank.addAll(sceneCFRosn);
+        recallVideos4Rank.addAll(sceneCFRosn);
         setVideo.addAll(sceneCFRosn.stream().map(Video::getVideoId).collect(Collectors.toSet()));
 
         //-------------------排-------------------
@@ -84,7 +83,7 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
         //-------------------辑-------------------
 
         // 1 批量获取特征  省份参数要对齐  headvid  要传递过来！
-        List<String> vids = CommonCollectionUtils.toListDistinct(rovRecallRank, v -> String.valueOf(v.getVideoId()));
+        List<String> vids = CommonCollectionUtils.toListDistinct(recallVideos4Rank, v -> String.valueOf(v.getVideoId()));
 
         // k1:视频、k2:表、k3:特征、v:特征值
         String provinceCn = param.getProvince().replaceAll("省$", "");
@@ -97,7 +96,7 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
 
         // 2 特征处理
         Map<String, Double> userFeatureMapDouble = new HashMap<>();
-        String mid = param.getMid();
+        // String mid = param.getMid();
         Map<String, String> c1 = featureOriginUser.getOrDefault("alg_mid_feature_play", new HashMap<>());
         Map<String, String> c2 = featureOriginUser.getOrDefault("alg_mid_feature_share_and_return", new HashMap<>());
         Map<String, String> c3 = featureOriginUser.getOrDefault("alg_mid_feature_play_tags", new HashMap<>());
@@ -170,7 +169,7 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
         }
 
 
-        List<RankItem> rankItems = CommonCollectionUtils.toList(rovRecallRank, RankItem::new);
+        List<RankItem> rankItems = CommonCollectionUtils.toList(recallVideos4Rank, RankItem::new);
         for (RankItem item : rankItems) {
             Map<String, Double> featureMap = new HashMap<>();
             String vid = item.getVideoId() + "";
@@ -317,63 +316,45 @@ public class RankStrategy4RegionMergeModelV562 extends RankStrategy4RegionMergeM
         List<RankItem> items = ScorerUtils.getScorerPipeline("feeds_score_config_20240807.conf").scoring(sceneFeatureMap, userFeatureMap, rankItems);
         // 5 排序公式特征
         Map<String, Map<String, String>> vid2MapFeature = this.getVideoRedisFeature(vids, "redis:vid_hasreturn_vor:");
-
         // Ros增强传播因子
         Map<String, Map<String, String>> rosSpreadDivMap = this.getVideoRedisFeature(vids, "vid_for_spread:");
-
+        double alpha = mergeWeight.getOrDefault("alpha", 0.1);
+        double beta = mergeWeight.getOrDefault("beta", 0.0);
+        double gamma = mergeWeight.getOrDefault("gamma", 0.5);
+        double vorMod =  mergeWeight.getOrDefault("vorMod", 4.0);
         List<Video> result = new ArrayList<>();
-
-        double calcVorMode = mergeWeight.getOrDefault("calcVorMode", 3d);
-        double calcRosMode = mergeWeight.getOrDefault("calcRosMode", 0d);
-        double calcStrMode = mergeWeight.getOrDefault("calcStrMode", 3d);
-
-        double rosAdd = mergeWeight.getOrDefault("ros_add", 0.1d);
-        double ros2Multi = mergeWeight.getOrDefault("ros2_multi", 1d);
-        double vorAdd = mergeWeight.getOrDefault("vor_add", 0d);
-
-        double rosSpreadDivisorIndex = mergeWeight.getOrDefault("rosSpreadDivisorIndex", 4d);
-        String spreadDivisorKey = this.indexCoverKey(rosSpreadDivisorIndex);
-        log.info("562 spreadDivisorKey is: {}", spreadDivisorKey);
-
         for (RankItem item : items) {
-            double score;
             double fmRovOrigin = item.getScoreRov();
             item.getScoresMap().put("fmRovOrigin", fmRovOrigin);
-            double str = restoreScore(fmRovOrigin);
-            item.getScoresMap().put("originStr", str);
-            str = this.handleStr(str, calcStrMode, item, mergeWeight);
-            item.getScoresMap().put("xgbRovNegRate", 0.9d);
-            item.getScoresMap().put("fmRov", str);
-            item.getScoresMap().put("str", str);
-            item.getScoresMap().put("calcStrMode", calcStrMode);
-
-            double originRos = Double.parseDouble(vid2MapFeature.getOrDefault(item.getVideoId() + "", new HashMap<>()).getOrDefault("rov", "0"));
-            double ros = this.handleRos(originRos, calcRosMode, item, mergeWeight);
-            item.getScoresMap().put("hasReturnRovScore", ros);
-            item.getScoresMap().put("ros", ros);
-            item.getScoresMap().put("originRos", originRos);
-            item.getScoresMap().put("calcRosMode", calcRosMode);
-
-            String spreadDivStr = rosSpreadDivMap.getOrDefault(String.valueOf(item.getVideoId()), new HashMap<>()).getOrDefault(spreadDivisorKey, "0");
-            double rosSpreadDiv = Double.parseDouble(spreadDivStr);
-            item.getScoresMap().put("rosSpreadDiv", rosSpreadDiv);
-
-            double originVor = Double.parseDouble(vid2MapFeature.getOrDefault(item.getVideoId() + "", new HashMap<>()).getOrDefault("vor", "0"));
-            double vor = this.handleVor(originVor, calcVorMode, item, mergeWeight);
-            item.getScoresMap().put("originVor", originVor);
+            double fmRov = restoreScore(fmRovOrigin);
+            item.getScoresMap().put("fmRov", fmRov);
+            double strTransfor = fmRov;
+            item.getScoresMap().put("strTransfor", strTransfor);
+            double originRos = Double.parseDouble(vid2MapFeature.getOrDefault(item.getVideoId() + "", new HashMap<>(0)).getOrDefault("rov", "0"));
+            item.getScoresMap().put("hasReturnRovScore", originRos);
+            double rosTransfor = originRos;
+            item.getScoresMap().put("rosTransfor", rosTransfor);
+            double vor = Double.parseDouble(vid2MapFeature.getOrDefault(item.getVideoId() + "", new HashMap<>()).getOrDefault("vor", "0"));
             item.getScoresMap().put("vor", vor);
-            item.getScoresMap().put("calcVorMode", calcVorMode);
+            double vorTransfor = this.handleVor(vor, vorMod, item, mergeWeight);
+            item.getScoresMap().put("vorTransfor", vorTransfor);
+            double spreadRate = Double.parseDouble(rosSpreadDivMap.getOrDefault(String.valueOf(item.getVideoId()), new HashMap<>(0)).getOrDefault("head_video_recommend_fission_rate", "0.01"));
+            item.getScoresMap().put("spreadRate", spreadRate);
+
+            // 最终融合公式计算
+            double scoreRov = strTransfor * (alpha + rosTransfor);
+            double scoreVov = scoreRov * (beta + vorTransfor);
+            double score = scoreVov + gamma * spreadRate;
 
+            item.getScoresMap().put("scoreRov", scoreRov);
+            item.getScoresMap().put("scoreVov", scoreVov);
+            item.getScoresMap().put("score", score);
 
-            item.getScoresMap().put("rosAdd", rosAdd);
-            item.getScoresMap().put("vorAdd", vorAdd);
-            item.getScoresMap().put("ros2Multi", ros2Multi);
-            item.getScoresMap().put("rosSpreadDivisorIndex", rosSpreadDivisorIndex);
-            score = str * (rosAdd + ros + ros2Multi * rosSpreadDiv) * (vorAdd + vor);
+            item.getScoresMap().put("alpha", alpha);
+            item.getScoresMap().put("beta", beta);
+            item.getScoresMap().put("gamma", gamma);
 
             Video video = item.getVideo();
-            video.setScoreStr(str);
-            video.setScoreRos(rosAdd + ros + ros2Multi * rosSpreadDiv);
             video.setScore(score);
             video.setSortScore(score);
             video.setScoresMap(item.getScoresMap());

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

@@ -14,7 +14,6 @@ import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.MapUtils;
 import org.apache.commons.math3.util.Pair;
 import org.springframework.beans.factory.annotation.Autowired;
-import org.springframework.beans.factory.annotation.Value;
 import org.springframework.stereotype.Service;
 
 import java.util.*;

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

@@ -1,26 +1,29 @@
 package com.tzld.piaoquan.recommend.server.service.rank.strategy;
 
+import com.alibaba.fastjson.JSON;
 import com.ctrip.framework.apollo.spring.annotation.ApolloJsonValue;
 import com.tzld.piaoquan.recommend.server.common.ThreadPoolFactory;
 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.rank.RankParam;
-import com.tzld.piaoquan.recommend.server.service.rank.extractor.ExtractorUtils;
+import com.tzld.piaoquan.recommend.server.service.rank.bo.UserSRBO;
+import com.tzld.piaoquan.recommend.server.service.rank.bo.UserShareReturnProfile;
+import com.tzld.piaoquan.recommend.server.service.rank.tansform.FeatureV6;
 import com.tzld.piaoquan.recommend.server.service.recall.strategy.*;
 import com.tzld.piaoquan.recommend.server.service.score.ScorerUtils;
 import com.tzld.piaoquan.recommend.server.util.CommonCollectionUtils;
-import com.tzld.piaoquan.recommend.server.util.FeatureUtils;
+import com.tzld.piaoquan.recommend.server.util.FeatureBucketUtils;
+import com.tzld.piaoquan.recommend.server.util.JSONUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.MapUtils;
-import org.apache.commons.math3.util.Pair;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import java.util.*;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
-import java.util.regex.Matcher;
 import java.util.stream.Collectors;
 
 @Service
@@ -39,9 +42,8 @@ public class RankStrategy4RegionMergeModelV568 extends RankStrategy4RegionMergeM
         //-------------------合-------------------
         //-------------------逻-------------------
         //-------------------辑-------------------
-        Set<Long> setVideo = new HashSet<>();
-        List<Video> rovRecallRank = new ArrayList<>();
 
+        long currentMs = System.currentTimeMillis();
         List<Video> oldRovs = new ArrayList<>();
         oldRovs.addAll(extractAndSort(param, RegionHRecallStrategy.PUSH_FORM));
         oldRovs.addAll(extractAndSort(param, RegionHDupRecallStrategy.PUSH_FORM));
@@ -53,326 +55,284 @@ public class RankStrategy4RegionMergeModelV568 extends RankStrategy4RegionMergeM
         List<Video> v0 = oldRovs.size() <= sizeReturn
                 ? oldRovs
                 : oldRovs.subList(0, sizeReturn);
-        //this.duplicate(setVideo, v0);
-
-        Matcher matcher = FeatureUtils.getChannelMatcher(param.getRootSourceId());
-        if (null != matcher && matcher.find() && FeatureUtils.firstLevel(param.getUserShareDepth())) {
-            //-------------------return相似召回------------------
-            List<Video> v6 = extractAndSort(param, ReturnVideoRecallStrategy.PUSH_FORM);
-            v6 = v6.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
-            v6 = v6.subList(0, Math.min(mergeWeight.getOrDefault("v6", 4.0).intValue(), v6.size()));
-            rovRecallRank.addAll(v6);
-            setVideo.addAll(v6.stream().map(Video::getVideoId).collect(Collectors.toSet()));
-            // channel rovn
-            int channelROVN = mergeWeight.getOrDefault("channelROVN", 4.0).intValue();
-            addRecall(param, channelROVN, ChannelROVRecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
-            // 老地域
-            v0 = v0.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
-            rovRecallRank.addAll(v0);
-            setVideo.addAll(v0.stream().map(Video::getVideoId).collect(Collectors.toSet()));
-
-            // 是否排序
-            boolean firstLevelRank = mergeWeight.getOrDefault("firstLevelRank", 0D).intValue() > 0;
-            if (!firstLevelRank) {
-                return rovRecallRank;
-            }
-        } else {
-            // 老地域
-            v0 = v0.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
-            rovRecallRank.addAll(v0);
-            setVideo.addAll(v0.stream().map(Video::getVideoId).collect(Collectors.toSet()));
-            //-------------------return相似召回------------------
-            List<Video> v6 = extractAndSort(param, ReturnVideoRecallStrategy.PUSH_FORM);
-            v6 = v6.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
-            v6 = v6.subList(0, Math.min(mergeWeight.getOrDefault("v6", 5.0).intValue(), v6.size()));
-            rovRecallRank.addAll(v6);
-            setVideo.addAll(v6.stream().map(Video::getVideoId).collect(Collectors.toSet()));
-            //-------------------新地域召回------------------
-            List<Video> v1 = extractAndSort(param, RegionRealtimeRecallStrategyV1.PUSH_FORM);
-            v1 = v1.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
-            v1 = v1.subList(0, Math.min(mergeWeight.getOrDefault("v1", 5.0).intValue(), v1.size()));
-            rovRecallRank.addAll(v1);
-            setVideo.addAll(v1.stream().map(Video::getVideoId).collect(Collectors.toSet()));
-            //-------------------scene cf rovn------------------
-            List<Video> sceneCFRovn = extractAndSort(param, SceneCFRovnRecallStrategy.PUSH_FORM);
-            sceneCFRovn = sceneCFRovn.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
-            sceneCFRovn = sceneCFRovn.subList(0, Math.min(mergeWeight.getOrDefault("sceneCFRovn", 5.0).intValue(), sceneCFRovn.size()));
-            rovRecallRank.addAll(sceneCFRovn);
-            setVideo.addAll(sceneCFRovn.stream().map(Video::getVideoId).collect(Collectors.toSet()));
-            //-------------------scene cf rosn------------------
-            List<Video> sceneCFRosn = extractAndSort(param, SceneCFRosnRecallStrategy.PUSH_FORM);
-            sceneCFRosn = sceneCFRosn.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
-            sceneCFRosn = sceneCFRosn.subList(0, Math.min(mergeWeight.getOrDefault("sceneCFRosn", 5.0).intValue(), sceneCFRosn.size()));
-            rovRecallRank.addAll(sceneCFRosn);
-            setVideo.addAll(sceneCFRosn.stream().map(Video::getVideoId).collect(Collectors.toSet()));
-        }
+        Set<Long> setVideo = new HashSet<>();
+        this.duplicate(setVideo, v0);
+        setVideo.addAll(v0.stream().map(Video::getVideoId).collect(Collectors.toSet()));
+        List<Video> rovRecallRank = new ArrayList<>(v0);
+        //-------------------return相似召回------------------
+        List<Video> v6 = extractAndSort(param, ReturnVideoRecallStrategy.PUSH_FORM);
+        v6 = v6.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
+        v6 = v6.subList(0, Math.min(mergeWeight.getOrDefault("v6", 5.0).intValue(), v6.size()));
+        rovRecallRank.addAll(v6);
+        setVideo.addAll(v6.stream().map(Video::getVideoId).collect(Collectors.toSet()));
+        //-------------------新地域召回------------------
+        List<Video> v1 = extractAndSort(param, RegionRealtimeRecallStrategyV1.PUSH_FORM);
+        v1 = v1.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
+        v1 = v1.subList(0, Math.min(mergeWeight.getOrDefault("v1", 5.0).intValue(), v1.size()));
+        rovRecallRank.addAll(v1);
+        setVideo.addAll(v1.stream().map(Video::getVideoId).collect(Collectors.toSet()));
+        //-------------------scene cf rovn------------------
+        List<Video> sceneCFRovn = extractAndSort(param, SceneCFRovnRecallStrategy.PUSH_FORM);
+        sceneCFRovn = sceneCFRovn.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
+        sceneCFRovn = sceneCFRovn.subList(0, Math.min(mergeWeight.getOrDefault("sceneCFRovn", 5.0).intValue(), sceneCFRovn.size()));
+        rovRecallRank.addAll(sceneCFRovn);
+        setVideo.addAll(sceneCFRovn.stream().map(Video::getVideoId).collect(Collectors.toSet()));
+        //-------------------scene cf rosn------------------
+        List<Video> sceneCFRosn = extractAndSort(param, SceneCFRosnRecallStrategy.PUSH_FORM);
+        sceneCFRosn = sceneCFRosn.stream().filter(r -> !setVideo.contains(r.getVideoId())).collect(Collectors.toList());
+        sceneCFRosn = sceneCFRosn.subList(0, Math.min(mergeWeight.getOrDefault("sceneCFRosn", 5.0).intValue(), sceneCFRosn.size()));
+        rovRecallRank.addAll(sceneCFRosn);
+        setVideo.addAll(sceneCFRosn.stream().map(Video::getVideoId).collect(Collectors.toSet()));
+        // -------------------cate1------------------
+        int cate1RecallN = mergeWeight.getOrDefault("cate1RecallN", 5.0).intValue();
+        addRecall(param, cate1RecallN, UserCate1RecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
+        // -------------------cate2------------------
+        int cate2RecallN = mergeWeight.getOrDefault("cate2RecallN", 5.0).intValue();
+        addRecall(param, cate2RecallN, UserCate2RecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
+        // -------------------head province cate1------------------
+        int headCate1RecallN = mergeWeight.getOrDefault("headCate1RecallN", 5.0).intValue();
+        addRecall(param, headCate1RecallN, HeadProvinceCate1RecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
+        // -------------------head province cate2------------------
+        int headCate2RecallN = mergeWeight.getOrDefault("headCate2RecallN", 5.0).intValue();
+        addRecall(param, headCate2RecallN, HeadProvinceCate2RecallStrategy.PUSH_FORM, setVideo, rovRecallRank);
 
         //-------------------排-------------------
         //-------------------序-------------------
         //-------------------逻-------------------
         //-------------------辑-------------------
 
-        // 1 批量获取特征  省份参数要对齐  headvid  要传递过来！
-        List<String> vids = CommonCollectionUtils.toListDistinct(rovRecallRank, v -> String.valueOf(v.getVideoId()));
-
+        // 1. 批量获取特征  省份参数要对齐  headvid  要传递过来！
         // k1:视频、k2:表、k3:特征、v:特征值
-        String provinceCn = param.getProvince().replaceAll("省$", "");
+        List<String> vids = CommonCollectionUtils.toListDistinct(rovRecallRank, v -> String.valueOf(v.getVideoId()));
         String headVid = String.valueOf(param.getHeadVid());
-        FeatureService.Feature feature = featureService.getFeature(param.getMid(), vids,
-                String.valueOf(param.getAppType()), provinceCn, headVid);
+        Map<String, Map<String, Map<String, String>>> videoBaseInfoMap = featureService.getVideoBaseInfo(headVid, vids);
+        FeatureService.Feature feature = featureService.getFeatureV3(param, videoBaseInfoMap, vids);
         Map<String, Map<String, String>> featureOriginUser = feature.getUserFeature();
         Map<String, Map<String, Map<String, String>>> featureOriginVideo = feature.getVideoFeature();
+        Map<String, String> headVideoInfo = videoBaseInfoMap.getOrDefault(headVid, new HashMap<>()).getOrDefault("alg_vid_feature_basic_info", new HashMap<>());
+
+        // 2. 用户信息预处理
+        Map<String, Map<String, String[]>> newC7Map = FeatureV6.parseUCFScore(featureOriginUser.getOrDefault("alg_mid_feature_sharecf", new HashMap<>()));
+        Map<String, Map<String, String[]>> newC8Map = FeatureV6.parseUCFScore(featureOriginUser.getOrDefault("alg_mid_feature_returncf", new HashMap<>()));
+        UserShareReturnProfile userProfile = parseUserProfile(featureOriginUser);
+        Map<String, Map<String, String>> userBehaviorVideoMap = getUserBehaviorVideoMap(userProfile);
 
+        // 3. 特征处理
+        List<RankItem> rankItems = CommonCollectionUtils.toList(rovRecallRank, RankItem::new);
+        Map<String, String> userFeatureMap = getUserFeature(currentMs, param, headVideoInfo, userProfile, featureOriginUser);
+        batchGetVideoFeature(currentMs, userProfile, headVideoInfo, videoBaseInfoMap,
+                newC7Map, newC8Map, featureOriginUser, userBehaviorVideoMap, featureOriginVideo, rankItems);
 
-        // 2 特征处理
-        Map<String, Double> userFeatureMapDouble = new HashMap<>();
-        String mid = param.getMid();
-        Map<String, String> c1 = featureOriginUser.getOrDefault("alg_mid_feature_play", new HashMap<>());
-        Map<String, String> c2 = featureOriginUser.getOrDefault("alg_mid_feature_share_and_return", new HashMap<>());
-        Map<String, String> c3 = featureOriginUser.getOrDefault("alg_mid_feature_play_tags", new HashMap<>());
-        Map<String, String> c4 = featureOriginUser.getOrDefault("alg_mid_feature_return_tags", new HashMap<>());
-        Map<String, String> c5 = featureOriginUser.getOrDefault("alg_mid_feature_share_tags", new HashMap<>());
-        Map<String, String> c6 = featureOriginUser.getOrDefault("alg_mid_feature_feed_exp_share_tags_v2", new HashMap<>());
-        Map<String, String> c7 = featureOriginUser.getOrDefault("alg_mid_feature_feed_exp_return_tags_v2", new HashMap<>());
-        Map<String, String> c8 = featureOriginUser.getOrDefault("alg_mid_feature_sharecf", new HashMap<>());
-        Map<String, String> c9 = featureOriginUser.getOrDefault("alg_mid_feature_returncf", new HashMap<>());
+        // 4. 排序模型计算
+        Map<String, String> sceneFeatureMap = new HashMap<>(0);
+        List<RankItem> items = ScorerUtils.getScorerPipeline("feeds_score_config_fm_xgb_20250317.conf").scoring(sceneFeatureMap, userFeatureMap, userFeatureMap, rankItems);
 
-        if (!c1.isEmpty()) {
-            userFeatureMapDouble.put("playcnt_6h", Double.parseDouble(c1.getOrDefault("playcnt_6h", "0")));
-            userFeatureMapDouble.put("playcnt_1d", Double.parseDouble(c1.getOrDefault("playcnt_1d", "0")));
-            userFeatureMapDouble.put("playcnt_3d", Double.parseDouble(c1.getOrDefault("playcnt_3d", "0")));
-            userFeatureMapDouble.put("playcnt_7d", Double.parseDouble(c1.getOrDefault("playcnt_7d", "0")));
-        }
-        if (!c2.isEmpty()) {
-            userFeatureMapDouble.put("share_pv_12h", Double.parseDouble(c2.getOrDefault("share_pv_12h", "0")));
-            userFeatureMapDouble.put("share_pv_1d", Double.parseDouble(c2.getOrDefault("share_pv_1d", "0")));
-            userFeatureMapDouble.put("share_pv_3d", Double.parseDouble(c2.getOrDefault("share_pv_3d", "0")));
-            userFeatureMapDouble.put("share_pv_7d", Double.parseDouble(c2.getOrDefault("share_pv_7d", "0")));
-            userFeatureMapDouble.put("return_uv_12h", Double.parseDouble(c2.getOrDefault("return_uv_12h", "0")));
-            userFeatureMapDouble.put("return_uv_1d", Double.parseDouble(c2.getOrDefault("return_uv_1d", "0")));
-            userFeatureMapDouble.put("return_uv_3d", Double.parseDouble(c2.getOrDefault("return_uv_3d", "0")));
-            userFeatureMapDouble.put("return_uv_7d", Double.parseDouble(c2.getOrDefault("return_uv_7d", "0")));
+        // 5. 排序公式特征
+        double xgbRovNegRate = mergeWeight.getOrDefault("xgbRovNegRate", 0.059);
+        double xgbNorPowerWeight = mergeWeight.getOrDefault("xgbNorPowerWeight", 1.22);
+        double xgbNorPowerExp = mergeWeight.getOrDefault("xgbNorPowerExp", 1.24);
+        Map<String, Map<String, String>> vid2MapFeature = this.getVideoRedisFeature(vids, "redis:vid_hasreturn_vor:");
+        List<Video> result = new ArrayList<>();
+        for (RankItem item : items) {
+            double score;
+            double fmRovOrigin = item.getScoreRov();
+            item.getScoresMap().put("fmRovOrigin", fmRovOrigin);
+            double fmRov = restoreScore(fmRovOrigin, xgbRovNegRate);
+            item.getScoresMap().put("fmRov", fmRov);
+            double hasReturnRovScore = Double.parseDouble(vid2MapFeature.getOrDefault(item.getVideoId() + "", new HashMap<>()).getOrDefault("rov", "0"));
+            item.getScoresMap().put("hasReturnRovScore", hasReturnRovScore);
+            double norXGBScore = item.getScoresMap().getOrDefault("NorXGBScore", 0d);
+            double newNorXGBScore = norPowerCalibration(xgbNorPowerWeight, xgbNorPowerExp, norXGBScore);
+            double vor = Double.parseDouble(vid2MapFeature.getOrDefault(item.getVideoId() + "", new HashMap<>()).getOrDefault("vor", "0"));
+            item.getScoresMap().put("vor", vor);
+            score = fmRov * (0.1 + hasReturnRovScore) * (0.1 + vor);
+            Video video = item.getVideo();
+            video.setScore(score);
+            video.setSortScore(score);
+            video.setScoresMap(item.getScoresMap());
+            video.setAllFeatureMap(item.getAllFeatureMap());
+            if (MapUtils.isNotEmpty(feature.getVideoFeature()) && MapUtils.isNotEmpty(feature.getVideoFeature().get(item.getVideoId() + ""))) {
+                video.getMetaFeatureMap().putAll(feature.getVideoFeature().get(item.getVideoId() + ""));
+            }
+            if (MapUtils.isNotEmpty(videoBaseInfoMap) && MapUtils.isNotEmpty(videoBaseInfoMap.get(item.getVideoId() + ""))) {
+                video.getMetaFeatureMap().putAll(videoBaseInfoMap.get(item.getVideoId() + ""));
+            }
+            if (MapUtils.isNotEmpty(headVideoInfo)) {
+                video.getMetaFeatureMap().put("head_video", headVideoInfo);
+            }
+            if (MapUtils.isNotEmpty(feature.getUserFeature())) {
+                video.getMetaFeatureMap().putAll(feature.getUserFeature());
+            }
+            result.add(video);
         }
+        result.sort(Comparator.comparingDouble(o -> -o.getSortScore()));
+        return result;
+    }
 
-        Map<String, String> c34567Map = new HashMap<>(15);
-        List<Tuple2> tmpList0 = Arrays.asList(
-                new Tuple2(c3, "c3_feature"),
-                new Tuple2(c4, "c4_feature"),
-                new Tuple2(c5, "c5_feature"),
-                new Tuple2(c6, "c6_feature"),
-                new Tuple2(c7, "c7_feature")
-        );
-        for (Tuple2 tuple2 : tmpList0) {
-            for (String key_time : Arrays.asList("tags_1d", "tags_3d", "tags_7d")) {
-                String tags = tuple2.first.getOrDefault(key_time, "");
-                if (!tags.isEmpty()) {
-                    c34567Map.put(tuple2.name + "_" + key_time, tags);
+    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");
+            if (null != c9 && !c9.isEmpty()) {
+                String c9Str = JSONUtils.toJson(c9);
+                if (!c9Str.isEmpty()) {
+                    try {
+                        return JSON.parseObject(c9Str, UserShareReturnProfile.class);
+                    } catch (Exception e) {
+                        log.error("parseObject user profile error! value=[{}]", c9Str, e);
+                    }
                 }
             }
         }
+        return null;
+    }
 
-        Map<String, Map<String, String[]>> c89Map = new HashMap<>(4);
-        List<Tuple2> tmpList1 = Arrays.asList(
-                new Tuple2(c8, "c8_feature"),
-                new Tuple2(c9, "c9_feature")
-        );
-        for (Tuple2 tuple2 : tmpList1) {
-            for (String key_action : Arrays.asList("share", "return")) {
-                String cfListStr = tuple2.first.getOrDefault(key_action, "");
-                if (!cfListStr.isEmpty()) {
-                    Map<String, String[]> cfMap = new HashMap<>();
-                    String[] entries = cfListStr.split(",");
-                    for (String entry : entries) {
-                        String[] rList = entry.split(":");
-                        if (rList.length >= 4) { // 确保分割后有四个元素
-                            String key = rList[0];
-                            String value1 = rList[1];
-                            String value2 = rList[2];
-                            String value3 = rList[3];
-                            String[] strs = {value1, value2, value3};
-                            cfMap.put(key, strs);
+    private Map<String, Map<String, String>> getUserBehaviorVideoMap(UserShareReturnProfile userProfile) {
+        Set<String> vidSet = new HashSet<>();
+        if (null != userProfile) {
+            for (List<UserSRBO> list : Arrays.asList(userProfile.getM_s_s(), userProfile.getM_r_s(), userProfile.getL_s_s(), userProfile.getL_r_s())) {
+                if (null != list) {
+                    for (UserSRBO u : list) {
+                        if (null != u) {
+                            vidSet.add(u.getId() + "");
                         }
                     }
-                    c89Map.put(tuple2.name + "_" + key_action, cfMap);
                 }
             }
         }
 
+        Map<String, Map<String, String>> historyVideoMap = new HashMap<>();
+        if (!vidSet.isEmpty()) {
+            Map<String, Map<String, Map<String, String>>> videoMap = featureService.getVideoBaseInfo("", new ArrayList<>(vidSet));
+            if (null != videoMap && !videoMap.isEmpty()) {
+                for (Map.Entry<String, Map<String, Map<String, String>>> entry : videoMap.entrySet()) {
+                    String vid = entry.getKey();
+                    Map<String, Map<String, String>> map = entry.getValue();
+                    if (null != map && map.containsKey("alg_vid_feature_basic_info")) {
+                        historyVideoMap.put(vid, map.get("alg_vid_feature_basic_info"));
+                    }
+                }
+            }
+        }
+        return historyVideoMap;
+    }
 
-        List<RankItem> rankItems = CommonCollectionUtils.toList(rovRecallRank, RankItem::new);
-        for (RankItem item : rankItems) {
-            Map<String, Double> featureMap = new HashMap<>();
-            String vid = item.getVideoId() + "";
-            Map<String, String> b1 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_all_exp_v2", new HashMap<>());
-            Map<String, String> b2 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_all_share", new HashMap<>());
-            Map<String, String> b3 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_all_return", new HashMap<>());
-            Map<String, String> b6 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_exp2share_v2", new HashMap<>());
-            Map<String, String> b7 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_share2return", new HashMap<>());
+    private Map<String, String> getUserFeature(long currentMs, RankParam param, Map<String, String> headInfo, UserShareReturnProfile userProfile, Map<String, Map<String, String>> userOriginInfo) {
+        Map<String, Double> featMap = new HashMap<>();
+        // context feature
+        String appType = String.valueOf(param.getAppType());
+        String hotSceneType = String.valueOf(param.getHotSceneType());
+        FeatureV6.getContextFeature(currentMs, appType, hotSceneType, featMap);
 
-            Map<String, String> b8 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_feed_noflow_exp_v2", new HashMap<>());
-            Map<String, String> b9 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_feed_noflow_root_share_v2", new HashMap<>());
-            Map<String, String> b10 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_feed_noflow_root_return_v2", new HashMap<>());
-            Map<String, String> b11 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_feed_flow_exp_v2", new HashMap<>());
-            Map<String, String> b12 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_feed_flow_root_share_v2", new HashMap<>());
-            Map<String, String> b13 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_feed_flow_root_return_v2", new HashMap<>());
-            Map<String, String> b17 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_feed_province_exp_v2", new HashMap<>());
-            Map<String, String> b18 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_feed_province_root_share_v2", new HashMap<>());
-            Map<String, String> b19 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_feed_province_root_return_v2", new HashMap<>());
+        // head video feature
+        FeatureV6.getVideoBaseFeature("h", currentMs, headInfo, featMap);
 
-            List<Tuple4> originData = Arrays.asList(
-                    new Tuple4(b1, b2, b3, "b123"),
-                    new Tuple4(b1, b6, b7, "b167"),
-                    new Tuple4(b8, b9, b10, "b8910"),
-                    new Tuple4(b11, b12, b13, "b111213"),
-                    new Tuple4(b17, b18, b19, "b171819")
-            );
+        // user feature
+        Map<String, String> baseInfo = getUserBaseInfo(param);
+        FeatureV6.getUserFeature(userOriginInfo, featMap);
+        FeatureV6.getUserProfileFeature(userProfile, baseInfo, featMap);
 
-            for (Tuple4 tuple4 : originData) {
-                for (String prefix2 : Arrays.asList("1h", "2h", "3h", "4h", "12h", "1d", "3d", "7d")) {
-                    double exp = tuple4.first.isEmpty() ? 0 : Double.parseDouble(tuple4.first.getOrDefault("exp_pv_" + prefix2, "0.0"));
-                    double share = tuple4.second.isEmpty() ? 0 : Double.parseDouble(tuple4.second.getOrDefault("share_pv_" + prefix2, "0.0"));
-                    double returns = tuple4.third.isEmpty() ? 0 : Double.parseDouble(tuple4.third.getOrDefault("return_uv_" + prefix2, "0.0"));
+        return FeatureBucketUtils.noBucketFeature(featMap);
+    }
 
-                    double f1 = ExtractorUtils.calDiv(share, exp);
-                    double f2 = ExtractorUtils.calLog(share);
-                    double f3 = ExtractorUtils.calDiv(returns, exp);
-                    double f4 = ExtractorUtils.calLog(returns);
-                    double f5 = f3 * f4;
+    private Map<String, String> getVideoFeature(long currentMs, String vid,
+                                                UserShareReturnProfile userProfile,
+                                                Map<String, String> headInfo, Map<String, String> rankInfo,
+                                                Map<String, Map<String, String[]>> c7Map,
+                                                Map<String, Map<String, String[]>> c8Map,
+                                                Map<String, Map<String, String>> userOriginInfo,
+                                                Map<String, Map<String, String>> historyVideoMap,
+                                                Map<String, Map<String, Map<String, String>>> videoOriginInfo) {
+        Map<String, Double> featMap = new HashMap<>();
+        // user & video feature
+        FeatureV6.getUserTagsCrossVideoFeature("c5", rankInfo, userOriginInfo.get("alg_mid_feature_return_tags"), featMap);
+        FeatureV6.getUserTagsCrossVideoFeature("c6", rankInfo, userOriginInfo.get("alg_mid_feature_share_tags"), featMap);
+        FeatureV6.getUserCFFeature("c7", vid, c7Map, featMap);
+        FeatureV6.getUserCFFeature("c8", vid, c8Map, featMap);
 
-                    String key1 = tuple4.name + "_" + prefix2 + "_" + "STR";
-                    String key2 = tuple4.name + "_" + prefix2 + "_" + "log(share)";
-                    String key3 = tuple4.name + "_" + prefix2 + "_" + "ROV";
-                    String key4 = tuple4.name + "_" + prefix2 + "_" + "log(return)";
-                    String key5 = tuple4.name + "_" + prefix2 + "_" + "ROV*log(return)";
+        // rank video feature
+        FeatureV6.getVideoBaseFeature("r", currentMs, rankInfo, featMap);
+        FeatureV6.getVideoFeature(vid, videoOriginInfo, featMap);
 
-                    featureMap.put(key1, f1);
-                    featureMap.put(key2, f2);
-                    featureMap.put(key3, f3);
-                    featureMap.put(key4, f4);
-                    featureMap.put(key5, f5);
-                }
-            }
+        // head&rank cross feature
+        FeatureV6.getHeadRankVideoCrossFeature(headInfo, rankInfo, featMap);
 
-            Map<String, String> videoInfo = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_basic_info", new HashMap<>());
-            featureMap.put("total_time", Double.parseDouble(videoInfo.getOrDefault("total_time", "0")));
-            featureMap.put("bit_rate", Double.parseDouble(videoInfo.getOrDefault("bit_rate", "0")));
+        // user profile & rank cross
+        FeatureV6.getProfileVideoCrossFeature(currentMs, userProfile, rankInfo, historyVideoMap, featMap);
 
-            String title = videoInfo.getOrDefault("title", "");
-            if (!title.isEmpty()) {
-                List<Future<Pair<String, Double[]>>> futures = new ArrayList<>();
-                for (String name : Arrays.asList("c3_feature", "c4_feature", "c5_feature", "c6_feature", "c7_feature")) {
-                    for (String key_time : Arrays.asList("tags_1d", "tags_3d", "tags_7d")) {
-                        String key = name + "_" + key_time;
-                        String tags = c34567Map.getOrDefault(key, "");
-                        if (!tags.isEmpty()) {
-                            Future<Pair<String, Double[]>> future = ThreadPoolFactory.defaultPool().submit(() -> {
-                                Double[] doubles = ExtractorUtils.funcC34567ForTagsNew(tags, title);
-                                return Pair.create(key, doubles);
-                            });
-                            futures.add(future);
-                        }
-                    }
-                }
-                try {
-                    for (Future<Pair<String, Double[]>> future : futures) {
-                        Pair<String, Double[]> pair = future.get(1000, TimeUnit.MILLISECONDS);
-                        featureMap.put(pair.getFirst() + "_matchnum", pair.getSecond()[0]);
-                        featureMap.put(pair.getFirst() + "_maxscore", pair.getSecond()[1]);
-                        featureMap.put(pair.getFirst() + "_avgscore", pair.getSecond()[2]);
-                    }
-                } catch (Exception e) {
-                    log.error("concurrent similarity error", e);
-                }
+        return FeatureBucketUtils.noBucketFeature(featMap);
+    }
+
+    private void batchGetVideoFeature(long currentMs,
+                                      UserShareReturnProfile userProfile,
+                                      Map<String, String> headInfo,
+                                      Map<String, Map<String, Map<String, String>>> videoBaseInfoMap,
+                                      Map<String, Map<String, String[]>> c7Map,
+                                      Map<String, Map<String, String[]>> c8Map,
+                                      Map<String, Map<String, String>> userOriginInfo,
+                                      Map<String, Map<String, String>> historyVideoMap,
+                                      Map<String, Map<String, Map<String, String>>> videoOriginInfo,
+                                      List<RankItem> rankItems) {
+        if (null != rankItems && !rankItems.isEmpty()) {
+            List<Future<Integer>> futures = new ArrayList<>();
+            for (RankItem item : rankItems) {
+                String vid = item.getVideoId() + "";
+                Map<String, String> rankInfo = videoBaseInfoMap.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_vid_feature_basic_info", new HashMap<>());
+                Future<Integer> future = ThreadPoolFactory.defaultPool().submit(() -> {
+                    item.featureMap = getVideoFeature(currentMs, vid, userProfile, headInfo, rankInfo, c7Map, c8Map, userOriginInfo, historyVideoMap, videoOriginInfo);
+                    item.norFeatureMap = item.featureMap;
+                    return 1;
+                });
+                futures.add(future);
             }
 
-            if (!vid.isEmpty()) {
-                for (String key_feature : Arrays.asList("c8_feature", "c9_feature")) {
-                    for (String key_action : Arrays.asList("share", "return")) {
-                        Map<String, String[]> cfMap = c89Map.getOrDefault(key_feature + "_" + key_action, new HashMap<>());
-                        if (cfMap.containsKey(vid)) {
-                            String[] scores = cfMap.get(vid);
-                            Double score1 = Double.parseDouble(scores[0]);
-                            Double score2 = Double.parseDouble(scores[1]);
-                            Double score3 = Double.parseDouble(scores[2]) <= 0 ? 0D : 1.0 / Double.parseDouble(scores[2]);
-                            featureMap.put(key_feature + "_" + key_action + "_score", score1);
-                            featureMap.put(key_feature + "_" + key_action + "_num", score2);
-                            featureMap.put(key_feature + "_" + key_action + "_rank", score3);
-                        }
-                    }
+            try {
+                for (Future<Integer> future : futures) {
+                    future.get(1000, TimeUnit.MILLISECONDS);
                 }
+            } catch (Exception e) {
+                log.error("get feature error", e);
             }
-            Map<String, String> d1 = featureOriginVideo.getOrDefault(vid, new HashMap<>()).getOrDefault("alg_recsys_feature_cf_i2i_new_v2", new HashMap<>());
-            if (!d1.isEmpty()) {
-                featureMap.put("d1_exp", Double.parseDouble(d1.getOrDefault("exp", "0")));
-                featureMap.put("d1_return_n", Double.parseDouble(d1.getOrDefault("return_n", "0")));
-                featureMap.put("d1_rovn", Double.parseDouble(d1.getOrDefault("rovn", "0")));
-            }
-            item.featureMapDouble = featureMap;
         }
+    }
 
-        // 3 连续值特征分桶
-        readBucketFile();
-        Map<String, String> userFeatureMap = new HashMap<>(userFeatureMapDouble.size());
-        for (Map.Entry<String, Double> entry : userFeatureMapDouble.entrySet()) {
-            String name = entry.getKey();
-            Double score = entry.getValue();
-            // 注意：0值、不在分桶文件中的特征，会被过滤掉。
-            if (score > 1E-8 && this.bucketsLen.containsKey(name) && this.bucketsMap.containsKey(name)) {
-                Double bucketNum = this.bucketsLen.get(name);
-                double[] buckets = this.bucketsMap.get(name);
-                Double scoreNew = 1.0 / bucketNum * (ExtractorUtils.findInsertPosition(buckets, score) + 1.0);
-                userFeatureMap.put(name, String.valueOf(scoreNew));
-            }
+    private Map<String, String> getUserBaseInfo(RankParam param) {
+        Map<String, String> baseInfo = new HashMap<>();
+        String province = param.getProvince();
+        if (null != province && !province.isEmpty()) {
+            baseInfo.put("province", province.replaceAll("省$", ""));
         }
-        for (RankItem item : rankItems) {
-            Map<String, String> featureMap = new HashMap<>();
-            Map<String, Double> featureMapDouble = item.featureMapDouble;
 
-            for (Map.Entry<String, Double> entry : featureMapDouble.entrySet()) {
-                String name = entry.getKey();
-                Double score = entry.getValue();
-                // 注意：0值、不在分桶文件中的特征，会被过滤掉。
-                if (score > 1E-8 && this.bucketsLen.containsKey(name) && this.bucketsMap.containsKey(name)) {
-                    Double bucketNum = this.bucketsLen.get(name);
-                    double[] buckets = this.bucketsMap.get(name);
-                    Double scoreNew = 1.0 / bucketNum * (ExtractorUtils.findInsertPosition(buckets, score) + 1.0);
-                    featureMap.put(name, String.valueOf(scoreNew));
-                }
-            }
-            item.featureMap = featureMap;
+        String city = param.getCity();
+        if (null != city && !city.isEmpty()) {
+            baseInfo.put("city", city.replaceAll("市$", ""));
         }
-        // 4 排序模型计算
-        Map<String, String> sceneFeatureMap = new HashMap<>(0);
-        List<RankItem> items = ScorerUtils.getScorerPipeline("feeds_score_config_20240807.conf").scoring(sceneFeatureMap, userFeatureMap, rankItems);
-        // 5 排序公式特征
-        Map<String, Map<String, String>> vid2MapFeature = this.getVideoRedisFeature(vids, "redis:vid_hasreturn_vor:");
-        List<Video> result = new ArrayList<>();
-        for (RankItem item : items) {
-            double score;
-            double fmRovOrigin = item.getScoreRov();
-            item.getScoresMap().put("fmRovOrigin", fmRovOrigin);
-            double fmRov = restoreScore(fmRovOrigin);
-            item.getScoresMap().put("fmRov", fmRov);
-            double hasReturnRovScore = Double.parseDouble(vid2MapFeature.getOrDefault(item.getVideoId() + "", new HashMap<>()).getOrDefault("rov", "0"));
-            item.getScoresMap().put("hasReturnRovScore", hasReturnRovScore);
-            double vor = Double.parseDouble(vid2MapFeature.getOrDefault(item.getVideoId() + "", new HashMap<>()).getOrDefault("vor", "0"));
-            item.getScoresMap().put("vor", vor);
-            score = fmRov * (0.1 + hasReturnRovScore) * (0.1 + vor);
-            Video video = item.getVideo();
-            video.setScore(score);
-            video.setSortScore(score);
-            video.setScoresMap(item.getScoresMap());
-            video.setAllFeatureMap(item.getAllFeatureMap());
-            if (MapUtils.isNotEmpty(feature.getVideoFeature()) && MapUtils.isNotEmpty(feature.getVideoFeature().get(item.getVideoId() + ""))) {
-                video.getMetaFeatureMap().putAll(feature.getVideoFeature().get(item.getVideoId() + ""));
+
+        MachineInfo machineInfo = param.getMachineInfo();
+        if (null != machineInfo) {
+            String model = machineInfo.getModel();
+            if (null != model && !model.isEmpty()) {
+                baseInfo.put("model", model);
             }
-            if (MapUtils.isNotEmpty(feature.getUserFeature())) {
-                video.getMetaFeatureMap().putAll(feature.getUserFeature());
+            String brand = machineInfo.getBrand();
+            if (null != brand && !brand.isEmpty()) {
+                baseInfo.put("brand", brand);
+            }
+            String system = machineInfo.getSystem();
+            if (null != system && !system.isEmpty()) {
+                baseInfo.put("system", system);
             }
-            result.add(video);
         }
-        result.sort(Comparator.comparingDouble(o -> -o.getSortScore()));
-        return result;
+        return baseInfo;
+    }
+
+    private double norPowerCalibration(double weight, double exp, double score) {
+        double newScore = weight * Math.pow(score, exp);
+        if (newScore > 100) {
+            newScore = 100;
+        } else if (newScore < score) {
+            newScore = score;
+        }
+        return newScore;
     }
 
     private void addRecall(RankParam param, int recallNum, String recallName, Set<Long> setVideo, List<Video> rovRecallRank) {

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

@@ -5,7 +5,6 @@ import com.tzld.piaoquan.recommend.server.common.ThreadPoolFactory;
 import com.tzld.piaoquan.recommend.server.common.enums.AppTypeEnum;
 import com.tzld.piaoquan.recommend.server.model.Video;
 import com.tzld.piaoquan.recommend.server.service.recall.strategy.*;
-import com.tzld.piaoquan.recommend.server.util.FeatureUtils;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.commons.collections4.CollectionUtils;
 import org.apache.commons.lang3.StringUtils;
@@ -20,8 +19,6 @@ import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
-import java.util.regex.Matcher;
-import java.util.stream.Collectors;
 
 /**
  * @author dyp
@@ -118,19 +115,17 @@ public class RecallService implements ApplicationContextAware {
         strategies.add(strategyMap.get(SceneCFRovnRecallStrategy.class.getSimpleName()));
         strategies.add(strategyMap.get(SceneCFRosnRecallStrategy.class.getSimpleName()));
         Set<String> abExpCodes = param.getAbExpCodes();
-        if (CollectionUtils.isNotEmpty(abExpCodes) && abExpCodes.contains("567")) {
+        if (CollectionUtils.isNotEmpty(abExpCodes) && abExpCodes.contains("564")) {
             strategies.add(strategyMap.get(UserCate1RecallStrategy.class.getSimpleName()));
             strategies.add(strategyMap.get(UserCate2RecallStrategy.class.getSimpleName()));
             strategies.add(strategyMap.get(HeadProvinceCate1RecallStrategy.class.getSimpleName()));
             strategies.add(strategyMap.get(HeadProvinceCate2RecallStrategy.class.getSimpleName()));
         }
         if (CollectionUtils.isNotEmpty(abExpCodes) && abExpCodes.contains("568")) {
-            Matcher matcher = FeatureUtils.getChannelMatcher(param.getRootSourceId());
-            if (null != matcher && matcher.find() && FeatureUtils.firstLevel(param.getUserShareDepth())) {
-                strategies.add(strategyMap.get(ChannelROVRecallStrategy.class.getSimpleName()));
-                Set<String> filterRecallSet = new HashSet<>(Arrays.asList(RegionRealtimeRecallStrategyV1.PUSH_FORM, SceneCFRovnRecallStrategy.PUSH_FORM, SceneCFRosnRecallStrategy.PUSH_FORM));
-                strategies = strategies.stream().filter(r -> !filterRecallSet.contains(r.pushFrom())).collect(Collectors.toList());
-            }
+            strategies.add(strategyMap.get(UserCate1RecallStrategy.class.getSimpleName()));
+            strategies.add(strategyMap.get(UserCate2RecallStrategy.class.getSimpleName()));
+            strategies.add(strategyMap.get(HeadProvinceCate1RecallStrategy.class.getSimpleName()));
+            strategies.add(strategyMap.get(HeadProvinceCate2RecallStrategy.class.getSimpleName()));
         }
 
         // 命中用户黑名单不走流量池