作者丨龍心塵 & 寒小陽

研究方向丨機器學習，資料探勘

題記：多年以後，當資深演算法專家們看著無縫對接使用者需求的廣告收入節節攀升時，他們可能會想起自己之前痛苦推導 FM 與深度學習公式的某個夜晚……

本文程式碼部分參考了 lambda 等同學的 TensorFlow 實現，在此向原作者表示感謝。

引言 

點選率（click-through rate, CTR）是網際網路公司進行流量分配的核心依據之一。比如網際網路廣告平臺，為了精細化權衡和保障使用者、廣告、平臺三方的利益，準確的 CTR 預估是不可或缺的。CTR 預估技術從傳統的邏輯迴歸，到近兩年大火的深度學習，新的演算法層出不窮：DeepFM, NFM, DIN, AFM, DCN…… 

然而，相關的綜述文章不少，但碎片羅列的居多，模型之間內在的聯絡和演化思路如何揭示？怎樣才能迅速 get 到新模型的創新點和適用場景，快速提高新論文速度，節約理解、復現模型的成本？這些都是亟待解決的問題。 

我們認為，從 FM 及其與神經網路的結合出發，能夠迅速貫穿很多深度學習 CTR 預估網路的思路，從而更好地理解和應用模型。

本文的思路與方法

1. 我們試圖從原理上進行推導、理解各個深度 CTR 預估模型之間的相互關係，知其然也知其所以然（以下的分析與拆解角度，是一種我們嘗試的理解視角，並不是唯一的理解方式）。

2. 推演的核心思路：“通過設計網路結構進行組合特徵的挖掘”。 

3. 具體來說有兩條：其一是從 FM 開始推演其在深度學習上的各種推廣（對應下圖的紅線）

，另一條是從 embedding + MLP 自身的演進特點結合 CTR 預估本身的業務場景進行推演（對應下圖黑線部分）。

4. 為了便於理解，我們簡化了資料案例——只考慮離散特徵資料的建模，以分析不同神經網路在處理相同業務問題時的不同思路。

5. 同時，我們將各典型論文不同風格的神經網路結構圖統一按照計算圖來繪製，以便於對比不同模型。

FM：降維版本的特徵二階組合

CTR 預估本質是一個二分類問題，以移動端展示廣告推薦為例，依據日誌中的使用者側的資訊（比如年齡，性別，國籍，手機上安裝的 app 列表）、廣告側的資訊（廣告 id，廣告類別，廣告標題等）、上下文側資訊（渠道 id 等），去建模預測使用者是否會點選該廣告。 

FM 出現之前的傳統的處理方法是人工特徵工程加上線性模型（如邏輯迴歸 Logistic Regression）。為了提高模型效果，關鍵技術是找到到使用者點選行為背後隱含的特徵組合。如男性、大學生使用者往往會點選遊戲類廣告，因此“男性且是大學生且是遊戲類”的特徵組合就是一個關鍵特徵。但這本質仍是線性模型，其假設函式表示成內積形式一般為：

其中為特徵向量，為權重向量，σ() 為 sigmoid 函式。 

但是人工進行特徵組合通常會存在諸多困難，如特徵爆炸、特徵難以被識別、組合特徵難以設計等。為了讓模型自動地考慮特徵之間的二階組合資訊，線性模型推廣為二階多項式（2d−Polynomial）模型：

其實就是對特徵兩兩相乘（組合）構成新特徵（離散化之後其實就是“且”操作），並對每個新特徵分配獨立的權重，通過機器學習來自動得到這些權重。將其寫成矩陣形式為：

其中為二階特徵組合的權重矩陣，是對稱矩陣。而這個矩陣引數非常多，為。為了降低該矩陣的維度，可以將其因子分解（Factorization）為兩個低維（比如 n∗k）矩陣的相乘。則此時 W 矩陣的引數就大幅降低，為O(nk)。公式如下：

這就是 Rendle 等在 2010 年提出因子分解機（Factorization Machines，FM）的名字的由來。FM 的矩陣形式公式如下：

將其寫成內積的形式：

利用，可以將上式進一步改寫成求和式的形式：

其中向量是矩陣 W 的第 i 列。為了去除重複項與特徵平方項，上式可以進一步改寫成更為常見的 FM 公式：

對比二階多項式模型，FM 模型中特徵兩兩相乘（組合）的權重是相互不獨立的，它是一種引數較少但表達力強的模型。

此處附上 FM 的 TensorFlow 程式碼實現，完整資料和程式碼請參考網盤。

網盤連結：

https://pan.baidu.com/s/1eDwOxweRDPurI2fF51EALQ

注意 FM 通過內積進行無重複項與特徵平方項的特徵組合過程使用了一個小 trick，就是：

class FM(Model):
    def __init__(self, input_dim=None, output_dim=1, factor_order=10, init_path=None, opt_algo='gd', learning_rate=1e-2,
                 l2_w=0, l2_v=0, random_seed=None):
        Model.__init__(self)
        # 一次、二次交叉、偏置項
        init_vars = [('w', [input_dim, output_dim], 'xavier', dtype),
                     ('v', [input_dim, factor_order], 'xavier', dtype),
                     ('b', [output_dim], 'zero', dtype)]
        self.graph = tf.Graph()
        with self.graph.as_default():
            if random_seed is not None:
                tf.set_random_seed(random_seed)
            self.X = tf.sparse_placeholder(dtype)
            self.y = tf.placeholder(dtype)
            self.vars = init_var_map(init_vars, init_path)

            w = self.vars['w']
            v = self.vars['v']
            b = self.vars['b']

            # [(x1+x2+x3)^2 - (x1^2+x2^2+x3^2)]/2
            # 先計算所有的交叉項，再減去平方項(自己和自己相乘)
            X_square = tf.SparseTensor(self.X.indices, tf.square(self.X.values), tf.to_int64(tf.shape(self.X)))
            xv = tf.square(tf.sparse_tensor_dense_matmul(self.X, v))
            p = 0.5 * tf.reshape(
                tf.reduce_sum(xv - tf.sparse_tensor_dense_matmul(X_square, tf.square(v)), 1),
                [-1, output_dim])
            xw = tf.sparse_tensor_dense_matmul(self.X, w)
            logits = tf.reshape(xw + b + p, [-1])
            self.y_prob = tf.sigmoid(logits)

            self.loss = tf.reduce_mean(
                tf.nn.sigmoid_cross_entropy_with_logits(logits=logits, labels=self.y)) + \
                        l2_w * tf.nn.l2_loss(xw) + \
                        l2_v * tf.nn.l2_loss(xv)
            self.optimizer = get_optimizer(opt_algo, learning_rate, self.loss)

            #GPU設定
            config = tf.ConfigProto()
            config.gpu_options.allow_growth = True
            self.sess = tf.Session(config=config)
            # 圖中所有variable初始化
            tf.global_variables_initializer().run(session=self.sess)

用神經網路的視角看FM：嵌入後再進行內積

我們觀察 FM 公式的矩陣內積形式：

發現部分就是將離散係數特徵通過矩陣乘法降維成一個低維稠密向量。這個過程對神經網路來說就叫做嵌入（embedding）。所以用神經網路視角來看： 

1. FM 首先是對離散特徵進行嵌入。 

2. 之後通過對嵌入後的稠密向量進行內積來進行二階特徵組合。 

3. 最後再與線性模型的結果求和進而得到預估點選率。 

其示意圖如下。為了表述清晰，我們繪製的是神經網路計算圖而不是網路結構圖——在網路結構圖中增加了權重 W 的位置。

FM的實際應用：考慮領域資訊

廣告點選率預估模型中的特徵以分領域的離散特徵為主，如：廣告類別、使用者職業、手機APP列表等。由於連續特徵比較好處理，為了簡化起見，本文只考慮同時存在不同領域的離散特徵的情形。

處理離散特徵的常見方法是通過獨熱（one-hot）編碼轉換為一系列二值特徵向量。然後將這些高維稀疏特徵通過嵌入（embedding）轉換為低維連續特徵。前面已經說明 FM 中間的一個核心步驟就是嵌入，但這個嵌入過程沒有考慮領域資訊。這使得同領域內的特徵也被當做不同領域特徵進行兩兩組合了。 

其實可以將特徵具有領域關係的特點作為先驗知識加入到神經網路的設計中去：同領域的特徵嵌入後直接求和作為一個整體嵌入向量，進而與其他領域的整體嵌入向量進行兩兩組合。而這個先嵌入後求和的過程，就是一個單領域的小離散特徵向量乘以矩陣的過程。

此時 FM 的過程變為：對不同領域的離散特徵分別進行嵌入，之後再進行二階特徵的向量內積。其計算圖圖如下所示：

這樣考慮其實是給 FM 增加了一個正則：考慮了領域內的資訊的相似性。而且還有一個附加的好處，這些嵌入後的同領域特徵可以拼接起來作為更深的神經網路的輸入，達到降維的目的。接下來我們將反覆看到這種處理方式。 

此處需要注意，這與“基於領域的因子分解機”（Field-aware Factorization Machines，FFM）有區別。FFM 也是 FM 的另一種變體，也考慮了領域資訊。但其不同點是同一個特徵與不同領域進行特徵組合時，其對應的嵌入向量是不同的。本文不考慮 FFM 的作用機制。 

經過這些改進的 FM 終究還是淺層網路，它的表現力仍然有限。為了增加模型的表現力（model capacity），一個自然的想法就是將該淺層網路不斷“深化”。

embedding+MLP：深度學習CTR預估的通用框架

embedding+MLP 是對於分領域離散特徵進行深度學習 CTR 預估的通用框架。深度學習在特徵組合挖掘（特徵學習）方面具有很大的優勢。比如以 CNN 為代表的深度網路主要用於影象、語音等稠密特徵上的學習，以 W2V、RNN 為代表的深度網路主要用於文字的同質化、序列化高維稀疏特徵的學習。CTR 預估的主要場景是對離散且有具體領域的特徵進行學習，所以其深度網路結構也不同於 CNN 與 RNN。 

具體來說， embedding+MLP 的過程如下： 

1. 對不同領域的 one-hot 特徵進行嵌入（embedding），使其降維成低維度稠密特徵。 

2. 然後將這些特徵向量拼接（concatenate）成一個隱含層。 

3. 之後再不斷堆疊全連線層，也就是多層感知機（Multilayer Perceptron, MLP，有時也叫作前饋神經網路）。 

4. 最終輸出預測的點選率。 

其示意圖如下：

embedding+MLP 的缺點是隻學習高階特徵組合，對於低階或者手動的特徵組合不夠相容，而且引數較多，學習較困難。

FNN：FM與MLP的串聯結合

Weinan Zhang 等在 2016 年提出的因子分解機神經網路（Factorisation Machine supported Neural Network，FNN）將考 FM 與 MLP 進行了結合。它有著十分顯著的特點： 

1. 採用 FM 預訓練得到的隱含層及其權重作為神經網路的第一層的初始值，之後再不斷堆疊全連線層，最終輸出預測的點選率。 

2. 可以將 FNN 理解成一種特殊的 embedding+MLP，其要求第一層嵌入後的各領域特徵維度一致，並且嵌入權重的初始化是 FM 預訓練好的。 

3. 這不是一個端到端的訓練過程，有貪心訓練的思路。而且如果不考慮預訓練過程，模型網路結構也沒有考慮低階特徵組合。 

其計算圖如下所示：

通過觀察 FFN 的計算圖可以看出其與 embedding+MLP 確實非常像。不過此處省略了 FNN 的 FM 部分的線性模組。這種省略為了更好地進行兩個模型的對比。接下來的計算圖我們都會省略線性模組。

此處附上 FNN 的程式碼實現，完整資料和程式碼請參考網盤。 

網盤連結：

https://pan.baidu.com/s/1eDwOxweRDPurI2fF51EALQ

class FNN(Model):
    def __init__(self, field_sizes=None, embed_size=10, layer_sizes=None, layer_acts=None, drop_out=None,
                 embed_l2=None, layer_l2=None, init_path=None, opt_algo='gd', learning_rate=1e-2, random_seed=None):
        Model.__init__(self)
        init_vars = []
        num_inputs = len(field_sizes)
        for i in range(num_inputs):
            init_vars.append(('embed_%d' % i, [field_sizes[i], embed_size], 'xavier', dtype))
        node_in = num_inputs * embed_size
        for i in range(len(layer_sizes)):
            init_vars.append(('w%d' % i, [node_in, layer_sizes[i]], 'xavier', dtype))
            init_vars.append(('b%d' % i, [layer_sizes[i]], 'zero', dtype))
            node_in = layer_sizes[i]
        self.graph = tf.Graph()
        with self.graph.as_default():
            if random_seed is not None:
                tf.set_random_seed(random_seed)
            self.X = [tf.sparse_placeholder(dtype) for i in range(num_inputs)]
            self.y = tf.placeholder(dtype)
            self.keep_prob_train = 1 - np.array(drop_out)
            self.keep_prob_test = np.ones_like(drop_out)
            self.layer_keeps = tf.placeholder(dtype)
            self.vars = init_var_map(init_vars, init_path)
            w0 = [self.vars['embed_%d' % i] for i in range(num_inputs)]
            xw = tf.concat([tf.sparse_tensor_dense_matmul(self.X[i], w0[i]) for i in range(num_inputs)], 1)
            l = xw

            #全連線部分
            for i in range(len(layer_sizes)):
                wi = self.vars['w%d' % i]
                bi = self.vars['b%d' % i]
                print(l.shape, wi.shape, bi.shape)
                l = tf.nn.dropout(
                    activate(
                        tf.matmul(l, wi) + bi,
                        layer_acts[i]),
                    self.layer_keeps[i])

            l = tf.squeeze(l)
            self.y_prob = tf.sigmoid(l)

            self.loss = tf.reduce_mean(
                tf.nn.sigmoid_cross_entropy_with_logits(logits=l, labels=self.y))
            if layer_l2 is not None:
                self.loss += embed_l2 * tf.nn.l2_loss(xw)
                for i in range(len(layer_sizes)):
                    wi = self.vars['w%d' % i]
                    self.loss += layer_l2[i] * tf.nn.l2_loss(wi)
            self.optimizer = get_optimizer(opt_algo, learning_rate, self.loss)

            config = tf.ConfigProto()
            config.gpu_options.allow_growth = True
            self.sess = tf.Session(config=config)
            tf.global_variables_initializer().run(session=self.sess)

NFM：通過逐元素乘法延遲FM的實現過程

我們再回到考慮領域資訊的 FM，它仍有改進的空間。因為以上這些網路的 FM 部分都是隻進行嵌入向量的兩兩內積後直接求和，沒有充分利用二階特徵組合的資訊。Xiangnan He 等在 2017 年提出了神經網路因子分解機（Neural Factorization Machines，NFM）對此作出了改進。其計算圖如下所示：

NFM 的基本特點是： 

1. 利用二階互動池化層（Bi-Interaction Pooling）對 FM 嵌入後的向量兩兩進行元素級別的乘法，形成同維度的向量求和後作為前饋神經網路的輸入。計算圖中用圈乘 ⨂ 表示逐元素乘法運算。 

2. NFM 與 DeepFM 的區別是沒有單獨的 FM 的淺層網路進行聯合訓練，而是將其整合後直接輸出給前饋神經網路。 

3. 當 MLP 的全連線層都是恆等變換且最後一層引數全為 1 時，NFM 就退化成了 FM。可見，NFM 是 FM 的推廣，它推遲了 FM 的實現過程，並在其中加入了更多非線性運算。 

4. 另一方面，我們觀察計算圖會發現 NFM 與 FNN 非常相似。它們的主要區別是 NFM 在 embedding 之後對特徵進行了兩兩逐元素乘法。因為逐元素相乘的向量維數不變，之後對這些向量求和的維數仍然與 embedding 的維數一致。因此輸入到 MLP 的引數比起直接 concatenate 的 FNN 更少。 

此處附上 NFM 的程式碼實現，完整資料和程式碼請參考網盤：

網盤連結：

https://pan.baidu.com/s/1eDwOxweRDPurI2fF51EALQ

def model_fn(features, labels, mode, params):
    """Bulid Model function f(x) for Estimator."""
    #------hyperparameters----
    field_size = params["field_size"]
    feature_size = params["feature_size"]
    embedding_size = params["embedding_size"]
    l2_reg = params["l2_reg"]
    learning_rate = params["learning_rate"]
    #optimizer = params["optimizer"]
    layers = map(int, params["deep_layers"].split(','))
    dropout = map(float, params["dropout"].split(','))

    #------bulid weights------
    Global_Bias = tf.get_variable(name='bias', shape=[1], initializer=tf.constant_initializer(0.0))
    Feat_Bias = tf.get_variable(name='linear', shape=[feature_size], initializer=tf.glorot_normal_initializer())
    Feat_Emb = tf.get_variable(name='emb', shape=[feature_size,embedding_size], initializer=tf.glorot_normal_initializer())

    #------build feaure-------
    feat_ids  = features['feat_ids']
    feat_ids = tf.reshape(feat_ids,shape=[-1,field_size])
    feat_vals = features['feat_vals']
    feat_vals = tf.reshape(feat_vals,shape=[-1,field_size])

    #------build f(x)------
    with tf.variable_scope("Linear-part"):
        feat_wgts = tf.nn.embedding_lookup(Feat_Bias, feat_ids)         # None * F * 1
        y_linear = tf.reduce_sum(tf.multiply(feat_wgts, feat_vals),1)

    with tf.variable_scope("BiInter-part"):
        embeddings = tf.nn.embedding_lookup(Feat_Emb, feat_ids)         # None * F * K
        feat_vals = tf.reshape(feat_vals, shape=[-1, field_size, 1])
        embeddings = tf.multiply(embeddings, feat_vals)                 # vij * xi
        sum_square_emb = tf.square(tf.reduce_sum(embeddings,1))
        square_sum_emb = tf.reduce_sum(tf.square(embeddings),1)
        deep_inputs = 0.5*tf.subtract(sum_square_emb, square_sum_emb)   # None * K

    with tf.variable_scope("Deep-part"):
        if mode == tf.estimator.ModeKeys.TRAIN:
            train_phase = True
        else:
            train_phase = False

        if mode == tf.estimator.ModeKeys.TRAIN:
            deep_inputs = tf.nn.dropout(deep_inputs, keep_prob=dropout[0])                      # None * K
        for i in range(len(layers)):
            deep_inputs = tf.contrib.layers.fully_connected(inputs=deep_inputs, num_outputs=layers[i], \
                weights_regularizer=tf.contrib.layers.l2_regularizer(l2_reg), scope='mlp%d' % i)

            if FLAGS.batch_norm:
                deep_inputs = batch_norm_layer(deep_inputs, train_phase=train_phase, scope_bn='bn_%d' %i)   #放在RELU之後 https://github.com/ducha-aiki/caffenet-benchmark/blob/master/batchnorm.md#bn----before-or-after-relu
            if mode == tf.estimator.ModeKeys.TRAIN:
                deep_inputs = tf.nn.dropout(deep_inputs, keep_prob=dropout[i])                              #Apply Dropout after all BN layers and set dropout=0.8(drop_ratio=0.2)
                #deep_inputs = tf.layers.dropout(inputs=deep_inputs, rate=dropout[i], training=mode == tf.estimator.ModeKeys.TRAIN)

        y_deep = tf.contrib.layers.fully_connected(inputs=deep_inputs, num_outputs=1, activation_fn=tf.identity, \
            weights_regularizer=tf.contrib.layers.l2_regularizer(l2_reg), scope='deep_out')
        y_d = tf.reshape(y_deep,shape=[-1])

    with tf.variable_scope("NFM-out"):
        #y_bias = Global_Bias * tf.ones_like(labels, dtype=tf.float32)  # None * 1  warning;這裡不能用label，否則呼叫predict/export函式會出錯，train/evaluate正常；初步判斷estimator做了優化，用不到label時不傳
        y_bias = Global_Bias * tf.ones_like(y_d, dtype=tf.float32)      # None * 1
        y = y_bias + y_linear + y_d
        pred = tf.sigmoid(y)

    predictions={"prob": pred}
    export_outputs = {tf.saved_model.signature_constants.DEFAULT_SERVING_SIGNATURE_DEF_KEY: tf.estimator.export.PredictOutput(predictions)}
    # Provide an estimator spec for `ModeKeys.PREDICT`
    if mode == tf.estimator.ModeKeys.PREDICT:
        return tf.estimator.EstimatorSpec(
                mode=mode,
                predictions=predictions,
                export_outputs=export_outputs)

    #------bulid loss------
    loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=y, labels=labels)) + \
        l2_reg * tf.nn.l2_loss(Feat_Bias) + l2_reg * tf.nn.l2_loss(Feat_Emb)

    # Provide an estimator spec for `ModeKeys.EVAL`
    eval_metric_ops = {
        "auc": tf.metrics.auc(labels, pred)
    }
    if mode == tf.estimator.ModeKeys.EVAL:
        return tf.estimator.EstimatorSpec(
                mode=mode,
                predictions=predictions,
                loss=loss,
                eval_metric_ops=eval_metric_ops)

    #------bulid optimizer------
    if FLAGS.optimizer == 'Adam':
        optimizer = tf.train.AdamOptimizer(learning_rate=learning_rate, beta1=0.9, beta2=0.999, epsilon=1e-8)
    elif FLAGS.optimizer == 'Adagrad':
        optimizer = tf.train.AdagradOptimizer(learning_rate=learning_rate, initial_accumulator_value=1e-8)
    elif FLAGS.optimizer == 'Momentum':
        optimizer = tf.train.MomentumOptimizer(learning_rate=learning_rate, momentum=0.95)
    elif FLAGS.optimizer == 'ftrl':
        optimizer = tf.train.FtrlOptimizer(learning_rate)

    train_op = optimizer.minimize(loss, global_step=tf.train.get_global_step())

    # Provide an estimator spec for `ModeKeys.TRAIN` modes
    if mode == tf.estimator.ModeKeys.TRAIN:
        return tf.estimator.EstimatorSpec(
                mode=mode,
                predictions=predictions,
                loss=loss,
                train_op=train_op)

AFM：對簡化版NFM進行加權求和

相關推薦