o tBh @s4dZddlZddlZddlZddlZddlZddlmZddl m Z ddl m Z m Z mZddlmZdd lmZmZdd lmZdd lmZdd lmZdd lmZmZddZddZddZGddde Z!ddddddde"ej#j$dd ddZ%Gddde Z&       d#dd Z'Gd!d"d"e&Z(dS)$zUGraphicalLasso: sparse inverse covariance estimation with an l1-penalized estimator. N)linalg)Parallel)empirical_covarianceEmpiricalCovariancelog_likelihood)ConvergenceWarning)_is_arraylike_not_scalarcheck_random_state)delayed)_cd_fast)lars_path_gram)check_cvcross_val_scorecCsZ|jd}dt|||tdtj}||t|tt|7}|S)zEvaluation of the graphical-lasso objective function the objective function is made of a shifted scaled version of the normalized log-likelihood (i.e. its empirical mean over the samples) and a penalisation term to promote sparsity rr)shapernplogpiabssumdiag)mle precision_alphapcostrv/var/www/html/riverr-enterprise-integrations-main/venv/lib/python3.10/site-packages/sklearn/covariance/_graph_lasso.py _objectives "*r cCsJt||}||jd8}||t|tt|7}|S)zExpression of the dual gap convergence criterion The specific definition is given in Duchi "Projected Subgradient Methods for Learning Sparse Gaussians". r)rrrrr)emp_covrrgaprrr _dual_gap,s*r#cCs4t|}d|jdd|jdd<tt|S)aFind the maximum alpha for which there are some non-zeros off-diagonal. Parameters ---------- emp_cov : ndarray of shape (n_features, n_features) The sample covariance matrix. Notes ----- This results from the bound for the all the Lasso that are solved in GraphicalLasso: each time, the row of cov corresponds to Xy. As the bound for alpha is given by `max(abs(Xy))`, the result follows. rNr)rcopyflatrmaxr)r!Arrr alpha_max8s r(cs4eZdZdZfddZfddZddZZS)_DictWithDeprecatedKeyszbDictionary with deprecated keys. Currently only be used in GraphicalLassoCV to deprecate keysc stjdi|i|_dS)Nr)super__init___deprecated_key_to_new_key)selfkwargs __class__rrr+Ps z _DictWithDeprecatedKeys.__init__cs6||jvrtd|d|j|dtt|S)NzKey: 'z9', is deprecated in 1.0 and will be removed in 1.2. Use 'z ' instead)r,warningswarn FutureWarningr* __getitem__)r-keyr/rrr4Ts  z#_DictWithDeprecatedKeys.__getitem__cCs||j|<|||<||<dSN)r,)r-valuenew_keydeprecated_keyrrr_set_deprecated]s z'_DictWithDeprecatedKeys._set_deprecated)__name__ __module__ __qualname____doc__r+r4r: __classcell__rrr/rr)Ks    r)cd-C6?dF) cov_initmodetolenet_tolmax_iterverbose return_costseps return_n_iterc Cs@|j\} } |dkrN|r=t|} dt|| }|| tdtj7}t|| | }| r6|| ||fdfS|| ||ffS| rG|t|dfS|t|fS|durW|}n|}|d9}|j dd| d}||j dd| d<t |} t | }t }|dkrt dd d }nt dd }zUtj}tj|ddddfd d }t|D]1}t| D]}|dkr|d}||||k||<|dd|f||k|dd|f<n|ddddf|dd<||||kf}tjdi|I|dkr"| ||k|f| ||fd|  }t||d|||||tdd \}} } } nt|||j|| dd| ddd\} } }Wdn 1sAwYd|||ft|||k|f|| ||f<| ||f || ||k|f<| ||f || |||kf<t||}|||||kf<||||k|f<qt| stdt|| |}t|| |}|rtd|||f|r|||ft||krnt|s|dkrtdqtd||ft Wnty}z |j!ddf|_!|d}~ww|r| r || ||dfS|| |fS| r|| |dfS|| fS)ac L1-penalized covariance estimator. Read more in the :ref:`User Guide `. .. versionchanged:: v0.20 graph_lasso has been renamed to graphical_lasso Parameters ---------- emp_cov : ndarray of shape (n_features, n_features) Empirical covariance from which to compute the covariance estimate. alpha : float The regularization parameter: the higher alpha, the more regularization, the sparser the inverse covariance. Range is (0, inf]. cov_init : array of shape (n_features, n_features), default=None The initial guess for the covariance. If None, then the empirical covariance is used. mode : {'cd', 'lars'}, default='cd' The Lasso solver to use: coordinate descent or LARS. Use LARS for very sparse underlying graphs, where p > n. Elsewhere prefer cd which is more numerically stable. 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 The maximum number of iterations. verbose : bool, default=False If verbose is True, the objective function and dual gap are printed at each iteration. return_costs : bool, default=Flase If return_costs is True, the objective function and dual gap at each iteration are returned. eps : float, default=eps The machine-precision regularization in the computation of the Cholesky diagonal factors. Increase this for very ill-conditioned systems. Default is `np.finfo(np.float64).eps`. return_n_iter : bool, default=False Whether or not to return the number of iterations. Returns ------- covariance : ndarray of shape (n_features, n_features) The estimated covariance matrix. precision : ndarray of shape (n_features, n_features) The estimated (sparse) precision matrix. costs : list of (objective, dual_gap) pairs The list of values of the objective function and the dual gap at each iteration. Returned only if return_costs is True. n_iter : int Number of iterations. Returned only if `return_n_iter` is set to True. See Also -------- GraphicalLasso : Sparse inverse covariance estimation with an l1-penalized estimator. GraphicalLassoCV : Sparse inverse covariance with cross-validated choice of the l1 penalty. Notes ----- The algorithm employed to solve this problem is the GLasso algorithm, from the Friedman 2008 Biostatistics paper. It is the same algorithm as in the R `glasso` package. One possible difference with the `glasso` R package is that the diagonal coefficients are not penalized. rrrNgffffff?rr@raiseignore)overinvalid)rOC)orderiFTlars)XyGram n_samples alpha_min copy_GramrJmethod return_pathg?z1The system is too ill-conditioned for this solverz<[graphical_lasso] Iteration % 3i, cost % 3.2e, dual gap %.3ezANon SPD result: the system is too ill-conditioned for this solverzDgraphical_lasso: did not converge after %i iteration: dual gap: %.3ez3. The system is too ill-conditioned for this solverr)"rrinvrrrrrr$r%pinvharangelistdictinfrangeerrstatecd_fastenet_coordinate_descent_gramr rsizedotisfiniteFloatingPointErrorr#r printappendrr1r2r args)r!rrCrDrErFrGrHrIrJrK_ n_featuresrrd_gap covariance_diagonalindicescostserrorssub_covarianceiidxdirowcoefserrrgraphical_lassocs d      &         rzcs>eZdZdZ d dddddddfdd Zdd d ZZS)GraphicalLassoa Sparse inverse covariance estimation with an l1-penalized estimator. Read more in the :ref:`User Guide `. .. versionchanged:: v0.20 GraphLasso has been renamed to GraphicalLasso Parameters ---------- alpha : float, default=0.01 The regularization parameter: the higher alpha, the more regularization, the sparser the inverse covariance. Range is (0, inf]. mode : {'cd', 'lars'}, default='cd' The Lasso solver to use: coordinate descent or LARS. Use LARS for very sparse underlying graphs, where p > n. Elsewhere prefer cd which is more numerically stable. 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 The maximum number of iterations. verbose : bool, default=False If verbose is True, the objective function and dual gap are plotted 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 pseudo inverse matrix. n_iter_ : int Number of iterations run. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- graphical_lasso : L1-penalized covariance estimator. GraphicalLassoCV : Sparse inverse covariance with cross-validated choice of the l1 penalty. Examples -------- >>> import numpy as np >>> from sklearn.covariance import GraphicalLasso >>> 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 = GraphicalLasso().fit(X) >>> np.around(cov.covariance_, decimals=3) array([[0.816, 0.049, 0.218, 0.019], [0.049, 0.364, 0.017, 0.034], [0.218, 0.017, 0.322, 0.093], [0.019, 0.034, 0.093, 0.69 ]]) >>> np.around(cov.location_, decimals=3) array([0.073, 0.04 , 0.038, 0.143]) {Gz?r@rArBF)rDrErFrGrHassume_centeredcs6tj|d||_||_||_||_||_||_dS)Nr})r*r+rrDrErFrGrH)r-rrDrErFrGrHr}r/rrr+s  zGraphicalLasso.__init__Nc Csx|j|ddd}|jrt|jd|_n|d|_t||jd}t||j |j |j |j |j |jdd\|_|_|_|S)aFit the GraphicalLasso 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 consistency by convention. Returns ------- self : object Returns the instance itself. r)ensure_min_featuresensure_min_samplesrrr~TrrDrErFrGrHrK)_validate_datar}rzerosr location_meanrrzrrDrErFrGrHrnrn_iter_)r-Xyr!rrrfits   zGraphicalLasso.fit)r|r6r;r<r=r>r+rr?rrr/rr{Qsar{c  CsTtd|d} t|} |dur| } n|} t} t} t}|dur't|}|D]s}z#t| || ||||| d\} }| | | ||durMt||}Wntygtj }| tj | tj Ynw|durzt |sutj }|||dkrt j dq)|dkr|durtd||fq)td|q)|dur| | |fS| | fS)al1-penalized covariance estimator along a path of decreasing alphas Read more in the :ref:`User Guide `. Parameters ---------- X : ndarray of shape (n_samples, n_features) Data from which to compute the covariance estimate. alphas : array-like of shape (n_alphas,) The list of regularization parameters, decreasing order. cov_init : array of shape (n_features, n_features), default=None The initial guess for the covariance. X_test : array of shape (n_test_samples, n_features), default=None Optional test matrix to measure generalisation error. mode : {'cd', 'lars'}, default='cd' The Lasso solver to use: coordinate descent or LARS. Use LARS for very sparse underlying graphs, where p > n. Elsewhere prefer cd which is more numerically stable. tol : float, default=1e-4 The tolerance to declare convergence: if the dual gap goes below this value, iterations are stopped. The tolerance must be a positive number. 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'. The tolerance must be a positive number. max_iter : int, default=100 The maximum number of iterations. This parameter should be a strictly positive integer. verbose : int or bool, default=False The higher the verbosity flag, the more information is printed during the fitting. Returns ------- covariances_ : list of shape (n_alphas,) of ndarray of shape (n_features, n_features) The estimated covariance matrices. precisions_ : list of shape (n_alphas,) of ndarray of shape (n_features, n_features) The estimated (sparse) precision matrices. scores_ : list of shape (n_alphas,), dtype=float The generalisation error (log-likelihood) on the test data. Returned only if test data is passed. rrN)rrCrDrErFrGrH.z/[graphical_lasso_path] alpha: %.2e, score: %.2ez"[graphical_lasso_path] alpha: %.2e)r&rr$r]rzrirrgrr_nanrfsysstderrwriterh)ralphasrCX_testrDrErFrGrH inner_verboser!rn covariances_ precisions_scores_ test_emp_covrr this_scorerrrgraphical_lasso_pathsdC         rc sBeZdZdZddddddddddd fd d Zd d d ZZS)GraphicalLassoCVaXSparse 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 `. .. 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 ` 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 ` 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_results_ : dict of ndarrays A dict with keys: alphas : ndarray of shape (n_alphas,) All penalization parameters explored. split(k)_test_score : ndarray of shape (n_alphas,) Log-likelihood score on left-out data across (k)th fold. .. versionadded:: 1.0 mean_test_score : ndarray of shape (n_alphas,) Mean of scores over the folds. .. versionadded:: 1.0 std_test_score : ndarray of shape (n_alphas,) Standard deviation of scores over the folds. .. versionadded:: 1.0 split(k)_score : ndarray of shape (n_alphas,) Log-likelihood score on left-out data across (k)th fold. .. deprecated:: 1.0 `split(k)_score` is deprecated in 1.0 and will be removed in 1.2. Use `split(k)_test_score` instead. mean_score : ndarray of shape (n_alphas,) Mean of scores over the folds. .. deprecated:: 1.0 `mean_score` is deprecated in 1.0 and will be removed in 1.2. Use `mean_test_score` instead. std_score : ndarray of shape (n_alphas,) Standard deviation of scores over the folds. .. deprecated:: 1.0 `std_score` is deprecated in 1.0 and will be removed in 1.2. Use `std_test_score` instead. .. versionadded:: 0.24 n_iter_ : int Number of iterations run for the optimal alpha. n_features_in_ : int Number of features seen during :term:`fit`. .. versionadded:: 0.24 feature_names_in_ : ndarray of shape (`n_features_in_`,) Names of features seen during :term:`fit`. Defined only when `X` has feature names that are all strings. .. versionadded:: 1.0 See Also -------- graphical_lasso : L1-penalized covariance estimator. GraphicalLasso : Sparse inverse covariance estimation with an l1-penalized estimator. 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. In `fit`, once the best parameter `alpha` is found through cross-validation, the model is fit again using the entire training set. 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]) NrArBr@F) r n_refinementscvrErFrGrDn_jobsrHr}c s4tj||| ||| d||_||_||_||_dS)N)rDrErHrFrGr})r*r+rrrr) r-rrrrErFrGrDrrHr}r/rrr+!s zGraphicalLassoCV.__init__c sjddjrtjd_nd_tjd}tj |dd}t }j }t dj dt|rAj d}nj}t|}d|} tt| t||d d d t} t|D]} t&td ttjj d fd d||D} Wd n1swYt| \} }}t| } t|}|t|| t|t ddd}tj! }d}t"|D])\}\}}}t|}|dt#tj$j%krtj&}t'|r|}||kr|}|}q|dkr|dd}|dd} nE||kr |t(|dks ||d}||dd} n(|t(|dkr8||d}d||d} n||dd}||dd} t|sbtt|t| |ddd j rz|dkrzt)d| d|t| fqft t|}t |d}t |d*d|*t+t,|jdt-|}t.t-d_/t|jdD]} j/j0|d d | fd| dd| ddqj/j0tj|dddddj/j0tj1|ddddd|}|_2t3||j4j5j6j7dd\_8_9_:S)aFit 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 consistency by convention. Returns ------- self : object Returns the instance itself. r)rrrr~F) classifierr|NrM)rrHc 3sH|]\}}tt||jjjtdjdVqdS)皙?)rrrDrErFrGrHN)r rrDrErFintrG).0traintestrrrr-rr ps   z'GraphicalLassoCV.fit..T)r5reverserz8[GraphicalLassoCV] Done refinement % 2i out of %i: % 3is)rrrH)rsplit _test_score_score)r8r9)axismean_test_score mean_scorestd_test_score std_scorer);rr}rrrrrrrrr]rr&rHr rr(logspacelog10timer`r1catch_warnings simplefilterr rrrzipextendsortedoperator itemgetterr_ enumeratefinfofloat64rJrrflenrhrirrarrayr) cv_results_r:stdalpha_rzrDrErFrGrnrr)r-rrr!rpathn_alphasralpha_1alpha_0t0rt this_pathcovsrkscores best_scorelast_finite_idxindexrr best_index grid_scores best_alpharrrr<s $                      zGraphicalLassoCV.fitr6rrrr/rrasCr)NNr@rArArBF))r>r1rrrnumpyrscipyrjoblibrrrr exceptionsr utils.validationr r utils.fixesr linear_modelr rbrmodel_selectionrrr r#r(r^r)rrrJrzr{rrrrrrsR          o w