package sklearn

  1. Overview
  2. Docs
Legend:
Library
Module
Module type
Parameter
Class
Class type
type tag = [
  1. | `GraphicalLassoCV
]
type t = [ `BaseEstimator | `GraphicalLassoCV | `Object ] 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 create : ?alphas:Py.Object.t -> ?n_refinements:int -> ?cv: [ `BaseCrossValidator of [> `BaseCrossValidator ] Np.Obj.t | `Arr of [> `ArrayLike ] Np.Obj.t | `I of int ] -> ?tol:float -> ?enet_tol:float -> ?max_iter:int -> ?mode:[ `Cd | `Lars ] -> ?n_jobs:int -> ?verbose:int -> ?assume_centered:bool -> unit -> t

Sparse inverse covariance w/ cross-validated choice of the l1 penalty.

See glossary entry for :term:`cross-validation estimator`.

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

.. versionchanged:: v0.20 GraphLassoCV has been renamed to GraphicalLassoCV

Parameters ---------- alphas : int or array-like of shape (n_alphas,), dtype=float, default=4 If an integer is given, it fixes the number of points on the grids of alpha to be used. If a list is given, it gives the grid to be used. See the notes in the class docstring for more details. Range is (0, inf] when floats given.

n_refinements : int, default=4 The number of times the grid is refined. Not used if explicit values of alphas are passed. Range is 1, inf). cv : int, cross-validation generator or iterable, default=None Determines the cross-validation splitting strategy. Possible inputs for cv are: - None, to use the default 5-fold cross-validation, - integer, to specify the number of folds. - :term:`CV splitter`, - An iterable yielding (train, test) splits as arrays of indices. For integer/None inputs :class:`KFold` is used. Refer :ref:`User Guide <cross_validation>` for the various cross-validation strategies that can be used here. .. versionchanged:: 0.20 ``cv`` default value if None changed from 3-fold to 5-fold. tol : float, default=1e-4 The tolerance to declare convergence: if the dual gap goes below this value, iterations are stopped. Range is (0, inf.

enet_tol : float, default=1e-4 The tolerance for the elastic net solver used to calculate the descent direction. This parameter controls the accuracy of the search direction for a given column update, not of the overall parameter estimate. Only used for mode='cd'. Range is (0, inf].

max_iter : int, default=100 Maximum number of iterations.

mode : 'cd', 'lars', default='cd' The Lasso solver to use: coordinate descent or LARS. Use LARS for very sparse underlying graphs, where number of features is greater than number of samples. Elsewhere prefer cd which is more numerically stable.

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

.. versionchanged:: v0.20 `n_jobs` default changed from 1 to None

verbose : bool, default=False If verbose is True, the objective function and duality gap are printed at each iteration.

assume_centered : bool, default=False If True, data are not centered before computation. Useful when working with data whose mean is almost, but not exactly zero. If False, data are centered before computation.

Attributes ---------- location_ : ndarray of shape (n_features,) Estimated location, i.e. the estimated mean.

covariance_ : ndarray of shape (n_features, n_features) Estimated covariance matrix.

precision_ : ndarray of shape (n_features, n_features) Estimated precision matrix (inverse covariance).

alpha_ : float Penalization parameter selected.

cv_alphas_ : list of shape (n_alphas,), dtype=float All penalization parameters explored.

grid_scores_ : ndarray of shape (n_alphas, n_folds) Log-likelihood score on left-out data across folds.

n_iter_ : int Number of iterations run for the optimal alpha.

Examples -------- >>> import numpy as np >>> from sklearn.covariance import GraphicalLassoCV >>> true_cov = np.array([0.8, 0.0, 0.2, 0.0], ... [0.0, 0.4, 0.0, 0.0], ... [0.2, 0.0, 0.3, 0.1], ... [0.0, 0.0, 0.1, 0.7]) >>> np.random.seed(0) >>> X = np.random.multivariate_normal(mean=0, 0, 0, 0, ... cov=true_cov, ... size=200) >>> cov = GraphicalLassoCV().fit(X) >>> np.around(cov.covariance_, decimals=3) array([0.816, 0.051, 0.22 , 0.017], [0.051, 0.364, 0.018, 0.036], [0.22 , 0.018, 0.322, 0.094], [0.017, 0.036, 0.094, 0.69 ]) >>> np.around(cov.location_, decimals=3) array(0.073, 0.04 , 0.038, 0.143)

See Also -------- graphical_lasso, GraphicalLasso

Notes ----- The search for the optimal penalization parameter (alpha) is done on an iteratively refined grid: first the cross-validated scores on a grid are computed, then a new refined grid is centered around the maximum, and so on.

One of the challenges which is faced here is that the solvers can fail to converge to a well-conditioned estimate. The corresponding values of alpha then come out as missing values, but the optimum may be close to these missing values.

val error_norm : ?norm:[ `Frobenius | `Spectral ] -> ?scaling:bool -> ?squared:bool -> comp_cov:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> float

Computes the Mean Squared Error between two covariance estimators. (In the sense of the Frobenius norm).

Parameters ---------- comp_cov : array-like of shape (n_features, n_features) The covariance to compare with.

norm : 'frobenius', 'spectral', default='frobenius' The type of norm used to compute the error. Available error types:

  • 'frobenius' (default): sqrt(tr(A^t.A))
  • 'spectral': sqrt(max(eigenvalues(A^t.A)) where A is the error ``(comp_cov - self.covariance_)``.

scaling : bool, default=True If True (default), the squared error norm is divided by n_features. If False, the squared error norm is not rescaled.

squared : bool, default=True Whether to compute the squared error norm or the error norm. If True (default), the squared error norm is returned. If False, the error norm is returned.

Returns ------- result : float The Mean Squared Error (in the sense of the Frobenius norm) between `self` and `comp_cov` covariance estimators.

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

Fits the GraphicalLasso covariance model to X.

Parameters ---------- X : array-like of shape (n_samples, n_features) Data from which to compute the covariance estimate

y : Ignored Not used, present for API consistence purpose.

Returns ------- self : object

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

Getter for the precision matrix.

Returns ------- precision_ : array-like of shape (n_features, n_features) The precision matrix associated to the current covariance object.

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

Computes the squared Mahalanobis distances of given observations.

Parameters ---------- X : array-like of shape (n_samples, n_features) The observations, the Mahalanobis distances of the which we compute. Observations are assumed to be drawn from the same distribution than the data used in fit.

Returns ------- dist : ndarray of shape (n_samples,) Squared Mahalanobis distances of the observations.

val score : ?y:Py.Object.t -> x_test:[> `ArrayLike ] Np.Obj.t -> [> tag ] Obj.t -> float

Computes the log-likelihood of a Gaussian data set with `self.covariance_` as an estimator of its covariance matrix.

Parameters ---------- X_test : array-like of shape (n_samples, n_features) Test data of which we compute the likelihood, where n_samples is the number of samples and n_features is the number of features. X_test is assumed to be drawn from the same distribution than the data used in fit (including centering).

y : Ignored Not used, present for API consistence purpose.

Returns ------- res : float The likelihood of the data set with `self.covariance_` as an estimator of its covariance matrix.

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

Attribute location_: get value or raise Not_found if None.

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

Attribute location_: get value as an option.

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

Attribute covariance_: get value or raise Not_found if None.

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

Attribute covariance_: get value as an option.

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

Attribute precision_: get value or raise Not_found if None.

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

Attribute precision_: get value as an option.

val alpha_ : t -> float

Attribute alpha_: get value or raise Not_found if None.

val alpha_opt : t -> float option

Attribute alpha_: get value as an option.

val cv_alphas_ : t -> Py.Object.t

Attribute cv_alphas_: get value or raise Not_found if None.

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

Attribute cv_alphas_: get value as an option.

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

Attribute grid_scores_: get value or raise Not_found if None.

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

Attribute grid_scores_: get value as an option.

val n_iter_ : t -> int

Attribute n_iter_: get value or raise Not_found if None.

val n_iter_opt : t -> int option

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

OCaml

Innovation. Community. Security.