| class_weight | Weights associated with classes in the form ``{class_label: weight}``
If not given, all classes are supposed to have weight one. For
multi-output problems, a list of dicts can be provided in the same
order as the columns of y
Note that for multioutput (including multilabel) weights should be
defined for each class of every column in its own dict. For example,
for four-class multilabel classification weights should be
[{0: 1, 1: 1}, {0: 1, 1: 5}, {0: 1, 1: 1}, {0: 1, 1: 1}] instead of
[{1:1}, {2:5}, {3:1}, {4:1}]
The "balanced" mode uses the values of y to automatically adjust
weights inversely proportional to class frequencies in the input data
as ``n_samples / (n_classes * np.bincount(y))``
For multi-output, the weights of each column of y will be multiplied
Note that these weights will be multiplied with sample_weight (passed
through the fit method) if sample_weight is specified | default: null |
| criterion | The function to measure the quality of a split. Supported criteria are
"gini" for the Gini impurity and "entropy" for the information gain | default: "gini" |
| max_depth | The maximum depth of the tree. If None, then nodes are expanded until
all leaves are pure or until all leaves contain less than
min_samples_split samples | default: 10 |
| max_features | The number of features to consider when looking for the best split:
- If int, then consider `max_features` features at each split
- If float, then `max_features` is a percentage and
`int(max_features * n_features)` features are considered at each
split
- If "auto", then `max_features=sqrt(n_features)`
- If "sqrt", then `max_features=sqrt(n_features)`
- If "log2", then `max_features=log2(n_features)`
- If None, then `max_features=n_features`
Note: the search for a split does not stop until at least one
valid partition of the node samples is found, even if it requires to
effectively inspect more than ``max_features`` features | default: null |
| max_leaf_nodes | Grow a tree with ``max_leaf_nodes`` in best-first fashion
Best nodes are defined as relative reduction in impurity
If None then unlimited number of leaf nodes | default: null |
| min_impurity_decrease | A node will be split if this split induces a decrease of the impurity
greater than or equal to this value
The weighted impurity decrease equation is the following::
N_t / N * (impurity - N_t_R / N_t * right_impurity
- N_t_L / N_t * left_impurity)
where ``N`` is the total number of samples, ``N_t`` is the number of
samples at the current node, ``N_t_L`` is the number of samples in the
left child, and ``N_t_R`` is the number of samples in the right child
``N``, ``N_t``, ``N_t_R`` and ``N_t_L`` all refer to the weighted sum,
if ``sample_weight`` is passed
.. versionadded:: 0.19 | default: 0.0 |
| min_impurity_split | Threshold for early stopping in tree growth. A node will split
if its impurity is above the threshold, otherwise it is a leaf
.. deprecated:: 0.19
``min_impurity_split`` has been deprecated in favor of
``min_impurity_decrease`` in 0.19 and will be removed in 0.21
Use ``min_impurity_decrease`` instead | default: null |
| min_samples_leaf | The minimum number of samples required to be at a leaf node:
- If int, then consider `min_samples_leaf` as the minimum number
- If float, then `min_samples_leaf` is a percentage and
`ceil(min_samples_leaf * n_samples)` are the minimum
number of samples for each node
.. versionchanged:: 0.18
Added float values for percentages | default: 13 |
| min_samples_split | The minimum number of samples required to split an internal node:
- If int, then consider `min_samples_split` as the minimum number
- If float, then `min_samples_split` is a percentage and
`ceil(min_samples_split * n_samples)` are the minimum
number of samples for each split
.. versionchanged:: 0.18
Added float values for percentages | default: 16 |
| min_weight_fraction_leaf | The minimum weighted fraction of the sum total of weights (of all
the input samples) required to be at a leaf node. Samples have
equal weight when sample_weight is not provided | default: 0.0 |
| presort | Whether to presort the data to speed up the finding of best splits in
fitting. For the default settings of a decision tree on large
datasets, setting this to true may slow down the training process
When using either a smaller dataset or a restricted depth, this may
speed up the training. | default: false |
| random_state | If int, random_state is the seed used by the random number generator;
If RandomState instance, random_state is the random number generator;
If None, the random number generator is the RandomState instance used
by `np.random` | default: 22408 |
| splitter | The strategy used to choose the split at each node. Supported
strategies are "best" to choose the best split and "random" to choose
the best random split | default: "best" |