& 从源代码剖析Mahout推荐引擎
从源代码剖析Mahout推荐引擎
，主要介绍Hadoop家族产品，常用的项目包括Hadoop, Hive, Pig, HBase, Sqoop, Mahout, Zookeeper, Avro, Ambari, Chukwa，新增加的项目包括，YARN, Hcatalog, Oozie, Cassandra, Hama, Whirr, Flume, Bigtop, Crunch, Hue等。
从2011年开始，中国进入大数据风起云涌的时代，以Hadoop为代表的家族软件，占据了大数据处理的广阔地盘。开源界及厂商，所有数据软件，无一不向Hadoop靠拢。Hadoop也从小众的高富帅领域，变成了大数据开发的标准。在Hadoop原有技术基础之上，出现了Hadoop家族产品，通过“大数据”概念不断创新，推出科技进步。
作为IT界的开发人员，我们也要跟上节奏，抓住机遇，跟着Hadoop一起雄起！
关于作者：
张丹(Conan), 程序员Java,R,PHP,Javascript
weibo：@Conan_Z
转载请注明出处：
Mahout框架中cf.taste包实现了推荐算法引擎，它提供了一套完整的推荐算法工具集，同时规范了数据结构，并标准化了程序开发过程。应用推荐算法时，代码也就7-8行，简单地有点像R了。为了使用简单的目标，Mahout推荐引擎必然要做到精巧的程序设计。
本文将介绍Mahout推荐引擎的程序设计。
Mahout推荐引擎概况
标准化的程序开发过程
相似度算法工具集
近邻算法工具集
推荐算法工具集
创建自己的推荐引擎构造器
1. Mahout推荐引擎概况
Mahout的推荐引擎，要从org.apache.mahout.cf.taste包说起。
packages的说明：
common: 公共类包括，异常，数据刷新接口，权重常量
eval: 定义构造器接口，类似于工厂模式
model: 定义数据模型接口
neighborhood: 定义近邻算法的接口
recommender: 定义推荐算法的接口
similarity: 定义相似度算法的接口
transforms: 定义数据转换的接口
hadoop: 基于hadoop的分步式算法的实现类
impl: 单机内存算法实现类
从上面的package情况，我可以粗略地看出推荐引擎分为5个主要部分组成：数据模型，相似度算法，近邻算法，推荐算法，算法评分器。
从数据处理能力上，算法可以分为：单机内存算法，基于hadoop的分步式算法。
下面我们将基于单机内存算法，研究Mahout的推荐引擎的结构。
2. 标准化的程序开发过程
以UserCF的推荐算法为例，官方建议我们的开发过程：
图片摘自Mahout in Action
从上图中我们可以看到，算法是被模块化的，通过1,2,3,4的过程进行方法调用。
程序代码：
public class UserCF {
final static int NEIGHBORHOOD_NUM = 2;
final static int RECOMMENDER_NUM = 3;
public static void main(String[] args) throws IOException, TasteException {
String file = "datafile/item.csv";
DataModel model = new FileDataModel(new File(file));
UserSimilarity user = new EuclideanDistanceSimilarity(model);
NearestNUserNeighborhood neighbor = new NearestNUserNeighborhood(NEIGHBORHOOD_NUM, user, model);
Recommender r = new GenericUserBasedRecommender(model, neighbor, user);
LongPrimitiveIterator iter = model.getUserIDs();
while (iter.hasNext()) {
long uid = iter.nextLong();
List list = r.recommend(uid, RECOMMENDER_NUM);
System.out.printf("uid:%s", uid);
for (RecommendedItem ritem : list) {
System.out.printf("(%s,%f)", ritem.getItemID(), ritem.getValue());
System.out.println();
我们调用算法的程序，要用到4个对象：DataModel, UserSimilarity, NearestNUserNeighborhood, Recommender。
3. 数据模型
Mahout的推荐引擎的数据模型，以DataModel接口为父类。
通过“策略模式”匹配不同的数据源，支持File, JDBC(MySQL, PostgreSQL), NoSQL(Cassandra, HBase, MongoDB)。
注：NoSQL的实现在mahout-integration-0.8.jar中。
数据格式支持2种：
GenericDataModel: 用户ID，物品ID，用户对物品的打分(UserID,ItemID,PreferenceValue)
GenericBooleanPrefDataModel: 用户ID，物品ID (UserID,ItemID)，这种方式表达用户是否浏览过该物品，但并未对物品进行打分。
4. 相似度算法工具集
相似度算法分为2种
基于用户(UserCF)的相似度算法
基于物品(ItemCF)的相似度算法
1). 基于用户(UserCF)的相似度算法
计算用户的相似矩阵，可以通过上图中几种算法。
2). 基于物品(ItemCF)的相似度算法
计算物品的相似矩阵，可以通过上图中几种算法。
关于相似度距离的说明：
EuclideanDistanceSimilarity: 欧氏距离相似度
原理：利用欧式距离d定义的相似度s，s=1 / (1+d)。
范围：[0,1]，值越大，说明d越小，也就是距离越近，则相似度越大。
说明：同皮尔森相似度一样，该相似度也没有考虑重叠数对结果的影响，同样地，Mahout通过增加一个枚举类型（Weighting）的参数来使得重叠数也成为计算相似度的影响因子。
PearsonCorrelationSimilarity: 皮尔森相似度
原理：用来反映两个变量线性相关程度的统计量
范围：[-1,1]，绝对值越大，说明相关性越强，负相关对于推荐的意义小。
说明：1、 不考虑重叠的数量；2、 如果只有一项重叠，无法计算相似性（计算过程被除数有n-1）；3、 如果重叠的值都相等，也无法计算相似性（标准差为0，做除数）。
该相似度并不是最好的选择，也不是最坏的选择，只是因为其容易理解，在早期研究中经常被提起。使用Pearson线性相关系数必须假设数据是成对地从正态分布中取得的，并且数据至少在逻辑范畴内必须是等间距的数据。Mahout中，为皮尔森相关计算提供了一个扩展，通过增加一个枚举类型（Weighting）的参数来使得重叠数也成为计算相似度的影响因子。
UncenteredCosineSimilarity: 余弦相似度
原理：多维空间两点与所设定的点形成夹角的余弦值。
范围：[-1,1]，值越大，说明夹角越大，两点相距就越远，相似度就越小。
说明：在数学表达中，如果对两个项的属性进行了数据中心化，计算出来的余弦相似度和皮尔森相似度是一样的，在mahout中，实现了数据中心化的过程，所以皮尔森相似度值也是数据中心化后的余弦相似度。另外在新版本中，Mahout提供了UncenteredCosineSimilarity类作为计算非中心化数据的余弦相似度。
SpearmanCorrelationSimilarity: Spearman秩相关系数相似度
原理：Spearman秩相关系数通常被认为是排列后的变量之间的Pearson线性相关系数。
范围：{-1.0,1.0}，当一致时为1.0，不一致时为-1.0。
说明：计算非常慢，有大量排序。针对推荐系统中的数据集来讲，用Spearman秩相关系数作为相似度量是不合适的。
CityBlockSimilarity: 曼哈顿距离相似度
原理：曼哈顿距离的实现，同欧式距离相似，都是用于多维数据空间距离的测度
范围：[0,1]，同欧式距离一致，值越小，说明距离值越大，相似度越大。
说明：比欧式距离计算量少，性能相对高。
LogLikelihoodSimilarity: 对数似然相似度
原理：重叠的个数，不重叠的个数，都没有的个数
范围：具体可去百度文库中查找论文《Accurate Methods for the Statistics of Surprise and Coincidence》
说明：处理无打分的偏好数据，比Tanimoto系数的计算方法更为智能。
TanimotoCoefficientSimilarity: Tanimoto系数相似度
原理：又名广义Jaccard系数，是对Jaccard系数的扩展，等式为
范围：[0,1]，完全重叠时为1，无重叠项时为0，越接近1说明越相似。
说明：处理无打分的偏好数据。
相似度算法介绍，摘自：
5. 近邻算法工具集
近邻算法只对于UserCF适用，通过近邻算法给相似的用户进行排序，选出前N个最相似的，作为最终推荐的参考的用户。
近邻算法分为2种：
NearestNUserNeighborhood:指定N的个数，比如，选出前10最相似的用户。
ThresholdUserNeighborhood:指定比例，比如，选择前10%最相似的用户。
6. 推荐算法工具集
推荐算法是以Recommender作为基础的父类，关于推荐算法的详细介绍，请参考文章：
7. 创建自己的推荐引擎构造器
有了上面的知识，我就清楚地知道了Mahout推荐引擎的原理和使用，我们就可以写一个自己的构造器，通过“策略模式”实现，算法的组合。
新建文件：org.conan.mymahout.recommendation.job.RecommendFactory.java
public final class RecommendFactory {
1). 构造数据模型
public static DataModel buildDataModel(String file) throws TasteException, IOException {
return new FileDataModel(new File(file));
public static DataModel buildDataModelNoPref(String file) throws TasteException, IOException {
return new GenericBooleanPrefDataModel(GenericBooleanPrefDataModel.toDataMap(new FileDataModel(new File(file))));
public static DataModelBuilder buildDataModelNoPrefBuilder() {
return new DataModelBuilder() {
public DataModel buildDataModel(FastByIDMap trainingData) {
return new GenericBooleanPrefDataModel(GenericBooleanPrefDataModel.toDataMap(trainingData));
2). 构造相似度算法模型
public enum SIMILARITY {
PEARSON, EUCLIDEAN, COSINE, TANIMOTO, LOGLIKELIHOOD, FARTHEST_NEIGHBOR_CLUSTER, NEAREST_NEIGHBOR_CLUSTER
public static UserSimilarity userSimilarity(SIMILARITY type, DataModel m) throws TasteException {
switch (type) {
case PEARSON:
return new PearsonCorrelationSimilarity(m);
case COSINE:
return new UncenteredCosineSimilarity(m);
case TANIMOTO:
return new TanimotoCoefficientSimilarity(m);
case LOGLIKELIHOOD:
return new LogLikelihoodSimilarity(m);
case EUCLIDEAN:
return new EuclideanDistanceSimilarity(m);
public static ItemSimilarity itemSimilarity(SIMILARITY type, DataModel m) throws TasteException {
switch (type) {
case LOGLIKELIHOOD:
return new LogLikelihoodSimilarity(m);
case TANIMOTO:
return new TanimotoCoefficientSimilarity(m);
public static ClusterSimilarity clusterSimilarity(SIMILARITY type, UserSimilarity us) throws TasteException {
switch (type) {
case NEAREST_NEIGHBOR_CLUSTER:
return new NearestNeighborClusterSimilarity(us);
case FARTHEST_NEIGHBOR_CLUSTER:
return new FarthestNeighborClusterSimilarity(us);
3). 构造近邻算法模型
public enum NEIGHBORHOOD {
NEAREST, THRESHOLD
public static UserNeighborhood userNeighborhood(NEIGHBORHOOD type, UserSimilarity s, DataModel m, double num) throws TasteException {
switch (type) {
case NEAREST:
return new NearestNUserNeighborhood((int) num, s, m);
case THRESHOLD:
return new ThresholdUserNeighborhood(num, s, m);
4). 构造推荐算法模型
public enum RECOMMENDER {
USER, ITEM
public static RecommenderBuilder userRecommender(final UserSimilarity us, final UserNeighborhood un, boolean pref) throws TasteException {
return pref ? new RecommenderBuilder() {
public Recommender buildRecommender(DataModel model) throws TasteException {
return new GenericUserBasedRecommender(model, un, us);
} : new RecommenderBuilder() {
public Recommender buildRecommender(DataModel model) throws TasteException {
return new GenericBooleanPrefUserBasedRecommender(model, un, us);
public static RecommenderBuilder itemRecommender(final ItemSimilarity is, boolean pref) throws TasteException {
return pref ? new RecommenderBuilder() {
public Recommender buildRecommender(DataModel model) throws TasteException {
return new GenericItemBasedRecommender(model, is);
} : new RecommenderBuilder() {
public Recommender buildRecommender(DataModel model) throws TasteException {
return new GenericBooleanPrefItemBasedRecommender(model, is);
public static RecommenderBuilder slopeOneRecommender() throws TasteException {
return new RecommenderBuilder() {
public Recommender buildRecommender(DataModel dataModel) throws TasteException {
return new SlopeOneRecommender(dataModel);
public static RecommenderBuilder itemKNNRecommender(final ItemSimilarity is, final Optimizer op, final int n) throws TasteException {
return new RecommenderBuilder() {
public Recommender buildRecommender(DataModel dataModel) throws TasteException {
return new KnnItemBasedRecommender(dataModel, is, op, n);
public static RecommenderBuilder svdRecommender(final Factorizer factorizer) throws TasteException {
return new RecommenderBuilder() {
public Recommender buildRecommender(DataModel dataModel) throws TasteException {
return new SVDRecommender(dataModel, factorizer);
public static RecommenderBuilder treeClusterRecommender(final ClusterSimilarity cs, final int n) throws TasteException {
return new RecommenderBuilder() {
public Recommender buildRecommender(DataModel dataModel) throws TasteException {
return new TreeClusteringRecommender(dataModel, cs, n);
5). 构造算法评估模型
public enum EVALUATOR {
AVERAGE_ABSOLUTE_DIFFERENCE, RMS
public static RecommenderEvaluator buildEvaluator(EVALUATOR type) {
switch (type) {
return new RMSRecommenderEvaluator();
case AVERAGE_ABSOLUTE_DIFFERENCE:
return new AverageAbsoluteDifferenceRecommenderEvaluator();
public static void evaluate(EVALUATOR type, RecommenderBuilder rb, DataModelBuilder mb, DataModel dm, double trainPt) throws TasteException {
System.out.printf("%s Evaluater Score:%s\n", type.toString(), buildEvaluator(type).evaluate(rb, mb, dm, trainPt, 1.0));
public static void evaluate(RecommenderEvaluator re, RecommenderBuilder rb, DataModelBuilder mb, DataModel dm, double trainPt) throws TasteException {
System.out.printf("Evaluater Score:%s\n", re.evaluate(rb, mb, dm, trainPt, 1.0));
* statsEvaluator
public static void statsEvaluator(RecommenderBuilder rb, DataModelBuilder mb, DataModel m, int topn) throws TasteException {
RecommenderIRStatsEvaluator evaluator = new GenericRecommenderIRStatsEvaluator();
IRStatistics stats = evaluator.evaluate(rb, mb, m, null, topn, GenericRecommenderIRStatsEvaluator.CHOOSE_THRESHOLD, 1.0);
// System.out.printf("Recommender IR Evaluator: %s\n", stats);
System.out.printf("Recommender IR Evaluator: [Precision:%s,Recall:%s]\n", stats.getPrecision(), stats.getRecall());
6). 推荐结果输出
public static void showItems(long uid, List recommendations, boolean skip) {
if (!skip || recommendations.size() > 0) {
System.out.printf("uid:%s,", uid);
for (RecommendedItem recommendation : recommendations) {
System.out.printf("(%s,%f)", recommendation.getItemID(), recommendation.getValue());
System.out.println();
7). 完整源代码文件及使用样例：
转载请注明出处：
This entry was posted in , , ,
Pingback: ()
Pingback: ()
Designed byHadoop2.2+Mahout0.9实战 - 看引擎 KENGINE | 看看新闻网 IT资讯
Hadoop2.2+Mahout0.9实战
版本：2.2.0，mahout0.9。
使用mahout的org.apache.mahout.cf.taste.hadoop.item.RecommenderJob进行测试。
首先说明下，如果使用官网提供的下载hadoop2.2.0以及mahout0.9进行调用mahout的相关算法会报错。一般报错如下：
java.lang.IncompatibleClassChangeError: Found interface org.apache.hadoop.mapreduce.JobContext, but class was expected at org.mon.HadoopUtil.getCustomJobName(HadoopUtil.java:174) at org.mon.AbstractJob.prepareJob(AbstractJob.java:614) at org.apache.mahout.cf.taste.hadoop.preparation.PreparePreferenceMatrixJob.run(PreparePreferenceMatrixJob.java:73) at org.apache.hadoop.util.ToolRunner.run(ToolRunner.java:70)
这个是因为目前mahout只支持hadoop1 的缘故。在这里可以找到解决方法：。主要就是修改pom文件，修改mahout的依赖。
大家可以下载修改后的源码包
1、（Mahout0.9源码（支持Hadoop2））
2、自己编译Mahout(mvn clean install -Dhadoop2 -Dhadoop.2.version=2.2.0 -DskipTests)，或者直接下载已经编译好的jar包。
——————————————分割线——————————————
在 2014年\4月\Hadoop2.2+Mahout0.9实战
下载方法见
——————————————分割线——————————————
接着，按照这篇文章建立eclipse的环境：。环境配置好了之后，需要添加mahout的jar包，下载前面提供的jar包，然后导入到java工程中。
编写下面的java代码：
package fz.hadoop2.
import org.apache.hadoop.conf.Cimport org.apache.hadoop.yarn.conf.YarnC
public class Hadoop2Util { private static Configuration conf=
private static final String YARN_RESOURCE=”node31:;; private static final String DEFAULT_FS=”hdfs://node31:;;
public static Configuration getConf(){
if(conf==null){
conf = new YarnConfiguration();
conf.set(“fs.defaultFS”, DEFAULT_FS);
conf.set(“mapreduce.framework.name”, “yarn”);
conf.set(“yarn.resourcemanager.address”, YARN_RESOURCE);
===============================================
相关阅读：
13.04上搭建Hadoop环境
Ubuntu 12.10 +Hadoop 1.2.1版本集群配置
Ubuntu上搭建Hadoop环境（单机模式+伪分布模式）
Ubuntu下Hadoop环境的配置
单机版搭建Hadoop环境图文教程详解
搭建Hadoop环境（在Winodws环境下用虚拟机虚拟两个Ubuntu系统进行搭建）
===============================================
package fz.mahout.
import org.apache.hadoop.conf.Cimport org.apache.hadoop.util.ToolRimport org.apache.mahout.cf.taste.hadoop.item.RecommenderJimport org.junit.Aimport org.junit.Bimport org.junit.T
import fz.hadoop2.util.Hadoop2U/** * 测试mahout org.apache.mahout.cf.taste.hadoop.item.RecommenderJob * environment：
* mahout0.9 * hadoop2.2 * @author fansy * */public class RecommenderJobTest{ //RecommenderJob rec = Configuration conf = @Before public void setUp(){ // rec= new RecommenderJob();
conf= Hadoop2Util.getConf();
System.out.println(“Begin to test…”); }
@Test public void testMain() throws Exception{
String[] args ={
“-i”,”hdfs://node31:9000/input/user.csv”,
“-o”,”hdfs://node31:9000/output/rec001″,
“-n”,+,”-b”,”false”,”-s”,”SIMILARITY_EUCLIDEAN_DISTANCE”,
“–maxPrefsPerUser”,+,”–minPrefsPerUser”,+,
“–maxPrefsInItemSimilarity”,+,
“–outputPathForSimilarityMatrix”,”hdfs://node31:9000/output/matrix/rec001″,
“–tempDir”,”hdfs://node31:9000/output/temp/rec001″};
ToolRunner.run(conf, new RecommenderJob(), args); }
@After public void cleanUp(){
No tags for this post.
除非注明，本站文章均为原创或编译，转载请注明： 文章来自
分享给朋友：
查看全部：后使用快捷导航没有帐号？
查看: 904|回复: 27
第八周作业 Mahout应该用啥版本
金牌会员, 积分 2319, 距离下一级还需 681 积分
论坛徽章:13
老师的ppt写着是 用 mahout-0.6， 然后看到有同学发贴说执行0.8的时候出错了
按照以前张丹老师写的（）
这里要说明一下mahout的运行版本。
mahout-0.5, mahout-0.6, mahout-0.7，是基于hadoop-0.20.2x的。
mahout-0.8, mahout-0.9，是基于hadoop-1.1.x的。
mahout-0.7，有一次重大升级，去掉了多个算法的单机内存运行，并且了部分API不向前兼容。复制代码
估计得用0.6了那，有尝试用其他版本成功的么？
每次换个环境是相当痛苦那
金牌会员, 积分 2319, 距离下一级还需 681 积分
论坛徽章:13
下载了 0.7 和0.8，看了 jar 中的 driver.classes.default.props 文件，写着trainclassifier = deprecated : Try the new vector backed naivebayes classifier see examples/bin/classify-20newsgroups.sh
testclassifier = deprecated : Try the new vector backed naivebayes classifier see examples/bin/classify-20newsgroups.sh 复制代码在 classify-20newsgroups.sh 中的例子是用 testnb 和 trainnb
金牌会员, 积分 2319, 距离下一级还需 681 积分
论坛徽章:13
执行了 mahout trainnb 提示Caused by: java.io.IOException: hdfs://hd1:9000/user/hd/week08/input/train/part-r-00000 not a SequenceFile复制代码看来新版本对数据还有要求，这工作量太大了，还是换成跟老师的版本一致试试把
金牌会员, 积分 2395, 距离下一级还需 605 积分
论坛徽章:5
金牌会员, 积分 2037, 距离下一级还需 963 积分
论坛徽章:4
环境已经配好了，用0.9版本mahout+1.2.1版本的hadoop
金牌会员, 积分 2319, 距离下一级还需 681 积分
论坛徽章:13
楼上两位，有跑成功的么？
论坛徽章:11
mahout-0.5, mahout-0.6, mahout-0.7，是基于hadoop-0.20.2x的。
为啥0.6在hadoop1.2.1上跑得也好好的
金牌会员, 积分 2319, 距离下一级还需 681 积分
论坛徽章:13
peter_zhang921 发表于
mahout-0.5, mahout-0.6, mahout-0.7，是基于hadoop-0.20.2x的。
为啥0.6在hadoop1.2.1上跑得也好好的
这个估计得问下老师了，可能某些函数已经问题不大把
高级会员, 积分 896, 距离下一级还需 104 积分
论坛徽章:2
0.8应该也可以吧
金牌会员, 积分 1405, 距离下一级还需 1595 积分
论坛徽章:2
我换回了0.6& 用Maven构建Mahout项目
用Maven构建Mahout项目
，主要介绍Hadoop家族产品，常用的项目包括Hadoop, Hive, Pig, HBase, Sqoop, Mahout, Zookeeper, Avro, Ambari, Chukwa，新增加的项目包括，YARN, Hcatalog, Oozie, Cassandra, Hama, Whirr, Flume, Bigtop, Crunch, Hue等。
从2011年开始，中国进入大数据风起云涌的时代，以Hadoop为代表的家族软件，占据了大数据处理的广阔地盘。开源界及厂商，所有数据软件，无一不向Hadoop靠拢。Hadoop也从小众的高富帅领域，变成了大数据开发的标准。在Hadoop原有技术基础之上，出现了Hadoop家族产品，通过“大数据”概念不断创新，推出科技进步。
作为IT界的开发人员，我们也要跟上节奏，抓住机遇，跟着Hadoop一起雄起！
关于作者：
张丹(Conan), 程序员Java,R,PHP,Javascript
weibo：@Conan_Z
转载请注明出处：
基于Hadoop的项目，不管是MapReduce开发，还是Mahout的开发都是在一个复杂的编程环境中开发。Java的环境问题，是困扰着每个程序员的噩梦。Java程序员，不仅要会写Java程序，还要会调linux，会配hadoop，启动hadoop，还要会自己运维。所以，新手想玩起Hadoop真不是件简单的事。
不过，我们可以尽可能的简化环境问题，让程序员只关注于写程序。特别是像算法程序员，把精力投入在算法设计上，要比花时间解决环境问题有价值的多。
Maven介绍和安装
Mahout单机开发环境介绍
用Maven构建Mahout开发环境
用Mahout实现协同过滤userCF
用Mahout实现kmeans
模板项目上传github
1. Maven介绍和安装
请参考文章：
Win7 64bit
Java 1.6.0_45
Eclipse Juno Service Release 2
Mahout 0.6
这里要说明一下mahout的运行版本。
mahout-0.5, mahout-0.6, mahout-0.7，是基于hadoop-0.20.2x的。
mahout-0.8, mahout-0.9，是基于hadoop-1.1.x的。
mahout-0.7，有一次重大升级，去掉了多个算法的单机内存运行，并且了部分API不向前兼容。
注：本文关注于“用Maven构建Mahout的开发环境”，文中的 2个例子都是基于单机的内存实现，因此选择0.6版本。Mahout在Hadoop集群中运行会在下一篇文章介绍。
2. Mahout单机开发环境介绍
如上图所示，我们可以选择在win中开发，也可以在linux中开发，开发过程我们可以在本地环境进行调试，标配的工具都是Maven和Eclipse。
3. 用Maven构建Mahout开发环境
1. 用Maven创建一个标准化的Java项目
2. 导入项目到eclipse
3. 增加mahout依赖，修改pom.xml
4. 下载依赖
1). 用Maven创建一个标准化的Java项目
~ D:\workspace\java&mvn archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes
-DgroupId=org.conan.mymahout -DartifactId=myMahout -DpackageName=org.conan.mymahout -Dversion=1.0-SNAPSHOT -DinteractiveMode=false
进入项目，执行mvn命令
~ D:\workspace\java&cd myMahout
~ D:\workspace\java\myMahout&mvn clean install
2). 导入项目到eclipse
我们创建好了一个基本的maven项目，然后导入到eclipse中。 这里我们最好已安装好了Maven的插件。
3). 增加mahout依赖，修改pom.xml
这里我使用hadoop-0.6版本，同时去掉对junit的依赖，修改文件：pom.xml
&project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"&
&modelVersion&4.0.0&/modelVersion&
&groupId&org.conan.mymahout&/groupId&
&artifactId&myMahout&/artifactId&
&packaging&jar&/packaging&
&version&1.0-SNAPSHOT&/version&
&name&myMahout&/name&
&url&http://maven.apache.org&/url&
&properties&
&project.build.sourceEncoding&UTF-8&/project.build.sourceEncoding&
&mahout.version&0.6&/mahout.version&
&/properties&
&dependencies&
&dependency&
&groupId&org.apache.mahout&/groupId&
&artifactId&mahout-core&/artifactId&
&version&${mahout.version}&/version&
&/dependency&
&dependency&
&groupId&org.apache.mahout&/groupId&
&artifactId&mahout-integration&/artifactId&
&version&${mahout.version}&/version&
&exclusions&
&exclusion&
&groupId&org.mortbay.jetty&/groupId&
&artifactId&jetty&/artifactId&
&/exclusion&
&exclusion&
&groupId&org.apache.cassandra&/groupId&
&artifactId&cassandra-all&/artifactId&
&/exclusion&
&exclusion&
&groupId&me.prettyprint&/groupId&
&artifactId&hector-core&/artifactId&
&/exclusion&
&/exclusions&
&/dependency&
&/dependencies&
&/project&
4). 下载依赖
~ mvn clean install
在eclipse中刷新项目：
项目的依赖程序，被自动加载的库路径下面。
4. 用Mahout实现协同过滤userCF
Mahout协同过滤UserCF深度算法剖析，请参考文章：
实现步骤：
1. 准备数据文件: item.csv
2. Java程序：UserCF.java
3. 运行程序
4. 推荐结果解读
1). 新建数据文件: item.csv
~ mkdir datafile
~ vi datafile/item.csv
数据解释：每一行有三列，第一列是用户ID，第二列是物品ID，第三列是用户对物品的打分。
2). Java程序：UserCF.java
Mahout协同过滤的数据流，调用过程。
上图摘自：Mahout in Action
新建JAVA类：org.conan.mymahout.recommendation.UserCF.java
package org.conan.mymahout.
import java.io.F
import java.io.IOE
import java.util.L
import org.apache.mahout.mon.TasteE
import org.apache.mahout.cf.mon.LongPrimitiveI
import org.apache.mahout.cf.taste.impl.model.file.FileDataM
import org.apache.mahout.cf.taste.impl.neighborhood.NearestNUserN
import org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedR
import org.apache.mahout.cf.taste.impl.similarity.EuclideanDistanceS
import org.apache.mahout.cf.taste.model.DataM
import org.apache.mahout.cf.taste.recommender.RecommendedI
import org.apache.mahout.cf.taste.recommender.R
import org.apache.mahout.cf.taste.similarity.UserS
public class UserCF {
final static int NEIGHBORHOOD_NUM = 2;
final static int RECOMMENDER_NUM = 3;
public static void main(String[] args) throws IOException, TasteException {
String file = "datafile/item.csv";
DataModel model = new FileDataModel(new File(file));
UserSimilarity user = new EuclideanDistanceSimilarity(model);
NearestNUserNeighborhood neighbor = new NearestNUserNeighborhood(NEIGHBORHOOD_NUM, user, model);
Recommender r = new GenericUserBasedRecommender(model, neighbor, user);
LongPrimitiveIterator iter = model.getUserIDs();
while (iter.hasNext()) {
long uid = iter.nextLong();
List list = r.recommend(uid, RECOMMENDER_NUM);
System.out.printf("uid:%s", uid);
for (RecommendedItem ritem : list) {
System.out.printf("(%s,%f)", ritem.getItemID(), ritem.getValue());
System.out.println();
3). 运行程序
控制台输出:
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
uid:1(104,4.6,4.000000)
uid:2(105,4.055916)
uid:3(103,3.2,2.773169)
uid:4(102,3.000000)
4). 推荐结果解读
向用户ID1，推荐前二个最相关的物品, 104和106
向用户ID2，推荐前二个最相关的物品, 但只有一个105
向用户ID3，推荐前二个最相关的物品, 103和102
向用户ID4，推荐前二个最相关的物品, 但只有一个102
向用户ID5，推荐前二个最相关的物品, 没有符合的
5. 用Mahout实现kmeans
1. 准备数据文件: randomData.csv
2. Java程序：Kmeans.java
3. 运行Java程序
4. mahout结果解读
5. 用R语言实现Kmeans算法
6. 比较Mahout和R的结果
1). 准备数据文件: randomData.csv
~ vi datafile/randomData.csv
-0.402,-3.49
-2.56,3.71
-1.94,-6.89
-4.16,1.32
-2.8,-3.35
-3.66,0.1799
-2.37,2.78
-0.376,1.37
-2.35,2.75
这里只截取了一部分，更多的数据请查看源代码。
注：我是通过R语言生成的randomData.csv
x1&-cbind(x=rnorm(400,1,3),y=rnorm(400,1,3))
x2&-cbind(x=rnorm(300,1,0.5),y=rnorm(300,0,0.5))
x3&-cbind(x=rnorm(300,0,0.1),y=rnorm(300,2,0.2))
x&-rbind(x1,x2,x3)
write.table(x,file="randomData.csv",sep=",",row.names=FALSE,col.names=FALSE)
2). Java程序：Kmeans.java
Mahout中kmeans方法的算法实现过程。
上图摘自：Mahout in Action
新建JAVA类：org.conan.mymahout.cluster06.Kmeans.java
package org.conan.mymahout.cluster06;
import java.io.IOE
import java.util.ArrayL
import java.util.L
import org.apache.mahout.clustering.kmeans.C
import org.apache.mahout.clustering.kmeans.KMeansC
import org.mon.distance.EuclideanDistanceM
import org.apache.mahout.math.V
public class Kmeans {
public static void main(String[] args) throws IOException {
List sampleData = MathUtil.readFileToVector("datafile/randomData.csv");
int k = 3;
double threshold = 0.01;
List randomPoints = MathUtil.chooseRandomPoints(sampleData, k);
for (Vector vector : randomPoints) {
System.out.println("Init Point center: " + vector);
List clusters = new ArrayList();
for (int i = 0; i & i++) {
clusters.add(new Cluster(randomPoints.get(i), i, new EuclideanDistanceMeasure()));
List&List& finalClusters = KMeansClusterer.clusterPoints(sampleData, clusters, new EuclideanDistanceMeasure(), k, threshold);
for (Cluster cluster : finalClusters.get(finalClusters.size() - 1)) {
System.out.println("Cluster id: " + cluster.getId() + " center: " + cluster.getCenter().asFormatString());
3). 运行Java程序
控制台输出:
Init Point center: {0:-0.196,1:2.62}
Init Point center: {0:-0..57}
Init Point center: {0:0.687,1:2.73}
SLF4J: Failed to load class "org.slf4j.impl.StaticLoggerBinder".
SLF4J: Defaulting to no-operation (NOP) logger implementation
SLF4J: See http://www.slf4j.org/codes.html#StaticLoggerBinder for further details.
Cluster id: 0 center: {0:-2.941,1:1.3795}
Cluster id: 1 center: {0:0..02105}
Cluster id: 2 center: {0:3.998,1:3.7653}
4). mahout结果解读
1. Init Point center表示，kmeans算法初始时的设置的3个中心点
2. Cluster center表示，聚类后找到3个中心点
5). 用R语言实现Kmeans算法
接下来为了让结果更直观，我们再用R语言，进行kmeans实验，操作相同的数据。
R语言代码：
& y&-read.csv(file="randomData.csv",sep=",",header=FALSE)
& cl&-kmeans(y,3,iter.max = 10, nstart = 25)
& cl$centers
1 -0..2852949
0..7011153
4..4622609
# 生成聚类中心的图形
& plot(y, col=c("black","blue","green")[cl$cluster])
& points(cl$centers, col="red", pch = 19)
# 画出Mahout聚类的中心
& mahout&-matrix(c(-2.941,1.6,0.,3.7653),ncol=2,byrow=TRUE)
& points(mahout, col="violetred", pch = 19)
聚类的效果图：
6). 比较Mahout和R的结果
从上图中，我们看到有 黑，蓝，绿，三种颜色的空心点，这些点就是原始的数据。
3个红色实点，是R语言kmeans后生成的3个中心。
3个紫色实点，是Mahout的kmeans后生成的3个中心。
R语言和Mahout生成的点，并不是重合的，原因有几点：
1. 距离算法不一样：
Mahout中，我们用的 “欧氏距离(EuclideanDistanceMeasure)”
R语言中，默认是”Hartigan and Wong”
2. 初始化的中心是不一样的。
3. 最大迭代次数是不一样的。
4. 点合并时，判断的”阈值(threshold)”是不一样的。
6. 模板项目上传github
大家可以下载这个项目，做为开发的起点。
~ git clone /bsspirit/maven_mahout_template
~ git checkout mahout-0.6
我们完成了第一步，下面就将正式进入mahout算法的开发实践，并且应用到hadoop集群的环境中。
转载请注明出处：
This entry was posted in , , , ,
Pingback: ()
Designed by