| Issue | #Downvotes for this reason | By |
|---|
| C | Inverse of regularization strength; must be a positive float Like in support vector machines, smaller values specify stronger regularization | default: 1.0 |
| class_weight | 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'* | default: null |
| dual | Dual or primal formulation. Dual formulation is only implemented for l2 penalty with liblinear solver. Prefer dual=False when n_samples > n_features | default: false |
| fit_intercept | Specifies if a constant (a.k.a. bias or intercept) should be added to the decision function | default: true |
| intercept_scaling | 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 | default: 1 |
| l1_ratio | 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. | default: null |
| max_iter | Maximum number of iterations taken for the solvers to converge 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 | default: 100 |
| multi_class | default: "auto" | |
| n_jobs | 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 | default: null |
| penalty | 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. If 'none' (not supported by the liblinear solver), no regularization is applied .. versionadded:: 0.19 l1 penalty with SAGA solver (allowing 'multinomial' + L1) | default: "l2" |
| random_state | The seed of the pseudo random number generator to use when shuffling the data. If int, random_state is the seed used by the random number generator; If RandomState instance, random_state is the random number generator; If None, the random number generator is the RandomState instance used by `np.random`. Used when ``solver`` == 'sag' or 'liblinear' | default: null |
| solver | 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 Gradient descent solver .. versionadded:: 0.19 SAGA solver .. versionchanged:: 0.22 The default solver changed from 'liblinear' to 'lbfgs' in 0.22 | default: "lbfgs" |
| tol | Tolerance for stopping criteria | default: 0.0001 |
| verbose | For the liblinear and lbfgs solvers set verbose to any positive number for verbosity | default: 0 |
| warm_start | 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 | default: false |