snowflake-ml-python 1.6.4__py3-none-any.whl → 1.7.0__py3-none-any.whl

snowflake/ml/modeling/linear_model/lasso_lars.py

@@ -124,14 +124,6 @@ class LassoLars(BaseTransformer):
     verbose: bool or int, default=False
         Sets the verbosity amount.
 
-    normalize: bool, default=False
-        This parameter is ignored when ``fit_intercept`` is set to False.
-        If True, the regressors X will be normalized before regression by
-        subtracting the mean and dividing by the l2-norm.
-        If you wish to standardize, please use
-        :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``
-        on an estimator with ``normalize=False``.
-
     precompute: bool, 'auto' or array-like, default='auto'
         Whether to use a precomputed Gram matrix to speed up
         calculations. If set to ``'auto'`` let us decide. The Gram
@@ -183,7 +175,6 @@ class LassoLars(BaseTransformer):
         alpha=1.0,
         fit_intercept=True,
         verbose=False,
-        normalize="deprecated",
         precompute="auto",
         max_iter=500,
         eps=2.220446049250313e-16,
@@ -216,7 +207,6 @@ class LassoLars(BaseTransformer):
         init_args = {'alpha':(alpha, 1.0, False),
             'fit_intercept':(fit_intercept, True, False),
             'verbose':(verbose, False, False),
-            'normalize':(normalize, "deprecated", False),
             'precompute':(precompute, "auto", False),
             'max_iter':(max_iter, 500, False),
             'eps':(eps, 2.220446049250313e-16, False),

snowflake/ml/modeling/linear_model/lasso_lars_cv.py

@@ -120,14 +120,6 @@ class LassoLarsCV(BaseTransformer):
     max_iter: int, default=500
         Maximum number of iterations to perform.
 
-    normalize: bool, default=False
-        This parameter is ignored when ``fit_intercept`` is set to False.
-        If True, the regressors X will be normalized before regression by
-        subtracting the mean and dividing by the l2-norm.
-        If you wish to standardize, please use
-        :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``
-        on an estimator with ``normalize=False``.
-
     precompute: bool or 'auto' , default='auto'
         Whether to use a precomputed Gram matrix to speed up
         calculations. If set to ``'auto'`` let us decide. The Gram matrix
@@ -142,7 +134,7 @@ class LassoLarsCV(BaseTransformer):
         - :term:`CV splitter`,
         - An iterable yielding (train, test) splits as arrays of indices.
 
-        For integer/None inputs, :class:`KFold` is used.
+        For integer/None inputs, :class:`~sklearn.model_selection.KFold` is used.
 
         Refer :ref:`User Guide <cross_validation>` for the various
         cross-validation strategies that can be used here.
@@ -186,7 +178,6 @@ class LassoLarsCV(BaseTransformer):
         fit_intercept=True,
         verbose=False,
         max_iter=500,
-        normalize="deprecated",
         precompute="auto",
         cv=None,
         max_n_alphas=1000,
@@ -218,7 +209,6 @@ class LassoLarsCV(BaseTransformer):
         init_args = {'fit_intercept':(fit_intercept, True, False),
             'verbose':(verbose, False, False),
             'max_iter':(max_iter, 500, False),
-            'normalize':(normalize, "deprecated", False),
             'precompute':(precompute, "auto", False),
             'cv':(cv, None, False),
             'max_n_alphas':(max_n_alphas, 1000, False),

snowflake/ml/modeling/linear_model/lasso_lars_ic.py

@@ -120,14 +120,6 @@ class LassoLarsIC(BaseTransformer):
     verbose: bool or int, default=False
         Sets the verbosity amount.
 
-    normalize: bool, default=False
-        This parameter is ignored when ``fit_intercept`` is set to False.
-        If True, the regressors X will be normalized before regression by
-        subtracting the mean and dividing by the l2-norm.
-        If you wish to standardize, please use
-        :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``
-        on an estimator with ``normalize=False``.
-
     precompute: bool, 'auto' or array-like, default='auto'
         Whether to use a precomputed Gram matrix to speed up
         calculations. If set to ``'auto'`` let us decide. The Gram
@@ -171,7 +163,6 @@ class LassoLarsIC(BaseTransformer):
         criterion="aic",
         fit_intercept=True,
         verbose=False,
-        normalize="deprecated",
         precompute="auto",
         max_iter=500,
         eps=2.220446049250313e-16,
@@ -202,7 +193,6 @@ class LassoLarsIC(BaseTransformer):
         init_args = {'criterion':(criterion, "aic", False),
             'fit_intercept':(fit_intercept, True, False),
             'verbose':(verbose, False, False),
-            'normalize':(normalize, "deprecated", False),
             'precompute':(precompute, "auto", False),
             'max_iter':(max_iter, 500, False),
             'eps':(eps, 2.220446049250313e-16, False),

snowflake/ml/modeling/linear_model/logistic_regression.py

@@ -118,8 +118,9 @@ class LogisticRegression(BaseTransformer):
         - `'elasticnet'`: both L1 and L2 penalty terms are added.
 
     dual: bool, default=False
-        Dual or primal formulation. Dual formulation is only implemented for
-        l2 penalty with liblinear solver. Prefer dual=False when
+        Dual (constrained) or primal (regularized, see also
+        :ref:`this equation <regularized-logistic-loss>`) 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
@@ -167,24 +168,29 @@ class LogisticRegression(BaseTransformer):
         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, only 'newton-cg', 'sag', 'saga' and
-              'lbfgs' handle multinomial loss;
-            - 'liblinear' is limited to one-versus-rest schemes.
-            - 'newton-cholesky' is a good choice for `n_samples` >> `n_features`,
-              especially with one-hot encoded categorical features with rare
-              categories. Note that it is limited to binary classification and the
-              one-versus-rest reduction for multiclass classification. Be aware that
-              the memory usage of this solver has a quadratic dependency on
-              `n_features` because it explicitly computes the Hessian matrix.
-
-           - 'lbfgs'           -   ['l2', None]
-           - 'liblinear'       -   ['l1', 'l2']
-           - 'newton-cg'       -   ['l2', None]
-           - 'newton-cholesky' -   ['l2', None]
-           - 'sag'             -   ['l2', None]
-           - 'saga'            -   ['elasticnet', 'l1', 'l2', None]
+        - 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' and 'newton-cholesky' can only handle binary classification
+          by default. To apply a one-versus-rest scheme for the multiclass setting
+          one can wrapt it with the `OneVsRestClassifier`.
+        - 'newton-cholesky' is a good choice for `n_samples` >> `n_features`,
+          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` because it explicitly computes the Hessian
+          matrix.
+
+           ================= ============================== ======================
+           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
+           ================= ============================== ======================
 
     max_iter: int, default=100
         Maximum number of iterations taken for the solvers to converge.
@@ -235,7 +241,7 @@ class LogisticRegression(BaseTransformer):
         random_state=None,
         solver="lbfgs",
         max_iter=100,
-        multi_class="auto",
+        multi_class="deprecated",
         verbose=0,
         warm_start=False,
         n_jobs=None,
@@ -271,7 +277,7 @@ class LogisticRegression(BaseTransformer):
             'random_state':(random_state, None, False),
             'solver':(solver, "lbfgs", False),
             'max_iter':(max_iter, 100, False),
-            'multi_class':(multi_class, "auto", False),
+            'multi_class':(multi_class, "deprecated", False),
             'verbose':(verbose, 0, False),
             'warm_start':(warm_start, False, False),
             'n_jobs':(n_jobs, None, False),

snowflake/ml/modeling/linear_model/logistic_regression_cv.py

@@ -127,8 +127,9 @@ class LogisticRegressionCV(BaseTransformer):
         list of possible cross-validation objects.
 
     dual: bool, default=False
-        Dual or primal formulation. Dual formulation is only implemented for
-        l2 penalty with liblinear solver. Prefer dual=False when
+        Dual (constrained) or primal (regularized, see also
+        :ref:`this equation <regularized-logistic-loss>`) 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'
@@ -150,26 +151,31 @@ class LogisticRegressionCV(BaseTransformer):
         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, only 'newton-cg', 'sag', 'saga' and
-              'lbfgs' handle multinomial loss;
-            - 'liblinear' might be slower in :class:`LogisticRegressionCV`
-              because it does not handle warm-starting. 'liblinear' is
-              limited to one-versus-rest schemes.
-            - 'newton-cholesky' is a good choice for `n_samples` >> `n_features`,
-              especially with one-hot encoded categorical features with rare
-              categories. Note that it is limited to binary classification and the
-              one-versus-rest reduction for multiclass classification. Be aware that
-              the memory usage of this solver has a quadratic dependency on
-              `n_features` because it explicitly computes the Hessian matrix.
-
-           - 'lbfgs'           -   ['l2']
-           - 'liblinear'       -   ['l1', 'l2']
-           - 'newton-cg'       -   ['l2']
-           - 'newton-cholesky' -   ['l2']
-           - 'sag'             -   ['l2']
-           - 'saga'            -   ['elasticnet', 'l1', 'l2']
+        - 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' might be slower in :class:`LogisticRegressionCV`
+          because it does not handle warm-starting.
+        - 'liblinear' and 'newton-cholesky' can only handle binary classification
+          by default. To apply a one-versus-rest scheme for the multiclass setting
+          one can wrapt it with the `OneVsRestClassifier`.
+        - 'newton-cholesky' is a good choice for `n_samples` >> `n_features`,
+          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` because it explicitly computes the Hessian
+          matrix.
+
+           ================= ============================== ======================
+           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
+           ================= ============================== ======================
 
     tol: float, default=1e-4
         Tolerance for stopping criteria.
@@ -256,7 +262,7 @@ class LogisticRegressionCV(BaseTransformer):
         verbose=0,
         refit=True,
         intercept_scaling=1.0,
-        multi_class="auto",
+        multi_class="deprecated",
         random_state=None,
         l1_ratios=None,
         input_cols: Optional[Union[str, Iterable[str]]] = None,
@@ -294,7 +300,7 @@ class LogisticRegressionCV(BaseTransformer):
             'verbose':(verbose, 0, False),
             'refit':(refit, True, False),
             'intercept_scaling':(intercept_scaling, 1.0, False),
-            'multi_class':(multi_class, "auto", False),
+            'multi_class':(multi_class, "deprecated", False),
             'random_state':(random_state, None, False),
             'l1_ratios':(l1_ratios, None, False),}
         cleaned_up_init_args = validate_sklearn_args(

snowflake/ml/modeling/linear_model/multi_task_elastic_net_cv.py

@@ -155,7 +155,7 @@ class MultiTaskElasticNetCV(BaseTransformer):
         - :term:`CV splitter`,
         - An iterable yielding (train, test) splits as arrays of indices.
 
-        For int/None inputs, :class:`KFold` is used.
+        For int/None inputs, :class:`~sklearn.model_selection.KFold` is used.
 
         Refer :ref:`User Guide <cross_validation>` for the various
         cross-validation strategies that can be used here.

snowflake/ml/modeling/linear_model/multi_task_lasso_cv.py

@@ -146,7 +146,7 @@ class MultiTaskLassoCV(BaseTransformer):
         - :term:`CV splitter`,
         - An iterable yielding (train, test) splits as arrays of indices.
 
-        For int/None inputs, :class:`KFold` is used.
+        For int/None inputs, :class:`~sklearn.model_selection.KFold` is used.
 
         Refer :ref:`User Guide <cross_validation>` for the various
         cross-validation strategies that can be used here.

snowflake/ml/modeling/linear_model/orthogonal_matching_pursuit.py

@@ -110,25 +110,18 @@ class OrthogonalMatchingPursuit(BaseTransformer):
         If set, the response of predict(), transform() methods will not contain input columns.
 
     n_nonzero_coefs: int, default=None
-        Desired number of non-zero entries in the solution. If None (by
-        default) this value is set to 10% of n_features.
+        Desired number of non-zero entries in the solution. Ignored if `tol` is set.
+        When `None` and `tol` is also `None`, this value is either set to 10% of
+        `n_features` or 1, whichever is greater.
 
     tol: float, default=None
-        Maximum norm of the residual. If not None, overrides n_nonzero_coefs.
+        Maximum squared norm of the residual. If not None, overrides n_nonzero_coefs.
 
     fit_intercept: bool, default=True
         Whether to calculate the intercept for this model. If set
         to false, no intercept will be used in calculations
         (i.e. data is expected to be centered).
 
-    normalize: bool, default=False
-        This parameter is ignored when ``fit_intercept`` is set to False.
-        If True, the regressors X will be normalized before regression by
-        subtracting the mean and dividing by the l2-norm.
-        If you wish to standardize, please use
-        :class:`~sklearn.preprocessing.StandardScaler` before calling ``fit``
-        on an estimator with ``normalize=False``.
-
     precompute: 'auto' or bool, default='auto'
         Whether to use a precomputed Gram and Xy matrix to speed up
         calculations. Improves performance when :term:`n_targets` or
@@ -142,7 +135,6 @@ class OrthogonalMatchingPursuit(BaseTransformer):
         n_nonzero_coefs=None,
         tol=None,
         fit_intercept=True,
-        normalize="deprecated",
         precompute="auto",
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
@@ -168,7 +160,6 @@ class OrthogonalMatchingPursuit(BaseTransformer):
         init_args = {'n_nonzero_coefs':(n_nonzero_coefs, None, False),
             'tol':(tol, None, False),
             'fit_intercept':(fit_intercept, True, False),
-            'normalize':(normalize, "deprecated", False),
             'precompute':(precompute, "auto", False),}
         cleaned_up_init_args = validate_sklearn_args(
             args=init_args,

snowflake/ml/modeling/linear_model/passive_aggressive_classifier.py

@@ -119,18 +119,18 @@ class PassiveAggressiveClassifier(BaseTransformer):
     max_iter: int, default=1000
         The maximum number of passes over the training data (aka epochs).
         It only impacts the behavior in the ``fit`` method, and not the
-        :meth:`partial_fit` method.
+        :meth:`~sklearn.linear_model.PassiveAggressiveClassifier.partial_fit` method.
 
     tol: float or None, default=1e-3
         The stopping criterion. If it is not None, the iterations will stop
         when (loss > previous_loss - tol).
 
     early_stopping: bool, default=False
-        Whether to use early stopping to terminate training when validation.
+        Whether to use early stopping to terminate training when validation
         score is not improving. If set to True, it will automatically set aside
         a stratified fraction of training data as validation and terminate
-        training when validation score is not improving by at least tol for
-        n_iter_no_change consecutive epochs.
+        training when validation score is not improving by at least `tol` for
+        `n_iter_no_change` consecutive epochs.
 
     validation_fraction: float, default=0.1
         The proportion of training data to set aside as validation set for

snowflake/ml/modeling/linear_model/passive_aggressive_regressor.py

@@ -119,7 +119,7 @@ class PassiveAggressiveRegressor(BaseTransformer):
     max_iter: int, default=1000
         The maximum number of passes over the training data (aka epochs).
         It only impacts the behavior in the ``fit`` method, and not the
-        :meth:`partial_fit` method.
+        :meth:`~sklearn.linear_model.PassiveAggressiveRegressor.partial_fit` method.
 
     tol: float or None, default=1e-3
         The stopping criterion. If it is not None, the iterations will stop

snowflake/ml/modeling/linear_model/perceptron.py

@@ -157,11 +157,11 @@ class Perceptron(BaseTransformer):
         See :term:`Glossary <random_state>`.
 
     early_stopping: bool, default=False
-        Whether to use early stopping to terminate training when validation.
+        Whether to use early stopping to terminate training when validation
         score is not improving. If set to True, it will automatically set aside
         a stratified fraction of training data as validation and terminate
-        training when validation score is not improving by at least tol for
-        n_iter_no_change consecutive epochs.
+        training when validation score is not improving by at least `tol` for
+        `n_iter_no_change` consecutive epochs.
 
     validation_fraction: float, default=0.1
         The proportion of training data to set aside as validation set for

snowflake/ml/modeling/linear_model/ransac_regressor.py

@@ -133,10 +133,11 @@ class RANSACRegressor(BaseTransformer):
         relative number `ceil(min_samples * X.shape[0])` for
         `min_samples < 1`. This is typically chosen as the minimal number of
         samples necessary to estimate the given `estimator`. By default a
-        ``sklearn.linear_model.LinearRegression()`` estimator is assumed and
+        :class:`~sklearn.linear_model.LinearRegression` estimator is assumed and
         `min_samples` is chosen as ``X.shape[1] + 1``. This parameter is highly
         dependent upon the model, so if a `estimator` other than
-        :class:`linear_model.LinearRegression` is used, the user must provide a value.
+        :class:`~sklearn.linear_model.LinearRegression` is used, the user must
+        provide a value.
 
     residual_threshold: float, default=None
         Maximum residual for a data sample to be classified as an inlier.

snowflake/ml/modeling/linear_model/ridge_classifier_cv.py

@@ -117,6 +117,7 @@ class RidgeClassifierCV(BaseTransformer):
         Alpha corresponds to ``1 / (2C)`` in other linear models such as
         :class:`~sklearn.linear_model.LogisticRegression` or
         :class:`~sklearn.svm.LinearSVC`.
+        If using Leave-One-Out cross-validation, alphas must be strictly positive.
 
     fit_intercept: bool, default=True
         Whether to calculate the intercept for this model. If set
@@ -124,9 +125,8 @@ class RidgeClassifierCV(BaseTransformer):
         (i.e. data is expected to be centered).
 
     scoring: str, callable, default=None
-        A string (see model evaluation documentation) or
-        a scorer callable object / function with signature
-        ``scorer(estimator, X, y)``.
+        A string (see :ref:`scoring_parameter`) or a scorer callable object /
+        function with signature ``scorer(estimator, X, y)``.
 
     cv: int, cross-validation generator or an iterable, default=None
         Determines the cross-validation splitting strategy.
@@ -148,7 +148,13 @@ class RidgeClassifierCV(BaseTransformer):
         weights inversely proportional to class frequencies in the input data
         as ``n_samples / (n_classes * np.bincount(y))``.
 
-    store_cv_values: bool, default=False
+    store_cv_results: bool, default=False
+        Flag indicating if the cross-validation results corresponding to
+        each alpha should be stored in the ``cv_results_`` attribute (see
+        below). This flag is only compatible with ``cv=None`` (i.e. using
+        Leave-One-Out Cross-Validation).
+
+    store_cv_values: bool
         Flag indicating if the cross-validation values corresponding to
         each alpha should be stored in the ``cv_values_`` attribute (see
         below). This flag is only compatible with ``cv=None`` (i.e. using
@@ -163,7 +169,8 @@ class RidgeClassifierCV(BaseTransformer):
         scoring=None,
         cv=None,
         class_weight=None,
-        store_cv_values=False,
+        store_cv_results=None,
+        store_cv_values="deprecated",
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
         label_cols: Optional[Union[str, Iterable[str]]] = None,
@@ -190,7 +197,8 @@ class RidgeClassifierCV(BaseTransformer):
             'scoring':(scoring, None, False),
             'cv':(cv, None, False),
             'class_weight':(class_weight, None, False),
-            'store_cv_values':(store_cv_values, False, False),}
+            'store_cv_results':(store_cv_results, None, False),
+            'store_cv_values':(store_cv_values, "deprecated", False),}
         cleaned_up_init_args = validate_sklearn_args(
             args=init_args,
             klass=sklearn.linear_model.RidgeClassifierCV

snowflake/ml/modeling/linear_model/ridge_cv.py

@@ -117,7 +117,7 @@ class RidgeCV(BaseTransformer):
         Alpha corresponds to ``1 / (2C)`` in other linear models such as
         :class:`~sklearn.linear_model.LogisticRegression` or
         :class:`~sklearn.svm.LinearSVC`.
-        If using Leave-One-Out cross-validation, alphas must be positive.
+        If using Leave-One-Out cross-validation, alphas must be strictly positive.
 
     fit_intercept: bool, default=True
         Whether to calculate the intercept for this model. If set
@@ -125,12 +125,10 @@ class RidgeCV(BaseTransformer):
         (i.e. data is expected to be centered).
 
     scoring: str, callable, default=None
-        A string (see model evaluation documentation) or
-        a scorer callable object / function with signature
-        ``scorer(estimator, X, y)``.
-        If None, the negative mean squared error if cv is 'auto' or None
-        (i.e. when using leave-one-out cross-validation), and r2 score
-        otherwise.
+        A string (see :ref:`scoring_parameter`) or a scorer callable object /
+        function with signature ``scorer(estimator, X, y)``. If None, the
+        negative mean squared error if cv is 'auto' or None (i.e. when using
+        leave-one-out cross-validation), and r2 score otherwise.
 
     cv: int, cross-validation generator or an iterable, default=None
         Determines the cross-validation splitting strategy.
@@ -160,7 +158,7 @@ class RidgeCV(BaseTransformer):
         The 'auto' mode is the default and is intended to pick the cheaper
         option of the two depending on the shape of the training data.
 
-    store_cv_values: bool, default=False
+    store_cv_results: bool, default=False
         Flag indicating if the cross-validation values corresponding to
         each alpha should be stored in the ``cv_values_`` attribute (see
         below). This flag is only compatible with ``cv=None`` (i.e. using
@@ -172,6 +170,12 @@ class RidgeCV(BaseTransformer):
         settings: multiple prediction targets). When set to `True`, after
         fitting, the `alpha_` attribute will contain a value for each target.
         When set to `False`, a single alpha is used for all targets.
+
+    store_cv_values: bool
+        Flag indicating if the cross-validation values corresponding to
+        each alpha should be stored in the ``cv_values_`` attribute (see
+        below). This flag is only compatible with ``cv=None`` (i.e. using
+        Leave-One-Out Cross-Validation).
     """
 
     def __init__(  # type: ignore[no-untyped-def]
@@ -182,8 +186,9 @@ class RidgeCV(BaseTransformer):
         scoring=None,
         cv=None,
         gcv_mode=None,
-        store_cv_values=False,
+        store_cv_results=None,
         alpha_per_target=False,
+        store_cv_values="deprecated",
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
         label_cols: Optional[Union[str, Iterable[str]]] = None,
@@ -210,8 +215,9 @@ class RidgeCV(BaseTransformer):
             'scoring':(scoring, None, False),
             'cv':(cv, None, False),
             'gcv_mode':(gcv_mode, None, False),
-            'store_cv_values':(store_cv_values, False, False),
-            'alpha_per_target':(alpha_per_target, False, False),}
+            'store_cv_results':(store_cv_results, None, False),
+            'alpha_per_target':(alpha_per_target, False, False),
+            'store_cv_values':(store_cv_values, "deprecated", False),}
         cleaned_up_init_args = validate_sklearn_args(
             args=init_args,
             klass=sklearn.linear_model.RidgeCV

snowflake/ml/modeling/linear_model/sgd_classifier.py

@@ -207,10 +207,10 @@ class SGDClassifier(BaseTransformer):
         The initial learning rate for the 'constant', 'invscaling' or
         'adaptive' schedules. The default value is 0.0 as eta0 is not used by
         the default schedule 'optimal'.
-        Values must be in the range `(0.0, inf)`.
+        Values must be in the range `[0.0, inf)`.
 
     power_t: float, default=0.5
-        The exponent for inverse scaling learning rate [default 0.5].
+        The exponent for inverse scaling learning rate.
         Values must be in the range `(-inf, inf)`.
 
     early_stopping: bool, default=False

snowflake/ml/modeling/linear_model/sgd_one_class_svm.py

@@ -122,10 +122,12 @@ class SGDOneClassSVM(BaseTransformer):
         The maximum number of passes over the training data (aka epochs).
         It only impacts the behavior in the ``fit`` method, and not the
         `partial_fit`. Defaults to 1000.
+        Values must be in the range `[1, inf)`.
 
     tol: float or None, default=1e-3
         The stopping criterion. If it is not None, the iterations will stop
         when (loss > previous_loss - tol). Defaults to 1e-3.
+        Values must be in the range `[0.0, inf)`.
 
     shuffle: bool, default=True
         Whether or not the training data should be shuffled after each epoch.
@@ -158,9 +160,11 @@ class SGDOneClassSVM(BaseTransformer):
         The initial learning rate for the 'constant', 'invscaling' or
         'adaptive' schedules. The default value is 0.0 as eta0 is not used by
         the default schedule 'optimal'.
+        Values must be in the range `[0.0, inf)`.
 
     power_t: float, default=0.5
-        The exponent for inverse scaling learning rate [default 0.5].
+        The exponent for inverse scaling learning rate.
+        Values must be in the range `(-inf, inf)`.
 
     warm_start: bool, default=False
         When set to True, reuse the solution of the previous call to fit as

snowflake/ml/modeling/linear_model/sgd_regressor.py

@@ -132,14 +132,15 @@ class SGDRegressor(BaseTransformer):
 
     alpha: float, default=0.0001
         Constant that multiplies the regularization term. The higher the
-        value, the stronger the regularization.
-        Also used to compute the learning rate when set to `learning_rate` is
-        set to 'optimal'.
+        value, the stronger the regularization. Also used to compute the
+        learning rate when `learning_rate` is set to 'optimal'.
+        Values must be in the range `[0.0, inf)`.
 
     l1_ratio: float, default=0.15
         The Elastic Net mixing parameter, with 0 <= l1_ratio <= 1.
         l1_ratio=0 corresponds to L2 penalty, l1_ratio=1 to L1.
         Only used if `penalty` is 'elasticnet'.
+        Values must be in the range `[0.0, 1.0]`.
 
     fit_intercept: bool, default=True
         Whether the intercept should be estimated or not. If False, the
@@ -149,6 +150,7 @@ class SGDRegressor(BaseTransformer):
         The maximum number of passes over the training data (aka epochs).
         It only impacts the behavior in the ``fit`` method, and not the
         :meth:`partial_fit` method.
+        Values must be in the range `[1, inf)`.
 
     tol: float or None, default=1e-3
         The stopping criterion. If it is not None, training will stop
@@ -156,12 +158,14 @@ class SGDRegressor(BaseTransformer):
         epochs.
         Convergence is checked against the training loss or the
         validation loss depending on the `early_stopping` parameter.
+        Values must be in the range `[0.0, inf)`.
 
     shuffle: bool, default=True
         Whether or not the training data should be shuffled after each epoch.
 
     verbose: int, default=0
         The verbosity level.
+        Values must be in the range `[0, inf)`.
 
     epsilon: float, default=0.1
         Epsilon in the epsilon-insensitive loss functions; only if `loss` is
@@ -170,6 +174,7 @@ class SGDRegressor(BaseTransformer):
         important to get the prediction exactly right.
         For epsilon-insensitive, any differences between the current prediction
         and the correct label are ignored if they are less than this threshold.
+        Values must be in the range `[0.0, inf)`.
 
     random_state: int, RandomState instance, default=None
         Used for shuffling the data, when ``shuffle`` is set to ``True``.
@@ -191,9 +196,11 @@ class SGDRegressor(BaseTransformer):
     eta0: float, default=0.01
         The initial learning rate for the 'constant', 'invscaling' or
         'adaptive' schedules. The default value is 0.01.
+        Values must be in the range `[0.0, inf)`.
 
     power_t: float, default=0.25
         The exponent for inverse scaling learning rate.
+        Values must be in the range `(-inf, inf)`.
 
     early_stopping: bool, default=False
         Whether to use early stopping to terminate training when validation
@@ -207,12 +214,14 @@ class SGDRegressor(BaseTransformer):
         The proportion of training data to set aside as validation set for
         early stopping. Must be between 0 and 1.
         Only used if `early_stopping` is True.
+        Values must be in the range `(0.0, 1.0)`.
 
     n_iter_no_change: int, default=5
         Number of iterations with no improvement to wait before stopping
         fitting.
         Convergence is checked against the training loss or the
         validation loss depending on the `early_stopping` parameter.
+        Integer values must be in the range `[1, max_iter)`.
 
     warm_start: bool, default=False
         When set to True, reuse the solution of the previous call to fit as