@etrain and I came with a PR for arbitrarily deep decision trees at the cost of multiple passes over the data at deep tree levels. To summarize: 1) We take a parameter that indicates the amount of memory users want to reserve for computation on each worker (and 2x that at the driver). 2) Using that information, we calculate two things - the maximum depth to which we train as usual (which is, implicitly, the maximum number of nodes we want to train in parallel), and the size of the groups we should use in the case where we exceed this depth. cc: @atalwalkar, @hirakendu, @mengxr Author: Manish Amde <manish9ue@gmail.com> Author: manishamde <manish9ue@gmail.com> Author: Evan Sparks <sparks@cs.berkeley.edu> Closes #475 from manishamde/deep_tree and squashes the following commits: 968ca9d [Manish Amde] merged master 7fc9545 [Manish Amde] added docs ce004a1 [Manish Amde] minor formatting b27ad2c [Manish Amde] formatting 426bb28 [Manish Amde] programming guide blurb 8053fed [Manish Amde] more formatting 5eca9e4 [Manish Amde] grammar 4731cda [Manish Amde] formatting 5e82202 [Manish Amde] added documentation, fixed off by 1 error in max level calculation cbd9f14 [Manish Amde] modified scala.math to math dad9652 [Manish Amde] removed unused imports e0426ee [Manish Amde] renamed parameter 718506b [Manish Amde] added unit test 1517155 [Manish Amde] updated documentation 9dbdabe [Manish Amde] merge from master 719d009 [Manish Amde] updating user documentation fecf89a [manishamde] Merge pull request #6 from etrain/deep_tree 0287772 [Evan Sparks] Fixing scalastyle issue. 2f1e093 [Manish Amde] minor: added doc for maxMemory parameter 2f6072c [manishamde] Merge pull request #5 from etrain/deep_tree abc5a23 [Evan Sparks] Parameterizing max memory. 50b143a [Manish Amde] adding support for very deep trees
8.1 KiB
layout | title |
---|---|
global | <a href="mllib-guide.html">MLlib</a> - Decision Tree |
- Table of contents {:toc}
Decision trees and their ensembles are popular methods for the machine learning tasks of classification and regression. Decision trees are widely used since they are easy to interpret, handle categorical variables, extend to the multiclass classification setting, do not require feature scaling and are able to capture nonlinearities and feature interactions. Tree ensemble algorithms such as decision forest and boosting are among the top performers for classification and regression tasks.
Basic algorithm
The decision tree is a greedy algorithm that performs a recursive binary partitioning of the feature
space by choosing a single element from the best split set where each element of the set maximizes
the information gain at a tree node. In other words, the split chosen at each tree node is chosen
from the set $\underset{s}{\operatorname{argmax}} IG(D,s)$
where $IG(D,s)$
is the information
gain when a split $s$
is applied to a dataset $D$
.
Node impurity and information gain
The node impurity is a measure of the homogeneity of the labels at the node. The current implementation provides two impurity measures for classification (Gini impurity and entropy) and one impurity measure for regression (variance).
Impurity | Task | Formula | Description |
---|---|---|---|
Gini impurity | Classification | $\sum_{i=1}^{M} f_i(1-f_i)$ | $f_i$ is the frequency of label $i$ at a node and $M$ is the number of unique labels. |
Entropy | Classification | $\sum_{i=1}^{M} -f_ilog(f_i)$ | $f_i$ is the frequency of label $i$ at a node and $M$ is the number of unique labels. |
Variance | Regression | $\frac{1}{n} \sum_{i=1}^{N} (x_i - \mu)^2$ | $y_i$ is label for an instance, $N$ is the number of instances and $\mu$ is the mean given by $\frac{1}{N} \sum_{i=1}^n x_i$. |
The information gain is the difference in the parent node impurity and the weighted sum of the two
child node impurities. Assuming that a split s
partitions the dataset $D$
of size $N$
into two
datasets $D_{left}$
and $D_{right}$
of sizes $N_{left}$
and $N_{right}$
, respectively:
$IG(D,s) = Impurity(D) - \frac{N_{left}}{N} Impurity(D_{left}) - \frac{N_{right}}{N} Impurity(D_{right})$
Split candidates
Continuous features
For small datasets in single machine implementations, the split candidates for each continuous feature are typically the unique values for the feature. Some implementations sort the feature values and then use the ordered unique values as split candidates for faster tree calculations.
Finding ordered unique feature values is computationally intensive for large distributed
datasets. One can get an approximate set of split candidates by performing a quantile calculation
over a sampled fraction of the data. The ordered splits create "bins" and the maximum number of such
bins can be specified using the maxBins
parameters.
Note that the number of bins cannot be greater than the number of instances $N$
(a rare scenario
since the default maxBins
value is 100). The tree algorithm automatically reduces the number of
bins if the condition is not satisfied.
Categorical features
For $M$
categorical features, one could come up with $2^M-1$
split candidates. However, for
binary classification, the number of split candidates can be reduced to $M-1$
by ordering the
categorical feature values by the proportion of labels falling in one of the two classes (see
Section 9.2.4 in
Elements of Statistical Machine Learning for
details). For example, for a binary classification problem with one categorical feature with three
categories A, B and C with corresponding proportion of label 1 as 0.2, 0.6 and 0.4, the categorical
features are ordered as A followed by C followed B or A, B, C. The two split candidates are A | C, B
and A , B | C where | denotes the split.
Stopping rule
The recursive tree construction is stopped at a node when one of the two conditions is met:
- The node depth is equal to the
maxDepth
training parameter - No split candidate leads to an information gain at the node.
Max memory requirements
For faster processing, the decision tree algorithm performs simultaneous histogram computations for all nodes at each level of the tree. This could lead to high memory requirements at deeper levels of the tree leading to memory overflow errors. To alleviate this problem, a 'maxMemoryInMB' training parameter is provided which specifies the maximum amount of memory at the workers (twice as much at the master) to be allocated to the histogram computation. The default value is conservatively chosen to be 128 MB to allow the decision algorithm to work in most scenarios. Once the memory requirements for a level-wise computation crosses the maxMemoryInMB
threshold, the node training tasks at each subsequent level is split into smaller tasks.
Practical limitations
- The implemented algorithm reads both sparse and dense data. However, it is not optimized for sparse input.
- Python is not supported in this release.
Examples
Classification
The example below demonstrates how to load a CSV file, parse it as an RDD of LabeledPoint
and then
perform classification using a decision tree using Gini impurity as an impurity measure and a
maximum tree depth of 5. The training error is calculated to measure the algorithm accuracy.
// Load and parse the data file val data = sc.textFile("mllib/data/sample_tree_data.csv") val parsedData = data.map { line => val parts = line.split(',').map(_.toDouble) LabeledPoint(parts(0), Vectors.dense(parts.tail)) }
// Run training algorithm to build the model val maxDepth = 5 val model = DecisionTree.train(parsedData, Classification, Gini, maxDepth)
// Evaluate model on training examples and compute training error val labelAndPreds = parsedData.map { point => val prediction = model.predict(point.features) (point.label, prediction) } val trainErr = labelAndPreds.filter(r => r._1 != r._2).count.toDouble / parsedData.count println("Training Error = " + trainErr) {% endhighlight %}
Regression
The example below demonstrates how to load a CSV file, parse it as an RDD of LabeledPoint
and then
perform regression using a decision tree using variance as an impurity measure and a maximum tree
depth of 5. The Mean Squared Error (MSE) is computed at the end to evaluate
goodness of fit.
// Load and parse the data file val data = sc.textFile("mllib/data/sample_tree_data.csv") val parsedData = data.map { line => val parts = line.split(',').map(_.toDouble) LabeledPoint(parts(0), Vectors.dense(parts.tail)) }
// Run training algorithm to build the model val maxDepth = 5 val model = DecisionTree.train(parsedData, Regression, Variance, maxDepth)
// Evaluate model on training examples and compute training error val valuesAndPreds = parsedData.map { point => val prediction = model.predict(point.features) (point.label, prediction) } val MSE = valuesAndPreds.map{ case(v, p) => math.pow((v - p), 2)}.mean() println("training Mean Squared Error = " + MSE) {% endhighlight %}