org.apache.spark.mllib.recommendation

Class ALS

Object

org.apache.spark.mllib.recommendation.ALS

All Implemented Interfaces:

java.io.Serializable, Logging

public class ALS
extends Object
implements scala.Serializable, Logging

Alternating Least Squares matrix factorization.

ALS attempts to estimate the ratings matrix R as the product of two lower-rank matrices, X and Y, i.e. X * Yt = R. Typically these approximations are called 'factor' matrices. The general approach is iterative. During each iteration, one of the factor matrices is held constant, while the other is solved for using least squares. The newly-solved factor matrix is then held constant while solving for the other factor matrix.

This is a blocked implementation of the ALS factorization algorithm that groups the two sets of factors (referred to as "users" and "products") into blocks and reduces communication by only sending one copy of each user vector to each product block on each iteration, and only for the product blocks that need that user's feature vector. This is achieved by precomputing some information about the ratings matrix to determine the "out-links" of each user (which blocks of products it will contribute to) and "in-link" information for each product (which of the feature vectors it receives from each user block it will depend on). This allows us to send only an array of feature vectors between each user block and product block, and have the product block find the users' ratings and update the products based on these messages.

For implicit preference data, the algorithm used is based on "Collaborative Filtering for Implicit Feedback Datasets", available at http://dx.doi.org/10.1109/ICDM.2008.22, adapted for the blocked approach used here.

Essentially instead of finding the low-rank approximations to the rating matrix R, this finds the approximations for a preference matrix P where the elements of P are 1 if r > 0 and 0 if r <= 0. The ratings then act as 'confidence' values related to strength of indicated user preferences rather than explicit ratings given to items.

See Also:

Serialized Form

Constructor Summary

Constructors

Constructor and Description
ALS() Constructs an ALS instance with default parameters: {numBlocks: -1, rank: 10, iterations: 10, lambda: 0.01, implicitPrefs: false, alpha: 1.0}.

Method Summary

Methods

Modifier and Type	Method and Description
MatrixFactorizationModel	run(JavaRDD<Rating> ratings) Java-friendly version of ALS.run.
MatrixFactorizationModel	run(RDD<Rating> ratings) Run ALS with the configured parameters on an input RDD of (user, product, rating) triples.
ALS	setAlpha(double alpha) Sets the constant used in computing confidence in implicit ALS.
ALS	setBlocks(int numBlocks) Set the number of blocks for both user blocks and product blocks to parallelize the computation into; pass -1 for an auto-configured number of blocks.
ALS	setCheckpointInterval(int checkpointInterval) Set period (in iterations) between checkpoints (default = 10).
ALS	setFinalRDDStorageLevel(StorageLevel storageLevel) :: DeveloperApi :: Sets storage level for final RDDs (user/product used in MatrixFactorizationModel).
ALS	setImplicitPrefs(boolean implicitPrefs) Sets whether to use implicit preference.
ALS	setIntermediateRDDStorageLevel(StorageLevel storageLevel) :: DeveloperApi :: Sets storage level for intermediate RDDs (user/product in/out links).
ALS	setIterations(int iterations) Set the number of iterations to run.
ALS	setLambda(double lambda) Set the regularization parameter, lambda.
ALS	setNonnegative(boolean b) Set whether the least-squares problems solved at each iteration should have nonnegativity constraints.
ALS	setProductBlocks(int numProductBlocks) Set the number of product blocks to parallelize the computation.
ALS	setRank(int rank) Set the rank of the feature matrices computed (number of features).
ALS	setSeed(long seed) Sets a random seed to have deterministic results.
ALS	setUserBlocks(int numUserBlocks) Set the number of user blocks to parallelize the computation.
static MatrixFactorizationModel	train(RDD<Rating> ratings, int rank, int iterations) Train a matrix factorization model given an RDD of ratings given by users to some products, in the form of (userID, productID, rating) pairs.
static MatrixFactorizationModel	train(RDD<Rating> ratings, int rank, int iterations, double lambda) Train a matrix factorization model given an RDD of ratings given by users to some products, in the form of (userID, productID, rating) pairs.
static MatrixFactorizationModel	train(RDD<Rating> ratings, int rank, int iterations, double lambda, int blocks) Train a matrix factorization model given an RDD of ratings given by users to some products, in the form of (userID, productID, rating) pairs.
static MatrixFactorizationModel	train(RDD<Rating> ratings, int rank, int iterations, double lambda, int blocks, long seed) Train a matrix factorization model given an RDD of ratings given by users to some products, in the form of (userID, productID, rating) pairs.
static MatrixFactorizationModel	trainImplicit(RDD<Rating> ratings, int rank, int iterations) Train a matrix factorization model given an RDD of 'implicit preferences' ratings given by users to some products, in the form of (userID, productID, rating) pairs.
static MatrixFactorizationModel	trainImplicit(RDD<Rating> ratings, int rank, int iterations, double lambda, double alpha) Train a matrix factorization model given an RDD of 'implicit preferences' given by users to some products, in the form of (userID, productID, preference) pairs.
static MatrixFactorizationModel	trainImplicit(RDD<Rating> ratings, int rank, int iterations, double lambda, int blocks, double alpha) Train a matrix factorization model given an RDD of 'implicit preferences' given by users to some products, in the form of (userID, productID, preference) pairs.
static MatrixFactorizationModel	trainImplicit(RDD<Rating> ratings, int rank, int iterations, double lambda, int blocks, double alpha, long seed) Train a matrix factorization model given an RDD of 'implicit preferences' given by users to some products, in the form of (userID, productID, preference) pairs.

Methods inherited from class Object

equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.apache.spark.Logging

initializeIfNecessary, initializeLogging, isTraceEnabled, log_, log, logDebug, logDebug, logError, logError, logInfo, logInfo, logName, logTrace, logTrace, logWarning, logWarning

Constructor Detail

ALS

public ALS()

Constructs an ALS instance with default parameters: {numBlocks: -1, rank: 10, iterations: 10, lambda: 0.01, implicitPrefs: false, alpha: 1.0}.

Method Detail

train

public static MatrixFactorizationModel train(RDD<Rating> ratings,
                             int rank,
                             int iterations,
                             double lambda,
                             int blocks,
                             long seed)

Train a matrix factorization model given an RDD of ratings given by users to some products, in the form of (userID, productID, rating) pairs. We approximate the ratings matrix as the product of two lower-rank matrices of a given rank (number of features). To solve for these features, we run a given number of iterations of ALS. This is done using a level of parallelism given by blocks.

Parameters:

ratings - RDD of (userID, productID, rating) pairs

rank - number of features to use

iterations - number of iterations of ALS (recommended: 10-20)

lambda - regularization factor (recommended: 0.01)

blocks - level of parallelism to split computation into

seed - random seed

train

public static MatrixFactorizationModel train(RDD<Rating> ratings,
                             int rank,
                             int iterations,
                             double lambda,
                             int blocks)

Train a matrix factorization model given an RDD of ratings given by users to some products, in the form of (userID, productID, rating) pairs. We approximate the ratings matrix as the product of two lower-rank matrices of a given rank (number of features). To solve for these features, we run a given number of iterations of ALS. This is done using a level of parallelism given by blocks.

Parameters:

ratings - RDD of (userID, productID, rating) pairs

rank - number of features to use

iterations - number of iterations of ALS (recommended: 10-20)

lambda - regularization factor (recommended: 0.01)

blocks - level of parallelism to split computation into

train

public static MatrixFactorizationModel train(RDD<Rating> ratings,
                             int rank,
                             int iterations,
                             double lambda)

Train a matrix factorization model given an RDD of ratings given by users to some products, in the form of (userID, productID, rating) pairs. We approximate the ratings matrix as the product of two lower-rank matrices of a given rank (number of features). To solve for these features, we run a given number of iterations of ALS. The level of parallelism is determined automatically based on the number of partitions in ratings.

Parameters:

ratings - RDD of (userID, productID, rating) pairs

rank - number of features to use

iterations - number of iterations of ALS (recommended: 10-20)

lambda - regularization factor (recommended: 0.01)

train

public static MatrixFactorizationModel train(RDD<Rating> ratings,
                             int rank,
                             int iterations)

Train a matrix factorization model given an RDD of ratings given by users to some products, in the form of (userID, productID, rating) pairs. We approximate the ratings matrix as the product of two lower-rank matrices of a given rank (number of features). To solve for these features, we run a given number of iterations of ALS. The level of parallelism is determined automatically based on the number of partitions in ratings.

Parameters:

ratings - RDD of (userID, productID, rating) pairs

rank - number of features to use

iterations - number of iterations of ALS (recommended: 10-20)

trainImplicit

public static MatrixFactorizationModel trainImplicit(RDD<Rating> ratings,
                                     int rank,
                                     int iterations,
                                     double lambda,
                                     int blocks,
                                     double alpha,
                                     long seed)

Train a matrix factorization model given an RDD of 'implicit preferences' given by users to some products, in the form of (userID, productID, preference) pairs. We approximate the ratings matrix as the product of two lower-rank matrices of a given rank (number of features). To solve for these features, we run a given number of iterations of ALS. This is done using a level of parallelism given by blocks.

Parameters:

ratings - RDD of (userID, productID, rating) pairs

rank - number of features to use

iterations - number of iterations of ALS (recommended: 10-20)

lambda - regularization factor (recommended: 0.01)

blocks - level of parallelism to split computation into

alpha - confidence parameter

seed - random seed

trainImplicit

public static MatrixFactorizationModel trainImplicit(RDD<Rating> ratings,
                                     int rank,
                                     int iterations,
                                     double lambda,
                                     int blocks,
                                     double alpha)

Train a matrix factorization model given an RDD of 'implicit preferences' given by users to some products, in the form of (userID, productID, preference) pairs. We approximate the ratings matrix as the product of two lower-rank matrices of a given rank (number of features). To solve for these features, we run a given number of iterations of ALS. This is done using a level of parallelism given by blocks.

Parameters:

ratings - RDD of (userID, productID, rating) pairs

rank - number of features to use

iterations - number of iterations of ALS (recommended: 10-20)

lambda - regularization factor (recommended: 0.01)

blocks - level of parallelism to split computation into

alpha - confidence parameter

trainImplicit

public static MatrixFactorizationModel trainImplicit(RDD<Rating> ratings,
                                     int rank,
                                     int iterations,
                                     double lambda,
                                     double alpha)

Train a matrix factorization model given an RDD of 'implicit preferences' given by users to some products, in the form of (userID, productID, preference) pairs. We approximate the ratings matrix as the product of two lower-rank matrices of a given rank (number of features). To solve for these features, we run a given number of iterations of ALS. The level of parallelism is determined automatically based on the number of partitions in ratings.

Parameters:

ratings - RDD of (userID, productID, rating) pairs

rank - number of features to use

iterations - number of iterations of ALS (recommended: 10-20)

lambda - regularization factor (recommended: 0.01)

alpha - confidence parameter

trainImplicit

public static MatrixFactorizationModel trainImplicit(RDD<Rating> ratings,
                                     int rank,
                                     int iterations)

Train a matrix factorization model given an RDD of 'implicit preferences' ratings given by users to some products, in the form of (userID, productID, rating) pairs. We approximate the ratings matrix as the product of two lower-rank matrices of a given rank (number of features). To solve for these features, we run a given number of iterations of ALS. The level of parallelism is determined automatically based on the number of partitions in ratings. Model parameters alpha and lambda are set to reasonable default values

Parameters:

ratings - RDD of (userID, productID, rating) pairs

rank - number of features to use

iterations - number of iterations of ALS (recommended: 10-20)

setBlocks

public ALS setBlocks(int numBlocks)

Set the number of blocks for both user blocks and product blocks to parallelize the computation into; pass -1 for an auto-configured number of blocks. Default: -1.

setUserBlocks

public ALS setUserBlocks(int numUserBlocks)

Set the number of user blocks to parallelize the computation.

setProductBlocks

public ALS setProductBlocks(int numProductBlocks)

Set the number of product blocks to parallelize the computation.

setRank

public ALS setRank(int rank)

Set the rank of the feature matrices computed (number of features). Default: 10.

setIterations

public ALS setIterations(int iterations)

Set the number of iterations to run. Default: 10.

setLambda

public ALS setLambda(double lambda)

Set the regularization parameter, lambda. Default: 0.01.

setImplicitPrefs

public ALS setImplicitPrefs(boolean implicitPrefs)

Sets whether to use implicit preference. Default: false.

setAlpha

public ALS setAlpha(double alpha)

Sets the constant used in computing confidence in implicit ALS. Default: 1.0.

setSeed

public ALS setSeed(long seed)

Sets a random seed to have deterministic results.

setNonnegative

public ALS setNonnegative(boolean b)

Set whether the least-squares problems solved at each iteration should have nonnegativity constraints.

setIntermediateRDDStorageLevel

public ALS setIntermediateRDDStorageLevel(StorageLevel storageLevel)

:: DeveloperApi :: Sets storage level for intermediate RDDs (user/product in/out links). The default value is MEMORY_AND_DISK. Users can change it to a serialized storage, e.g., MEMORY_AND_DISK_SER and set spark.rdd.compress to true to reduce the space requirement, at the cost of speed.

setFinalRDDStorageLevel

public ALS setFinalRDDStorageLevel(StorageLevel storageLevel)

:: DeveloperApi :: Sets storage level for final RDDs (user/product used in MatrixFactorizationModel). The default value is MEMORY_AND_DISK. Users can change it to a serialized storage, e.g. MEMORY_AND_DISK_SER and set spark.rdd.compress to true to reduce the space requirement, at the cost of speed.

setCheckpointInterval

public ALS setCheckpointInterval(int checkpointInterval)

Set period (in iterations) between checkpoints (default = 10). Checkpointing helps with recovery (when nodes fail) and StackOverflow exceptions caused by long lineage. It also helps with eliminating temporary shuffle files on disk, which can be important when there are many ALS iterations. If the checkpoint directory is not set in SparkContext, this setting is ignored.

run

public MatrixFactorizationModel run(RDD<Rating> ratings)

Run ALS with the configured parameters on an input RDD of (user, product, rating) triples. Returns a MatrixFactorizationModel with feature vectors for each user and product.

run

public MatrixFactorizationModel run(JavaRDD<Rating> ratings)

Java-friendly version of ALS.run.