18434
12269
sklearn.pipeline.Pipeline(step_0=automl.components.feature_preprocessing.one_hot_encoding.OneHotEncoderComponent,step_1=sklearn.preprocessing._data.RobustScaler,step_2=sklearn.svm._classes.SVC)
sklearn.Pipeline(OneHotEncoderComponent,RobustScaler,SVC)
sklearn.pipeline.Pipeline
1
automl==0.0.1,openml==0.10.2,sklearn==0.22.1
Pipeline of transforms with a final estimator.
Sequentially apply a list of transforms and a final estimator.
Intermediate steps of the pipeline must be 'transforms', that is, they
must implement fit and transform methods.
The final estimator only needs to implement fit.
The transformers in the pipeline can be cached using ``memory`` argument.
The purpose of the pipeline is to assemble several steps that can be
cross-validated together while setting different parameters.
For this, it enables setting parameters of the various steps using their
names and the parameter name separated by a '__', as in the example below.
A step's estimator may be replaced entirely by setting the parameter
with its name to another estimator, or a transformer removed by setting
it to 'passthrough' or ``None``.
2020-05-20T18:40:19
English
sklearn==0.22.1
numpy>=1.6.1
scipy>=0.9
memory
None
null
Used to cache the fitted transformers of the pipeline. By default,
no caching is performed. If a string is given, it is the path to
the caching directory. Enabling caching triggers a clone of
the transformers before fitting. Therefore, the transformer
instance given to the pipeline cannot be inspected
directly. Use the attribute ``named_steps`` or ``steps`` to
inspect estimators within the pipeline. Caching the
transformers is advantageous when fitting is time consuming
steps
list
[{"oml-python:serialized_object": "component_reference", "value": {"key": "step_0", "step_name": "step_0"}}, {"oml-python:serialized_object": "component_reference", "value": {"key": "step_1", "step_name": "step_1"}}, {"oml-python:serialized_object": "component_reference", "value": {"key": "step_2", "step_name": "step_2"}}]
List of (name, transform) tuples (implementing fit/transform) that are
chained, in the order in which they are chained, with the last object
an estimator
verbose
bool
false
If True, the time elapsed while fitting each step will be printed as it
is completed.
step_2
17707
12269
sklearn.svm._classes.SVC
sklearn.SVC
sklearn.svm._classes.SVC
4
openml==0.10.2,sklearn==0.22.1
C-Support Vector Classification.
The implementation is based on libsvm. The fit time scales at least
quadratically with the number of samples and may be impractical
beyond tens of thousands of samples. For large datasets
consider using :class:`sklearn.svm.LinearSVC` or
:class:`sklearn.linear_model.SGDClassifier` instead, possibly after a
:class:`sklearn.kernel_approximation.Nystroem` transformer.
The multiclass support is handled according to a one-vs-one scheme.
For details on the precise mathematical formulation of the provided
kernel functions and how `gamma`, `coef0` and `degree` affect each
other, see the corresponding section in the narrative documentation:
:ref:`svm_kernels`.
2020-05-18T19:46:42
English
sklearn==0.22.1
numpy>=1.6.1
scipy>=0.9
C
float
4.3827607743865347e-07
Regularization parameter. The strength of the regularization is
inversely proportional to C. Must be strictly positive. The penalty
is a squared l2 penalty
break_ties
bool
false
If true, ``decision_function_shape='ovr'``, and number of classes > 2,
:term:`predict` will break ties according to the confidence values of
:term:`decision_function`; otherwise the first class among the tied
classes is returned. Please note that breaking ties comes at a
relatively high computational cost compared to a simple predict
.. versionadded:: 0.22
cache_size
float
200
Specify the size of the kernel cache (in MB)
class_weight : {dict, 'balanced'}, optional
Set the parameter C of class i to class_weight[i]*C for
SVC. If not given, all classes are supposed to have
weight one
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))``
class_weight
null
coef0
float
-15.332261879793727
Independent term in kernel function
It is only significant in 'poly' and 'sigmoid'
decision_function_shape
'ovo'
"ovr"
Whether to return a one-vs-rest ('ovr') decision function of shape
(n_samples, n_classes) as all other classifiers, or the original
one-vs-one ('ovo') decision function of libsvm which has shape
(n_samples, n_classes * (n_classes - 1) / 2). However, one-vs-one
('ovo') is always used as multi-class strategy
.. versionchanged:: 0.19
decision_function_shape is 'ovr' by default
.. versionadded:: 0.17
*decision_function_shape='ovr'* is recommended
.. versionchanged:: 0.17
Deprecated *decision_function_shape='ovo' and None*
degree
int
3
Degree of the polynomial kernel function ('poly')
Ignored by all other kernels
gamma : {'scale', 'auto'} or float, optional (default='scale')
Kernel coefficient for 'rbf', 'poly' and 'sigmoid'
- if ``gamma='scale'`` (default) is passed then it uses
1 / (n_features * X.var()) as value of gamma,
- if 'auto', uses 1 / n_features
.. versionchanged:: 0.22
The default value of ``gamma`` changed from 'auto' to 'scale'
gamma
0.0010017639673572045
kernel
string
"sigmoid"
Specifies the kernel type to be used in the algorithm
It must be one of 'linear', 'poly', 'rbf', 'sigmoid', 'precomputed' or
a callable
If none is given, 'rbf' will be used. If a callable is given it is
used to pre-compute the kernel matrix from data matrices; that matrix
should be an array of shape ``(n_samples, n_samples)``
max_iter
int
-1
Hard limit on iterations within solver, or -1 for no limit
probability
boolean
true
Whether to enable probability estimates. This must be enabled prior
to calling `fit`, will slow down that method as it internally uses
5-fold cross-validation, and `predict_proba` may be inconsistent with
`predict`. Read more in the :ref:`User Guide <scores_probabilities>`
random_state
int
42
The seed of the pseudo random number generator used when shuffling
the data for probability estimates. 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`.
shrinking
boolean
false
Whether to use the shrinking heuristic
tol
float
0.00013562683316384962
Tolerance for stopping criterion
verbose
bool
false
Enable verbose output. Note that this setting takes advantage of a
per-process runtime setting in libsvm that, if enabled, may not work
properly in a multithreaded context
openml-python
python
scikit-learn
sklearn
sklearn_0.22.1
step_0
17714
12269
automl.components.feature_preprocessing.one_hot_encoding.OneHotEncoderComponent
automl.OneHotEncoderComponent
automl.components.feature_preprocessing.one_hot_encoding.OneHotEncoderComponent
1
automl==0.0.1,openml==0.10.2,sklearn==0.22.1
OneHotEncoderComponent
A OneHotEncoder that can handle missing values and multiple categorical columns.
2020-05-18T21:55:11
English
sklearn==0.22.1
numpy>=1.6.1
scipy>=0.9
openml-python
python
scikit-learn
sklearn
sklearn_0.22.1
step_1
17867
12269
sklearn.preprocessing._data.RobustScaler
sklearn.RobustScaler
sklearn.preprocessing._data.RobustScaler
1
openml==0.10.2,sklearn==0.22.1
Scale features using statistics that are robust to outliers.
This Scaler removes the median and scales the data according to
the quantile range (defaults to IQR: Interquartile Range).
The IQR is the range between the 1st quartile (25th quantile)
and the 3rd quartile (75th quantile).
Centering and scaling happen independently on each feature by
computing the relevant statistics on the samples in the training
set. Median and interquartile range are then stored to be used on
later data using the ``transform`` method.
Standardization of a dataset is a common requirement for many
machine learning estimators. Typically this is done by removing the mean
and scaling to unit variance. However, outliers can often influence the
sample mean / variance in a negative way. In such cases, the median and
the interquartile range often give better results.
.. versionadded:: 0.17
2020-05-19T03:27:31
English
sklearn==0.22.1
numpy>=1.6.1
scipy>=0.9
copy
boolean
false
If False, try to avoid a copy and do inplace scaling instead
This is not guaranteed to always work inplace; e.g. if the data is
not a NumPy array or scipy.sparse CSR matrix, a copy may still be
returned.
quantile_range
tuple
[24.275836142495244, 92.52607450557818]
Default: (25.0, 75.0) = (1st quantile, 3rd quantile) = IQR
Quantile range used to calculate ``scale_``
.. versionadded:: 0.18
with_centering
boolean
false
If True, center the data before scaling
This will cause ``transform`` to raise an exception when attempted on
sparse matrices, because centering them entails building a dense
matrix which in common use cases is likely to be too large to fit in
memory
with_scaling
boolean
true
If True, scale the data to interquartile range
openml-python
python
scikit-learn
sklearn
sklearn_0.22.1
openml-python
python
scikit-learn
sklearn
sklearn_0.22.1