本章节从推荐系统模型搭建基础和DeepCrossing原理讲解及实操两方面展开。
keras搭建模型主要有两种模式，一种是Sequential API，另外一种是Functional API。前者主要是通过层的有序堆叠形成一个模型，在大多数情况下可以快速的搭建一个模型，但是搭建的模型更适合简单的堆叠模型，对于复杂模型(多输入、多输出、共享层)的搭建就比较困难，所以后者函数式API可以更加灵活的搭建复杂网络，函数式API搭建模型是通过创建层的实例并将将层与层之间连接在一起，最后只需要指定模型的输入和输出就可以完成模型的搭建，不同层的实例可以表示不同的操作，搭建模型的时候只需要考虑层与层之间的关系，以及复杂层的搭建就可以很方便的搭建起一个复杂网络。
Sequential API Demo
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
# 定义一个3层的序列模型
model = keras.Sequential(
[
layers.Dense(2, activation="relu", name="layer1"),
layers.Dense(3, activation="relu", name="layer2"),
layers.Dense(4, name="layer3"),
]
)
# 定义数据
x = tf.random.normal((3, 4))
y = model(x)
Functional API Demo
# 定义输入层(可以看成数据层)
inputs = keras.Input(shape=(784,))
# 定义模型逻辑层(将输入数据进行转换)
x = layers.Dense(64, activation="relu")(inputs)
# 定义输出层，这里其实和其他的层没有区别，只不过是最后认定这一层作为输出层而已
outputs = layers.Dense(10)(x)
# 定义整个模型，通过制定模型的输入和输出，按照前面所说的构建模型的流程，产生最终的模型结构
model = Model(inputs=inputs,outputs=outputs)
注意：
layers.Dense(64, activation=“relu”)表示的是一个Dense层实例，括号中的参数就是创建Dense实例的参数，将inputs输入到layers.Dense(64, activation=“relu”)实例中，会自动的调用实例的__call__()方法，这样就把输入和层与层之间的逻辑给确定了。
所以函数API搭建模型的基本操作就是，将输入数据输入到层的实例中，层对象就会调用该层的call方法完成该层的计算并产生新的输出，接下来再将产生的新的输出输入到下一个层实例中产生新的输出，一直不断的构建层的实例并得到新的输出，进而构建一个复杂的模型。
深度学习模型中最经典的一种模型结构是Embedding+MLP。它不仅经典，还是后续实现其他深度学习模型的基础。
这里面的Embedding大家应该比较熟悉，而MLP是什么呢？它其实是 Multilayer perceptron，多层感知机的缩写。感知机是神经元的另外一种叫法，所以多层感知机就是多层神经网络。微软的DeepCrossing就是Embedding+MLP模型机构中的一种。
DeepCrossing模型应用场景是微软搜索引擎Bing中的搜索广告推荐， 用户在输入搜索词之后， 搜索引擎除了返回相关结果， 还返回与搜索词相关的广告，Deep Crossing的优化目标就是预测对于某一广告， 用户是否会点击，依然是点击率预测的一个问题。
可以看到该结构由Embedding Layer、Stacking Layer、Multiple Residual Units Layer、Scoring Layer组成。下面分别介绍各层作用。
Embedding Layer
Embedding 层就是为了把稀疏的 One-hot 向量转换成稠密的 Embedding 向量而设置的，我们需要注意的是，Embedding 层并不是全部连接起来的，而是每一个特征对应一个 Embedding 层，不同 Embedding 层之间互不干涉。
Embeding 层的结构就是 Word2vec 模型中从输入神经元到隐层神经元的部分（如图 2 红框内的部分）。参照下面的示意图，我们可以看到，这部分就是一个从输入层到隐层之间的全连接网络。
Stacking Layer
Stacking 层中文名是堆叠层，我们也经常叫它连接（Concatenate）层。它的作用比较简单，就是把不同的 Embedding 特征和数值型特征拼接在一起，形成新的包含全部特征的特征向量。
Multiple Residual Units Layer
MLP 层就是我们开头提到的多层神经网络层，在图 1 中指的是 Multiple Residual Units 层，中文叫多层残差网络。微软在实现 Deep Crossing 时针对特定的问题选择了残差神经元。
但事实上，神经元的选择有非常多种，以 Sigmoid 函数为激活函数的神经元，以及使用 tanh、ReLU 等其他激活函数的神经元。我们具体选择哪种是一个调参的问题，一般来说，ReLU 最经常使用在隐层神经元上，Sigmoid 则多使用在输出神经元，实践中也可以选择性地尝试其他神经元，根据效果作出最后的决定。
不管选择哪种神经元，MLP 层的特点是全连接，就是不同层的神经元两两之间都有连接。
Scoring Layer
这个作为输出层，为了拟合优化目标存在。 对于CTR预估二分类问题， Scoring往往采用逻辑回归，模型通过叠加多个残差块加深网络的深度，最后将结果转换成一个概率值输出。
用于点击率预估模型的损失函数就是对数损失函数：
l
o
g
l
o
s
s
=
−
1
N
∑
1
N
(
y
i
l
o
g
(
p
i
)
+
(
1
−
y
i
)
l
o
g
(
1
−
p
i
)
logloss=-\frac 1N\sum_1^N(y_ilog(p_i)+(1-y_i)log(1-p_i)
logloss=−N11∑N(yilog(pi)+(1−yi)log(1−pi)
其中
y
i
y_i
yi表示真实的标签（点击或未点击），
p
i
p_i
pi表示Scoring Layer输出的结果。但是在实际应用中，根据不同的需求可以灵活替换为其他目标函数。
在正式进入DeepCrossing代码实操前，我们先了解下代码中的几个技巧。
1. 特征较多时构建多输入模型
将输入的数据转换成字典的形式，定义输入层的时候让输入层的name和字典中特征的key一致，就可以使得输入的数据和对应的Input层对应。方便后面搭建模型。
2. 特征表示的统一
看过DeepCTR源码的人可能就会知道，项目中输入分成三大类，分别是SparseFeat, DenseFeat, VarLenSparseFeat，并且使用类进行了封装，其中也考虑到效率的问题做了一些优化。
3. 通过特征标记构造输入层
在前面的函数式API构建模型最后说到过，可以使用字典的形式构建输入，最后只要将对应Input层的名字与字典中特征的key相对应就可以。在定义Input层的时候，除了name以外还有一个重要的属性就是shape
然而所有特征Input层的shape其实只有4种情况：
4. Embedding层的注意点
在构建模型的时候Embedding相关的需要注意两点：
1. 数据读取及特征预处理
# 读取数据
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]
定义特征标记
from collections import namedtuple
# 使用具名元组定义特征标记
SparseFeat = namedtuple('SparseFeat', ['name', 'vocabulary_size', 'embedding_dim'])
DenseFeat = namedtuple('DenseFeat', ['name', 'dimension'])
VarLenSparseFeat = namedtuple('VarLenSparseFeat', ['name', 'vocabulary_size', 'embedding_dim', 'maxlen'])
2. 构建DeepCrossing模型
# 构建DeepCrossing模型
history = DeepCrossing(dnn_feature_columns)
DeepCrossing函数
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
build_input_layers函数
用于构建输入层，用字典的形式返回dense和sparse数据。
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
build_embedding_layers函数
用于创建sparse特征的embeddin。
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
concat_embedding_list函数
用于将所有的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
get_dnn_logits函数
用于将dnn的输出转化成logits
# 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
调用ResidualBlock类，运行call方法。
# 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
3. 查看参数概况，定义损失函数、优化函数、评估指标，训练模型
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, )
代码放至DeepCrossing
参考资料：
深度学习推荐系统模型搭建基础
DeepCrossing
Embedding+MLP：如何用TensorFlow实现经典的深度学习模型？