Add @SInCE tags to mllib.fpm

Author: rahulpalamuttam

mllib/src/main/scala/org/apache/spark/mllib/fpm/AssociationRules.scala

@@ -31,18 +31,24 @@ import org.apache.spark.rdd.RDD
  *
  * Generates association rules from a [[RDD[FreqItemset[Item]]]. This method only generates
  * association rules which have a single item as the consequent.
+ *
+ * @since 1.5.0
  */
 @Experimental
 class AssociationRules private[fpm] (
     private var minConfidence: Double) extends Logging with Serializable {
 
   /**
    * Constructs a default instance with default parameters {minConfidence = 0.8}.
+   *
+   * @since 1.5.0
    */
   def this() = this(0.8)
 
   /**
    * Sets the minimal confidence (default: `0.8`).
+   *
+   * @since 1.5.0
    */
   def setMinConfidence(minConfidence: Double): this.type = {
     require(minConfidence >= 0.0 && minConfidence <= 1.0)
@@ -54,6 +60,8 @@ class AssociationRules private[fpm] (
    * Computes the association rules with confidence above [[minConfidence]].
    * @param freqItemsets frequent itemset model obtained from [[FPGrowth]]
    * @return a [[Set[Rule[Item]]] containing the assocation rules.
+   *
+   * @since 1.5.0
    */
   def run[Item: ClassTag](freqItemsets: RDD[FreqItemset[Item]]): RDD[Rule[Item]] = {
     // For candidate rule X => Y, generate (X, (Y, freq(X union Y)))
@@ -90,6 +98,8 @@ object AssociationRules {
    * @param antecedent hypotheses of the rule
    * @param consequent conclusion of the rule
    * @tparam Item item type
+   *
+   * @since 1.5.0
    */
   @Experimental
   class Rule[Item] private[fpm] (

mllib/src/main/scala/org/apache/spark/mllib/fpm/FPGrowth.scala

@@ -38,12 +38,15 @@ import org.apache.spark.storage.StorageLevel
  * Model trained by [[FPGrowth]], which holds frequent itemsets.
  * @param freqItemsets frequent itemset, which is an RDD of [[FreqItemset]]
  * @tparam Item item type
+ *
+ * @since 1.5.0
  */
 @Experimental
 class FPGrowthModel[Item: ClassTag](val freqItemsets: RDD[FreqItemset[Item]]) extends Serializable {
   /**
    * Generates association rules for the [[Item]]s in [[freqItemsets]].
    * @param confidence minimal confidence of the rules produced
+   * @since 1.5.0
    */
   def generateAssociationRules(confidence: Double): RDD[AssociationRules.Rule[Item]] = {
     val associationRules = new AssociationRules(confidence)
@@ -67,6 +70,8 @@ class FPGrowthModel[Item: ClassTag](val freqItemsets: RDD[FreqItemset[Item]]) ex
  *
  * @see [[http://en.wikipedia.org/wiki/Association_rule_learning Association rule learning
  *       (Wikipedia)]]
+ *
+ * @since 1.5.0
  */
 @Experimental
 class FPGrowth private (
@@ -76,11 +81,15 @@ class FPGrowth private (
   /**
    * Constructs a default instance with default parameters {minSupport: `0.3`, numPartitions: same
    * as the input data}.
+   *
+   * @since 1.5.0
    */
   def this() = this(0.3, -1)
 
   /**
    * Sets the minimal support level (default: `0.3`).
+   *
+   * @since 1.5.0
    */
   def setMinSupport(minSupport: Double): this.type = {
     this.minSupport = minSupport
@@ -89,6 +98,8 @@ class FPGrowth private (
 
   /**
    * Sets the number of partitions used by parallel FP-growth (default: same as input data).
+   *
+   * @since 1.5.0
    */
   def setNumPartitions(numPartitions: Int): this.type = {
     this.numPartitions = numPartitions
@@ -99,6 +110,8 @@ class FPGrowth private (
    * Computes an FP-Growth model that contains frequent itemsets.
    * @param data input data set, each element contains a transaction
    * @return an [[FPGrowthModel]]
+   *
+   * @since 1.5.0
    */
   def run[Item: ClassTag](data: RDD[Array[Item]]): FPGrowthModel[Item] = {
     if (data.getStorageLevel == StorageLevel.NONE) {
@@ -123,6 +136,8 @@ class FPGrowth private (
    * @param minCount minimum count for frequent itemsets
    * @param partitioner partitioner used to distribute items
    * @return array of frequent pattern ordered by their frequencies
+   *
+   * @since 1.5.0
    */
   private def genFreqItems[Item: ClassTag](
       data: RDD[Array[Item]],
@@ -149,6 +164,8 @@ class FPGrowth private (
    * @param freqItems frequent items
    * @param partitioner partitioner used to distribute transactions
    * @return an RDD of (frequent itemset, count)
+   *
+   * @since 1.5.0
    */
   private def genFreqItemsets[Item: ClassTag](
       data: RDD[Array[Item]],
@@ -174,6 +191,8 @@ class FPGrowth private (
    * @param itemToRank map from item to their rank
    * @param partitioner partitioner used to distribute transactions
    * @return a map of (target partition, conditional transaction)
+   *
+   * @since 1.5.0
    */
   private def genCondTransactions[Item: ClassTag](
       transaction: Array[Item],
@@ -199,6 +218,8 @@ class FPGrowth private (
 
 /**
  * :: Experimental ::
+ *
+ * @since 1.5.0
  */
 @Experimental
 object FPGrowth {
@@ -208,11 +229,15 @@ object FPGrowth {
    * @param items items in this itemset. Java users should call [[FreqItemset#javaItems]] instead.
    * @param freq frequency
    * @tparam Item item type
+   *
+   * @since 1.5.0
    */
   class FreqItemset[Item](val items: Array[Item], val freq: Long) extends Serializable {
 
     /**
      * Returns items in a Java List.
+     *
+     * @since 1.5.0
      */
     def javaItems: java.util.List[Item] = {
       items.toList.asJava

mllib/src/main/scala/org/apache/spark/mllib/fpm/FPTree.scala

@@ -23,6 +23,8 @@ import scala.collection.mutable.ListBuffer
 /**
  * FP-Tree data structure used in FP-Growth.
  * @tparam T item type
+ *
+ * @since 1.5.0
  */
 private[fpm] class FPTree[T] extends Serializable {
 
@@ -32,7 +34,11 @@ private[fpm] class FPTree[T] extends Serializable {
 
   private val summaries: mutable.Map[T, Summary[T]] = mutable.Map.empty
 
-  /** Adds a transaction with count. */
+  /**
+   * Adds a transaction with count.
+   *
+   * @since 1.5.0
+   */
   def add(t: Iterable[T], count: Long = 1L): this.type = {
     require(count > 0)
     var curr = root
@@ -52,15 +58,23 @@ private[fpm] class FPTree[T] extends Serializable {
     this
   }
 
-  /** Merges another FP-Tree. */
+  /**
+   * Merges another FP-Tree.
+   *
+   * @since 1.5.0
+   */
   def merge(other: FPTree[T]): this.type = {
     other.transactions.foreach { case (t, c) =>
       add(t, c)
     }
     this
   }
 
-  /** Gets a subtree with the suffix. */
+  /**
+   * Gets a subtree with the suffix.
+   *
+   * @since 1.5.0
+   */
   private def project(suffix: T): FPTree[T] = {
     val tree = new FPTree[T]
     if (summaries.contains(suffix)) {
@@ -78,10 +92,18 @@ private[fpm] class FPTree[T] extends Serializable {
     tree
   }
 
-  /** Returns all transactions in an iterator. */
+  /**
+   * Returns all transactions in an iterator.
+   *
+   * @since 1.5.0
+   */
   def transactions: Iterator[(List[T], Long)] = getTransactions(root)
 
-  /** Returns all transactions under this node. */
+  /**
+   * Returns all transactions under this node.
+   *
+   * @since 1.5.0
+   */
   private def getTransactions(node: Node[T]): Iterator[(List[T], Long)] = {
     var count = node.count
     node.children.iterator.flatMap { case (item, child) =>
@@ -98,7 +120,11 @@ private[fpm] class FPTree[T] extends Serializable {
     }
   }
 
-  /** Extracts all patterns with valid suffix and minimum count. */
+  /**
+   * Extracts all patterns with valid suffix and minimum count.
+   *
+   * @since 1.5.0
+   */
   def extract(
       minCount: Long,
       validateSuffix: T => Boolean = _ => true): Iterator[(List[T], Long)] = {
@@ -117,7 +143,11 @@ private[fpm] class FPTree[T] extends Serializable {
 
 private[fpm] object FPTree {
 
-  /** Representing a node in an FP-Tree. */
+  /**
+   * Representing a node in an FP-Tree.
+   *
+   * @since 1.5.0
+   */
   class Node[T](val parent: Node[T]) extends Serializable {
     var item: T = _
     var count: Long = 0L
@@ -126,7 +156,11 @@ private[fpm] object FPTree {
     def isRoot: Boolean = parent == null
   }
 
-  /** Summary of a item in an FP-Tree. */
+  /**
+   * Summary of a item in an FP-Tree.
+   *
+   * @since 1.5.0
+   */
   private class Summary[T] extends Serializable {
     var count: Long = 0L
     val nodes: ListBuffer[Node[T]] = ListBuffer.empty