added ALS

Author: brkyvz

mllib/src/main/scala/org/apache/spark/ml/recommendation/ALS.scala

@@ -49,7 +49,7 @@ import org.apache.spark.util.random.XORShiftRandom
  * Common params for ALS.
  */
 private[recommendation] trait ALSParams extends Params with HasMaxIter with HasRegParam
-  with HasPredictionCol with HasCheckpointInterval {
+  with HasPredictionCol with HasCheckpointInterval with HasSeed {
 
   /**
    * Param for rank of the matrix factorization (>= 1).
@@ -147,7 +147,7 @@ private[recommendation] trait ALSParams extends Params with HasMaxIter with HasR
 
   setDefault(rank -> 10, maxIter -> 10, regParam -> 0.1, numUserBlocks -> 10, numItemBlocks -> 10,
     implicitPrefs -> false, alpha -> 1.0, userCol -> "user", itemCol -> "item",
-    ratingCol -> "rating", nonnegative -> false, checkpointInterval -> 10)
+    ratingCol -> "rating", nonnegative -> false, checkpointInterval -> 10, seed -> 42L)
 
   /**
    * Validates and transforms the input schema.
@@ -290,15 +290,16 @@ class ALS extends Estimator[ALSModel] with ALSParams {
 
   override def fit(dataset: DataFrame): ALSModel = {
     val ratings = dataset
-      .select(col($(userCol)), col($(itemCol)), col($(ratingCol)).cast(FloatType))
+      .select(col($(userCol)).cast(IntegerType), col($(itemCol)).cast(IntegerType),
+        col($(ratingCol)).cast(FloatType))
       .map { row =>
         Rating(row.getInt(0), row.getInt(1), row.getFloat(2))
       }
     val (userFactors, itemFactors) = ALS.train(ratings, rank = $(rank),
       numUserBlocks = $(numUserBlocks), numItemBlocks = $(numItemBlocks),
       maxIter = $(maxIter), regParam = $(regParam), implicitPrefs = $(implicitPrefs),
       alpha = $(alpha), nonnegative = $(nonnegative),
-      checkpointInterval = $(checkpointInterval))
+      checkpointInterval = $(checkpointInterval), seed = $(seed))
     copyValues(new ALSModel(this, $(rank), userFactors, itemFactors))
   }
 

python/pyspark/ml/param/_shared_params_code_gen.py

@@ -97,7 +97,7 @@ def get$Name(self):
         ("inputCol", "input column name", None),
         ("inputCols", "input column names", None),
         ("outputCol", "output column name", None),
-        ("numFeatures", "number of features", None)]
+        ("checkpointInterval", "checkpoint interval (>= 1)", None)]
     code = []
     for name, doc, defaultValueStr in shared:
         code.append(_gen_param_code(name, doc, defaultValueStr))

python/pyspark/ml/param/shared.py

@@ -281,30 +281,136 @@ def getOutputCol(self):
         return self.getOrDefault(self.outputCol)
 
 
-class HasNumFeatures(Params):
+
+class HasNumItemBlocks(Params):
+    """
+    Mixin for param numItemBlocks: number of item blocks.
+    """
+
+    # a placeholder to make it appear in the generated doc
+
+
+    def __init__(self):
+        super(HasNumItemBlocks, self).__init__()
+        #: param for number of item blocks
+
+        if None is not None:
+            self._setDefault(numItemBlocks=None)
+
+
+
+class HasImplicitPrefs(Params):
+    """
+    Mixin for param implicitPrefs: whether to use implicit preference.
+    """
+
+    # a placeholder to make it appear in the generated doc
+
+
+    def __init__(self):
+        super(HasImplicitPrefs, self).__init__()
+        #: param for whether to use implicit preference
+
+        if None is not None:
+            self._setDefault(implicitPrefs=None)
+
+
+
+
+class HasAlpha(Params):
+    """
+    Mixin for param alpha: alpha for implicit preference.
+    """
+
+    # a placeholder to make it appear in the generated doc
+
+
+    def __init__(self):
+        super(HasAlpha, self).__init__()
+        #: param for alpha for implicit preference
+
+        if None is not None:
+            self._setDefault(alpha=None)
+
+
+
+
+class HasUserCol(Params):
+    """
+    Mixin for param userCol: column name for user ids.
+    """
+
+    # a placeholder to make it appear in the generated doc
+
+
+    def __init__(self):
+        super(HasUserCol, self).__init__()
+        #: param for column name for user ids
+
+        if None is not None:
+            self._setDefault(userCol=None)
+
+
+
+
+class HasItemCol(Params):
+    """
+    Mixin for param itemCol: column name for item ids.
+    """
+
+    # a placeholder to make it appear in the generated doc
+
+
+    def __init__(self):
+        super(HasItemCol, self).__init__()
+        #: param for column name for item ids
+
+        if None is not None:
+            self._setDefault(itemCol=None)
+
+
+
+
+class HasRatingCol(Params):
+    """
+    Mixin for param ratingCol: column name for ratings.
+    """
+
+    # a placeholder to make it appear in the generated doc
+
+
+    def __init__(self):
+        super(HasRatingCol, self).__init__()
+        #: param for column name for ratings
+
+        if None is not None:
+            self._setDefault(ratingCol=None)
+
+
+class HasCheckpointInterval(Params):
     """
-    Mixin for param numFeatures: number of features.
+    Mixin for param checkpointInterval: checkpoint interval (>= 1).
     """
 
     # a placeholder to make it appear in the generated doc
-    numFeatures = Param(Params._dummy(), "numFeatures", "number of features")
+    checkpointInterval = Param(Params._dummy(), "checkpointInterval", "checkpoint interval (>= 1)")
 
     def __init__(self):
-        super(HasNumFeatures, self).__init__()
-        #: param for number of features
-        self.numFeatures = Param(self, "numFeatures", "number of features")
+        super(HasCheckpointInterval, self).__init__()
+        #: param for checkpoint interval (>= 1)
+        self.checkpointInterval = Param(self, "checkpointInterval", "checkpoint interval (>= 1)")
         if None is not None:
-            self._setDefault(numFeatures=None)
+            self._setDefault(checkpointInterval=None)
 
-    def setNumFeatures(self, value):
+    def setCheckpointInterval(self, value):
         """
-        Sets the value of :py:attr:`numFeatures`.
+        Sets the value of :py:attr:`checkpointInterval`.
         """
-        self.paramMap[self.numFeatures] = value
+        self.paramMap[self.checkpointInterval] = value
         return self
 
-    def getNumFeatures(self):
+    def getCheckpointInterval(self):
         """
-        Gets the value of numFeatures or its default value.
+        Gets the value of checkpointInterval or its default value.
         """
-        return self.getOrDefault(self.numFeatures)
+        return self.getOrDefault(self.checkpointInterval)