KimSSrSSKrSSKrSSKJrJr SSKrSSKJr SSK J r J r SSK J r SSKJrJrJr SSKJr SS KJr SS KJr SS KJrJr SS KJr SS KJr SSKJ r SSK!J"r"J#r#J$r$J%r%J&r& SSK'J(r(J)r)J*r* SSK+J,r,J-r- SSK.J/r/ SSK0J1r1J2r2J3r3J4r4J5r5 SSK6J7r7 SSK8J9r9J:r: SSK;JJ?r?J@r@JArAJBrB SrCSrDSSSSSSSSSS S!SSSSSS"S#.S$jrES%rF"S&S'\\\5rG"S(S)\G\\5rHg)*z Logistic Regression N)IntegralReal)optimize)HalfBinomialLossHalfMultinomialLoss) _fit_context) BaseEstimatorLinearClassifierMixinSparseCoefMixin)NewtonCholeskySolver)LinearModelLoss) sag_solver) get_scorerget_scorer_names)check_cv) LabelEncoder)_fit_liblinear)Bunch check_arraycheck_consistent_lengthcheck_random_statecompute_class_weight)HiddenInterval StrOptions) row_normssoftmax)"_get_additional_lbfgs_options_dict)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_datazPlease also refer to the documentation for alternative solver options: https://scikit-learn.org/stable/modules/linear_model.html#logistic-regressioncUS;aUS;a[SUSUS35eUS:waU(a[SUSU35eUS:XaUS :wa[S US 35eUS:XaUc [S 5eU$) N) liblinearsaga)l2NzSolver z+ supports only 'l2' or None penalties, got z penalty.r.z$ supports only dual=False, got dual= elasticnetr/z;Only 'saga' solver supports elasticnet penalty, got solver=.zJC=np.inf as well as penalty=None is not supported for the liblinear solver) ValueError)solverpenaltyduals `/var/www/html/dynamic-report/venv/lib/python3.13/site-packages/sklearn/linear_model/_logistic.py _check_solverr8?s **wl/JfXH R   76(*NtfUVV,6V#3I&QR S   X   M Td-C6?lbfgsFr0?)Cs fit_interceptmax_itertolverboser4coef class_weightr6r5intercept_scaling random_state check_inputmax_squared_sum sample_weightl1_ratio n_threadsc[U[R5(a[R"SSU5n[ XU 5nU(a3[ US[RUS;S9n[ USSS9n[X5 UcU b[UXRS S 9nURunn[U5nUS :HnUS :XaU(d [S 5e[U5n[5R!U5nU b"[#XUUS9nUUUR%U5-nU(ao[R&"U[)U5-URS9nXS:Hn[R*"URURS9nUS :XaSUU)'OhSUU)'OaUR%U5R-URSS9n[R&"UR.U[)U5-4SURS9nUS;aUcUO[R0"U5nU GbBU(aU R2S:Xa&U RSU[)U5-:XaU USS&GOU R2S :Xa;U RSS:Xa(U RSU[)U5-:Xa U SUSS&OSU RSURSURSS3n[U5eU R2S :XaKU RSU:Xa8U RSU[)U5-:XaU USS2SU RS24'O'SU RSUR3n[U5eU(aiWn [5[75US9n!US:Xa U!R8n"O*US:Xa$U!R:n"U!R<n#U!R>n$S[R@"USS 90n%O}[5[CUR.S!9US9n!Wn US;aURESS"9nUS:Xa U!R8n"O*US:Xa$U!R:n"U!R<n#U!R>n$SURF0n%[I5n&[R&"[U5[RJS9n'[MU5GHun(n)US:XaS#U)W-- n*/S$Q[RN"[RP"/S%Q5U5n+[RRT"W"US&S UU UU*U4US'US([RV"[X5RZ-S).[]S*U+5ES+9n,[_UU,U[`S,9n-U,RbU,Rdn!nGO]US:Xa$S#U)W-- n*UU UU*U4n.[gW$W"W#UU.UUUS-9unn-GO3US.:Xa5S#U)W-- n*[iUU!U*UUUUS/9n/U/RkUU US09nU/Rln-OUS :Xah[oUU U)UU SU U UUUUUS19 un0n1n-U(a'[Rp"U0RE5U1/5nOU0RE5nU-Rs5n-OUS2;asU(aS3n!OU R-URSS9n S4n!U S5:XaSn2S#U)- n3O!U S6:XaS#U)- n2Sn3OS#U)- SU- -n2S#U)- U-n3[uUU UU!U2U3UUUUSUU%US7:HS89unn-n%OS9US:3n[U5eU(a U&RwURy55 O@US;a[Rz"UUS;4SS"9n4OUn4U&RwU4Ry55 U-U'U('GM [RP"U&5[RP"U5U'4$)`. 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. classes : ndarray A list of class labels known to the classifier. 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_classes, features + int(fit_intercept)) or (1, n_features + int(fit_intercept)) or (n_features + int(fit_intercept)), 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 or 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. 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_classes, n_features + int(fit_intercept)) or (n_cs, n_features + int(fit_intercept)) List of coefficients for the Logistic Regression model. If fit_intercept is set to True, then the last dimension will be n_features + 1, where the last item represents the intercept. For binary problems the second dimension in n_classes is dropped, i.e. the shape will be `(n_cs, n_features + int(fit_intercept))`. Cs : ndarray Grid of Cs used for cross-validation. n_iter : array of shape (n_cs,) Actual number of iteration for each C in 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. csrr.sagr/) accept_sparsedtypeaccept_large_sparseFN) ensure_2drUT)rUcopyr.The 'liblinear' solver does not support multiclass classification (n_classes >= 3). Either use another solver or wrap the estimator in a OneVsRestClassifier to keep applying a one-versus-rest scheme.classesyrKrUr?grXF)orderrU)r= newton-cgnewton-choleskyrz Initialization coef is of shape z, expected shape z or (1, )) base_lossrAr=rcrEaxis) n_classes)rbr>)2r?r;e)rr?rYzL-BFGS-Brk@)maxitermaxlsgtolftoliprint)methodjacargsoptions)extra_warning_msg) grad_hessfuncgradx0rvrorCrDrd)rE linear_lossl2_reg_strengthrCrBrMrD)Xr]rKrKrSr/log multinomiall1r0r/)is_sagazbsolver must be one of {'lbfgs', 'liblinear', 'newton-cg', 'newton-cholesky', 'sag', 'saga'}, got 'z ' instead.rj)> isinstancenumbersrnplogspacer8rfloat64rr*rUshapelenr3rrfitr transformzerosintonesastypesizesumndimr r loss_gradientlossgradientgradient_hessian_product expand_dimsrravelTlistint32 enumerate searchsortedarrayrminimizefinfofloatepsrr% _LOGISTIC_SOLVER_CONVERGENCE_MSGxfunr&r solve iterationr concatenateitemrappendrXreshape)5rr]r\r@rArBrCrDr4rErFr6r5rGrHrIrJrKrLrM n_samples n_featuresri is_binaryle class_weight_w0masky_binY_multisw_summsgtargetrrzr{hesswarm_start_sagcoefsn_iteriCr~rsopt_resn_iter_irvsolcoef_ intercept_alphabetamulti_w0s5 r7_logistic_regression_pathrVslF"g&&'' [[Q # 6D 1F  ** &.J J   U$ 7% L$<,]AWWSWX GGIzG IQI Y &  &l3L   G $B, Qm  r||A77  XXj3}#55QWW EAJqww/ [ E4%LE4%L ,,q/((u(= XX \\:M(:: ;3agg ::,3 9N  yyA~$**Q-:M@R3R"R1 QJJqMQ&JJqMZ#m2D%DDQ17tzzlBSxxj! Q8!o% QJJqMY.JJqMZ#m2D%DD)-1o 1 o%&7tzzlBSxxj"!o%&(   W %%D { "99D==D00D "..!"<=)GLLA'  > > $B W %%D { "99D==D00D "$$ FE XXc"gRXX .F" 1 W !QZ0O* 6@F''!K'%!4!44  96J  G."B H yy'++B { "!QZ0Ov}oyID%  LB( (!QZ0O& /!#CQ& FB}}H { "*8!++ 'E:x^^U[[]J$?@[[] }}H  &qwwU;$$QwDaqQ\2a8++56), (B.&xz+  S/ !  LL #BB::b9b/E LL )q AD 88E?BHHRL& 00r9c rXnXnXnXnSunnUb[UU5nUUnUUn[UU40SU_SU_SU_SU_SU _SU_S U _S U _S U _S U_S U _SU_SU_SS_SU_SU_6unnn[U S9nUUl[ 5n[ U5nUHnU(aUSSS24UlUSUlOUUlSUlUc"URURUUUS95 MVU=(d 0n[UUUS9nURU"UUU40UD65 M UU[R"U5U4$)aComputes 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. classes : ndarray A list of class labels known to the classifier. 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 : str, callable or None The scoring method to use for cross-validation. Options: - str: see :ref:`scoring_string_names` for options. - callable: a scorer callable object (e.g., function) with signature ``scorer(estimator, X, y)``. See :ref:`scoring_callable` for details. - `None`: :ref:`accuracy ` is used. 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 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 or 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. 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_classes, n_features + int(fit_intercept)) or (n_cs, n_features + int(fit_intercept)) List of coefficients for the Logistic Regression model. If fit_intercept is set to True, then the last dimension will be n_features + 1, where the last item represents the intercept. For binary problems the second dimension in n_classes is dropped, i.e. the shape will be `(n_cs, n_features + int(fit_intercept))`. Cs : ndarray of shape (n_cs,) 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 C in Cs. )NNNr\r@rLrAr4rBrFrCrDr6r5rGrHrIFrJrK)r4.rj).rjr_r)rparamsindices) r*rLogisticRegressionclasses_rrrrrscorer)rr) rr]traintestr\r@scoringrArBrCrFrDr4r5r6rGrHrJrKrL score_paramsX_trainX_testy_trainy_testsw_trainsw_testrrlog_regscoresws r7_log_reg_scoring_pathrsnhG WFhG WF"Hg ,]A>  '% 2     $ " ," !"(#$%E2v*!/GG VF!G  c3B3hKGM!"7G GM!$G  ? MM'--g-N O'-2L/!LRVWL MM''66J\J K!" "bhhv& ..r9cj^\rSrSr%Sr\"1Sk5S\"\"S155/\"\SSSS9/\"\SS S S9S/S /\"\SSS S9/S /\"\SSS S9/\ \"S15S/S/\"1Sk5/\"\ SSS S9/S/S /S\ /S.r \ \ S'S#SSSSSS SSSSSSSS. Sjjr \"SS9S$Sj5rU4SjrS rU4S!jrS"rU=r$)%riav. Logistic Regression (aka logit, MaxEnt) classifier. This class implements regularized logistic regression using a set of available solvers. **Note that regularization is applied by default**. It can handle both dense and sparse input `X`. Use C-ordered arrays or CSR matrices containing 64-bit floats for optimal performance; any other input format will be converted (and copied). The solvers 'lbfgs', 'newton-cg', 'newton-cholesky' and 'sag' support only L2 regularization with primal formulation, or no regularization. The 'liblinear' solver supports both L1 and L2 regularization (but not both, i.e. elastic-net), with a dual formulation only for the L2 penalty. The Elastic-Net (combination of L1 and L2) regularization is only supported by the 'saga' solver. For :term:`multiclass` problems (whenever `n_classes >= 3`), all solvers except 'liblinear' optimize the (penalized) multinomial loss. 'liblinear' only handles 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) .. deprecated:: 1.8 `penalty` was deprecated in version 1.8 and will be removed in 1.10. Use `l1_ratio` instead. `l1_ratio=0` for `penalty='l2'`, `l1_ratio=1` for `penalty='l1'` and `l1_ratio` set to any float between 0 and 1 for `'penalty='elasticnet'`. C : float, default=1.0 Inverse of regularization strength; must be a positive float. Like in support vector machines, smaller values specify stronger regularization. `C=np.inf` results in unpenalized logistic regression. For a visual example on the effect of tuning the `C` parameter with an L1 penalty, see: :ref:`sphx_glr_auto_examples_linear_model_plot_logistic_path.py`. l1_ratio : float, default=0.0 The Elastic-Net mixing parameter, with `0 <= l1_ratio <= 1`. Setting `l1_ratio=1` gives a pure L1-penalty, setting `l1_ratio=0` a pure L2-penalty. Any value between 0 and 1 gives an Elastic-Net penalty of the form `l1_ratio * L1 + (1 - l1_ratio) * L2`. .. warning:: Certain values of `l1_ratio`, i.e. some penalties, may not work with some solvers. See the parameter `solver` below, to know the compatibility between the penalty and solver. .. versionchanged:: 1.8 Default value changed from None to 0.0. .. deprecated:: 1.8 `None` is deprecated and will be removed in version 1.10. Always use `l1_ratio` to specify the penalty type. 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. 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 or 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: - 'lbfgs' is a good default solver because it works reasonably well for a wide class of problems. - For :term:`multiclass` problems (`n_classes >= 3`), all solvers except 'liblinear' minimize the full multinomial loss, 'liblinear' will raise an error. - '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. - For small datasets, 'liblinear' is a good choice, whereas 'sag' and 'saga' are faster for large ones; - '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`. .. warning:: The choice of the algorithm depends on the penalty chosen (`l1_ratio=0` for L2-penalty, `l1_ratio=1` for L1-penalty and `0 < l1_ratio < 1` for Elastic-Net) and on (multinomial) multiclass support: ================= ======================== ====================== solver l1_ratio multinomial multiclass ================= ======================== ====================== 'lbfgs' l1_ratio=0 yes 'liblinear' l1_ratio=1 or l1_ratio=0 no 'newton-cg' l1_ratio=0 yes 'newton-cholesky' l1_ratio=0 yes 'sag' l1_ratio=0 yes 'saga' 0<=l1_ratio<=1 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 (SAG) descent solver. Multinomial support in version 0.18. .. 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. Multinomial support in version 1.6. max_iter : int, default=100 Maximum number of iterations taken for the solvers to converge. 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 Does not have any effect. .. deprecated:: 1.8 `n_jobs` is deprecated in version 1.8 and will be removed in 1.10. 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 given problem is binary. 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 (1, ) Actual number of iterations for all classes. .. 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.82e-01, 1.82e-02, 1.44e-08], [9.72e-01, 2.82e-02, 3.02e-08]]) >>> clf.score(X, y) 0.97 For a comparison of the LogisticRegression with other classifiers see: :ref:`sphx_glr_auto_examples_classification_plot_classification_probability.py`. >rr0r1N deprecatedrrightclosedr?bothbooleanleftneitherbalancedrH>rSr/r=r.rcrdrDr5rrLr6rCrArGrFrHr4rBrD warm_startn_jobs_parameter_constraintsr>r_Fr<Tr=r;) rrLr6rCrArGrFrHr4rBrDrrc XlX lX0lX@lXPlX`lXplXlXlXl Xl Xl Xl Xl gNr)selfr5rrLr6rCrArGrFrHr4rBrDrrs r7__init__LogisticRegression.__init__sN$   *!2((   $ r9prefer_skip_nested_validationc URS:Xa~URS:Xd URc+SnURc[R"S[5 OURS:XaSnOSnUR [ R:XaSnO'URn[R"S [5 [URX@R5nUS:waLURb?SURs=:aS:a(O O%[R"S RU55 URS:XaURS:wd URS:XaAURS:wa1[R"S URS URS 35 US:XaURc [S5eUc9UR S:wa[R"S5 [ RnSnO UR nSURS3nURb[R"U[S9 US:Xa[ RnO [ R[ R/n[!UUUSUSUS;S9upUR"Sn [%U5 [ R&"U5Ul[+UR(5n U S:Hn US:XaU (d [S5e[ R,"U5S:a [S5e[/UUUR UR0UR2UR4UURUR6UR8UR:UR<US9 uUlUl Ul!U$US;a[EUS S!9R-5n OSn U S:a[S"UR(S-5eURF(a[IUS#S5n OSn U bEUR0(a4[ RJ"XR@SS2[ RL4SS$9n Sn[OUU40S%UR(_S&U/_S'UR_S(UR0_S)UR:_S*UR6_S+U_S,UR8_S-UR4_S.S/_S0UR<_S1U _S2U_S3U _S4U_S5U_6unnn[ RP"U[ RRS69Ul!USUlUR0(amU (a1UR>S7SUl UR>SS7SSS24UlU$UR>SS2S74Ul UR>SS2SS724UlU$U (a>[ RT"SURVS69Ul UR>SSS24UlU$[ RT"XRVS69Ul U$)8a 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. rrNr0zl'l1_ratio=None' was deprecated in version 1.8 and will trigger an error in 1.10. Use 0<=l1_ratio<=1 instead.r?rr1a'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratio' or 'C' instead. Use l1_ratio=0 instead of penalty='l2', l1_ratio=1 instead of penalty='l1', and C=np.inf instead of penalty=None.zNl1_ratio parameter is only used when penalty is 'elasticnet'. Got (penalty={})zInconsistent values: penalty=z with l1_ratio=z2. penalty is deprecated. Please use l1_ratio only.z6l1_ratio must be specified when penalty is elasticnet.r>z>Setting penalty=None will ignore the C and l1_ratio parameterszS'n_jobs' has no effect since 1.8 and will be removed in 1.10. You provided 'n_jobs=z', please leave it unspecified.)categoryr=rQrrRrTrUrbrVrYr.rZgꌠ9Y>)FzUsing the 'liblinear' solver while X contains a maximum value > 1e30 results in a frozen fit. Please choose another solver or rescale the input X.rrTsquaredzeThis solver needs samples of at least 2 classes in the data, but the data contains only one class: %rrrgr\r@rLrArCrDr4rBrFrIFrHrEr5rJrKrMr^rj),r5rLwarningswarn FutureWarningrrinfr8r4r6formatr3rrfloat32r,rr$uniquerrmaxrrArGrFrDrBrCrHrrn_iter_rrgetattrrnewaxisrasarrayrrrU)rrr]rKr5r4C_r_dtyperrirrJwarm_start_coefrMr_rs r7rLogisticRegression.fit>sz< <<< '}}!T]]%:==(MMT& !#&vvllG MM8 t{{GYY? l " MM %!dmm*?a*? MM%vg  LLD T]]a%7 LLD T]]a%7 MM/ ~> MM?+!"  l "t}}'<UV V ?vv} TBGB $$(KK=0O Q  ;; " MM# 6 W ZZFjj"**-F   &.J J WWQZ $Q' !   & N [  . vvay4 5 9G""&&!!   !!+9 5DJK _ $'48<<>O"O q=#}}Q/0  ??%dGT:O"O  &4+=+= iiBJJ!?aO  4  MM t  ]]  ,,   LL  ]] **  ** !  ,! "(# $ % q&*zz&9 1X   "&**RS/!ZZ_T1W5  #'**QU"3!ZZ3B3/  "$((1AGG"<!ZZa0  #%((9GG"D r9c>[U5 URRS:*nU(a[TU]U5$UR U5n[ USS9$)a] Probability estimates. The returned estimates for all classes are ordered by the label of classes. For a multiclass / multinomial problem the softmax function is used to find the predicted probability of each class. 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_``. rYFr`)r+rrsuper_predict_proba_lrdecision_functionr)rrr decision_2d __class__s r7 predict_proba LogisticRegression.predict_probasQ, MM&&!+ 7,Q/ /003K;U3 3r9cL[R"URU55$)a 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 r7predict_log_proba$LogisticRegression.predict_log_proba5s&vvd((+,,r9c>[TU]5nSURlURS:XaSUR lU$)NTr.F)r __sklearn_tags__ input_tagssparser4classifier_tags multi_classrtagsrs r7r#LogisticRegression.__sklearn_tags__Js;w')!% ;;+ %/4D , r9)rrFrrr6rArrGrLrBrrr5rHr4rCrDr)rr)__name__ __module__ __qualname____firstlineno____doc__rrrrdictrr__annotations__rrrrrr__static_attributes__ __classcell__rs@r7rrsBbL 1 2  :|n- . tQW5 6dAq8$? q$v67#&tQYGHz:,7>'( U  h4?@; k"-$D6   !B5U6Un4>-*r9rc^\rSrSr%Sr0\R Er\\S'SHr \R\ 5 M \R\ "\ SSSS9S /S S\"\"S 155/S /\"\"\"555\S/S /\"1S k5\"\"S155/S \"\"S 155/S.5 SS SSSSSSSSSSSSSSS S.Sjr\"SS9S!Sj5rS!SjrSrSrU4SjrS rU=r$)"LogisticRegressionCViSa6Logistic Regression CV (aka logit, MaxEnt) classifier. See glossary entry for :term:`cross-validation estimator`. This class implements regularized logistic regression with implicit cross validation for the penalty parameters `C` and `l1_ratio`, see :class:`LogisticRegression`, using a set of available solvers. The solvers 'lbfgs', 'newton-cg', 'newton-cholesky' and 'sag' support only L2 regularization with primal formulation. The 'liblinear' solver supports both L1 and L2 regularization (but not both, i.e. elastic-net), with a dual formulation only for the L2 penalty. The Elastic-Net (combination of L1 and L2) regularization 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. All solvers except 'liblinear' 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. l1_ratios : array-like of shape (n_l1_ratios), default=None Floats between 0 and 1 passed as Elastic-Net mixing parameter (scaling between L1 and L2 penalties). For `l1_ratio = 0` the penalty is an L2 penalty. For `l1_ratio = 1` it is an L1 penalty. For `0 < l1_ratio < 1`, the penalty is a combination of L1 and L2. All the values of the given array-like are tested by cross-validation and the one giving the best prediction score is used. .. warning:: Certain values of `l1_ratios`, i.e. some penalties, may not work with some solvers. See the parameter `solver` below, to know the compatibility between the penalty and solver. .. deprecated:: 1.8 `l1_ratios=None` is deprecated in 1.8 and will raise an error in version 1.10. Default value will change from `None` to `(0.0,)` in version 1.10. 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, it specifies the number of folds, `n_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. .. deprecated:: 1.8 `penalty` was deprecated in version 1.8 and will be removed in 1.10. Use `l1_ratio` instead. `l1_ratio=0` for `penalty='l2'`, `l1_ratio=1` for `penalty='l1'` and `l1_ratio` set to any float between 0 and 1 for `'penalty='elasticnet'`. scoring : str or callable, default=None The scoring method to use for cross-validation. Options: - str: see :ref:`scoring_string_names` for options. - callable: a scorer callable object (e.g., function) with signature ``scorer(estimator, X, y)``. See :ref:`scoring_callable` for details. - `None`: :ref:`accuracy ` is used. 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: - 'lbfgs' is a good default solver because it works reasonably well for a wide class of problems. - For :term:`multiclass` problems (`n_classes >= 3`), all solvers except 'liblinear' minimize the full multinomial loss, 'liblinear' will raise an error. - '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. - For small datasets, 'liblinear' is a good choice, whereas 'sag' and 'saga' are faster for large ones; - '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`. .. warning:: The choice of the algorithm depends on the penalty (`l1_ratio=0` for L2-penalty, `l1_ratio=1` for L1-penalty and `0 < l1_ratio < 1` for Elastic-Net) chosen and on (multinomial) multiclass support: ================= ======================== ====================== solver l1_ratio multinomial multiclass ================= ======================== ====================== 'lbfgs' l1_ratio=0 yes 'liblinear' l1_ratio=1 or l1_ratio=0 no 'newton-cg' l1_ratio=0 yes 'newton-cholesky' l1_ratio=0 yes 'sag' l1_ratio=0 yes 'saga' 0<=l1_ratio<=1 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 (SAG) descent solver. Multinomial support in version 0.18. .. versionadded:: 0.19 SAGA solver. .. versionadded:: 1.2 newton-cholesky solver. Multinomial support in version 1.6. 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 or 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. 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. use_legacy_attributes : bool, default=True If True, use legacy values for attributes: - `C_` is an ndarray of shape (n_classes,) with the same value repeated - `l1_ratio_` is an ndarray of shape (n_classes,) with the same value repeated - `coefs_paths_` is a dict with class labels as keys and ndarrays as values - `scores_` is a dict with class labels as keys and ndarrays as values - `n_iter_` is an ndarray of shape (1, n_folds, n_cs) or similar If False, use new values for attributes: - `C_` is a float - `l1_ratio_` is a float - `coefs_paths_` is an ndarray of shape (n_folds, n_l1_ratios, n_cs, n_classes, n_features) For binary problems (n_classes=2), the 2nd last dimension is 1. - `scores_` is an ndarray of shape (n_folds, n_l1_ratios, n_cs) - `n_iter_` is an ndarray of shape (n_folds, n_l1_ratios, n_cs) .. versionchanged:: 1.10 The default will change from True to False in version 1.10. .. deprecated:: 1.10 `use_legacy_attributes` will be deprecated in version 1.10 and be removed in 1.12. 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 l1_ratios=None is used (i.e. penalty is not 'elasticnet'), this is set to ``[None]`` coefs_paths_ : dict of ndarray of shape (n_folds, n_cs, n_dof) or (n_folds, n_cs, n_l1_ratios, n_dof) A dict with classes as the keys, and the path of coefficients obtained during cross-validating across each fold (`n_folds`) and then across each Cs (`n_cs`). The size of the coefficients is the number of degrees of freedom (`n_dof`), i.e. without intercept `n_dof=n_features` and with intercept `n_dof=n_features+1`. If `penalty='elasticnet'`, there is an additional dimension for the number of l1_ratio values (`n_l1_ratios`), which gives a shape of ``(n_folds, n_cs, n_l1_ratios_, n_dof)``. See also parameter `use_legacy_attributes`. scores_ : dict A dict with classes as the keys, and the values as the grid of scores obtained during cross-validating each fold. The same score is repeated across all classes. Each dict value has shape ``(n_folds, n_cs)`` or ``(n_folds, n_cs, n_l1_ratios)`` if ``penalty='elasticnet'``. See also parameter `use_legacy_attributes`. C_ : ndarray of shape (n_classes,) or (1,) The value of C that maps to the best score, repeated n_classes times. If refit is set to False, the best C is the average of the C's that correspond to the best score for each fold. `C_` is of shape (1,) when the problem is binary. See also parameter `use_legacy_attributes`. l1_ratio_ : ndarray of shape (n_classes,) or (n_classes - 1,) The value of l1_ratio that maps to the best score, repeated n_classes times. If refit is set to False, the best l1_ratio is the average of the l1_ratio's that correspond to the best score for each fold. `l1_ratio_` is of shape (1,) when the problem is binary. See also parameter `use_legacy_attributes`. n_iter_ : ndarray of shape (1, n_folds, n_cs) or (1, n_folds, n_cs, n_l1_ratios) Actual number of iterations for all classes, folds and Cs. If `penalty='elasticnet'`, the shape is `(1, n_folds, n_cs, n_l1_ratios)`. See also parameter `use_legacy_attributes`. 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, use_legacy_attributes=False, l1_ratios=(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)rrrLr?Nrrz array-liker cv_objectr>rr0r1r)r@ l1_ratioscvrrefitr5use_legacy_attributesr:TFr=r<r;rr>)r@r*rAr+r6r5rr4rCrBrFrrDr,rGrHr-cXlX lX0lX@lXPlX`lXplXlXlXl Xl Xl Xl Xl XlUUlUUlgr)r@r*rAr+r6r5rrCrBrFrrDr4r,rGrHr-)rr@r*rAr+r6r5rr4rCrBrFrrDr,rGrHr-s r7rLogisticRegressionCV.__init__sb*"*    (    !2(%:"r9rc R^^^^^*^+^,^-^.^/^0[UTS5 [TR[5(a.TRS:XaSn[R "S[ 5 O TRnTRS:XaTRc[R "S[ 5 [R"[R"U5S:H5(dUcSm.O_[R"[R"U5S :H5(aS m.O*S m.O'TRm.[R "S [ 5 TRS:XaM[R "S TRRSTRRS3[ 5 SnO TRn[TRT.TR 5m0T.S :Xa:Ub&[#U5S:Xd[%SU55(a['SU-5eUm+OAUb5TRS:wa%[R "SR)T.55 UcS/m+OUm+[+TTTS[R,ST0S;S9ummTR.S n[1T5 TR2m*[55R7T5nUR8=n Tl[#TR85n U S:Hn U S:a['STR8SS35eT0S;a[;TSS9R=5m,OSm,[?5(a[ATS4ST0UD6m/OB[C5m/[C0S9T/l"[CUS9T/l#TbTT/RFRHS'[KTRLTSS 9n [OU RP"TT40T/RDRPD65n [T*[R5(a\[UT*RW55[UTR85::d+S!TR8S"T*RW53n['U5eO;T*S#:Xa5[YT*TR8TTS$9m*[S[[TR8T*55m*U (aS n U S Sn [][^5m-TRS;aS%nOS&n[aTRbTRdUS'9"UU*U+U,U-U.U/UUU0U4 S(jU 55n[[U6unnnnUSTl3U (a\[Rh"U[#U 5[#T+5[#TRf5S)45n[Rj"US S5S*nOY[Rh"U[#U 5[#T+5[#TRf5U S)45n[Rl"US+S,5n[Rh"U[#U 5[#T+5[#TRf545n[Rj"US S5S*Tl7[Rh"U[#U 5[#T+5[#TRf545n[Rj"US S5S*n[Rp"UU S S S 45n[S[[U U55Tl9[S[[U U55Tl:[O5Tl;[O5Tl<[Rz"X45Tl>[R~"U 5Tl@TRrU SnTR(GaTURSS-9n[R"[R"U5UR.5nTRfUSnTRvRU5 T+US nTRxRU5 U (a$[R"USSS2/UQSS2P7SS-9nO%[R"USS2SS2/UQSS2P7S S-9n[TT4TR8U/T0TRUTRTRT.T*[=STRdS - 5TRS.T,TUS/.6un nUSnGOUR.unnnURiUS)5n[R"US S-9n[R"UUU45n[O[[U65nU (aH[R"[[#U 55V s/sHn USU /UU QSS2P7PM sn SS-9nOP[R"[[#U 55V s/sHn USS2U UU SUU S SS24PM sn SS-9n[R"U5nUSS2S4n!TRvR[R"TRfU!55 T.S :Xa<USS2S 4n"TRxR[R"T+U"55 OTRxRS5 U (aeURS:Xa USS2SU24O USUSSS24Tl>TR(a'URS:XaUS0OUS)TRS'O{[Rp"TRvU 5Tl;[Rp"TRxU 5Tl<USS2SU24Tl>TR(aUSS2S)4Tl@[R"TRv5Tl;[R"TRx5Tl<[R"T+5TlNUcTRtR5H"un#n$U$SS2SS2SSS24TRtU#'M$ TRrR5Hun#n%U%SS2SS2S4TRrU#'M! TRnSS2SS2SS2S4Tl7U(Gd[#U 5nTRfRnTR.S [TR5-n&[TRvS5Tl;[R"[OTRtR555n'TRrU Sn(TRnSn)UcwU S::aU'RiS UUS U&5n'OU'RiU UUS U&5n'U(RiUUS 5n(U)RiUUS 5n)TRS :XaS1Tl<OkS2Tl<Oc[#TR5n[TRxS5Tl<U S::aU'RiS UUUU&5n'OU'RiU UUUU&5n'[Rl"U'S+S35Tl:[Rl"U(S4S55Tl9[Rl"U)S4S55Tl7T$s sn fs sn f)6aFit 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. rrNzThe default value for l1_ratios will change from None to (0.0,) in version 1.10. From version 1.10 onwards, only array-like with values in [0, 1] will be allowed, None will be forbidden. To avoid this warning, explicitly set a value, e.g. l1_ratios=(0,).rz'l1_ratios=None' was deprecated in version 1.8 and will trigger an error in 1.10. Use an array-like with valuesin [0, 1] instead.rr0r?rr1z'penalty' was deprecated in version 1.8 and will be removed in 1.10. To avoid this warning, leave 'penalty' set to its default value and use 'l1_ratios' instead. Use l1_ratios=(0,) instead of penalty='l2' and l1_ratios=(1,) instead of penalty='l1'.zThe fitted attributes of ax will be simplified in scikit-learn 1.10 to remove redundancy. Set`use_legacy_attributes=False` to enable the new behavior now, or set it to `True` to silence this warning during the transition period while keeping the deprecated behavior for the time being. The default value of use_legacy_attributes will change from True to False in scikit-learn 1.10. See the docstring of z for more details.Tc3# UH<n[U[R5(+=(d US:=(d US:v M> g7f)rr?N)rrNumber).0rLs r7 +LogisticRegressionCV.fit..4sF %. 'x@@(#a<(#a<(%.sAAzNl1_ratios must be an array-like of numbers between 0 and 1; got (l1_ratios=%r)zOl1_ratios parameter is only used when penalty is 'elasticnet'. Got (penalty={})rQrrRrrYzcThis solver needs samples of at least 2 classes in the data, but the data contains only one class: r2rrrK)splitr) classifierzHThe given class_weight dict must have the class labels as keys; classes=z but key=rr[threads processes)rrDpreferc3> # UHupTHnT"TTUU40ST R_ST R_ST R_ST _ST R_ST _ST R_ST R _ST R _S T_S T R_S T R_S T R_S T_ST _SU_ST RR_6v M M g7f)r\r@rAr5r6r4rCrBrDrFrrGrHrJrKrLrN) rr@rAr6rCrBrDrrGrHscorerr)r3rrrLrrF l1_ratios_rJ path_funcr5 routed_paramsrKrr4r]s r7r4r5s#X 0 % &1       77  #00   YY  HH    *    #'"8"8! ""..# $!0% &,' (") *+1177+ 0'1 . %sCCrj)N.)rr?rm)r?rmrrgF)r\r@r4rArErBrCr5rFrDrHrIrJrKrL)rrjr>r_)rmrr?)r?rY)rYr?)Ur!rr*strrrrr5rallrr-rrr8r4r6ranyr3rr,rrr$rFrrrrrr"r#rsplitterr=rrr+rr6r"setkeysrzipr(rr'rrDCs_rswapaxesmoveaxisrtilescores_ coefs_paths_r l1_ratio_emptyrrrr,r unravel_indexargmaxrmeanrrArBrCrHrangerr>itemsrrrrvalues)1rrr]rKrr*r-r label_encoderclasses_only_pos_if_binaryrirr+foldsrr; fold_coefs_ coefs_pathsr@rr scores_sum best_indexrrN coef_initrrn_foldsn_cs n_l1_ratios best_indicesrbest_indices_Cbest_indices_l1cls coefs_pathrn_dofnewpaths newscoresnewniterrFr>rJr?r5r@r4s1```` @@@@@@@r7rLogisticRegressionCV.fits_ 6 &$. dnnc * *t~~/GI MM+  I <<< '~~% -" vvbjj+q011Y5F 9-233&llG MMC    % % / MM+DNN,C,C+DE; <@>>;R;R:ST$ $ %) !$($>$> !t{{GTYY? l "!y>Q& %. !24=>#J$)E 88>w  "V &   ** &.J J 1WWQZ $Q'(( %**1- 6C5K5KK"T] & N q===+,A/  _ $'48<<>O"O   +, M"GM%*_M "#(v#6M (>K $$**?;dggqT 2RXXaCm&<&<&B&BCD lD ) ) ))+,DMM0BB#}}oY|7H7H7J6KM!o% C Z '/ + L  DMM< @AL I)CAB)G &12  ;;/ )F Fdkk4<PRS$ST!2 ::l3L)!Q$/N GGNN277488N#;< =,&".q!t"4%%bggj.I&JK%%d+ ./ffk1kzk>*q*~dTUg?VDJ!!121QuX!B%"ggdggy1DGWWT^^Y?DN1kzk>*DJ!!"#ArE(**TWW%DNN3**Z0  $(#4#4#:#:#<Z)3Aq!QJ)?!!#&$="ll002 U$)!Q'N S!3<<1a 3DL$%jG88==DGGAJT%7%7!88EDGGAJ'DG~~d4+<+<+C+C+E&FGH *1-I||AH >'//7D!UKH'// 7D!USH%--gtQ? #++GT1=<<4'%(DN%(DN!$//2 !&t~~a'8!9>'//7D+uUH'//!7D+u H !# Hi KD ;;y&&ADL;;x@DL iX s x$x$c [X@S5 UR5n[5(a[US4SU0UD6nO3[ 5n[ 0S9UlUbX6R R S'U"UUU40UR R D6$)aScore 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. rrKr7)r! _get_scorerr"r#rr=r)rrr]rKrrr@s r7rLogisticRegressionCV.scoreis0 ,g6""$   +, M"GM#(r?M (>K$$**?;   ""((   r9c[US9RU5RUR[ 5RSSS9S9RUR 5[ 5RSSS9RSSS9S9nU$)a"Get 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. )ownerrr6)callercallee)rDmethod_mappingr)r=rr)radd_self_requestaddr+r rl)rrouters r7get_metadata_routing)LogisticRegressionCV.get_metadata_routings  &  d # S,22%2PS''),GG4E'2   r9cBUR=(d Sn[U5$)z`Get the scorer based on the scoring method specified. The default scoring method is `accuracy`. accuracy)rr)rrs r7rl LogisticRegressionCV._get_scorers,,,*'""r9cF>[TU]5nSURlU$)NT)r rrrrs r7r%LogisticRegressionCV.__sklearn_tags__s!w')!% r9)rr@rHrFrrrMr+r6rArrGrNr*r>rBrrr5rHr,rLrr4rCr-rDr)rrrr r!rrr"r#parampopupdaterrrrrErcallablerrrrrvrlrr$r%r&s@r7r(r(Ss@DL $Q&8&O&O#PDP0""5)1!!Haf=|L&fZ5I.JK-"3'7'9#:;XtL[56z<.12'0 F88L1M%N  $    $'%;N5Q6Qf - ^>#r9r()Ir!rrrrnumpyrscipyrsklearn._loss.lossrr sklearn.basersklearn.linear_model._baser r r sklearn.linear_model._glm.glmr !sklearn.linear_model._linear_lossr sklearn.linear_model._sagrsklearn.metricsrrsklearn.model_selectionrsklearn.preprocessingrsklearn.svm._baser sklearn.utilsrrrrrsklearn.utils._param_validationrrrsklearn.utils.extmathrrsklearn.utils.fixesrsklearn.utils.metadata_routingrr r!r"r#sklearn.utils.multiclassr$sklearn.utils.optimizer%r&sklearn.utils.parallelr'r(sklearn.utils.validationr)r*r+r,rr8rrrr(r9r7rs"D% ?=08,.,IH4BBE4!8       +n1d T/nq .q hn -/Dmn r9