当前位置： →
→ 云计算数据挖掘Mahout下的机器学习
云计算数据挖掘Mahout下的机器学习
& 作者及来源： SamWu - 博客园 &
&收藏到→_→：
摘要: 云计算数据挖掘Mahout下的机器学习
"云计算数据挖掘Mahout下的机器学习"：：
apache mahout 是 apachesoftware foundation (asf) 旗下的一个开源项目，提供一些可扩展的机器学习领域经典算法的实现，旨在帮助更加方便快捷地创建智能，并且，在 mahout 的最近版本中还加入了对apache hadoop 的支持，使这些算法可以更高效的运行在环境中。
在mahout实现的机器学习算法见下表：
logistic regression
支持向量机
perceptron
感知器算法
neural network
random forests
restricted boltzmann machines
有限波尔兹曼机
canopy clustering
canopy聚类
k-means clustering
fuzzy k-means
expectation maximization
em聚类（期望最大化聚类）
mean shift clustering
均值漂移聚类
hierarchical clustering
dirichlet process clustering
狄里克雷过程聚类
latent dirichlet allocation
spectral clustering
关联规则挖掘
parallel fp growth algorithm
并行fp growth算法
locally weighted linear regression
局部加权线性回归
降维/维约简
singular value decomposition
奇异值分解
principal components analysis
主成分分析
independent component analysis
独立成分分析
gaussian discriminative analysis
高斯判别分析
并行化了watchmaker框架
推荐/协同过滤
non-distributed recommenders
taste(usercf, itemcf, slopeone）
distributed recommenders
向量相似度计算
rowsimilarityjob
计算列间相似度
vectordistancejob
计算向量间距离
非map-reduce算法
hidden markov models
隐马尔科夫模型
集合方法扩展
collections
扩展了java的collections类
mahout最大的优点就是基于hadoop实现，把很多以前运行于单机上的算法，转化为了mapreduce模式，这样大大提升了算法可处理的数据量和处理性能。
mahout下个性化推荐引擎taste介绍
taste是&apache mahout&提供的一个个性化推荐引擎的高效实现，该引擎基于java实现，可扩展性强，同时在mahout中对一些推荐算法进行了mapreduce编程模式转化，从而可以利用hadoop的分布式架构，提高推荐算法的性能。
在mahout0.5版本中的taste，&实现了多种推荐算法，其中有最基本的基于用户的和此文来自: 马开东博客
转载请注明出处 网址：
基于内容的推荐算法，也有比较高效的slopeone算法，以及处于研究阶段的基于svd和线性插值的算法，同时taste还提供了扩展接口，用于定制化开发基于内容或基于模型的个性化推荐算法。
taste&不仅仅适用于&java&，还可以作为内部服务器的一个组件以&http&和&web service&的形式向外界提供推荐的逻辑。taste&的设计使它能满足企业对推荐引擎在性能、灵活性和可扩展性等方面的要求。
下图展示了构成taste的核心组件：
从上图可见，taste由以下几个主要组件组成：
datamodel：datamodel是用户喜好信息的抽象接口，它的具体实现支持从指定类型的数据源抽取用户喜好信息。在mahout0.5中，taste&提供jdbcdatamodel&和&filedatamodel两种类的实现，分别支持从和文件文件系统中读取用户的喜好信息。对于的读取支持，在mahout 0.5中只提供了对和postgresql的支持，如果在，或者是把数据导入到这两个中，或者是自行编程实现相应的类。
&&& usersimilarit和itemsimilarity：前者用于定义两个用户间的相似度，后者用于定义两个项目之间的相似度。mahout支持大部分驻留的相似度或相关度计算方法，针对不同的数据源，需要合理选择相似度计算方法。
&&& userneighborhood：在基于用户的推荐方法中，推荐的内容是基于找到与当前用户喜好相似的&邻居用户&的方式产生的，该组件就是用来定义与目标用户相邻的&邻居用户&。所以，该组件只有在基于用户此文来自: 马开东博客
转载请注明出处 网址：
的推荐算法中才会被使用。
&&&&&recommender：recommender是推荐引擎的抽象接口，taste&中的核心组件。利用该组件就可以为指定用户生成项目推荐列表。
mahout源码目录说明
mahout项目是由多个子项目组成的，各子项目分别位于源码的不同目录下，下面对mahout的组成进行介绍：
1、mahout-core：核心程序模块，位于/core目录下；
2、mahout-math：在核心程序中使用的一些数据通用计算模块，位于/math目录下；
3、mahout-utils：在核心程序中使用的一些通用的工具性模块，位于/utils目录下；
上述三个部分是程序的主题，存储所有mahout项目的源码。
另外，mahout提供了样例程序，分别在taste-web和examples目录下：
4、taste-web：利用mahout推荐算法而建立的基于web的个性化推荐系统demo；
5、examples：对mahout中各种机器学习算法的；
6、bin：bin目录下只有一个名为mahout的文件，是一个shell脚本文件，用于在hadoop平台的命令行下调用mahout中的程序；
在buildtools、eclipse和distribution目录下，有mahout相关的配置文件
7、buildtools目录下是用于核心程序构建的配置文件，以mahout-buildtools的模块名称在mahout的pom.xml文件中进行说明；
8、eclipse下的xml文件是对利用eclipse开发mahout的配置说明；
9、distribution目录下有两个配置文件：bin.xml和src.xml，进行mahou安装时的一些配置信息。
（在开发的时候一般很少对这个目录下的文件进行修改，所以不用太关注，知道大体什么意思就ok）
另 外，在mahout的下载地址下可以看到有个文件夹与mahout处于同一级别，它是mahout项目的分支项目&mahout- collections，用于实现了核心程序中使用的集合类操作，该于mahout进行开发，是对标准jdk中关于集合类的修改，使其可以适应数 据密集型项目的开发。
在windows xp下利用eclipse构建mahout
1. mahout构建的先决条件
1） jdk，使用1.6版本。需要说明一下，因为要基于eclipse构建，所以在设置path的值之前要先定义java_home变量。
2） maven，使用2.0.11版本或以上。在eclipse上安装maven插件&m2eclipse。
2. mahout源码获取
与其他apache下开源项目类似，可以有两种获取源码的方法：
一是通过subversion检出，检出命令和地址如下
svn co http://svn.apache.org/repos/asf/mahout/trunk
二是直接下载发行版本，下载地址：//mahout/，打开该地址，可以看到如下目录组织：
到发文为止mahout的发行版本到0.5，点击进入0.5/，进入源码页，如下图：
红色框中的就是mahout的源码压缩文件，可以根据安装的解压工具选择任意一个进行下载。
另外，下载发行版也可以到maven的在线资源库中下载，地址如下：
http://repo2.maven.org/maven2/org/apache/mahout/
3. mahout构建
1）解压mahout源码压缩文件，了解目录结构
利用解压工具把下载的解压到当前目录，点击进入，可以看到如下目录结构（使用subversion检出的可以在检出的当前目下看到如下目录结构）：
2）把源码导入eclipse中
打开eclipse，点击file-&import 在开打的对话框中，选择导入maven项目如下图，然后点击next
通过浏览方式，确定mahout源码的根目录，如下图，然后点击finish：
至此，通过eclipse的package explore 可以查看导入的mahout项目的组成，如下图：
3）运行编译
运行时，点开mahout-distribution-0.5，选中其下的pom.xml文件，然后右键选择run as项搜索此文相关文章：Mahout下的机器学习此文来自: 马开东博客
网址: 站长QQ
云计算数据挖掘Mahout下的机器学习_博客园相关文章
博客园_总排行榜
博客园_最新
博客园_月排行榜
博客园_周排行榜
博客园_日排行榜机器学习（74）
转自别处&有很多与此类似的文章&&也不知道谁是原创 因原文由少于错误 所以下文对此有修改并且做了适当的重点标记(横线见的内容没大明白 并且有些复杂，后面的运行流程依据前面的得出的算子进行分类)
谓LR分类器(Logistic Regression Classifier)，并没有什么神秘的。在分类的情形下，经过学习之后的LR分类器其实就是一组权值w0,w1,...,wm.
当测试样本集中的测试数据来到时，这一组权值按照与测试数据线性加和的方式，求出一个z值：
z = w0+w1*x1+w2*x2+...+wm*xm。
① （其中x1,x2,...,xm是某样本数据的各个特征，维度为m）
之后按照sigmoid函数的形式求出：
σ(z) = 1 / (1+exp(z)) 。②
由于sigmoid函数的定义域是(-INF, +INF),而值域为(0, 1)。因此最基本的LR分类器适合于对两类目标进行分类。
那么LR分类器的这一组权值w0,w1,...,wm是如何求得的呢？这就需要涉及到极大似然估计MLE和优化算法的概念了。
我们将sigmoid函数看成样本数据的概率密度函数，每一个样本点，都可以通过上述的公式①和②计算出其概率密度
1.逻辑回归模型
1.1逻辑回归模型
考虑具有p个独立变量的向量,设条件概率为根据观测量相对于某事件发生的概率。逻辑回归模型可表示为
　　　　　　　　　（1.1）
上式右侧形式的函数称为称为逻辑函数。下图给出其函数图象形式。
其中。如果含有名义变量，则将其变为dummy变量。一个具有k个取值的名义变量，将变为k-1个dummy变量。这样，有
　　定义不发生事件的条件概率为
那么，事件发生与事件不发生的概率之比为
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& （1.4）
这个比值称为事件的发生比(the odds of experiencing an event),简称为odds。因为0&p&1,故odds&0。对odds取对数，即得到线性函数，
　　　　　　（1.5），
1.2极大似然函数
　　假设有n个观测样本，观测值分别为设为给定条件下得到yi=1（原文）的概率。在同样条件下得到yi=0（）的条件概率为。于是，得到一个观测值的概率为
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& (1.6)&&&& -----此公式实际上是综合前两个等式得出，并无特别之处
&因为各项观测独立，所以它们的联合分布可以表示为各边际分布的乘积。
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
上式称为n个观测的似然函数。我们的目标是能够求出使这一似然函数的值最大的参数估计。于是，最大似然估计的关键就是求出参数，使上式取得最大值。
对上述函数求对数
&& （1.8）
上式称为对数似然函数。为了估计能使取得最大的参数的值。
对此函数求导，得到p+1个似然方程。
&&&&&&&&&& （1.9）
，j=1,2,..,p.-----p为独立向量个数
&上式称为似然方程。为了解上述非线性方程，应用牛顿－拉斐森(Newton-Raphson)方法进行迭代求解。
1.3　牛顿－拉斐森迭代法
　　对求二阶偏导数，即Hessian矩阵为
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&& （1.10）
如果写成矩阵形式，以Ｈ表示Hessian矩阵，Ｘ表示
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
&&&&&&&&&&&&&&&&&&&&&&&& （1.12）
则。再令(注：前一个矩阵需转置)，即似然方程的矩阵形式。
得牛顿迭代法的形式为
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
注意到上式中矩阵Ｈ为对称正定的，求解即为求解线性方程ＨＸ＝Ｕ中的矩阵Ｘ。对Ｈ进行cholesky分解。
最大似然估计的渐近方差（asymptotic variance）和协方差(covariance)可以由信息矩阵（information matrix）的逆矩阵估计出来。而信息矩阵实际上是二阶导数的负值，表示为。估计值的方差和协方差表示为，也就是说，估计值的方差为矩阵Ｉ的逆矩阵的对角线上的值，而估计值和的协方差(和的协方差等于？不解。。。)为除了对角线以外的值。然而在多数情况，我们将使用估计值的标准方差，表示为
，for j=0,1,2,…,p&&&&&&&&&&&&&&&&&&&&&&& （1.14）
-----------------------------------------------------------------------------------------------------------------------------------------------
２.显著性检验
下面讨论在逻辑回归模型中自变量是否与反应变量显著相关的显著性检验。零假设：＝0（表示自变量对事件发生可能性无影响作用）。如果零假设被拒绝，说明事件发生可能性依赖于的变化。
2.1 Wald test
对回归系数进行显著性检验时，通常使用Wald检验，其公式为
其中, 为的标准误差。这个单变量Wald统计量服从自由度等于１的分布。
　　如果需要检验假设：＝0,计算统计量
其中，为去掉所在的行和列的估计值，相应地，为去掉所在的行和列的标准误差。这里，Wald统计量服从自由度等于p的分布。如果将上式写成矩阵形式，有
矩阵Ｑ是第一列为零的一常数矩阵。例如，如果检验，则。
　　然而当回归系数的绝对值很大时，这一系数的估计标准误就会膨胀，于是会导致Wald统计值变得很小，以致第二类错误的概率增加。也就是说，在实际上会导致应该拒绝零假设时却未能拒绝。所以当发现回归系数的绝对值很大时，就不再用Wald统计值来检验零假设，而应该使用似然比检验来代替。
2.2　似然比（Likelihood ratio test）检验
　　在一个模型里面，含有变量与不含变量的对数似然值乘以-2的结果之差，服从分布。这一检验统计量称为似然比(likelihood
ratio)，用式子表示为
计算似然值采用公式（1.8）。
倘若需要检验假设：＝0,计算统计量
&&& （2.5）
式中，表示＝0的观测值的个数，而表示＝１的观测值的个数，那么n就表示所有观测值的个数了。实际上，上式的右端的右半部分表示只含有的似然值。统计量G服从自由度为p的分布
2.3 Score检验
　　在零假设：＝0下，设参数的估计值为，即对应的＝0。计算Score统计量的公式为
　　　　　　　　　　（2.6）
上式中，表示在＝0下的对数似然函数（1.9）的一价偏导数值，而表示在＝0下的对数似然函数（1.9）的二价偏导数值。Score统计量服从自由度等于１的分布。
2.4　模型拟合信息
　　模型建立后，考虑和比较模型的拟合程度。有三个度量值可作为拟合的判断根据。
(1)-2LogLikelihood
&&& （2.7）
(2) Akaike信息准则（Akaike Information Criterion,简写为AIC）
　其中Ｋ为模型中自变量的数目，Ｓ为反应变量类别总数减１，对于逻辑回归有S=2-1=1。-2LogL的值域为0至，其值越小说明拟合越好。当模型中的参数数量越大时，似然值也就越大，-2LogL就变小。因此，将２(K+S)加到AIC公式中以抵销参数数量产生的影响。在其它条件不变的情况下，较小的AIC值表示拟合模型较好。
(3)Schwarz准则
　　这一指标根据自变量数目和观测数量对-2LogL值进行另外一种调整。SC指标的定义为
其中ln(n)是观测数量的自然对数。这一指标只能用于比较对同一数据所设的不同模型。在其它条件相同时，一个模型的AIC或SC值越小说明模型拟合越好。
3.回归系数解释
odds=[p/(1-p)]，即事件发生的概率与不发生的概率之比。而发生比率(odds ration),即
(1)连续自变量。对于自变量，每增加一个单位，odds ration为
(2)二分类自变量的发生比率。变量的取值只能为0或1，称为dummy variable。当取值为1，对于取值为0的发生比率为
亦即对应系数的幂。
(3)分类自变量的发生比率。
如果一个分类变量包括m个类别，需要建立的dummy variable的个数为m-1,所省略的那个类别称作参照类(reference category)。设dummy variable为，其系数为，对于参照类，其发生比率为。
3.2 逻辑回归系数的置信区间
　　对于置信度１-，参数的100%（１-）的置信区间为
　　上式中，为与正态曲线下的临界Ｚ值（critical value）,
为系数估计的标准误差，和两值便分别是置信区间的下限和上限。当样本较大时，＝0.05水平的系数的95%置信区间为
-----------------------------------------------------------------------------------------------------------------------------------------------
4.变量选择
4.1前向选择（forward selection）：在截距模型的基础上，将符合所定显著水平的自变量一次一个地加入模型。
　　具体选择程序如下
（1） 常数（即截距）进入模型。
（2） 根据公式（2.6）计算待进入模型变量的Score检验值，并得到相应的P值。
（3） 找出最小的p值，如果此p值小于显著性水平,则此变量进入模型。如果此变量是某个名义变量的单面化(dummy)变量，则此名义变量的其它单面化变理同时也进入模型。不然，表明没有变量可被选入模型。选择过程终止。
（4） 回到(2)继续下一次选择。
4.2 后向选择（backward selection）：在模型包括所有候选变量的基础上，将不符合保留要求显著水平的自变量一次一个地删除。
具体选择程序如下
(1) 所有变量进入模型。
(2) 根据公式（2.1）计算所有变量的Wald检验值，并得到相应的p值。
(3) 找出其中最大的p值，如果此P值大于显著性水平，则此变量被剔除。对于某个名义变量的单面化变量，其最小p值大于显著性水平，则此名义变量的其它单面化变量也被删除。不然，表明没有变量可被剔除，选择过程终止。
(4) 回到(2)进行下一轮剔除。
4.3逐步回归(stepwise selection)
(1)基本思想：逐个引入自变量。每次引入对Ｙ影响最显著的自变量，并对方程中的老变量逐个进行检验，把变为不显著的变量逐个从方程中剔除掉，最终得到的方程中既不漏掉对Ｙ影响显著的变量，又不包含对Ｙ影响不显著的变量。
(2)筛选的步骤：首先给出引入变量的显著性水平和剔除变量的显著性水平，然后按下图筛选变量。
(3)逐步筛选法的基本步骤
逐步筛选变量的过程主要包括两个基本步骤：一是从不在方程中的变量考虑引入新变量的步骤；二是从回归方程中考虑剔除不显著变量的步骤。
假设有p个需要考虑引入回归方程的自变量.
① 设仅有截距项的最大似然估计值为。对p个自变量每个分别计算Score检验值，
设有最小p值的变量为，且有，对于单面化(dummy)变量，也如此。若，则此变量进入模型，不然停止。如果此变量是名义变量单面化(dummy)的变量，则此名义变量的其它单面化变量也进入模型。其中为引入变量的显著性水平。
② 为了确定当变量在模型中时其它p-1个变量也是否重要，将分别与进行拟合。对p-1个变量分别计算Score检验值，其p值设为。设有最小p值的变量为，且有.若，则进入下一步，不然停止。对于单面化变量，其方式如同上步。
③ 此步开始于模型中已含有变量与。注意到有可能在变量被引入后，变量不再重要。本步包括向后删除。根据(2.1)计算变量与的Wald检验值，和相应的p值。设为具有最大p值的变量，即=max(),.如果此p值大于，则此变量从模型中被删除，不然停止。对于名义变量，如果某个单面化变量的最小p值大于，则此名义变量从模型中被删除。
④ 如此进行下去，每当向前选择一个变量进入后，都进行向后删除的检查。循环终止的条件是：所有的p个变量都进入模型中或者模型中的变量的p值小于，不包含在模型中的变量的p值大于。或者某个变量进入模型后，在下一步又被删除，形成循环。
from： /biyeymyhjob/archive//2595410.html
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：215393次
积分：4230
积分：4230
排名：第5172名
原创：30篇
转载：1109篇
评论：27条
1）OpenCV俱乐部
2） 视频/音频/图像/算法/ML
备注：加群需要回答问题，避免广告党。
如果你是博客看到后加的，请注明“博客”并回答问题，只注明”博客“不回答问题的恕不加入。答案为和群相关的任何技术名词，不能出现1）和2）中的任何字眼
(2)(118)(143)(56)(68)(107)(226)(78)(3)(9)(37)(46)(50)(19)(15)(13)(27)(12)(12)(103)(18)(18)苹果/安卓/wp
积分 9, 距离下一级还需 1 积分
权限: 设置帖子权限
道具: 彩虹炫, 涂鸦板, 雷达卡, 热点灯下一级可获得
道具: 金钱卡
购买后可立即获得
权限: 隐身
道具: 金钱卡, 彩虹炫, 雷达卡, 热点灯, 涂鸦板
开心签到天数: 1 天连续签到: 1 天[LV.1]初来乍到
要做逻辑回归，但是自变量中有定性变量，做回归的时候要设置成哑变量，但是变量较多，想从中筛选出重要的变量，但是含有哑变量，如何进行筛选呢，还有如何看结果呢？
支持楼主：、
购买后，论坛将把您花费的资金全部奖励给楼主，以表示您对TA发好贴的支持
载入中......
& &回归分为解释型回归和预测型回归。如果你是做预测，那么你直接用逐步回归法就行，这样显著的变量就保留了，不显著就被剔除了；如果你是做解释型回归，那么你的自变量选取就是有依据的，要么是根据文献/理论/客观常识，并在构建模型前做了研究假设。这种条件下即使变量不显著那可能也要保留，从专业上去解释不显著的原因。
& & 所以具体到你这个问题，你自变量中含有类别变量，在构建模型时将其处理为哑变量纳入模型即可。然后参照我上面提的解释型回归和预测型回归，看是哪种类型的回归。祝好运。
一级伯乐勋章
一级伯乐勋章
初级学术勋章
初级学术勋章
初级热心勋章
初级热心勋章
初级信用勋章
初级信用勋章
中级热心勋章
中级热心勋章
中级学术勋章
中级学术勋章
中级信用勋章
中级信用勋章
高级热心勋章
高级热心勋章
高级学术勋章
高级学术勋章
高级信用勋章
高级信用勋章
特级热心勋章
高级热心勋章
特级学术勋章
特级学术勋章
特级信用勋章
高级信用勋章
无限扩大经管职场人脉圈！每天抽选10位免费名额，现在就扫& 论坛VIP& 贵宾会员& 可免费加入
加入我们,立即就学扫码下载「就学」app& Join us!& JoinLearn&
&nbsp&nbsp|
&nbsp&nbsp|
&nbsp&nbsp|
&nbsp&nbsp|
&nbsp&nbsp|
&nbsp&nbsp|
如有投资本站或合作意向，请联系（010-）；
邮箱：service@pinggu.org
投诉或不良信息处理：（010-）
京ICP证090565号
京公网安备号
论坛法律顾问：王进律师数据建模（29）
Mahout（5）
用Mahout来构建推荐系统，是一件既简单又困难的事情。简单是因为Mahout完整地封装了“协同过滤”算法，并实现了并行化，提供非常简单的API接口；困难是因为我们不了解算法细节，很难去根据业务的场景进行算法配置和调优。
本文将深入算法API去解释Mahout推荐算法底层的一些事。
Mahout推荐算法介绍算法评判标准：召回率与准确率Recommender.java的API接口测试程序：RecommenderTest.java基于用户的协同过滤算法UserCF基于物品的协同过滤算法ItemCFSlopeOne算法KNN Linear interpolation item–based推荐算法SVD推荐算法Tree Cluster-based 推荐算法Mahout推荐算法总结
1. Mahout推荐算法介绍
Mahoutt推荐算法，从数据处理能力上，可以划分为2类：
单机内存算法实现基于Hadoop的分步式算法实现
1). 单机内存算法实现
单机内存算法实现：就是在单机下运行的算法，是由cf.taste项目实现的，像我的们熟悉的UserCF,ItemCF都支持单机内存运行，并且参数可以灵活配置。单机算法的基本实例，请参考文章：
单机内存算法的问题在于，受限于单机的资源。对于中等规模的数据，像1G,10G的数据量，有能力进行计算，但是超过100G的数据量，对于单机来说是不可能完成的任务。
2). 基于Hadoop的分步式算法实现
基于Hadoop的分步式算法实现：就是把单机内存算法并行化，把任务分散到多台计算机一起运行。Mahout提供了ItemCF基于Hadoop并行化算法实现。基于Hadoop的分步式算法实现，请参考文章：
分步式并行算法的问题在于，如何让单机算法并行化。在单机算法中，我们只需要考虑算法，数据结构，内存，CPU就够了，但是分步式算法还要额外考虑很多的情况，比如多节点的数据合并，数据排序，网路通信的效率，节点宕机重算，数据分步式存储等等的很多问题。
2. 算法评判标准：召回率(recall)与查准率(precision)
Mahout提供了2个评估推荐器的指标，查准率和召回率（查全率），这两个指标是搜索引擎中经典的度量方法。
相关 不相关
A：检索到的，相关的 （搜到的也想要的）B：未检索到的，但是相关的 （没搜到，然而实际上想要的）C：检索到的，但是不相关的 （搜到的但没用的）D：未检索到的，也不相关的 （没搜到也没用的）
被检索到的越多越好，这是追求“查全率”，即A/(A+B)，越大越好。
被检索到的，越相关的越多越好，不相关的越少越好，这是追求“查准率”，即A/(A+C)，越大越好。
在大规模数据集合中，这两个指标是相互制约的。当希望索引出更多的数据的时候，查准率就会下降，当希望索引更准确的时候，会索引更少的数据。
3. Recommender的API接口
1). 系统环境:
Win7 64bitJava 1.6.0_45Maven 3Eclipse Juno Service Release 2Mahout 0.8Hadoop 1.1.2
2). Recommender接口文件：
org.apache.mahout.cf.taste.recommender.Recommender.java
接口中方法的解释：
recommend(long userID, int howMany): 获得推荐结果，给userID推荐howMany个Itemrecommend(long userID, int howMany, IDRescorer rescorer): 获得推荐结果，给userID推荐howMany个Item，可以根据rescorer对结构重新排序。estimatePreference(long userID, long itemID): 当打分为空，估计用户对物品的打分setPreference(long userID, long itemID, float value): 赋值用户，物品，打分removePreference(long userID, long itemID): 删除用户对物品的打分getDataModel(): 提取推荐数据
通过Recommender接口，我可以猜出核心算法，应该会在子类的estimatePreference()方法中进行实现。
3). 通过继承关系到Recommender接口的子类：
推荐算法实现类：
GenericUserBasedRecommender: 基于用户的推荐算法GenericItemBasedRecommender: 基于物品的推荐算法KnnItemBasedRecommender: 基于物品的KNN推荐算法SlopeOneRecommender: Slope推荐算法SVDRecommender: SVD推荐算法TreeClusteringRecommender：TreeCluster推荐算法
下面将分别介绍每种算法的实现。
4. 测试程序：RecommenderTest.java
测试数据集：item.csv
测试程序：org.conan.mymahout.recommendation.job.RecommenderTest.java
package org.conan.mymahout.recommendation.
import java.io.IOE
import java.util.L
import org.apache.mahout.mon.TasteE
import org.apache.mahout.cf.taste.eval.RecommenderB
import org.apache.mahout.cf.mon.LongPrimitiveI
import org.apache.mahout.cf.taste.model.DataM
import org.apache.mahout.cf.taste.recommender.RecommendedI
import org.mon.RandomU
public class RecommenderTest {
final static int NEIGHBORHOOD_NUM = 2;
final static int RECOMMENDER_NUM = 3;
public static void main(String[] args) throws TasteException, IOException {
RandomUtils.useTestSeed();
String file = &datafile/item.csv&;
DataModel dataModel = RecommendFactory.buildDataModel(file);
slopeOne(dataModel);
public static void userCF(DataModel dataModel) throws TasteException{}
public static void itemCF(DataModel dataModel) throws TasteException{}
public static void slopeOne(DataModel dataModel) throws TasteException{}
每种算法都一个单独的方法进行算法测试，如userCF(),itemCF(),slopeOne()….
5. 基于用户的协同过滤算法UserCF
基于用户的协同过滤，通过不同用户对物品的评分来评测用户之间的相似性，基于用户之间的相似性做出推荐。简单来讲就是：给用户推荐和他兴趣相似的其他用户喜欢的物品。
举例说明：
基于用户的 CF 的基本思想相当简单，基于用户对物品的偏好找到相邻邻居用户，然后将邻居用户喜欢的推荐给当前用户。计算上，就是将一个用户对所有物品的偏好作为一个向量来计算用户之间的相似度，找到 K 邻居后，根据邻居的相似度权重以及他们对物品的偏好，预测当前用户没有偏好的未涉及物品，计算得到一个排序的物品列表作为推荐。图 2 给出了一个例子，对于用户 A，根据用户的历史偏好，这里只计算得到一个邻居 – 用户 C，然后将用户 C 喜欢的物品 D 推荐给用户 A。
上文中图片和解释文字，摘自：&
算法API: org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender
public float estimatePreference(long userID, long itemID) throws TasteException {
DataModel model = getDataModel();
Float actualPref = model.getPreferenceValue(userID, itemID);
if (actualPref != null) {
return actualP
long[] theNeighborhood = neighborhood.getUserNeighborhood(userID);
return doEstimatePreference(userID, theNeighborhood, itemID);
protected float doEstimatePreference(long theUserID, long[] theNeighborhood, long itemID) throws TasteException {
if (theNeighborhood.length == 0) {
return Float.NaN;
DataModel dataModel = getDataModel();
double preference = 0.0;
double totalSimilarity = 0.0;
int count = 0;
for (long userID : theNeighborhood) {
if (userID != theUserID) {
// See GenericItemBasedRecommender.doEstimatePreference() too
Float pref = dataModel.getPreferenceValue(userID, itemID);
if (pref != null) {
double theSimilarity = similarity.userSimilarity(theUserID, userID);
if (!Double.isNaN(theSimilarity)) {
preference += theSimilarity *
totalSimilarity += theS
count++;
// Throw out the estimate if it was based on no data points, of course, but also if based on
// just one. This is a bit of a band-aid on the 'stock' item-based algorithm for the moment.
// The reason is that in this case the estimate is, simply, the user's rating for one item
// that happened to have a defined similarity. The similarity score doesn't matter, and that
// seems like a bad situation.
if (count &= 1) {
return Float.NaN;
float estimate = (float) (preference / totalSimilarity);
if (capper != null) {
estimate = capper.capEstimate(estimate);
public static void userCF(DataModel dataModel) throws TasteException {
UserSimilarity userSimilarity = RecommendFactory.userSimilarity(RecommendFactory.SIMILARITY.EUCLIDEAN, dataModel);
UserNeighborhood userNeighborhood = RecommendFactory.userNeighborhood(RecommendFactory.NEIGHBORHOOD.NEAREST, userSimilarity, dataModel, NEIGHBORHOOD_NUM);
RecommenderBuilder recommenderBuilder = RecommendFactory.userRecommender(userSimilarity, userNeighborhood, true);
RecommendFactory.evaluate(RecommendFactory.EVALUATOR.AVERAGE_ABSOLUTE_DIFFERENCE, recommenderBuilder, null, dataModel, 0.7);
RecommendFactory.statsEvaluator(recommenderBuilder, null, dataModel, 2);
LongPrimitiveIterator iter = dataModel.getUserIDs();
while (iter.hasNext()) {
long uid = iter.nextLong();
List list = recommenderBuilder.buildRecommender(dataModel).recommend(uid, RECOMMENDER_NUM);
RecommendFactory.showItems(uid, list, true);
程序输出：
AVERAGE_ABSOLUTE_DIFFERENCE Evaluater Score:1.0
Recommender IR Evaluator: [Precision:0.5,Recall:0.5]
uid:1,(104,4.6,4.000000)
uid:2,(105,4.049678)
uid:3,(103,3.2,2.747869)
uid:4,(102,3.000000)
用R语言重写UserCF的实现，请参考文章：
6. 基于物品的协同过滤算法ItemCF
基于item的协同过滤，通过用户对不同item的评分来评测item之间的相似性，基于item之间的相似性做出推荐。简单来讲就是：给用户推荐和他之前喜欢的物品相似的物品。
举例说明：
基于物品的 CF 的原理和基于用户的 CF 类似，只是在计算邻居时采用物品本身，而不是从用户的角度，即基于用户对物品的偏好找到相似的物品，然后根据用户的历史偏好，推荐相似的物品给他。从计算的角度看，就是将所有用户对某个物品的偏好作为一个向量来计算物品之间的相似度，得到物品的相似物品后，根据用户历史的偏好预测当前用户还没有表示偏好的物品，计算得到一个排序的物品列表作为推荐。图 3 给出了一个例子，对于物品 A，根据所有用户的历史偏好，喜欢物品 A 的用户都喜欢物品 C，得出物品 A 和物品 C 比较相似，而用户
C 喜欢物品 A，那么可以推断出用户 C 可能也喜欢物品 C。
上文中图片和解释文字，摘自：&
算法API: org.apache.mahout.cf.taste.impl.recommender.GenericItemBasedRecommender
public float estimatePreference(long userID, long itemID) throws TasteException {
PreferenceArray preferencesFromUser = getDataModel().getPreferencesFromUser(userID);
Float actualPref = getPreferenceForItem(preferencesFromUser, itemID);
if (actualPref != null) {
return actualP
return doEstimatePreference(userID, preferencesFromUser, itemID);
protected float doEstimatePreference(long userID, PreferenceArray preferencesFromUser, long itemID)
throws TasteException {
double preference = 0.0;
double totalSimilarity = 0.0;
int count = 0;
double[] similarities = similarity.itemSimilarities(itemID, preferencesFromUser.getIDs());
for (int i = 0; i & similarities. i++) {
double theSimilarity = similarities[i];
if (!Double.isNaN(theSimilarity)) {
// Weights can be negative!
preference += theSimilarity * preferencesFromUser.getValue(i);
totalSimilarity += theS
count++;
// Throw out the estimate if it was based on no data points, of course, but also if based on
// just one. This is a bit of a band-aid on the 'stock' item-based algorithm for the moment.
// The reason is that in this case the estimate is, simply, the user's rating for one item
// that happened to have a defined similarity. The similarity score doesn't matter, and that
// seems like a bad situation.
if (count &= 1) {
return Float.NaN;
float estimate = (float) (preference / totalSimilarity);
if (capper != null) {
estimate = capper.capEstimate(estimate);
public static void itemCF(DataModel dataModel) throws TasteException {
ItemSimilarity itemSimilarity = RecommendFactory.itemSimilarity(RecommendFactory.SIMILARITY.EUCLIDEAN, dataModel);
RecommenderBuilder recommenderBuilder = RecommendFactory.itemRecommender(itemSimilarity, true);
RecommendFactory.evaluate(RecommendFactory.EVALUATOR.AVERAGE_ABSOLUTE_DIFFERENCE, recommenderBuilder, null, dataModel, 0.7);
RecommendFactory.statsEvaluator(recommenderBuilder, null, dataModel, 2);
LongPrimitiveIterator iter = dataModel.getUserIDs();
while (iter.hasNext()) {
long uid = iter.nextLong();
List list = recommenderBuilder.buildRecommender(dataModel).recommend(uid, RECOMMENDER_NUM);
RecommendFactory.showItems(uid, list, true);
程序输出：
AVERAGE_ABSOLUTE_DIFFERENCE Evaluater Score:0.1973
Recommender IR Evaluator: [Precision:0.5,Recall:1.0]
uid:1,(105,3.4,3.6,3.478261)
uid:2,(106,2.5,2.7,2.000000)
uid:3,(106,3.2,3.3,3.312500)
uid:4,(107,4.5,4.2,4.025000)
uid:5,(107,3.736842)
7. SlopeOne算法
这个算法在mahout-0.8版本中，已经被@Deprecated。
SlopeOne是一种简单高效的协同过滤算法。通过均差计算进行评分。SlopeOne论文下载()
1). 举例说明：
用户X，Y，Z，对于物品A,B进行打分，如下表，求Z对B的打分是多少？
Slope one算法认为：平均值可以代替某两个未知个体之间的打分差异，事物A对事物B的平均差是：((5 - 4) + (4 - 2)) / 2 = 1.5，就得到Z对B的打分是，3-1.5 = 1.5。
Slope one算法将用户的评分之间的关系看作简单的线性关系：
Y = mX + b
2). 平均加权计算：
用户X，Y，Z，对于物品A,B,C进行打分，如下表，求Z对A的打分是多少？
1. 计算A和B的平均差, ((5-3)+(3-4))/2=0.52. 计算A和C的平均差, (5-2)/1=33. Z对A的评分，通过AB得到, 2+0.5=2.54. Z对A的评分，通过AC得到，5+3=85. 通过加权平均计算Z对A的评分：A和B都有评价的用户数为2,A和C都有评价的用户数为1，权重为别是2和1， (2*2.5+1*8)/(2+1)=13/3=4.33
通过这种简单的方式，我们可以快速计算出一个评分项，完成推荐过程！
算法API: org.apache.mahout.cf.taste.impl.recommender.slopeone.SlopeOneRecommender
public float estimatePreference(long userID, long itemID) throws TasteException {
DataModel model = getDataModel();
Float actualPref = model.getPreferenceValue(userID, itemID);
if (actualPref != null) {
return actualP
return doEstimatePreference(userID, itemID);
private float doEstimatePreference(long userID, long itemID) throws TasteException {
double count = 0.0;
double totalPreference = 0.0;
PreferenceArray prefs = getDataModel().getPreferencesFromUser(userID);
RunningAverage[] averages = diffStorage.getDiffs(userID, itemID, prefs);
int size = prefs.length();
for (int i = 0; i & i++) {
RunningAverage averageDiff = averages[i];
if (averageDiff != null) {
double averageDiffValue = averageDiff.getAverage();
if (weighted) {
double weight = averageDiff.getCount();
if (stdDevWeighted) {
double stdev = ((RunningAverageAndStdDev) averageDiff).getStandardDeviation();
if (!Double.isNaN(stdev)) {
weight /= 1.0 +
// If stdev is NaN, then it is because count is 1. Because we're weighting by count,
// the weight is already relatively low. We effectively assume stdev is 0.0 here and
// that is reasonable enough. Otherwise, dividing by NaN would yield a weight of NaN
// and disqualify this pref entirely
// (Thanks Daemmon)
totalPreference += weight * (prefs.getValue(i) + averageDiffValue);
count +=
totalPreference += prefs.getValue(i) + averageDiffV
count += 1.0;
if (count &= 0.0) {
RunningAverage itemAverage = diffStorage.getAverageItemPref(itemID);
return itemAverage == null ? Float.NaN : (float) itemAverage.getAverage();
return (float) (totalPreference / count);
public static void slopeOne(DataModel dataModel) throws TasteException {
RecommenderBuilder recommenderBuilder = RecommendFactory.slopeOneRecommender();
RecommendFactory.evaluate(RecommendFactory.EVALUATOR.AVERAGE_ABSOLUTE_DIFFERENCE, recommenderBuilder, null, dataModel, 0.7);
RecommendFactory.statsEvaluator(recommenderBuilder, null, dataModel, 2);
LongPrimitiveIterator iter = dataModel.getUserIDs();
while (iter.hasNext()) {
long uid = iter.nextLong();
List list = recommenderBuilder.buildRecommender(dataModel).recommend(uid, RECOMMENDER_NUM);
RecommendFactory.showItems(uid, list, true);
程序输出：
AVERAGE_ABSOLUTE_DIFFERENCE Evaluater Score:1.3333
Recommender IR Evaluator: [Precision:0.25,Recall:0.5]
uid:1,(105,5.4,5.6,4.500000)
uid:2,(105,2.6,1.500000)
uid:3,(106,2.2,1.3,1.625000)
uid:4,(105,4.2,3.509071)
8. KNN Linear interpolation item–based推荐算法
这个算法在mahout-0.8版本中，已经被@Deprecated。
算法来自论文：
This algorithm is based in the paper of Robert M. Bell and Yehuda Koren in ICDM '07.
(TODO未完)
算法API: org.apache.mahout.cf.taste.impl.recommender.knn.KnnItemBasedRecommender
protected float doEstimatePreference(long theUserID, PreferenceArray preferencesFromUser, long itemID)
throws TasteException {
DataModel dataModel = getDataModel();
int size = preferencesFromUser.length();
FastIDSet possibleItemIDs = new FastIDSet(size);
for (int i = 0; i & i++) {
possibleItemIDs.add(preferencesFromUser.getItemID(i));
possibleItemIDs.remove(itemID);
List mostSimilar = mostSimilarItems(itemID, possibleItemIDs.iterator(),
neighborhoodSize, null);
long[] theNeighborhood = new long[mostSimilar.size() + 1];
theNeighborhood[0] = -1;
List usersRatedNeighborhood = Lists.newArrayList();
int nOffset = 0;
for (RecommendedItem rec : mostSimilar) {
theNeighborhood[nOffset++] = rec.getItemID();
if (!mostSimilar.isEmpty()) {
theNeighborhood[mostSimilar.size()] = itemID;
for (int i = 0; i & theNeighborhood. i++) {
PreferenceArray usersNeighborhood = dataModel.getPreferencesForItem(theNeighborhood[i]);
int size1 = usersRatedNeighborhood.isEmpty() ? usersNeighborhood.length() : usersRatedNeighborhood.size();
for (int j = 0; j & size1; j++) {
if (i == 0) {
usersRatedNeighborhood.add(usersNeighborhood.getUserID(j));
if (j &= usersRatedNeighborhood.size()) {
long index = usersRatedNeighborhood.get(j);
if (!usersNeighborhood.hasPrefWithUserID(index) || index == theUserID) {
usersRatedNeighborhood.remove(index);
double[] weights =
if (!mostSimilar.isEmpty()) {
weights = getInterpolations(itemID, theNeighborhood, usersRatedNeighborhood);
int i = 0;
double preference = 0.0;
double totalSimilarity = 0.0;
for (long jitem : theNeighborhood) {
Float pref = dataModel.getPreferenceValue(theUserID, jitem);
if (pref != null) {
double weight = weights[i];
preference += pref *
totalSimilarity +=
i++;
return totalSimilarity == 0.0 ? Float.NaN : (float) (preference / totalSimilarity);
public static void itemKNN(DataModel dataModel) throws TasteException {
ItemSimilarity itemSimilarity = RecommendFactory.itemSimilarity(RecommendFactory.SIMILARITY.EUCLIDEAN, dataModel);
RecommenderBuilder recommenderBuilder = RecommendFactory.itemKNNRecommender(itemSimilarity, new NonNegativeQuadraticOptimizer(), 10);
RecommendFactory.evaluate(RecommendFactory.EVALUATOR.AVERAGE_ABSOLUTE_DIFFERENCE, recommenderBuilder, null, dataModel, 0.7);
RecommendFactory.statsEvaluator(recommenderBuilder, null, dataModel, 2);
LongPrimitiveIterator iter = dataModel.getUserIDs();
while (iter.hasNext()) {
long uid = iter.nextLong();
List list = recommenderBuilder.buildRecommender(dataModel).recommend(uid, RECOMMENDER_NUM);
RecommendFactory.showItems(uid, list, true);
程序输出：
AVERAGE_ABSOLUTE_DIFFERENCE Evaluater Score:1.5
Recommender IR Evaluator: [Precision:0.5,Recall:1.0]
uid:1,(107,5.4,3.6,3.498198)
uid:2,(105,2.6,2.7,2.000000)
uid:3,(103,3.2,3.6,3.667019)
uid:4,(107,4.2,4.5,4.122709)
uid:5,(107,3.833621)
9. SVD推荐算法
(TODO未完)
算法API: org.apache.mahout.cf.taste.impl.recommender.svd.SVDRecommender
public float estimatePreference(long userID, long itemID) throws TasteException {
double[] userFeatures = factorization.getUserFeatures(userID);
double[] itemFeatures = factorization.getItemFeatures(itemID);
double estimate = 0;
for (int feature = 0; feature & userFeatures. feature++) {
estimate += userFeatures[feature] * itemFeatures[feature];
return (float)
public static void svd(DataModel dataModel) throws TasteException {
RecommenderBuilder recommenderBuilder = RecommendFactory.svdRecommender(new ALSWRFactorizer(dataModel, 10, 0.05, 10));
RecommendFactory.evaluate(RecommendFactory.EVALUATOR.AVERAGE_ABSOLUTE_DIFFERENCE, recommenderBuilder, null, dataModel, 0.7);
RecommendFactory.statsEvaluator(recommenderBuilder, null, dataModel, 2);
LongPrimitiveIterator iter = dataModel.getUserIDs();
while (iter.hasNext()) {
long uid = iter.nextLong();
List list = recommenderBuilder.buildRecommender(dataModel).recommend(uid, RECOMMENDER_NUM);
RecommendFactory.showItems(uid, list, true);
程序输出：
AVERAGE_ABSOLUTE_DIFFERENCE Evaluater Score:0.96355
Recommender IR Evaluator: [Precision:0.5,Recall:1.0]
uid:1,(104,4.5,3.7,1.858541)
uid:2,(105,3.6,2.7,1.561116)
uid:3,(103,5.2,2.6,-0.091259)
uid:4,(105,4.2,3.7,0.206257)
uid:5,(107,0.105169)
10. Tree Cluster-based 推荐算法
这个算法在mahout-0.8版本中，已经被@Deprecated。
(TODO未完)
算法API: org.apache.mahout.cf.taste.impl.recommender.TreeClusteringRecommender
public float estimatePreference(long userID, long itemID) throws TasteException {
DataModel model = getDataModel();
Float actualPref = model.getPreferenceValue(userID, itemID);
if (actualPref != null) {
return actualP
buildClusters();
List topRecsForUser = topRecsByUserID.get(userID);
if (topRecsForUser != null) {
for (RecommendedItem item : topRecsForUser) {
if (itemID == item.getItemID()) {
return item.getValue();
// Hmm, we have no idea. The item is not in the user's cluster
return Float.NaN;
public static void treeCluster(DataModel dataModel) throws TasteException {
UserSimilarity userSimilarity = RecommendFactory.userSimilarity(RecommendFactory.SIMILARITY.LOGLIKELIHOOD, dataModel);
ClusterSimilarity clusterSimilarity = RecommendFactory.clusterSimilarity(RecommendFactory.SIMILARITY.FARTHEST_NEIGHBOR_CLUSTER, userSimilarity);
RecommenderBuilder recommenderBuilder = RecommendFactory.treeClusterRecommender(clusterSimilarity, 10);
RecommendFactory.evaluate(RecommendFactory.EVALUATOR.AVERAGE_ABSOLUTE_DIFFERENCE, recommenderBuilder, null, dataModel, 0.7);
RecommendFactory.statsEvaluator(recommenderBuilder, null, dataModel, 2);
LongPrimitiveIterator iter = dataModel.getUserIDs();
while (iter.hasNext()) {
long uid = iter.nextLong();
List list = recommenderBuilder.buildRecommender(dataModel).recommend(uid, RECOMMENDER_NUM);
RecommendFactory.showItems(uid, list, true);
程序输出：
AVERAGE_ABSOLUTE_DIFFERENCE Evaluater Score:NaN
Recommender IR Evaluator: [Precision:NaN,Recall:0.0]
11. Mahout推荐算法总结
算法及适用场景：
算法评分的结果：
通过对上面几种算法的一平分比较：itemCF,itemKNN,SVD的Rrecision,Recall的评分值是最好的，并且itemCF和 SVD的AVERAGE_ABSOLUTE_DIFFERENCE是最低的，所以，从算法的角度知道了，哪个算法是更准确的或者会索引到更多的数据集。
另外的一些因素：
1. 这3个指标，并不能直接决定计算结果一定itemCF,SVD好2. 各种算法的参数我们并没有调优3. 数据量和数据分布，是影响算法的评分
程序源代码下载
转载请注明出处：
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：26828次
排名：千里之外
转载：270篇
(1)(7)(37)(58)(15)(6)(60)(2)(11)(7)(26)(34)(1)(2)(16)(1)