原文：https://www.csie.ntu.edu.tw/~b97053/paper/Rendle2010FM.pdf
本文仅仅只是对文章的一些个人理解。本章先回顾一下FM模型和代码实现。
在FM模型里，每个事物被表式为一个多领域的类别特征向量 表示，利用one-hot/multi-hot编码来描述上下文信息。one-hot大家一定很了解，比如性别特征男=[1,0,0]，女=[0,1,0],未识别=[0,0,1]。但是multi-hot是第一次听说，文中给的一个例子是historical items，可以类比在电商领域里，用户在过去某一段时间浏览的商品。由于用户不只是对一种商品有过浏览行为，所以不像one-hot只在某一位上有值。比如[衣服，鞋子，包]，用户在前一天浏览了衣服和鞋子，则该特征为[1,1,0]。
式子（1）是FM模型，我们回顾一下，其中是全局的偏置项,是第个变量的权重值，到此为止也就是大家常见的线性模型。FM模型是在线性模型的基础上加了二阶项，也就是式(1)的第三项。其中<v_i,v_j>是二阶交叉项的系数。式子(1)的第三项可以被简化成：
简记为和平方-平方和。虽然它在线性模型的基础上加上了二阶特征，但它的局限性也在于此，它仅仅只利用了特征之间两两乘积的线性组合。更高阶的特征组合仍无法获取。由此作者提出了CFM模型。其目的是获取更高阶的特征组合。我们先回忆一下FM模型的代码，先看主程序
if __name__ == '__main__':
# 读取数据
data = pd.read_csv('./criteo_sample.txt')
# 将数据按照连续特征离散特征和目标分开
dense_features = ['I' + str(i) for i in range(1, 14)]
sparse_features = ['C' + str(i) for i in range(1, 27)]
labelName = 'label'
# 数据基础处理
df = hadleData(data=data,sparse_features=sparse_features, dense_features=dense_features)
# 将数据按照8:2分成训练数据和测试数据
df_train, df_test = train_test_split(df, test_size=0.2, random_state=10)
# 得到特征集和特征个数
dict, feature_size = get_feature_dict(df_train, dense_features,labelName)
# for k,v in dict.items():
# print("--------------")
# print(k)
# print(v)
#
# 可以这样理解这一步，
x_train_index, x_train_value, y_train = get_data(df_train, dict,dense_features,labelName)
# print(len(x_train_index))
# for i in range(len(x_train_index)):
# print(x_train_index[i])
# print("--------------")
# for i in range(len(x_train_index)):
# print(x_train_value[i])
x_test_index, x_test_value, y_test = get_data(df_test, dict,dense_features,labelName)
#
m, n = np.array(x_train_index).shape
xidx = tf.placeholder(tf.int32, [None, None], name='feat_index')
xval = tf.placeholder(tf.float32, [None, None], name='feat_value')
y = tf.placeholder(tf.float32, [None, 1], name='label')
#模型预测值
embedding_size = 4 # 定义embedding的大小
liner = linear(xidx, xval ,feature_size,n)
fm = FM(n,feature_size,embedding_size,xidx,xval)
# prediction = tf.add(liner, fm) # None * 1 # 回归最后一层
prediction = tf.nn.sigmoid(tf.add(liner, fm)) #因为只有两类，所有用sigmoid
# 模型的损失函数
# loss = tf.reduce_mean(tf.square(prediction - y)) #回归的损失函数
loss = tf.reduce_mean(-tf.reduce_sum(y_train * tf.log(prediction), reduction_indices=[1]))
# 分类的损失函数,交叉熵损失函数
# 梯度下降
lr =0.01 # 定义梯度下降的参数,试验几种梯度下降法
train_op = tf.train.AdamOptimizer(learning_rate=lr).minimize(loss)
epoch = 1000
init = tf.global_variables_initializer() # 初始化参数，必须要
with tf.Session() as sess:
sess.run(init)
for step in range(epoch):
if step%50==0:
train_acct_num =computeAcc(x_train_index, x_train_value, y_train)
# test_acct_num = computeAcc(x_test_index, x_test_value, y_test)
tmp_loss_train, _ = sess.run([loss, train_op],
feed_dict={xidx: x_train_index, xval: x_train_value, y: y_train})
print("epoch:%d train_acct_num：%f tmp_loss_train: %f" %(step,train_acct_num, tmp_loss_train))
首先我们要对拿到的数据做一些最基础的处理，比如空值填充，one-hot编码及连续值scale化。
def hadleData(data, sparse_features, dense_features):
# 空值填充,连续值填充为0，离散值填充为-1
data[sparse_features] = data[sparse_features].fillna('-1', )
data[dense_features] = data[dense_features].fillna(0, )
# 独热编码，在本代码中实际不需要，因为在#get_feature_dict中实际上进行了独热编码
# for feat in sparse_features:
# lbe = LabelEncoder()
# data[feat] = lbe.fit_transform(data[feat])
# 连续特征进行归一化处理
mms = MinMaxScaler(feature_range=(0, 1))
data[dense_features] = mms.fit_transform(data[dense_features])
return data
接着我们需要将特征变成{field：{特征：编号}}的形式，例如C22离散特征，它只有-1、c9d4222a、ad3062eb、8ec974f4、78e2e389。共5个取值，最终的类结合为{'-1': 1664, 'c9d4222a': 1665, 'ad3062eb': 1666, '8ec974f4': 1667, '78e2e389': 1668}后面的数字1701是它的特征编码，也就是说它是第1701个特征。可以这样理解，把所有特征编码后展开，连续特征维数不变，离散特征要拉长成它所有取值的大小。然后将其重新编号。
def get_feature_dict(df,denseFeature,labelName):
feature_dict = {}
total_feature = 0
# df.drop(labelName, axis=1, inplace=True)
for col in df.columns:
if col in denseFeature:
feature_dict[col] = total_feature
total_feature += 1
else:
unique_feature = df[col].unique()
feature_dict[col] = dict(zip(unique_feature, range(total_feature, total_feature + len(unique_feature))))
total_feature += len(unique_feature)
return feature_dict, total_feature
下面的操作就类似于稀疏存储，记录每个样本非空的特征xi和对应的特征值xv。
def get_data(df,feature_dict,denseFeature,labelName):
y = df[[labelName]].values
dd = df.drop(labelName,axis=1)
df_index = dd.copy()
df_value = dd.copy()
for col in df_index.columns:
if col in denseFeature:
df_index[col] = feature_dict[col]
else:
df_index[col] = df_index[col].map(feature_dict[col])
df_value[col] = 1.0
xi=df_index.values.tolist()
xv=df_value.values.tolist()
return xi,xv,y
接着看两大主要部分：线性模块和FM模块
def linear(xidx, xval ,feature_size,n):
# xidx 的大小是[160, 39] feature_sze = 1872
# 偏置项
w_0 = tf.Variable(initial_value=tf.zeros(shape=[1]),dtype=tf.float32) ，
# 权重项，初始化为均值为0方差为0.01的二项分布
w = tf.Variable(initial_value=tf.random_normal(shape=[feature_size, 1], mean=0,stddev=0.01),
dtype=tf.float32)
# tf.nn.embedding_lookup函数的用法主要是选取一个张量里面索引对应的元素
# 例如 c=np.random([5,1]) b = tf.nn.embedding_lookup(c, [1,3])
# b=[[ 0.23976515],[ 0.77505197],[ 0.08798201],[ 0.20635818],[ 0.37183035]], c = [[ 0.77505197],[ 0.20635818]]
embedding_first = tf.nn.embedding_lookup(w, xidx)
# reshape将矩阵重新，相当于把数据拉长成了一维数据进行计算
value = tf.reshape(xval, [-1, n, 1])
# multiply(embedding_first,value) = embedding_first*value
# axis=1,如果是二维矩阵，按行求和，例如[[1,2], [3,4]] 就和的结果为[3,7]
first_order = tf.reduce_sum(tf.multiply(embedding_first, value), axis=1)
liner = tf.add(w_0, first_order)
return liner
def FM(n,feature_size,embedding_size,xidx,xval):
# 定义权重 v = [sampleNum, sampleDim]
v = tf.Variable(initial_value=tf.random_normal(
shape=[feature_size, embedding_size], mean=0, stddev=0.01),
dtype=tf.float32
)
# 此时inputData= [sampleNum, sampleDim]
#计算v_{i,k}*x_i, 最后得到的维度是[sampleNum, sampleDim]，只不过每个v_{i,k}的位置乘了x_i
embedding = tf.nn.embedding_lookup(v, xidx) # N n embedding_size
value = tf.reshape(xval, [-1, n, 1])
embedding_value = tf.multiply(embedding, value) # N n embedding_size
# 和平方 (\sum_i^n v_{i,k}*x_i)^2， 按行求和
square_of_sum = tf.square(tf.reduce_sum(
embedding_value, axis=1, keepdims=True))
# 平方和 \sum_i^n (v_{i,k}*x_i)^2
sum_of_square = tf.reduce_sum(
embedding_value * embedding_value, axis=1, keepdims=True)
cross_term = square_of_sum - sum_of_square
cross_term = 0.5 * tf.reduce_sum(cross_term, axis=2, keepdims=False)
return cross_term
问题1：实际上我所理解如果要用该模型做分类的话，应该在外层嵌套一个sigmoid函数，就像LR模型，是在线性模型的基础上嵌套一层sigmoid函数，作为二分类模型的某类别的概率值。
问题2：看到有人说FM实际上先进行one-hot再进行embedding。embedding具体在哪里体现的呢？
参考文献
[1]https://blog.csdn.net/qq_40006058/article/details/88532970
[2]//www.greatytc.com/p/d2068c991ee7
