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 tag = [

| `SparseCoder

]

type t =
  [ `BaseEstimator
  | `Object
  | `SparseCoder
  | `SparseCodingMixin
  | `TransformerMixin ]
    Obj.t

val of_pyobject : Py.Object.t -> t

val to_pyobject : [> tag ] Obj.t -> Py.Object.t

val as_transformer : t -> [ `TransformerMixin ] Obj.t

val as_estimator : t -> [ `BaseEstimator ] Obj.t

val as_sparse_coding : t -> [ `SparseCodingMixin ] Obj.t

val create : 
  ?transform_algorithm:[ `Lasso_lars | `Lasso_cd | `Lars | `Omp | `Threshold ] ->
  ?transform_n_nonzero_coefs:int ->
  ?transform_alpha:float ->
  ?split_sign:bool ->
  ?n_jobs:int ->
  ?positive_code:bool ->
  ?transform_max_iter:int ->
  dictionary:[> `ArrayLike ] Np.Obj.t ->
  unit ->
  t

Sparse coding

Finds a sparse representation of data against a fixed, precomputed dictionary.

Each row of the result is the solution to a sparse coding problem. The goal is to find a sparse array `code` such that::

X ~= code * dictionary

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

Parameters ---------- dictionary : array, n_components, n_features The dictionary atoms used for sparse coding. Lines are assumed to be normalized to unit norm.

transform_algorithm : 'lasso_lars', 'lasso_cd', 'lars', 'omp', 'threshold', default='omp' Algorithm used to transform the data: lars: uses the least angle regression method (linear_model.lars_path) lasso_lars: uses Lars to compute the Lasso solution lasso_cd: uses the coordinate descent method to compute the Lasso solution (linear_model.Lasso). lasso_lars will be faster if the estimated components are sparse. omp: uses orthogonal matching pursuit to estimate the sparse solution threshold: squashes to zero all coefficients less than alpha from the projection ``dictionary * X'``

transform_n_nonzero_coefs : int, default=0.1*n_features Number of nonzero coefficients to target in each column of the solution. This is only used by `algorithm='lars'` and `algorithm='omp'` and is overridden by `alpha` in the `omp` case.

transform_alpha : float, default=1. If `algorithm='lasso_lars'` or `algorithm='lasso_cd'`, `alpha` is the penalty applied to the L1 norm. If `algorithm='threshold'`, `alpha` is the absolute value of the threshold below which coefficients will be squashed to zero. If `algorithm='omp'`, `alpha` is the tolerance parameter: the value of the reconstruction error targeted. In this case, it overrides `n_nonzero_coefs`.

split_sign : bool, default=False Whether to split the sparse feature vector into the concatenation of its negative part and its positive part. This can improve the performance of downstream classifiers.

n_jobs : int or None, default=None 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.

positive_code : bool, default=False Whether to enforce positivity when finding the code.

.. versionadded:: 0.20

transform_max_iter : int, default=1000 Maximum number of iterations to perform if `algorithm='lasso_cd'` or `lasso_lars`.

.. versionadded:: 0.22

Attributes ---------- components_ : array, n_components, n_features The unchanged dictionary atoms

See also -------- DictionaryLearning MiniBatchDictionaryLearning SparsePCA MiniBatchSparsePCA sparse_encode

val fit : ?y:Py.Object.t -> x:Py.Object.t -> [> tag ] Obj.t -> t

Do nothing and return the estimator unchanged

This method is just there to implement the usual API and hence work in pipelines.

Parameters ---------- X : Ignored

y : Ignored

Returns ------- self : object Returns the object itself

val fit_transform : 
  ?y:[> `ArrayLike ] Np.Obj.t ->
  ?fit_params:(string * Py.Object.t) list ->
  x:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  [> `ArrayLike ] Np.Obj.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 : array-like, sparse matrix, dataframe of shape (n_samples, n_features)

y : ndarray of shape (n_samples,), default=None Target values.

**fit_params : dict Additional fit parameters.

Returns ------- X_new : ndarray array of shape (n_samples, n_features_new) Transformed array.

val get_params : ?deep:bool -> [> tag ] Obj.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 -> [> tag ] Obj.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:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  [> `ArrayLike ] Np.Obj.t

Encode the data as a sparse combination of the dictionary atoms.

Coding method is determined by the object parameter `transform_algorithm`.

Parameters ---------- X : array of shape (n_samples, n_features) Test data to be transformed, must have the same number of features as the data used to train the model.

Returns ------- X_new : array, shape (n_samples, n_components) Transformed data

val components_ : t -> [> `ArrayLike ] Np.Obj.t

Attribute components_: get value or raise Not_found if None.

val components_opt : t -> [> `ArrayLike ] Np.Obj.t option

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