spark ML ALS实现电影推荐

17人阅读 评论(0) 收藏 举报
package zqr.com;

import org.apache.spark.SparkConf;
import org.apache.spark.api.java.JavaPairRDD;
import org.apache.spark.api.java.JavaRDD;
import org.apache.spark.api.java.JavaSparkContext;
import org.apache.spark.mllib.recommendation.ALS;
import org.apache.spark.mllib.recommendation.MatrixFactorizationModel;
import org.apache.spark.mllib.recommendation.Rating;
import scala.Tuple2;
import scala.reflect.internal.Names;

import java.util.*;

public class MovieRecommended {

    public static void main(String args[]){
        // 输入用户id
        System.out.println("输入用户id");
        Scanner scan=new Scanner(System.in);
        String number=scan.nextLine();


        SparkConf conf = new SparkConf().setAppName("movie recommended system").setMaster("local");

        JavaSparkContext sc = new JavaSparkContext(conf); // 其底层实际上就是ScalaSparkContext

        String path = "/usr/local/spark/testdata/ml-latest-small/ratings.csv";

        JavaRDD<String> rating_data = sc.textFile(path);

        // rating_data.collect().forEach(System.out::println);


        Set<String>NotViewMovie=new HashSet<String>();
        Set<String>ViewMovie=new HashSet<String>();
        JavaRDD<Rating> mapdata = rating_data.map(s -> {
            String[] sarray = s.split(",");
            Rating rt=null;

            if(sarray[0].equals("userId")) {

             rt=null;

            }else if(Double.parseDouble(sarray[2])<5&&Double.parseDouble(sarray[2])>=0&&!sarray[2].isEmpty()){
                rt=new Rating(Integer.parseInt(sarray[0]),
                        Integer.parseInt(sarray[1]),
                        Double.parseDouble(sarray[2]));
                if(!sarray[0].equals(number)){
                    NotViewMovie.add(sarray[1]);
                }else{
                   ViewMovie.add(sarray[1]);
                }
            }else{
                rt=null;
            }

            return rt;
        }).filter(k->k!=null);
//============================================================================================

        NotViewMovie.addAll(ViewMovie);
        List<String> d=new ArrayList<String>();
        for(String h:NotViewMovie){
            d.add(h);
        }
        //=====================================================================================

        //mapdata.collect().forEach(System.out::println);

        // 隐性因子个数
        int rank = 10;
        //迭代次数
        int numIterations = 10;
        //lambdaALS的正则化参数;
        MatrixFactorizationModel model = ALS.train(JavaRDD.toRDD(mapdata), rank, numIterations, 0.01);

        //System.out.println("model:"+model);

        // 评估评级数据模型
        JavaRDD data=sc.parallelize(d);
        JavaRDD<Tuple2<Object, Object>> userProducts =
                data.map(r -> new Tuple2<>(number, r));

        JavaPairRDD<Tuple2<Integer, Integer>, Double> predictions = JavaPairRDD.fromJavaRDD(
                model.predict(JavaRDD.toRDD(userProducts)).toJavaRDD()
                        .map(r -> new Tuple2<>(new Tuple2<>(r.user(), r.product()), r.rating()))
        );

        //System.out.println("打印predictions的值");
        //predictions.collect().forEach(System.out::println);
        //Map<String,Map<Double,String>> data=new HashMap<String,Map<Double,String>>();
        Map<String,Double> tow=new TreeMap<String,Double>();
        List list=predictions.collect();
        for(Object x : list){
            String string=x.toString();
            String []arr=string.split("[,()]");
            String uid=arr[2];
            String mid=arr[3];
            double pfen=Double.parseDouble(arr[5]);

            if(uid.equals(number)){
                tow.put(mid,pfen);
            }

            //data.put(uid,tow);
            //System.out.println(uid+"--->"+mid+"---->"+pfen);

        }
           //System.out.println(list);
//
//           for (Map.Entry<String, Double> entry : tow.entrySet()) {
//           System.out.println(entry.getKey() + ":" + entry.getValue());
//           }


          //转换成list进行排序
          List<Map.Entry<String, Double>> li = new ArrayList<Map.Entry<String,Double>>(tow.entrySet());
          // 排序
          Collections.sort(li, new Comparator<Map.Entry<String, Double>>() {
            //根据value排序
            public int compare(Map.Entry<String, Double> o1,
                               Map.Entry<String, Double> o2) {
                double result = o2.getValue() - o1.getValue();
                if(result > 0)
                    return 1;
                else if(result == 0)
                    return 0;
                else
                    return -1;
            }
        });
        List<String> l=new ArrayList<String>();
        int num=0;
        for (Map.Entry<String, Double> entry : li) {
            System.out.println(entry.getKey() + "      " + entry.getValue());
            l.add(entry.getKey().toString());
            num++;
            if(num==10){
                break;
            }
        }

        for(String x:l){
    System.out.println(x);
        }


        String path1 = "/usr/local/spark/testdata/ml-latest-small/movies.csv";

        JavaRDD<String> mviddata = sc.textFile(path1);

        // rating_data.collect().forEach(System.out::println);


            JavaRDD<Map<String,String>> move_pair = mviddata.map(s -> {
                String[] sarray = s.split(",");
                String x=sarray[0].toString();
                String y=sarray[1].toString();
                Map mp=new HashMap<String,String>();
                mp.put(x,y);
                return  mp;
            });


        //move_pair.collect().forEach(System.out::println);
        for(String idx:l) {
            move_pair.foreach(x -> {
             if(x.containsKey(idx)){
                 String value=x.get(idx).toString();
                 System.out.println(value);
             }

            });
        }








        //for (Map.Entry<String, Double> entry : tow.entrySet()) {
        //System.out.println(entry.getKey() + ":" + entry.getValue());
        //}

       // model.save(sc.sc(), "target/movierd/myCollaborativeFilter");
    }



}
查看评论

推荐系统实践1---基于spark ALS做的电影推荐,参考网上的做的,能跑起来

package recommendation import org.apache.log4j._ import org.apache.spark._ import org.apache.spark....
  • sinat_31726559
  • sinat_31726559
  • 2016-06-10 01:42:07
  • 1319

Spark MLlib系列(二):基于协同过滤的电影推荐系统

随着大数据时代的到来,数据当中挖取金子的工作越来越有吸引力。利用Spark在内存迭代运算、机器学习领域强悍性能的优势,使用spark处理数据挖掘问题就显得很有实际价值。这篇文章给大家分享一个spark...
  • shifenglov
  • shifenglov
  • 2015-02-13 16:36:00
  • 25526

基于ALS算法电影推荐(java版)

基于ALS算法的最佳电影推荐(java版)package spark;import java.util.Arrays; import java.util.List;import org.apache....
  • zll441488958
  • zll441488958
  • 2017-12-27 17:06:22
  • 194

深入理解Spark ML:基于ALS矩阵分解的协同过滤算法与源码分析

http://blog.csdn.net/u011239443/article/details/51752904 1. 引言 随着互联网的迅猛发展,为了满足人们在繁多的信息中获取自己需要内容的...
  • u011239443
  • u011239443
  • 2016-06-26 13:40:00
  • 9628

构建基于Spark的推荐引擎(python实现)

这几天在看由人民邮电出版社出版的《Spark机器学习》(Machine Learning with Spark,Nick Pentreath),看的很是郁闷。这本书一会儿用python, 一会儿用sc...
  • q1w2e3r4470
  • q1w2e3r4470
  • 2015-10-18 21:28:36
  • 2150

协同过滤(ALS)算法原理及Spark MLlib调用实例(Scala/Java/Python)

协同过滤 算法介绍:     协同过滤常被用于推荐系统。这类技术目标在于填充“用户-商品”联系矩阵中的缺失项。Spark.ml目前支持基于模型的协同过滤,其中用户和商品以少量的潜在因子来描述,用以...
  • liulingyuan6
  • liulingyuan6
  • 2016-12-06 17:03:08
  • 4772

Spark ML -1:ALS推荐算法

矩阵分解 推荐系统,最基本的一个数据就是,用户-物品的评分矩阵,如下图1所示   图1         矩阵中,描述了5个用户(U1,U2,U3,U4 ,U5)对4个物品(D1,D2...
  • ZhongGuoZhiChuang
  • ZhongGuoZhiChuang
  • 2017-04-13 10:11:36
  • 1041

SparkML之推荐算法(一)ALS

ALS(alternating least squares ):交替最小二乘法 ------------------------------------------------------------...
  • legotime
  • legotime
  • 2016-07-06 07:45:01
  • 10196

使用Spark ALS实现协同过滤

转自:http://blog.javachen.com/2015/06/01/how-to-implement-collaborative-filtering-using-spark-als.html...
  • student1218
  • student1218
  • 2015-08-12 10:22:09
  • 3593

Spark机器学习之协同过滤

协作过滤通常用于推荐系统。 这些技术旨在填补用户项目关联矩阵的缺失条目。 spark.ml目前支持基于模型的协同过滤,其中用户和产品由一小组潜在因素描述,可用于预测缺失的条目。 spark.ml使用交...
  • cheng9981
  • cheng9981
  • 2017-04-12 15:18:15
  • 524
    个人资料
    等级:
    访问量: 2080
    积分: 186
    排名: 99万+
    最新评论