18490
12269
sklearn.pipeline.Pipeline(step_0=sklearn.impute._base.MissingIndicator,step_1=sklearn.decomposition._factor_analysis.FactorAnalysis,step_2=sklearn.svm._classes.SVC)
sklearn.Pipeline(MissingIndicator,FactorAnalysis,SVC)
sklearn.pipeline.Pipeline
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-21T08:20:28
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_1
17734
12269
sklearn.decomposition._factor_analysis.FactorAnalysis
sklearn.FactorAnalysis
sklearn.decomposition._factor_analysis.FactorAnalysis
1
openml==0.10.2,sklearn==0.22.1
Factor Analysis (FA)
A simple linear generative model with Gaussian latent variables.
The observations are assumed to be caused by a linear transformation of
lower dimensional latent factors and added Gaussian noise.
Without loss of generality the factors are distributed according to a
Gaussian with zero mean and unit covariance. The noise is also zero mean
and has an arbitrary diagonal covariance matrix.
If we would restrict the model further, by assuming that the Gaussian
noise is even isotropic (all diagonal entries are the same) we would obtain
:class:`PPCA`.
FactorAnalysis performs a maximum likelihood estimate of the so-called
`loading` matrix, the transformation of the latent variables to the
observed ones, using SVD based approach.
2020-05-18T23:44:12
English
sklearn==0.22.1
numpy>=1.6.1
scipy>=0.9
copy
bool
false
Whether to make a copy of X. If ``False``, the input X gets overwritten
during fitting
iterated_power
int
3
Number of iterations for the power method. 3 by default. Only used
if ``svd_method`` equals 'randomized'
max_iter
int
7723
Maximum number of iterations
n_components
int
3
Dimensionality of latent space, the number of components
of ``X`` that are obtained after ``transform``
If None, n_components is set to the number of features
noise_variance_init
None
null
The initial guess of the noise variance for each feature
If None, it defaults to np.ones(n_features)
svd_method : {'lapack', 'randomized'}
Which SVD method to use. If 'lapack' use standard SVD from
scipy.linalg, if 'randomized' use fast ``randomized_svd`` function
Defaults to 'randomized'. For most applications 'randomized' will
be sufficiently precise while providing significant speed gains
Accuracy can also be improved by setting higher values for
`iterated_power`. If this is not sufficient, for maximum precision
you should choose 'lapack'
random_state
int
42
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`. Only used when ``svd_method`` equals 'randomized'.
svd_method
"lapack"
tol
float
1.841563435236402
Stopping tolerance for log-likelihood increase
openml-python
python
scikit-learn
sklearn
sklearn_0.22.1
step_0
18449
12269
sklearn.impute._base.MissingIndicator
sklearn.MissingIndicator
sklearn.impute._base.MissingIndicator
1
openml==0.10.2,sklearn==0.22.1
Binary indicators for missing values.
Note that this component typically should not be used in a vanilla
:class:`Pipeline` consisting of transformers and a classifier, but rather
could be added using a :class:`FeatureUnion` or :class:`ColumnTransformer`.
2020-05-21T07:48:00
English
sklearn==0.22.1
numpy>=1.6.1
scipy>=0.9
error_on_new
boolean
true
If True (default), transform will raise an error when there are
features with missing values in transform that have no missing values
in fit. This is applicable only when ``features="missing-only"``.
features
str
"all"
Whether the imputer mask should represent all or a subset of
features
- If "missing-only" (default), the imputer mask will only represent
features containing missing values during fit time
- If "all", the imputer mask will represent all features
missing_values
number
NaN
The placeholder for the missing values. All occurrences of
`missing_values` will be indicated (True in the output array), the
other values will be marked as False
sparse
boolean or
"auto"
Whether the imputer mask format should be sparse or dense
- If "auto" (default), the imputer mask will be of same type as
input
- If True, the imputer mask will be a sparse matrix
- If False, the imputer mask will be a numpy array
openml-python
python
scikit-learn
sklearn
sklearn_0.22.1
openml-python
python
scikit-learn
sklearn
sklearn_0.22.1