Source: eclairjs/mllib/fpm/FPGrowth.js

  1. /*                                                                         
  2. * Copyright 2016 IBM Corp.                                                 
  3. *                                                                          
  4. * Licensed under the Apache License, Version 2.0 (the "License");          
  5. * you may not use this file except in compliance with the License.         
  6. * You may obtain a copy of the License at                                  
  7. *                                                                          
  8. *      http://www.apache.org/licenses/LICENSE-2.0                          
  9. *                                                                          
  10. * Unless required by applicable law or agreed to in writing, software      
  11. * distributed under the License is distributed on an "AS IS" BASIS,        
  12. * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 
  13. * See the License for the specific language governing permissions and      
  14. * limitations under the License.                                           
  15. */ 
  16. (function () {
  18.     var JavaWrapper = require(EclairJS_Globals.NAMESPACE + '/JavaWrapper');
  19.     var Logger = require(EclairJS_Globals.NAMESPACE + '/Logger');
  20.     var Utils = require(EclairJS_Globals.NAMESPACE + '/Utils');
  22.     var FPGrowthModel = require(EclairJS_Globals.NAMESPACE + '/mllib/fpm/FPGrowthModel');
  24.     /**
  25.      * A parallel FP-growth algorithm to mine frequent itemsets. The algorithm is described in
  26.      * [[http://dx.doi.org/10.1145/1454008.1454027 Li et al., PFP: Parallel FP-Growth for Query
  27.      *  Recommendation]]. PFP distributes computation in such a way that each worker executes an
  28.      * independent group of mining tasks. The FP-Growth algorithm is described in
  29.      * [[http://dx.doi.org/10.1145/335191.335372 Han et al., Mining frequent patterns without candidate
  30.      *  generation]].
  31.      *
  32.      * @param minSupport the minimal support level of the frequent pattern, any pattern appears
  33.      *                   more than (minSupport * size-of-the-dataset) times will be output
  34.      * @param numPartitions number of partitions used by parallel FP-growth
  35.      *
  36.      * @see [[http://en.wikipedia.org/wiki/Association_rule_learning Association rule learning
  37.      *       (Wikipedia)]]
  38.      *
  39.      * @classdesc
  40.      */
  42.     /**
  43.      * Constructs a default instance with default parameters {minSupport: `0.3`, numPartitions: same
  44.      * as the input data}.
  45.      *
  46.      * @class
  47.      * @memberof module:eclairjs/mllib/fpm
  48.      */
  49.     var FPGrowth = function(obj) {
  50.          
  51.          this.logger = Logger.getLogger("FPGrowth_js");
  52.         var jvmObject;
  53.         if (obj instanceof org.apache.spark.mllib.fpm.FPGrowth) {
  54.             jvmObject = obj;
  55.         } else {
  56.             jvmObject = new org.apache.spark.mllib.fpm.FPGrowth();
  57.         }
  58.          JavaWrapper.call(this, jvmObject);
  60.     };
  62.     FPGrowth.prototype = Object.create(JavaWrapper.prototype);
  64.     FPGrowth.prototype.constructor = FPGrowth;
  68.     /**
  69.      * Sets the minimal support level (default: `0.3`).
  70.      *
  71.      * @param {float} minSupport
  72.      * @returns {module:eclairjs/mllib/fpm.FPGrowth}
  73.      */
  74.     FPGrowth.prototype.setMinSupport = function(minSupport) {
  75.        var javaObject =  this.getJavaObject().setMinSupport(minSupport);
  76.        return new FPGrowth(javaObject);
  77.     };
  80.     /**
  81.      * Sets the number of partitions used by parallel FP-growth (default: same as input data).
  82.      *
  83.      * @param {integer} numPartitions
  84.      * @returns {module:eclairjs/mllib/fpm.FPGrowth}
  85.      */
  86.     FPGrowth.prototype.setNumPartitions = function(numPartitions) {
  87.        var javaObject =  this.getJavaObject().setNumPartitions(numPartitions);
  88.        return new FPGrowth(javaObject);
  89.     };
  92.     /**
  93.      * Computes an FP-Growth model that contains frequent itemsets.
  94.      * @param {module:eclairjs.RDD} data  input data set, each element contains a transaction
  95.      *
  96.      * @returns {module:eclairjs/mllib/fpm.FPGrowthModel}  an [[module:eclairjs/mllib/fpm.FPGrowthModel]]
  97.      */
  98.     FPGrowth.prototype.run = function(data) {
  99.        var data_uw = Utils.unwrapObject(data);
  100.        var javaObject =  this.getJavaObject().run(data_uw);
  101.        return new FPGrowthModel(javaObject);
  102.     };
  104.     module.exports = FPGrowth;
  106. })();