datawhale WIDE&DEEP学习笔记
CTR就是广告点击率，click through rate
deepcrossing的特征交叉，是能够实现一种记忆能力的，它能够记住共现频率高的特征组合，但是不能基于此探索新的特征组合。针对前面的deepcrossing存在的：有一些特征没有被充分学习，因此产生的embedding 向量不准确，因此会导致模型泛化过度的问题，WIDE&DEEP这一模型就被引进，该模型围绕记忆性和泛化性，能从历史数据中学习到高频共现的特征组合。
模型的memorization：指的是模型能够从历史数据中学习高频出现的特征组合的能力。
模型的generalization：指的是模型能利用特征之间的传递性去探索新的特征组合。
wide%deep模型的结构原理
就是这个模型分为wide和deep两个部分，我们要有选择的将特征放入wide或者deep部分。
怎么样构建特征组合呢？比如说将是否是大学生和是否拥有爱奇艺会员作为两个特征，将其合并，那么只有同时满足是大学生和是爱奇艺会员这个新特征才是1，否则这个新特征的值就是0，这就实现了两个特征的组合。
在线学习
在线学习算法的特点就是每来一个训练样本，就用该样本产生的loss和梯度对模型迭代一次，一个一个数据地进行训练，因此可以处理大数据量训练和在线训练。常用的有在线梯度下降（OGD）和随机梯度下降（SGD）等，是对单个数据的损失函数进行梯度下降，但是并不是每一步的方向都是最优的。
wide层
wide层使用了FTRL算法，这个算法使得通过wide层的特征尽量少，也就是让wide部分尽量稀疏，因此能通过wide层的特征都属于很重要的特征，wide层输入的特征可能是单一特征也可以是组合特征。wide部分体现了模型的记忆能力，他提取的特征属于那种直接的、显然的关联规则。
wide层其实就是将已经存在的单一特征或者组合特征进行一种选择吧，现有的所有的特征能通过wide层的都必然会被保留着进入模型，这就体现出了模型的记忆能力，对原始特征的一种保留。
deep层
deep层就是深度学习模型，数值特征直接输入DNN，类别特征要经过embedding然后在输入模型。DEEP层体现出了wide&deep模型的一种泛化能力，因为我们可以知道，随着dnn模型层数增加，提取出的特征就越抽象，因此模型的泛化能力会越高。DNN模型作者使用了深度学习常用的优化器AdaGrad
wide与deep的结合
wide部分增强了模型的记忆能力，其保留了模型原来就有的那些单一特征或者组合特征；deep模型增强了模型的泛化能力，随着层数的增加，学习出来的特征就越抽象，这些特征就会增强模型的泛化性能。
因此wide&deep模型将这两部分输出的特征一起进行训练，使用一个逻辑回归做最终的预测，就会保持记忆和泛化能力。
因为Wide侧的数据是高维稀疏的，所以作者使用了FTRL算法优化，而Deep侧使用的是 Adagrad
FTRL算法
link
这个连接里面，对fobos,rda,ftrl都做了说明
ADAGRAD
思考题：
1、在你的应用场景中，哪些特征适合放在Wide侧，哪些特征适合放在Deep侧，为什么呢？
一些明显的直接的特征，能够发现高频、常见模式的特征应该放在wide层，但是如果我们想要从某些特征中学习出一些新特征，我们就要将其放入deep层。比如说预测广告的点击概率，性别、年龄、学历、地区和性别、、、这些就放入WIDE层，像是家里是否有老人、是否有小孩、每天工作时间、、、、这些想要从中提取出能帮助预测的特征的就将其放入deep层。
2、为什么Wide部分要用L1 FTRL训练？
应该是为了尽量让特征稀疏，筛选出那些最具有代表性的特征。
3、为什么Deep部分不特别考虑稀疏性的问题？
因为deep部分筛选出来的特征是一种抽象的特征，是为了从原来的特征里发现一些新的联系，从已经存在的特征里发现暗含的一种新特征，所以是不需要考虑特征的稀缺性的。
代码实现：
#导入需要的库
import warnings
warnings.filterwarnings("ignore")
import itertools
import pandas as pd
import numpy as np
from tqdm import tqdm
from collections import namedtuple
import tensorflow as tf
from tensorflow.keras.layers import *
from tensorflow.keras.models import *
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import MinMaxScaler, LabelEncoder
from utils import SparseFeat, DenseFeat, VarLenSparseFeat
# 简单处理特征，包括填充缺失值，数值处理，类别编码
#dense_features指的是数值特征数据，sparse指的是类别型数据
def data_process(data_df, dense_features, sparse_features):
data_df[dense_features] = data_df[dense_features].fillna(0.0)
#这一步是为了实现数值的平滑
for f in dense_features:
data_df[f] = data_df[f].apply(lambda x: np.log(x+1) if x > -1 else -1)
data_df[sparse_features] = data_df[sparse_features].fillna("-1")#补充缺失值
for f in sparse_features:
lbe = LabelEncoder()
data_df[f] = lbe.fit_transform(data_df[f])
#fit（）是为了求得训练集X的均值，方差，最大值，最小值,这些训练集X固有的属性
#transform（）：在fit的基础上，进行标准化，降维，归一化等操作
#fit_transform():部分数据先拟合fit，找到该part的整体指标，如均值、方差、
#最大值最小值等等（根据具体转换的目的），然后对该trainData进行转换transform，从而实现数据的标准化、归一化等等。
return data_df[dense_features + sparse_features]
##这步其实就是输出字典查看我们一共有多少个原始的特征
def build_input_layers(feature_columns):
"""
构建输入层
param feature_columns: 数据集中的所有特征对应的特征标记值
"""
# 构建Input层字典，并以dense数值型特征和sparse类型特征两类字典的形式返回
dense_input_dict, sparse_input_dict = {}, {}
for fc in feature_columns:
if isinstance(fc, SparseFeat):
sparse_input_dict[fc.name] = Input(shape=(1, ), name=fc.name)
elif isinstance(fc, DenseFeat):
dense_input_dict[fc.name] = Input(shape=(fc.dimension, ), name=fc.name)
return dense_input_dict, sparse_input_dict
##embedding层只是输入类别特征，数值型特征是不进行embedding的
##embedding层将类别特征进行探索，发现这些特征的内在关系，这是一种泛化性的提升
def build_embedding_layers(feature_columns, input_layers_dict, is_linear):
# 定义一个embedding层对应的字典
embedding_layers_dict = dict()
# 将特征中的sparse特征筛选出来
sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), feature_columns)) if feature_columns else []
# 如果是用于线性部分的embedding层，其维度为1，否则维度就是自己定义的embedding维度
if is_linear:
for fc in sparse_feature_columns:
embedding_layers_dict[fc.name] = Embedding(fc.vocabulary_size + 1, 1, name='1d_emb_' + fc.name)
else:
for fc in sparse_feature_columns:
embedding_layers_dict[fc.name] = Embedding(fc.vocabulary_size + 1, fc.embedding_dim, name='kd_emb_' + fc.name)
return embedding_layers_dict
# 将所有的sparse特征embedding拼接
def concat_embedding_list(feature_columns, input_layer_dict, embedding_layer_dict, flatten=False):
# 将sparse特征筛选出来
sparse_feature_columns = list(filter(lambda x: isinstance(x, SparseFeat), feature_columns))
embedding_list = []
for fc in sparse_feature_columns:
_input = input_layer_dict[fc.name] # 获取输入层
_embed = embedding_layer_dict[fc.name] # B x 1 x dim 获取对应的embedding层
embed = _embed(_input) # B x dim 将input层输入到embedding层中
# 是否需要flatten, 如果embedding列表最终是直接输入到Dense层中，需要进行Flatten，否则不需要
if flatten:
embed = Flatten()(embed)
embedding_list.append(embed)
return embedding_list
# DNN残差块的定义
class ResidualBlock(Layer):
def __init__(self, units): # units表示的是DNN隐藏层神经元数量
super(ResidualBlock, self).__init__()
self.units = units
def build(self, input_shape):
out_dim = input_shape[-1]
self.dnn1 = Dense(self.units, activation='relu')
self.dnn2 = Dense(out_dim, activation='relu') # 保证输入的维度和输出的维度一致才能进行残差连接
def call(self, inputs):
x = inputs
x = self.dnn1(x)
x = self.dnn2(x)
x = Activation('relu')(x + inputs) # 残差操作
return x
# block_nums表示DNN残差块的数量
def get_dnn_logits(dnn_inputs, block_nums=3):
dnn_out = dnn_inputs
for i in range(block_nums):
dnn_out = ResidualBlock(64)(dnn_out)
# 将dnn的输出转化成logits
dnn_logits = Dense(1, activation='sigmoid')(dnn_out)
return dnn_logits
def DeepCrossing(dnn_feature_columns):
# 构建输入层，即所有特征对应的Input()层，这里使用字典的形式返回，方便后续构建模型
dense_input_dict, sparse_input_dict = build_input_layers(dnn_feature_columns)
# 构建模型的输入层，模型的输入层不能是字典的形式，应该将字典的形式转换成列表的形式
# 注意：这里实际的输入与Input()层的对应，是通过模型输入时候的字典数据的key与对应name的Input层
input_layers = list(dense_input_dict.values()) + list(sparse_input_dict.values())
# 构建维度为k的embedding层，这里使用字典的形式返回，方便后面搭建模型
embedding_layer_dict = build_embedding_layers(dnn_feature_columns, sparse_input_dict, is_linear=False)
#将所有的dense特征拼接到一起
dense_dnn_list = list(dense_input_dict.values())
dense_dnn_inputs = Concatenate(axis=1)(dense_dnn_list) # B x n (n表示数值特征的数量)
# 因为需要将其与dense特征拼接到一起所以需要Flatten，不进行Flatten的Embedding层输出的维度为：Bx1xdim
sparse_dnn_list = concat_embedding_list(dnn_feature_columns, sparse_input_dict, embedding_layer_dict, flatten=True)
sparse_dnn_inputs = Concatenate(axis=1)(sparse_dnn_list) # B x m*dim (n表示类别特征的数量，dim表示embedding的维度)
# 将dense特征和Sparse特征拼接到一起
dnn_inputs = Concatenate(axis=1)([dense_dnn_inputs, sparse_dnn_inputs]) # B x (n + m*dim)
# 输入到dnn中，需要提前定义需要几个残差块
output_layer = get_dnn_logits(dnn_inputs, block_nums=3)
model = Model(input_layers, output_layer)
return model
if __name__ == "__main__":
# 读取数据
data = pd.read_csv('./data/criteo_sample.txt')
# 划分dense和sparse特征
columns = data.columns.values
dense_features = [feat for feat in columns if 'I' in feat]
sparse_features = [feat for feat in columns if 'C' in feat]
# 简单的数据预处理
train_data = data_process(data, dense_features, sparse_features)
train_data['label'] = data['label']
# 将特征做标记
dnn_feature_columns = [SparseFeat(feat, vocabulary_size=data[feat].nunique(),embedding_dim=4)
for feat in sparse_features] + [DenseFeat(feat, 1,)
for feat in dense_features]
# 构建DeepCrossing模型
history = DeepCrossing(dnn_feature_columns)
history.summary()
history.compile(optimizer="adam",
loss="binary_crossentropy",
metrics=["binary_crossentropy", tf.keras.metrics.AUC(name='auc')])
# 将输入数据转化成字典的形式输入
train_model_input = {name: data[name] for name in dense_features + sparse_features}
# 模型训练
history.fit(train_model_input, train_data['label'].values,
batch_size=64, epochs=5, validation_split=0.2, )
扫一扫
306
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
