一、Factorization-machine supported Neural Networks (FNN)
由前几期的介绍可知因子机(FM)可以对特征进行二阶交叉。当面对海量高度稀疏的用户行为反馈数据时，二阶交叉往往是不够的，三阶、四阶甚至更高阶的组合交叉能够进一步提升模型学习能力，但是高阶的特征交叉会使复杂度大大增加。
FNN的思想比较简单，直接在FM上接入若干全连接层。利用DNN对特征进行隐式交叉，可以减轻特征工程的工作，同时也能够将计算时间复杂度控制在一个合理的范围内。为了加速模型的收敛，充分利用FM的特征表达能力，FNN采用了两阶段训练方式。首先，针对任务构建FM模型，完成模型参数的学习。然后，将FM的参数作为FNN底层参数的初始值。这种两阶段方式的应用，是为了将FM作为先验知识加入到模型中，防止因为数据稀疏带来的歧义造成模型参数偏差。
一个4层的FNN结构
其基本模型如下：
输出层，即预估的CTR值：
其中分别表示权值和偏置。
第二隐藏层：
第一隐藏层：
其中表示因子机的参数向量，
，
由第一层的因子机初始化：
损失函数可以采用交叉熵：
二、Product-based Neural Network(PNN)
PNN同样引入了神经网络对低阶特征进行组合，但与FNN不同，PNN并没有单纯使用全连接层来对低阶特征进行组合，而是设计了Product层对特征进行更细致的交叉运算。
PNN典型结构
输出层，即预估的CTR值：
第二隐藏层：
第一隐藏层：
其中分别表示线性信息和二次信息，PNN的核心即在于计算。
定义点积运算：
则：
其中：
综上：
其中表示经过embedding之后的特征向量，embedding过程与FNN保持一致，同时可以看到PNN保留了低阶特征，避免了FNN仅对二阶特征进行更高阶组合的缺点。
表示成对特征交叉函数，定义不同的交叉方式就有不同的PNN结构，常见的有內积运算（Inner Product-based Neural Network, IPNN）和外积运算（Outer Product-based Neural Network, OPNN）。
2.1 IPNN 分析
定义 ， 则：
空间复杂度：的计算空间复杂度
，
的计算空间复杂度
，因此，product layer 整体计算空间复杂度为
。
时间复杂度：的计算时间复杂度
，计算
需要
时间开销，计算
需要
时间开销，又因为
需要
时间开销，所以
计算时间复杂度为
，因此，product layer 整体计算时间复杂度为
。
时空复杂度过高不适合工程实践，所以需要进行计算优化。因为 本身计算开销不大，所以将重点在于优化
的计算，受FM的参数矩阵分解启发，由于
都是对称方阵，所以使用一阶矩阵分解，假设
。将原本参数量为
的矩阵
，分解为了参数量为
的向量
，则：
其中，则：
优化后的时空复杂度：
空间复杂度由降为
，
时间复杂度由降为
。
2.2 OPNN分析
将特征交叉的方式由內积变为外积，边可得到PNN的另一种形式OPNN。
定义，则：
分析可知，OPNN时空复杂度均为。
为了进行计算优化，引入叠加的概念（sum pooling）。将 p 的计算公式重新定义为：
，则：
其中f_{\Sigma}的时间复杂度为，
的时空复杂度均为
，
的时空复杂度均为
，则
的时空复杂度均为
，
的时空复杂度均为
，则最终OPNN的时空复杂度为
。
三、算法实现
3.1 包的调用与参数初始化
import numpy as np
import pandas as pd
import tensorflow as tf
class PNN():
def __init__(self, feature_size, field_size, embedding_size=8, deep_layers=[32,32], deep_init_size=50, epoch=10, batch_size=256, learning_rate=0.001, random_seed=2020):
self.feature_size = feature_size
self.field_size = field_size
self.embedding_size = embedding_size
self.deep_layers = deep_layers
self.deep_init_size = deep_init_size
self.epoch = epoch
self.batch_size = batch_size
self.learning_rate = learning_rate
self.random_seed = random_seed
self._init_graph()
3.2 图的初始化与一次部分的计算
def _init_graph(self):
self.graph = tf.Graph()
with self.graph.as_default():
tf.set_random_seed(self.random_seed)
self.feat_index = tf.placeholder(tf.int32, shape=[None,None], name='feat_index')
self.feat_value = tf.placeholder(tf.float32, shape=[None,None], name='feat_value')
self.label = tf.placeholder(tf.float32, shape=[None,1], name='label')
self.train_phase = tf.placeholder(tf.bool, name='train_phase')
self.weights = self._init_weights()
# embeddings
self.embeddings = tf.nn.embedding_lookup(self.weights['feature_embeddings'], self.feat_index) # N * F * K
feat_value = tf.reshape(self.feat_value, shape=[-1, self.field_size, 1])
self.embeddings = tf.multiply(self.embeddings, feat_value)
# linear part
linear_output = []
for i in range(self.deep_init_size):
lz_i = tf.reduce_sum(tf.multiply(self.embeddings, self.weights['product-linear'][i]),axis=[1,2])
linear_output.append(tf.reshape(lz_i, shape=(-1,1))) # N * 1
self.lz = tf.concat(linear_output, axis=1) # N * init_deep_size
3.3 二次部分的计算（IPNN OPNN）
# quardatic part
# IPNN
quadratic_output = []
for i in range(self.deep_init_size):
weight = tf.reshape(self.weights['product-quadratic-inner'][i], (1,-1,1)) # 1 * F * 1
f_segma = tf.reduce_sum(tf.multiply(self.embeddings, weight), axis=1) # N * K
lp_i = tf.reshape(tf.norm(f_segma, axis=1), shape=(-1,1))
quadratic_output.append(lp_i)
self.lp = tf.concat(quadratic_output, axis=1) # N * init_deep_size
# OPNN
# quadratic_output = []
# for i in range(self.deep_init_size):
# f_sigma = tf.reduce_sum(self.embeddings, axis=1)
# p = tf.matmul(tf.expand_dims(f_sigma,2), tf.expand_dims(f_sigma,1)) # N * K * K = (N * K * 1) * (N * 1 * K)
# self.weights['product-quadratic-outer'] = tf.Variable(tf.random_normal([self.deep_init_size, self.embedding_size, self.embedding_size], 0.0, 0.01))
#
# for i in range(self.deep_init_size):
# theta = tf.multiply(p, tf.expand_dims(self.weights['product-quadratic-outer'][i], 0 )) # N * K * K
# lp_i = tf.reshape(tf.reduce_sum(theta, axis=[1,2]), shape=(-1,1)) # N * 1
# quadratic_output.append(lp_i)
#
3.4 深度网络部分
# deep layer
self.y_deep = tf.nn.relu(tf.add(tf.add(self.lz, self.lp), self.weights['product-bias']))
self.y_deep = tf.add(tf.matmul(self.y_deep, self.weights['layer_0']), self.weights['bias_0'])
self.y_deep = tf.nn.relu(self.y_deep)
self.y_deep = tf.add(tf.matmul(self.y_deep, self.weights['layer_1']), self.weights['bias_1'])
self.y_deep = tf.nn.relu(self.y_deep)
self.out = tf.add(tf.matmul(self.y_deep, self.weights['output']), self.weights['output_bias'])
self.out = tf.nn.sigmoid(self.out)
self.loss = tf.losses.log_loss(self.label, self.out)
self.optimizer = tf.train.AdamOptimizer(learning_rate=self.learning_rate, beta1=0.9, beta2=0.999, epsilon=1e-8).minimize(self.loss)
self.saver = tf.train.Saver()
init = tf.global_variables_initializer()
self.sess = tf.Session()
self.sess.run(init)
writer = tf.summary.FileWriter("D:/logs/pnn/", tf.get_default_graph())
writer.close()
3.5 权值的初始化
def _init_weights(self):
weights = dict()
# embeddings
weights['feature_embeddings'] = tf.Variable(tf.random_normal([self.feature_size,self.embedding_size], 0.0, 0.01),name='feature_embeddings')
weights['feature_bias'] = tf.Variable(tf.random_normal([self.feature_size,1],0.0,1.0), name='feature_bias')
weights['product-quadratic-inner'] = tf.Variable(tf.random_normal([self.deep_init_size, self.field_size], 0.0, 0.01))
weights['product-linear'] = tf.Variable(tf.random_normal([self.deep_init_size, self.field_size, self.embedding_size], 0.0, 0.01))
weights['product-bias'] = tf.Variable(tf.random_normal([self.deep_init_size,], 0.0, 0.01))
# deep layer
input_size = self.deep_init_size
glorot = np.sqrt(2.0 / (input_size + self.deep_layers[0]))
weights['layer_0'] = tf.Variable(np.random.normal(loc=0, scale=glorot, size=(input_size, self.deep_layers[0])),dtype=np.float32)
weights['bias_0'] = tf.Variable(np.random.normal(loc=0, scale=glorot, size=(1, self.deep_layers[0])), dtype=np.float32)
glorot = np.sqrt(2.0 / (self.deep_layers[0] + self.deep_layers[1]))
weights['layer_1'] = tf.Variable(np.random.normal(loc=0, scale=glorot, size=(self.deep_layers[0],self.deep_layers[1])),dtype=np.float32)
weights['bias_1'] = tf.Variable(np.random.normal(loc=0, scale=glorot, size=(1, self.deep_layers[1])),dtype=np.float32)
glorot = np.sqrt(2.0 / (input_size + 1))
weights['output'] = tf.Variable(np.random.normal(loc=0, scale=glorot, size=(self.deep_layers[-1],1)),dtype=np.float32)
weights['output_bias'] = tf.Variable(tf.constant(0.01), dtype=np.float32)
return weights
3.6 训练函数及其补充函数
def fit_on_batch(self, Xi, Xv, y):
feed_dict = {self.feat_index:Xi,
self.feat_value:Xv,
self.label:y,
self.train_phase:True}
loss, opt = self.sess.run([self.loss, self.optimizer], feed_dict=feed_dict)
return loss
def get_batch(self, Xi, Xv, y, batch_size, index):
start = index * batch_size
end = (index+1) * batch_size
end = end if end<len(y) else len(y)
return Xi[start:end], Xv[start:end], [[y_] for y_ in y[start:end]]
def fit(self, Xi_train, Xv_train, y_train, Xi_valid=None, Xv_valid=None, y_valid=None, early_stopping=False, refit=False):
for epoch in range(self.epoch):
total_batch = int(len(y_train) / self.batch_size)
for i in range(total_batch):
Xi_batch, Xv_batch, y_batch = self.get_batch(Xi_train,Xv_train,y_train,self.batch_size, 1)
self.fit_on_batch(Xi_batch, Xv_batch, y_batch)
feed_dict = {self.feat_index:Xi_batch,
self.feat_value:Xv_batch,
self.label:y_batch
}
loss, opt = self.sess.run([self.loss, self.optimizer], feed_dict=feed_dict)
print('epoch:',epoch,' loss:',loss)
PNN网络结构1
PNN网络结构2
3.7 文件加载与序列处理
TRAIN_FILE = "Driver_Prediction_Data/train.csv"
TEST_FILE = "Driver_Prediction_Data/test.csv"
NUMERIC_COLS = [
"ps_reg_01", "ps_reg_02", "ps_reg_03",
"ps_car_12", "ps_car_13", "ps_car_14", "ps_car_15"
]
IGNORE_COLS = [
"id", "target",
"ps_calc_01", "ps_calc_02", "ps_calc_03", "ps_calc_04",
"ps_calc_05", "ps_calc_06", "ps_calc_07", "ps_calc_08",
"ps_calc_09", "ps_calc_10", "ps_calc_11", "ps_calc_12",
"ps_calc_13", "ps_calc_14",
"ps_calc_15_bin", "ps_calc_16_bin", "ps_calc_17_bin",
"ps_calc_18_bin", "ps_calc_19_bin", "ps_calc_20_bin"
]
def load_data():
train_data = pd.read_csv(TRAIN_FILE)
test_data = pd.read_csv(TEST_FILE)
data = pd.concat([train_data, test_data])
cols = [c for c in train_data.columns if c not in ['id','target']]
cols = [c for c in cols if (c not in IGNORE_COLS)]
X_train = train_data[cols].values
y_train = train_data['target'].values
X_test = test_data[cols].values
ids_test = test_data['id'].values
return data, train_data, test_data, X_train, y_train, X_test, ids_test
3.8 数据预处理函数
def split_dimensions(data):
feat_dict = {}
tc = 0
for col in data.columns:
if col in IGNORE_COLS:
continue
if col in NUMERIC_COLS:
feat_dict[col] = tc
tc += 1
else:
us = data[col].unique()
feat_dict[col] = dict(zip(us,range(tc,len(us)+tc)))
tc += len(us)
feat_dimension = tc
return feat_dict, feat_dimension
def data_parse(data, feat_dict, training=True):
if training:
y = data['target'].values.tolist()
data.drop(['id','target'], axis=1, inplace=True)
else:
ids = data['id'].values.tolist()
data.drop(['id'], axis=1, inplace=True)
index = data.copy()
for col in data.columns:
if col in IGNORE_COLS:
data.drop(col, axis=1, inplace=True)
index.drop(col, axis=1, inplace=True)
continue
if col in NUMERIC_COLS:
index[col] = feat_dict[col]
else:
index[col] = data[col].map(feat_dict[col])
data[col] = 1.
xi = index.values.tolist()
xd = data.values.tolist()
if training:
return xi, xd, y
else:
return xi, xd, ids
3.9 主函数
def main():
data, train_data, test_data, X_train, y_train, X_test, ids_test = load_data()
feat_dict, feat_dimension = split_dimensions(data)
Xi_train, Xv_train, y_train = data_parse(train_data, feat_dict, training=True)
Xi_test, Xv_test, ids_test = data_parse(test_data, feat_dict, training=False)
pnn_model = PNN(feature_size = feat_dimension,
field_size = len(Xi_train[0]),
batch_size=128,
epoch=100
)
pnn_model.fit(Xi_train, Xv_train, y_train)
if __name__ == '__main__':
main()
训练过程的损失值如下所示：
epoch: 0 loss: 0.015076467
epoch: 1 loss: 0.00010797631
epoch: 2 loss: 3.4825567e-05
epoch: 3 loss: 1.7326316e-05
epoch: 4 loss: 1.0358356e-05
epoch: 5 loss: 6.848299e-06
···
epoch: 95 loss: -1.1920928e-07
epoch: 96 loss: -1.1920928e-07
epoch: 97 loss: -1.1920928e-07
epoch: 98 loss: -1.1920928e-07
epoch: 99 loss: -1.1920928e-07
参考资料
[1]. https://www.cnblogs.com/yinzm/p/11758595.html
[2]. https://www.cnblogs.com/yinzm/p/11775948.html
[3]. Qu Y, Cai H, Ren K, et al. Product-based neural networks for user response prediction[C]//2016 IEEE 16th International Conference on Data Mining (ICDM). IEEE, 2016: 1149-1154.
[4]. Zhang W, Du T, Wang J. Deep learning over multi-field categorical data[C]//European conference on information retrieval. Springer, Cham, 2016: 45-57.
日月忽其不淹兮，春与秋其代序。 ——屈原《离骚》
