机器学习 hadoop-Mahout

协同过滤

测试数据

用户ID,物品ID,评分
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

可参考 http://dblab.xmu.edu.cn/blog/1175/ 

导入依赖

<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>
            <scope>compile</scope>
            <exclusions>
                <exclusion>
                    <artifactId>jetty</artifactId>
                    <groupId>org.mortbay.jetty</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>cassandra-all</artifactId>
                    <groupId>org.apache.cassandra</groupId>
                </exclusion>
                <exclusion>
                    <artifactId>hector-core</artifactId>
                    <groupId>me.prettyprint</groupId>
                </exclusion>
            </exclusions>
        </dependency>

根据相似用户进行推荐

package mahout;

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.impl.neighborhood.NearestNUserNeighborhood;
import org.apache.mahout.cf.taste.impl.recommender.GenericUserBasedRecommender;
import org.apache.mahout.cf.taste.impl.similarity.UncenteredCosineSimilarity;
import org.apache.mahout.cf.taste.recommender.RecommendedItem;
import org.apache.mahout.cf.taste.recommender.Recommender;

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

/**
 * 基本的过程(步骤)
 * 1.分析各个用户(user)对物品(item的评分)
 * 2.根据用户对物品的评分,计算所有用户之间的相似度(余弦相似度,欧式距离等待)
 * 3.选出与当前用户最相似的N个用户
 * 4.将当前用户购买过的商品,推荐给其他用户
 */
public class UserBaseCF {
    public static void main(String[] args) throws Exception {
        //根据数据源建立数据模型,就是打分矩阵模型
        String filePath = args[0];
        FileDataModel model = new FileDataModel(new File(filePath));

        //根据打分矩阵模型,计算用户的相似度,(余弦相似度,欧式距离)
        UncenteredCosineSimilarity similarity = new UncenteredCosineSimilarity(model);

        //找到与用户相邻的用户,,即最相似的用户
        //N:找到相似的N个用户
        NearestNUserNeighborhood nearesthbood = new NearestNUserNeighborhood(2, similarity, model);

        //构建基于用户的推荐引擎
        Recommender r = new GenericUserBasedRecommender(model, nearesthbood,similarity);

        //给指定的用户推荐商品
        System.out.println("--------------------给一个用户推荐商品---------------------");

        long userID =3 ;
        List<RecommendedItem> list = r.recommend(userID, 2);
        for (RecommendedItem item: list) {
            System.out.println("给用户：" + userID + "推荐的商品是：" + item.getItemID() + "，推荐的理由是：" + item.getValue());
        }
        System.out.println("******************************给每个用户推荐商品******************************");
        //得到所有用户的id
        LongPrimitiveIterator iters =model.getUserIDs();
        while (iters.hasNext()){
            userID = iters.nextLong();
            List<RecommendedItem> list2 = r.recommend(userID, 2);
            System.out.println("用户ID :"+userID);
            for (RecommendedItem item:list2) {
                System.out.println("给用户：" + userID + "推荐的商品是：" + item.getItemID() + "，推荐的理由是：" + item.getValue());
            }
            System.out.println("-------------------------------------------------------------");
        }
    }
}

根据物品智能推荐

package mahout;

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.impl.recommender.GenericItemBasedRecommender;
import org.apache.mahout.cf.taste.impl.similarity.EuclideanDistanceSimilarity;
import org.apache.mahout.cf.taste.recommender.RecommendedItem;

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

/**
 * 基本的步骤
 * 1:分析各个用户对物品的评分
 * 2.计算出所有物品之间的相似度(余弦相似度,欧式距离)
 * 3.找到与当前用户购买的物品,相似度比较高的其他物品
 * 4.把这些物品推荐给当前用户
 */
public class ItemBaseCF {
    public static void main(String[] args) throws Exception {
        //根据数据源建立数据模型,就是打分矩阵模型
        String filePath =args[0];
        FileDataModel model = new FileDataModel(new File(filePath));

        //计算物品的相似度矩阵(欧式距离)
        EuclideanDistanceSimilarity itemSimilarity = new EuclideanDistanceSimilarity(model);

        //建立基于物品的推荐引擎
        GenericItemBasedRecommender r = new GenericItemBasedRecommender(model, itemSimilarity);

        //推荐物品,为每个用户推荐商品,最多每个用户推荐3个商品
        LongPrimitiveIterator iterator = model.getUserIDs();

        while (iterator.hasNext()){
            //取出一个用户id
            Long userid = iterator.next();

            //为该用户进行物品的推荐
            List<RecommendedItem> list = r.recommend(userid, 3);

            //输出
            System.out.println("用户ID: "+userid);
            for (RecommendedItem item: list) {
                System.out.println("物品的ID:"+item.getItemID()+",评分: "+item.getValue());

            }
            System.out.println("------------------------------------------------");
        }
    }
}