一.概念

FM(分解機模型)和FFM(基於域的分解機模型)是最近幾年提出的模型，主要用於預估CTR/CVR，憑藉其在資料量比較大並且特徵稀疏的情況下，仍然能夠得到優秀的效能和效果的特性，屢次在各大公司舉辦的CTR預估比賽中獲得不錯的戰績。

二.原理

FM（Factorization Machine）是由Konstanz大學Steffen Rendle（現任職於Google）於2010年最早提出的，旨在解決稀疏資料下的特徵組合問題，相比SVM的二階多項式核而言，FM在樣本稀疏的情況下是有優勢的；而且，FM的訓練/預測複雜度是線性的，而二項多項式核SVM需要計算核矩陣，核矩陣複雜度就是N平方。

FFM（Field-aware Factorization Machine）最初的概念來自Yu-Chin Juan（阮毓欽，畢業於中國臺灣大學，現在美國Criteo工作）與其比賽隊員，是他們借鑑了來自Michael Jahrer的論文中的field概念提出了FM的升級版模型。通過引入field的概念，FFM把相同性質的特徵歸於同一個field
假設樣本的 n 個特徵屬於 f 個field，那麼FFM的二次項有 nf個隱向量。而在FM模型中，每一維特徵的隱向量只有一個。FM可以看作FFM的特例，是把所有特徵都歸屬到一個field時的FFM模型。根據FFM的field敏感特性，可以匯出其模型方程。

其中，fj 是第 j 個特徵所屬的field。如果隱向量的長度為 k，那麼FFM的二次引數有 nfk 個，遠多於FM模型的 nk 個。此外，由於隱向量與field相關，FFM二次項並不能夠化簡，其預測複雜度是 O(kn2)O(kn2)。

三.演算法

演算法程式碼：（原始碼見最後）

ffm_model ffm_train_on_disk(string tr_path, string va_path, ffm_parameter param) {

    problem_on_disk tr(tr_path);
    problem_on_disk va(va_path);

	ffm_model model = init_model(tr.meta.n, tr.meta.m, param);


	//cout << "ffm_train_on_disk:" << endl;
	
	//for (int i = 0; i < 10; i++)
	//{
	//	cout << "model.W[i]  "<<i<<" "<<*(model.W+i) << endl;

	//}
	
    bool auto_stop = param.auto_stop && !va_path.empty();

	ffm_long w_size = get_w_size(model);
    vector<ffm_float> prev_W(w_size, 0);
    if(auto_stop)
        prev_W.assign(w_size, 0);
    ffm_double best_va_loss = numeric_limits<ffm_double>::max();

    cout.width(4);
    cout << "iter";
    cout.width(13);
    cout << "tr_logloss";
    if(!va_path.empty())
    {
        cout.width(13);
        cout << "va_logloss";
    }
    cout.width(13);
    cout << "tr_time";
    cout << endl;

    Timer timer;

    auto one_epoch = [&] (problem_on_disk &prob, bool do_update) {

        ffm_double loss = 0;
        vector<ffm_int> outer_order(prob.meta.num_blocks);
        iota(outer_order.begin(), outer_order.end(), 0);
        random_shuffle(outer_order.begin(), outer_order.end());
        for(auto blk : outer_order) {
            ffm_int l = prob.load_block(blk);

            vector<ffm_int> inner_order(l);
            iota(inner_order.begin(), inner_order.end(), 0);
            random_shuffle(inner_order.begin(), inner_order.end());

#if defined USEOMP
#pragma omp parallel for schedule(static) reduction(+: loss)
#endif
			
            for(ffm_int ii = 0; ii < l; ii++) {
                ffm_int i = inner_order[ii];

                ffm_float y = prob.Y[i];
                
                ffm_node *begin = &prob.X[prob.P[i]];

                ffm_node *end = &prob.X[prob.P[i+1]];

                ffm_float r = param.normalization? prob.R[i] : 1;

                ffm_double t = wTx(begin, end, r, model);

                ffm_double expnyt = exp(-y*t);

                loss += log1p(expnyt);
				//cout << ii <<"/"<< l <<" "<< i<<" " << y << " " << r ;
				//cout <<" " << t << " " << expnyt << endl;
				
                if(do_update) {
                   
                    ffm_float kappa = -y*expnyt/(1+expnyt);

                    wTx(begin, end, r, model, kappa, param.eta, param.lambda, true);
                }
            }
        }

        return loss / prob.meta.l;
    };

	//cout << "ffm_train_on_disk one_epoch" << endl;
    for(ffm_int iter = 1; iter <= param.nr_iters; iter++) {
        timer.tic();
        ffm_double tr_loss = one_epoch(tr, true);
        timer.toc();

        cout.width(4);
        cout << iter;
        cout.width(13);
        cout << fixed << setprecision(5) << tr_loss;

        if(!va.is_empty()) {
            ffm_double va_loss = one_epoch(va, false);

            cout.width(13);
            cout << fixed << setprecision(5) << va_loss;

            if(auto_stop) {
                if(va_loss > best_va_loss) {
                    memcpy(model.W, prev_W.data(), w_size*sizeof(ffm_float));                    
					cout.width(13);
					cout << fixed << setprecision(1) << timer.get() << endl;
					cout << endl << "Auto-stop. Use model at " << iter - 1 << "th iteration." << endl;
                    break;
                } else {
                    memcpy(prev_W.data(), model.W, w_size*sizeof(ffm_float));
                    best_va_loss = va_loss; 
                }
            }
        
		}
        cout.width(13);
        cout << fixed << setprecision(1) << timer.get() << endl;
    }

    return model;
}
 

inline ffm_float wTx(
    ffm_node *begin,
    ffm_node *end,
    ffm_float r,
    ffm_model &model, 
    ffm_float kappa=0, 
    ffm_float eta=0, 
    ffm_float lambda=0, 
    bool do_update=false) {

    ffm_int align0 = 2 * get_k_aligned(model.k);
    ffm_int align1 = model.m * align0;

    ffm_float t = 0;
    for(ffm_node *N1 = begin; N1 != end; N1++) {
		//cout << "model.W "<<model.W << endl;
        ffm_int j1 = N1->j;
        ffm_int f1 = N1->f;
        ffm_float v1 = N1->v;
        if(j1 >= model.n || f1 >= model.m)
            continue;

        for(ffm_node *N2 = N1+1; N2 != end; N2++) {
            ffm_int j2 = N2->j;
            ffm_int f2 = N2->f;
            ffm_float v2 = N2->v;
            if(j2 >= model.n || f2 >= model.m)
                continue;

            ffm_float *w1 = model.W + (ffm_long)j1*align1 + f2*align0;
            ffm_float *w2 = model.W + (ffm_long)j2*align1 + f1*align0;

            ffm_float v = v1 * v2 * r;

            if(do_update) {
                ffm_float *wg1 = w1 + kALIGN;
                ffm_float *wg2 = w2 + kALIGN;
                for(ffm_int d = 0; d < align0; d += kALIGN * 2)
                {
                    ffm_float g1 = lambda * w1[d] + kappa * w2[d] * v;
                    ffm_float g2 = lambda * w2[d] + kappa * w1[d] * v;

                    wg1[d] += g1 * g1;
                    wg2[d] += g2 * g2;

                    w1[d] -= eta / sqrt(wg1[d]) * g1;
                    w2[d] -= eta / sqrt(wg2[d]) * g2;
                }
            } else {
                for(ffm_int d = 0; d < align0; d += kALIGN * 2)
                    t += w1[d] * w2[d] * v;
            }
        }
    }

    return t;
}
 

問題1.ffm_node *end = &prob.X[prob.P[i+1]]下標越界問題

解決方法：

初始化時設定為(P[l]+1)

        P.resize(l+1);
        f.read(reinterpret_cast<char*>(P.data()), sizeof(ffm_long) * (l+1));

        X.resize(P[l]+1);
        f.read(reinterpret_cast<char*>(X.data()), sizeof(ffm_node) * (P[l]+1));

        ffm_long nnz = P[l];
        meta.l += l;

        f_bin.write(reinterpret_cast<char*>(&l), sizeof(ffm_int));
        f_bin.write(reinterpret_cast<char*>(Y.data()), sizeof(ffm_float) * l);
        f_bin.write(reinterpret_cast<char*>(R.data()), sizeof(ffm_float) * l);
        f_bin.write(reinterpret_cast<char*>(P.data()), sizeof(ffm_long) * (l+1));
        f_bin.write(reinterpret_cast<char*>(X.data()), sizeof(ffm_node) * (nnz+1));

問題2.ffm_model model = init_model(tr.meta.n, tr.meta.m, param);時model.K資料接不到

解決方法：

由於函式結束時解構函式會釋放該記憶體資料，只能先停用解構函式

struct ffm_model {
    ffm_int n; // number of features
    ffm_int m; // number of fields
    ffm_int k; // number of latent factors
    ffm_float *W = nullptr;
    bool normalization;
    //~ffm_model();
};

/*
ffm_model::~ffm_model() {
    if(W != nullptr) {
#ifndef USESSE
        free(W);
#else
    #ifdef _WIN32
        _aligned_free(W);
    #else
        free(W);
    #endif
#endif
        W = nullptr;
    }
}
*/

train測試截圖

以及輸出model（二進位制檔案）

不過你們不要輕易開啟，看看大小就可以了。

四.總結

在DSP的場景中，FFM主要用來預估站內的CTR和CVR。在訓練FFM的過程中，有許多小細節值得特別關注。
第一，樣本歸一化。FFM預設是進行樣本資料的歸一化，即 pa.normpa.norm 為真；若此引數設定為假，很容易造成資料inf溢位，進而引起梯度計算的nan錯誤。因此，樣本層面的資料是推薦進行歸一化的。
第二，特徵歸一化。CTR/CVR模型採用了多種型別的源特徵，包括數值型和categorical型別等。但是，categorical類編碼後的特徵取值只有0或1，較大的數值型特徵會造成樣本歸一化後categorical類生成特徵的值非常小，沒有區分性。例如，一條使用者-商品記錄，使用者為“男”性，商品的銷量是5000個（假設其它特徵的值為零），那麼歸一化後特徵“sex=male”（性別為男）的值略小於0.0002，而“volume”（銷量）的值近似為1。特徵“sex=male”在這個樣本中的作用幾乎可以忽略不計，這是相當不合理的。因此，將源數值型特徵的值歸一化到 [0,1][0,1] 是非常必要的。
第三，省略零值特徵。從FFM模型的表示式(4)(4)可以看出，零值特徵對模型完全沒有貢獻。包含零值特徵的一次項和組合項均為零，對於訓練模型引數或者目標值預估是沒有作用的。因此，可以省去零值特徵，提高FFM模型訓練和預測的速度，這也是稀疏樣本採用FFM的顯著優勢。

五.相關學習資源

六.原始碼下載

注：提供了FFM-predict.cpp預測和FFM-train.cpp訓練兩個介面