package sklearn

You can search for identifiers within the package.

in-package search v0.2.0

sklearn
- Sklearn

Legend:
Library
Module
Module type
Parameter
Class
Class type

type t

val of_pyobject : Py.Object.t -> t

val to_pyobject : t -> Py.Object.t

val create : 
  ?n_components:int ->
  ?kernel:[ `Linear | `Poly | `Rbf | `Sigmoid | `Cosine | `Precomputed ] ->
  ?gamma:float ->
  ?degree:int ->
  ?coef0:float ->
  ?kernel_params:Dict.t ->
  ?alpha:int ->
  ?fit_inverse_transform:bool ->
  ?eigen_solver:[ `Auto | `Dense | `Arpack ] ->
  ?tol:float ->
  ?max_iter:int ->
  ?remove_zero_eig:bool ->
  ?random_state:int ->
  ?copy_X:bool ->
  ?n_jobs:int ->
  unit ->
  t

Kernel Principal component analysis (KPCA)

Non-linear dimensionality reduction through the use of kernels (see :ref:`metrics`).

Read more in the :ref:`User Guide <kernel_PCA>`.

Parameters ---------- n_components : int, default=None Number of components. If None, all non-zero components are kept.

gamma : float, default=1/n_features Kernel coefficient for rbf, poly and sigmoid kernels. Ignored by other kernels.

degree : int, default=3 Degree for poly kernels. Ignored by other kernels.

coef0 : float, default=1 Independent term in poly and sigmoid kernels. Ignored by other kernels.

kernel_params : mapping of string to any, default=None Parameters (keyword arguments) and values for kernel passed as callable object. Ignored by other kernels.

alpha : int, default=1.0 Hyperparameter of the ridge regression that learns the inverse transform (when fit_inverse_transform=True).

fit_inverse_transform : bool, default=False Learn the inverse transform for non-precomputed kernels. (i.e. learn to find the pre-image of a point)

eigen_solver : string 'auto'|'dense'|'arpack', default='auto' Select eigensolver to use. If n_components is much less than the number of training samples, arpack may be more efficient than the dense eigensolver.

tol : float, default=0 Convergence tolerance for arpack. If 0, optimal value will be chosen by arpack.

max_iter : int, default=None Maximum number of iterations for arpack. If None, optimal value will be chosen by arpack.

remove_zero_eig : boolean, default=False If True, then all components with zero eigenvalues are removed, so that the number of components in the output may be < n_components (and sometimes even zero due to numerical instability). When n_components is None, this parameter is ignored and components with zero eigenvalues are removed regardless.

random_state : int, RandomState instance or None, optional (default=None) 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`. Used when ``eigen_solver`` == 'arpack'.

.. versionadded:: 0.18

copy_X : boolean, default=True If True, input X is copied and stored by the model in the `X_fit_` attribute. If no further changes will be done to X, setting `copy_X=False` saves memory by storing a reference.

.. versionadded:: 0.18

n_jobs : int or None, optional (default=None) The number of parallel jobs to run. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary <n_jobs>` for more details.

.. versionadded:: 0.18

Attributes ---------- lambdas_ : array, (n_components,) Eigenvalues of the centered kernel matrix in decreasing order. If `n_components` and `remove_zero_eig` are not set, then all values are stored.

alphas_ : array, (n_samples, n_components) Eigenvectors of the centered kernel matrix. If `n_components` and `remove_zero_eig` are not set, then all components are stored.

dual_coef_ : array, (n_samples, n_features) Inverse transform matrix. Only available when ``fit_inverse_transform`` is True.

X_transformed_fit_ : array, (n_samples, n_components) Projection of the fitted data on the kernel principal components. Only available when ``fit_inverse_transform`` is True.

X_fit_ : (n_samples, n_features) The data used to fit the model. If `copy_X=False`, then `X_fit_` is a reference. This attribute is used for the calls to transform.

Examples -------- >>> from sklearn.datasets import load_digits >>> from sklearn.decomposition import KernelPCA >>> X, _ = load_digits(return_X_y=True) >>> transformer = KernelPCA(n_components=7, kernel='linear') >>> X_transformed = transformer.fit_transform(X) >>> X_transformed.shape (1797, 7)

References ---------- Kernel PCA was introduced in: Bernhard Schoelkopf, Alexander J. Smola, and Klaus-Robert Mueller. 1999. Kernel principal component analysis. In Advances in kernel methods, MIT Press, Cambridge, MA, USA 327-352.

val fit : ?y:Py.Object.t -> x:Arr.t -> t -> t

Fit the model from data in X.

Parameters ---------- X : array-like, shape (n_samples, n_features) Training vector, where n_samples in the number of samples and n_features is the number of features.

Returns ------- self : object Returns the instance itself.

val fit_transform : 
  ?y:Py.Object.t ->
  ?params:(string * Py.Object.t) list ->
  x:Arr.t ->
  t ->
  Arr.t

Fit the model from data in X and transform X.

Parameters ---------- X : array-like, shape (n_samples, n_features) Training vector, where n_samples in the number of samples and n_features is the number of features.

Returns ------- X_new : array-like, shape (n_samples, n_components)

val get_params : ?deep:bool -> t -> Dict.t

Get parameters for this estimator.

Parameters ---------- deep : bool, default=True If True, will return the parameters for this estimator and contained subobjects that are estimators.

Returns ------- params : mapping of string to any Parameter names mapped to their values.

val inverse_transform : x:Arr.t -> t -> Arr.t

Transform X back to original space.

Parameters ---------- X : array-like, shape (n_samples, n_components)

Returns ------- X_new : array-like, shape (n_samples, n_features)

References ---------- "Learning to Find Pre-Images", G BakIr et al, 2004.

val set_params : ?params:(string * Py.Object.t) list -> t -> t

Set the parameters of this estimator.

The method works on simple estimators as well as on nested objects (such as pipelines). The latter have parameters of the form ``<component>__<parameter>`` so that it's possible to update each component of a nested object.

Parameters ---------- **params : dict Estimator parameters.

Returns ------- self : object Estimator instance.

val transform : x:Arr.t -> t -> Arr.t

Transform X.

Parameters ---------- X : array-like, shape (n_samples, n_features)

Returns ------- X_new : array-like, shape (n_samples, n_components)

val lambdas_ : t -> Py.Object.t

Attribute lambdas_: get value or raise Not_found if None.

val lambdas_opt : t -> Py.Object.t option

Attribute lambdas_: get value as an option.

val alphas_ : t -> Py.Object.t

Attribute alphas_: get value or raise Not_found if None.

val alphas_opt : t -> Py.Object.t option

Attribute alphas_: get value as an option.

val dual_coef_ : t -> Py.Object.t

Attribute dual_coef_: get value or raise Not_found if None.

val dual_coef_opt : t -> Py.Object.t option

Attribute dual_coef_: get value as an option.

val x_transformed_fit_ : t -> Py.Object.t

Attribute X_transformed_fit_: get value or raise Not_found if None.

val x_transformed_fit_opt : t -> Py.Object.t option

Attribute X_transformed_fit_: get value as an option.

val x_fit_ : t -> Py.Object.t

Attribute X_fit_: get value or raise Not_found if None.

val x_fit_opt : t -> Py.Object.t option

Attribute X_fit_: get value as an option.

val to_string : t -> string

Print the object to a human-readable representation.

val show : t -> string

Print the object to a human-readable representation.

val pp : Format.formatter -> t -> unit

Pretty-print the object to a formatter.