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

| `OneClassSVM

]

type t =
  [ `BaseEstimator | `BaseLibSVM | `Object | `OneClassSVM | `OutlierMixin ]
    Obj.t

val of_pyobject : Py.Object.t -> t

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

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

val as_lib_svm : t -> [ `BaseLibSVM ] Obj.t

val as_outlier : t -> [ `OutlierMixin ] Obj.t

val create : 
  ?kernel:[ `Linear | `Poly | `Rbf | `Sigmoid | `Precomputed ] ->
  ?degree:int ->
  ?gamma:[ `Scale | `Auto | `F of float ] ->
  ?coef0:float ->
  ?tol:float ->
  ?nu:float ->
  ?shrinking:bool ->
  ?cache_size:float ->
  ?verbose:int ->
  ?max_iter:int ->
  unit ->
  t

Unsupervised Outlier Detection.

Estimate the support of a high-dimensional distribution.

The implementation is based on libsvm.

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

Parameters ---------- kernel : 'linear', 'poly', 'rbf', 'sigmoid', 'precomputed', default='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 precompute the kernel matrix.

degree : int, default=3 Degree of the polynomial kernel function ('poly'). Ignored by all other kernels.

gamma : 'scale', 'auto' or float, 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'.

coef0 : float, default=0.0 Independent term in kernel function. It is only significant in 'poly' and 'sigmoid'.

tol : float, default=1e-3 Tolerance for stopping criterion.

nu : float, default=0.5 An upper bound on the fraction of training errors and a lower bound of the fraction of support vectors. Should be in the interval (0, 1]. By default 0.5 will be taken.

shrinking : bool, default=True Whether to use the shrinking heuristic. See the :ref:`User Guide <shrinking_svm>`.

cache_size : float, default=200 Specify the size of the kernel cache (in MB).

verbose : bool, default=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.

max_iter : int, default=-1 Hard limit on iterations within solver, or -1 for no limit.

Attributes ---------- support_ : ndarray of shape (n_SV,) Indices of support vectors.

support_vectors_ : ndarray of shape (n_SV, n_features) Support vectors.

dual_coef_ : ndarray of shape (1, n_SV) Coefficients of the support vectors in the decision function.

coef_ : ndarray of shape (1, n_features) Weights assigned to the features (coefficients in the primal problem). This is only available in the case of a linear kernel.

`coef_` is readonly property derived from `dual_coef_` and `support_vectors_`

intercept_ : ndarray of shape (1,) Constant in the decision function.

offset_ : float Offset used to define the decision function from the raw scores. We have the relation: decision_function = score_samples - `offset_`. The offset is the opposite of `intercept_` and is provided for consistency with other outlier detection algorithms.

.. versionadded:: 0.20

fit_status_ : int 0 if correctly fitted, 1 otherwise (will raise warning)

Examples -------- >>> from sklearn.svm import OneClassSVM >>> X = [0], [0.44], [0.45], [0.46], [1] >>> clf = OneClassSVM(gamma='auto').fit(X) >>> clf.predict(X) array(-1, 1, 1, 1, -1) >>> clf.score_samples(X) array(1.7798..., 2.0547..., 2.0556..., 2.0561..., 1.7332...)

val decision_function : 
  x:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  [> `ArrayLike ] Np.Obj.t

Signed distance to the separating hyperplane.

Signed distance is positive for an inlier and negative for an outlier.

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

Returns ------- dec : ndarray of shape (n_samples,) Returns the decision function of the samples.

val fit : 
  ?y:Py.Object.t ->
  ?sample_weight:[> `ArrayLike ] Np.Obj.t ->
  ?params:(string * Py.Object.t) list ->
  x:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  t

Detects the soft boundary of the set of samples X.

Parameters ---------- X : array-like, sparse matrix of shape (n_samples, n_features) Set of samples, where n_samples is the number of samples and n_features is the number of features.

sample_weight : array-like of shape (n_samples,), default=None Per-sample weights. Rescale C per sample. Higher weights force the classifier to put more emphasis on these points.

y : Ignored not used, present for API consistency by convention.

Returns ------- self : object

Notes ----- If X is not a C-ordered contiguous array it is copied.

val fit_predict : 
  ?y:Py.Object.t ->
  x:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  [> `ArrayLike ] Np.Obj.t

Perform fit on X and returns labels for X.

Returns -1 for outliers and 1 for inliers.

Parameters ---------- X : array-like, sparse matrix, dataframe of shape (n_samples, n_features)

y : Ignored Not used, present for API consistency by convention.

Returns ------- y : ndarray of shape (n_samples,) 1 for inliers, -1 for outliers.

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 predict : 
  x:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  [> `ArrayLike ] Np.Obj.t

Perform classification on samples in X.

For a one-class model, +1 or -1 is returned.

Parameters ---------- X : array-like, sparse matrix of shape (n_samples, n_features) or (n_samples_test, n_samples_train) For kernel='precomputed', the expected shape of X is (n_samples_test, n_samples_train).

Returns ------- y_pred : ndarray of shape (n_samples,) Class labels for samples in X.

val score_samples : 
  x:[> `ArrayLike ] Np.Obj.t ->
  [> tag ] Obj.t ->
  [> `ArrayLike ] Np.Obj.t

Raw scoring function of the samples.

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

Returns ------- score_samples : ndarray of shape (n_samples,) Returns the (unshifted) scoring function of the samples.

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 support_ : t -> [> `ArrayLike ] Np.Obj.t

Attribute support_: get value or raise Not_found if None.

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

Attribute support_: get value as an option.

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

Attribute support_vectors_: get value or raise Not_found if None.

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

Attribute support_vectors_: get value as an option.

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

Attribute dual_coef_: get value or raise Not_found if None.

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

Attribute dual_coef_: get value as an option.

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

Attribute coef_: get value or raise Not_found if None.

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

Attribute coef_: get value as an option.

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

Attribute intercept_: get value or raise Not_found if None.

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

Attribute intercept_: get value as an option.

val offset_ : t -> float

Attribute offset_: get value or raise Not_found if None.

val offset_opt : t -> float option

Attribute offset_: get value as an option.

val fit_status_ : t -> int

Attribute fit_status_: get value or raise Not_found if None.

val fit_status_opt : t -> int option

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