U
    3d                  
   @   sB  d Z ddlZddlZddlZddlZddlmZmZ ddlZ	ddl
mZ ddlmZmZmZ ddlmZ dd	lmZmZmZ dd
lmZmZ ddlmZmZ ddlmZ ddlmZ ddl m!Z!m"Z" dd Z#dd Z$dd Z%ddddddde	&e	j'j(dd	ddZ)G dd deZ*G dd de*Z+d$d d!Z,G d"d# d#e*Z-dS )%zUGraphicalLasso: sparse inverse covariance estimation with an l1-penalized
estimator.
    N)IntegralReal)linalg   )empirical_covarianceEmpiricalCovariancelog_likelihood   )ConvergenceWarning)_is_arraylike_not_scalarcheck_random_statecheck_scalar)delayedParallel)Interval
StrOptions)_cd_fast)lars_path_gram)check_cvcross_val_scorec                 C   sZ   |j d }dt| | |tdtj   }||t| tt|   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
    r          r	   )shaper   nplogpiabssumdiag)Zmle
precision_alphapcost r"   C/tmp/pip-unpacked-wheel-zrfo1fqw/sklearn/covariance/_graph_lasso.py
_objective$   s    
"*r$   c                 C   sJ   t | | }||jd 8 }||t | t t |   7 }|S )zExpression of the dual gap convergence criterion

    The specific definition is given in Duchi "Projected Subgradient Methods
    for Learning Sparse Gaussians".
    r   )r   r   r   r   r   )emp_covr   r   Zgapr"   r"   r#   	_dual_gap1   s    *r&   c                 C   s4   t | }d|jdd|jd d < t t |S )a  Find 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.
    r   Nr   )r   copyflatr   maxr   )r%   Ar"   r"   r#   	alpha_max=   s    
r+   cd-C6?d   F)	cov_initmodetolenet_tolmax_iterverbosereturn_costsepsreturn_n_iterc       	         C   sD  | j \}}|dkr|r|t| }dt| | }||tdtj  7 }t| | | }|
rl| |||fdfS | |||ffS n"|
r| t| dfS | t| fS |dkr|  }n| }|d9 }| j	dd|d  }||j	dd|d < t
|}t|}t }|dkrtdd	d
}n
tdd}ztj}tj|ddddf dd}t|D ]R}t|D ]}|dkr|d }|| ||k ||< |dd|f ||k |dd|f< n|ddddf |dd< | |||kf }tjf | |dkrH|||k|f |||f d|	    }t||d|||||tdd
\}}}}n(t|||j||d  d|	ddd\}}}W 5 Q R X d|||f t|||k|f |  |||f< |||f  | |||k|f< |||f  | ||||kf< t||}|||||kf< ||||k|f< qbt| s.tdt| ||}t| ||}|r^td|||f  |rr|||f t||k r qt|sT|dkrTtdqTtd||f t  W n: tk
r } z|j!d d f|_!|W 5 d}~X Y nX |r$|
r||||d fS |||fS n|
r8|||d fS ||fS dS )ac  L1-penalized covariance estimator.

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

    .. 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=False
        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.
    r   r   r	   Ngffffff?r   r,   raiseignore)Zoverinvalid)r:   C)orderi  FTlars)ZXyZGramZ	n_samplesZ	alpha_minZ	copy_Gramr6   methodZ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 solver)"r   r   invr   r   r   r   r   r'   r(   ZpinvhZarangelistdictinfrangeZerrstatecd_fastZenet_coordinate_descent_gramr   r   sizedotisfiniteFloatingPointErrorr&   r$   printappendr   warningswarnr
   args)r%   r   r/   r0   r1   r2   r3   r4   r5   r6   r7   _Z
n_featuresr   r!   Zd_gapcovariance_ZdiagonalindicesZcostserrorsZsub_covarianceiidxZdirowZcoefser"   r"   r#   graphical_lassoQ   s    d







&


rV   c                	       s~   e Zd ZU ejeeddddgeeddddgeeddddgeddhgdgd	Ze	e
d
< ed d fdd	Z  ZS )BaseGraphicalLassor   Nrightclosedleftr,   r=   r4   )r1   r2   r3   r0   r4   _parameter_constraintsZstore_precisionr-   r.   Fc                    s0   t  j|d || _|| _|| _|| _|| _d S )Nassume_centered)super__init__r1   r2   r3   r0   r4   )selfr1   r2   r3   r0   r4   r^   	__class__r"   r#   r`   I  s    	zBaseGraphicalLasso.__init__)r-   r-   r.   r,   FF)__name__
__module____qualname__r   r\   r   r   r   r   rA   __annotations__popr`   __classcell__r"   r"   rb   r#   rW   >  s   

      rW   c                       sb   e Zd ZU dZejdeeddddgiZee	d< dd	d
d
dddd fddZ
dddZ  ZS )GraphicalLassoa  Sparse inverse covariance estimation with an l1-penalized estimator.

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

    .. 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])
    r   r   NrX   rY   r\   {Gz?r,   r-   r.   F)r0   r1   r2   r3   r4   r^   c                   s"   t  j||||||d || _d S N)r1   r2   r3   r0   r4   r^   )r_   r`   r   )ra   r   r0   r1   r2   r3   r4   r^   rb   r"   r#   r`     s    zGraphicalLasso.__init__c              
   C   s   |    | j|ddd}| jr2t|jd | _n|d| _t|| jd}t	|| j
| j| j| j| j| jdd\| _| _| _| S )a  Fit 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_featuresZensure_min_samplesr   r   r]   Tr   r0   r1   r2   r3   r4   r7   )_validate_params_validate_datar^   r   zerosr   	location_meanr   rV   r   r0   r1   r2   r3   r4   rO   r   n_iter_)ra   Xyr%   r"   r"   r#   fit  s"    
zGraphicalLasso.fit)rk   )N)rd   re   rf   __doc__rW   r\   r   r   rA   rg   r`   rw   ri   r"   r"   rb   r#   rj   Z  s   
`  rj   c	                 C   s\  t d|d }	t| }
|dkr(|
 }n|}t }t }t }|dk	rNt|}|D ]}zFt|
|||||||	d\}}|| || |dk	rt||}W n4 tk
r   tj	 }|tj
 |tj
 Y nX |dk	rt|stj	 }|| |dkrtjd qR|dkrR|dk	r2td||f  qRtd|  qR|dk	rT|||fS ||fS )a  l1-penalized covariance estimator along a path of decreasing alphas

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

    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.
    r   r   N)r   r/   r0   r1   r2   r3   r4   .z/[graphical_lasso_path] alpha: %.2e, score: %.2ez"[graphical_lasso_path] alpha: %.2e)r)   r   r'   r@   rV   rJ   r   rH   r   rB   nanrG   sysstderrwriterI   )ru   alphasr/   X_testr0   r1   r2   r3   r4   inner_verboser%   rO   Zcovariances_Zprecisions_Zscores_Ztest_emp_covr   r   
this_scorer"   r"   r#   graphical_lasso_path  s^    C










r   c                       s   e Zd ZU dZejeedddddgeeddddgdgedgdZee	d	< d
d
ddddddddd
 fdd
Z
dddZ  ZS )GraphicalLassoCVaG  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 [1, inf) for an integer.
        Range is (0, inf] for an array-like of floats.

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

    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])
    r   Nr[   rY   z
array-likeZ	cv_object)r~   n_refinementscvn_jobsr\      r-   r.   r,   F)
r~   r   r   r1   r2   r3   r0   r   r4   r^   c       
            s4   t  j|||||	|
d || _|| _|| _|| _d S rl   )r_   r`   r~   r   r   r   )ra   r~   r   r   r1   r2   r3   r0   r   r4   r^   rb   r"   r#   r`   $  s    zGraphicalLassoCV.__init__c              
      s     j dd jr0t jd _n d_t jd}t	j
|dd}t }j}tdjd t|rjD ]}t|dtdtjd	d
 qjd}n:j}t|}	d|	 }
tt|
t|	|ddd t }t|D ]}t B tdt tjjd fdd| |D }W 5 Q R X t | \}}}t | }t | }|!t || t"|t#$ddd}tj }d}t%|D ]Z\}\}}}t|}|dt&tj'j( krtj)}t*|r|}||kr|}|}q|dkr$|d d }	|d d }
n||kr^|t+|d ks^|| d }	||d  d }
nP|t+|d kr|| d }	d|| d  }
n ||d  d }	||d  d }
t|stt|	t|
|d dd jr|dkrt,d|d |t | f  qtt | }t|d }t|d -d |-t.t/  |jd t0|}dt0i_1t|jd D ]$}|dd|f j1d| d< qtj|ddj1d< tj2|ddj1d< | }|_3t4||j5j6j7j8dd\_9_:_;S )a  Fit 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	   )rm   r   r   r]   F)
classifierr   rX   )Zmin_valZmax_valZinclude_boundariesrk   Nr9   )r   r4   c                 3   sF   | ]>\}}t t |  | jjjtd j dV  qdS )皙?)r~   r   r0   r1   r2   r3   r4   N)r   r   r0   r1   r2   intr3   ).0Ztraintestru   r~   r   ra   r"   r#   	<genexpr>}  s   z'GraphicalLassoCV.fit.<locals>.<genexpr>T)keyreverser   z8[GraphicalLassoCV] Done refinement % 2i out of %i: % 3is)r   r   r4   r~   splitZ_test_score)ZaxisZmean_test_scoreZstd_test_scorern   )<ro   rp   r^   r   rq   r   rr   rs   r   r   r   r@   r~   r)   r4   r   r   r   rB   r   r+   Zlogspacelog10timerC   rK   catch_warningssimplefilterr
   r   r   r   zipextendsortedoperator
itemgetter	enumeratefinfofloat64r6   rz   rG   lenrI   rJ   r   r   arrayZcv_results_ZstdZalpha_rV   r0   r1   r2   r3   rO   r   rt   )ra   ru   rv   r%   r   pathZn_alphasr   r   Zalpha_1Zalpha_0t0rR   Z	this_pathZcovsrN   ZscoresZ
best_scoreZlast_finite_idxindexr   Z
best_indexZgrid_scoresZ
best_alphar"   r   r#   rw   ?  s    
$






	
"
zGraphicalLassoCV.fit)N)rd   re   rf   rx   rW   r\   r   r   rA   rg   r`   rw   ri   r"   r"   rb   r#   r   r  s(   
 +r   )NNr,   r-   r-   r.   F).rx   rK   r   r{   r   Znumbersr   r   Znumpyr   Zscipyr    r   r   r   
exceptionsr
   Zutils.validationr   r   r   Zutils.parallelr   r   Zutils._param_validationr   r   Zlinear_modelr   rD   r   Zmodel_selectionr   r   r$   r&   r+   r   r   r6   rV   rW   rj   r   r   r"   r"   r"   r#   <module>   sR    n %       
w