1232
1159
sklearn.model_selection._search.RandomizedSearchCV(estimator=sklearn.ensemble.forest.RandomForestClassifier)
sklearn.RandomizedSearchCV(RandomForestClassifier)
sklearn.model_selection._search.RandomizedSearchCV
5
openml==0.10.1,sklearn==0.20.0
Randomized search on hyper parameters.
RandomizedSearchCV implements a "fit" and a "score" method.
It also implements "predict", "predict_proba", "decision_function",
"transform" and "inverse_transform" if they are implemented in the
estimator used.
The parameters of the estimator used to apply these methods are optimized
by cross-validated search over parameter settings.
In contrast to GridSearchCV, not all parameter values are tried out, but
rather a fixed number of parameter settings is sampled from the specified
distributions. The number of parameter settings that are tried is
given by n_iter.
If all parameters are presented as a list,
sampling without replacement is performed. If at least one parameter
is given as a distribution, sampling with replacement is used.
It is highly recommended to use continuous distributions for continuous
parameters.
Note that before SciPy 0.16, the ``scipy.stats.distributions`` do not
accept a custom RNG instance and always use the singleton RNG from
``numpy.random`...
2019-10-29T16:48:51
English
sklearn==0.20.0
numpy>=1.6.1
scipy>=0.9
cv
int
3
Determines the cross-validation splitting strategy
Possible inputs for cv are:
- None, to use the default 3-fold cross validation,
- integer, to specify the number of folds in a `(Stratified)KFold`,
- An object to be used as a cross-validation generator
- An iterable yielding train, test splits
For integer/None inputs, if the estimator is a classifier and ``y`` is
either binary or multiclass, :class:`StratifiedKFold` is used. In all
other cases, :class:`KFold` is used
Refer :ref:`User Guide <cross_validation>` for the various
cross-validation strategies that can be used here
.. versionchanged:: 0.20
``cv`` default value if None will change from 3-fold to 5-fold
in v0.22
error_score
'raise' or numeric
"raise-deprecating"
Value to assign to the score if an error occurs in estimator fitting
If set to 'raise', the error is raised. If a numeric value is given,
FitFailedWarning is raised. This parameter does not affect the refit
step, which will always raise the error. Default is 'raise' but from
version 0.22 it will change to np.nan
estimator
estimator object
{"oml-python:serialized_object": "component_reference", "value": {"key": "estimator", "step_name": null}}
A object of that type is instantiated for each grid point
This is assumed to implement the scikit-learn estimator interface
Either estimator needs to provide a ``score`` function,
or ``scoring`` must be passed
fit_params
dict
null
Parameters to pass to the fit method
.. deprecated:: 0.19
``fit_params`` as a constructor argument was deprecated in version
0.19 and will be removed in version 0.21. Pass fit parameters to
the ``fit`` method instead
iid
boolean
"warn"
If True, return the average score across folds, weighted by the number
of samples in each test set. In this case, the data is assumed to be
identically distributed across the folds, and the loss minimized is
the total loss per sample, and not the mean loss across the folds. If
False, return the average score across folds. Default is True, but
will change to False in version 0.21, to correspond to the standard
definition of cross-validation
.. versionchanged:: 0.20
Parameter ``iid`` will change from True to False by default in
version 0.22, and will be removed in 0.24
n_iter
int
10
Number of parameter settings that are sampled. n_iter trades
off runtime vs quality of the solution
n_jobs
int or None
null
Number of jobs to run in parallel
``None`` means 1 unless in a :obj:`joblib.parallel_backend` context
``-1`` means using all processors. See :term:`Glossary <n_jobs>`
for more details
param_distributions
dict
{"bootstrap": [true, false], "criterion": ["gini", "entropy"], "max_depth": [3, null], "max_features": [1, 2, 3, 4]}
Dictionary with parameters names (string) as keys and distributions
or lists of parameters to try. Distributions must provide a ``rvs``
method for sampling (such as those from scipy.stats.distributions)
If a list is given, it is sampled uniformly
pre_dispatch
int
"2*n_jobs"
Controls the number of jobs that get dispatched during parallel
execution. Reducing this number can be useful to avoid an
explosion of memory consumption when more jobs get dispatched
than CPUs can process. This parameter can be:
- None, in which case all the jobs are immediately
created and spawned. Use this for lightweight and
fast-running jobs, to avoid delays due to on-demand
spawning of the jobs
- An int, giving the exact number of total jobs that are
spawned
- A string, giving an expression as a function of n_jobs,
as in '2*n_jobs'
random_state
int
42
Pseudo random number generator state used for random uniform sampling
from lists of possible values instead of scipy.stats distributions
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`
refit
boolean
true
Refit an estimator using the best found parameters on the whole
dataset
For multiple metric evaluation, this needs to be a string denoting the
scorer that would be used to find the best parameters for refitting
the estimator at the end
The refitted estimator is made available at the ``best_estimator_``
attribute and permits using ``predict`` directly on this
``RandomizedSearchCV`` instance
Also for multiple metric evaluation, the attributes ``best_index_``,
``best_score_`` and ``best_params_`` will only be available if
``refit`` is set and all of them will be determined w.r.t this specific
scorer
See ``scoring`` parameter to know more about multiple metric
evaluation
return_train_score
boolean
"warn"
If ``False``, the ``cv_results_`` attribute will not include training
scores
Current default is ``'warn'``, which behaves as ``True`` in addition
to raising a warning when a training score is looked up
That default will be changed to ``False`` in 0.21
Computing training scores is used to get insights on how different
parameter settings impact the overfitting/underfitting trade-off
However computing the scores on the training set can be computationally
expensive and is not strictly required to select the parameters that
yield the best generalization performance.
scoring
string
null
A single string (see :ref:`scoring_parameter`) or a callable
(see :ref:`scoring`) to evaluate the predictions on the test set
For evaluating multiple metrics, either give a list of (unique) strings
or a dict with names as keys and callables as values
NOTE that when using custom scorers, each scorer should return a single
value. Metric functions returning a list/array of values can be wrapped
into multiple scorers that return one value each
See :ref:`multimetric_grid_search` for an example
If None, the estimator's default scorer (if available) is used
verbose
integer
0
Controls the verbosity: the higher, the more messages
estimator
1227
1159
sklearn.ensemble.forest.RandomForestClassifier
sklearn.RandomForestClassifier
sklearn.ensemble.forest.RandomForestClassifier
5
openml==0.10.1,sklearn==0.20.0
A random forest classifier.
A random forest is a meta estimator that fits a number of decision tree
classifiers on various sub-samples of the dataset and uses averaging to
improve the predictive accuracy and control over-fitting.
The sub-sample size is always the same as the original
input sample size but the samples are drawn with replacement if
`bootstrap=True` (default).
2019-10-29T16:48:40
English
sklearn==0.20.0
numpy>=1.6.1
scipy>=0.9
bootstrap
boolean
true
Whether bootstrap samples are used when building trees
class_weight
dict
null
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))``
The "balanced_subsample" mode is the same as "balanced" except that
weights are computed based on the bootstrap sample for every tree
grown
For multi-output, the weights of each column of y will be multiplied
Note that these weights will be multiplied...
criterion
string
"gini"
The function to measure the quality of a split. Supported criteria are
"gini" for the Gini impurity and "entropy" for the information gain
Note: this parameter is tree-specific
max_depth
integer or None
null
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
max_features
int
"auto"
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 fraction 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)` (same as "auto")
- 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
max_leaf_nodes
int or None
null
Grow trees 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
min_impurity_decrease
float
0.0
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
min_impurity_split
float
null
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
min_samples_leaf
int
1
The minimum number of samples required to be at a leaf node
A split point at any depth will only be considered if it leaves at
least ``min_samples_leaf`` training samples in each of the left and
right branches. This may have the effect of smoothing the model,
especially in regression
- If int, then consider `min_samples_leaf` as the minimum number
- If float, then `min_samples_leaf` is a fraction and
`ceil(min_samples_leaf * n_samples)` are the minimum
number of samples for each node
.. versionchanged:: 0.18
Added float values for fractions
min_samples_split
int
2
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 fraction and
`ceil(min_samples_split * n_samples)` are the minimum
number of samples for each split
.. versionchanged:: 0.18
Added float values for fractions
min_weight_fraction_leaf
float
0.0
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
n_estimators
integer
33
The number of trees in the forest
.. versionchanged:: 0.20
The default value of ``n_estimators`` will change from 10 in
version 0.20 to 100 in version 0.22
n_jobs
int or None
null
The number of jobs to run in parallel for both `fit` and `predict`
``None`` means 1 unless in a :obj:`joblib.parallel_backend` context
``-1`` means using all processors. See :term:`Glossary <n_jobs>`
for more details
oob_score
bool
false
Whether to use out-of-bag samples to estimate
the generalization accuracy
random_state
int
null
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`
verbose
int
0
Controls the verbosity when fitting and predicting
warm_start
bool
false
When set to ``True``, reuse the solution of the previous call to fit
and add more estimators to the ensemble, otherwise, just fit a whole
new forest. See :term:`the Glossary <warm_start>`
openml-python
python
scikit-learn
sklearn
sklearn_0.20.0
openml-python
python
scikit-learn
sklearn
sklearn_0.20.0