ALS 推荐系统

1：ALS(alternating least squares ):交替最小二乘法

在机器学习中，特指使用最小二乘法的一种协同推荐算法。如下图所示，u表示用户，v表示商品，用户给商品打分，但是并不是每一个用户都会给每一种商品打分。? 表示用户没有打分的情况，所以这个矩阵A很多元素都是空的，我们称其为“缺失值（missing value）”。协同过滤提出了一种支持不完整评分矩阵的矩阵分解方法,不用对评分矩阵进行估值填充。

和协同过滤不一样的是，ALS认为用户的评分矩阵是有用户特征矩阵和物品特征矩阵相乘得到的。

ALS 的核心假设是：打分矩阵A是近似低秩的，即一个m∗n的打分矩阵 A 可以用两个小矩阵U(m∗k)和V(n∗k)的乘积来近似：其中k<<m,n。

A_m×n=U_m×k×V_k×n

_{我们把打分理解成相似度，那么“打分矩阵A(m∗n)”就可以由“用户喜好特征矩阵U(m∗k)”和“产品特征矩阵V(n∗k)”的乘积。}

• 给定隐含特征的数量，用随机数初始化用户-特征矩阵和商品-特征矩阵
• 用梯度下降法交替的优化这两个矩阵，用商品矩阵的各维度作为用户矩阵的梯度下降的方向，反之亦然
• 优化结束后，计算用户特征向量和商品特征向量的相似度（内积、余弦……），这就是用户对商品的偏好打分

2.Spark Mllib

 Spark使用的是交叉最小二乘法（ALS）来最优化损失函数。算法的思想就是：我们先随机生成然后固定它求解，再固定求解，这样交替进行下去，直到取得最优解min(C)。因为每步迭代都会降低误差，并且误差是有下界的，所以 ALS 一定会收敛。但由于问题是非凸的，ALS 并不保证会收敛到全局最优解。但在实际应用中，ALS 对初始点不是很敏感，是否全局最优解造成的影响并不大。（也可能是一个局部最优解）

3. MLlib的ALS实现

ALS伴生对象是建立ALS模型的入口，其主要定义训练线性回归模型的train方法，train方法通过设置训练参数进行模型训练，其参数主要包括：

• ratings-----评分RDD格式（userID，productID，rating）对；
• rank------特征数量
• iterations------迭代次数
• lambda------正则因子（推荐值为0.01）
• blocks-----数据分隔
• seed------随机种子

4. 优化步骤

1. 一个用户特征和一个商品特征相乘，得到用户对商品的偏好（单元格）
2. 已知偏好的单元格，乘的结果要和已知的值尽量接近（MSE，总的方差最小）
3. 用梯度下降法交替的优化用户特征和商品特征（ALS）

5. 梯度下降

1. n个隐含特征=在n维空间里优化用户、商品特征
2. 找一个下降最快的方向（拉格朗日乘数法、随机……）
3. 朝着这个方向走一小步
4. 回到1，直到总的偏差不再下降

实现coding

package hhc.mllib.label.learn.recommend;

import hhc.mllib.label.learn.config.AppConfig;
import hhc.mllib.label.learn.ml.CreaterBase;
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.api.java.function.Function;
import org.apache.spark.mllib.evaluation.RegressionMetrics;
import org.apache.spark.mllib.recommendation.ALS;
import org.apache.spark.mllib.recommendation.MatrixFactorizationModel;
import org.apache.spark.mllib.recommendation.Rating;
import org.apache.spark.rdd.RDD;
import scala.Tuple2;

import java.util.Arrays;
import java.util.List;

/**
 * Created by huhuichao on 2017/12/7.
 */
public class ALSModelCreater extends CreaterBase{



    private MatrixFactorizationModel model;

    private transient JavaSparkContext jsc;


    public ALSModelCreater(JavaSparkContext jsc) {
        this.jsc = jsc;
    }

    /**
     * 读取样本数据
     * @param path
     * @return
     */
    public static JavaRDD<Rating> getALSJavaRDD(String path, JavaSparkContext sc,String split) {
        JavaRDD<String> data=sc.textFile(path);
        JavaRDD<Rating> ratings = data.map(
                new Function<String, Rating>() {
                    public Rating call(String s) {
                        String[] sarray = s.split(split);
                        return new Rating(Integer.parseInt(sarray[0]), Integer.parseInt(sarray[1]),
                                Double.parseDouble(sarray[2]));
                    }
                }
        );
        return ratings;
    }


    public  MatrixFactorizationModel training (JavaRDD<Rating> ratings,int rank, int numIterations, double v){
        return  ALS.train(ratings.rdd(), rank, numIterations, v);
    }

    /**
     *
     * 计算方差
     * @param ratings  样本数据
     *  @param model  model
     * @return
     */
    public static double evaluateMSE(JavaRDD<Rating> ratings,MatrixFactorizationModel model) {

        JavaRDD<Tuple2<Object, Object>>   userProducts = ratings.map(
                    new Function<Rating, Tuple2<Object, Object>>() {
                        private static final long serialVersionUID = 1L;
                        @Override
                        public Tuple2<Object, Object> call(Rating r) {
                            return new Tuple2<Object, Object>(r.user(), r.product());
                        }
                    }
            );
        JavaPairRDD<Tuple2<Integer, Integer>, Object> predictions = JavaPairRDD.fromJavaRDD(
                model.predict( JavaRDD.toRDD(userProducts)).toJavaRDD().map(
                        new Function<Rating, Tuple2<Tuple2<Integer, Integer>, Object>>() {
                            private static final long serialVersionUID = 1L;
                            @Override
                            public Tuple2<Tuple2<Integer, Integer>, Object> call(Rating r) {
                                return new Tuple2<Tuple2<Integer, Integer>, Object>(
                                        new Tuple2<>(r.user(), r.product()), r.rating());
                            }
                        }
                ));
        JavaRDD<Tuple2<Object, Object>> ratesAndPreds =
                JavaPairRDD.fromJavaRDD(ratings.map(
                        new Function<Rating, Tuple2<Tuple2<Integer, Integer>, Object>>() {
                            private static final long serialVersionUID = 1L;
                            @Override
                            public Tuple2<Tuple2<Integer, Integer>, Object> call(Rating r) {
                                return new Tuple2<Tuple2<Integer, Integer>, Object>(
                                        new Tuple2<>(r.user(), r.product()), r.rating());
                            }
                        }
                )).join(predictions).values();

        // Create regression metrics object
        RegressionMetrics regressionMetrics = new RegressionMetrics(ratesAndPreds.rdd());
        return regressionMetrics.meanSquaredError();
    }


    /**
     * 获取矩阵分解后的物品特征矩阵
     * @param model
     * @return
     */
    public static JavaPairRDD<Object, double[]>  getProductPeatures(MatrixFactorizationModel model){
        return JavaPairRDD.fromJavaRDD(model.productFeatures().toJavaRDD());
    }


    /**
     * recommendProductsForUsers  对所有用户推荐物品，取前n个物品
     * @param num
     * @param model
     * @return
     */
    public static JavaPairRDD<Object, Rating[]> recommendProductsForUsers(int num,MatrixFactorizationModel model) {

        RDD<Tuple2<Object, Rating[]>> tuple2RDD = model.recommendProductsForUsers(num);
        JavaRDD<Tuple2<Object, Rating[]>> tuple2JavaRDD = tuple2RDD.toJavaRDD();
        JavaPairRDD<Object, Rating[]> productFeatures=JavaPairRDD.fromJavaRDD(tuple2JavaRDD);
        return productFeatures;
    }
    public static void main(String[] args) {
//        ALSModelCreater alsModel=new ALSModelCreater(AppConfig.getInstance().sc);
//        //读取样本数据
//        JavaRDD<Rating> ratings= getALSJavaRDD("data/ml/recommend/als/test.data", alsModel.jsc,",");
////        List<Rating> list=ratings.collect();
//        //建立模型
//        int rank=10;
//        int numIterations=5;
//        MatrixFactorizationModel model = ALS.train(ratings.rdd(), rank, numIterations, 0.01);
//
//        System.out.println("Mean Squared Error = " + evaluateMSE(ratings,model));
//        model.save(alsModel.jsc.sc(),"data/ml/recommend/als/model");
        MatrixFactorizationModel model=MatrixFactorizationModel.load(AppConfig.getInstance().sc.sc(),"data/ml/recommend/als/model");
        System.out.println(Arrays.toString(model.recommendProducts(4,2)));

        JavaPairRDD<Object, double[]> productFeatures = getProductPeatures(model);
        List<Tuple2<Object, double[]>> list=productFeatures.collect();
        System.out.println(list);

        JavaPairRDD<Object, Rating[]> features=recommendProductsForUsers(2,model);
        List<Tuple2<Object, Rating[]>> list1=features.collect();
        System.out.println(list1);
    }


}