Merge branch 'test' of https://git.yishihui.com/algorithm/rov-offline into test

config.py

@@ -397,18 +397,26 @@ class BaseConfig(object):
             # 其余表与地域小时级表，不做去重，召回在线去重
             'rule19': {'view_type': 'video-show-region', 'platform_return_rate': 0.001,
                        'region_24h_rule_key': 'rule4', '24h_rule_key': 'rule4', 'merge_func': 2, 'dup_remove': False},
-            # 分值计算公式 增加h-2分享当前小时回流数据、h-3分享当前小时回流数据特征
+            # 分值计算公式2 增加h-2分享当前小时回流数据、h-3分享当前小时回流数据特征
             # score = k2 * sharerate * (backrate * LOG(lastonehour_return+1) + backrate_2 * LOG(lasttwohour_return_now+1) + backrate_3 * LOG(lastthreehour_return_now+1))
             'rule20': {'view_type': 'video-show-region', 'platform_return_rate': 0.001, 'region_24h_rule_key': 'rule2',
                        '24h_rule_key': 'rule3', 'score_func': 'add_backrate*log(return+1)'},
-            # 分值计算公式 增加[h-3,h-2]之间的回流留存特征
+            # 分值计算公式3 增加[h-3,h-2]之间的回流留存特征
             # score = k2 * sharerate * backrate * LOG(lastonehour_return+1) * 前两小时回流留存
             'rule21': {'view_type': 'video-show-region', 'platform_return_rate': 0.001, 'region_24h_rule_key': 'rule2',
                        '24h_rule_key': 'rule3', 'score_func': 'multiply_return_retention'},
-            # 分值计算公式 增加h-2分享当前小时回流/h-2分享、h-3分享当前小时回流/h-3分享 特征
+            # 分值计算公式4 增加h-2分享当前小时回流/h-2分享、h-3分享当前小时回流/h-3分享 特征
             # score = k2 * sharerate * (backrate + backrate * backrate_2 * backrate_3) * LOG(lastonehour_return+1)
             'rule22': {'view_type': 'video-show-region', 'platform_return_rate': 0.001, 'region_24h_rule_key': 'rule2',
                        '24h_rule_key': 'rule3', 'score_func': 'update_backrate'},
+            # 回流数据使用 分享限制地域，回流不限制地域 统计数据
+            'rule23': {'view_type': 'video-show-region', 'platform_return_rate': 0.001, 'region_24h_rule_key': 'rule2',
+                       '24h_rule_key': 'rule3', 'return_data': 'share_region_return'},
+            # 分值计算公式3 增加[h-3,h-2]之间的回流留存特征 + 回流数据使用 分享限制地域，回流不限制地域 统计数据
+            # score = k2 * sharerate * backrate * LOG(lastonehour_return_new+1) * 前两小时回流留存
+            'rule24': {'view_type': 'video-show-region', 'platform_return_rate': 0.001, 'region_24h_rule_key': 'rule2',
+                       '24h_rule_key': 'rule3', 'score_func': 'multiply_return_retention',
+                       'return_data': 'share_region_return'},
 
         },
         'data_params': DATA_PARAMS,
@@ -443,6 +451,8 @@ class BaseConfig(object):
             {'data': 'data1', 'rule': 'rule20'},  # 461 vlog 分值计算公式 增加h-2分享当前小时回流数据、h-3分享当前小时回流数据特征
             {'data': 'data1', 'rule': 'rule21'},  # 462 vlog 分值计算公式 增加[h-3,h-2]之间的回流留存特征
             {'data': 'data1', 'rule': 'rule22'},  # 463 vlog 分值计算公式 增加h-2分享当前小时回流/h-2分享、h-3分享当前小时回流/h-3分享 特征
+            {'data': 'data1', 'rule': 'rule23'},  # 465 vlog 回流数据使用 分享限制地域，回流不限制地域 统计数据
+            {'data': 'data1', 'rule': 'rule24'},  # 466 vlog 分值计算公式 增加[h-3,h-2]之间的回流留存特征 + 回流数据使用 分享限制地域，回流不限制地域 统计数据
         ],
         'params_list_new': [
             {'data': 'data10', 'rule': 'rule19'},  # 316 票圈视频 + 召回在线去重

region_rule_rank_h.py

@@ -51,6 +51,13 @@ features = [
     'lastthreehour_share',  # h-3小时分享人数
     'lastthreehour_return_now',  # h-3分享，过去1小时回流人数
     'lastthreehour_return',  # h-3分享，h-3回流人数
+
+    'lastonehour_return_new',  # 过去1小时分享，过去1小时回流人数（回流统计为对应地域分享带回的回流，分享限制地域，回流不限制地域）
+    'lasttwohour_return_now_new',  # h-2分享，过去1小时回流人数（回流统计为对应地域分享带回的回流，分享限制地域，回流不限制地域）
+    'lasttwohour_return_new',  # h-2分享，h-2回流人数（回流统计为对应地域分享带回的回流，分享限制地域，回流不限制地域）
+    'lastthreehour_return_now_new',  # h-3分享，过去1小时回流人数（回流统计为对应地域分享带回的回流，分享限制地域，回流不限制地域）
+    'lastthreehour_return_new',  # h-3分享，h-3回流人数（回流统计为对应地域分享带回的回流，分享限制地域，回流不限制地域）
+    'platform_return_new',  # 平台分发回流（回流统计为对应地域分享带回的回流，分享限制地域，回流不限制地域）
 ]
 
 
@@ -279,15 +286,83 @@ def cal_score_update_backrate(df, param):
     return df
 
 
+def cal_score_with_new_return(df, param):
+    # 回流数据使用 分享限制地域，回流不限制地域 统计数据
+    # score计算公式: sharerate*backrate*logback*ctr
+    # sharerate = lastonehour_share/(lastonehour_play+1000)
+    # backrate = lastonehour_return_new/(lastonehour_share+10)
+    # ctr = lastonehour_play/(lastonehour_preview+1000), 对ctr限最大值：K2 = 0.6 if ctr > 0.6 else ctr
+    # score = sharerate * backrate * LOG(lastonehour_return_new+1) * K2
+
+    df = df.fillna(0)
+    df['share_rate'] = df['lastonehour_share'] / (df['lastonehour_play'] + 1000)
+    df['back_rate'] = df['lastonehour_return_new'] / (df['lastonehour_share'] + 10)
+    df['log_back'] = (df['lastonehour_return_new'] + 1).apply(math.log)
+    if param.get('view_type', None) == 'video-show':
+        df['ctr'] = df['lastonehour_play'] / (df['lastonehour_show'] + 1000)
+    elif param.get('view_type', None) == 'video-show-region':
+        df['ctr'] = df['lastonehour_play'] / (df['lastonehour_show_region'] + 1000)
+    else:
+        df['ctr'] = df['lastonehour_play'] / (df['lastonehour_preview'] + 1000)
+    df['K2'] = df['ctr'].apply(lambda x: 0.6 if x > 0.6 else x)
+    df['platform_return_rate'] = df['platform_return_new'] / df['lastonehour_return_new']
+
+    df['score'] = df['share_rate'] * df['back_rate'] * df['log_back'] * df['K2']
+
+    df = df.sort_values(by=['score'], ascending=False)
+    return df
+
+
+def cal_score_multiply_return_retention_with_new_return(df, param):
+    # 回流数据使用 分享限制地域，回流不限制地域 统计数据
+    # score计算公式: k2 * sharerate * backrate * LOG(lastonehour_return_new+1) * 前两小时回流留存
+    # sharerate = lastonehour_share/(lastonehour_play+1000)
+    # backrate = lastonehour_return_new/(lastonehour_share+10)
+    # ctr = lastonehour_play/(lastonehour_preview+1000), 对ctr限最大值：K2 = 0.6 if ctr > 0.6 else ctr
+    # 前两小时回流留存 return_retention_initial = (lasttwohour_return_now_new + lastthreehour_return_now_new)/(lasttwohour_return_new + lastthreehour_return_new + 1)
+    # return_retention = 0.5 if return_retention_initial == 0 else return_retention_initial
+    # score = k2 * sharerate * backrate * LOG(lastonehour_return_new+1) * return_retention
+
+    df = df.fillna(0)
+    df['share_rate'] = df['lastonehour_share'] / (df['lastonehour_play'] + 1000)
+    df['back_rate'] = df['lastonehour_return_new'] / (df['lastonehour_share'] + 10)
+    df['log_back'] = (df['lastonehour_return_new'] + 1).apply(math.log)
+
+    if param.get('view_type', None) == 'video-show':
+        df['ctr'] = df['lastonehour_play'] / (df['lastonehour_show'] + 1000)
+    elif param.get('view_type', None) == 'video-show-region':
+        df['ctr'] = df['lastonehour_play'] / (df['lastonehour_show_region'] + 1000)
+    else:
+        df['ctr'] = df['lastonehour_play'] / (df['lastonehour_preview'] + 1000)
+    df['K2'] = df['ctr'].apply(lambda x: 0.6 if x > 0.6 else x)
+
+    df['return_retention_initial'] = (df['lasttwohour_return_now_new'] + df['lastthreehour_return_now_new']) / \
+                                     (df['lasttwohour_return_new'] + df['lastthreehour_return_new'] + 1)
+    df['return_retention'] = df['return_retention_initial'].apply(lambda x: 0.5 if x == 0 else x)
+
+    df['platform_return_rate'] = df['platform_return_new'] / df['lastonehour_return_new']
+
+    df['score'] = df['K2'] * df['share_rate'] * df['back_rate'] * df['log_back'] * df['return_retention']
+
+    df = df.sort_values(by=['score'], ascending=False)
+    return df
+
+
 def cal_score(df, param):
-    if param.get('score_func', None) == 'add_backrate*log(return+1)':
-        df = cal_score_add_return(df=df, param=param)
-    elif param.get('score_func', None) == 'multiply_return_retention':
-        df = cal_score_multiply_return_retention(df=df, param=param)
-    elif param.get('score_func', None) == 'update_backrate':
-        df = cal_score_update_backrate(df=df, param=param)
+    if param.get('return_data', None) == 'share_region_return':
+        if param.get('score_func', None) == 'multiply_return_retention':
+            df = cal_score_multiply_return_retention_with_new_return(df=df, param=param)
+        else:
+            df = cal_score_with_new_return(df=df, param=param)
     else:
-        df = cal_score_initial(df=df, param=param)
+        if param.get('score_func', None) == 'add_backrate*log(return+1)':
+            df = cal_score_add_return(df=df, param=param)
+        elif param.get('score_func', None) == 'multiply_return_retention':
+            df = cal_score_multiply_return_retention(df=df, param=param)
+        elif param.get('score_func', None) == 'update_backrate':
+            df = cal_score_update_backrate(df=df, param=param)
+        else:
+            df = cal_score_initial(df=df, param=param)
     return df