《机器学习实战》学习笔记——第14章 利用SVD简化数据

一. SVD

1. 基本概念：

（1）定义：提取信息的方法：奇异值分解Singular Value Decomposition（SVD）

（2）优点：简化数据， 去除噪声，提高算法的结果

（3）缺点：数据转换难以想象，耗时，损失特征

（4）适用于：数值型数据

2. 应用：

（1）隐性语义索引（LSI/LSA）

（2）推荐系统

3. 原理——矩阵分解

将原始的数据集矩阵data(m*n)分解成三个矩阵U(m*n), Sigma(n*m), VT(m*n):

对于Sigma矩阵:

• 该矩阵只用对角元素，其他元素均为零
• 对角元素从大到小排列。这些对角元素称为奇异值，它们对应了原始数据集矩阵的奇异值
• 这里的奇异值就是矩阵data特征值的平方根。
• 在某个奇异值的数目（ 1个 ）之后，其他的奇异值都置为0。这就意味着数据集中仅有r个重要特征，而其余特征则都是噪声或冗余特征。 
  • 确认r——启发式策略
    • 保留矩阵中90%的能量信息，将奇异值平方和累加加到90%
    • 若有上万奇异值，则保留2-3k

4. 实现：

Numpy中称为linalg的线性代数工具：la.svd()

import numpy as np
from numpy impot linalg as la
 
data = np.array([[4, 4, 0, 2, 2],
           [4, 0, 0, 3, 3],
           [4, 0, 0, 1, 1],
           [1, 1, 1, 2, 0],
           [2, 2, 2, 0, 0],
           [1, 1, 1, 0, 0],
           [5, 5, 5, 2, 0]])
 
U, Sigma, VT  = la.svd(data)

二、推荐系统实现

2.1. 基于协同过滤的推荐系统（Collaborate Filtering）

　　协同过滤是通过将用户和其他用户的数据进行对比来实现推荐的。

2.1.1 相似度计算

　　1. 欧式距离（0~1）：

　　　　相似度 = 1/ (1 + 距离)

　　2. 皮尔逊相关系数(Pearson correlation):

　　　　

• 介绍：http://mines.humanoriented.com/classes/2010/fall/csci568/portfolio_exports/sphilip/pear.html
• 该方法相对于欧氏距离的一个优势在于，它对用户评级的量级并不敏感。比如某个狂躁者对所有物品的评分都是5分 ，而另一个忧郁者对所有物品的评分都是1分，皮尔逊相关系数会认为这两个向量是相等的。
• 皮尔逊相关系数的计算是由Numpy中的corrcoef()函数，他的取值范围在：(-1~1)
• 后面我们很快就会用到它了。皮尔逊相关系数的取值范围从-1到+1，
• 我们通过0.5 + 0 . 5 * corrcoef()把其取值范围归一化到0到 1之间。

3. 余弦相似度（cosine similarity）

　　　　

其中，在Numpy中计算范数的公式：linalg.norm()

 def ecludSim(inA,inB):
     return 1.0/(1.0 + la.norm(inA - inB))  #计算向量的第二范式,相当于直接计算了欧式距离
 
 def pearsSim(inA, inB):
     if len(inA) < 3:
         return 1.0
     return 0.5 + 0.5 * corrcoef(inA, inB, rowvar=0)[0][1]
 # corrcoef直接计算皮尔逊相关系数
 
 def cosSim(inA, inB):
     num = float(inA.T * inB)
     denom = la.norm(inA) * la.norm(inB)
     return 0.5 + 0.5 * (num/denom)

上面的相似度计算都是假设数据采用了列向量方式进行表示。如果利用上述函数来计算两个行向量的相似度就会遇到问题（我们很容易对上述函数进行修改以计算行向量之间的相似度)。这里采用列向量的表示方法，暗示着我们将利用基于物品的相似度计算方法。

2.1.2 基于物品的相似度还是基于用户的相似度？

行与行之间比较的是基于用户的相似度，列与列之间比较的则是基于物品的相似度。

到底使用哪一种相似度呢？这取决于用户或物品的数目。基于物品相似度计算的时间会随物品数量的增加而增加，基于用户的相似度计算的时间则会随用户数量的增加而增加。如果我们有一个商店，那么最多会有几千件商品。在撰写本书之际，最大的商店大概有100 000件商品。而在\61!«\大赛中，则会有480 000个用户和17 700部电影。如果用户的数目很多，那么我们可能倾向于使用基于物品相似度的计算方法。对于大部分产品导向的推荐引擎而言，用户的数量往往大于物品的数量，即购买商品的用户数会多于出售的商品种类。

2.1.3 推荐系统的评价

• 采用交叉测试的方法。具体的做法就是，我们将某些已知的评分值去掉，然后对它们进行预测，最后计算预测值和真实值之间的差异。
• 评价的指标是称为最小均方根误差（ RootMeanSquaredError, RMSE ) 的指标。
  • 它首先计算均方误差的平均值然后取其平方根。
  • 如果评级在1星到5星这个范围内，而我们得到的为1.0,那么就意味着我们的预测值和用户给出的真实评价相差了一个星级。

2.1.4 实现：

 def loadExData():
     return[[4, 4, 0, 2, 2],
            [4, 0, 0, 3, 3],
            [4, 0, 0, 1, 1],
            [1, 1, 1, 2, 0],
            [2, 2, 2, 0, 0],
            [1, 1, 1, 0, 0],
            [5, 5, 5, 2, 0]]
 
 def loadExData2():
     return[[0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 5],
            [0, 0, 0, 3, 0, 4, 0, 0, 0, 0, 3],
            [0, 0, 0, 0, 4, 0, 0, 1, 0, 4, 0],
            [3, 3, 4, 0, 0, 0, 0, 2, 2, 0, 0],
            [5, 4, 5, 0, 0, 0, 0, 5, 5, 0, 0],
            [0, 0, 0, 0, 5, 0, 1, 0, 0, 5, 0],
            [4, 3, 4, 0, 0, 0, 0, 5, 5, 0, 1],
            [0, 0, 0, 4, 0, 4, 0, 0, 0, 0, 4],
            [0, 0, 0, 2, 0, 2, 5, 0, 0, 1, 2],
            [0, 0, 0, 0, 5, 0, 0, 0, 0, 4, 0],
            [1, 0, 0, 0, 0, 0, 0, 1, 2, 0, 0]]
 
 # 协同过滤算法
 # dataMat 用户数据 user 用户 simMeas 相似度计算方式 item 物品
 def standEst(dataMat, user, simMeas, item):
     n = shape(dataMat)[1]  # 计算列的数量，物品的数量
     simTotal = 0.0
     ratSimTotal = 0.0
     for j in range(n):
         userRating = dataMat[user, j]
         print(dataMat[user, j])
         if userRating == 0:
             continue  # 如果用户u没有对物品j进行打分，那么这个判断就可以跳过了
         overLap = nonzero(logical_and(dataMat[:, item] > 0, dataMat[:, j] > 0))[0]  # 找到对物品 j 和item都打过分的用户
         if len(overLap) == 0:
             similarity = 0
         else:
             similarity = simMeas(dataMat[overLap, item], dataMat[overLap, j])  # 利用相似度计算两个物品之间的相似度
 
         print('the %d and %d similarity is: %f' % (item, j, similarity))
         simTotal += similarity
         ratSimTotal += similarity * userRating  # 待推荐物品与用户打过分的物品之间的相似度*用户对物品的打分
     if simTotal == 0:
         return 0
     else:
         return ratSimTotal / simTotal
 
 def recommand(dataMat, user, N=3, simMeas=pearsSim, estMethod=standEst):
     unratedItem = nonzero(dataMat[user, :]==0)[0]
     if len(unratedItem) == 0:
         return  'You rated everything'
     else:
         itemScores=[]
         # 对于为评分的item，对他进行评分
         for item in unratedItem:
             estimatedScore = standEst(dataMat, user, simMeas, item)
             itemScores.append((item, estimatedScore))
     itemScores = sorted(itemScores, key=lambda jj: jj[1], reverse=True)[:N]
     print(itemScores)
 
 data = array(loadExData())
 recommand(data, 2)
         

2.2 利用SVD实现推荐

2.2.1 选取Sigma奇异值个数r:

 # 获取数据：
 data = np.array(loadExData2())
 
 # SVD 分解
 U, Sigma, VT = la.svd(data)
 
 # 计算取几个奇异值
 # 计算90%能量：487.83
 Sig2 = Sigma ** 2
 s = sum(Sig2) * 0.9
 
 # 计算前两个奇异值包含能量:378（<487.83）
 sum(Sig2[:2])
 
 # 计算前三个奇异值包含能量:500(>487)
 sum(Sig2[:3])
 #所以选择前三个就可以了

2.2.2 用SVD实现推荐系统：

 #  利用SVD实现推荐系统
 def svdEst(dataMat, user, simMeas, item):
     n = shape(dataMat)[1]
     simTotal = 0.0
     ratsimTotal = 0.0
     U, Sigma, VT = la.svd(dataMat)
     Sig4 = array(eye(4) * Sigma[:4])
     xformedItems = dot(dot(dataMat.T, U[:, :4]), Sig4)
 
     for j in range(n):
         userRating = dataMat[user, j]
         if userRating == 0 or j == item:
             continue
         similarity = simMeas(xformedItems[item, :].T, xformedItems[j, :].T)
         simTotal += similarity
         ratsimTotal += userRating * similarity
     if simTotal == 0:
         return 0
     else:
         return ratsimTotal/simTotal
 
 def recommand(dataMat, user, N=3, simMeas=pearsSim, estMethod=standEst):
     unratedItem = nonzero(dataMat[user, :]==0)[0]
     if len(unratedItem) == 0:
         return  'You rated everything'
     else:
         itemScores=[]
         # 对于为评分的item，对他进行评分
         for item in unratedItem:
             estimatedScore = svdEst(dataMat, user, simMeas, item)
             itemScores.append((item, estimatedScore))
     itemScores = sorted(itemScores, key=lambda jj: jj[1], reverse=True)[:N]
     print(itemScores)
 
 data = array(loadExData())
 recommand(data, 2)

最后结果：

2.3 冷启动问题

推荐引擎面临的另一个问题就是如何在缺乏数据时给出好的推荐。这称为冷启动问题，处理起来十分困难。

冷启动问题的解决方案，就是将推荐看成是搜索问题。在内部表现上，不同的解决办法虽然有所不同，但是对用户而言却都是透明的。为了将推荐看成是搜索问题，我们可能要使用所需要推荐物品的属性。在餐馆菜肴的例子中,我们可以通过各种标签来标记菜肴，比如素食、美式88、价格很贵等。同时，我们也可以将这些属性作为相似度计算所需要的数据，这被称为基于内容(content-based)的推荐。可能，基于内容的推荐并不如我们前面介绍的基于协同过滤的推荐效果好 ，但我们拥有它，这就是个良好的开始。