[关闭]
@HUST-SuWB 2015-12-15T00:53:21.000000Z 字数 12307 阅读 593

基于Mahout的推荐实例

项目实战

基本概念

所谓推荐算法就是利用用户的一些行为，通过一些数学算法，推测出用户可能喜欢的东西。推荐算法的主要类型有基于内容的推荐、协同过滤推荐（基于用户、基于物品）、基于关联规则的推荐等。在Mahout的算法实现中，重点放在协同过滤推荐上，因为这种推荐方式是最通用的，理论上不受推荐对象的影响，可以用于各种事物的推荐。

需求分析

我的需求是为高校推荐他们后续可以合作的其他高校。基本思路是基于关联规则来推荐，即在历史数据中找出所有高校之间的关联度，以此关联度作为评分。当为某个具体的高校进行推荐的时候，推荐结果就是此高校没有合作过，但是是与跟此高校合作过的其他高校关联度最高的。
一个典型的输入数据如下

学校1 学校2 关联度
华中科技大学 武汉大学 10
武汉大学 华中科技大学 10
华中科技大学 武汉理工大学 8
武汉理工大学 华中科技大学 8

P.S. 给高校做推荐只是个例子，对于实际需求来说，给予学校推荐后续可以合作的高校并不合理，因为高校不是项目申报立项过程中的主体，主体是具体的人，所以人和人之间的关联关系放大到高校层面不具备指导意义。

代码实例

  1. import java.io.File;
  2. import java.io.IOException;
  3. import java.util.ArrayList;
  4. import java.util.Collection;
  5. import java.util.HashMap;
  6. import java.util.HashSet;
  7. import java.util.List;
  8. import java.util.Map;
  9. import java.util.Map.Entry;
  10. import java.util.Set;
  12. import org.apache.hadoop.conf.Configuration;
  13. import org.apache.hadoop.fs.FileSystem;
  14. import org.apache.hadoop.fs.Path;
  15. import org.apache.hadoop.io.SequenceFile;
  16. import org.apache.hadoop.io.Text;
  17. import org.apache.mahout.common.Pair;
  18. import org.apache.mahout.fpm.pfpgrowth.convertors.ContextStatusUpdater;
  19. import org.apache.mahout.fpm.pfpgrowth.convertors.SequenceFileOutputCollector;
  20. import org.apache.mahout.fpm.pfpgrowth.convertors.string.StringOutputConverter;
  21. import org.apache.mahout.fpm.pfpgrowth.convertors.string.TopKStringPatterns;
  22. import org.apache.mahout.fpm.pfpgrowth.fpgrowth.FPGrowth;
  24. import tool.CsvTool;
  26. /**
  27.  * 关联分析测试
  28.  * @author suwb
  29.  * @since 2015-12-14
  30.  */
  31. public class Association {
  33.     private static int minSupport = 2;//设置最小支持度
  34.     private static final String UNIVERSITY_PATH = "F:\\source\\association\\university_out.dat";
  35.     private static final String CSV_PATH = "F:\\source\\association\\关联规则输出.csv";
  37.     //准备源数据
  38.     public List<Object[]> getData(){
  39.         Dao jdbcDao = new Dao();
  40.         //定义关联规则挖掘器的输入数据
  41.         List<Object[]> dataItems = new ArrayList<Object[]>();
  42.         //高校与高校之间的关联性
  43.         //查询项目中有高校合作研究的情况，并转换为关联规则挖掘器的输入数据格式
  44.         //所有立项项目所属高校
  45.         List<Object[]> univs4Project = null;
  46.         //所有立项项目项目成员所在高校
  47.         List<Object[]> univs4Member = null;
  48.         //所有立项项目所属高校
  49.         String projectHql = "SQL";
  50.         univs4Project = jdbcDao.queryBySql(projectHql);
  51.         //所有立项项目项目成员所在高校
  52.         String memberHql = "SQL";
  53.         univs4Member = jdbcDao.queryBySql(memberHql);
  54.         //项目id -> 高校集合的映射（set去重）
  55.         Map<String, Set<String>> univMap = new HashMap<String, Set<String>>();
  56.         //根据项目id，遍历项目所有成员的高校信息
  57.         for (Object[] objs : univs4Member) {
  58.             Set<String> univs = univMap.get(objs[0]);
  59.             if (univs == null) {
  60.                 univs = new HashSet<String>();
  61.                 univMap.put((String)objs[0], univs);
  62.             }
  63.             univs.add((String)objs[1]);
  64.         }
  65.         //根据项目id，遍历项目的高校信息
  66.         for (Object[] objs : univs4Project) {
  67.             Set<String> univs = univMap.get(objs[0]);
  68.             if (univs != null) {
  69.                 univs.add((String)objs[1]);
  70.             }
  71.         }
  72.         //准备关联规则挖掘器的输入数据
  73.         for (Entry<String, Set<String>> entry : univMap.entrySet()) {
  74.             Set<String> univs = entry.getValue();
  75.             dataItems.add(univs.toArray());
  76.         }
  77.         return dataItems;
  78.     }
  80.     //生成频繁模式，并序列化
  81.     @SuppressWarnings("deprecation")
  82.     public void getFrequentPatternFile() throws IOException{
  83.         List<Object[]> dataItems = getData();
  84.         //采用FP-bonsai pruning而实现更快的频繁模式增长（Frequent Pattern Growth）算法
  85.         FPGrowth<String> fp = new FPGrowth<String>();
  86.         // 所有事务集合
  87.         Collection<Pair<List<String>, Long>> transactions = new ArrayList<Pair<List<String>, Long>>();
  88.         // 构建transactions：pair事务集
  89.         for (Object[] dataItem : dataItems) {
  90.             List<String> list = new ArrayList<String>();
  91.             for (int i = 0; i < dataItem.length; i++) {
  92.                 if (dataItem[i] != null) {
  93.                     list.add(String.valueOf(dataItem[i]));
  94.                 }
  95.             }
  96.             transactions.add(new Pair<List<String>, Long>(list, 1L));
  97.         }
  98.         //设置输出文件路径
  99.         String tmpFilePath = UNIVERSITY_PATH;
  100.         File tmpFile = new File(tmpFilePath);
  101.         String tmpDirPath = null;   //临时文件路径
  102.         if (!tmpFile.exists()) {
  103.             tmpDirPath = tmpFilePath.substring(0, tmpFilePath.indexOf("university_out.dat"));//从文件路径中截取文件夹得路径
  104.             tmpFile = File.createTempFile("university_out", ".dat", new File(tmpDirPath));//在上一步的文件夹中创建新文件fpg_out.dat文件
  105.         }
  106.         Path path = new Path(tmpFile.getAbsolutePath());
  107.         Configuration conf = new Configuration();
  108.         FileSystem fs = FileSystem.get(conf);
  110.         //构造序列化文件写入器
  111.         SequenceFile.Writer writer = new SequenceFile.Writer(fs, conf, path, Text.class, TopKStringPatterns.class);
  113.         // 在给定的事务流和最小支持度下，为每个属性生成前K频繁模
  114.         fp.generateTopKFrequentPatterns(
  115.                 transactions.iterator(),    //待挖掘的事务迭代器
  116.                 fp.generateFList(transactions.iterator(), (int) minSupport),
  117.                 minSupport,     //最小支持度
  118.                 1000,           //各属性显示前K条(Number of top frequent patterns to keep)
  119.                 null, 
  120.                 new StringOutputConverter(new SequenceFileOutputCollector<Text, TopKStringPatterns>(writer)), 
  121.                 new ContextStatusUpdater(null));
  122.         writer.close();
  123.     }
  125.     //将关联结果写入文件
  126.     @SuppressWarnings("deprecation")
  127.     public void writeAssociationToFile(){
  128.         String tmpDirPath = UNIVERSITY_PATH.substring(0, UNIVERSITY_PATH.indexOf("university_out.dat"));//从文件路径中截取文件夹得路径
  129.         File file = new File(tmpDirPath);
  130.         File[] listFile = file.listFiles();
  131.         Path path = null;
  132.         for(File thisFile : listFile){
  133.             if(thisFile.getName().contains("university") && !thisFile.getName().contains("crc")){
  134.                 path = new Path(thisFile.getAbsolutePath());
  135.             }
  136.         }
  137.         Configuration conf = new Configuration();
  138.         //调用mahout读取接口方法，从频繁模式库中读取频繁模式集
  139.         List<Pair<String, TopKStringPatterns>> frequentPatterns = FPGrowth.readFrequentPattern(conf, path);
  140.         Map<String, List<Object[]>> assoMap = new HashMap<String, List<Object[]>>();
  141.         //对所有频繁模式进行遍历
  142.         for (Pair<String, TopKStringPatterns> fps : frequentPatterns) {
  143.             String key = fps.getFirst();    //如：key=华中科技大学
  144.             TopKStringPatterns value = fps.getSecond();
  145. //          System.out.println("key：" + key + " | value：" + value);
  146.             List<Object[]> data = new ArrayList<Object[]>();
  147.             //获取当前关键词key下所有模式
  148.             List<Pair<List<String>, Long>> patterns = value.getPatterns();
  149.             for(Pair<List<String>, Long> pair: patterns) {
  150.                 List<String> itemNames = pair.getFirst();   // 获取模式的元素名，如：[华中科技大学, 武汉大学, 湖北大学]
  151.                 Long occurrence = pair.getSecond();         // 获取模式的频繁度，如：10或6
  152.                 for(String itemName: itemNames) {
  153.                     if (!itemName.equals(key)) {//过滤掉key自身
  154.                         data.add(new Object[]{itemName, occurrence});
  155.                     }
  156.                 }
  157.             }
  158.             if (data.size() > 0) {
  159.                 assoMap.put(key, data);//map格式样例：{华中科技大学, [[武汉大学, 48], [湖北大学, 11]], [武汉大学, 7]]}
  160.             }
  161.         }
  162.         List<String[]> dataList = new ArrayList<String[]>();//关联结果集
  163.         for(String key : assoMap.keySet()){
  164.             List<Object[]> value = assoMap.get(key);
  165.             Map<String, Long> map = new HashMap<String, Long>();
  166.             for(Object[] o : value){
  167.                 if(map.get(o[0]) == null){
  168.                     map.put(o[0].toString(), (Long)o[1]);
  169.                 }else {
  170.                     map.put(o[0].toString(), map.get(o[0]) + (Long)o[1]);
  171.                 }
  172.             }
  173.             for(String k : map.keySet()){
  174.                 dataList.add(new String[]{key, k, map.get(k).toString()});//dataList格式样例：[[华中科技大学, 武汉大学, 48], [武汉科技大学, 湖北大学, 11]]
  175.             }
  176.         }
  177.         String[] header = {"user1", "user2", "评分"};
  178.         CsvTool.writeCsv(CSV_PATH, header, dataList);
  179.     }
  181.     public void run(){
  182.         try {
  183.             getFrequentPatternFile();
  184.         } catch (IOException e) {
  185.             e.printStackTrace();
  186.         }
  187.         writeAssociationToFile();
  188.     }
  189. }
  1. import java.io.File;
  2. import java.util.ArrayList;
  3. import java.util.HashMap;
  4. import java.util.List;
  5. import java.util.Map;
  7. import org.apache.mahout.cf.taste.common.TasteException;
  8. import org.apache.mahout.cf.taste.eval.IRStatistics;
  9. import org.apache.mahout.cf.taste.eval.RecommenderBuilder;
  10. import org.apache.mahout.cf.taste.eval.RecommenderEvaluator;
  11. import org.apache.mahout.cf.taste.eval.RecommenderIRStatsEvaluator;
  12. import org.apache.mahout.cf.taste.impl.eval.AverageAbsoluteDifferenceRecommenderEvaluator;
  13. import org.apache.mahout.cf.taste.impl.eval.GenericRecommenderIRStatsEvaluator;
  14. import org.apache.mahout.cf.taste.impl.model.file.FileDataModel;
  15. import org.apache.mahout.cf.taste.impl.neighborhood.NearestNUserNeighborhood;
  16. import org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender;
  17. import org.apache.mahout.cf.taste.impl.similarity.PearsonCorrelationSimilarity;
  18. import org.apache.mahout.cf.taste.model.DataModel;
  19. import org.apache.mahout.cf.taste.neighborhood.UserNeighborhood;
  20. import org.apache.mahout.cf.taste.recommender.RecommendedItem;
  21. import org.apache.mahout.cf.taste.recommender.Recommender;
  22. import org.apache.mahout.cf.taste.similarity.UserSimilarity;
  24. import tool.CsvTool;
  26. /**
  27.  * 推荐测试
  28.  * Mahout中的推荐由多个组件组成
  29.  * 1、数据模型，由DataModel实现；
  30.  * 2、用户间的相似性度量 ，由UserSimilarity实现；
  31.  * 3、用户邻域的定义，由UserNeighborhood实现；
  32.  * 4、推荐引擎，由一个Recommender实现。
  33.  * 基本原理见《Mahout实战》P36
  34.  * @author suwb
  35.  * @since 2015-12-08
  36.  */
  37. public class Recommendation {
  39.     private static final String ASSOCIATION_SOURCE = "F:\\source\\association\\关联规则输出.csv";
  40.     private static final String RECOMMENDATION_SOURCE = "F:\\source\\recommendation\\推荐算法输入数据.csv";
  41.     private static Map<String, Integer> map;
  42.     private static String userName = "华中科技大学";
  44.     public Recommendation(){
  45.         if(map == null){
  46.             initName2IdMap();
  47.         }
  48.     }
  50.     //运行推荐算法
  51.     public List<RecommendedItem> work(long userId) throws Exception{
  52.         DataModel model = new FileDataModel(new File(RECOMMENDATION_SOURCE));
  53.         UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
  54.         UserNeighborhood neighborhood = new NearestNUserNeighborhood(50, similarity, model);
  55.         Recommender recommender = new GenericUserBasedRecommender(model, neighborhood, similarity);
  56.         return recommender.recommend(userId, 5);
  57.     }
  59.     //算法效果评分
  60.     //评分越小越好
  61.     public void evaluateScore() throws Exception{
  62.         DataModel model = new FileDataModel(new File(RECOMMENDATION_SOURCE));
  63.         RecommenderEvaluator evaluator = new AverageAbsoluteDifferenceRecommenderEvaluator();
  64.         RecommenderBuilder builder = new RecommenderBuilder() {
  65.             @Override
  66.             public Recommender buildRecommender(DataModel model) throws TasteException {
  67.                 UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
  68.                 UserNeighborhood neighborhood = new NearestNUserNeighborhood(90, similarity, model);
  69.                 return new GenericUserBasedRecommender(model, neighborhood, similarity);
  70.             }
  71.         };
  72.         double score = evaluator.evaluate(builder, null, model, 0.7, 1);
  73.         System.out.println(score);
  74.     }
  76.     //评估查准率和查全率
  77.     public void evaluateRate() throws Exception{
  78.         DataModel model = new FileDataModel(new File(RECOMMENDATION_SOURCE));
  79.         RecommenderIRStatsEvaluator evaluator = new GenericRecommenderIRStatsEvaluator();
  80.         RecommenderBuilder builder = new RecommenderBuilder() {
  81.           @Override
  82.           public Recommender buildRecommender(DataModel model) throws TasteException {
  83.             UserSimilarity similarity = new PearsonCorrelationSimilarity(model);
  84.             UserNeighborhood neighborhood = new NearestNUserNeighborhood(90, similarity, model);
  85.             return new GenericUserBasedRecommender(model, neighborhood, similarity);
  86.           }
  87.         };
  88.         IRStatistics stats = evaluator.evaluate(builder, null, model, null, 5,
  89.                                                 GenericRecommenderIRStatsEvaluator.CHOOSE_THRESHOLD,
  90.                                                 1);
  91.         System.out.println(stats.getPrecision());
  92.         System.out.println(stats.getRecall());
  93.     }
  95.     public String getNameById(int id){
  96.         String name = "";
  97.         for(String key : map.keySet()){
  98.             if(map.get(key) == id){
  99.                 name = key;
  100.                 break;
  101.             }
  102.         }
  103.         return name;
  104.     }
  106.     public void initName2IdMap(){
  107.         map = new HashMap<String, Integer>();
  108.         Dao dao = new Dao();
  109.         int i = 1001;
  110.         List<Object[]> unitName = dao.queryBySql("select c_name from t_agency where c_type='3' or c_type='4'");
  111.         for(Object[] o : unitName){
  112.             map.put(o[0].toString(), i);
  113.             i++;
  114.         }
  115.     }
  117.     public void run() throws Exception{
  118.         List<Object[]> dataList = CsvTool.readCsv(ASSOCIATION_SOURCE);
  119.         List<String[]> data = new ArrayList<String[]>();
  120.         for(int i=1; i<dataList.size(); i++){
  121.             Object[] o = dataList.get(i);
  122.             data.add(new String[]{map.get(o[0]).toString(), map.get(o[1]).toString(), o[2].toString()});
  123.         }
  124.         CsvTool.writeCsv(RECOMMENDATION_SOURCE, null, data);
  125.         evaluateScore();
  126.         evaluateRate();
  127.         List<RecommendedItem> recommendedList = work(new Long(map.get(userName)));
  128.         for (RecommendedItem item : recommendedList) {
  129.             System.out.printf("(%s,%f)", getNameById(Integer.parseInt(String.valueOf(item.getItemID()))), item.getValue());
  130.         }
  131.     }
  132. }
  1. package tool;
  3. import java.io.IOException;
  4. import java.nio.charset.Charset;
  5. import java.util.ArrayList;
  6. import java.util.List;
  8. import com.csvreader.CsvReader;
  9. import com.csvreader.CsvWriter;
  11. /**
  12.  * CSV工具包
  13.  * @author suwb
  14.  */
  15. public class CsvTool {
  17.     /**
  18.      * 写CSV文件
  19.      * @param outFilePath   数据文件路径
  20.      * @param header        内容第一行标题
  21.      * @param dataList      内容
  22.      */
  23.     public static void writeCsv(String outFilePath, String[] header, List<String[]> dataList) {
  25.         CsvWriter writer = null;  
  26.         try {
  27.             writer = new CsvWriter(outFilePath, ',', Charset.forName("UTF-8"));
  28.             //写文件头
  29.             if(header != null){
  30.                 writer.writeRecord(header);
  31.             }
  32.             //写文件内容
  33.             for (String[] datas : dataList) {
  34.                 writer.writeRecord(datas);
  35.             }
  36.         } catch (IOException e) {  
  37.             e.printStackTrace();  
  38.         } finally {  
  39.             writer.close();  
  40.         }  
  41.     }
  43.     /** 
  44.      * 读CSV文件
  45.      * @param csvFilePath 
  46.      * @throws Exception 
  47.      */  
  48.     public static List<Object[]> readCsv(String csvFilePath) throws Exception {  
  49.         // 返回结果
  50.         List<Object[]> datas = new ArrayList<Object[]>();  
  51.         CsvReader reader = new CsvReader(csvFilePath, ',', Charset.forName("UTF-8"));
  52.         //读文件内容
  53.         while (reader.readRecord()) {  
  54.             datas.add(reader.getValues());  
  55.         }  
  56.         return datas;
  57.     }  
  58. }

代码解释

推荐由以下几个组件组成：
1、数据模型，由DataModel实现；
2、用户间的相似性度量 ，由UserSimilarity实现；
3、用户邻域的定义，由UserNeighborhood实现；
4、推荐引擎，由一个Recommender实现。
做好这几部就能得到基本的推荐结果，剩下的就是调优了。
我这里有个问题在于，针对当下的推荐需求，我拿不到评分的数据，所以我的推荐程序的输入数据来源于先进行了一次关联分析得到的结果，以高校间的关联度作为高校的评分。

最后

几个典型的推荐结果如下：

  1. 对武汉大学的推荐：
  2. (武汉大学,24.060883)(西北师范大学,10.000000)(黑龙江大学,6.448706)(西安交通大学,5.522729)(兰州交通大学,5.000000)
  4. 对华中科技大学的推荐：
  5. (华中科技大学,27.968401)(新疆大学,16.533577)(新疆医科大学,12.936143)(海南大学,7.918249)(西安交通大学,6.500000)
  7. 对清华大学的推荐：
  8. (清华大学,10.495702)(中南财经政法大学,7.616104)(哈尔滨师范大学,5.000000)(华东政法大学,4.476559)(浙江工商大学,3.679918)
  10. 对北京大学的推荐：
  11. (新疆师范大学,7.000000)(南京师范大学,7.000000)(西安交通大学,5.500000)(聊城大学,5.468179)(西华师范大学,4.000000)
  13. 对电子科技大学的推荐：
  14. (广东工业大学,19.635860)(浙江大学,15.270090)(南京理工大学,15.048809)(广东财经大学,13.014910)(湖南商学院,10.524227)

解释一下为什么推荐结果集中会出现自己。原因在于我的输入数据中，user1、user2是对等的，就像我在需求分析里举的典型的输入数据，两所高校间的关联数据会出现两次，也就是说对于一所高校来说，它既是user，也是item。所以对一个user推荐一个item的时候，是可能推荐到自己的。而这里结果多次出现了自己，也正证实了推荐算法的有效性。算法是在一大堆的数据中发现item中的"华中科技大学"特别适合user中的"华中科技大学"的。

添加新批注
在作者公开此批注前，只有你和作者可见。
回复批注