Merge branch 'ad-abtest-threshold-auto-update-20230103'

ad_threshold_auto_update.py

@@ -1,11 +1,13 @@
+import copy
 import datetime
 import traceback
+import math
 import numpy as np
 from threading import Timer
 
 import pandas as pd
 
-from utils import RedisHelper, data_check, get_feature_data, send_msg_to_feishu
+from utils import RedisHelper, data_check, get_feature_data, send_msg_to_feishu, request_get
 from config import set_config
 from log import Log
 config_, _ = set_config()
@@ -14,10 +16,8 @@ redis_helper = RedisHelper()
 
 features = [
     'apptype',
-    'adcode',
-    'visit_uv_today',
-    'visit_uv_yesterday',
-    'b'
+    '分组',
+    '广告uv'
 ]
 
 
@@ -62,32 +62,143 @@ def get_threshold_record_new(ad_abtest_abcode_config, feature_df, threshold_reco
     return threshold_record_new, robot_msg_record
 
 
+def get_threshold_record_new_by_uv(ad_abtest_abcode_config, feature_df, threshold_record, ad_target_uv):
+    """根据广告uv计算新的阈值参数"""
+    robot_msg_record = []
+    threshold_record_new = copy.deepcopy(threshold_record)
+    # 根据目标uv进行调整
+    for app_type, target_uv_mapping in ad_target_uv.items():
+        # 获取app_type对应的目标uv
+        temp_df = feature_df[feature_df['apptype'] == int(app_type)]
+        # 获取app_type对应的阈值调整参数
+        update_threshold_params = ad_abtest_abcode_config.get(int(app_type))
+        ab_test_id = update_threshold_params.get('ab_test_id')
+        not_update = update_threshold_params.get('not_update')
+        gradient = update_threshold_params.get('gradient')
+        max_update_step = update_threshold_params.get('max_update_step')
+        threshold_update_mapping = update_threshold_params.get('threshold_update')
+        threshold_record_old = threshold_record.get(ab_test_id)
+        # print(ab_test_id, threshold_record, threshold_record_old)
+        for ab_test_group, target_uv in target_uv_mapping.items():
+            if target_uv is None:
+                continue
+            update_range = threshold_update_mapping.get(ab_test_group)
+            # 获取对应组的当前uv
+            try:
+                current_uv = temp_df[temp_df['分组'] == ab_test_group]['广告uv'].values[0]
+            except Exception as e:
+                continue
+            # 计算uv差值
+            uv_differ = current_uv - target_uv
+            if abs(uv_differ) < not_update:
+                continue
+            # 获取当前阈值参数
+            threshold_param_old = threshold_record_old[ab_test_group].get('group')
+            if uv_differ < 0:
+                # 当前uv < 目标uv，阈值按梯度调低
+                step = math.ceil((uv_differ * -1) / gradient)
+                step = max_update_step if step > max_update_step else step
+                threshold_param_new = float(threshold_param_old) - update_range * step
+            elif uv_differ > 0:
+                # 当前uv > 目标uv，阈值按梯度调高
+                step = math.ceil(uv_differ / gradient)
+                step = max_update_step if step > max_update_step else step
+                threshold_param_new = float(threshold_param_old) + update_range * step
+            else:
+                continue
+            if threshold_param_new > 0:
+                log_.info(
+                    {
+                        'appType': app_type, 'abtestid': ab_test_id, 'abTestGroup': ab_test_group,
+                        'targetUv': target_uv, 'currentUv': round(current_uv, 4),
+                        'uvDiffer':  round(uv_differ, 4), 'gradient': round(gradient, 4), 'step': step,
+                        'range': round(update_range, 4),
+                        'paramOld': round(float(threshold_param_old), 4),
+                        'paramNew': round(threshold_param_new, 4)
+                    }
+                )
+                threshold_record_new[ab_test_id][ab_test_group]['group'] = threshold_param_new
+                threshold_record_new[ab_test_id][ab_test_group]['mean_group'] = threshold_param_new
+                robot_msg_record.append(
+                    {
+                        'appType': app_type, 'abtestid': ab_test_id, 'abTestGroup': ab_test_group,
+                        'targetUv': target_uv, 'currentUv': round(current_uv, 4),
+                        'uvDiffer':  round(uv_differ, 4), 'gradient': round(gradient, 4), 'step': step,
+                        'range': round(update_range, 4),
+                        'paramOld': round(float(threshold_param_old), 4),
+                        'paramNew': round(threshold_param_new, 4)
+                    }
+                )
+    return threshold_record_new, robot_msg_record
+
+
 def update_threshold(threshold_record_old, threshold_record_new):
     """更新阈值"""
+    # 获取用户组列表
     ad_mid_group_list = [group for class_key, group_list in config_.AD_MID_GROUP.items()
                          for group in group_list]
     ad_mid_group_list.append("mean_group")
     ad_mid_group_list = list(set(ad_mid_group_list))
-    for ad_abtest_tag, threshold_param_new in threshold_record_new.items():
-        threshold_param_old = threshold_record_old.get(ad_abtest_tag)
-        log_.info(f"ad_abtest_tag = {ad_abtest_tag}, "
-                  f"threshold_param_old = {threshold_param_old}, threshold_param_new = {threshold_param_new}")
-        tag_list = ad_abtest_tag.split('-')
-        for group_key in ad_mid_group_list:
-            # 获取对应的阈值
-            key_name = f"{config_.KEY_NAME_PREFIX_AD_THRESHOLD}{tag_list[0]}:{tag_list[1]}:{group_key}"
-            threshold_old = redis_helper.get_data_from_redis(key_name=key_name)
-            if threshold_old is None:
+    # 获取实验配置列表
+    ad_abtest_config_mapping = {}
+    abtest_id_list = []
+    for key, val in config_.AD_ABTEST_CONFIG.items():
+        abtest_id, abtest_config_tag = key.split('-')
+        if abtest_id in abtest_id_list:
+            ad_abtest_config_mapping[abtest_id].append((abtest_config_tag, val))
+        else:
+            abtest_id_list.append(abtest_id)
+            ad_abtest_config_mapping[abtest_id] = [(abtest_config_tag, val)]
+    log_.info(f"ad_abtest_config_mapping = {ad_abtest_config_mapping}")
+
+    # 计算新的阈值并更新
+    for abtest_id, threshold_param_mapping in threshold_record_new.items():
+        for abtest_group, threshold_param_new in threshold_param_mapping.items():
+            threshold_param_old = threshold_record_old[abtest_id].get(abtest_group)
+            if str(threshold_param_old) == str(threshold_param_new):
+                # print(abtest_id, abtest_group, threshold_param_old, threshold_param_new)
                 continue
-            # 计算新的阈值
-            threshold_new = float(threshold_old) / threshold_param_old * threshold_param_new
-            log_.info(f"ad_abtest_tag = {ad_abtest_tag}, group_key = {group_key}, "
-                      f"threshold_old = {threshold_old}, threshold_new = {threshold_new}")
-            # 更新redis
-            redis_helper.set_data_to_redis(key_name=key_name, value=threshold_new)
+            log_.info(f"abtest_id = {abtest_id}, abtest_group = {abtest_group}, "
+                      f"threshold_param_old = {threshold_param_old}, threshold_param_new = {threshold_param_new}")
+            for abtest_config_tag, config_val in ad_abtest_config_mapping.get(abtest_id, []):
+                for group_key in ad_mid_group_list:
+                    # 获取对应的阈值
+                    key_name = \
+                        f"{config_.KEY_NAME_PREFIX_AD_THRESHOLD}{abtest_id}:{abtest_config_tag}:{abtest_group}:{group_key}"
+                    threshold_old = redis_helper.get_data_from_redis(key_name=key_name)
+                    if threshold_old is None:
+                        continue
+                    # 计算新的阈值
+                    if group_key == 'mean_group':
+                        threshold_new = \
+                            float(threshold_old) / threshold_param_old['mean_group'] * threshold_param_new['mean_group']
+                    else:
+                        threshold_new = \
+                            float(threshold_old) / threshold_param_old['group'] * threshold_param_new['group']
+
+                    # 更新redis
+                    redis_helper.set_data_to_redis(key_name=key_name, value=threshold_new, expire_time=2 * 24 * 3600)
+                    log_.info(f"abtest_id = {abtest_id}, abtest_config_tag = {abtest_config_tag}, "
+                              f"abtest_group = {abtest_group}, group_key = {group_key}, "
+                              f"threshold_old = {threshold_old}, threshold_new = {threshold_new}")
 
+                    # 关怀模式实验阈值更新
+                    care_model = config_val.get('care_model', None)
+                    threshold_rate = config_val.get('threshold_rate', None)
+                    if care_model is True:
+                        care_model_key_name = \
+                            f"{config_.KEY_NAME_PREFIX_AD_THRESHOLD_CARE_MODEL}{abtest_id}:{abtest_config_tag}:{abtest_group}:{group_key}"
+                        care_model_threshold_old = redis_helper.get_data_from_redis(key_name=care_model_key_name)
+                        care_model_threshold_new = threshold_new * threshold_rate
+                        redis_helper.set_data_to_redis(key_name=care_model_key_name,
+                                                       value=care_model_threshold_new, expire_time=2 * 24 * 3600)
+                        log_.info(f"abtest_id = {abtest_id}, abtest_config_tag = {abtest_config_tag}, "
+                                  f"abtest_group = {abtest_group}, group_key = {group_key}, "
+                                  f"care_model_threshold_old = {care_model_threshold_old}, "
+                                  f"care_model_threshold_new = {care_model_threshold_new}")
 
-def update_ad_abtest_threshold(project, table, dt, ad_abtest_abcode_config):
+
+def update_ad_abtest_threshold(project, table, dt, ad_abtest_abcode_config, ad_target_uv):
     # 获取当前阈值参数值
     threshold_record = redis_helper.get_data_from_redis(key_name=config_.KEY_NAME_PREFIX_AD_THRESHOLD_RECORD)
     threshold_record = eval(threshold_record)
@@ -95,36 +206,68 @@ def update_ad_abtest_threshold(project, table, dt, ad_abtest_abcode_config):
     # 获取uv数据
     feature_df = get_feature_data(project=project, table=table, features=features, dt=dt)
     feature_df['apptype'] = feature_df['apptype'].astype(int)
-    feature_df['b'] = feature_df['b'].astype(float)
-    # 根据活跃人数变化计算新的阈值参数
-    threshold_record_new, robot_msg_record = get_threshold_record_new(
-        ad_abtest_abcode_config=ad_abtest_abcode_config, feature_df=feature_df, threshold_record=threshold_record)
+    feature_df['广告uv'] = feature_df['广告uv'].astype(float)
+    # 根据广告uv变化计算新的阈值参数
+    threshold_record_new, robot_msg_record = get_threshold_record_new_by_uv(
+        ad_abtest_abcode_config=ad_abtest_abcode_config, feature_df=feature_df,
+        threshold_record=threshold_record, ad_target_uv=ad_target_uv)
     log_.info(f"threshold_record_new = {threshold_record_new}")
     # 更新阈值
     update_threshold(threshold_record_old=threshold_record, threshold_record_new=threshold_record_new)
     # 更新阈值参数
     redis_helper.set_data_to_redis(key_name=config_.KEY_NAME_PREFIX_AD_THRESHOLD_RECORD,
-                                   value=str(threshold_record_new))
+                                   value=str(threshold_record_new), expire_time=2 * 24 * 3600)
     return robot_msg_record
 
 
+def get_ad_target_uv():
+    """获取管理后台开启自动调整阈值开关的目标uv值"""
+    ad_target_uv = {}
+    result = request_get(request_url=config_.GET_AD_TARGET_UV_URL)
+    if result is None:
+        log_.info('获取管理后台广告目标uv值失败！')
+        return ad_target_uv
+    if result['code'] != 0:
+        log_.info('获取管理后台广告目标uv值失败！')
+        return ad_target_uv
+    if not result['content']:
+        return ad_target_uv
+    for item in result['content']:
+        app_type = item['productId']
+        target_uv_mapping = {}
+        for uv_item in item['uvTargetDetails']:
+            ab_group = uv_item['abParam']
+            target_uv = uv_item['uvTarget']
+            target_uv_mapping[ab_group] = target_uv
+        ad_target_uv[app_type] = target_uv_mapping
+    return ad_target_uv
+
+
 def timer_check():
     try:
+        # 获取自动调整阈值参数
         ad_abtest_abcode_config = config_.AD_ABTEST_ABCODE_CONFIG
         project = config_.AD_THRESHOLD_AUTO_UPDATE_DATA.get('project')
         table = config_.AD_THRESHOLD_AUTO_UPDATE_DATA.get('table')
         now_date = datetime.datetime.today()
         now_min = datetime.datetime.now().minute
         log_.info(f"now_date: {datetime.datetime.strftime(now_date, '%Y%m%d%H')}")
-        dt = datetime.datetime.strftime(now_date - datetime.timedelta(hours=1), '%Y%m%d%H')
+
+        # 管理后台获取开启自动调整阈值开关的目标uv值
+        ad_target_uv = get_ad_target_uv()
+        log_.info(f"ad_target_uv: {ad_target_uv}")
+        if len(ad_target_uv) == 0:
+            return
 
         # 查看当前更新的数据是否已准备好
+        dt = datetime.datetime.strftime(now_date - datetime.timedelta(hours=1), '%Y%m%d%H')
         data_count = data_check(project=project, table=table, dt=dt)
         if data_count > 0:
             log_.info(f"data count = {data_count}")
             # 数据准备好，进行更新
             robot_msg_record = update_ad_abtest_threshold(
-                project=project, table=table, dt=dt, ad_abtest_abcode_config=ad_abtest_abcode_config)
+                project=project, table=table, dt=dt,
+                ad_abtest_abcode_config=ad_abtest_abcode_config, ad_target_uv=ad_target_uv)
             if len(robot_msg_record) > 0:
                 robot_msg_record_text = "\n".join([str(item) for item in robot_msg_record])
                 msg = f"threshold_param_update: \n{robot_msg_record_text.replace(', ', ',   ')}\n"

ad_user_video_predict.py

@@ -61,7 +61,7 @@ def predict_video_share_rate(dt, app_type):
     return video_df
 
 
-def predict_ad_group_video(dt, config_key, config_param):
+def predict_ad_group_video(dt, config_key, config_param, threshold_record):
     log_.info(f"config_key = {config_key} update start ...")
     # 获取用户组预测值
     user_data_key = config_param['user'].get('data')
@@ -94,7 +94,8 @@ def predict_ad_group_video(dt, config_key, config_param):
         all_group_data.extend(predict_df[item['group']].tolist())
 
     # 计算对应的阈值
-    ad_threshold_mappings = config_.AD_ABTEST_THRESHOLD_CONFIG.get(config_key.split('-')[0])
+    # ad_threshold_mappings = config_.AD_ABTEST_THRESHOLD_CONFIG.get(config_key.split('-')[0])
+    ad_threshold_mappings = threshold_record.get(config_key.split('-')[0])
     for abtest_group, ad_threshold_mapping in ad_threshold_mappings.items():
         threshold_data = {}
         for _, item in group_df.iterrows():
@@ -132,17 +133,23 @@ def predict():
     now_date = datetime.datetime.today()
     dt = datetime.datetime.strftime(now_date, '%Y%m%d')
     log_.info(f"dt = {dt}")
+    # 获取阈值参数记录
+    threshold_record = redis_helper.get_data_from_redis(key_name=config_.KEY_NAME_PREFIX_AD_THRESHOLD_RECORD)
+    threshold_record = eval(threshold_record)
+    log_.info(f"threshold_record = {threshold_record}")
     params = config_.AD_ABTEST_CONFIG
-    threshold_record = {}
     for config_key, config_param in params.items():
-        predict_ad_group_video(dt=dt, config_key=config_key, config_param=config_param)
-        # 阈值参数记录
-        ad_threshold_mappings = config_.AD_ABTEST_THRESHOLD_CONFIG.get(config_key.split('-')[0])
-        for abtest_group, ad_threshold_mapping in ad_threshold_mappings.items():
-            threshold_record[f"{config_key}-{abtest_group}"] = ad_threshold_mapping['group']
+        predict_ad_group_video(dt=dt,
+                               config_key=config_key,
+                               config_param=config_param,
+                               threshold_record=threshold_record)
+    # 阈值参数记录
+    # redis_helper.set_data_to_redis(key_name=config_.KEY_NAME_PREFIX_AD_THRESHOLD_RECORD,
+    #                                value=str(config_.AD_ABTEST_THRESHOLD_CONFIG),
+    #                                expire_time=24*3600)
     redis_helper.set_data_to_redis(key_name=config_.KEY_NAME_PREFIX_AD_THRESHOLD_RECORD,
                                    value=str(threshold_record),
-                                   expire_time=24*3600)
+                                   expire_time=2 * 24 * 3600)
 
 
 if __name__ == '__main__':

config.py

@@ -719,7 +719,7 @@ class BaseConfig(object):
     # 自动调整广告模型阈值数据
     AD_THRESHOLD_AUTO_UPDATE_DATA = {
         'project': 'loghubods',
-        'table': 'visit_uv_hh'
+        'table': 'ad_view_monitor_hh_report_final'
     }
 
     # 调用广告模型appType列表
@@ -1014,62 +1014,141 @@ class BaseConfig(object):
         },
     }
 
-    # 广告模型abtest分组配置
+    # 广告模型自动调整阈值配置
     AD_ABTEST_ABCODE_CONFIG = {
         # 票圈vlog
-        # APP_TYPE['VLOG']: {
-        #     'ab_test_id': 173,
-        #     'ab_test_config': {"a": ["ab1"], "b": ["ab3", "ab4", "ab6", "ab7", "ab8"], "c": [], "d": ["ab2"]},
-        #     'threshold_update': 1/24,
-        # },
+        APP_TYPE['VLOG']: {
+            'ab_test_id': '173',
+            'not_update': 0.01,  # 无需调整阈值的uv浮动
+            'gradient': 0.05,  # 调整梯度
+            'max_update_step': 5,  # 最大调整步数
+            'threshold_update': {
+                'ab0': 1 / 48,
+                'ab1': 1 / 48,
+                'ab2': 1 / 48,
+                'ab3': 1 / 48,
+                'ab4': 1 / 48,
+                'ab5': 1 / 48,
+                'ab6': 1 / 48,
+                'ab7': 1 / 48,
+                'ab8': 1 / 48,
+                'ab9': 1 / 48,
+            },
+        },
         # 票圈视频+
-        # APP_TYPE['PIAO_QUAN_VIDEO_PLUS']: {
-        #     'ab_test_id': 190,
-        #     'ab_test_config': {"a": ["ab1"], "b": ["ab6", "ab7", "ab2", "ab3"]},
-        #     'threshold_update': 1 / 24,
-        # },
+        APP_TYPE['PIAO_QUAN_VIDEO_PLUS']: {
+            'ab_test_id': '190',
+            'not_update': 0.01,
+            'gradient': 0.05,
+            'max_update_step': 5,
+            'threshold_update': {
+                'ab0': 1 / 48,
+                'ab1': 1 / 48,
+                'ab2': 1 / 48,
+                'ab3': 1 / 48,
+                'ab4': 1 / 48,
+                'ab5': 1 / 48,
+                'ab6': 1 / 48,
+                'ab7': 1 / 48,
+                'ab8': 1 / 48,
+                'ab9': 1 / 48,
+            },
+        },
         # 票圈视频
         APP_TYPE['LOVE_LIVE']: {
-            'ab_test_id': 194,
-            'ab_test_config': {"a": ["ab6", "ab7", "ab8"], "b": ["ab3", "ab4"], "c": ["ab2"], "d": ["ab1"]},
-            'up_threshold_update': {
-                'a': {'gradient': 0.05, 'update_range': 1 / 24},
-                'b': {'gradient': 0.05, 'update_range': 1 / 24},
-                'c': {'gradient': 0.1, 'update_range': 1 / 192},
-                'd': {'gradient': 0.1, 'update_range': 1 / 192},
-            },
-            'down_threshold_update': {
-                'a': {'gradient': 0.1, 'update_range': 1 / 12},
-                'b': {'gradient': 0.1, 'update_range': 1 / 12},
-                'c': {'gradient': 0.1, 'update_range': 1 / 12},
-                'd': {'gradient': 0.1, 'update_range': 1 / 12},
+            'ab_test_id': '194',
+            'not_update': 0.01,
+            'gradient': 0.05,
+            'max_update_step': 5,
+            'threshold_update': {
+                'ab0': 1 / 48,
+                'ab1': 1 / 48,
+                'ab2': 1 / 48,
+                'ab3': 1 / 48,
+                'ab4': 1 / 48,
+                'ab5': 1 / 48,
+                'ab6': 1 / 48,
+                'ab7': 1 / 48,
+                'ab8': 1 / 48,
+                'ab9': 1 / 48,
             },
         },
         # 内容精选
-        # APP_TYPE['LONG_VIDEO']: {
-        #     'ab_test_id': 195,
-        #     'ab_test_config': {"b": [], "c": ["ab1", "ab2"]},
-        #     'threshold_update': 1 / 24,
-        # },
+        APP_TYPE['LONG_VIDEO']: {
+            'ab_test_id': '195',
+            'not_update': 0.01,
+            'gradient': 0.05,
+            'max_update_step': 5,
+            'threshold_update': {
+                'ab0': 1 / 48,
+                'ab1': 1 / 48,
+                'ab2': 1 / 48,
+                'ab3': 1 / 48,
+                'ab4': 1 / 48,
+                'ab5': 1 / 48,
+                'ab6': 1 / 48,
+                'ab7': 1 / 48,
+                'ab8': 1 / 48,
+                'ab9': 1 / 48,
+            },
+        },
         # 票圈短视频
-        # APP_TYPE['SHORT_VIDEO']: {
-        #     'ab_test_id': 196,
-        #     'ab_test_config': {"a": [], "b": [], "c": ["ab2", "ab3", "ab1", "ab9"]},
-        #     'threshold_update': 1 / 24,
-        # },
+        APP_TYPE['SHORT_VIDEO']: {
+            'ab_test_id': '196',
+            'not_update': 0.01,
+            'gradient': 0.05,
+            'max_update_step': 5,
+            'threshold_update': {
+                'ab0': 1 / 48,
+                'ab1': 1 / 48,
+                'ab2': 1 / 48,
+                'ab3': 1 / 48,
+                'ab4': 1 / 48,
+                'ab5': 1 / 48,
+                'ab6': 1 / 48,
+                'ab7': 1 / 48,
+                'ab8': 1 / 48,
+                'ab9': 1 / 48,
+            },
+        },
         # 老好看视频
-        # APP_TYPE['LAO_HAO_KAN_VIDEO']: {
-        #     'ab_test_id': 197,
-        #     'ab_test_config': {"a": ["ab0", "ab100", "ab6", "ab7", "ab8", "ab9"],
-        #                        "b": ["ab1", "ab2", "ab3",  "ab4", "ab5"]},
-        #     'threshold_update': 1 / 24,
-        # },
+        APP_TYPE['LAO_HAO_KAN_VIDEO']: {
+            'ab_test_id': '197',
+            'not_update': 0.01,
+            'gradient': 0.05,
+            'max_update_step': 5,
+            'threshold_update': {
+                'ab0': 1 / 48,
+                'ab1': 1 / 48,
+                'ab2': 1 / 48,
+                'ab3': 1 / 48,
+                'ab4': 1 / 48,
+                'ab5': 1 / 48,
+                'ab6': 1 / 48,
+                'ab7': 1 / 48,
+                'ab8': 1 / 48,
+                'ab9': 1 / 48,
+            },
+        },
         # 票圈最惊奇
-        # APP_TYPE['ZUI_JING_QI']: {
-        #     'ab_test_id': 198,
-        #     'ab_test_config': {"a": ["ab3", "ab6", "ab7"], "b": ["ab8", "ab9"]},
-        #     'threshold_update': 1 / 24,
-        # },
+        APP_TYPE['ZUI_JING_QI']: {
+            'ab_test_id': '198',
+            'not_update': 0.01,
+            'gradient': 0.05,
+            'max_update_step': 5,
+            'threshold_update': {
+                'ab0': 1 / 48,
+                'ab1': 1 / 48,
+                'ab2': 1 / 48,
+                'ab3': 1 / 48,
+                'ab4': 1 / 48,
+                'ab5': 1 / 48,
+                'ab6': 1 / 48,
+                'ab7': 1 / 48,
+                'ab8': 1 / 48,
+                'ab9': 1 / 48,
+            },
+        },
     }
 
     # 用户组有广告时的分享率预测结果存放 redis key 前缀，完整格式：ad:users:group:predict:share:rate:{user_data_key}:{user_rule_key}:{date}
@@ -1159,11 +1238,13 @@ class DevelopmentConfig(BaseConfig):
     NOTIFY_BACKEND_updateFallBackVideoList_URL = 'http://videotest-internal.yishihui.com/longvideoapi/openapi/recommend/updateFallBackVideoList'
     # 获取限流视频接口地址
     GET_VIDEO_LIMIT_LIST_URL = 'http://videotest-internal.yishihui.com/longvideoapi/openapi/recommend/getVideoLimitList'
+    # 获取管理后台设置的广告目标uv值接口地址
+    GET_AD_TARGET_UV_URL = 'https://testadmin.piaoquantv.com/manager/ad/algo/threshold/productUvTargetList'
 
-    # logs 上传oss 目标Bucket指定目录
-    OSS_FOLDER_LOGS = 'rov-offline/dev/logs/'
-    # data 上传oss 目标Bucket指定目录
-    OSS_FOLDER_DATA = 'rov-offline/dev/data/'
+    # # logs 上传oss 目标Bucket指定目录
+    # OSS_FOLDER_LOGS = 'rov-offline/dev/logs/'
+    # # data 上传oss 目标Bucket指定目录
+    # OSS_FOLDER_DATA = 'rov-offline/dev/data/'
 
 
 class TestConfig(BaseConfig):
@@ -1239,11 +1320,13 @@ class TestConfig(BaseConfig):
     NOTIFY_BACKEND_updateFallBackVideoList_URL = 'http://videotest-internal.yishihui.com/longvideoapi/openapi/recommend/updateFallBackVideoList'
     # 获取限流视频接口地址
     GET_VIDEO_LIMIT_LIST_URL = 'http://videotest-internal.yishihui.com/longvideoapi/openapi/recommend/getVideoLimitList'
+    # 获取管理后台设置的广告目标uv值接口地址
+    GET_AD_TARGET_UV_URL = 'https://testadmin.piaoquantv.com/manager/ad/algo/threshold/productUvTargetList'
 
-    # logs 上传oss 目标Bucket指定目录
-    OSS_FOLDER_LOGS = 'rov-offline/test/logs/'
-    # data 上传oss 目标Bucket指定目录
-    OSS_FOLDER_DATA = 'rov-offline/test/data/'
+    # # logs 上传oss 目标Bucket指定目录
+    # OSS_FOLDER_LOGS = 'rov-offline/test/logs/'
+    # # data 上传oss 目标Bucket指定目录
+    # OSS_FOLDER_DATA = 'rov-offline/test/data/'
 
 
 class PreProductionConfig(BaseConfig):
@@ -1319,11 +1402,13 @@ class PreProductionConfig(BaseConfig):
     NOTIFY_BACKEND_updateFallBackVideoList_URL = 'http://videopre-internal.piaoquantv.com/longvideoapi/openapi/recommend/updateFallBackVideoList'
     # 获取限流视频接口地址
     GET_VIDEO_LIMIT_LIST_URL = 'http://prespeed-internal.piaoquantv.com/longvideoapi/openapi/recommend/getVideoLimitList'
+    # 获取管理后台设置的广告目标uv值接口地址
+    GET_AD_TARGET_UV_URL = 'https://preadmin.piaoquantv.com/manager/ad/algo/threshold/productUvTargetList'
 
-    # logs 上传oss 目标Bucket指定目录
-    OSS_FOLDER_LOGS = 'rov-offline/pre/logs/'
-    # data 上传oss 目标Bucket指定目录
-    OSS_FOLDER_DATA = 'rov-offline/pre/data/'
+    # # logs 上传oss 目标Bucket指定目录
+    # OSS_FOLDER_LOGS = 'rov-offline/pre/logs/'
+    # # data 上传oss 目标Bucket指定目录
+    # OSS_FOLDER_DATA = 'rov-offline/pre/data/'
 
 
 class ProductionConfig(BaseConfig):
@@ -1399,11 +1484,13 @@ class ProductionConfig(BaseConfig):
     NOTIFY_BACKEND_updateFallBackVideoList_URL = 'http://recommend-common-internal.piaoquantv.com/longvideoapi/openapi/recommend/updateFallBackVideoList'
     # 获取限流视频接口地址
     GET_VIDEO_LIMIT_LIST_URL = 'http://recommend-common-internal.piaoquantv.com/longvideoapi/openapi/recommend/getVideoLimitList'
+    # 获取管理后台设置的广告目标uv值接口地址
+    GET_AD_TARGET_UV_URL = 'https://admin.piaoquantv.com/manager/ad/algo/threshold/productUvTargetList'
 
-    # logs 上传oss 目标Bucket指定目录
-    OSS_FOLDER_LOGS = 'rov-offline/pro/logs/'
-    # data 上传oss 目标Bucket指定目录
-    OSS_FOLDER_DATA = 'rov-offline/pro/data/'
+    # # logs 上传oss 目标Bucket指定目录
+    # OSS_FOLDER_LOGS = 'rov-offline/pro/logs/'
+    # # data 上传oss 目标Bucket指定目录
+    # OSS_FOLDER_DATA = 'rov-offline/pro/data/'
 
 
 def set_config():

utils.py

@@ -153,6 +153,30 @@ def request_post(request_url, request_data=None, **kwargs):
         return None
 
 
+def request_get(request_url):
+    """
+    get 请求 HTTP接口
+    :param request_url: 接口URL
+    :return: res_data json格式
+    """
+    try:
+        response = requests.get(url=request_url)
+        if response.status_code == 200:
+            res_data = json.loads(response.text)
+            return res_data
+        else:
+            log_.info(f"response.status_code: {response.status_code}")
+            return None
+    except Exception as e:
+        log_.error('url: {}, exception: {}, traceback: {}'.format(request_url, e, traceback.format_exc()))
+        send_msg_to_feishu(
+            webhook=config_.FEISHU_ROBOT['server_robot'].get('webhook'),
+            key_word=config_.FEISHU_ROBOT['server_robot'].get('key_word'),
+            msg_text='rov-offline{} - 接口请求失败：{}, exception: {}'.format(config_.ENV_TEXT, request_url, e)
+        )
+        return None
+
+
 def data_normalization(data):
     """
     对结果做归一化处理(Min-Max Normalization)，将分数控制在[0, 100]