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 : 
  ?kernel:[ `S of string | `Callable of Py.Object.t ] ->
  ?gamma:float ->
  ?coef0:float ->
  ?degree:float ->
  ?kernel_params:Dict.t ->
  ?n_components:int ->
  ?random_state:int ->
  unit ->
  t

Approximate a kernel map using a subset of the training data.

Constructs an approximate feature map for an arbitrary kernel using a subset of the data as basis.

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

.. versionadded:: 0.13

Parameters ---------- kernel : string or callable, default="rbf" Kernel map to be approximated. A callable should accept two arguments and the keyword arguments passed to this object as kernel_params, and should return a floating point number.

gamma : float, default=None Gamma parameter for the RBF, laplacian, polynomial, exponential chi2 and sigmoid kernels. Interpretation of the default value is left to the kernel; see the documentation for sklearn.metrics.pairwise. Ignored by other kernels.

coef0 : float, default=None Zero coefficient for polynomial and sigmoid kernels. Ignored by other kernels.

degree : float, default=None Degree of the polynomial kernel. Ignored by other kernels.

kernel_params : mapping of string to any, optional Additional parameters (keyword arguments) for kernel function passed as callable object.

n_components : int Number of features to construct. How many data points will be used to construct the mapping.

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`.

Attributes ---------- components_ : array, shape (n_components, n_features) Subset of training points used to construct the feature map.

component_indices_ : array, shape (n_components) Indices of ``components_`` in the training set.

normalization_ : array, shape (n_components, n_components) Normalization matrix needed for embedding. Square root of the kernel matrix on ``components_``.

Examples -------- >>> from sklearn import datasets, svm >>> from sklearn.kernel_approximation import Nystroem >>> X, y = datasets.load_digits(n_class=9, return_X_y=True) >>> data = X / 16. >>> clf = svm.LinearSVC() >>> feature_map_nystroem = Nystroem(gamma=.2, ... random_state=1, ... n_components=300) >>> data_transformed = feature_map_nystroem.fit_transform(data) >>> clf.fit(data_transformed, y) LinearSVC() >>> clf.score(data_transformed, y) 0.9987...

References ---------- * Williams, C.K.I. and Seeger, M. "Using the Nystroem method to speed up kernel machines", Advances in neural information processing systems 2001

* T. Yang, Y. Li, M. Mahdavi, R. Jin and Z. Zhou "Nystroem Method vs Random Fourier Features: A Theoretical and Empirical Comparison", Advances in Neural Information Processing Systems 2012

See also -------- RBFSampler : An approximation to the RBF kernel using random Fourier features.

sklearn.metrics.pairwise.kernel_metrics : List of built-in kernels.

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

Fit estimator to data.

Samples a subset of training points, computes kernel on these and computes normalization matrix.

Parameters ---------- X : array-like of shape (n_samples, n_features) Training data.

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

Fit to data, then transform it.

Fits transformer to X and y with optional parameters fit_params and returns a transformed version of X.

Parameters ---------- X : numpy array of shape n_samples, n_features Training set.

y : numpy array of shape n_samples Target values.

**fit_params : dict Additional fit parameters.

Returns ------- X_new : numpy array of shape n_samples, n_features_new Transformed array.

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 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

Apply feature map to X.

Computes an approximate feature map using the kernel between some training points and X.

Parameters ---------- X : array-like of shape (n_samples, n_features) Data to transform.

Returns ------- X_transformed : array, shape=(n_samples, n_components) Transformed data.

val components_ : t -> Arr.t

Attribute components_: get value or raise Not_found if None.

val components_opt : t -> Arr.t option

Attribute components_: get value as an option.

val component_indices_ : t -> Arr.t

Attribute component_indices_: get value or raise Not_found if None.

val component_indices_opt : t -> Arr.t option

Attribute component_indices_: get value as an option.

val normalization_ : t -> Arr.t

Attribute normalization_: get value or raise Not_found if None.

val normalization_opt : t -> Arr.t option

Attribute normalization_: 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.