2018科大讯飞营销广告算法大赛
2018讯飞广告营销算法
本次的最终是一个分类任务，评价指标选择为logloss,以前虽然做过一些分类性的任务，但任务本身难度不大，而本次第一个主要的问题就是数据量大，尤其是在最终的建模中，以前靠只靠cpu版本的XGBoost和Stacking就能得到一个不错的trade-off，而本次任务在Cpu的情况下，就需要花费更多的时间了,所以,重新编译安装了GPU版本的XGBoost，并首次尝试使用了LightGBM(GPU)，其性能多方面优先与XGBoost，所以，最后选择使用了LightGBM模型，注：文中张贴非完整代码，完整代码及参考见文末。
赛题背景
讯飞AI营销云在高速发展的同时，积累了海量的广告数据和用户数据，如何有效利用这些数据去预测用户的广告点击概率，是大数据应用在精准营销中的关键问题，也是所有智能营销平台必须具备的核心技术。
本次大赛提供了讯飞AI营销云的海量广告投放数据，参赛选手通过人工智能技术构建预测模型预估用户的广告点击概率，即给定广告点击相关的广告、媒体、用户、上下文内容等信息的条件下预测广告点击概率。希望通过本次大赛挖掘AI营销算法领域的顶尖人才，共同推动AI营销的技术革新。
EDA
查看时间与点击量的相关信息
# 处理时间戳函数
def get_time(attr):
"""从时间戳获得具体的时间信息"""
day = []
hour = []
for time in attr:
t = datetime.datetime.fromtimestamp(time + 3600*24*5) #加5天
day.append(t.day)
hour.append(t.hour)
return day, hour
train_df = train.copy()
train_df["day"], train_df["hour"] = get_time(train_df.time.values)
# 绘制不同时刻的点击情况
hour_info = train_df.groupby(["hour", "click"])["hour"].count()
hour_info = hour_info.unstack() #构成数映射表
hour_info[[0, 1]].plot(kind="bar", stacked=True, figsize=(12, 6)) # stacked堆叠显示
plt.show()
hour_info.plot(figsize=(12,6))
plt.xticks(np.arange(0, 24, 6))
plt.title("The plot of click in different hour", fontsize=15)
plt.show()
结论: 具体每一个时间的点击率有所不同(将连续的时间离散化),可以将时间划分为四个不同的时间间隔,间隔六小时
不同时间段的点击情况
def seg_hour(x):
"""划分时间间隔"""
if x > 0 and x <= 6:
return 1
elif x > 6 and x <= 12:
return 2
elif x > 12 and x <= 18:
return 3
else:
return 4
train_df["hour_seg"] = train_df.hour.apply(lambda x:seg_hour(x))
seg_hour = train_df.groupby(["hour_seg", "click"]).hour_seg.count().unstack()
seg_hour[[0, 1]].plot(kind="bar")
plt.show()
结论:对用户的分时段之后可以看出用户时间分布情况。
查看样本的均衡情况
plt.figure(figsize=(5, 5))
cnt_click = train_df.click.value_counts()
plt.pie(x=cnt_click
, labels=[0, 1]
, autopct="%1.1f%%"
, explode=[0.1, 0]
, startangle=90
)
plt.title("Click")
plt.show()
结论:样布不均衡,正负样本1:4,少数类为点击，希望捕获少数类。
广告长宽与点击情况
sns.stripplot(x="click", y="creative_height", data=train_df)
plt.show()
sns.stripplot(train_df.click, train_df.creative_width)
plt.show()
结论:人们趋向于点击广告大小适中的广告，长宽在500以下比较集中
探索布尔型变量对结果的影响
# 打印bool类型数据
bool_feture = []
cols = data.columns
for col in cols:
if str(train_df[col].dtype) == 'bool':
print(col)
bool_feture.append(str(col))
creative_is_jump
creative_is_download
creative_is_js
creative_is_voicead
creative_has_deeplink
app_paid
def plot_ratio(df, name1, name2):
gropy_n = df.groupby([name1, name2])[name1].count().unstack()
print(gropy_n)
print()
gropy_n[[0, 1]].plot(kind="bar")
plt.xlabel(name1)
plt.ylabel(name2 + "_" + "counts")
plt.show()
# 是否是语音广告
plot_ratio(train_df, "creative_is_voicead", "click")
click 0 1
creative_is_voicead
False 2397237 595402
# 是否是js素材
plot_ratio(train_df, "creative_is_js", "click")
click 0 1
creative_is_js
False 2397237 595402
# app是否收费
plot_ratio(train_df, "app_paid", "click")
click 0 1
app_paid
False 2397237 595402
# 是否落地页跳转
plot_ratio(train_df, "creative_is_jump", "click")
click 0 1
creative_is_jump
False 56805 690
True 2340432 594712
# 是否落地页下载
plot_ratio(train_df, "creative_is_download", "click")
click 0 1
creative_is_download
False 2340432 594712
True 56805 690
# 是否有deeplink
plot_ratio(train_df, "creative_has_deeplink", "click")
click 0 1
creative_has_deeplink
False 2396401 595348
True 836 54
结论：从生成的结果来看，这三种(creative_is_voicead、creative_is_js、 app_paid)bool型特征的值为单个值，无法通过变化来影响是否点击，所以，理论上可以删除。而对于creative_is_jump和creative_is_download是互补关系，可以选择保留其中一个特征
数据预处理
删除冗余数据
del data["instance_id"]
del data["creative_is_js"]
del data["app_paid"]
del data["creative_is_voicead"]
del train
del test
处理时间变量
将时间戳类型的输出抽取为更细的时间参数,并分区
def seg_hour(x):
"""划分时间间隔"""
if x > 0 and x <= 6:
return 1
elif x > 6 and x <= 12:
return 2
elif x > 12 and x <= 18:
return 3
else:
return 4
# 时间向下细分
data["day"], data["hour"] = get_time(data.time.values)
data["hour_part"] = data["hour"].apply(lambda x: seg_hour(x)) # 组合特征
# 删除时间列
del data["time"]
手机品牌处理
清洗手机品牌和机型字段，对同类型进行合并（redmi->xiaomi, honour->huawei）
# 名称装换为小写
col = []
for va in data["make"].values:
va = str(va)
if "," in va:
col.append(va.split(",")[0].lower())
elif "-"in va:
col.append(va.split("-")[0].lower())
elif " " in va:
col.append(va.split(" ")[0].lower())
else:
col.append(va.lower())
# 修改同类品牌的下的子品牌
for index in range(len(col)):
if "apple" in col[index]:
col[index] = "apple"
elif "redmi" in col[index]:
col[index] = "xiaomi"
elif "honor" == col[index]:
col[index] = "huawei"
elif col[index] == "mi":
col[index] = "xiaomi"
elif col[index] == "nan":
col[index] == np.nan
elif col[index] == "meitu":
col[index] == "meizu"
elif col[index] == "le" or col[index] == "letv" or col[index] == "lemobile" or col[index] == "blephone":
col[index] == "leshi"
data["new_make"] = col
手机机型处理
# 机型数据统一化处理
lst = []
for va in data.model.values:
va = str(va)
if "-" in va:
lst.append(va.replace('-', " "))
elif "+" in va:
lst.append(va.replace("+", " "))
elif "," in va:
lst.append(va.replace(",", " "))
elif va == "nan":
lst.append(np.nan)
else:
lst.append(va)
data["new_model"] = lst
广告主行业划分
形式：教育＿培训(划分)
lst1 = []
lst2 = []
for va in data.advert_industry_inner.values:
lst1.append(va.split("_")[0])
lst2.append(va.split("_")[1])
data["advert_industry_inner1"] = lst1
data["advert_industry_inner2"] = lst2
媒体广告位置划分
如xf, iqy
lst = []
for va in data.inner_slot_id.values:
lst.append(va.split("_")[0])
data["inner_slot_id1"] = lst
操作系统
# plt.pie(data.os.value_counts())
plt.figure(figsize=(5, 5))
percent = data.os.value_counts()
plt.pie(x=percent
, labels=["Andiord", "iOS", "Other"]
, autopct="%1.2f%%"
, startangle=90
, rotatelabels=True
)
plt.show()
# 其他类型操作系统比重极少，可将其归为安卓类
data.os.replace(0, 2, inplace=True)
…
查看缺失值情况
Total = data.isnull().sum().sort_values(ascending=False)
Percent = (data.isnull().sum()/data.isnull().count()).sort_values(ascending=False)*100
missing_data = pd.concat([Total, Percent], axis=1, keys=["Total", "Percent"])
# 可视化缺失值
index = 10
fig, ax = plt.subplots(figsize=(12, 6))
sns.barplot(x=missing_data[:index].index, y=missing_data.Percent[:index], hue_order=True)
plt.xticks(rotation=90)
plt.xlabel("missing_features", fontsize=14)
plt.ylabel("Percent", fontsize=14)
plt.title("The percent of missing_feature", fontsize=16)
plt.show()
特征编码
特征类型分析
use_tags表示唯一性,不要编码
creative_width, creative_height :属于数值型特征变量不需要进行编码
creative_is_jump, creative_is_download, creative_has_deeplink :0, 1
day :一周
click :目标 [0, 1]
hour_part :[1, 2, 3, 4]
osv1, osv2, osv3 :类别型数值变量
from sklearn.preprocessing import LabelEncoder
# 打印object类型数据
bool_feture = []
cols = data.columns
for col in cols:
if str(data[col].dtype) == 'object':
print(col)
bool_feture.append(str(col))
type_feature = ['city', 'province', 'carrier', 'devtype', 'make', 'model',
'nnt', 'os', 'osv', 'os_name', 'adid', 'advert_id', 'orderid',
'advert_industry_inner', 'campaign_id', 'creative_id',
'creative_tp_dnf', 'app_cate_id', 'f_channel', 'app_id',
'inner_slot_id', 'creative_type',
'advert_name', 'hour', 'new_make',
'advert_industry_inner1', 'advert_industry_inner2',
'inner_slot_id1', 'user_id', 'new_model', 'os_name1']
# 标签编码
for feature in type_feature:
try:
data[feature] = LabelEncoder().fit_transform(data[feature].fillna(-1).apply(int)) # 字符型数值转为int类型
except:
data[feature] = LabelEncoder().fit_transform(data[feature].fillna("-1"))
处理数据
# 取出训练集数据索引
train_index = data[data.click != -1].index
test_index = data[data.click == -1].index
train_y = pd.Series(data=data.loc[train_index, "click"])
train = data.iloc[train_index, :]
test = data.iloc[test_index, :]
del test["click"]
del train["click"]
建模
LightGBM
- 确定任务类型(回归、分类、排序等)，以及基学习器的类型(dark, gbdt、RF)
- 首先选择较高的学习率，大概0.1附近，这样是为了加快收敛的速度。这对于调参是很有必要的。
- 对决策树基本参数调参
- 正则化参数调参
- 最后降低学习率，这里是为了最后提高准确率
data_train = lgb.Dataset(train_df, y)
初始化状态(未调参)
# 参数设定为默认状态
params1 = {
"boosting_type": "gbdt"
, "objective": "binary" # 二分类任务
, "metric": {
"binary_logloss", "auc"}
, "nthread": 4
, "device": "gpu"
, "gpu_device_id": 1
, "verbose": 1
, "learning_rate": 0.1
, "max_depth": 5
, "num_leaves": 31 # 由于lightGBM是leaves_wise生长，官方说法是要小于2^max_depth
, "subsample": 1.0 # 数据采样
, "colsample_bytree": 1.0 # 特征采样
, 'reg_alpha': 0.0 # L1
, 'reg_lambda': 0.0 # L2
}
t0 = time()
cv_result1 = lgb.cv(params=params1, train_set=data_train
, nfold=5
, stratified=True
, shuffle=True
# , metrics="binary_logloss"
, seed=0
)
print("参数处理时间：",datetime.datetime.fromtimestamp(time()-t0).strftime("%M:%S:%f"))
参数处理时间： 01:06:799278
调整好的参数状态
num_boost_round = 3000
params2 = {
"boosting_type": "gbdt"
, "objective": "binary" # 二分类任务
, "metric": {
"binary_logloss", "auc"}
, "nthread": 4
, "device": "gpu"
, "gpu_device_id": 1
, "verbose": 1
, "learning_rate": 0.01
, "max_depth": 6
, "num_leaves": 41 # 由于lightGBM是leaves_wise生长，官方说法是要小于2^max_depth
, "subsample": 0.8 # 数据采样
, "colsample_bytree": 0.8 # 特征采样
, 'reg_alpha': 0.0 # L1
, 'reg_lambda': 0.0 # L2
}
t0 = time()
cv_result2 = lgb.cv(params=params2, train_set=data_train
, num_boost_round=num_boost_round
, nfold=5
, stratified=True
, shuffle=True
# , metrics="binary_logloss"
# , early_stopping_rounds=50
, seed=0
)
print("参数处理时间：",datetime.datetime.fromtimestamp(time()-t0).strftime("%M:%S:%f"))
参数处理时间： 28:52:279001
# 选择最佳的estimators
print("Best_n_estimators: %d\nBest_cv_score: %.4f"
% (np.array(list(cv_result2.values())).shape[1],
min(np.array(list(cv_result2.values()))[0]))
)
Best_n_estimators: 3000
Best_cv_score: 0.4166
调参数状态
params3 = {
"boosting_type": "gbdt"
, "objective": "binary" # 二分类任务
, "metric": {
"binary_logloss", "auc"}
, "nthread": 4
, "device": "gpu"
, "gpu_device_id": 1
, "verbose": 1
, "learning_rate": 0.01
, "max_depth": 6
, "num_leaves": 31 # 由于lightGBM是leaves_wise生长，官方说法是要小于2^max_depth
, "subsample": 0.8 # 数据采样
, "colsample_bytree": 0.8 # 特征采样
, 'reg_alpha': 0.0 # L1
, 'reg_lambda': 0.0 # L2
}
t0 = time()
cv_result3 = lgb.cv(params=params3, train_set=data_train
, num_boost_round=3000
, nfold=5
, stratified=True
, shuffle=True
# , metrics="binary_logloss"
# , early_stopping_rounds=50
, seed=0
)
print("处理时间：",datetime.datetime.fromtimestamp(time()-t0).strftime("%M:%S:%f"))
处理时间： 27:40:536119
可视化指标
1. logloss指标
fig, ax = plt.subplots(1, 2, figsize = (14,5))
length1 = np.array(list(cv_result1.values())).shape[1]
length2 = np.array(list(cv_result2.values())).shape[1]
length3 = np.array(list(cv_result3.values())).shape[1]
ax[0].plot(range(length1), cv_result1[list(cv_result1.keys())[0]], label="param1", c="red")
ax[1].plot(range(length1), cv_result1[list(cv_result1.keys())[1]], label="param1", c="green")
ax[0].plot(range(length2), cv_result2[list(cv_result2.keys())[0]], label="param2", c="magenta")
ax[1].plot(range(length2), cv_result2[list(cv_result2.keys())[1]], label="param2", c="blue")
ax[0].plot(range(length3), cv_result3[list(cv_result3.keys())[0]], label="param3", c="yellow")
ax[1].plot(range(length3), cv_result3[list(cv_result3.keys())[1]], label="param3", c="c")
ax[0].set_xlabel("num_round", fontsize=12)
ax[1].set_xlabel("num_round", fontsize=12)
ax[0].set_ylabel(list(cv_result1.keys())[0], fontsize=12)
ax[1].set_ylabel(list(cv_result1.keys())[1], fontsize=12)
ax[0].set_ylim((0.37, 0.5))
ax[0].legend()
ax[1].legend()
plt.show()
2. AUC指标
fig, ax = plt.subplots(1, 2, figsize = (14,5))
length1 = np.array(list(cv_result1.values())).shape[1]
length2 = np.array(list(cv_result2.values())).shape[1]
length3 = np.array(list(cv_result3.values())).shape[1]
ax[0].plot(range(length1), cv_result1[list(cv_result1.keys())[2]], label="param1", c="red")
ax[1].plot(range(length1), cv_result1[list(cv_result1.keys())[3]], label="param1", c="green")
ax[0].plot(range(length2), cv_result2[list(cv_result2.keys())[2]], label="param2", c="magenta")
ax[1].plot(range(length2), cv_result2[list(cv_result2.keys())[3]], label="param2", c="blue")
ax[0].plot(range(length3), cv_result3[list(cv_result3.keys())[2]], label="param3", c="yellow")
ax[1].plot(range(length3), cv_result3[list(cv_result3.keys())[3]], label="param3", c="c")
ax[0].set_xlabel("num_round", fontsize=12)
ax[1].set_xlabel("num_round", fontsize=12)
ax[0].set_ylabel(list(cv_result1.keys())[2], fontsize=12)
ax[1].set_ylabel(list(cv_result1.keys())[3], fontsize=12)
ax[0].set_ylim((0.74, 0.78))
ax[0].legend()
ax[1].legend()
plt.show()
最终预测结果
# 最终预测
t0 = time()
lgb_c = lgb.train(params=params2, train_set=data_train
, num_boost_round=8000
# , nfold=5
# , stratified=True
# , shuffle=True
# , metrics="binary_logloss"
# , early_stopping_rounds=50
# , seed=0
)
print("处理时间：",datetime.datetime.fromtimestamp(time()-t0).strftime("%M:%S:%f"))
处理时间： 08:23:193281
探索性分析
特征重要性
feature_importance = [*zip(lgbc.feature_name(),lgbc.feature_importance())]
df = pd.DataFrame(feature_impoetance, columns=["feature", "importance socre"])
df.plot(kind="bar",figsize = (14, 8))
plt.plot(np.arange(0, 38), [13000]*38, c="r", linestyle="--", label = "base_line")
plt.xticks(np.arange(0, 38), df.feature.tolist(),fontsize=12)
plt.legend()
plt.show()
总结
本次实现过程主要参考该算法比赛第一名的算法思路，在建模阶段由于对原作者的设计思路，自己仍处于研究阶段，所以，后续若更改会随时更新。
参考
2018科大讯飞AI营销算法大赛总结及完整代码（冠军)
2018科大讯飞营销算法大赛（冠军方案)
DC竞赛
2018科大讯飞AI营销算法大赛(31名代码)
pandas之 read_table函数读取txt文件
LightGBM 中文文档
XGBoost Documentation