18686
11601
sklearn.linear_model._logistic.LogisticRegression
sklearn.LogisticRegression
sklearn.linear_model._logistic.LogisticRegression
4
openml==0.10.2,sklearn==0.23.2
Logistic Regression (aka logit, MaxEnt) classifier.
In the multiclass case, the training algorithm uses the one-vs-rest (OvR)
scheme if the 'multi_class' option is set to 'ovr', and uses the
cross-entropy loss if the 'multi_class' option is set to 'multinomial'.
(Currently the 'multinomial' option is supported only by the 'lbfgs',
'sag', 'saga' and 'newton-cg' solvers.)
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 su...
2020-09-18T03:11:00
English
sklearn==0.23.2
numpy>=1.6.1
scipy>=0.9
C
float
1.0
Inverse of regularization strength; must be a positive float
Like in support vector machines, smaller values specify stronger
regularization
class_weight
dict or
null
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'*
dual
bool
false
Dual or primal formulation. Dual formulation is only implemented for
l2 penalty with liblinear solver. Prefer dual=False when
n_samples > n_features
fit_intercept
bool
true
Specifies if a constant (a.k.a. bias or intercept) should be
added to the decision function
intercept_scaling
float
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
l1_ratio
float
null
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.
max_iter
int
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
multi_class
"auto"
n_jobs
int
null
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 <n_jobs>` for more details
penalty
"l2"
random_state
int
null
Used when ``solver`` == 'sag', 'saga' or 'liblinear' to shuffle the
data. See :term:`Glossary <random_state>` for details
solver : {'newton-cg', 'lbfgs', 'liblinear', 'sag', 'saga'}, default='lbfgs'
Algorithm to use in the optimization problem
- For small datasets, 'liblinear' is a good choice, whereas 'sag' and
'saga' are faster for large ones
- For multiclass problems, only 'newton-cg', 'sag', 'saga' and 'lbfgs'
handle multinomial loss; 'liblinear' is limited to one-versus-rest
schemes
- 'newton-cg', 'lbfgs', 'sag' and 'saga' handle L2 or no penalty
- 'liblinear' and 'saga' also handle L1 penalty
- 'saga' also supports 'elasticnet' penalty
- 'liblinear' does not support setting ``penalty='none'``
Note that 'sag' and 'saga' fast convergence is only guaranteed on
features with approximately the same scale. You can
preprocess the data with a scaler from sklearn.preprocessing
.. versionadded:: 0.17
Stochastic Average Gr...
solver
"lbfgs"
tol
float
0.0001
Tolerance for stopping criteria
verbose
int
0
For the liblinear and lbfgs solvers set verbose to any positive
number for verbosity
warm_start
bool
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 <warm_start>`
.. versionadded:: 0.17
*warm_start* to support *lbfgs*, *newton-cg*, *sag*, *saga* solvers
openml-python
python
scikit-learn
sklearn
sklearn_0.23.2