矩阵分解-汇总

相似度计算

1.欧式距离（Euclidean Distance）

def EuclideanDistance(x,y):
    d = 0
    for a,b in zip(x,y):
        d += (a-b)**2
    return d**0.5
使用 numpy 简化：
import numpy as np
def EuclideanDistance(dataA,dataB):
    # np.linalg.norm 用于范数计算，默认是二范数，相当于平方和开根号
    return 1.0/(1.0 + np.linalg.norm(dataA - dataB))

2.余弦相似度（Cosine）

1. Python 代码的简单按公式还原：
def Cosine(x,y):
    sum_xy = 0.0;  
    normX = 0.0;  
    normY = 0.0;  
    for a,b in zip(x,y):  
        sum_xy += a*b  
        normX += a**2  
        normY += b**2  
    if normX == 0.0 or normY == 0.0:  
        return None  
    else:  
        return sum_xy / ((normX*normY)**0.5)  
2. 使用 numpy 简化夹角余弦
def Cosine(dataA,dataB):
    sumData = dataA *dataB.T # 若列为向量则为 dataA.T * dataB
    denom = np.linalg.norm(dataA) * np.linalg.norm(dataB)
    # 归一化
    return 0.5 + 0.5 * (sumData / denom)

3.皮尔逊相关系数（Pearson）

相比于余弦相似度，皮尔森相关系数通过使用用户平均分对独立评分进行修正，减小了用户评分偏置的影响。

另一个博主描述

Python 代码实现皮尔逊相关系数：
def Pearson(x,y):
    sum_XY = 0.0
    sum_X = 0.0
    sum_Y = 0.0
    normX = 0.0
    normY = 0.0
    count = 0
    for a,b in zip(x,y):
        count += 1
        sum_XY += a * b
        sum_X += a
        sum_Y += b
        normX += a**2
        normY += b**2
    if count == 0:
        return 0
    # denominator part
    denominator = (normX - sum_X**2 / count)**0.5 * (normY - sum_Y**2 / count)**0.5
    if denominator == 0:
        return 0
    return (sum_XY - (sum_X * sum_Y) / count) / denominator
numpy 简化实现皮尔逊相关系数
def Pearson(dataA,dataB):
    # 皮尔逊相关系数的取值范围(-1 ~ 1),0.5 + 0.5 * result 归一化(0 ~ 1)
    return 0.5 + 0.5 * np.corrcoef(dataA,dataB,rowvar = 0)[0][1]

用余弦相似度相同的方法实现皮尔逊：

余弦相似度、修正余弦相似度、皮尔逊相关系数的关系
Pearson 减去的是每个item i 的被打分的均值
def Pearson(dataA,dataB):
    avgA = np.mean(dataA)
    avgB = np.mean(dataB)
    sumData = (dataA - avgA) * (dataB - avgB).T # 若列为向量则为 dataA.T * dataB
    denom = np.linalg.norm(dataA - avgA) * np.linalg.norm(dataB - avgB)
    # 归一化
    return 0.5 + 0.5 * (sumData / denom)

4.修正余弦相似度（Adjusted Cosine）

跟皮尔逊不同在于，减的是整体均值
为什么需要在余弦相似度的基础上使用修正余弦相似度
X和Y两个用户对两个内容的评分分别为（1,2）和（4,5），使用余弦相似度得到的结果是0.98，两者极为相似。但从评分上看X似乎不喜欢2这个 内容，而Y则比较喜欢，余弦相似度对数值的不敏感导致了结果的误差，需要修正这种不合理性

#修正余弦相似度 # 修正cosine 减去的是对item i打过分的每个user u，其打分的均值
data = np.mat([[1,2,3],[3,4,5]])
avg = np.mean(data[:,0]) # 下标0表示正在打分的用户
def AdjustedCosine(dataA,dataB,avg):
    sumData = (dataA - avg) * (dataB - avg).T # 若列为向量则为 dataA.T * dataB
    denom = np.linalg.norm(dataA - avg) * np.linalg.norm(dataB - avg)
    return 0.5 + 0.5 * (sumData / denom)
print(AdjustedCosine(data[0,:],data[1,:],avg))

5.汉明距离（Hamming Distance）

汉明距离表示的是两个字符串（相同长度）对应位不同的数量。比如有两个等长的字符串 str1 = “11111” 和 str2 = “10001” 那么它们之间的汉明距离就是3（这样说就简单多了吧。哈哈）。汉明距离多用于图像像素的匹配（同图搜索）。

1.Python 的矩阵汉明距离简单运用：

def hammingDistance(dataA,dataB):
    distanceArr = dataA - dataB
    return np.sum(distanceArr == 0)# 若列为向量则为 shape[0]

6.曼哈顿距离(Manhattan Distance)

def Manhattan(dataA,dataB):
    return np.sum(np.abs(dataA - dataB))
print(Manhattan(dataA,dataB))

范数

二部图邻接矩阵的特征值 呈现出正负成对出现的现象

SVD

Funk-SVD,隐语义模型最大的区别

上面各种矩阵方法都是基于大量的矩阵计算，一步到位分解，计算复杂度很高
而Funk-SVD或称作隐语义模型，更像是线性映射的单层神经网络，它求解过程是最优化问题，是通过梯度下降或者其他方法，去拟合，逼近原始矩阵，从而确定参数