 上传我的文档
 下载
 收藏
该文档贡献者很忙，什么也没留下。
 下载此文档
正在努力加载中...
Mahout学习[精选PDF]
下载积分：1500
内容提示：Mahout学习[精选PDF]
文档格式：PDF|
浏览次数：17|
上传日期： 02:20:44|
文档星级：
全文阅读已结束，如果下载本文需要使用
 1500 积分
下载此文档
该用户还上传了这些文档
Mahout学习[精选PDF]
官方公共微信[Mahout] Windows下Mahout单机安装 - 路漫漫 - ITeye技术网站
博客分类：
刚开始接触Mahout，在网上也看了一些人家的文章，但是感觉都比较复杂。
下面我这种方式，在单机做一些简单的实验、作为初步对于mahout的了解估计是比较好的方法。
1. 到官网下载最新的版本：/apache-mirror/mahout/0.9/
2. 下载之后解压
3. Eclipse之中创建一个普通的java project 并将解压包之中的jar包导入到项目的classpath之中
在创建好项目之后，我们试一下第一个程序： （使用到的intro.csv被压缩在intro.zip之中了）
import java.io.F
import java.io.IOE
import java.util.L
import org.apache.mahout.mon.TasteE
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.PearsonCorrelationS
import org.apache.mahout.cf.taste.model.DataM
import org.apache.mahout.cf.taste.neighborhood.UserN
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 Test {
public static void main(String[] args) throws IOException, TasteException {
DataModel model = new FileDataModel(new File("E:\\DataSet\\intro.csv"));
UserSimilarity sim = new PearsonCorrelationSimilarity(model);
UserNeighborhood nbh = new NearestNUserNeighborhood(2, sim, model);
// 生成推荐引擎
Recommender rec = new GenericUserBasedRecommender(model, nbh, sim);
// 为用户1推荐物品1
List&RecommendedItem& recItemList = rec.recommend(1, 1);
for(RecommendedItem item : recItemList) {
System.out.println(item);
// RecommendedItem[item:104, value:4.257081]
结果即为推荐104这个东西
(238 Bytes)
下载次数: 182
RangerWolf
浏览: 130946 次
来自: 南京
那个csv数据在哪里呢
多谢赐教！
给的文件没有main函数 这个怎么启动啊
&div class=&quote_title ...
你好，这里面用到的数据文件在哪里找呢？mahout的推荐引擎Taste的学习笔记（三） -
- ITeye技术网站
博客分类：
（二） 基于物品的CF
了解了 User CF，Mahout Item CF 的实现与 User CF 类似，是基于 ItemSimilarity，下面我们看实现的代码例子，它比 User CF 更简单，因为 Item CF 中并不需要引入邻居的概念：
清单 4. 基于 Mahout 实现 Item CF
DataModel model = new FileDataModel(new File("preferences.dat"));
ItemSimilarity similarity = new PearsonCorrelationSimilarity(model);
Recommender recommender = new GenericItemBasedRecommender(model, similarity);
首先来分析一下GenericItemBasedRecommender这个类，他的功能函数为：
public List&RecommendedItem& recommend(long userID, int howMany, IDRescorer rescorer) throws TasteException {
Preconditions.checkArgument(howMany &= 1, "howMany must be at least 1");
log.debug("Recommending items for user ID '{}'", userID);
PreferenceArray preferencesFromUser = getDataModel().getPreferencesFromUser(userID);
if (preferencesFromUser.length() == 0) {
return Collections.emptyList();
//得到其他所有可能的item
FastIDSet possibleItemIDs = getAllOtherItems(userID, preferencesFromUser);
//创建评估器
TopItems.Estimator&Long& estimator = new Estimator(userID, preferencesFromUser);
//获取评测分数最高的howMany个item返回
List&RecommendedItem& topItems = TopItems.getTopItems(howMany, possibleItemIDs.iterator(), rescorer,
estimator);
log.debug("Recommendations are: {}", topItems);
return topI
1、获取其他可能的items
首先根据该userid用户所评论过的所有item，然后得到每个item对应进行评价过的user列表，然后将对应的每个user所评价过的item都添加到一个集合之中 ，最后将该集合中该userid用户评价过的item去除掉，得到我们想要的集合
protected FastIDSet getAllOtherItems(long userID, PreferenceArray preferencesFromUser) throws TasteException {
return candidateItemsStrategy.getCandidateItems(userID, preferencesFromUser, dataModel);
//这里的candidateItemsStrategy的出处
public GenericItemBasedRecommender(DataModel dataModel, ItemSimilarity similarity) {
this(dataModel,
similarity,
AbstractRecommender.getDefaultCandidateItemsStrategy(),
getDefaultMostSimilarItemsCandidateItemsStrategy());
protected static CandidateItemsStrategy getDefaultCandidateItemsStrategy() {
return new PreferredItemsNeighborhoodCandidateItemsStrategy();
public final class PreferredItemsNeighborhoodCandidateItemsStrategy extends AbstractCandidateItemsStrategy {
* 首先根据该user所评论过的所有item，然后得到每个item对应进行评价过的user列表，
* 然后将对应的每个user所评价过的item都添加到一个集合之中
* 最后将该集合中该user评价过的item去除掉，得到我们想要的集合
protected FastIDSet doGetCandidateItems(long[] preferredItemIDs, DataModel dataModel) throws TasteException {
FastIDSet possibleItemsIDs = new FastIDSet();
for (long itemID : preferredItemIDs) {
PreferenceArray itemPreferences = dataModel.getPreferencesForItem(itemID);
int numUsersPreferringItem = itemPreferences.length();
for (int index = 0; index & numUsersPreferringI index++) {
possibleItemsIDs.addAll(dataModel.getItemIDsFromUser(itemPreferences.getUserID(index)));
possibleItemsIDs.removeAll(preferredItemIDs);
return possibleItemsIDs;
2、创建评估器
将上边得到的可能的item的列表中的每一个item进行评估，一个可能的item与该userid用户所评价过的所有的item进行相似度的计算，最后取平均值，得到的这个值就是对这个item的评估值
private final class Estimator implements TopItems.Estimator&Long& {
public double estimate(Long itemID) throws TasteException {
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;
//用userid用户所有评价过的item与itemid的物品进行相似度计算
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
// 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);
3、获取评测分数最高的howMany个item返回
将上边可能item列表中的item的得分，都插入到一个优先队列中，保留评估值最高的howMany个item，作为最后的推荐结果返回
public static List&RecommendedItem& getTopItems(int howMany,
LongPrimitiveIterator possibleItemIDs,
IDRescorer rescorer,
Estimator&Long& estimator) throws TasteException {
Preconditions.checkArgument(possibleItemIDs != null, "argument is null");
Preconditions.checkArgument(estimator != null, "argument is null");
Queue&RecommendedItem& topItems = new PriorityQueue&RecommendedItem&(howMany + 1,
Collections.reverseOrder(ByValueRecommendedItemComparator.getInstance()));
boolean full =
double lowestTopValue = Double.NEGATIVE_INFINITY;
while (possibleItemIDs.hasNext()) {
long itemID = possibleItemIDs.next();
if (rescorer == null || !rescorer.isFiltered(itemID)) {
//得到该item的平均得分作为user的预测评分
preference = estimator.estimate(itemID);
} catch (NoSuchItemException nsie) {
double rescoredPref = rescorer == null ? preference : rescorer.rescore(itemID, preference);
if (!Double.isNaN(rescoredPref) && (!full || rescoredPref & lowestTopValue)) {
topItems.add(new GenericRecommendedItem(itemID, (float) rescoredPref));
if (full) {
topItems.poll();
} else if (topItems.size() & howMany) {
topItems.poll();
lowestTopValue = topItems.peek().getValue();
int size = topItems.size();
if (size == 0) {
return Collections.emptyList();
List&RecommendedItem& result = Lists.newArrayListWithCapacity(size);
result.addAll(topItems);
Collections.sort(result, ByValueRecommendedItemComparator.getInstance());
浏览: 431083 次
来自: 北京
易用易懂的支持向量机：excel+SVM
有二分 ...
不错，谢谢~~
你好！主函数main的代码是没有问题的，但是在使用rs.get ...
只限定固定个数的空格符, 多打一个空格就不起作用了
//这句话很关键
conf.set(& ...Mahout Item-based推荐的分布式实现 - 简书
Mahout Item-based推荐的分布式实现
title: Mahout Item-based推荐的分布式实现date:
16:02:36tags:
推荐系统categories: 大数据
Mahout API地址：
Mahout算法框架自带的推荐器有下面这些：
GenericUserBasedRecommender：基于用户的推荐器，用户数量少时速度快；
GenericItemBasedRecommender：基于商品推荐器，商品数量少时速度快，尤其当外部提供了商品相似度数据后效率更好；
SlopeOneRecommender：基于slope-one算法的推荐器，在线推荐或更新较快，需要事先大量预处理运算，物品数量少时较好；
SVDRecommender：奇异值分解，推荐效果较好，但之前需要大量预处理运算；
KnnRecommender：基于k近邻算法(KNN)，适合于物品数量较小时；
TreeClusteringRecommender：基于聚类的推荐器，在线推荐较快，之前需要大量预处理运算，用户数量较少时效果好；
Mahout最常用的三个推荐器是上述的前三个，本文主要讨论前两种的使用。
接口相关介绍
基于用户或物品的推荐器主要包括以下几个接口：
DataModel 是用户喜好信息的抽象接口，它的具体实现支持从任意类型的数据源抽取用户喜好信息。Taste 默认提供 JDBCDataModel 和 FileDataModel，分别支持从数据库和文件中读取用户的喜好信息。UserSimilarity 和 ItemSimilarity。UserSimilarity 用于定义两个用户间的相似度，它是基于协同过滤的推荐引擎的核心部分，可以用来计算用户的“邻居”，这里我们将与当前用户口味相似的用户称为他的邻居。ItemSimilarity 类似的，计算内容之间的相似度。UserNeighborhood 用于基于用户相似度的推荐方法中，推荐的内容是基于找到与当前用户喜好相似的邻居用户的方式产生的。UserNeighborhood 定义了确定邻居用户的方法，具体实现一般是基于 UserSimilarity 计算得到的。Recommender 是推荐引擎的抽象接口，Taste 中的核心组件。程序中，为它提供一个 DataModel，它可以计算出对不同用户的推荐内容。实际应用中，主要使用它的实现类 GenericUserBasedRecommender 或者 GenericItemBasedRecommender，分别实现基于用户相似度的推荐引擎或者基于内容的推荐引擎。RecommenderEvaluator：评分器。RecommenderIRStatsEvaluator：搜集推荐性能相关的指标，包括准确率、召回率等等。目前，Mahout为DataModel提供了以下几种实现：
org.apache.mahout.cf.taste.impl.model.GenericDataModel
org.apache.mahout.cf.taste.impl.model.GenericBooleanPrefDataModel
org.apache.mahout.cf.taste.impl.model.PlusAnonymousUserDataModel
org.apache.mahout.cf.taste.impl.model.file.FileDataModel
org.apache.mahout.cf.taste.impl.model.hbase.HBaseDataModel
org.apache.mahout.cf.taste.impl.model.cassandra.CassandraDataModel
org.apache.mahout.cf.taste.impl.model.mongodb.MongoDBDataModel
org.apache.mahout.cf.taste.impl.model.jdbc.SQL92JDBCDataModel
org.apache.mahout.cf.taste.impl.model.jdbc.MySQLJDBCDataModel
org.apache.mahout.cf.taste.impl.model.jdbc.PostgreSQLJDBCDataModel
org.apache.mahout.cf.taste.impl.model.jdbc.GenericJDBCDataModel
org.apache.mahout.cf.taste.impl.model.jdbc.SQL92BooleanPrefJDBCDataModel
org.apache.mahout.cf.taste.impl.model.jdbc.MySQLBooleanPrefJDBCDataModel
org.apache.mahout.cf.taste.impl.model.jdbc.PostgreBooleanPrefSQLJDBCDataModel
org.apache.mahout.cf.taste.impl.model.jdbc.ReloadFromJDBCDataModel从类名上就可以大概猜出来每个DataModel的用途，奇怪的是竟然没有HDFS的DataModel，有人实现了一个，请参考。
UserSimilarity 和 ItemSimilarity 相似度实现有以下几种：
CityBlockSimilarity：基于Manhattan距离相似度
EuclideanDistanceSimilarity：基于欧几里德距离计算相似度
LogLikelihoodSimilarity：基于对数似然比的相似度
PearsonCorrelationSimilarity：基于皮尔逊相关系数计算相似度
SpearmanCorrelationSimilarity：基于皮尔斯曼相关系数相似度
TanimotoCoefficientSimilarity：基于谷本系数计算相似度
UncenteredCosineSimilarity：计算 Cosine 相似度以上相似度的说明，请参考Mahout推荐引擎介绍。
UserNeighborhood 主要实现有两种：
NearestNUserNeighborhood：对每个用户取固定数量N个最近邻居
ThresholdUserNeighborhood：对每个用户基于一定的限制，取落在相似度限制以内的所有用户为邻居
Recommender分为以下几种实现：
GenericUserBasedRecommender：基于用户的推荐引擎
GenericBooleanPrefUserBasedRecommender：基于用户的无偏好值推荐引擎
GenericItemBasedRecommender：基于物品的推荐引擎
GenericBooleanPrefItemBasedRecommender：基于物品的无偏好值推荐引擎
RecommenderEvaluator有以下几种实现：
AverageAbsoluteDifferenceRecommenderEvaluator：计算平均差值
RMSRecommenderEvaluator：计算均方根差
RecommenderIRStatsEvaluator的实现类是GenericRecommenderIRStatsEvaluator。
首先，需要在maven中加入对mahout的依赖：
&dependency&
&groupId&org.apache.mahout&/groupId&
&artifactId&mahout-core&/artifactId&
&version&0.9&/version&
&/dependency&
&dependency&
&groupId&org.apache.mahout&/groupId&
&artifactId&mahout-integration&/artifactId&
&version&0.9&/version&
&/dependency&
&dependency&
&groupId&org.apache.mahout&/groupId&
&artifactId&mahout-math&/artifactId&
&version&0.9&/version&
&/dependency&
&dependency&
&groupId&org.apache.mahout&/groupId&
&artifactId&mahout-examples&/artifactId&
&version&0.9&/version&
&/dependency&
基于用户的推荐，以FileDataModel为例：
File modelFile modelFile = new File("intro.csv");
DataModel model = new FileDataModel(modelFile);
//用户相似度，使用基于皮尔逊相关系数计算相似度
UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
//选择邻居用户，使用NearestNUserNeighborhood实现UserNeighborhood接口，选择邻近的4个用户
UserNeighborhood neighborhood = new NearestNUserNeighborhood(4, similarity, model);
Recommender recommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
//给用户1推荐4个物品
List&RecommendedItem& recommendations = recommender.recommend(1, 4);
for (RecommendedItem recommendation : recommendations) {
System.out.println(recommendation);
注意： FileDataModel要求输入文件中的字段分隔符为逗号或者制表符，如果你想使用其他分隔符，你可以扩展一个FileDataModel的实现，例如，mahout中已经提供了一个解析MoiveLens的数据集（分隔符为::）的实现GroupLensDataModel。
GenericUserBasedRecommender是基于用户的简单推荐器实现类，推荐主要参照传入的DataModel和UserNeighborhood，总体是三个步骤：
从UserNeighborhood获取当前用户Ui最相似的K个用户集合{U1, U2, …Uk}；
从这K个用户集合排除Ui的偏好商品，剩下的Item集合为{Item0, Item1, …Itemm}；
对Item集合里每个Itemj计算Ui可能偏好程度值pref(Ui, Itemj)，并把Item按此数值从高到低排序，前N个item推荐给用户Ui。
对相同用户重复获得推荐结果，我们可以改用CachingRecommender来包装GenericUserBasedRecommender对象，将推荐结果缓存起来：
Recommender cachingRecommender = new CachingRecommender(recommender);
上面代码可以在main方法中直接运行，然后，我们可以获取推荐模型的评分：
//使用平均绝对差值获得评分
RecommenderEvaluator evaluator = new AverageAbsoluteDifferenceRecommenderEvaluator();
// 用RecommenderBuilder构建推荐引擎
RecommenderBuilder recommenderBuilder = new RecommenderBuilder() {
public Recommender buildRecommender(DataModel model) throws TasteException {
UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
UserNeighborhood neighborhood = new NearestNUserNeighborhood(4, similarity, model);
return new GenericUserBasedRecommender(model, neighborhood, similarity);
// Use 70%
test using the other 30%.
double score = evaluator.evaluate(recommenderBuilder, null, model, 0.7, 1.0);
System.out.println(score);
接下来，可以获取推荐结果的查准率和召回率：
RecommenderIRStatsEvaluator statsEvaluator = new GenericRecommenderIRStatsEvaluator();
// Build the same recommender for testing that we did last time:
RecommenderBuilder recommenderBuilder = new RecommenderBuilder() {
public Recommender buildRecommender(DataModel model) throws TasteException {
UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
UserNeighborhood neighborhood = new NearestNUserNeighborhood(4, similarity, model);
return new GenericUserBasedRecommender(model, neighborhood, similarity);
// 计算推荐4个结果时的查准率和召回率
IRStatistics stats = statsEvaluator.evaluate(recommenderBuilder,null, model, null, 4,
GenericRecommenderIRStatsEvaluator.CHOOSE_THRESHOLD,1.0);
System.out.println(stats.getPrecision());
System.out.println(stats.getRecall());
如果是基于物品的推荐，代码大体相似，只是没有了UserNeighborhood，然后将上面代码中的User换成Item即可，完整代码如下：
File modelFile modelFile = new File("intro.csv");
DataModel model = new FileDataModel(new File(file));
// Build the same recommender for testing that we did last time:
RecommenderBuilder recommenderBuilder = new RecommenderBuilder() {
public Recommender buildRecommender(DataModel model) throws TasteException {
ItemSimilarity similarity = new PearsonCorrelationSimilarity(model);
return new GenericItemBasedRecommender(model, similarity);
//获取推荐结果
List&RecommendedItem& recommendations = recommenderBuilder.buildRecommender(model).recommend(1, 4);
for (RecommendedItem recommendation : recommendations) {
System.out.println(recommendation);
//计算评分
RecommenderEvaluator evaluator =
new AverageAbsoluteDifferenceRecommenderEvaluator();
// Use 70%
test using the other 30%.
double score = evaluator.evaluate(recommenderBuilder, null, model, 0.7, 1.0);
System.out.println(score);
//计算查全率和查准率
RecommenderIRStatsEvaluator statsEvaluator = new GenericRecommenderIRStatsEvaluator();
// Evaluate precision and recall "at 2":
IRStatistics stats = statsEvaluator.evaluate(recommenderBuilder,
null, model, null, 4,
GenericRecommenderIRStatsEvaluator.CHOOSE_THRESHOLD,
System.out.println(stats.getPrecision());
System.out.println(stats.getRecall());
在Spark中运行
在Spark中运行，需要将Mahout相关的jar添加到Spark的classpath中，修改/etc/spark/conf/spark-env.sh，添加下面两行代码：
SPARK_DIST_CLASSPATH="$SPARK_DIST_CLASSPATH:/usr/lib/mahout/lib/*"
SPARK_DIST_CLASSPATH="$SPARK_DIST_CLASSPATH:/usr/lib/mahout/*"
然后，以本地模式在spark-shell中运行下面代码交互测试：
//注意：这里是本地目录
val model = new FileDataModel(new File("intro.csv"))
val evaluator = new RMSRecommenderEvaluator()
val recommenderBuilder = new RecommenderBuilder {
override def buildRecommender(dataModel: DataModel): Recommender = {
val similarity = new LogLikelihoodSimilarity(dataModel)
new GenericItemBasedRecommender(dataModel, similarity)
val score = evaluator.evaluate(recommenderBuilder, null, model, 0.95, 0.05)
println(s"Score=$score")
val recommender=recommenderBuilder.buildRecommender(model)
val users=trainingRatings.map(_.user).distinct().take(20)
import scala.collection.JavaConversions._
val result=users.par.map{user=&
user+","+recommender.recommend(user,40).map(_.getItemID).mkString(",")
RecommenderEvaluator，供大家学习参考。
分布式运行
Mahout提供了org.apache.mahout.cf.taste.hadoop.item.RecommenderJob类以MapReduce的方式来实现基于物品的协同过滤，查看该类的使用说明：
ubuntu@Master:~/data$ mahout org.apache.mahout.cf.taste.hadoop.item.RecommenderJob
MAHOUT_LOCAL adding HADOOP_CONF_DIR to classpath.
Running on hadoop, using /home/ubuntu/hadoop/bin/hadoop and HADOOP_CONF_DIR=/home/ubuntu/hadoop/etc/hadoop
MAHOUT-JOB: /home/ubuntu/apache-mahout-distribution-0.10.1/mahout-examples-0.10.1-job.jar
16/07/25 07:41:32 WARN driver.MahoutDriver: No org.apache.mahout.cf.taste.hadoop.item.RecommenderJob.props found on classpath, will use command-line arguments only
16/07/25 07:41:33 ERROR common.AbstractJob: Missing required option --similarityClassname
Missing required option --similarityClassname
[--input &input& --output &output& --numRecommendations &numRecommendations&
--usersFile &usersFile& --itemsFile &itemsFile& --filterFile &filterFile&
--userItemFile &userItemFile& --booleanData &booleanData& --maxPrefsPerUser
&maxPrefsPerUser& --minPrefsPerUser &minPrefsPerUser& --maxSimilaritiesPerItem
&maxSimilaritiesPerItem& --maxPrefsInItemSimilarity &maxPrefsInItemSimilarity&
--similarityClassname &similarityClassname& --threshold &threshold&
--outputPathForSimilarityMatrix &outputPathForSimilarityMatrix& --randomSeed
&randomSeed& --sequencefileOutput --help --tempDir &tempDir& --startPhase
&startPhase& --endPhase &endPhase&]
--similarityClassname (-s) similarityClassname
Name of distributed
similarity measures class to
instantiate, alternatively
use one of the predefined
similarities
([SIMILARITY_COOCCURRENCE,
SIMILARITY_LOGLIKELIHOOD,
SIMILARITY_TANIMOTO_COEFFICIEN
T, SIMILARITY_CITY_BLOCK,
SIMILARITY_COSINE,
SIMILARITY_PEARSON_CORRELATION
SIMILARITY_EUCLIDEAN_DISTANCE]
也可输入mahout org.apache.mahout.cf.taste.hadoop.item.RecommenderJob
--help查看详细说明
可见，该类可以接收的命令行参数如下：
--input(path)(-i): 存储用户偏好数据的目录，该目录下可以包含一个或多个存储用户偏好数据的文本文件；--output(path)(-o): 结算结果的输出目录--numRecommendations (integer): 为每个用户推荐的item数量，默认为10--usersFile (path): 指定一个包含了一个或多个存储userID的文件路径，仅为该路径下所有文件包含的userID做推荐计算 (该选项可选)--itemsFile (path): 指定一个包含了一个或多个存储itemID的文件路径，仅为该路径下所有文件包含的itemID做推荐计算 (该选项可选)--filterFile (path): 指定一个路径，该路径下的文件包含了[userID,itemID]值对，userID和itemID用逗号分隔。计算结果将不会为user推荐[userID,itemID]值对中包含的item (该选项可选)--booleanData (boolean): 如果输入数据不包含偏好数值，则将该参数设置为true，默认为false--maxPrefsPerUser (integer): 在最后计算推荐结果的阶段，针对每一个user使用的偏好数据的最大数量，默认为10--minPrefsPerUser (integer): 在相似度计算中，忽略所有偏好数据量少于该值的用户，默认为1--maxSimilaritiesPerItem (integer): 针对每个item的相似度最大值，默认为100--maxPrefsPerUserInItemSimilarity (integer): 在item相似度计算阶段，针对每个用户考虑的偏好数据最大数量，默认为1000--similarityClassname (classname): 向量相似度计算类outputPathForSimilarityMatrix：SimilarityMatrix输出目录--randomSeed：随机种子 –sequencefileOutput：序列文件输出路径--tempDir (path): 存储临时文件的目录，默认为当前用户的home目录下的temp目录--startPhase--endPhase--threshold (double): 忽略相似度低于该阀值的item对
一个例子如下，使用SIMILARITY_LOGLIKELIHOOD相似度推荐物品：
$ hadoop jar /usr/lib/mahout/mahout-examples-0.9-cdh5.4.0-job.jar org.apache.mahout.cf.taste.hadoop.item.RecommenderJob --input /tmp/mahout/part-00000 --output /tmp/mahout-out
-s SIMILARITY_LOGLIKELIHOOD
自己运行的例子如下：
部分实验数据：
ubuntu@Master:~/data$ mahout org.apache.mahout.cf.taste.hadoop.item.RecommenderJob -i /test/item/ckm_pre_result1000000.txt -o /test/item/outputPersonCorr --similarityClassname org.apache.mahout.math.hadoop.similarity.cooccurrence.measures.PearsonCorrelationSimilarity
部分结果：
[196:10.:9.:8.:7.:7.:7.:7.:6.:6.:6.586777]
[386:4.:4.:4.:4.:3.:3.:3.:2.:2.:2.693153]
[45:4.:4.:3.:3.:3.:3.:3.:3.:3.:3.28568]
[293:4.:3.:3.:3.:2.:2.:2.:2.:2.:2.008545]
[590:1.:1.:1.:1.:1.:1.:1.:1.:1.:1.0349866]
默认情况下，mahout使用的reduce数目为1，这样造成大数据处理时效率较低，可以通过参数mahout执行脚本中的MAHOUT_OPTS中的-Dmapred.reduce.tasks参数指定reduce数目。
上面命令运行完成之后，会在当前用户的hdfs主目录生成temp目录，该目录可由--tempDir (path)参数设置：
$ hadoop fs -ls temp
Found 10 items
-rw-r--r--
3 root hadoop
14:42 temp/maxValues.bin
-rw-r--r--
3 root hadoop
5-06-10 14:42 temp/norms.bin
drwxr-xr-x
- root hadoop
14:41 temp/notUsed
-rw-r--r--
3 root hadoop
14:42 temp/numNonZeroEntries.bin
-rw-r--r--
3 root hadoop
5-06-10 14:41 temp/observationsPerColumn.bin
drwxr-xr-x
- root hadoop
14:47 temp/pairwiseSimilarity
drwxr-xr-x
- root hadoop
14:52 temp/partialMultiply
drwxr-xr-x
- root hadoop
14:39 temp/preparePreferenceMatrix
drwxr-xr-x
- root hadoop
14:50 temp/similarityMatrix
drwxr-xr-x
- root hadoop
14:42 temp/weights
观察yarn的管理界面，该命令会生成9个任务，任务名称依次是：
PreparePreferenceMatrixJob-ItemIDIndexMapper-Reducer
PreparePreferenceMatrixJob-ToItemPrefsMapper-Reducer
PreparePreferenceMatrixJob-ToItemVectorsMapper-Reducer
RowSimilarityJob-CountObservationsMapper-Reducer
RowSimilarityJob-VectorNormMapper-Reducer
RowSimilarityJob-CooccurrencesMapper-Reducer
RowSimilarityJob-UnsymmetrifyMapper-Reducer
partialMultiply
RecommenderJob-PartialMultiplyMapper-Reducer
从任务名称，大概可以知道每个任务在做什么，如果你的输入参数不一样，生成的任务数可能不一样，这个需要测试一下才能确认。
在hdfs上查看输出的结果，用户和推荐结果用\t分隔，推荐结果中物品之间用逗号分隔，物品后面通过冒号连接评分：
843 [.426,.:4.5:4.108,.0467]
[.:3.164,.:3.7:3.3839]
使用Java API方式执行，请参考。
在Scala或者Spark中，可以以Java API或者命令方式运行，最后还可以通过Spark来处理推荐的结果，例如：过滤、去重、补足数据，这部分内容不做介绍。
本文基本转载自：转载自，作者：JavaChen，文章地址
其他参考资料:}