0Ph@[dZddlZddlZddlmZmZddlZddlmZddl m Z ddl m Z ddl mZmZdd lmZdd lmZdd lmZdd lmZmZdd lmZddlmZmZmZmZm Z ddl!m"Z"m#Z#m$Z$ddl%m&Z&m'Z'ddl(m)Z)m*Z*m+Z+m,Z,m-Z-ddl.m/Z/ddl0m1Z1m2Z2ddl3m4Z4m5Z5ddl6m7Z7m8Z8m9Z9m:Z:ddl;mZ>ddl?m@Z@ddlAmBZBddlCmDZDdZEdZFdZG d-d'ZHd(ZIGd)d*e=e>e<ZJGd+d,eJe=e<ZKdS).z Logistic Regression N)IntegralReal)effective_n_jobs)optimize)get_scorer_names)HalfBinomialLossHalfMultinomialLoss) _fit_context) get_scorer)check_cv)LabelBinarizer LabelEncoder)_fit_liblinear)Bunch check_arraycheck_consistent_lengthcheck_random_statecompute_class_weight)HiddenInterval StrOptions) row_normssoftmax)MetadataRouter MethodMapping_raise_for_params_routing_enabledprocess_routing)check_classification_targets)_check_optimize_result _newton_cg)Paralleldelayed)_check_method_params_check_sample_weightcheck_is_fitted validate_data) BaseEstimatorLinearClassifierMixinSparseCoefMixin)NewtonCholeskySolver)LinearModelLoss) sag_solverzPlease also refer to the documentation for alternative solver options: https://scikit-learn.org/stable/modules/linear_model.html#logistic-regressionc|dvr|dvrtd|d|d|dkr|rtd|d||dkr|d krtd |d |dkr|td |S) N) liblinearsaga)l2NzSolver z+ supports only 'l2' or None penalties, got z penalty.r1z$ supports only dual=False, got dual= elasticnetr2z;Only 'saga' solver supports elasticnet penalty, got solver=.z6penalty=None is not supported for the liblinear solver ValueError)solverpenaltyduals ^/var/www/html/test/jupyter/venv/lib/python3.11/site-packages/sklearn/linear_model/_logistic.py _check_solverr<=s ***wl/J/J f        U6UUtUUVVV,6V#3#3 S& S S S   QRRR Mcn|dkr|dvrd}n |dkrd}nd}|dkr|dvrtd|z|S)zComputes the multi class type, either "multinomial" or "ovr". For `n_classes` > 2 and a solver that supports it, returns "multinomial". For all other cases, in particular binary classification, return "ovr". auto)r1ovrr multinomialz1Solver %s does not support a multinomial backend.r6) multi_classr8 n_classess r;_check_multi_classrDQse f ^ # #KK ]]'KKKm##.(@(@LvUVVV r= Td-C6?lbfgsFr3?r?ct|tjrtjdd|}t || | }|rAt |dtj|dv}t |dd}t|||j \}}tj |}t|}t||t|}|(|d kr"|jd krtd |d }|| t!|||jd }t%}t| t&s|d kr2| 0t)| ||}||||z}|dkrtj|t/|z|j}||k}tj|j |j}|dkrtjdd g}d||<ntjdd g}d||<| dkr0t)| ||}||||z}n|dvr>t%}|||jd}nMt7}||}|j d d krtjd |z |g}tj|j|t/|zfd|j}|dvr||ntj|} | |dkr<| j||jfvrtd| j||jfz| |d| j<n|j}!|!d krd }!| j d|!ks| j d ||d zfvr;td| j d| j d |j||j|d zfz|!d kr*| |dd| j d f<| |d d| j d f<n| |ddd| j d f<|d krs|dvr|d}t?tA|j |!}"|}#|d"kr|"j!}$n|d#kr|"j"}$|"j#}%|"j$}&d$|j%i}'n|}#|d"kr%t?tM|!}"|"j!}$n\|d#kr3t?tM|!}"|"j"}$|"j#}%|"j$}&n#|d%krt?tM|!}"d$tj'|d &i}'tQ}(tjt|tj)})tU|D]\}*}+|d"krd'|+| zz },gd(tj+tjgd)|}-tYj-|$|d*d ||#||,|f|d+|-|d,tj.t^j0zd-.}.tc||.|td/}/|.j3|.j4}"}n|d#kr+d'|+| zz },||#||,|f}0tk|&|$|%||0|||0\}}/nQ|d%kr?d'|+| zz },tm||"|,||||1}1|17||#|2}|1j8}/n |dkrtts||#|+|| d| | |||||3 \}2}3}/|r)tj:|2|3g}n|2}|/;}/n|d4vr||d kr|#|jd}#d }"nd5}"| d6krd}4d'|+z }5n!| d7krd'|+z }4d}5nd'|+z d |z z}4d'|+z |z}5ty||#||"|4|5||||d||'|d8k9\}}/}'ntd:|z|d krt{d |j}!|dvrtj>||!dfd}6n|}6|!d kr|6d tj?ddf}6|(@|6An'|(@|A|/|)|*<tj|(tj||)fS);aCompute a Logistic Regression model for a list of regularization parameters. This is an implementation that uses the result of the previous model to speed up computations along the set of solutions, making it faster than sequentially calling LogisticRegression for the different parameters. Note that there will be no speedup with liblinear solver, since it does not handle warm-starting. Read more in the :ref:`User Guide `. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Input data. y : array-like of shape (n_samples,) or (n_samples, n_targets) Input data, target values. pos_class : int, default=None The class with respect to which we perform a one-vs-all fit. If None, then it is assumed that the given problem is binary. Cs : int or array-like of shape (n_cs,), default=10 List of values for the regularization parameter or integer specifying the number of regularization parameters that should be used. In this case, the parameters will be chosen in a logarithmic scale between 1e-4 and 1e4. fit_intercept : bool, default=True Whether to fit an intercept for the model. In this case the shape of the returned array is (n_cs, n_features + 1). max_iter : int, default=100 Maximum number of iterations for the solver. tol : float, default=1e-4 Stopping criterion. For the newton-cg and lbfgs solvers, the iteration will stop when ``max{|g_i | i = 1, ..., n} <= tol`` where ``g_i`` is the i-th component of the gradient. verbose : int, default=0 For the liblinear and lbfgs solvers set verbose to any positive number for verbosity. solver : {'lbfgs', 'liblinear', 'newton-cg', 'newton-cholesky', 'sag', 'saga'}, default='lbfgs' Numerical solver to use. coef : array-like of shape (n_features,), default=None Initialization value for coefficients of logistic regression. Useless for liblinear solver. class_weight : dict or 'balanced', default=None Weights associated with classes in the form ``{class_label: weight}``. If not given, all classes are supposed to have weight one. The "balanced" mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data as ``n_samples / (n_classes * np.bincount(y))``. Note that these weights will be multiplied with sample_weight (passed through the fit method) if sample_weight is specified. dual : bool, default=False Dual or primal formulation. Dual formulation is only implemented for l2 penalty with liblinear solver. Prefer dual=False when n_samples > n_features. penalty : {'l1', 'l2', 'elasticnet'}, default='l2' Used to specify the norm used in the penalization. The 'newton-cg', 'sag' and 'lbfgs' solvers support only l2 penalties. 'elasticnet' is only supported by the 'saga' solver. intercept_scaling : float, default=1. Useful only when the solver 'liblinear' is used and self.fit_intercept is set to True. In this case, x becomes [x, self.intercept_scaling], i.e. a "synthetic" feature with constant value equal to intercept_scaling is appended to the instance vector. The intercept becomes ``intercept_scaling * synthetic_feature_weight``. Note! the synthetic feature weight is subject to l1/l2 regularization as all other features. To lessen the effect of regularization on synthetic feature weight (and therefore on the intercept) intercept_scaling has to be increased. multi_class : {'ovr', 'multinomial', 'auto'}, default='auto' If the option chosen is 'ovr', then a binary problem is fit for each label. For 'multinomial' the loss minimised is the multinomial loss fit across the entire probability distribution, *even when the data is binary*. 'multinomial' is unavailable when solver='liblinear'. 'auto' selects 'ovr' if the data is binary, or if solver='liblinear', and otherwise selects 'multinomial'. .. versionadded:: 0.18 Stochastic Average Gradient descent solver for 'multinomial' case. .. versionchanged:: 0.22 Default changed from 'ovr' to 'auto' in 0.22. random_state : int, RandomState instance, default=None Used when ``solver`` == 'sag', 'saga' or 'liblinear' to shuffle the data. See :term:`Glossary ` for details. check_input : bool, default=True If False, the input arrays X and y will not be checked. max_squared_sum : float, default=None Maximum squared sum of X over samples. Used only in SAG solver. If None, it will be computed, going through all the samples. The value should be precomputed to speed up cross validation. sample_weight : array-like of shape(n_samples,), default=None Array of weights that are assigned to individual samples. If not provided, then each sample is given unit weight. l1_ratio : float, default=None The Elastic-Net mixing parameter, with ``0 <= l1_ratio <= 1``. Only used if ``penalty='elasticnet'``. Setting ``l1_ratio=0`` is equivalent to using ``penalty='l2'``, while setting ``l1_ratio=1`` is equivalent to using ``penalty='l1'``. For ``0 < l1_ratio <1``, the penalty is a combination of L1 and L2. n_threads : int, default=1 Number of OpenMP threads to use. Returns ------- coefs : ndarray of shape (n_cs, n_features) or (n_cs, n_features + 1) List of coefficients for the Logistic Regression model. If fit_intercept is set to True then the second dimension will be n_features + 1, where the last item represents the intercept. For ``multiclass='multinomial'``, the shape is (n_classes, n_cs, n_features) or (n_classes, n_cs, n_features + 1). Cs : ndarray Grid of Cs used for cross-validation. n_iter : array of shape (n_cs,) Actual number of iteration for each Cs. Notes ----- You might get slightly different results with the solver liblinear than with the others since this uses LIBLINEAR which penalizes the intercept. .. versionchanged:: 0.19 The "copy" parameter was removed. csrr1sagr2) accept_sparsedtypeaccept_large_sparseFN) ensure_2drQrArz&To fit OvR, use the pos_class argumentr)T)rQcopyclassesyr@rQr1rbalanced)rOr2rH newton-cgnewton-choleskyrTF)orderrQrHr]r^z;Initialization coef is of shape %d, expected shape %d or %dzMInitialization coef is of shape (%d, %d), expected shape (%d, %d) or (%d, %d))ra)rC) base_loss fit_interceptrHr]coefr^axisrI)rY2r)rFe)rr)rzL-BFGS-Brh@)maxitermaxlsiprintgtolftol)methodjacargsoptions)extra_warning_msg) grad_hessfuncgradx0rsrltolverbose)re linear_lossl2_reg_strengthrzmax_iter n_threadsr{)XrW sample_weightrrOr2logl1r3r2)is_sagazRsolver must be one of {'liblinear', 'lbfgs', 'newton-cg', 'sag'}, got '%s' instead)B isinstancenumbersrnplogspacer<rfloat64rshapeuniquerrDlensizer7r&rQrdictr fit_transformzerosintonesarrayastyperhstacksumravelr.r loss_gradientlossgradientgradient_hessian_productTr expand_dimslistint32 enumerate searchsortedrminimizefinfofloatepsr! _LOGISTIC_SOLVER_CONVERGENCE_MSGxfunr"r-solve iterationr concatenateitemr/maxreshapenewaxisappendrT)7rrW pos_classCsrdr~rzr{r8re class_weightr:r9intercept_scalingrB random_state check_inputmax_squared_sumrl1_ratior n_samples n_featuresrVle class_weight_w0masky_bin mask_classesY_multilbinsw_sumrCrtargetrwrxhesswarm_start_sagcoefsn_iteriCr}rnopt_resn_iter_irssolcoef_ intercept_alphabetamulti_w0s7 r;_logistic_regression_pathrcsA X"g&''$ [Q # # 67D 1 1F&  * &.J J     U$ 7 7 71%%%GIzillG%l33L$[&#g,,GGK[M99  > > $$B)GLAAA'    W  %DD { " "9D=D0D "$ W  "*,,MD%DD { " ""*,,MD9D=D0DD ( ( ("*,,MD!".!"<"<"<= FFE Xc"ggRX . . .F" EE1 W  !QZ0O*** 6 6@@F'!K'$%!44    G."B H y'+BB { " "!QZ0Ov}oyID%    LB( ( (!QZ0O& /!#CQ& FFB}HH { " " !+    #^U[[]]J$?@@[[]] }}HH  & &m++qwU;;$$QwDaqQ\2a8++56),,, (B..$8:@A  - ' 'Aw|,,IBBB:b9b/EEEA~~#A;rz111}5 LL ) ) ) ) LL # # #q 8E??BHRLL& 00r=c ||}||}||}||}d\}}| t||}||}||}t||fid|d|d|d| d|d| d |d |d | d | d |d| d|d|ddd|d|\}}}t| |}|dkrtjddg|_n2|dkrtj||_ntd|z|1||k}tj|j tj }d||<t} t|}|D]}!|dkr|!tj ddf}!|r%|!ddddf|_|!dddf|_n|!|_d|_|,| |||||pi}t%|||}| ||||fi|||tj| |fS) a#Computes scores across logistic_regression_path Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training data. y : array-like of shape (n_samples,) or (n_samples, n_targets) Target labels. train : list of indices The indices of the train set. test : list of indices The indices of the test set. pos_class : int The class with respect to which we perform a one-vs-all fit. If None, then it is assumed that the given problem is binary. Cs : int or list of floats Each of the values in Cs describes the inverse of regularization strength. If Cs is as an int, then a grid of Cs values are chosen in a logarithmic scale between 1e-4 and 1e4. scoring : callable A string (see :ref:`scoring_parameter`) or a scorer callable object / function with signature ``scorer(estimator, X, y)``. For a list of scoring functions that can be used, look at :mod:`sklearn.metrics`. fit_intercept : bool If False, then the bias term is set to zero. Else the last term of each coef_ gives us the intercept. max_iter : int Maximum number of iterations for the solver. tol : float Tolerance for stopping criteria. class_weight : dict or 'balanced' Weights associated with classes in the form ``{class_label: weight}``. If not given, all classes are supposed to have weight one. The "balanced" mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data as ``n_samples / (n_classes * np.bincount(y))`` Note that these weights will be multiplied with sample_weight (passed through the fit method) if sample_weight is specified. verbose : int For the liblinear and lbfgs solvers set verbose to any positive number for verbosity. solver : {'lbfgs', 'liblinear', 'newton-cg', 'newton-cholesky', 'sag', 'saga'} Decides which solver to use. penalty : {'l1', 'l2', 'elasticnet'} Used to specify the norm used in the penalization. The 'newton-cg', 'sag' and 'lbfgs' solvers support only l2 penalties. 'elasticnet' is only supported by the 'saga' solver. dual : bool Dual or primal formulation. Dual formulation is only implemented for l2 penalty with liblinear solver. Prefer dual=False when n_samples > n_features. intercept_scaling : float Useful only when the solver 'liblinear' is used and self.fit_intercept is set to True. In this case, x becomes [x, self.intercept_scaling], i.e. a "synthetic" feature with constant value equals to intercept_scaling is appended to the instance vector. The intercept becomes intercept_scaling * synthetic feature weight Note! the synthetic feature weight is subject to l1/l2 regularization as all other features. To lessen the effect of regularization on synthetic feature weight (and therefore on the intercept) intercept_scaling has to be increased. multi_class : {'auto', 'ovr', 'multinomial'} If the option chosen is 'ovr', then a binary problem is fit for each label. For 'multinomial' the loss minimised is the multinomial loss fit across the entire probability distribution, *even when the data is binary*. 'multinomial' is unavailable when solver='liblinear'. random_state : int, RandomState instance Used when ``solver`` == 'sag', 'saga' or 'liblinear' to shuffle the data. See :term:`Glossary ` for details. max_squared_sum : float Maximum squared sum of X over samples. Used only in SAG solver. If None, it will be computed, going through all the samples. The value should be precomputed to speed up cross validation. sample_weight : array-like of shape(n_samples,) Array of weights that are assigned to individual samples. If not provided, then each sample is given unit weight. l1_ratio : float The Elastic-Net mixing parameter, with ``0 <= l1_ratio <= 1``. Only used if ``penalty='elasticnet'``. Setting ``l1_ratio=0`` is equivalent to using ``penalty='l2'``, while setting ``l1_ratio=1`` is equivalent to using ``penalty='l1'``. For ``0 < l1_ratio <1``, the penalty is a combination of L1 and L2. score_params : dict Parameters to pass to the `score` method of the underlying scorer. Returns ------- coefs : ndarray of shape (n_cs, n_features) or (n_cs, n_features + 1) List of coefficients for the Logistic Regression model. If fit_intercept is set to True then the second dimension will be n_features + 1, where the last item represents the intercept. Cs : ndarray Grid of Cs used for cross-validation. scores : ndarray of shape (n_cs,) Scores obtained for each Cs. n_iter : ndarray of shape(n_cs,) Actual number of iteration for each Cs. )NNNrrrdr8r~rrrBrzr{r:r9rrrFrr)r8rBr@rYr)rAz7multi_class should be either multinomial or ovr, got %drXrZr[r)rparamsindices)r&rLogisticRegressionrrclasses_rr7rrrrr rrrrscorer%)"rrWtraintestrrscoringrdr~rzrr{r8r9r:rrBrrrr score_paramsX_trainX_testy_trainy_testsw_trainsw_testrrlog_regrscoresws" r;_log_reg_scoring_pathrHs nhG tWFhG tWF"Hg ,]A>>  '%1 2  $m  v "\) K CT,+ "\!"E#$(%&h'E2v,!KHHHGe8RG,,  % %9W-- E S   "RZ888u VVF!!G LL %  "*aaa- A  %aaa"fIGM!"111b5G  GM!$G  ? MM'--g-NN O O O O'-2L/!LRVWWWL MM'''66JJ\JJ K K K K "bhv&& ..r=ceZdZUdZehddgdgeedddgeedddgdgeeddd geed hdgd gehd geedddgd gdgdegeeddddgehde edhgdZ ee d< d"ddddddddddddddddZ e dd#dZfdZd Zfd!ZxZS)$ra3 Logistic Regression (aka logit, MaxEnt) classifier. This class implements regularized logistic regression using the 'liblinear' library, 'newton-cg', 'sag', 'saga' and 'lbfgs' solvers. **Note that regularization is applied by default**. It can handle both dense and sparse input. Use C-ordered arrays or CSR matrices containing 64-bit floats for optimal performance; any other input format will be converted (and copied). The 'newton-cg', 'sag', and 'lbfgs' solvers support only L2 regularization with primal formulation, or no regularization. The 'liblinear' solver supports both L1 and L2 regularization, with a dual formulation only for the L2 penalty. The Elastic-Net regularization is only supported by the 'saga' solver. For :term:`multiclass` problems, only 'newton-cg', 'sag', 'saga' and 'lbfgs' handle multinomial loss. 'liblinear' and 'newton-cholesky' only handle binary classification but can be extended to handle multiclass by using :class:`~sklearn.multiclass.OneVsRestClassifier`. Read more in the :ref:`User Guide `. Parameters ---------- penalty : {'l1', 'l2', 'elasticnet', None}, default='l2' Specify the norm of the penalty: - `None`: no penalty is added; - `'l2'`: add a L2 penalty term and it is the default choice; - `'l1'`: add a L1 penalty term; - `'elasticnet'`: both L1 and L2 penalty terms are added. .. warning:: Some penalties may not work with some solvers. See the parameter `solver` below, to know the compatibility between the penalty and solver. .. versionadded:: 0.19 l1 penalty with SAGA solver (allowing 'multinomial' + L1) dual : bool, default=False Dual (constrained) or primal (regularized, see also :ref:`this equation `) formulation. Dual formulation is only implemented for l2 penalty with liblinear solver. Prefer dual=False when n_samples > n_features. tol : float, default=1e-4 Tolerance for stopping criteria. C : float, default=1.0 Inverse of regularization strength; must be a positive float. Like in support vector machines, smaller values specify stronger regularization. fit_intercept : bool, default=True Specifies if a constant (a.k.a. bias or intercept) should be added to the decision function. intercept_scaling : float, default=1 Useful only when the solver 'liblinear' is used and self.fit_intercept is set to True. In this case, x becomes [x, self.intercept_scaling], i.e. a "synthetic" feature with constant value equal to intercept_scaling is appended to the instance vector. The intercept becomes ``intercept_scaling * synthetic_feature_weight``. Note! the synthetic feature weight is subject to l1/l2 regularization as all other features. To lessen the effect of regularization on synthetic feature weight (and therefore on the intercept) intercept_scaling has to be increased. class_weight : dict or 'balanced', default=None Weights associated with classes in the form ``{class_label: weight}``. If not given, all classes are supposed to have weight one. The "balanced" mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data as ``n_samples / (n_classes * np.bincount(y))``. Note that these weights will be multiplied with sample_weight (passed through the fit method) if sample_weight is specified. .. versionadded:: 0.17 *class_weight='balanced'* random_state : int, RandomState instance, default=None Used when ``solver`` == 'sag', 'saga' or 'liblinear' to shuffle the data. See :term:`Glossary ` for details. solver : {'lbfgs', 'liblinear', 'newton-cg', 'newton-cholesky', 'sag', 'saga'}, default='lbfgs' Algorithm to use in the optimization problem. Default is 'lbfgs'. To choose a solver, you might want to consider the following aspects: - For small datasets, 'liblinear' is a good choice, whereas 'sag' and 'saga' are faster for large ones; - For :term:`multiclass` problems, all solvers except 'liblinear' minimize the full multinomial loss; - 'liblinear' can only handle binary classification by default. To apply a one-versus-rest scheme for the multiclass setting one can wrap it with the :class:`~sklearn.multiclass.OneVsRestClassifier`. - 'newton-cholesky' is a good choice for `n_samples` >> `n_features * n_classes`, especially with one-hot encoded categorical features with rare categories. Be aware that the memory usage of this solver has a quadratic dependency on `n_features * n_classes` because it explicitly computes the full Hessian matrix. .. warning:: The choice of the algorithm depends on the penalty chosen and on (multinomial) multiclass support: ================= ============================== ====================== solver penalty multinomial multiclass ================= ============================== ====================== 'lbfgs' 'l2', None yes 'liblinear' 'l1', 'l2' no 'newton-cg' 'l2', None yes 'newton-cholesky' 'l2', None no 'sag' 'l2', None yes 'saga' 'elasticnet', 'l1', 'l2', None yes ================= ============================== ====================== .. note:: 'sag' and 'saga' fast convergence is only guaranteed on features with approximately the same scale. You can preprocess the data with a scaler from :mod:`sklearn.preprocessing`. .. seealso:: Refer to the :ref:`User Guide ` for more information regarding :class:`LogisticRegression` and more specifically the :ref:`Table ` summarizing solver/penalty supports. .. versionadded:: 0.17 Stochastic Average Gradient descent solver. .. versionadded:: 0.19 SAGA solver. .. versionchanged:: 0.22 The default solver changed from 'liblinear' to 'lbfgs' in 0.22. .. versionadded:: 1.2 newton-cholesky solver. max_iter : int, default=100 Maximum number of iterations taken for the solvers to converge. multi_class : {'auto', 'ovr', 'multinomial'}, default='auto' If the option chosen is 'ovr', then a binary problem is fit for each label. For 'multinomial' the loss minimised is the multinomial loss fit across the entire probability distribution, *even when the data is binary*. 'multinomial' is unavailable when solver='liblinear'. 'auto' selects 'ovr' if the data is binary, or if solver='liblinear', and otherwise selects 'multinomial'. .. versionadded:: 0.18 Stochastic Average Gradient descent solver for 'multinomial' case. .. versionchanged:: 0.22 Default changed from 'ovr' to 'auto' in 0.22. .. deprecated:: 1.5 ``multi_class`` was deprecated in version 1.5 and will be removed in 1.7. From then on, the recommended 'multinomial' will always be used for `n_classes >= 3`. Solvers that do not support 'multinomial' will raise an error. Use `sklearn.multiclass.OneVsRestClassifier(LogisticRegression())` if you still want to use OvR. verbose : int, default=0 For the liblinear and lbfgs solvers set verbose to any positive number for verbosity. warm_start : bool, default=False When set to True, reuse the solution of the previous call to fit as initialization, otherwise, just erase the previous solution. Useless for liblinear solver. See :term:`the Glossary `. .. versionadded:: 0.17 *warm_start* to support *lbfgs*, *newton-cg*, *sag*, *saga* solvers. n_jobs : int, default=None Number of CPU cores used when parallelizing over classes if multi_class='ovr'". This parameter is ignored when the ``solver`` is set to 'liblinear' regardless of whether 'multi_class' is specified or not. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. l1_ratio : float, default=None The Elastic-Net mixing parameter, with ``0 <= l1_ratio <= 1``. Only used if ``penalty='elasticnet'``. Setting ``l1_ratio=0`` is equivalent to using ``penalty='l2'``, while setting ``l1_ratio=1`` is equivalent to using ``penalty='l1'``. For ``0 < l1_ratio <1``, the penalty is a combination of L1 and L2. Attributes ---------- classes_ : ndarray of shape (n_classes, ) A list of class labels known to the classifier. coef_ : ndarray of shape (1, n_features) or (n_classes, n_features) Coefficient of the features in the decision function. `coef_` is of shape (1, n_features) when the given problem is binary. In particular, when `multi_class='multinomial'`, `coef_` corresponds to outcome 1 (True) and `-coef_` corresponds to outcome 0 (False). intercept_ : ndarray of shape (1,) or (n_classes,) Intercept (a.k.a. bias) added to the decision function. If `fit_intercept` is set to False, the intercept is set to zero. `intercept_` is of shape (1,) when the given problem is binary. In particular, when `multi_class='multinomial'`, `intercept_` corresponds to outcome 1 (True) and `-intercept_` corresponds to outcome 0 (False). 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 n_iter_ : ndarray of shape (n_classes,) or (1, ) Actual number of iterations for all classes. If binary or multinomial, it returns only 1 element. For liblinear solver, only the maximum number of iteration across all classes is given. .. versionchanged:: 0.20 In SciPy <= 1.0.0 the number of lbfgs iterations may exceed ``max_iter``. ``n_iter_`` will now report at most ``max_iter``. See Also -------- SGDClassifier : Incrementally trained logistic regression (when given the parameter ``loss="log_loss"``). LogisticRegressionCV : Logistic regression with built-in cross validation. Notes ----- The underlying C implementation uses a random number generator to select features when fitting the model. It is thus not uncommon, to have slightly different results for the same input data. If that happens, try with a smaller tol parameter. Predict output may not match that of standalone liblinear in certain cases. See :ref:`differences from liblinear ` in the narrative documentation. References ---------- L-BFGS-B -- Software for Large-scale Bound-constrained Optimization Ciyou Zhu, Richard Byrd, Jorge Nocedal and Jose Luis Morales. http://users.iems.northwestern.edu/~nocedal/lbfgsb.html LIBLINEAR -- A Library for Large Linear Classification https://www.csie.ntu.edu.tw/~cjlin/liblinear/ SAG -- Mark Schmidt, Nicolas Le Roux, and Francis Bach Minimizing Finite Sums with the Stochastic Average Gradient https://hal.inria.fr/hal-00860051/document SAGA -- Defazio, A., Bach F. & Lacoste-Julien S. (2014). :arxiv:`"SAGA: A Fast Incremental Gradient Method With Support for Non-Strongly Convex Composite Objectives" <1407.0202>` Hsiang-Fu Yu, Fang-Lan Huang, Chih-Jen Lin (2011). Dual coordinate descent methods for logistic regression and maximum entropy models. Machine Learning 85(1-2):41-75. https://www.csie.ntu.edu.tw/~cjlin/papers/maxent_dual.pdf Examples -------- >>> from sklearn.datasets import load_iris >>> from sklearn.linear_model import LogisticRegression >>> X, y = load_iris(return_X_y=True) >>> clf = LogisticRegression(random_state=0).fit(X, y) >>> clf.predict(X[:2, :]) array([0, 0]) >>> clf.predict_proba(X[:2, :]) array([[9.8...e-01, 1.8...e-02, 1.4...e-08], [9.7...e-01, 2.8...e-02, ...e-08]]) >>> clf.score(X, y) 0.97... For a comaprison of the LogisticRegression with other classifiers see: :ref:`sphx_glr_auto_examples_classification_plot_classification_probability.py`. >rr3r4Nbooleanrleftclosedrightneitherr\r>rOr2rHr1r]r^r{r)both>r@r?rA deprecated)r9r:rzrrdrrrr8r~r{ warm_startn_jobsrrB_parameter_constraintsr3FrGrITrHrF)r:rzrrdrrrr8r~rBr{rrrc||_||_||_||_||_||_||_||_| |_| |_ | |_ | |_ | |_ ||_ ||_dSN)r9r:rzrrdrrrr8r~rBr{rrr)selfr9r:rzrrdrrrr8r~rBr{rrrs r;__init__zLogisticRegression.__init__hsv&  *!2((   & $   r=prefer_skip_nested_validationcj  tjjjjdkr3j,t jdjjdkrjtdj.j dkrt jdtj dnj jdkr tj }ntj tj g}td |d d v \ttj_jjd kr3t'jdkrt jdt(nLjdvrt jdt(n(jdkrt jdt(ndt+t'jdkrt-jdkr9t jdt-jt1j jjjjjjjjj \_ _!_"Sdvr$tGd$ndt'j}j}|dkrtd|dzt'jdkr d}|dd}j%rtMdd}nd}|7jr0tj'|j!ddtj(fd}d krdg}|g}|dg|z}tStTdvrd }nd!}d"vr.t'|dkrt-jdkrdndtWjj|# f d$tY||D} tY| \} } } tj-| tj.%dddf_"j/d} d kr| dd_ nNtj-| _ j 0|| tcjz_ jr/j ddd&f_!j dddd&f_ ntj2|_!S)'an Fit the model according to the given training data. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training vector, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) Target vector relative to X. sample_weight : array-like of shape (n_samples,) default=None Array of weights that are assigned to individual samples. If not provided, then each sample is given unit weight. .. versionadded:: 0.17 *sample_weight* support to LogisticRegression. Returns ------- self Fitted estimator. Notes ----- The SAGA solver supports both float64 and float32 bit arrays. r4NzNl1_ratio parameter is only used when penalty is 'elasticnet'. Got (penalty={})z6l1_ratio must be specified when penalty is elasticnet.rIz>Setting penalty=None will ignore the C and l1_ratio parametersr3rHrMrrNrPrQrarRrAr'multi_class' was deprecated in version 1.5 and will be removed in 1.7. From then on, binary problems will be fit as proper binary logistic regression models (as if multi_class='ovr' were set). Leave it to its default value to avoid this warning.rAr?'multi_class' was deprecated in version 1.5 and will be removed in 1.7. From then on, it will always use 'multinomial'. Leave it to its default value to avoid this warning.r@z'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegression(..)) instead. Leave it to its default value to avoid this warning.r?r1r)z]'n_jobs' > 1 does not have any effect when 'solver' is set to 'liblinear'. Got 'n_jobs' = {}.rrTsquaredeThis solver needs samples of at least 2 classes in the data, but the data contains only one class: %rrrrfthreads processesrbrr{preferc3 K|]f\}} fid|dgd jd jd jd jd dd jd jd d d jd |d dd dVgdS)rrrrdrzr{r8rBr~rrFrrer9rrrN)rrdrzr{r~rr).0class_warm_start_coef_C_rrrBr path_funcr9rrr8rWs r; z)LogisticRegression.fit..Fs@X X ,)(+ I   !& 44      #00  HH   v (K  ".. "E ".. &%   ! "!0# $,m% &$)' X X X X X X r=rXrY)3r<r8r9r:rwarningswarnformatr7rrinfrfloat32r(r rrrBr FutureWarningrDrrrrdrrr{r~rzrrrn_iter_rrrgetattrrrr$rr#zipasarrayrrrrr)rrrWr_dtyperCrwarm_start_coefr fold_coefs__rrr rrBrr r9r8s```` @@@@@@@r;fitzLogisticRegression.fits<t{DL$)DD << ' 'DM,E M%vdl33    << ' 'DM,AUVV V < v}} TBGGBlG W  ZFFj"*-F   &.J J   1 %Q''' !  &  } , ,T]1C1Cq1H1H ML      !8 8 8 ML       & & ML     !K(fc$->P>PQQ [  ,,11 #V$4T[$A$ABB 9G"&!    !+999 5DJK _ $ $'4888<<>>OO"O && = q=='{+  t}   " "I|H ? #%dGT::OO"O  &4+= & iBJ!?aO - ' 'vH./O  "#fy0O566  _ $ $FF F ? ? ?H "" --22IIIWhdk4(?(??DJ   2"jB/DOAAAssF+DJJ hy11DO r=cTt||jdvp#|jdvo|jjdkp |jdk}|r!t |S||}|jdkrtj | |f}n|}t|dS)a Probability estimates. The returned estimates for all classes are ordered by the label of classes. For a multi_class problem, if multi_class is set to be "multinomial" the softmax function is used to find the predicted probability of each class. Else use a one-vs-rest approach, i.e. calculate the probability of each class assuming it to be positive using the logistic function and normalize these values across all the classes. Parameters ---------- X : array-like of shape (n_samples, n_features) Vector to be scored, where `n_samples` is the number of samples and `n_features` is the number of features. Returns ------- T : array-like of shape (n_samples, n_classes) Returns the probability of the sample for each class in the model, where classes are ordered as they are in ``self.classes_``. )r@r)r?rrr1r)Fr_) r'rBrrr8super_predict_proba_lrdecision_functionndimrc_r)rrr@decision decision_2d __class__s r; predict_probaz LogisticRegression.predict_probass4 /1   6 6 H#q(FDK;,F   477,,Q// /--a00H}!!!eXIx$78 & ;U333 3r=cPtj||S)ap Predict logarithm of probability estimates. The returned estimates for all classes are ordered by the label of classes. Parameters ---------- X : array-like of shape (n_samples, n_features) Vector to be scored, where `n_samples` is the number of samples and `n_features` is the number of features. Returns ------- T : array-like of shape (n_samples, n_classes) Returns the log-probability of the sample for each class in the model, where classes are ordered as they are in ``self.classes_``. )rrr')rrs r;predict_log_probaz$LogisticRegression.predict_log_probas"&vd((++,,,r=c`t}d|j_|SNTr__sklearn_tags__ input_tagssparsertagsr&s r;r-z#LogisticRegression.__sklearn_tags__'ww''))!% r=)r3r)__name__ __module__ __qualname____doc__rrrrrrr__annotations__rr rr'r)r- __classcell__r&s@r;rr's4eeP J999::DA q$v6667htQW555 6#&htQYGGGHzz:,77>'( JUUU   Xh4???@; k"XdAq888$? J555 6 6 F::|n-- . . '$$D6!!   #!!!!!!!!!!F\555eee65eN*4*4*4*4*4X---*r=rceZdZUdZiejZeed<dD]Ze ee e e ddddgd ge eeedgddgd ge hd gd d ddddddddddddddddddZedddZddZdZdZfdZxZS) LogisticRegressionCVa95Logistic Regression CV (aka logit, MaxEnt) classifier. See glossary entry for :term:`cross-validation estimator`. This class implements logistic regression using liblinear, newton-cg, sag or lbfgs optimizer. The newton-cg, sag and lbfgs solvers support only L2 regularization with primal formulation. The liblinear solver supports both L1 and L2 regularization, with a dual formulation only for the L2 penalty. Elastic-Net penalty is only supported by the saga solver. For the grid of `Cs` values and `l1_ratios` values, the best hyperparameter is selected by the cross-validator :class:`~sklearn.model_selection.StratifiedKFold`, but it can be changed using the :term:`cv` parameter. The 'newton-cg', 'sag', 'saga' and 'lbfgs' solvers can warm-start the coefficients (see :term:`Glossary`). Read more in the :ref:`User Guide `. Parameters ---------- Cs : int or list of floats, default=10 Each of the values in Cs describes the inverse of regularization strength. If Cs is as an int, then a grid of Cs values are chosen in a logarithmic scale between 1e-4 and 1e4. Like in support vector machines, smaller values specify stronger regularization. fit_intercept : bool, default=True Specifies if a constant (a.k.a. bias or intercept) should be added to the decision function. cv : int or cross-validation generator, default=None The default cross-validation generator used is Stratified K-Folds. If an integer is provided, then it is the number of folds used. See the module :mod:`sklearn.model_selection` module for the list of possible cross-validation objects. .. versionchanged:: 0.22 ``cv`` default value if None changed from 3-fold to 5-fold. dual : bool, default=False Dual (constrained) or primal (regularized, see also :ref:`this equation `) formulation. Dual formulation is only implemented for l2 penalty with liblinear solver. Prefer dual=False when n_samples > n_features. penalty : {'l1', 'l2', 'elasticnet'}, default='l2' Specify the norm of the penalty: - `'l2'`: add a L2 penalty term (used by default); - `'l1'`: add a L1 penalty term; - `'elasticnet'`: both L1 and L2 penalty terms are added. .. warning:: Some penalties may not work with some solvers. See the parameter `solver` below, to know the compatibility between the penalty and solver. scoring : str or callable, default=None A string (see :ref:`scoring_parameter`) or a scorer callable object / function with signature ``scorer(estimator, X, y)``. For a list of scoring functions that can be used, look at :mod:`sklearn.metrics`. The default scoring option used is 'accuracy'. solver : {'lbfgs', 'liblinear', 'newton-cg', 'newton-cholesky', 'sag', 'saga'}, default='lbfgs' Algorithm to use in the optimization problem. Default is 'lbfgs'. To choose a solver, you might want to consider the following aspects: - For small datasets, 'liblinear' is a good choice, whereas 'sag' and 'saga' are faster for large ones; - For multiclass problems, all solvers except 'liblinear' minimize the full multinomial loss; - 'liblinear' might be slower in :class:`LogisticRegressionCV` because it does not handle warm-starting. - 'liblinear' can only handle binary classification by default. To apply a one-versus-rest scheme for the multiclass setting one can wrap it with the :class:`~sklearn.multiclass.OneVsRestClassifier`. - 'newton-cholesky' is a good choice for `n_samples` >> `n_features * n_classes`, especially with one-hot encoded categorical features with rare categories. Be aware that the memory usage of this solver has a quadratic dependency on `n_features * n_classes` because it explicitly computes the full Hessian matrix. .. warning:: The choice of the algorithm depends on the penalty chosen and on (multinomial) multiclass support: ================= ============================== ====================== solver penalty multinomial multiclass ================= ============================== ====================== 'lbfgs' 'l2' yes 'liblinear' 'l1', 'l2' no 'newton-cg' 'l2' yes 'newton-cholesky' 'l2', no 'sag' 'l2', yes 'saga' 'elasticnet', 'l1', 'l2' yes ================= ============================== ====================== .. note:: 'sag' and 'saga' fast convergence is only guaranteed on features with approximately the same scale. You can preprocess the data with a scaler from :mod:`sklearn.preprocessing`. .. versionadded:: 0.17 Stochastic Average Gradient descent solver. .. versionadded:: 0.19 SAGA solver. .. versionadded:: 1.2 newton-cholesky solver. tol : float, default=1e-4 Tolerance for stopping criteria. max_iter : int, default=100 Maximum number of iterations of the optimization algorithm. class_weight : dict or 'balanced', default=None Weights associated with classes in the form ``{class_label: weight}``. If not given, all classes are supposed to have weight one. The "balanced" mode uses the values of y to automatically adjust weights inversely proportional to class frequencies in the input data as ``n_samples / (n_classes * np.bincount(y))``. Note that these weights will be multiplied with sample_weight (passed through the fit method) if sample_weight is specified. .. versionadded:: 0.17 class_weight == 'balanced' n_jobs : int, default=None Number of CPU cores used during the cross-validation loop. ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context. ``-1`` means using all processors. See :term:`Glossary ` for more details. verbose : int, default=0 For the 'liblinear', 'sag' and 'lbfgs' solvers set verbose to any positive number for verbosity. refit : bool, default=True If set to True, the scores are averaged across all folds, and the coefs and the C that corresponds to the best score is taken, and a final refit is done using these parameters. Otherwise the coefs, intercepts and C that correspond to the best scores across folds are averaged. intercept_scaling : float, default=1 Useful only when the solver 'liblinear' is used and self.fit_intercept is set to True. In this case, x becomes [x, self.intercept_scaling], i.e. a "synthetic" feature with constant value equal to intercept_scaling is appended to the instance vector. The intercept becomes ``intercept_scaling * synthetic_feature_weight``. Note! the synthetic feature weight is subject to l1/l2 regularization as all other features. To lessen the effect of regularization on synthetic feature weight (and therefore on the intercept) intercept_scaling has to be increased. multi_class : {'auto, 'ovr', 'multinomial'}, default='auto' If the option chosen is 'ovr', then a binary problem is fit for each label. For 'multinomial' the loss minimised is the multinomial loss fit across the entire probability distribution, *even when the data is binary*. 'multinomial' is unavailable when solver='liblinear'. 'auto' selects 'ovr' if the data is binary, or if solver='liblinear', and otherwise selects 'multinomial'. .. versionadded:: 0.18 Stochastic Average Gradient descent solver for 'multinomial' case. .. versionchanged:: 0.22 Default changed from 'ovr' to 'auto' in 0.22. .. deprecated:: 1.5 ``multi_class`` was deprecated in version 1.5 and will be removed in 1.7. From then on, the recommended 'multinomial' will always be used for `n_classes >= 3`. Solvers that do not support 'multinomial' will raise an error. Use `sklearn.multiclass.OneVsRestClassifier(LogisticRegressionCV())` if you still want to use OvR. random_state : int, RandomState instance, default=None Used when `solver='sag'`, 'saga' or 'liblinear' to shuffle the data. Note that this only applies to the solver and not the cross-validation generator. See :term:`Glossary ` for details. l1_ratios : list of float, default=None The list of Elastic-Net mixing parameter, with ``0 <= l1_ratio <= 1``. Only used if ``penalty='elasticnet'``. A value of 0 is equivalent to using ``penalty='l2'``, while 1 is equivalent to using ``penalty='l1'``. For ``0 < l1_ratio <1``, the penalty is a combination of L1 and L2. Attributes ---------- classes_ : ndarray of shape (n_classes, ) A list of class labels known to the classifier. coef_ : ndarray of shape (1, n_features) or (n_classes, n_features) Coefficient of the features in the decision function. `coef_` is of shape (1, n_features) when the given problem is binary. intercept_ : ndarray of shape (1,) or (n_classes,) Intercept (a.k.a. bias) added to the decision function. If `fit_intercept` is set to False, the intercept is set to zero. `intercept_` is of shape(1,) when the problem is binary. Cs_ : ndarray of shape (n_cs) Array of C i.e. inverse of regularization parameter values used for cross-validation. l1_ratios_ : ndarray of shape (n_l1_ratios) Array of l1_ratios used for cross-validation. If no l1_ratio is used (i.e. penalty is not 'elasticnet'), this is set to ``[None]`` coefs_paths_ : ndarray of shape (n_folds, n_cs, n_features) or (n_folds, n_cs, n_features + 1) dict with classes as the keys, and the path of coefficients obtained during cross-validating across each fold and then across each Cs after doing an OvR for the corresponding class as values. If the 'multi_class' option is set to 'multinomial', then the coefs_paths are the coefficients corresponding to each class. Each dict value has shape ``(n_folds, n_cs, n_features)`` or ``(n_folds, n_cs, n_features + 1)`` depending on whether the intercept is fit or not. If ``penalty='elasticnet'``, the shape is ``(n_folds, n_cs, n_l1_ratios_, n_features)`` or ``(n_folds, n_cs, n_l1_ratios_, n_features + 1)``. scores_ : dict dict with classes as the keys, and the values as the grid of scores obtained during cross-validating each fold, after doing an OvR for the corresponding class. If the 'multi_class' option given is 'multinomial' then the same scores are repeated across all classes, since this is the multinomial class. Each dict value has shape ``(n_folds, n_cs)`` or ``(n_folds, n_cs, n_l1_ratios)`` if ``penalty='elasticnet'``. C_ : ndarray of shape (n_classes,) or (n_classes - 1,) Array of C that maps to the best scores across every class. If refit is set to False, then for each class, the best C is the average of the C's that correspond to the best scores for each fold. `C_` is of shape(n_classes,) when the problem is binary. l1_ratio_ : ndarray of shape (n_classes,) or (n_classes - 1,) Array of l1_ratio that maps to the best scores across every class. If refit is set to False, then for each class, the best l1_ratio is the average of the l1_ratio's that correspond to the best scores for each fold. `l1_ratio_` is of shape(n_classes,) when the problem is binary. n_iter_ : ndarray of shape (n_classes, n_folds, n_cs) or (1, n_folds, n_cs) Actual number of iterations for all classes, folds and Cs. In the binary or multinomial cases, the first dimension is equal to 1. If ``penalty='elasticnet'``, the shape is ``(n_classes, n_folds, n_cs, n_l1_ratios)`` or ``(1, n_folds, n_cs, n_l1_ratios)``. 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 -------- LogisticRegression : Logistic regression without tuning the hyperparameter `C`. Examples -------- >>> from sklearn.datasets import load_iris >>> from sklearn.linear_model import LogisticRegressionCV >>> X, y = load_iris(return_X_y=True) >>> clf = LogisticRegressionCV(cv=5, random_state=0).fit(X, y) >>> clf.predict(X[:2, :]) array([0, 0]) >>> clf.predict_proba(X[:2, :]).shape (2, 3) >>> clf.score(X, y) 0.98... r)rrrr)Nrrz array-like cv_objectr>rr3r4)rcvr l1_ratiosrefitr9rETFr3rHrGrFrrIr)rrdr=r:r9rr8rzr~rrr{r?rrBrr>c||_||_||_||_||_||_||_| |_| |_| |_ | |_ ||_ | |_ ||_ ||_||_||_dSr)rrdr=r:r9rrzr~rrr{r8r?rrBrr>)rrrdr=r:r9rr8rzr~rrr{r?rrBrr>s r;rzLogisticRegressionCV.__init__s**     (    !2&("r=rc \ !"#$%&'()t|dtjjj)jdkr\j6t jdkstdjDrtdjzj#n6j,tj d jdg#tdtjd )d v \tj t#$$t) t*r $fd  D $jx}_$$j}j&jd kr3t jdkrtj dt2nLjdvrtj dt2n(jdkrtj dt2nd&t5&)t |&)dvr$t7d%nd%t;rt=dfdi|(nIt?(t?i(_ t?|(_!(j!j"d<tGj$d}tK|j&fi(j j&"t |}|dkrtd|dz|dkrd}|dd}|dd}&d krdgx} } n|} |} dkrRtO tj(t j t+tS  tUtV'jdvrd } nd!} tYj-j.| " "#%&'()f d#| D} t_| \!} }}| d_0&d krtj1!t "t #t j0z|d$f!tj2!dd!tj2!dd!tj1|dt "t j0t #zf_3tj4||ddf}ntj1!|t "t j0t #zd$f!tj1||t "t j0t #zf_3tj1||t "d$f}t+t_||_5t+t_|!_6tK_7tK_8tj9|j:df_;tj<|_=tSt_| | D]\}\}}&dkrj5|}j6|!n|d}j>ri|?d%@}|t j0z}j0|}j7A||t j0z}#|}j8A|&d kr'tjB!dddd|ddfd%}n#tjB!dd|ddfd%}tfid&|d'|gd()d)jDd*|d+jEd,jFd-jd. d/&d0t9dj.dz d1jGd2d3d4%dd5|\}}}|d}nTtj@|d%&dkr>tjB!fd6tt "Dd%}n=tjB!fd7tt "Dd%}t j0z}j7AtjBj0|jdkrJt j0z}j8AtjB#|nj8Ad&d krvtj4j7|_7tj4j8|_8|dddj:df_;jDr|ddd$f_=s|dj:dj;|<jDr|d$j=|<tjIj7_7tjIj8_8tjI#_Jjtj6D]o\}}|1t "jJjKj0jKd$fj6|<tjLj6|d8j6|<pj5D]n\}}|1t "jJjKj0jKfj5|<tjLj5|d9j5|<oj31d$t "jJjKj0jKf_3tjLj3d:_3S);a@Fit the model according to the given training data. Parameters ---------- X : {array-like, sparse matrix} of shape (n_samples, n_features) Training vector, where `n_samples` is the number of samples and `n_features` is the number of features. y : array-like of shape (n_samples,) Target vector relative to X. sample_weight : array-like of shape (n_samples,) default=None Array of weights that are assigned to individual samples. If not provided, then each sample is given unit weight. **params : dict Parameters to pass to the underlying splitter and scorer. .. versionadded:: 1.4 Returns ------- self : object Fitted LogisticRegressionCV estimator. rr4Nrc3dK|]+}t|tj p |dkp|dkV,dS)rr)N)rrNumber)r rs r;rz+LogisticRegressionCV.fit..7s_ ! 'x@@@(#a<(#a< r=zGl1_ratios must be a list of numbers between 0 and 1; got (l1_ratios=%r)zOl1_ratios parameter is only used when penalty is 'elasticnet'. Got (penalty={})rMrrNrcPi|]"\}}|gd|#S)r) transform)r clsv label_encoders r; z,LogisticRegressionCV.fit.._sA9?a ''..q11r=rArrrrr@z'multi_class' was deprecated in version 1.5 and will be removed in 1.7. Use OneVsRestClassifier(LogisticRegressionCV(..)) instead. Leave it to its default value to avoid this warning.r?rTrr)splitr) classifierrr)r\rUrrrc 3* K|]}D]\}}D]} ||fid|djdjdjdjddjdjdjd d jd d jd j d d d|d j j VdS)rrrdr9r:r8rzr~r{rrrBrrrrrrN) rrdr9r:rzr~r{rrrscorerr)r labelrrrrrfolds l1_ratios_rrBr  routed_paramsrrr8rWs r;rz+LogisticRegressionCV.fit..sX X 2$5X X 4t&7X X 65 I      %   77  #00   YY v HH    *\    (K! "#'"8"8# $"..% &!0' (,m) *"+ ,+177- X X X X X X X X r=rYrfrrr8rdrer~rzr9rrBr{rrFrrc6g|]}||ddfSrr r best_indices coefs_pathss r; z,LogisticRegressionCV.fit..Rs-WWWQ Q%:;WWWr=c<g|]}dd||ddfSrrTrUs r;rXz,LogisticRegressionCV.fit..WsC !(1l1oqqq(@Ar=)rrr)rj)rrr))rr)rjr)Mrr<r8r9r:r>ranyr7rrrr(rrr rrrrErritemsrrBrrDrrrrrsplitterrNrr r=rrJrarangerr$rr#rr{rCs_rswapaxesrtilescores_ coefs_paths_r  l1_ratio_emptyrrrrr?rargmaxrmeanrrdr~rzrrangerrQr transpose)*rrrWrrrVencoded_labelsr=rCiter_encoded_labels iter_classesrrrrrindexrF encoded_label best_index best_index_Cr  best_index_l1rc coef_initrrbest_indices_Cbest_indices_l1 coefs_pathrrVrrWrPrQrHrrBr rRr8s*```` @@@@@@@@@@@r;rzLogisticRegressionCV.fits4 6 &$...t{DL$)DD << ' '&t~&&!++ %)N ,!248NCJJ~) 88>t|8L8L J  * &.J J   1 %Q'''( %**1--  # #A & & lD ) ) COCUCUCWCWL #0"88$-&001GHH&  } , ,T]1C1Cq1H1H ML      !8 8 8 ML       & & ML     !K(fc'llKK _ $ $'4888<<>>OO"O    L+, MM"GGM%*___M "#(v#6#6#6M (>K $*?;dgqT 2 2 2XRXaCCm&<&BCCDD'' q==&qz*  >>I+ABB/NabbkG - ' '26 7 ,,"0 "L : % %/biDM0B0B&C&CqL , 7 788L122  ;/ ) )FF FWhdk4 %$(#4#:#:#<#<  Z)3););ZZ!5tx}bI**!#&*,%c*L**!#&&#l0022 O O U$)MMZZ!5tx}E%% S!%'Lc1BI$N$N S!!<//SZZ!5tx}EDL< lCCDL r=c t||d|}trt|dfd|i|}n4t }t i|_|||jjd<||||fi|jjS)amScore using the `scoring` option on the given test data and labels. Parameters ---------- X : array-like of shape (n_samples, n_features) Test samples. y : array-like of shape (n_samples,) True labels for X. sample_weight : array-like of shape (n_samples,), default=None Sample weights. **score_params : dict Parameters to pass to the `score` method of the underlying scorer. .. versionadded:: 1.4 Returns ------- score : float Score of self.predict(X) w.r.t. y. rrrK)r _get_scorerrrrrNr)rrrWrrrrRs r;rzLogisticRegressionCV.scores0 ,g666""$$    L+, MM"GGM#(r???M (>K $*?;w    "(    r=ct|jj||jt dd|t dddd}|S)ajGet metadata routing of this object. Please check :ref:`User Guide ` on how the routing mechanism works. .. versionadded:: 1.4 Returns ------- routing : MetadataRouter A :class:`~sklearn.utils.metadata_routing.MetadataRouter` encapsulating routing information. )ownerrrJ)callercallee)r\method_mappingr)rNr{)rr&r3add_self_requestaddr=rrv)rrouters r;get_metadata_routingz)LogisticRegressionCV.get_metadata_routings !8 9 9 9  d # # S,22%2PPS'')),GG44E'22   r=c2|jpd}t|S)zpGet the scorer based on the scoring method specified. The default scoring method is `accuracy`. accuracy)rr )rrs r;rvz LogisticRegressionCV._get_scorers,,*'"""r=c`t}d|j_|Sr+r,r0s r;r-z%LogisticRegressionCV.__sklearn_tags__r2r=r)r3r4r5r6rrrr7parampopupdaterrrsetrcallablerr rrrrvr-r8r9s@r;r;r;s``D $Q&8&O#PDPPP0**""5))))!!8Haf===|L-" 33'7'7'9'9#:#:;;XtL&-[" #=#=#=>>?           '%#%#%#%#%#N\55565B - - - - ^>###r=r;)NrETrFrGrrHNNFr3rIr?NTNNNr))Lr6rrrrnumpyrjoblibrscipyrsklearn.metricsr _loss.lossr r baser metricsr model_selectionr preprocessingrr svm._baserutilsrrrrrutils._param_validationrrr utils.extmathrrutils.metadata_routingrrrrrutils.multiclassr utils.optimizer!r"utils.parallelr#r$utils.validationr%r&r'r(_baser*r+r,_glm.glmr- _linear_lossr._sagr/rr<rDrrrr;rTr=r;rs""""""""######,,,,,,>>>>>>>> &&&&&&88888888&&&&&&CBBBBBBBBB........<;;;;;????????........ IHHHHHHHHH******))))))!(*       +a1a1a1a1J\/\/\/~P P P P P .P P P ft t t t t -/Dmt t t t t r=