NMF算法簡介及python實現(gradient descent)

原文鏈接：http://www.albertauyeung.com/mf.php

基本原理

NMF，非負矩陣分解，它的目標很明確，就是將大矩陣分解成兩個小矩陣，使得這兩個小矩陣相乘後能夠還原到大矩陣。而非負表示分解的矩陣都不包含負值。 從應用的角度來說，矩陣分解能夠用於發現兩種實體間的潛在特徵，一個最常見的應用就是協同過濾中的預測打分值，而從協同過濾的這個角度來說，非負也很容易理解：打分都是正的，不會出現負值。

在例如Netflix或MovieLens這樣的推薦系統中，有用戶和電影兩個集合。給出每個用戶對部分電影的打分，我們希望預測該用戶對其他沒看過電影的打分值，這樣可以根據打分值爲其做出推薦。用戶和電影的關係，可以用一個矩陣來表示，每一行表示用戶，每一列表示電影，每個元素的值表示用戶對已經看過的電影的打分，矩陣看起來如下：

	D1	D2	D3	D4
U1	5	3	-	1
U2	4	-	-	1
U3	1	1	-	5
U4	1	-	-	4
U5	-	1	5	4

而使用矩陣分解來預測評分的思想來源於，我們可以通過矩陣分解來發現一些用戶打分的潛在特徵。比如兩個人都喜歡某一演員，那他們就傾向於給TA演的電影打高分；或者兩個人都喜歡動作片。假如我們能夠發現這些特徵，我們就能夠預測特定用戶對特定電影的打分。

爲了發現不同的特徵，我們假設特徵的數量少於用戶和電影的數量（要是每個用戶都有一個獨立特徵，那代價也太大啦）。

數學基礎

首先，我們定義U爲用戶的集合，D爲電影的集合，R = U * D，爲評分的集合。假設我們需要尋找K個特徵，則我們的目標是，找到兩個矩陣P和Q，使得它們相乘近似等於R。即：

這樣P的每一行表示用戶，每一列表示一個特徵，它們的值表示用戶與某一特徵的相關性，值越大，表明特徵越明顯。同理，Q的每一行表示電影，每一列表示電影與特徵的關聯。最後爲了預測用戶ui對特定電影dj的評分，我們可以直接計算ui和dj對應的特徵向量的點積，即：

現在我們就來計算P和Q。最簡單的方法就是梯度下降，該方法先初始化P和Q爲特定的值，計算它們的乘積與真實矩陣的誤差，然後通過迭代，逐漸減小誤差直至收斂。

由於誤差可大可小，這裏使用平方根誤差(squared error)來計算，計算公式如下：

即循環地計算每一條目的誤差，最後相加。

爲了最小化誤差，我們需要知道怎麼改變Pik和Qkj的值(在梯度下降中表現爲下降的方向)。我們對這個公式求偏微分，即得：

計算出梯度之後，我們逐步更新Pik和Qkj：

上面公式中，爲梯度下降常數，通常取一個較小的值（防止無法收斂），如0.0002。

有人可能會問一個問題：假如我們計算出P和Q，使得P*Q近似等於R，那麼那些未評分的不全是0了麼？首先，我們並不要求P*Q精確等於R；其次，我們輸入的數據是所有已評分的數據（或它的子集），即訓練集，而並不包含未評分的數據。因此，它能夠對未評分的做出不等於0的預測。

通過上面的更新規則，我們就可以逐步減小誤差，直至收斂：

規範化

上面的算法只是最簡單的一個實現，實際使用中可能複雜得多。一個最常見的修改就是引入規範化，以防止過度擬合。這通過加入另外一個參數來修改誤差公式：

參數用來控制用戶特徵向量與條目特徵向量的比例，以避免出現特徵向量中出現特別大的值。實際應用中，通常設置爲0~0.02之間的值。因此更新公式變成：

一個簡單的python實現如下（需要安裝numpy）

import numpy
 
def matrix_factorisation(R, P, Q, K, steps=5000, alpha=0.0002, beta=0.02):
    Q = Q.T
    for step in range(steps):
        for i in range(len(R)):
            for j in range(len(R[i])):
                if R[i][j] > 0:
                    eij = R[i][j] - numpy.dot(P[i,:],Q[:,j])
                    for k in range(K):
                        P[i][k] = P[i][k] + alpha * (2 * eij * Q[k][j] - beta * P[i][k])
                        Q[k][j] = Q[k][j] + alpha * (2 * eij * P[i][k] - beta * Q[k][j])
        eR = numpy.dot(P,Q)
        e = 0
        for i in range(len(R)):
            for j in range(len(R[i])):
                if R[i][j] > 0:
                    e = e + pow(R[i][j] - numpy.dot(P[i,:],Q[:,j]), 2)
                    for k in range(K):
                        e = e + (beta/2) * (pow(P[i][k],2) + pow(Q[k][j],2))
        if e < 0.001:
            break
    return P, Q.T

使用示例如下：

R = [
     [5,3,0,1],
     [4,0,0,1],
     [1,1,0,5],
     [1,0,0,4],
     [0,1,5,4],
    ]
 
R = numpy.array(R)
 
N = len(R)
M = len(R[0])
K = 2
 
P = numpy.random.rand(N,K)
Q = numpy.random.rand(M,K)
 
nP, nQ = matrix_factorisation(R, P, Q, K)
nR = numpy.dot(nP, nQ.T)
print(nR)

最後P*Q還原出的矩陣如下：

	D1	D2	D3	D4
U1	4.97	2.98	2.18	0.98
U2	3.97	2.40	1.97	0.99
U3	1.02	0.93	5.32	4.93
U4	1.00	0.85	4.59	3.93
U5	1.36	1.07	4.89	4.12

可以看到，還原後的矩陣跟原矩陣很接近，並且對原來空缺的值作出了預測。在這個例子中，我們可以看到U1和U2口味比較接近，他們都喜歡D1和D2。而其他的用戶則喜歡D3,D4和D5。

以上轉自：http://blog.csdn.net/inte_sleeper/article/details/7294003