eclipse、maven搭建mahout简单基于用户协同推荐demo

最新推荐文章于 2023-05-24 19:10:23 发布
最新推荐文章于 2023-05-24 19:10:23 发布
阅读量1.1k 收藏 6
点赞数
分类专栏： 实践 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_38232376/article/details/81199209
版权

 

 

本文记录了在mac使用maven和eclipse搭建mahout小demo的过程。

一、eclipse安装

二、maven安装

请允许我跳过这两步，因为我开始开发的过程中，eclipse和maven都已经是现成安装好的。

三、用maven构建mahout项目

1. 新建项目

打开eclipse，通过菜单File > New > Project新建项目，选择Maven Project

第一页直接Next,

第二页选择maven-archetype-quickstart,

第三页输入GroupId和ArtifactId, 这个自己随便定就好。

 

 

点了Finish后，Eclipse便会创建如下一个工程：

2. 引入mahout包

在http://mvnrepository.com/artifact/org.apache.mahout/mahout-core上可以查找到相关的包mahout-core, mahout-math。

在pom.xml中插入这段依赖，如下图。

实际上经过我尝试，只要引入mahout-core包以后，mahout-math也会引入。

<dependency>
		<groupId>org.apache.mahout</groupId>
		<artifactId>mahout-core</artifactId>
		<version>0.6</version>
	</dependency>

3. 编写代码运行程序

先添加工具类：recommendFactory 

package com.mrh.mahout.project;
import java.io.File;
import java.io.IOException;
import java.util.List;

import org.apache.mahout.cf.taste.common.TasteException;
import org.apache.mahout.cf.taste.eval.DataModelBuilder;
import org.apache.mahout.cf.taste.eval.IRStatistics;
import org.apache.mahout.cf.taste.eval.RecommenderBuilder;
import org.apache.mahout.cf.taste.eval.RecommenderEvaluator;
import org.apache.mahout.cf.taste.eval.RecommenderIRStatsEvaluator;
import org.apache.mahout.cf.taste.impl.common.FastByIDMap;
import org.apache.mahout.cf.taste.impl.eval.AverageAbsoluteDifferenceRecommenderEvaluator;
import org.apache.mahout.cf.taste.impl.eval.GenericRecommenderIRStatsEvaluator;
import org.apache.mahout.cf.taste.impl.eval.RMSRecommenderEvaluator;
import org.apache.mahout.cf.taste.impl.model.GenericBooleanPrefDataModel;
import org.apache.mahout.cf.taste.impl.model.file.FileDataModel;
import org.apache.mahout.cf.taste.impl.neighborhood.NearestNUserNeighborhood;
import org.apache.mahout.cf.taste.impl.neighborhood.ThresholdUserNeighborhood;
import org.apache.mahout.cf.taste.impl.recommender.ClusterSimilarity;
import org.apache.mahout.cf.taste.impl.recommender.FarthestNeighborClusterSimilarity;
import org.apache.mahout.cf.taste.impl.recommender.GenericBooleanPrefItemBasedRecommender;
import org.apache.mahout.cf.taste.impl.recommender.GenericBooleanPrefUserBasedRecommender;
import org.apache.mahout.cf.taste.impl.recommender.GenericItemBasedRecommender;
import org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender;
import org.apache.mahout.cf.taste.impl.recommender.NearestNeighborClusterSimilarity;
import org.apache.mahout.cf.taste.impl.recommender.TreeClusteringRecommender;
import org.apache.mahout.cf.taste.impl.recommender.knn.KnnItemBasedRecommender;
import org.apache.mahout.cf.taste.impl.recommender.knn.Optimizer;
import org.apache.mahout.cf.taste.impl.recommender.slopeone.SlopeOneRecommender;
import org.apache.mahout.cf.taste.impl.recommender.svd.Factorizer;
import org.apache.mahout.cf.taste.impl.recommender.svd.SVDRecommender;
import org.apache.mahout.cf.taste.impl.similarity.CityBlockSimilarity;
import org.apache.mahout.cf.taste.impl.similarity.EuclideanDistanceSimilarity;
import org.apache.mahout.cf.taste.impl.similarity.LogLikelihoodSimilarity;
import org.apache.mahout.cf.taste.impl.similarity.PearsonCorrelationSimilarity;
import org.apache.mahout.cf.taste.impl.similarity.SpearmanCorrelationSimilarity;
import org.apache.mahout.cf.taste.impl.similarity.TanimotoCoefficientSimilarity;
import org.apache.mahout.cf.taste.impl.similarity.UncenteredCosineSimilarity;
import org.apache.mahout.cf.taste.model.DataModel;
import org.apache.mahout.cf.taste.model.PreferenceArray;
import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood;
import org.apache.mahout.cf.taste.recommender.RecommendedItem;
import org.apache.mahout.cf.taste.recommender.Recommender;
import org.apache.mahout.cf.taste.similarity.ItemSimilarity;
import org.apache.mahout.cf.taste.similarity.UserSimilarity;

/**
 * 
 * @author bsspirit@gmail.com 
 * @link http://blog.fens.me/mahout-recommendation-api/
 */
public final class RecommendFactory {

    /**
     * build Data model from file
     */
    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<PreferenceArray> trainingData) {
                return new GenericBooleanPrefDataModel(GenericBooleanPrefDataModel.toDataMap(trainingData));
            }
        };
    }

    /**
     * similarity
     */
    public enum SIMILARITY {
        PEARSON, EUCLIDEAN, COSINE, TANIMOTO, LOGLIKELIHOOD, SPEARMAN, CITYBLOCK, 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 SPEARMAN:
            return new SpearmanCorrelationSimilarity(m);
        case CITYBLOCK:
            return new CityBlockSimilarity(m);
        case EUCLIDEAN:
        default:
            return new EuclideanDistanceSimilarity(m);
        }
    }

    public static ItemSimilarity itemSimilarity(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 CITYBLOCK:
            return new CityBlockSimilarity(m);
        case EUCLIDEAN:
        default:
            return new EuclideanDistanceSimilarity(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:
        default:
            return new FarthestNeighborClusterSimilarity(us);
        }
    }

    /**
     * neighborhood
     */
    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:
        default:
            return new ThresholdUserNeighborhood(num, s, m);
        }
    }

    /**
     * recommendation
     */
    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);
            }
        };
    }

    public static void showItems(long uid, List<RecommendedItem> 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();
        }
    }

    /**
     * evaluator
     */
    public enum EVALUATOR {
        AVERAGE_ABSOLUTE_DIFFERENCE, RMS
    }

    public static RecommenderEvaluator buildEvaluator(EVALUATOR type) {
        switch (type) {
        case RMS:
            return new RMSRecommenderEvaluator();
        case AVERAGE_ABSOLUTE_DIFFERENCE:
        default:
            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());
    }

}

测试类

package com.mrh.mahout.project;

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.apache.mahout.cf.taste.common.TasteException;
import org.apache.mahout.cf.taste.eval.RecommenderBuilder;
import org.apache.mahout.cf.taste.impl.common.LongPrimitiveIterator;
import org.apache.mahout.cf.taste.impl.model.file.FileDataModel;
import org.apache.mahout.cf.taste.model.DataModel;
import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood;
import org.apache.mahout.cf.taste.similarity.UserSimilarity;

public class RecommendTest {
	
	final static int NEIGHBORHOOD_NUM = 2;
    final static int RECOMMENDER_NUM = 3;
 
    public static void main(String[] args) throws TasteException, IOException {
        String file = "/Users/zjgy/Documents/dataset/item.csv";
        DataModel dataModel = new FileDataModel(new File(file));
        System.out.println(dataModel.toString());
        userCF(dataModel);
       // slopeOne(dataModel);
    }
    
    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);
        }

    }

}

测试结果：

附数据集：

1,101,5.0
1,102,3.0
1,103,2.5
2,101,2.0
2,102,2.5
2,103,5.0
2,104,2.0
3,101,2.5
3,104,4.0
3,105,4.5
3,107,5.0
4,101,5.0
4,103,3.0
4,104,4.5
4,106,4.0
5,101,4.0
5,102,3.0
5,103,2.0
5,104,4.0
5,105,3.5
5,106,4.0

 

猫球球
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java mahout使用教程_Mahout使用简例
weixin_35507450的博客
03-02 1430
剖析mahout脚本mahout 位于$MAHOUT_HOME/bin目录下，是所有mahout调用的入口。主要会做各类环境变量的设置。MAHOUT_JAVA_HOME:指定java的执行路劲，会覆盖$JAVA_HOMEMAHOUT_HEAPSIZE :JAVA运行堆栈的内存大小HADOOP_CONF_DIR : hadoop 配置文件路径主要是*-site.xml这些文件的位置MAHOUT...
JavaEE开发基于Eclipse的环境搭建以及Maven Web App的创建
08-31
本文主要介绍了如何在Eclipse中创建的Maven Project，本文是JavaEE开发的开篇，也是基础。下面内容主要包括了JDK1.8的安装、JavaEE版本的Eclipse的安装、Maven的安装、Tomcat 9.0的配置、Eclipse上的M2Eclipse插件...
使用Mahout搭建推荐系统之入门篇4-Mahout实战
清风漫步的专栏
11-07 5076
用意： 结合上篇博客，写写代码熟悉一下Mahout。很多地方想法都比较粗糙，亟待指正。 代码放在了：https://github.com/xiaoqiangkx/qingRS 一、基本内容     1. 加载数据: 判断userID和itemID的大小关系     2. 过滤数据: 评分较少的用户直接过滤掉, 那些评分均一致且评分数量多的用户过滤掉. 计算过滤百分比, 如果过滤过多
Mahout详细使用文档和案例
最新发布
qq_37480069的博客
05-24 1579
Mahout是一个基于Hadoop的机器学习库，它提供了许多常见机器学习算法的实现，包括聚类、分类、推荐等。以下是Mahout的详细使用文档，包括案例。
Mahout文件系统结构说明
The Best or Nothing!
06-01 219
Mahout项目是由多个子项目组成的，各子项目分别位于源码的不同目录下，下面对Mahout的组成进行介绍： 1、mahout-core：核心程序模块，位于/core目录下； 2、mahout-math：在核心程序中使用的一些数据通用计算模块，位于/math目录下； 3、mahout-utils：在核心程序中使用的一些通用的工具性模块，位于/utils目录下； 上述三个部分是程序...
用Maven构建Mahout项目
fens的博客
10-10 272
Hadoop家族系列文章，主要介绍Hadoop家族产品，常用的项目包括Hadoop, Hive, Pig, HBase, Sqoop, Mahout, Zookeeper, Avro, Ambari, Chukwa，新增加的项目包括，YARN, Hcatalog, Oozie, Cassandra, Hama, Whirr, Flume, ...
Eclipse使用maven搭建spring mvc图文教程
09-02
在本文中，我们将详细探讨如何使用Eclipse和Maven来搭建一个Spring MVC项目。首先，确保你的开发环境已经准备就绪，包括： 1. **环境配置**： - **Java 1.7**：作为运行基础，确保安装了JDK 1.7或以上版本。 - **...
使用eclipse + maven一步步搭建SSM框架教程详解
08-28
SSM（Spring+SpringMVC+MyBatis）框架集由Spring、SpringMVC、MyBatis三个开源框架整合而成，常作为数据源较简单的web项目的框架.这篇文章主要介绍了eclipse + maven搭建SSM框架 ,需要的朋友可以参考下
如何使用eclipse搭建maven多module项目(构建父子项目)
08-26
使用Eclipse搭建Maven多模块项目（构建父子项目） Maven是一款流行的Java项目管理和构建工具，Eclipse是最流行的Java集成开发环境（IDE）。在实际项目中，通常会使用Maven来管理项目的依赖关系和构建过程，而...
eclipse+ssm+maven+mysql简单搭建demo
05-25
采用eclipse开发工具 搭建的最简单的maven3.5.2+ssm+jdk7+mysql5框架。无任何署名，适合刚去新公司的人使用。可以直接导入即可开始项目工作，如果有特殊配置可以直接往上面增加即可
mahout-core-0.3.jar
04-01
mahout中需要用到的一个版本jar包：mahout-core-0.3.jar
mahout-core-0.7-job.jar
01-26
用于测试mahout中的决策树 ，即Partial Implementation用到的测试jar包。所谓的测试其实也只是把相应的数据可以打印出来，方便单机调试，理解算法实现原理而已。
mahout-core-0.9.jar
09-04
mahout-core-0.9.jar，支持版本hadoop-2.2.x，由mahout-distribution-0.9.tar.gz源码构建生成jar包。
mahout-core-0.9.jar+mahout-core-0.8.jar+mahout-core-0.1.jar
03-20
mahout-core-0.9.jar+mahout-core-0.8.jar+mahout-core-0.1.jar
mahout-core-0.8.jar
09-11
mahout-core-0.8.jar mahout-core-0.8.jar
零基础学习Mahout之一：搭建单机环境
chandzwx的专栏
03-09 591
本文主要介绍windows+eclipse+maven+mahout的环境搭建，之所以发表这文，一来由于网上的文章，多数没有注明版本，让很多初学者盲目跟从，总是遇到不可预知的问题，作者就是其中之一。二来，讲解针对不同的eclipse版本、mahout版本，怎么用java语言实现调用，记录笔记，利用其库实现mahout的算法调用，希望能帮助学习mahout的朋友，将大家聚集起来，共同进步
动手构建一个推荐系统(Recommendation System)
某花
11-20 3347
写在前面：本文通过构建一个电影推荐系统，深入浅出的介绍推荐系统相关的概念、算法，让读者朋友能够在对推荐系统有比较全面的认识的基础之上，能够轻松地构建出自己的推荐系统。 1. 什么是推荐系统（Recommendation System) 推荐系统是指根据一个群体的偏好，来为群体中的成员提供推荐的系统。现实生活中这样的例子很多，比如豆瓣(Douban.com)读书中的“豆瓣猜”功能，它根据你看过的
使用TensorFlow构建推荐系统Recommendation systems overview (Building recommendation systems with TensorFlow)
AI架构师易筋
02-01 559
References TensorFlow Recommenders https://www.tensorflow.org/recommenders ScaNN https://github.com/google-research/google-research/tree/master/scann TensorFlow Ranking https://github.com/tensorflow/ranking TensorFlow Lite on-device reco...
推荐系统Recommendation System：综述
皮皮blog
07-03 3813
http://blog.csdn.net/pipisorry/article/details/36633451博客内容：（个性化）推荐系统构建三大方法：基于内容的推荐content-based，协同过滤collaborative filtering，隐语义模型(LFM, latent factor model)推荐非个性化推荐[推荐系统：非个性化推荐Non-personalized recomme
eclipse + maven搭建SSM框架
04-18
如何用eclipse+maven 去搭建ssm框架 文档 需要的下吧 ！

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值