Mahout in Action 读书笔记chapter5 让推荐程序实用化

最新推荐文章于 2020-04-24 04:45:52 发布
最新推荐文章于 2020-04-24 04:45:52 发布
阅读量1.1k 收藏 1
点赞数
分类专栏： mahout in action 文章标签： mahout
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feitongxunke/article/details/38338455
版权

到了这一章就是真刀实枪的开始了。这是一个约会网站，首先需要下载
http://www.occamslab.com/petricek/data/libimseti-complete.zip ：

  • 这个里面包含了用户对其他人档案的评分，针对评分那个文件，事先经历了数据的预处理：提出了生成评分个数不到20个的用户，还排除了几乎对每个档案都给出相同分值的用户，因为这有可能是垃圾信息和不严肃的评分。
  • 还有个文件是表示用户的性别，其中U是代表为知。书中说了句：把女性推荐给一个仅对男性感兴趣的用户，这必然是一个糟糕的推荐，而且会冒犯用户，反之一样。

​1.找到一个有效的推荐程序

根据前一章的内容，首先我们要找到合适的推荐程序，这里尝试了基于用户的推荐，基于物品的推荐，对几种相似度度量的标准都一一进行了评测，根据评测出来的结果来选择合适的相似度度量方式。

1.1基于用户的推荐程序

n= 1 2 4 8 16 32 64 128
Euclidean 1.17 1.12 1.23 1.25 1.25 1.33 1.33 1.48
Pearson 1.30 1.19 1.27 1.30 1.26 1.35 1.38 1.47
Log-likelihood 1.33 1.38 1.33 1.35 1.33 1.29 1.33 1.49
Tanimoto 1.32 1.33 1.43 1.32 1.30 1.39 1.37 1.41
n= 0.95 0.9 0.85 0.8 0.75 0.7
Euclidean 1.33 1.37 1.39 1.43 1.41 1.47
Pearson 1.47 1.4 1.42 1.4 1.38 1.37
Log-likelihood 1.37 1.46 1.56 1.52 1.51 1.43
Tanimoto Nan Nan Nan Nan Nan Nan

上图是分别是基于n个最近邻和基于阈值的评测结果。

1.2基于物品的推荐程序

  Score
Euclidean 2.36
Pearson 2.32
Log-likelihood 2.38
Tanimoto 2.40

上图是基于物品推荐的结果。

1.3关于precision和recall

上面的谷本系数和对数似然比是无法进行评价的，因为这个无法得到评价值，只能进行precision和recall的计算。而且这里还有个很重要的问题，我们现在是采用的用户对物品打分的机制，但是用户不一定只对打分高的感兴趣。这种约会网站，更重要的不是仅仅推荐打分高的，因此这里我们可以采用布尔型来做推荐，书中接下来也是采用了布尔型，发现准确率和召回率高了很多。

2.引入特定域的信息

接下来会引入一个性别这个信息，基于性别可以定制一个ItemSimilarity这个度量，目的是避免推荐性别不当的用户。

2.1采用一个定制的物品相似性度量

下面代码是一个基于性别的物品相似度度量，书中说这个ItemSimilarity可以和标准的GenericItemBasedRecommender一起使用，进行评估。关于这点我并没有找到一起使用的方法，这里可以大致说下：
常见的是这个语句：


  
  
  1. ItemSimilarity similarity = new PearsonCorrelationSimilarity(model);

现在我们的GenderItemSimilarity继承ItemSimilarity接口，如果要使用GenderItemSimilarity，需要将
PearsonCorrelationSimilarity替换掉，GenderItemSimilarity里面最主要的方法是：


  
  
  1. public double[] itemSimilarities(long itemID1, long[] itemID2s) throws TasteException

我去查看了下PearsonCorrelationSimilarity父类，关系如下：


  
  
  1. public final class PearsonCorrelationSimilarity extends AbstractSimilarity
  2. abstract class AbstractSimilarity extends AbstractItemSimilarity implements UserSimilarity
  3. public interface UserSimilarity extends Refreshable

其中最主要的是AbstractSimilarity，其中Gender里面的很多方法，其中AbstractSimilarity都有所记载，但是我直接用GenderItemSimilarity继承AbstractSimilarity，也出了很多问题。继承AbstractSimilarity的原因很简单就是为了实现GenderItemSimilarity(model)，这里出现这么多问题，以后再看吧。
下面是GenderItemSimilarity的代码：


  
  
  1. import java.util.Collection;
  2. import org.apache.mahout.cf.taste.common.Refreshable;
  3. import org.apache.mahout.cf.taste.common.TasteException;
  4. import org.apache.mahout.cf.taste.impl.common.FastIDSet;
  5. import org.apache.mahout.cf.taste.similarity.ItemSimilarity;
  7. public class GenderItemSimilarity  implements ItemSimilarity  {
  8.     private final FastIDSet men; 
  9.     private final FastIDSet women; 
  11.     //给men和women集合赋初值
  12.     public GenderItemSimilarity(FastIDSet men, FastIDSet women) { 
  13.         this.men = men; 
  14.         this.women = women; 
  15.     } 
  16.     //判断两个ID是否同一性别
  17.     public double itemSimilarity(long profileID1, long profileID2) throws TasteException {
  18.         Boolean profile1IsMan = isMan(profileID1); 
  19.         if (profile1IsMan == null) { 
  20.           return 0.0; 
  21.         } 
  22.         Boolean profile2IsMan = isMan(profileID2); 
  23.         if (profile2IsMan == null) { 
  24.           return 0.0; 
  25.         } 
  26.         return profile1IsMan == profile2IsMan ? 1.0 : -1.0; 
  27.     }
  28.     //判断是否是男性
  29.     private Boolean isMan(long profileID) { 
  30.         if (men.contains(profileID)) { 
  31.           return Boolean.TRUE; 
  32.         } 
  33.         if (women.contains(profileID)) { 
  34.           return Boolean.FALSE; 
  35.         } 
  36.         return null; 
  37.     } 
  39.     //计算相似度的，调用方法itemSimilarity(long profileID1, long profileID2)
  40.     public double[] itemSimilarities(long itemID1, long[] itemID2s) throws TasteException{
  41.         double[] result = new double[itemID2s.length]; 
  42.         for (int i = 0; i < itemID2s.length; i++) { 
  43.           result[i] = itemSimilarity(itemID1, itemID2s[i]); 
  44.         } 
  45.         return result; 
  46.     } 
  49.     public long[] allSimilarItemIDs(long l) throws TasteException {
  50.         throw new UnsupportedOperationException("Not supported yet.");
  51.     }
  53.     public void refresh(Collection<Refreshable> clctn) {
  54.         throw new UnsupportedOperationException("Not supported yet.");
  55.     }
  57. }

2.2利用IDRescorer修改推荐结果

在Recommender.recommend()方法中有一个类型为IDRescorer的用final修饰的可选参数，在这里可以调用recommend(long userID,int howMany,IDRescorer rescorer)，IDRescorer这里是一个接口，里面有两个方法，


  
  
  1. double rescore(long id, double originalScore);
  2. boolean isFiltered(long id);

一个是用来重新打分，一个是用来过滤的。下面给出书中代码:


  
  
  1. import java.io.File;
  2. import java.io.IOException;
  3. import org.apache.mahout.cf.taste.common.TasteException;
  4. import org.apache.mahout.cf.taste.impl.common.FastIDSet;
  5. import org.apache.mahout.cf.taste.model.DataModel;
  6. import org.apache.mahout.cf.taste.model.PreferenceArray;
  7. import org.apache.mahout.cf.taste.recommender.IDRescorer;
  8. import org.apache.mahout.common.iterator.FileLineIterable;
  10. public class GenderRescorer implements IDRescorer {
  12.     private final FastIDSet men;//存放当前数据模型对应的所有male selectableUser
  13.     private final FastIDSet women;//存放当前数据模型对应的所有female selectableUser
  14.     private final FastIDSet usersRateMoreMen;//
  15.     private final FastIDSet usersRateLessMen;
  16.     private final boolean likeMen;//表明针对一个用户（userID定义）一个profileID是否应该过滤
  18.     public GenderRescorer(
  19.             FastIDSet men,
  20.             FastIDSet women,
  21.             long userID, DataModel model)
  22.             throws TasteException {
  23.         this.men = men;
  24.         this.women = women;
  25.         this.usersRateMoreMen = new FastIDSet();
  26.         this.usersRateLessMen = new FastIDSet();
  27.         this.likeMen = ratesMoreMen(userID, model);
  28.     }
  29.     //产生数据对应的men和women集合
  30.     public static FastIDSet[] generateMenWomen(File genderFile)
  31.             throws IOException {
  32.         FastIDSet men = new FastIDSet(50000);
  33.         FastIDSet women = new FastIDSet(50000);
  34.         for (String line : new FileLineIterable(genderFile)) {
  35.             int comma = line.indexOf(',');
  36.             char gender = line.charAt(comma + 1);
  37.             if (gender == 'U') {
  38.                 continue;
  39.             }
  40.             long profileID = Long.parseLong(line.substring(0, comma));
  41.             if (gender == 'M') {
  42.                 men.add(profileID);
  43.             } else {
  44.                 women.add(profileID);
  45.             }
  46.         }
  47.         men.rehash();
  48.         women.rehash();
  49.         return new FastIDSet[]{men, women};
  50.     }
  51.     //判断userID对应的用户是不是更喜欢男性，从他/她评过分的那些用户的性别来统计
  52.     private boolean ratesMoreMen(long userID, DataModel model)
  53.             throws TasteException {
  54.         if (usersRateMoreMen.contains(userID)) {
  55.             return true;
  56.         }
  57.         if (usersRateLessMen.contains(userID)) {
  58.             return false;
  59.         }
  60.         PreferenceArray prefs = model.getPreferencesFromUser(userID);
  61.         int menCount = 0;
  62.         int womenCount = 0;
  63.         for (int i = 0; i < prefs.length(); i++) {
  64.             long profileID = prefs.get(i).getItemID();
  65.             if (men.contains(profileID)) {
  66.                 menCount++;
  67.             } else if (women.contains(profileID)) {
  68.                 womenCount++;
  69.             }
  70.         }
  71.         boolean ratesMoreMen = menCount > womenCount;
  72.         if (ratesMoreMen) {
  73.             usersRateMoreMen.add(userID);
  74.         } else {
  75.             usersRateLessMen.add(userID);
  76.         }
  77.         return ratesMoreMen;
  78.     }
  79.    //对于需要过滤的推荐，设置其值为NaN，这是因为他们不是不能推荐的，而是最差的推荐
  80.     public double rescore(long profileID, double originalScore) {
  81.     if(originalScore<100)
  82.     System.out.println(profileID+" "+originalScore);
  83.         return isFiltered(profileID) ? Double.NaN : originalScore;
  84.     }
  85.     //如果一个用户是喜欢男性的，而推荐的又是女性，则这个推荐是应该过滤掉的，反之亦然
  86.     public boolean isFiltered(long profileID) {
  87.         return likeMen ? women.contains(profileID) : men.contains(profileID);
  88.     }
  89. }

2.3封装一个定制的推荐系统

下面是封装前面IDRescorer的推荐系统，当然也可以载入自己定义的IDRescorer，代码还是很简单，调用很方便。到时候直接调用即可


  
  
  1. public List<RecommendedItem> recommend(long userID, int topN)

  
  
  1. import java.io.File;
  2. import java.io.IOException;
  3. import java.util.Collection;
  4. import java.util.List;
  6. import org.apache.mahout.cf.taste.common.Refreshable;
  7. import org.apache.mahout.cf.taste.common.TasteException;
  8. import org.apache.mahout.cf.taste.impl.common.FastIDSet;
  9. import org.apache.mahout.cf.taste.impl.model.file.FileDataModel;
  10. import org.apache.mahout.cf.taste.impl.neighborhood.NearestNUserNeighborhood;
  11. import org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender;
  12. import org.apache.mahout.cf.taste.impl.similarity.EuclideanDistanceSimilarity;
  13. import org.apache.mahout.cf.taste.model.DataModel;
  14. import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood;
  15. import org.apache.mahout.cf.taste.recommender.IDRescorer;
  16. import org.apache.mahout.cf.taste.recommender.RecommendedItem;
  17. import org.apache.mahout.cf.taste.recommender.Recommender;
  18. import org.apache.mahout.cf.taste.similarity.UserSimilarity;
  20. public class LibimsetiRecommender implements Recommender {
  22.     private final Recommender libimsetiRecommender;
  23.     private final DataModel model;
  24.     private final FastIDSet men;
  25.     private final FastIDSet women;
  26.     //构造函数：一般而言，一个普适的自定义推荐器的输入应该是：DataModel和额外的知识
  27.     //应该将独立于数据的东西构建好：基本的pure CF推荐器
  29.     public LibimsetiRecommender() throws TasteException, IOException {
  30.         this((DataModel) new FileDataModel(new File("/Users/ericxk/Downloads/recommenderdata/libimseti/ratings.dat")));
  31.     }
  32.    //应该将独立于数据的东西构建好：基本的pure CF推荐器,即将libimsetiRecommender设为pure CF
  33.     public LibimsetiRecommender(DataModel model) throws TasteException, IOException {
  34.         UserSimilarity similarity = new EuclideanDistanceSimilarity(model);
  35.         UserNeighborhood neighborhood =
  36.                 new NearestNUserNeighborhood(2, similarity, model);
  37.         libimsetiRecommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
  38.         this.model = model;
  39.         FastIDSet[] menWomen = GenderRescorer.generateMenWomen(
  40.                 new File(("/Users/ericxk/Downloads/recommenderdata/libimseti/gender.dat")));
  41.         men = menWomen[0];
  42.         women = menWomen[1];
  43.     }
  44.    //用libimsetiRecommender进行推荐时就加入了由gender信息定义的GenderRescorer
  45.     public List<RecommendedItem> recommend(long userID, int topN) throws TasteException {
  46.         IDRescorer rescorer = new GenderRescorer(men, women, userID, model);
  47.         return libimsetiRecommender.recommend(userID, topN, rescorer);
  48.     }
  49.    //用libimsetiRecommender也提供了自定义IDRescorer进行推荐的方法
  50.     public List<RecommendedItem> recommend(long userID, int topN, IDRescorer idr) throws TasteException {
  51.     return libimsetiRecommender.recommend(userID, topN, idr); 
  52.     }
  53.    //这里要注意，由于libimsetiRecommender真正进行preference的估计是要受到GenderRescorer的rescore的影响的
  54.     public float estimatePreference(long userID, long itemID) throws TasteException {
  55.          IDRescorer rescorer = new GenderRescorer(men, women, userID, model); 
  56.     return (float) rescorer.rescore( 
  57.         itemID, libimsetiRecommender.estimatePreference(userID, itemID));
  58.     }
  59.    //这个可以直接借助于libimsetiRecommender的setPreference
  60.     public void setPreference(long userID, long itemID, float value) throws TasteException {
  61.         libimsetiRecommender.setPreference(userID, itemID, value);
  62.     }
  63.    //这个可以直接借助于libimsetiRecommender的removePreference
  64.     public void removePreference(long userID, long itemID) throws TasteException {
  65.         libimsetiRecommender.removePreference(userID, itemID);
  66.     }
  67.    //这个可以直接借助于libimsetiRecommender的getDataModel
  68.     public DataModel getDataModel() {
  69.         return libimsetiRecommender.getDataModel(); 
  70.     }
  71.    //这个可以直接借助于libimsetiRecommender的refresh
  72.     public void refresh(Collection<Refreshable> alreadyRefreshed) {
  73.         libimsetiRecommender.refresh(alreadyRefreshed);
  74.     }
  75. }

3.为匿名用户做推荐

因为在正常使用的情况，会有许多新用户没有历史记录，这个时候有一种方法是生成临时用户，并将所有的匿名用户当做一个用户。有一个类的名字叫PlusAnonymousUserDataModel，这个类是在DataModel上的一个封装。下面是代码：


  
  
  1. import java.io.File;
  2. import java.io.IOException;
  3. import java.util.List;
  4. import org.apache.mahout.cf.taste.common.TasteException;
  5. import org.apache.mahout.cf.taste.impl.model.GenericUserPreferenceArray;
  6. import org.apache.mahout.cf.taste.impl.model.PlusAnonymousUserDataModel;
  7. import org.apache.mahout.cf.taste.impl.model.file.FileDataModel;
  8. import org.apache.mahout.cf.taste.model.DataModel;
  9. import org.apache.mahout.cf.taste.model.PreferenceArray;
  10. import org.apache.mahout.cf.taste.recommender.RecommendedItem;
  12. public class LibimsetiWithAnonymousRecommender extends LibimsetiRecommender {
  14.     private final PlusAnonymousUserDataModel plusAnonymousModel;
  16.     public LibimsetiWithAnonymousRecommender()
  17.             throws TasteException, IOException {
  18.         this((DataModel) new FileDataModel(new File("data/dating/ratings.dat")));
  19.     }
  21.     public LibimsetiWithAnonymousRecommender(DataModel model)
  22.             throws TasteException, IOException {
  23.         //调用父类LibimsetiRecommender的构造函数
  24.         super(new PlusAnonymousUserDataModel(model));
  25.         //得到PlusAnonymousUserDataModel对象
  26.         plusAnonymousModel =
  27.                 (PlusAnonymousUserDataModel) getDataModel();
  28.     }
  29.     //设计这个推荐器的recommend方法：输入：匿名用户的评分信息 输出：对此匿名用户的推荐
  30.     public synchronized List<RecommendedItem> recommend(
  31.             PreferenceArray anonymousUserPrefs, int topN)
  32.             throws TasteException {
  33.         //利用PlusAnonymousUserDataModel对象的setTempPrefs方法为将匿名用户加入到数据中，
  34.         //并且利用PlusAnonymousUserDataModel.TEMP_USER_ID作为其userID
  35.         plusAnonymousModel.setTempPrefs(anonymousUserPrefs);
  36.         //调用父类LibimsetiRecommender的recommend方法
  37.         //userID现在被PlusAnonymousUserDataModel.TEMP_USER_ID所代替了
  38.         List<RecommendedItem> recommendations =
  39.                 recommend(PlusAnonymousUserDataModel.TEMP_USER_ID, topN, null);
  40.         //删除PlusAnonymousUserDataModel.TEMP_USER_ID与匿名用户的关联
  41.         plusAnonymousModel.clearTempPrefs();
  42.         return recommendations;
  43.     }
  44.     //创建当前匿名用户的伪数据
  45.     public PreferenceArray creatAnAnonymousPrefs() {
  46.         PreferenceArray anonymousPrefs =
  47.                 new GenericUserPreferenceArray(3);
  48.         anonymousPrefs.setUserID(0, PlusAnonymousUserDataModel.TEMP_USER_ID);
  49.         anonymousPrefs.setItemID(0, 123L);
  50.         anonymousPrefs.setValue(0, 1.0f);
  51.         anonymousPrefs.setItemID(1, 123L);
  52.         anonymousPrefs.setValue(1, 3.0f);
  53.         anonymousPrefs.setItemID(2, 123L);
  54.         anonymousPrefs.setValue(2, 2.0f);
  55.         return anonymousPrefs;
  56.     }
  58.     public static void main(String[] args) throws Exception {
  60.         LibimsetiWithAnonymousRecommender recommender =
  61.                 new LibimsetiWithAnonymousRecommender();
  62.         List<RecommendedItem> recommendations =
  63.                 recommender.recommend(recommender.creatAnAnonymousPrefs(), 10);
  64.         System.out.println(recommendations);
  65.     }
  66. }

4.创建一个支持Web访问的推荐程序

(这个时候可以下载官方的源代码:https://github.com/tdunning/MiA )
利用Mahout很容易将推荐程序捆绑成可部署的WAR文件。这一组件能很好地部署在Java servlet容器中，比如Tomcat，Resin。
首先需要封装WAR文件，在部署之前，需要把编译后的代码和数据文件打包为一个JAR文件。将数据集复制到/src/main/resources目录下，再用下面的命令制作出JAR文件:mvn package
然后进入Mahout发布包中的taste-web/模块目录，并从书中实例把target/mia-0.1.jar复制到lib子目录中。再编辑recommender.properties将推荐程序命名为索要采用的名称。如果你是用的是与实例相同的Java包名，正确的值应为mia.recommender.ch05.LibimsetiRecommender。现在再次执行mvn package，这个时候可以生成一个webapp-0.5.war的文件。这个文件可以立刻部署在Tomcat这种容器中。

5.更新和监控推荐程序

处于对性能的考虑，许多组件会生成缓存信息和中间的计算结果，这个时候有以下的处理方法:

  • 调用Recommender.refresh()强制情况所有缓存
  • 调用refresh方法来实现
    基于文件偏好数据是通过FileDataModel来访问的，这个时候部署更新信息时，我们可以对这个文件进行更新或者覆盖，而FileDataModel会马上注意到这个更新。
    数据文件重新加载很占资源，这个时候可以用更新文件，而不是对整个数据文件进行替换。
ericxk
关注
专栏目录
mahout in action中文版
wenyusuran的专栏
08-15 5112
mahout in action 中文翻译第1章初识mahout mahout in action 中文翻译 1. 初识Mahout 本章涵盖以下内容： Apache Mahout是什么？现实中推荐系统引擎、聚类、分类概述配置mahout 读者可能从本书的标题中依然知晓，本书是一本使用的工具书，讲解如何将mahout应用于业界。Mahout是Apache开源的机器学习库。它实现的算法
Mahout in Action 学习---基于物品的分布式推荐算法（Wikipedia数据集）
qq_17116557的博客
05-10 1713
文字总结自《Mahout in Action》中文版第六章的内容1.1 数据集介绍Wikipedia数据集:一篇文章到另外一篇文章的链接。 可以将文章看作是用户，将该文章指向的文章视为该源文章所喜欢的物品。 类型：单向布尔型偏好。 相似性评估算法：LogLikelihoodSimilarity 关于LogLikelihoodSimilarity具体算法思想见： 对数似然比相似度 - xid
Mahout in action小记（一）
u011569805的专栏
10-31 528
1.The user ID and item ID columns should be non-nullable, and must be indexed. 在使用数据库作为数据源时，userId, itemId 应该不为空 而且 应该建立索引 2.Refreshable interface 实现更新数据，显示调用 1,108,3.0 修改 user 1 item 108 3.0 1,10
Mahout in Action完整版本(英文)
01-31
一些支持 Map-Reduce 的集群实现包括 k-Means、模糊 k-Means、Canopy、Dirichlet 和 Mean-Shift。 　　Distributed Naive Bayes 和 Complementary Naive Bayes 分类实现。
Mahout in Action 读书笔记chapter2 推荐系统
ericxk
07-08 745
​1.推荐定义 基于用户（user-based）：要找到你可能喜欢的物品，你可以观察与你志趣相投的人喜欢什么。 基于物品（item-based）：通过观察其他人的明显偏好，你可以弄清楚哪些东西和你已然喜欢的物品相似。 基于内容（content-based）：立足于物品的属性来推荐，但是很难规整为一个框架。 Mahout对于基于内容的推荐较少。前两者是协同过滤的返利，也就是仅仅通过了
mahout in action
07-29
《Mahout in Action》是一本深入探讨Apache Mahout机器学习库的专业书籍，旨在帮助读者理解和应用这个强大的开源工具。Mahout是基于Java的，旨在提供可扩展的机器学习算法，适用于大数据处理。这本书通过实例和实践...
mahout in action推荐系统阅读笔记（5）
softwarehe的专栏
03-07 1109
第四章：making recommendation 理解User based推荐 重点在于用户之间的相似性，第一个算法如下： for every item i that u has no preference for yet for every other user v that has a preference for i compute a similarity s betw
mahout in action推荐系统阅读笔记（6）
softwarehe的专栏
03-07 1050
item based推荐 很多方面是和user based相同的 不同的是user based先要查找和自己相似用户，从他们喜欢的里边推荐，而item based是先找到user喜欢的item，然后寻找和这个item相似的item user based算法当用户多时候花费时间多，item based算法当item多时候花费时间多 算法 for every item i that
mahout in action 中文版
dangyifei
05-17 1565
http://running.iteye.com/category/144665
Mahout in action 实战中文版 高清 完整
03-13
Mahout in action 实战中文版 高清 完整,，最经典的hadoop机器学习库
MahoutInAction中文完整版.pdf
10-20
Apache顶级项目Mahout，基于Hadoop的分布式机器学习框架Mahout中文完整版文档。
mahout in action 笔记---初识
u013351371的专栏
01-01 494
机器学习和数据挖掘越来越热，相关的软件也很多，比如weka和mahout。weka是比较适合于做些模拟实验，在大规模的实践中，mahout用的比较多。    关于mahout的介绍有很多资料，这个可以在其官网找到mahout官网。    为了学好它，我们首先将其导入myeclipse，然后再开始编写。    这本书的前言部分对接下来的每一部分的功能说的很明白，今天主要是接触了一下样例，是一个
Mahout in action分析维基百科数据例子(一)
cbl709的专栏
04-03 1375
本文来源于我个人博客www.chenbiaolong.com概要本文主要根据mahout in action第六章分析维基百科链接数据的例子编写。大部分内容是直接翻译的mahout in action，不过不是逐字翻译，加入了一些个人理解。关于本文的前提背景可以参考其他博主翻译的文章： Mahout in action 中文版-6.分布式推荐计算-6.1 Mahout in action 中文版
Mahout in action 中文版-3.推荐器的数据表达
lhfredfly的专栏
01-02 1101
3 推荐器的数据表达 本章概要： Mahout的推荐数据如何呈现 DataModel 的实现和使用 布尔型的偏好数据处理 推荐结果的好坏取决于数据的数量和质量。“巧妇难为无米之炊”用在这里再合适不过了。数据质量高本身是好事，而且数据量大也是好事。推荐算法天生就是数据密集型的，它们擅长处理大数据。算法运行的性能和数据的质量和呈现形式直接相关。一个好的数据结构可以影
mahout和spark_Mahout和Scalding用于检测扑克共谋
04-24 221
mahout和spark 当我读过一本关于Mahout的非常出色的书《 Mahout In Action》 （这也是机器学习的出色入门）时，其中的一个例子引起了我的注意。 该书的作者使用了著名的K-means聚类算法在stackoverflow.com上寻找相似的参与者，其中相似性的标准是用户对问题的投票/回答的作者的集合。 用简单的话来说，K-means算法迭代地找到多维空间中彼此靠近的...
［mahout in action］mahout中用于推荐引擎的数据结构（二）
Leslie的专栏
08-15 763
DataModel是在Mahout中封装推荐引擎输入数据的抽象接口。实现类包括GenericDataModel，FileDataModel mahout中读取数据的方式有很多种，可以分为 手动录入，从file读取，从数据库读取 这里参考 《mahout in action》简单说一下手动录入方式，以及从file读取的方式。从数据库读取可参考API文档 手动： FastByI
能找到的最全的 mahout in action中文版
06-17
mahout in action 第一章 第二章 第三章第四章 第六章第七章 第九章
mahout in action[中文] 第一部分 推荐
扑腾蛾子
01-15 1076
本书的第一部分，包括第2章到第6章，探究mahout机器学习实现的三个核心之一：协同过滤和推荐。用这些技术，你能理解一个人的tastes并且自动的为他发现新的令他满意的内容。这一部分也是本书剩余部分的一个预热，这将要依赖于重量级的hadoop分布式计算框架。你会遇到在mahout中的机器学习技术，先用简单的java，然后在hadoop中。         第2章介绍推荐引擎，在mahout中的实
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值