81100
1159
sklearn.pipeline.Pipeline(columntransformer=sklearn.compose._column_transformer.ColumnTransformer(num=sklearn.preprocessing.data.StandardScaler,cat=sklearn.preprocessing._encoders.OneHotEncoder),svc=sklearn.svm.classes.SVC)
sklearn.Pipeline(ColumnTransformer,SVC)
sklearn.pipeline.Pipeline
4
openml==0.12.0,sklearn==0.21.2
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``.
2021-03-29T13:39:37
English
sklearn==0.21.2
numpy>=1.11.0
scipy>=0.17.0
joblib>=0.11
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": "columntransformer", "step_name": "columntransformer"}}, {"oml-python:serialized_object": "component_reference", "value": {"key": "svc", "step_name": "svc"}}]
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
boolean
false
If True, the time elapsed while fitting each step will be printed as it
is completed.
columntransformer
81101
1159
sklearn.compose._column_transformer.ColumnTransformer(num=sklearn.preprocessing.data.StandardScaler,cat=sklearn.preprocessing._encoders.OneHotEncoder)
sklearn.ColumnTransformer
sklearn.compose._column_transformer.ColumnTransformer
4
openml==0.12.0,sklearn==0.21.2
Applies transformers to columns of an array or pandas DataFrame.
This estimator allows different columns or column subsets of the input
to be transformed separately and the features generated by each transformer
will be concatenated to form a single feature space.
This is useful for heterogeneous or columnar data, to combine several
feature extraction mechanisms or transformations into a single transformer.
2021-03-29T13:39:37
English
sklearn==0.21.2
numpy>=1.11.0
scipy>=0.17.0
joblib>=0.11
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
remainder
"drop"
sparse_threshold
float
0.3
If the output of the different transformers contains sparse matrices,
these will be stacked as a sparse matrix if the overall density is
lower than this value. Use ``sparse_threshold=0`` to always return
dense. When the transformed output consists of all dense data, the
stacked result will be dense, and this keyword will be ignored
transformer_weights
dict
null
Multiplicative weights for features per transformer. The output of the
transformer is multiplied by these weights. Keys are transformer names,
values the weights
transformers
list of tuples
[{"oml-python:serialized_object": "component_reference", "value": {"key": "num", "step_name": "num", "argument_1": {"oml-python:serialized_object": "function", "value": "openml.extensions.sklearn.cont"}}}, {"oml-python:serialized_object": "component_reference", "value": {"key": "cat", "step_name": "cat", "argument_1": {"oml-python:serialized_object": "function", "value": "openml.extensions.sklearn.cat"}}}]
List of (name, transformer, column(s)) tuples specifying the
transformer objects to be applied to subsets of the data
verbose
boolean
false
If True, the time elapsed while fitting each transformer will be
printed as it is completed.
num
81092
1159
sklearn.preprocessing.data.StandardScaler
sklearn.StandardScaler
sklearn.preprocessing.data.StandardScaler
10
openml==0.12.0,sklearn==0.21.2
Standardize features by removing the mean and scaling to unit variance
The standard score of a sample `x` is calculated as:
z = (x - u) / s
where `u` is the mean of the training samples or zero if `with_mean=False`,
and `s` is the standard deviation of the training samples or one if
`with_std=False`.
Centering and scaling happen independently on each feature by computing
the relevant statistics on the samples in the training set. Mean and
standard deviation 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: they might behave badly if the
individual features do not more or less look like standard normally
distributed data (e.g. Gaussian with 0 mean and unit variance).
For instance many elements used in the objective function of
a learning algorithm (such as the RBF kernel of Support Vector
Machines or the L1 and L2 regularizers of linear models) assume that
all features are centered aroun...
2021-03-29T13:38:50
English
sklearn==0.21.2
numpy>=1.11.0
scipy>=0.17.0
joblib>=0.11
copy
boolean
true
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
with_mean
boolean
false
If True, center the data before scaling
This does not work (and will 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_std
boolean
true
If True, scale the data to unit variance (or equivalently,
unit standard deviation).
openml-python
python
scikit-learn
sklearn
sklearn_0.21.2
cat
81102
1159
sklearn.preprocessing._encoders.OneHotEncoder
sklearn.OneHotEncoder
sklearn.preprocessing._encoders.OneHotEncoder
16
openml==0.12.0,sklearn==0.21.2
Encode categorical integer features as a one-hot numeric array.
The input to this transformer should be an array-like of integers or
strings, denoting the values taken on by categorical (discrete) features.
The features are encoded using a one-hot (aka 'one-of-K' or 'dummy')
encoding scheme. This creates a binary column for each category and
returns a sparse matrix or dense array.
By default, the encoder derives the categories based on the unique values
in each feature. Alternatively, you can also specify the `categories`
manually.
The OneHotEncoder previously assumed that the input features take on
values in the range [0, max(values)). This behaviour is deprecated.
This encoding is needed for feeding categorical data to many scikit-learn
estimators, notably linear models and SVMs with the standard kernels.
Note: a one-hot encoding of y labels should use a LabelBinarizer
instead.
2021-03-29T13:39:37
English
sklearn==0.21.2
numpy>=1.11.0
scipy>=0.17.0
joblib>=0.11
categorical_features
'all' or array of indices or mask
null
Specify what features are treated as categorical
- 'all': All features are treated as categorical
- array of indices: Array of categorical feature indices
- mask: Array of length n_features and with dtype=bool
Non-categorical features are always stacked to the right of the matrix
.. deprecated:: 0.20
The `categorical_features` keyword was deprecated in version
0.20 and will be removed in 0.22
You can use the ``ColumnTransformer`` instead.
categories
'auto' or a list of lists
null
Categories (unique values) per feature:
- 'auto' : Determine categories automatically from the training data
- list : ``categories[i]`` holds the categories expected in the ith
column. The passed categories should not mix strings and numeric
values within a single feature, and should be sorted in case of
numeric values
The used categories can be found in the ``categories_`` attribute
drop
'first' or a list
null
Specifies a methodology to use to drop one of the categories per
feature. This is useful in situations where perfectly collinear
features cause problems, such as when feeding the resulting data
into a neural network or an unregularized regression
dtype
number type
{"oml-python:serialized_object": "type", "value": "np.float64"}
Desired dtype of output
handle_unknown
'error' or
"ignore"
Whether to raise an error or ignore if an unknown categorical feature
is present during transform (default is to raise). When this parameter
is set to 'ignore' and an unknown category is encountered during
transform, the resulting one-hot encoded columns for this feature
will be all zeros. In the inverse transform, an unknown category
will be denoted as None
n_values
'auto'
null
Number of values per feature
- 'auto' : determine value range from training data
sparse
boolean
true
Will return sparse matrix if set True else will return an array
openml-python
python
scikit-learn
sklearn
sklearn_0.21.2
openml-python
python
scikit-learn
sklearn
sklearn_0.21.2
svc
81103
1159
sklearn.svm.classes.SVC
sklearn.SVC
sklearn.svm.classes.SVC
4
openml==0.12.0,sklearn==0.21.2
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.linear_model.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`.
2021-03-29T13:39:37
English
sklearn==0.21.2
numpy>=1.11.0
scipy>=0.17.0
joblib>=0.11
C
float
1.0
Penalty parameter C of the error term
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
0.0
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
float
"scale"
Kernel coefficient for 'rbf', 'poly' and 'sigmoid'
Current default is 'auto' which uses 1 / n_features,
if ``gamma='scale'`` is passed then it uses 1 / (n_features * X.var())
as value of gamma. The current default of gamma, 'auto', will change
to 'scale' in version 0.22. 'auto_deprecated', a deprecated version of
'auto' is used as a default indicating that no explicit value of gamma
was passed
kernel
string
"rbf"
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
false
Whether to enable probability estimates. This must be enabled prior
to calling `fit`, and will slow down that method
random_state
int
1
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
true
Whether to use the shrinking heuristic
tol
float
0.001
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.21.2
openml-python
python
scikit-learn
sklearn
sklearn_0.21.2