snowflake-ml-python 1.1.1__py3-none-any.whl → 1.1.2__py3-none-any.whl

snowflake/ml/modeling/preprocessing/one_hot_encoder.py

@@ -101,7 +101,7 @@ class OneHotEncoder(base.BaseTransformer):
     (https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OneHotEncoder.html).
 
     Args:
-        categories: 'auto' or dict {column_name: ndarray([category])}, default='auto'
+        categories: 'auto' or dict {column_name: np.ndarray([category])}, default='auto'
             Categories (unique values) per feature:
             - 'auto': Determine categories automatically from the training data.
             - dict: ``categories[column_name]`` holds the categories expected in
@@ -109,6 +109,7 @@ class OneHotEncoder(base.BaseTransformer):
               and numeric values within a single feature, and should be sorted in
               case of numeric values.
             The used categories can be found in the ``categories_`` attribute.
+
         drop: {‘first’, ‘if_binary’} or an array-like of shape (n_features,), default=None
             Specifies a methodology to use to drop one of the categories per
             feature. This is useful in situations where perfectly collinear
@@ -128,15 +129,18 @@ class OneHotEncoder(base.BaseTransformer):
             When `max_categories` or `min_frequency` is configured to group
             infrequent categories, the dropping behavior is handled after the
             grouping.
+
         sparse: bool, default=False
             Will return a column with sparse representation if set True else will return
             a separate column for each category.
+
         handle_unknown: {'error', 'ignore'}, default='error'
             Specifies the way unknown categories are handled during :meth:`transform`.
             - 'error': Raise an error if an unknown category is present during transform.
             - 'ignore': When an unknown category is encountered during
               transform, the resulting one-hot encoded columns for this feature
               will be all zeros.
+
         min_frequency: int or float, default=None
             Specifies the minimum frequency below which a category will be
             considered infrequent.
@@ -144,22 +148,29 @@ class OneHotEncoder(base.BaseTransformer):
               infrequent.
             - If `float`, categories with a smaller cardinality than
               `min_frequency * n_samples`  will be considered infrequent.
+
         max_categories: int, default=None
             Specifies an upper limit to the number of output features for each input
             feature when considering infrequent categories. If there are infrequent
             categories, `max_categories` includes the category representing the
             infrequent categories along with the frequent categories. If `None`,
             there is no limit to the number of output features.
-        input_cols: str or Iterable [column_name], default=None
+
+        input_cols: Optional[Union[str, List[str]]], default=None
             Single or multiple input columns.
-        output_cols: str or Iterable [column_name], default=None
+
+        output_cols: Optional[Union[str, List[str]]], default=None
             Single or multiple output columns.
-        passthrough_cols: A string or a list of strings indicating column names to be excluded from any
-                operations (such as train, transform, or inference). These specified column(s)
-                will remain untouched throughout the process. This option is helpful in scenarios
-                requiring automatic input_cols inference, but need to avoid using specific
-                columns, like index columns, during training or inference.
-        drop_input_cols: Remove input columns from output if set True. False by default.
+
+        passthrough_cols: Optional[Union[str, List[str]]]
+            A string or a list of strings indicating column names to be excluded from any
+            operations (such as train, transform, or inference). These specified column(s)
+            will remain untouched throughout the process. This option is helpful in scenarios
+            requiring automatic input_cols inference, but need to avoid using specific
+            columns, like index columns, during training or inference.
+
+        drop_input_cols: Optional[Union[str, List[str]]]
+            Remove input columns from output if set True. False by default.
 
     Attributes:
         categories_: dict {column_name: ndarray([category])}
@@ -665,10 +676,6 @@ class OneHotEncoder(base.BaseTransformer):
         project=base.PROJECT,
         subproject=base.SUBPROJECT,
     )
-    @telemetry.add_stmt_params_to_df(
-        project=base.PROJECT,
-        subproject=base.SUBPROJECT,
-    )
     def transform(
         self, dataset: Union[snowpark.DataFrame, pd.DataFrame]
     ) -> Union[snowpark.DataFrame, pd.DataFrame, sparse.csr_matrix]:

snowflake/ml/modeling/preprocessing/ordinal_encoder.py

@@ -45,31 +45,47 @@ class OrdinalEncoder(base.BaseTransformer):
     (https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.OrdinalEncoder.html).
 
     Args:
-        categories: The string 'auto' (the default) causes the categories to be extracted from the input columns.
+        categories: Union[str, Dict[str, type_utils.LiteralNDArrayType]], default="auto"
+            The string 'auto' (the default) causes the categories to be extracted from the input columns.
             To specify the categories yourself, pass a dictionary mapping the column name to an ndarray containing the
             categories.
-        handle_unknown: Specifies how unknown categories are handled during transformation. Applicable only if
+
+        handle_unknown: str, default="error"
+            Specifies how unknown categories are handled during transformation. Applicable only if
             categories is not 'auto'.
             Valid values are:
                 - 'error': Raise an error if an unknown category is present during transform (default).
                 - 'use_encoded_value': When an unknown category is encountered during transform, the specified
                     encoded_missing_value (below) is used.
-        unknown_value: When the parameter handle_unknown is set to 'use_encoded_value', this parameter is required and
+
+        unknown_value: Optional[Union[int, float]], default=None
+            When the parameter handle_unknown is set to 'use_encoded_value', this parameter is required and
             will set the encoded value of unknown categories. It has to be distinct from the values used to encode any
             of the categories in `fit`.
-        encoded_missing_value: The value to be used to encode unknown categories.
-        input_cols: The name(s) of one or more columns in a DataFrame containing a feature to be encoded.
-        output_cols: The name(s) of one or more columns in a DataFrame in which results will be stored. The number of
+
+        encoded_missing_value: Union[int, float], default=np.nan
+            The value to be used to encode unknown categories.
+
+        input_cols: Optional[Union[str, List[str]]], default=None
+            The name(s) of one or more columns in a DataFrame containing a feature to be encoded.
+
+        output_cols: Optional[Union[str, List[str]]], default=None
+            The name(s) of one or more columns in a DataFrame in which results will be stored. The number of
             columns specified must match the number of input columns.
-        passthrough_cols: A string or a list of strings indicating column names to be excluded from any
+
+        passthrough_cols: Optional[Union[str, List[str]]], default=None
+            A string or a list of strings indicating column names to be excluded from any
             operations (such as train, transform, or inference). These specified column(s)
             will remain untouched throughout the process. This option is helpful in scenarios
             requiring automatic input_cols inference, but need to avoid using specific
             columns, like index columns, during training or inference.
-        drop_input_cols: Remove input columns from output if set True. False by default.
+
+        drop_input_cols: Optional[bool], default=False
+            Remove input columns from output if set True. False by default.
 
     Attributes:
-        categories_ (dict of ndarray): The categories of each feature determined during fitting. Maps input column
+        categories_ (dict of ndarray): List[type_utils.LiteralNDArrayType]
+            The categories of each feature determined during fitting. Maps input column
             names to an array of the detected categories.
             Attributes are valid only after fit() has been called.
     """
@@ -429,10 +445,6 @@ class OrdinalEncoder(base.BaseTransformer):
         project=base.PROJECT,
         subproject=base.SUBPROJECT,
     )
-    @telemetry.add_stmt_params_to_df(
-        project=base.PROJECT,
-        subproject=base.SUBPROJECT,
-    )
     def transform(self, dataset: Union[snowpark.DataFrame, pd.DataFrame]) -> Union[snowpark.DataFrame, pd.DataFrame]:
         """
         Transform dataset to ordinal codes.

snowflake/ml/modeling/preprocessing/polynomial_features.py

@@ -22,17 +22,19 @@ from sklearn.utils.metaestimators import available_if
 from snowflake.ml.modeling.framework.base import BaseTransformer, _process_cols
 from snowflake.ml._internal import telemetry
 from snowflake.ml._internal.exceptions import error_codes, exceptions, modeling_error_messages
+from snowflake.ml._internal.env_utils import SNOWML_SPROC_ENV
 from snowflake.ml._internal.utils import pkg_version_utils, identifier
-from snowflake.snowpark import DataFrame
+from snowflake.snowpark import DataFrame, Session
 from snowflake.snowpark._internal.type_utils import convert_sp_to_sf_type
 from snowflake.ml.modeling._internal.snowpark_handlers import SnowparkHandlers as HandlersImpl
+from snowflake.ml.modeling._internal.model_trainer_builder import ModelTrainerBuilder
+from snowflake.ml.modeling._internal.model_trainer import ModelTrainer
 from snowflake.ml.modeling._internal.estimator_utils import (
     gather_dependencies,
     original_estimator_has_callable,
     transform_snowml_obj_to_sklearn_obj,
     validate_sklearn_args,
 )
-from snowflake.ml.modeling._internal.snowpark_handlers import SklearnWrapperProvider
 from snowflake.ml.modeling._internal.estimator_protocols import FitPredictHandlers
 
 from snowflake.ml.model.model_signature import (
@@ -52,7 +54,6 @@ _PROJECT = "ModelDevelopment"
 _SUBPROJECT = "".join([s.capitalize() for s in "sklearn.preprocessing".replace("sklearn.", "").split("_")])
 
 
-
 class PolynomialFeatures(BaseTransformer):
     r"""Generate polynomial and interaction features
     For more details on this class, see [sklearn.preprocessing.PolynomialFeatures]
@@ -60,6 +61,49 @@ class PolynomialFeatures(BaseTransformer):
 
     Parameters
     ----------
+
+    input_cols: Optional[Union[str, List[str]]]
+        A string or list of strings representing column names that contain features.
+        If this parameter is not specified, all columns in the input DataFrame except
+        the columns specified by label_cols, sample_weight_col, and passthrough_cols
+        parameters are considered input columns. Input columns can also be set after
+        initialization with the `set_input_cols` method.
+    
+    label_cols: Optional[Union[str, List[str]]]
+        This parameter is optional and will be ignored during fit. It is present here for API consistency by convention.
+                    
+    output_cols: Optional[Union[str, List[str]]]
+        A string or list of strings representing column names that will store the
+        output of predict and transform operations. The length of output_cols must
+        match the expected number of output columns from the specific predictor or
+        transformer class used.
+        If you omit this parameter, output column names are derived by adding an
+        OUTPUT_ prefix to the label column names for supervised estimators, or
+        OUTPUT_<IDX>for unsupervised estimators. These inferred output column names
+        work for predictors, but output_cols must be set explicitly for transformers.
+        In general, explicitly specifying output column names is clearer, especially
+        if you don’t specify the input column names.
+        To transform in place, pass the same names for input_cols and output_cols.
+        be set explicitly for transformers. Output columns can also be set after
+        initialization with the `set_output_cols` method.
+
+    sample_weight_col: Optional[str]
+        A string representing the column name containing the sample weights.
+        This argument is only required when working with weighted datasets. Sample
+        weight column can also be set after initialization with the
+        `set_sample_weight_col` method.
+
+    passthrough_cols: Optional[Union[str, List[str]]]
+        A string or a list of strings indicating column names to be excluded from any
+        operations (such as train, transform, or inference). These specified column(s)
+        will remain untouched throughout the process. This option is helpful in scenarios
+        requiring automatic input_cols inference, but need to avoid using specific
+        columns, like index columns, during training or inference. Passthrough columns
+        can also be set after initialization with the `set_passthrough_cols` method.
+
+    drop_input_cols: Optional[bool], default=False
+        If set, the response of predict(), transform() methods will not contain input columns.
+
     degree: int or tuple (min_degree, max_degree), default=2
         If a single int is given, it specifies the maximal degree of the
         polynomial features. If a tuple `(min_degree, max_degree)` is passed,
@@ -84,42 +128,6 @@ class PolynomialFeatures(BaseTransformer):
     order: {'C', 'F'}, default='C'
         Order of output array in the dense case. `'F'` order is faster to
         compute, but may slow down subsequent estimators.
-
-    input_cols: Optional[Union[str, List[str]]]
-        A string or list of strings representing column names that contain features.
-        If this parameter is not specified, all columns in the input DataFrame except
-        the columns specified by label_cols, sample_weight_col, and passthrough_cols
-        parameters are considered input columns.
-
-    label_cols: Optional[Union[str, List[str]]]
-        A string or list of strings representing column names that contain labels.
-        This is a required param for estimators, as there is no way to infer these
-        columns. If this parameter is not specified, then object is fitted without
-        labels (like a transformer).
-
-    output_cols: Optional[Union[str, List[str]]]
-        A string or list of strings representing column names that will store the
-        output of predict and transform operations. The length of output_cols must
-        match the expected number of output columns from the specific estimator or
-        transformer class used.
-        If this parameter is not specified, output column names are derived by
-        adding an OUTPUT_ prefix to the label column names. These inferred output
-        column names work for estimator's predict() method, but output_cols must
-        be set explicitly for transformers.
-
-    sample_weight_col: Optional[str]
-        A string representing the column name containing the sample weights.
-        This argument is only required when working with weighted datasets.
-
-    passthrough_cols: Optional[Union[str, List[str]]]
-        A string or a list of strings indicating column names to be excluded from any
-        operations (such as train, transform, or inference). These specified column(s)
-        will remain untouched throughout the process. This option is helpful in scenarios
-        requiring automatic input_cols inference, but need to avoid using specific
-        columns, like index columns, during training or inference.
-
-    drop_input_cols: Optional[bool], default=False
-        If set, the response of predict(), transform() methods will not contain input columns.
     """
 
     def __init__(  # type: ignore[no-untyped-def]
@@ -144,7 +152,7 @@ class PolynomialFeatures(BaseTransformer):
         self.set_passthrough_cols(passthrough_cols)
         self.set_drop_input_cols(drop_input_cols)
         self.set_sample_weight_col(sample_weight_col)        
-        deps = set(SklearnWrapperProvider().dependencies)
+        deps: Set[str] = set([f'numpy=={np.__version__}', f'scikit-learn=={sklearn.__version__}', f'cloudpickle=={cp.__version__}'])
         
         self._deps = list(deps)
         
@@ -156,13 +164,14 @@ class PolynomialFeatures(BaseTransformer):
             args=init_args,
             klass=sklearn.preprocessing.PolynomialFeatures
         )
-        self._sklearn_object = sklearn.preprocessing.PolynomialFeatures(
+        self._sklearn_object: Any = sklearn.preprocessing.PolynomialFeatures(
             **cleaned_up_init_args,
         )
         self._model_signature_dict: Optional[Dict[str, ModelSignature]] = None
         # If user used snowpark dataframe during fit, here it stores the snowpark input_cols, otherwise the processed input_cols
         self._snowpark_cols: Optional[List[str]] = self.input_cols
-        self._handlers: FitPredictHandlers = HandlersImpl(class_name=PolynomialFeatures.__class__.__name__, subproject=_SUBPROJECT, autogenerated=True, wrapper_provider=SklearnWrapperProvider())
+        self._handlers: FitPredictHandlers = HandlersImpl(class_name=PolynomialFeatures.__class__.__name__, subproject=_SUBPROJECT, autogenerated=True)
+        self._autogenerated = True
 
     def _get_rand_id(self) -> str:
         """
@@ -218,54 +227,48 @@ class PolynomialFeatures(BaseTransformer):
             self
         """
         self._infer_input_output_cols(dataset)
-        if isinstance(dataset, pd.DataFrame):
-            assert self._sklearn_object is not None  # keep mypy happy
-            self._sklearn_object = self._handlers.fit_pandas(
-                dataset,
-                self._sklearn_object,
-                self.input_cols,
-                self.label_cols,
-                self.sample_weight_col
-            )
-        elif isinstance(dataset, DataFrame):
-            self._fit_snowpark(dataset)
-        else:
-            raise TypeError(
-                f"Unexpected dataset type: {type(dataset)}."
-                "Supported dataset types: snowpark.DataFrame, pandas.DataFrame."
-            )
+        if isinstance(dataset, DataFrame):
+            session = dataset._session
+            assert session is not None  # keep mypy happy
+            # Validate that key package version in user workspace are supported in snowflake conda channel
+            # If customer doesn't have package in conda channel, replace the ones have the closest versions
+            self._deps = pkg_version_utils.get_valid_pkg_versions_supported_in_snowflake_conda_channel(
+                pkg_versions=self._get_dependencies(), session=session, subproject=_SUBPROJECT)
+            
+            # Specify input columns so column pruning will be enforced
+            selected_cols = self._get_active_columns()
+            if len(selected_cols) > 0:
+                dataset = dataset.select(selected_cols)
+
+            self._snowpark_cols = dataset.select(self.input_cols).columns
+
+             # If we are already in a stored procedure, no need to kick off another one.
+            if SNOWML_SPROC_ENV in os.environ:
+                statement_params = telemetry.get_function_usage_statement_params(
+                    project=_PROJECT,
+                    subproject=_SUBPROJECT,
+                    function_name=telemetry.get_statement_params_full_func_name(inspect.currentframe(), PolynomialFeatures.__class__.__name__),
+                    api_calls=[Session.call],
+                    custom_tags=dict([("autogen", True)]) if self._autogenerated else None,
+                )
+                pd_df: pd.DataFrame = dataset.to_pandas(statement_params=statement_params)
+                pd_df.columns = dataset.columns
+                dataset = pd_df
+
+        model_trainer = ModelTrainerBuilder.build(
+            estimator=self._sklearn_object,
+            dataset=dataset,
+            input_cols=self.input_cols,
+            label_cols=self.label_cols,
+            sample_weight_col=self.sample_weight_col,
+            autogenerated=self._autogenerated,
+            subproject=_SUBPROJECT
+        )
+        self._sklearn_object = model_trainer.train()
         self._is_fitted = True
         self._get_model_signatures(dataset)
         return self
 
-    def _fit_snowpark(self, dataset: DataFrame) -> None:
-        session = dataset._session
-        assert session is not None  # keep mypy happy
-        # Validate that key package version in user workspace are supported in snowflake conda channel
-        # If customer doesn't have package in conda channel, replace the ones have the closest versions
-        self._deps = pkg_version_utils.get_valid_pkg_versions_supported_in_snowflake_conda_channel(
-            pkg_versions=self._get_dependencies(), session=session, subproject=_SUBPROJECT)
-        
-        # Specify input columns so column pruning will be enforced
-        selected_cols = self._get_active_columns()
-        if len(selected_cols) > 0:
-            dataset = dataset.select(selected_cols)
-
-        estimator = self._sklearn_object
-        assert estimator is not None  # Keep mypy happy
-
-        self._snowpark_cols = dataset.select(self.input_cols).columns
-
-        self._sklearn_object = self._handlers.fit_snowpark(
-            dataset,
-            session,
-            estimator,
-            ["snowflake-snowpark-python"] + self._get_dependencies(),
-            self.input_cols,
-            self.label_cols,
-            self.sample_weight_col,
-        )
-
     def _get_pass_through_columns(self, dataset: DataFrame) -> List[str]:
         if self._drop_input_cols:
             return []
@@ -453,11 +456,6 @@ class PolynomialFeatures(BaseTransformer):
         subproject=_SUBPROJECT,
         custom_tags=dict([("autogen", True)]),
     )
-    @telemetry.add_stmt_params_to_df(
-        project=_PROJECT,
-        subproject=_SUBPROJECT,
-        custom_tags=dict([("autogen", True)]),
-    )
     def predict(self, dataset: Union[DataFrame, pd.DataFrame]) -> Union[DataFrame, pd.DataFrame]:
         """Method not supported for this class.
 
@@ -509,11 +507,6 @@ class PolynomialFeatures(BaseTransformer):
         subproject=_SUBPROJECT,
         custom_tags=dict([("autogen", True)]),
     )
-    @telemetry.add_stmt_params_to_df(
-        project=_PROJECT,
-        subproject=_SUBPROJECT,
-        custom_tags=dict([("autogen", True)]),
-    )
     def transform(self, dataset: Union[DataFrame, pd.DataFrame]) -> Union[DataFrame, pd.DataFrame]:
         """Transform data to polynomial features
         For more details on this function, see [sklearn.preprocessing.PolynomialFeatures.transform]
@@ -572,7 +565,8 @@ class PolynomialFeatures(BaseTransformer):
         if False:
             self.fit(dataset)
             assert self._sklearn_object is not None
-            return self._sklearn_object.labels_
+            labels : npt.NDArray[Any] = self._sklearn_object.labels_
+            return labels
         else:
             raise NotImplementedError
 
@@ -608,6 +602,7 @@ class PolynomialFeatures(BaseTransformer):
             output_cols = []
 
         # Make sure column names are valid snowflake identifiers.
+        assert output_cols is not None  # Make MyPy happy
         rv = [identifier.rename_to_valid_snowflake_identifier(c) for c in output_cols]
 
         return rv
@@ -618,11 +613,6 @@ class PolynomialFeatures(BaseTransformer):
         subproject=_SUBPROJECT,
         custom_tags=dict([("autogen", True)]),
     )
-    @telemetry.add_stmt_params_to_df(
-        project=_PROJECT,
-        subproject=_SUBPROJECT,
-        custom_tags=dict([("autogen", True)]),
-    )
     def predict_proba(
         self, dataset: Union[DataFrame, pd.DataFrame], output_cols_prefix: str = "predict_proba_"
     ) -> Union[DataFrame, pd.DataFrame]:
@@ -663,11 +653,6 @@ class PolynomialFeatures(BaseTransformer):
         subproject=_SUBPROJECT,
         custom_tags=dict([("autogen", True)]),
     )
-    @telemetry.add_stmt_params_to_df(
-        project=_PROJECT,
-        subproject=_SUBPROJECT,
-        custom_tags=dict([("autogen", True)]),
-    )
     def predict_log_proba(
         self, dataset: Union[DataFrame, pd.DataFrame], output_cols_prefix: str = "predict_log_proba_"
     ) -> Union[DataFrame, pd.DataFrame]:
@@ -704,16 +689,6 @@ class PolynomialFeatures(BaseTransformer):
         return output_df
 
     @available_if(original_estimator_has_callable("decision_function"))  # type: ignore[misc]
-    @telemetry.send_api_usage_telemetry(
-        project=_PROJECT,
-        subproject=_SUBPROJECT,
-        custom_tags=dict([("autogen", True)]),
-    )
-    @telemetry.add_stmt_params_to_df(
-        project=_PROJECT,
-        subproject=_SUBPROJECT,
-        custom_tags=dict([("autogen", True)]),
-    )
     def decision_function(
         self, dataset: Union[DataFrame, pd.DataFrame], output_cols_prefix: str = "decision_function_"
     ) -> Union[DataFrame, pd.DataFrame]:
@@ -812,11 +787,6 @@ class PolynomialFeatures(BaseTransformer):
         subproject=_SUBPROJECT,
         custom_tags=dict([("autogen", True)]),
     )
-    @telemetry.add_stmt_params_to_df(
-        project=_PROJECT,
-        subproject=_SUBPROJECT,
-        custom_tags=dict([("autogen", True)]),
-    )
     def kneighbors(
         self,
         dataset: Union[DataFrame, pd.DataFrame],
@@ -876,9 +846,9 @@ class PolynomialFeatures(BaseTransformer):
             # For classifier, the type of predict is the same as the type of label
             if self._sklearn_object._estimator_type == 'classifier':
                  # label columns is the desired type for output
-                outputs = _infer_signature(dataset[self.label_cols], "output", use_snowflake_identifiers=True)
+                outputs = list(_infer_signature(dataset[self.label_cols], "output", use_snowflake_identifiers=True))
                 # rename the output columns
-                outputs = model_signature_utils.rename_features(outputs, self.output_cols)
+                outputs = list(model_signature_utils.rename_features(outputs, self.output_cols))
                 self._model_signature_dict["predict"] = ModelSignature(inputs,
                                                                        ([] if self._drop_input_cols else inputs)
                                                                        + outputs)

snowflake/ml/modeling/preprocessing/robust_scaler.py

@@ -20,28 +20,46 @@ class RobustScaler(base.BaseTransformer):
     (https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.RobustScaler.html).
 
     Args:
-        with_centering: If True, center the data around zero before scaling.
-        with_scaling: If True, scale the data to interquartile range.
-        quantile_range: tuple like (q_min, q_max), where 0.0 < q_min < q_max < 100.0, default=(25.0, 75.0). Quantile
+        with_centering: bool, default=True
+            If True, center the data around zero before scaling.
+
+        with_scaling: bool, default=True
+            If True, scale the data to interquartile range.
+
+        quantile_range: Tuple[float, float], default=(25.0, 75.0)
+            tuple like (q_min, q_max), where 0.0 < q_min < q_max < 100.0, default=(25.0, 75.0). Quantile
             range used to calculate scale_. By default, this is equal to the IQR, i.e., q_min is the first quantile and
             q_max is the third quantile.
-        unit_variance: If True, scale data so that normally-distributed features have a variance of 1. In general, if
+
+        unit_variance: bool, default=False
+            If True, scale data so that normally-distributed features have a variance of 1. In general, if
             the difference between the x-values of q_max and q_min for a standard normal distribution is greater than 1,
             the dataset is scaled down. If less than 1, the dataset is scaled up.
-        input_cols: The name(s) of one or more columns in a DataFrame containing a feature to be scaled.
-        output_cols: The name(s) of one or more columns in a DataFrame in which results will be stored. The number of
+
+        input_cols: Optional[Union[str, List[str]]], default=None
+            The name(s) of one or more columns in a DataFrame containing a feature to be scaled.
+
+        output_cols: Optional[Union[str, List[str]]], default=None
+            The name(s) of one or more columns in a DataFrame in which results will be stored. The number of
             columns specified must match the number of input columns. For dense output, the column names specified are
             used as base names for the columns created for each category.
-        passthrough_cols: A string or a list of strings indicating column names to be excluded from any
+
+        passthrough_cols: Optional[Union[str, List[str]]], default=None
+            A string or a list of strings indicating column names to be excluded from any
             operations (such as train, transform, or inference). These specified column(s)
             will remain untouched throughout the process. This option is helpful in scenarios
             requiring automatic input_cols inference, but need to avoid using specific
             columns, like index columns, during training or inference.
-        drop_input_cols: Remove input columns from output if set True. False by default.
+
+        drop_input_cols: Optional[bool], default=False
+            Remove input columns from output if set True. False by default.
 
     Attributes:
-        center_: Dictionary mapping input column name to the median value for that feature.
-        scale_: Dictionary mapping input column name to the (scaled) interquartile range for that feature.
+        center_: Dict[str, float]
+            Dictionary mapping input column name to the median value for that feature.
+
+        scale_: Dict[str, float]
+            Dictionary mapping input column name to the (scaled) interquartile range for that feature.
     """
 
     def __init__(
@@ -199,10 +217,6 @@ class RobustScaler(base.BaseTransformer):
         project=base.PROJECT,
         subproject=base.SUBPROJECT,
     )
-    @telemetry.add_stmt_params_to_df(
-        project=base.PROJECT,
-        subproject=base.SUBPROJECT,
-    )
     def transform(self, dataset: Union[snowpark.DataFrame, pd.DataFrame]) -> Union[snowpark.DataFrame, pd.DataFrame]:
         """
         Center and scale the data.

snowflake/ml/modeling/preprocessing/standard_scaler.py

@@ -19,24 +19,40 @@ class StandardScaler(base.BaseTransformer):
     (https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.StandardScaler.html).
 
     Args:
-        with_mean: If True, center the data before scaling.
-        with_std: If True, scale the data unit variance (i.e. unit standard deviation).
-        input_cols: The name(s) of one or more columns in a DataFrame containing a feature to be scaled.
-        output_cols: The name(s) of one or more columns in a DataFrame in which results will be stored. The number of
+        with_mean: bool, default=True
+            If True, center the data before scaling.
+
+        with_std: bool, default=True
+            If True, scale the data unit variance (i.e. unit standard deviation).
+
+        input_cols: Optional[Union[str, List[str]]], default=None
+            The name(s) of one or more columns in a DataFrame containing a feature to be scaled.
+
+        output_cols: Optional[Union[str, List[str]]], default=None
+            The name(s) of one or more columns in a DataFrame in which results will be stored. The number of
             columns specified must match the number of input columns.
-        passthrough_cols: A string or a list of strings indicating column names to be excluded from any
+
+        passthrough_cols: Optional[Union[str, List[str]]], default=None
+            A string or a list of strings indicating column names to be excluded from any
             operations (such as train, transform, or inference). These specified column(s)
             will remain untouched throughout the process. This option is helpful in scenarios
             requiring automatic input_cols inference, but need to avoid using specific
             columns, like index columns, during training or inference.
-        drop_input_cols: Remove input columns from output if set True. False by default.
+
+        drop_input_cols: Optional[bool], default=False
+            Remove input columns from output if set True. False by default.
 
     Attributes:
-        scale_: Dictionary mapping input column names to relative scaling factor to achieve zero mean and unit variance.
+        scale_: Optional[Dict[str, float]] = {}
+            Dictionary mapping input column names to relative scaling factor to achieve zero mean and unit variance.
             If a variance is zero, unit variance could not be achieved, and the data is left as-is, giving a scaling
             factor of 1. None if with_std is False.
-        mean_: Dictionary mapping input column name to the mean value for that feature. None if with_mean is False.
-        var_: Dictionary mapping input column name to the variance for that feature. Used to compute scale_. None if
+
+        mean_: Optional[Dict[str, float]] = {}
+            Dictionary mapping input column name to the mean value for that feature. None if with_mean is False.
+
+        var_: Optional[Dict[str, float]] = {}
+            Dictionary mapping input column name to the variance for that feature. Used to compute scale_. None if
             with_std is False
     """
 
@@ -177,10 +193,6 @@ class StandardScaler(base.BaseTransformer):
         project=base.PROJECT,
         subproject=base.SUBPROJECT,
     )
-    @telemetry.add_stmt_params_to_df(
-        project=base.PROJECT,
-        subproject=base.SUBPROJECT,
-    )
     def transform(self, dataset: Union[snowpark.DataFrame, pd.DataFrame]) -> Union[snowpark.DataFrame, pd.DataFrame]:
         """
         Perform standardization by centering and scaling.