Mahout使用(一)

1.HelloMahout.java
2.DistanceTest.java
3.MahoutDemo.java

1.HelloMahout.java

 package cn.crxy.mahout;

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

 import org.apache.log4j.Logger;
 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.recommender.GenericUserBasedRecommender;
 import org.apache.mahout.cf.taste.impl.similarity.PearsonCorrelationSimilarity;
 import org.apache.mahout.cf.taste.model.DataModel;
 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.UserSimilarity;

 public class HelloMahout {

     public static void main(String[] args) {

         Logger logger=Logger.getLogger(HelloMahout.class);
         try {
             //读取用户评分数据    封装成一个model
             DataModel model = new FileDataModel(new File("F:\\360Downloads\\超人学院\\第14期视频\\2016-09-12【mahout】\\样本数据\\info.csv"));
             // 根据相似度找出对应的好朋友的标准     物以类聚,人以群分
             UserSimilarity userSimilarity = new PearsonCorrelationSimilarity(model);
             // 邻域 选择两个好朋友帮我推荐
             UserNeighborhood userNeighborhood = new NearestNUserNeighborhood(2,userSimilarity, model);
             // 构建推荐引擎
             Recommender recommender = new GenericUserBasedRecommender(model,userNeighborhood, userSimilarity);
             // 进行推荐
             List<RecommendedItem> recommend = recommender.recommend(1, 5);
             for (RecommendedItem item : recommend) {
                 logger.info(item);
             }
         } catch (Exception e) {
             logger.error(e.getMessage());
         }
     }
 }

2.DistanceTest.java

 package cn.crxy.mahout;

 import org.junit.Before;
 import org.junit.Test;

 public class DistanceTest {

     //    水果维度依次为：苹果、梨、桃子、栗子、香蕉、橘子
     //    小明：5,4,2,1,5,5
     //    小丽：5,3,1,2,1,1
     //    小王：5,3,4,1,4,3
     private int[] a;
     private int[] b;
     private int[] c;

     @Before
     public void initData(){
         a=new int[]{5,4,2,1,5,5};
         b=new int[]{5,3,1,2,1,1};
         c=new int[]{5,3,4,1,4,3};
     }

     @Test
     public void Distance(){
 //        a-b:5.916079783099616
 //        a-c:3.1622776601683795
 //        c-b:4.795831523312719

         System.out.println(String.format("a-b:%s", 1.0/(1.0+Man(a, b))));
         System.out.println(String.format("a-c:%s", 1.0/(1.0+Man(a, c))));
         System.out.println(String.format("c-b:%s", 1.0/(1.0+Man(c, b))));
 //        a-b:0.08333333333333333
 //        a-c:0.14285714285714285
 //        c-b:0.1

     }
     //欧式距离
     private double ErluD(int[] a_array,int[] b_array){
         double result=0;
         for (int i = 0; i < a_array.length; i++) {
             result+=Math.pow(a_array[i]-b_array[i],2);
         }
         return Math.sqrt(result);
     }
     //曼哈顿距离
     private double Man(int[] a_array,int[] b_array){
         double result=0;
         for (int i = 0; i < a_array.length; i++) {
             result+=Math.abs(a_array[i]-b_array[i]);
         }
         return result;
     }
     //min式距离
     private double Min(int[] a_array,int[] b_array,int p){
         double result=0;
         for (int i = 0; i < a_array.length; i++) {
             result+=Math.pow(Math.abs(a_array[i]-b_array[i]),p);
         }
         return Math.pow(result,1.0/p);
     }

 }

3.MahoutDemo.java

 package cn.crxy.mahout;

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

 import org.apache.mahout.cf.taste.impl.common.FastByIDMap;
 import org.apache.mahout.cf.taste.impl.common.FastIDSet;
 import org.apache.mahout.cf.taste.impl.model.GenericPreference;
 import org.apache.mahout.cf.taste.impl.model.GenericUserPreferenceArray;
 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.GenericBooleanPrefItemBasedRecommender;
 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.similarity.CachingItemSimilarity;
 import org.apache.mahout.cf.taste.impl.similarity.CachingUserSimilarity;
 import org.apache.mahout.cf.taste.impl.similarity.PearsonCorrelationSimilarity;
 import org.apache.mahout.cf.taste.impl.similarity.TanimotoCoefficientSimilarity;
 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;
 import org.junit.Before;
 import org.junit.Ignore;
 import org.junit.Test;

 public class MahoutDemo {

     //组装datamodel

     // userid itemid score
     // 101 102 103 104
     // 1(5,4,2,)
     // 2(,2,4,1)
     // 3(4,3,1,)
     DataModel dataModel;

     @Before
     public void initData() throws Exception{
         //每一个用户的喜好列表 key：用户id  value：该用户的偏好列表
         FastByIDMap<PreferenceArray> data=new FastByIDMap<PreferenceArray>();
         //组装第一个用户 偏好列表
         PreferenceArray array1=new GenericUserPreferenceArray(3);
         //PreferenceArray index 指：偏好列表的index 序号。
         array1.setUserID(0, 1);
         array1.setItemID(0, 101);
         array1.setValue(0, 5);

         array1.setUserID(1, 1);
         array1.setItemID(1, 102);
         array1.setValue(1, 4);

         array1.setUserID(2, 1);
         array1.setItemID(2, 103);
         array1.setValue(2, 2);

         data.put(1, array1);

         //组装第二个喜好
         PreferenceArray array2=new GenericUserPreferenceArray(3);
         //2(,2,4,1)
         array2.set(0, new GenericPreference(2,102,2));
         array2.set(1, new GenericPreference(2,103,4));
         array2.set(2, new GenericPreference(2,104,1));
         data.put(2, array2);
         //组装第三个喜好
         PreferenceArray array3=new GenericUserPreferenceArray(3);
         //3(4,3,1,)
         array3.set(0, new GenericPreference(3,101,4));
         array3.set(1, new GenericPreference(3,102,3));
         array3.set(2, new GenericPreference(3,103,1));
         data.put(3, array3);

         //dataModel=new GenericDataModel(data);
 //        dataModel=new GenericBooleanPrefDataModel(userData);
 //        System.out.println(dataModel.getPreferenceValue(1, 102));//获得1用户对102的评分
 //        System.out.println(dataModel.getItemIDsFromUser(1));
 //        System.out.println(dataModel.getUserIDs());

         //1  101 102 103
         //2 102 103
         // key为userid value:物品的集合 set
         FastByIDMap<FastIDSet> userData=new FastByIDMap<FastIDSet>();

         FastIDSet userSet1=new FastIDSet(3);
         userSet1.add(101);
         userSet1.add(102);
         userSet1.add(103);
         userData.put(1,userSet1);

         FastIDSet userSet2=new FastIDSet(2);
         userSet2.add(102);
         userSet2.add(103);
         userData.put(2,userSet2);

         //无偏好的构建
 //        dataModel=new GenericBooleanPrefDataModel(userData);

         //读取文件 有偏好的
         dataModel=new FileDataModel(new File("F:\\360Downloads\\超人学院\\第14期视频\\2016-09-12【mahout】\\样本数据\\info.csv"));
         //读取文件 无偏好的 无偏好的数据只有用户和其关联的商品 没有对应商品的评分
 //        dataModel=new FileDataModel(new File("F:\\360Downloads\\超人学院\\第14期视频\\2016-09-12【mahout】\\样本数据\\ubool.data"));

 //        对于无偏好数据：getvalue：如果存在记录则是1.0；否则为null。
 //        System.out.println(dataModel.getPreferenceValue(1, 103));
 //        System.out.println(dataModel.getItemIDsFromUser(1));
 //        System.out.println(dataModel.getUserIDs());

     }
     @Ignore
     public void testUserSimi() throws Exception{

         //利用model和相似度函数 计算用户相似度
 //        UserSimilarity userSimilarity=new TanimotoCoefficientSimilarity(dataModel);
         UserSimilarity userSimilarity=new PearsonCorrelationSimilarity(dataModel);
         userSimilarity=new CachingUserSimilarity(userSimilarity, dataModel);
         //查询用户之间的相似度  0.9999999999999998    0.944911182523068
         //如果使用CachingUserSimilarity userSimilarity(1,5) 第二次不会再次计算了
         System.out.println(userSimilarity.userSimilarity(1, 5));
         System.out.println(userSimilarity.userSimilarity(1, 5));
     }
     @Ignore
     public void testItemSimi() throws Exception{

         //利用model和相似度函数 计算物品相似度
         ItemSimilarity itemSimilarity=new PearsonCorrelationSimilarity(dataModel);
         itemSimilarity =new CachingItemSimilarity(itemSimilarity,dataModel);
         //查询物品之间的相似度 0.9449111825230729
         System.out.println(itemSimilarity.itemSimilarity(101, 102));
     }
     @Test
     public void testuserNeighborhood() throws Exception{
         //相似度   有相似度才能算邻居是谁
         UserSimilarity userSimilarity=new PearsonCorrelationSimilarity(dataModel);
         //1.固定数目的邻居  如果取邻居 只取前三个
         UserNeighborhood userNeighborhood=new NearestNUserNeighborhood(3,userSimilarity,dataModel);
         long[] userNeighborhoods = userNeighborhood.getUserNeighborhood(1);//为1用户取得用户
         for (long l : userNeighborhoods) {
             System.out.println(l+"NearestNUserNeighborhoodsimi---"+userSimilarity.userSimilarity(1, l));
         }
 //        4NearestNUserNeighborhoodsimi---0.9999999999999998
 //        5NearestNUserNeighborhoodsimi---0.944911182523068
 //        2NearestNUserNeighborhoodsimi---   -0.7642652566278799这个是负0.7

         //2.固定阈值的邻居  只要0.8以上的
         userNeighborhood=new ThresholdUserNeighborhood(0.7,userSimilarity,dataModel);
         long[] userNeighborhoodsnew = userNeighborhood.getUserNeighborhood(1);
         System.out.println(userSimilarity.userSimilarity(1, 2)); //查看1和2的相似度
         for (long l : userNeighborhoodsnew) {
             System.out.println(l+"ThresholdUserNeighborhoodsimi---"+userSimilarity.userSimilarity(1, l));
         }

     }
     @Test
     public void testItemCmd() throws Exception{
         //1.基于物品的有偏好的推荐   基于物品的不需要邻居
 //        ItemSimilarity itemSimilarity=new PearsonCorrelationSimilarity(dataModel);
 //        Recommender recommender=new GenericItemBasedRecommender(dataModel,itemSimilarity);

         //2.基于物品的无偏好推荐
         ItemSimilarity itemSimilarity=new TanimotoCoefficientSimilarity(dataModel);
         Recommender recommender=new GenericBooleanPrefItemBasedRecommender(dataModel,itemSimilarity);

         List<RecommendedItem> recommend = recommender.recommend(1, 3);//给用户1推荐3个.
         for (RecommendedItem recommendedItem : recommend) {
             System.out.println(recommendedItem);
             //1.基于物品的有偏好的推荐RecommendedItem[item:104, value:5.0]其他的推荐不出来了....所以只推荐出了1个

             //2.基于物品的无偏好的推荐
             //RecommendedItem[item:104, value:1.8]
             //RecommendedItem[item:106, value:1.15]
             //RecommendedItem[item:105, value:0.85]
         }
     }
     @Test
     public void testUserCmd() throws Exception{
         //1.基于用户的有偏好的推荐
         //UserSimilarity userSimilarity=new PearsonCorrelationSimilarity(dataModel);
         //2.基于用户的无偏好的推荐
         UserSimilarity userSimilarity=new TanimotoCoefficientSimilarity(dataModel);

         UserNeighborhood userNeighborhood=new NearestNUserNeighborhood(3,userSimilarity,dataModel);//Top 3
         //构建推荐对象
         Recommender recommender=new GenericUserBasedRecommender(dataModel,userNeighborhood,userSimilarity);
         List<RecommendedItem> recommend = recommender.recommend(1, 3);
         for (RecommendedItem recommendedItem : recommend) {
             System.out.println(recommendedItem);
             //1.基于用户的有偏好推荐
             //RecommendedItem[item:104, value:5.0]
             //RecommendedItem[item:106, value:4.0]
             //2.基于用户的无偏好推荐
             //RecommendedItem[item:106, value:4.0]
             //RecommendedItem[item:104, value:3.2121212]

         }
     }

 }