update code gen and make param appear in the doc

mengxr · mengxr · commit 1dcc17e222be · 2015-01-27T13:43:19.000-08:00
diff --git a/python/pyspark/ml/param/__init__.py b/python/pyspark/ml/param/__init__.py
@@ -39,7 +39,8 @@ def __str__(self):
         return str(self.parent) + "_" + self.name
 
     def __repr__(self):
-        return str(self.parent) + "_" + self.name
+        return "Param(parent=%r, name=%r, doc=%r, defaultValue=%r)" % \
+               (self.parent, self.name, self.doc, self.defaultValue)
 
 
 class Params(Identifiable):
@@ -69,3 +70,12 @@ def _merge_params(self, params):
         paramMap = self.paramMap.copy()
         paramMap.update(params)
         return paramMap
+
+    @staticmethod
+    def _dummy():
+        """
+        Returns a dummy Params instance used as a placeholder to generate docs.
+        """
+        dummy = Params()
+        dummy.uid = "undefined"
+        return dummy
diff --git a/python/pyspark/ml/param/_gen_shared_params.py b/python/pyspark/ml/param/_gen_shared_params.py
@@ -42,25 +42,42 @@ def _gen_param_code(name, doc, defaultValue):
     :param defaultValue: string representation of the param
     :return: code string
     """
-    upperCamelName = name[0].upper() + name[1:]
-    return """class Has%s(Params):
+    # TODO: How to correctly inherit instance attributes?
+    template = '''class Has$Name(Params):
+    """
+    Params with $name.
+    """
+
+    # a placeholder to make it appear in the generated doc
+    $name = Param(Params._dummy(), "$name", "$doc", $defaultValue)
 
     def __init__(self):
-        super(Has%s, self).__init__()
-        #: %s
-        self.%s = Param(self, "%s", "%s", %s)
+        super(Has$Name, self).__init__()
+        #: param for $doc
+        self.$name = Param(self, "$name", "$doc", $defaultValue)
 
-    def set%s(self, value):
-        self.paramMap[self.%s] = value
+    def set$Name(self, value):
+        """
+        Sets the value of :py:attr:`$name`.
+        """
+        self.paramMap[self.$name] = value
         return self
 
-    def get%s(self):
-        if self.%s in self.paramMap:
-            return self.paramMap[self.%s]
+    def get$Name(self):
+        """
+        Gets the value of $name or its default value.
+        """
+        if self.$name in self.paramMap:
+            return self.paramMap[self.$name]
         else:
-            return self.%s.defaultValue""" % (
-        upperCamelName, upperCamelName, doc, name, name, doc, defaultValue, upperCamelName, name,
-        upperCamelName, name, name, name)
+            return self.$name.defaultValue'''
+
+    upperCamelName = name[0].upper() + name[1:]
+    return template \
+        .replace("$name", name) \
+        .replace("$Name", upperCamelName) \
+        .replace("$doc", doc) \
+        .replace("$defaultValue", defaultValue)
 
 if __name__ == "__main__":
     print header
diff --git a/python/pyspark/ml/param/shared.py b/python/pyspark/ml/param/shared.py
@@ -21,125 +21,209 @@
 
 
 class HasMaxIter(Params):
+    """
+    Params with maxIter.
+    """
+
+    # a placeholder to make it appear in the generated doc
+    maxIter = Param(Params._dummy(), "maxIter", "max number of iterations", 100)
 
     def __init__(self):
         super(HasMaxIter, self).__init__()
-        #: max number of iterations
+        #: param for max number of iterations
         self.maxIter = Param(self, "maxIter", "max number of iterations", 100)
 
     def setMaxIter(self, value):
+        """
+        Sets the value of :py:attr:`maxIter`.
+        """
         self.paramMap[self.maxIter] = value
         return self
 
     def getMaxIter(self):
+        """
+        Gets the value of maxIter or its default value.
+        """
         if self.maxIter in self.paramMap:
             return self.paramMap[self.maxIter]
         else:
             return self.maxIter.defaultValue
 
 
 class HasRegParam(Params):
+    """
+    Params with regParam.
+    """
+
+    # a placeholder to make it appear in the generated doc
+    regParam = Param(Params._dummy(), "regParam", "regularization constant", 0.1)
 
     def __init__(self):
         super(HasRegParam, self).__init__()
-        #: regularization constant
+        #: param for regularization constant
         self.regParam = Param(self, "regParam", "regularization constant", 0.1)
 
     def setRegParam(self, value):
+        """
+        Sets the value of :py:attr:`regParam`.
+        """
         self.paramMap[self.regParam] = value
         return self
 
     def getRegParam(self):
+        """
+        Gets the value of regParam or its default value.
+        """
         if self.regParam in self.paramMap:
             return self.paramMap[self.regParam]
         else:
             return self.regParam.defaultValue
 
 
 class HasFeaturesCol(Params):
+    """
+    Params with featuresCol.
+    """
+
+    # a placeholder to make it appear in the generated doc
+    featuresCol = Param(Params._dummy(), "featuresCol", "features column name", 'features')
 
     def __init__(self):
         super(HasFeaturesCol, self).__init__()
-        #: features column name
+        #: param for features column name
         self.featuresCol = Param(self, "featuresCol", "features column name", 'features')
 
     def setFeaturesCol(self, value):
+        """
+        Sets the value of :py:attr:`featuresCol`.
+        """
         self.paramMap[self.featuresCol] = value
         return self
 
     def getFeaturesCol(self):
+        """
+        Gets the value of featuresCol or its default value.
+        """
         if self.featuresCol in self.paramMap:
             return self.paramMap[self.featuresCol]
         else:
             return self.featuresCol.defaultValue
 
 
 class HasLabelCol(Params):
+    """
+    Params with labelCol.
+    """
+
+    # a placeholder to make it appear in the generated doc
+    labelCol = Param(Params._dummy(), "labelCol", "label column name", 'label')
 
     def __init__(self):
         super(HasLabelCol, self).__init__()
-        #: label column name
+        #: param for label column name
         self.labelCol = Param(self, "labelCol", "label column name", 'label')
 
     def setLabelCol(self, value):
+        """
+        Sets the value of :py:attr:`labelCol`.
+        """
         self.paramMap[self.labelCol] = value
         return self
 
     def getLabelCol(self):
+        """
+        Gets the value of labelCol or its default value.
+        """
         if self.labelCol in self.paramMap:
             return self.paramMap[self.labelCol]
         else:
             return self.labelCol.defaultValue
 
 
 class HasPredictionCol(Params):
+    """
+    Params with predictionCol.
+    """
+
+    # a placeholder to make it appear in the generated doc
+    predictionCol = Param(Params._dummy(), "predictionCol", "prediction column name", 'prediction')
 
     def __init__(self):
         super(HasPredictionCol, self).__init__()
-        #: prediction column name
+        #: param for prediction column name
         self.predictionCol = Param(self, "predictionCol", "prediction column name", 'prediction')
 
     def setPredictionCol(self, value):
+        """
+        Sets the value of :py:attr:`predictionCol`.
+        """
         self.paramMap[self.predictionCol] = value
         return self
 
     def getPredictionCol(self):
+        """
+        Gets the value of predictionCol or its default value.
+        """
         if self.predictionCol in self.paramMap:
             return self.paramMap[self.predictionCol]
         else:
             return self.predictionCol.defaultValue
 
 
 class HasInputCol(Params):
+    """
+    Params with inputCol.
+    """
+
+    # a placeholder to make it appear in the generated doc
+    inputCol = Param(Params._dummy(), "inputCol", "input column name", 'input')
 
     def __init__(self):
         super(HasInputCol, self).__init__()
-        #: input column name
+        #: param for input column name
         self.inputCol = Param(self, "inputCol", "input column name", 'input')
 
     def setInputCol(self, value):
+        """
+        Sets the value of :py:attr:`inputCol`.
+        """
         self.paramMap[self.inputCol] = value
         return self
 
     def getInputCol(self):
+        """
+        Gets the value of inputCol or its default value.
+        """
         if self.inputCol in self.paramMap:
             return self.paramMap[self.inputCol]
         else:
             return self.inputCol.defaultValue
 
 
 class HasOutputCol(Params):
+    """
+    Params with outputCol.
+    """
+
+    # a placeholder to make it appear in the generated doc
+    outputCol = Param(Params._dummy(), "outputCol", "output column name", 'output')
 
     def __init__(self):
         super(HasOutputCol, self).__init__()
-        #: output column name
+        #: param for output column name
         self.outputCol = Param(self, "outputCol", "output column name", 'output')
 
     def setOutputCol(self, value):
+        """
+        Sets the value of :py:attr:`outputCol`.
+        """
         self.paramMap[self.outputCol] = value
         return self
 
     def getOutputCol(self):
+        """
+        Gets the value of outputCol or its default value.
+        """
         if self.outputCol in self.paramMap:
             return self.paramMap[self.outputCol]
         else:
