org.apache.spark.mllib.tree

Class RandomForest

Object

org.apache.spark.mllib.tree.RandomForest

All Implemented Interfaces:

java.io.Serializable, Logging

public class RandomForest
extends Object
implements scala.Serializable, Logging

:: Experimental :: A class that implements a Random Forest learning algorithm for classification and regression. It supports both continuous and categorical features.

The settings for featureSubsetStrategy are based on the following references: - log2: tested in Breiman (2001) - sqrt: recommended by Breiman manual for random forests - The defaults of sqrt (classification) and onethird (regression) match the R randomForest package.

See Also:

, http://www.stat.berkeley.edu/~breiman/Using_random_forests_V3.1.pdf Breiman manual for random forests}

, Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	RandomForest.NodeIndexInfo

Constructor Summary

Constructors

Constructor and Description
RandomForest(Strategy strategy, int numTrees, String featureSubsetStrategy, int seed)

Method Summary

Methods

Modifier and Type	Method and Description
static long	aggregateSizeForNode(DecisionTreeMetadata metadata, scala.Option<int[]> featureSubset) Get the number of values to be stored for this node in the bin aggregates.
RandomForestModel	run(RDD<LabeledPoint> input) Method to train a decision tree model over an RDD
static scala.Tuple2<scala.collection.immutable.Map<Object,Node[]>,scala.collection.immutable.Map<Object,scala.collection.immutable.Map<Object,RandomForest.NodeIndexInfo>>>	selectNodesToSplit(scala.collection.mutable.Queue<scala.Tuple2<Object,Node>> nodeQueue, long maxMemoryUsage, DecisionTreeMetadata metadata, scala.util.Random rng) Pull nodes off of the queue, and collect a group of nodes to be split on this iteration.
static String[]	supportedFeatureSubsetStrategies() List of supported feature subset sampling strategies.
static RandomForestModel	trainClassifier(JavaRDD<LabeledPoint> input, int numClasses, java.util.Map<Integer,Integer> categoricalFeaturesInfo, int numTrees, String featureSubsetStrategy, String impurity, int maxDepth, int maxBins, int seed) Java-friendly API for RandomForest$.trainClassifier(org.apache.spark.rdd.RDD<org.apache.spark.mllib.regression.LabeledPoint>, org.apache.spark.mllib.tree.configuration.Strategy, int, java.lang.String, int)
static RandomForestModel	trainClassifier(RDD<LabeledPoint> input, int numClasses, scala.collection.immutable.Map<Object,Object> categoricalFeaturesInfo, int numTrees, String featureSubsetStrategy, String impurity, int maxDepth, int maxBins, int seed) Method to train a decision tree model for binary or multiclass classification.
static RandomForestModel	trainClassifier(RDD<LabeledPoint> input, Strategy strategy, int numTrees, String featureSubsetStrategy, int seed) Method to train a decision tree model for binary or multiclass classification.
static RandomForestModel	trainRegressor(JavaRDD<LabeledPoint> input, java.util.Map<Integer,Integer> categoricalFeaturesInfo, int numTrees, String featureSubsetStrategy, String impurity, int maxDepth, int maxBins, int seed) Java-friendly API for RandomForest$.trainRegressor(org.apache.spark.rdd.RDD<org.apache.spark.mllib.regression.LabeledPoint>, org.apache.spark.mllib.tree.configuration.Strategy, int, java.lang.String, int)
static RandomForestModel	trainRegressor(RDD<LabeledPoint> input, scala.collection.immutable.Map<Object,Object> categoricalFeaturesInfo, int numTrees, String featureSubsetStrategy, String impurity, int maxDepth, int maxBins, int seed) Method to train a decision tree model for regression.
static RandomForestModel	trainRegressor(RDD<LabeledPoint> input, Strategy strategy, int numTrees, String featureSubsetStrategy, int seed) Method to train a decision tree model for regression.

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

RandomForest

public RandomForest(Strategy strategy,
            int numTrees,
            String featureSubsetStrategy,
            int seed)

Method Detail

trainClassifier

public static RandomForestModel trainClassifier(RDD<LabeledPoint> input,
                                Strategy strategy,
                                int numTrees,
                                String featureSubsetStrategy,
                                int seed)

Method to train a decision tree model for binary or multiclass classification.

Parameters:

input - Training dataset: RDD of LabeledPoint. Labels should take values {0, 1, ..., numClasses-1}.

strategy - Parameters for training each tree in the forest.

numTrees - Number of trees in the random forest.

featureSubsetStrategy - Number of features to consider for splits at each node. Supported: "auto", "all", "sqrt", "log2", "onethird". If "auto" is set, this parameter is set based on numTrees: if numTrees == 1, set to "all"; if numTrees > 1 (forest) set to "sqrt".

seed - Random seed for bootstrapping and choosing feature subsets.

Returns:

a random forest model that can be used for prediction

trainClassifier

public static RandomForestModel trainClassifier(RDD<LabeledPoint> input,
                                int numClasses,
                                scala.collection.immutable.Map<Object,Object> categoricalFeaturesInfo,
                                int numTrees,
                                String featureSubsetStrategy,
                                String impurity,
                                int maxDepth,
                                int maxBins,
                                int seed)

Method to train a decision tree model for binary or multiclass classification.

Parameters:

input - Training dataset: RDD of LabeledPoint. Labels should take values {0, 1, ..., numClasses-1}.

numClasses - number of classes for classification.

categoricalFeaturesInfo - Map storing arity of categorical features. E.g., an entry (n -> k) indicates that feature n is categorical with k categories indexed from 0: {0, 1, ..., k-1}.

numTrees - Number of trees in the random forest.

featureSubsetStrategy - Number of features to consider for splits at each node. Supported: "auto", "all", "sqrt", "log2", "onethird". If "auto" is set, this parameter is set based on numTrees: if numTrees == 1, set to "all"; if numTrees > 1 (forest) set to "sqrt".

impurity - Criterion used for information gain calculation. Supported values: "gini" (recommended) or "entropy".

maxDepth - Maximum depth of the tree. E.g., depth 0 means 1 leaf node; depth 1 means 1 internal node + 2 leaf nodes. (suggested value: 4)

maxBins - maximum number of bins used for splitting features (suggested value: 100)

seed - Random seed for bootstrapping and choosing feature subsets.

Returns:

a random forest model that can be used for prediction

trainClassifier

public static RandomForestModel trainClassifier(JavaRDD<LabeledPoint> input,
                                int numClasses,
                                java.util.Map<Integer,Integer> categoricalFeaturesInfo,
                                int numTrees,
                                String featureSubsetStrategy,
                                String impurity,
                                int maxDepth,
                                int maxBins,
                                int seed)

Java-friendly API for RandomForest$.trainClassifier(org.apache.spark.rdd.RDD<org.apache.spark.mllib.regression.LabeledPoint>, org.apache.spark.mllib.tree.configuration.Strategy, int, java.lang.String, int)

trainRegressor

public static RandomForestModel trainRegressor(RDD<LabeledPoint> input,
                               Strategy strategy,
                               int numTrees,
                               String featureSubsetStrategy,
                               int seed)

Method to train a decision tree model for regression.

Parameters:

input - Training dataset: RDD of LabeledPoint. Labels are real numbers.

strategy - Parameters for training each tree in the forest.

numTrees - Number of trees in the random forest.

featureSubsetStrategy - Number of features to consider for splits at each node. Supported: "auto", "all", "sqrt", "log2", "onethird". If "auto" is set, this parameter is set based on numTrees: if numTrees == 1, set to "all"; if numTrees > 1 (forest) set to "onethird".

seed - Random seed for bootstrapping and choosing feature subsets.

Returns:

a random forest model that can be used for prediction

trainRegressor

public static RandomForestModel trainRegressor(RDD<LabeledPoint> input,
                               scala.collection.immutable.Map<Object,Object> categoricalFeaturesInfo,
                               int numTrees,
                               String featureSubsetStrategy,
                               String impurity,
                               int maxDepth,
                               int maxBins,
                               int seed)

Method to train a decision tree model for regression.

Parameters:

input - Training dataset: RDD of LabeledPoint. Labels are real numbers.

categoricalFeaturesInfo - Map storing arity of categorical features. E.g., an entry (n -> k) indicates that feature n is categorical with k categories indexed from 0: {0, 1, ..., k-1}.

numTrees - Number of trees in the random forest.

featureSubsetStrategy - Number of features to consider for splits at each node. Supported: "auto", "all", "sqrt", "log2", "onethird". If "auto" is set, this parameter is set based on numTrees: if numTrees == 1, set to "all"; if numTrees > 1 (forest) set to "onethird".

impurity - Criterion used for information gain calculation. Supported values: "variance".

maxDepth - Maximum depth of the tree. E.g., depth 0 means 1 leaf node; depth 1 means 1 internal node + 2 leaf nodes. (suggested value: 4)

maxBins - maximum number of bins used for splitting features (suggested value: 100)

seed - Random seed for bootstrapping and choosing feature subsets.

Returns:

a random forest model that can be used for prediction

trainRegressor

public static RandomForestModel trainRegressor(JavaRDD<LabeledPoint> input,
                               java.util.Map<Integer,Integer> categoricalFeaturesInfo,
                               int numTrees,
                               String featureSubsetStrategy,
                               String impurity,
                               int maxDepth,
                               int maxBins,
                               int seed)

Java-friendly API for RandomForest$.trainRegressor(org.apache.spark.rdd.RDD<org.apache.spark.mllib.regression.LabeledPoint>, org.apache.spark.mllib.tree.configuration.Strategy, int, java.lang.String, int)

supportedFeatureSubsetStrategies

public static String[] supportedFeatureSubsetStrategies()

List of supported feature subset sampling strategies.

selectNodesToSplit

public static scala.Tuple2<scala.collection.immutable.Map<Object,Node[]>,scala.collection.immutable.Map<Object,scala.collection.immutable.Map<Object,RandomForest.NodeIndexInfo>>> selectNodesToSplit(scala.collection.mutable.Queue<scala.Tuple2<Object,Node>> nodeQueue,
                                                                                                                                                                                      long maxMemoryUsage,
                                                                                                                                                                                      DecisionTreeMetadata metadata,
                                                                                                                                                                                      scala.util.Random rng)

Pull nodes off of the queue, and collect a group of nodes to be split on this iteration. This tracks the memory usage for aggregates and stops adding nodes when too much memory will be needed; this allows an adaptive number of nodes since different nodes may require different amounts of memory (if featureSubsetStrategy is not "all").

Parameters:

nodeQueue - Queue of nodes to split.

maxMemoryUsage - Bound on size of aggregate statistics.

Returns:

(nodesForGroup, treeToNodeToIndexInfo). nodesForGroup holds the nodes to split: treeIndex --> nodes in tree.

treeToNodeToIndexInfo holds indices selected features for each node: treeIndex --> (global) node index --> (node index in group, feature indices). The (global) node index is the index in the tree; the node index in group is the index in [0, numNodesInGroup) of the node in this group. The feature indices are None if not subsampling features.

aggregateSizeForNode

public static long aggregateSizeForNode(DecisionTreeMetadata metadata,
                        scala.Option<int[]> featureSubset)

Get the number of values to be stored for this node in the bin aggregates.

Parameters:

featureSubset - Indices of features which may be split at this node. If None, then use all features.

run

public RandomForestModel run(RDD<LabeledPoint> input)

Method to train a decision tree model over an RDD

Parameters:

input - Training data: RDD of LabeledPoint

Returns:

a random forest model that can be used for prediction