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

snowflake/ml/modeling/preprocessing/max_abs_scaler.py

@@ -27,14 +27,29 @@ class MaxAbsScaler(base.BaseTransformer):
     (https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MaxAbsScaler.html).
 
     Args:
-        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.
-        drop_input_cols: Remove input columns from output if set True. False by default.
+
+        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: Optional[bool], default=False
+            Remove input columns from output if set True. False by default.
 
     Attributes:
-        scale_: dict {column_name: value} or None. Per-feature relative scaling factor.
-        max_abs_: dict {column_name: value} or None. Per-feature maximum absolute value.
+        scale_: Dict[str, float]
+            dict {column_name: value} or None. Per-feature relative scaling factor.
+
+        max_abs_: Dict[str, float]
+            dict {column_name: value} or None. Per-feature maximum absolute value.
     """
 
     def __init__(
@@ -42,6 +57,7 @@ class MaxAbsScaler(base.BaseTransformer):
         *,
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
+        passthrough_cols: Optional[Union[str, Iterable[str]]] = None,
         drop_input_cols: Optional[bool] = False,
     ) -> None:
         """
@@ -55,6 +71,11 @@ class MaxAbsScaler(base.BaseTransformer):
         Args:
             input_cols: Single or multiple input columns.
             output_cols: 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 helful in scenarios
+                requiring automatic input_cols inference, but need to avoid using specific
+                columns, like index columns, during in training or inference.
             drop_input_cols: Remove input columns from output if set True. False by default.
 
         Attributes:
@@ -74,6 +95,7 @@ class MaxAbsScaler(base.BaseTransformer):
 
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
+        self.set_passthrough_cols(passthrough_cols)
 
     def _reset(self) -> None:
         """
@@ -138,10 +160,6 @@ class MaxAbsScaler(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]:
         """
         Scale the data.

snowflake/ml/modeling/preprocessing/min_max_scaler.py

@@ -21,20 +21,45 @@ class MinMaxScaler(base.BaseTransformer):
     (https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.MinMaxScaler.html).
 
     Args:
-        feature_range: Desired range of transformed data (default is 0 to 1).
-        clip: Whether to clip transformed values of held-out data to the specified feature range (default is True).
-        input_cols: The name(s) of one or more columns in a DataFrame containing a feature to be scaled. Each specified
+        feature_range: Tuple[float, float], default=(0, 1)
+            Desired range of transformed data (default is 0 to 1).
+
+        clip: bool, default=False
+            Whether to clip transformed values of held-out data to the specified feature range (default is True).
+
+        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. Each specified
             input column is scaled independently and stored in the corresponding output column.
-        output_cols: The name(s) of one or more columns in a DataFrame in which results will be stored. The number of
+
+        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.
-        drop_input_cols: Remove input columns from output if set True. False by default.
+
+        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: Optional[bool], default=False
+            Remove input columns from output if set True. False by default.
 
     Attributes:
-        min_: dict {column_name: value} or None. Per-feature adjustment for minimum.
-        scale_: dict {column_name: value} or None. Per-feature relative scaling factor.
-        data_min_: dict {column_name: value} or None. Per-feature minimum seen in the data.
-        data_max_: dict {column_name: value} or None. Per-feature maximum seen in the data.
-        data_range_: dict {column_name: value} or None. Per-feature range seen in the data as a (min, max) tuple.
+        min_: Dict[str, float]
+            dict {column_name: value} or None. Per-feature adjustment for minimum.
+
+        scale_: Dict[str, float]
+            dict {column_name: value} or None. Per-feature relative scaling factor.
+
+        data_min_: Dict[str, float]
+            dict {column_name: value} or None. Per-feature minimum seen in the data.
+
+        data_max_: Dict[str, float]
+            dict {column_name: value} or None. Per-feature maximum seen in the data.
+
+        data_range_: Dict[str, float]
+            dict {column_name: value} or None. Per-feature range seen in the data as a (min, max) tuple.
     """
 
     def __init__(
@@ -44,6 +69,7 @@ class MinMaxScaler(base.BaseTransformer):
         clip: bool = False,
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
+        passthrough_cols: Optional[Union[str, Iterable[str]]] = None,
         drop_input_cols: Optional[bool] = False,
     ) -> None:
         """
@@ -54,6 +80,11 @@ class MinMaxScaler(base.BaseTransformer):
             clip: Set to True to clip transformed values of held-out data to provided `feature range`.
             input_cols: Single or multiple input columns.
             output_cols: 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 helful in scenarios
+                requiring automatic input_cols inference, but need to avoid using specific
+                columns, like index columns, during in training or inference.
             drop_input_cols: Remove input columns from output if set True. False by default.
 
         Attributes:
@@ -78,6 +109,7 @@ class MinMaxScaler(base.BaseTransformer):
 
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
+        self.set_passthrough_cols(passthrough_cols)
 
     def _reset(self) -> None:
         """
@@ -158,10 +190,6 @@ class MinMaxScaler(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]:
         """
         Scale features according to feature_range.

snowflake/ml/modeling/preprocessing/normalizer.py

@@ -34,6 +34,13 @@ class Normalizer(base.BaseTransformer):
             A string or list of strings representing column names that will store the output of transform operation.
             The length of `output_cols` must equal the length of `input_cols`.
 
+        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: bool, default=False
             Remove input columns from output if set `True`.
     """
@@ -44,6 +51,7 @@ class Normalizer(base.BaseTransformer):
         norm: str = "l2",
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
+        passthrough_cols: Optional[Union[str, Iterable[str]]] = None,
         drop_input_cols: Optional[bool] = False,
     ) -> None:
         super().__init__(drop_input_cols=drop_input_cols)
@@ -51,6 +59,7 @@ class Normalizer(base.BaseTransformer):
         self._is_fitted = False
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
+        self.set_passthrough_cols(passthrough_cols)
 
     def _reset(self) -> None:
         """
@@ -82,10 +91,6 @@ class Normalizer(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]:
         """
         Scale each non-zero row of the input dataset to the unit norm.

snowflake/ml/modeling/preprocessing/one_hot_encoder.py

@@ -38,7 +38,7 @@ _N_FEATURES_OUT = "_N_FEATURES_OUT"
 # transformer with the sklearn version
 _SKLEARN_INITIAL_KEYWORDS = ("sparse", "handle_unknown")  # initial keywords in sklearn
 _SKLEARN_UNUSED_KEYWORDS = "dtype"  # sklearn keywords that are unused in snowml
-_SNOWML_ONLY_KEYWORDS = ["input_cols", "output_cols"]  # snowml only keywords not present in sklearn
+_SNOWML_ONLY_KEYWORDS = ["input_cols", "output_cols", "passthrough_cols"]  # snowml only keywords not present in sklearn
 
 # Added keywords mapped to the sklearn versions in which they were added. Update mappings in new
 # sklearn versions to support parameter validation.
@@ -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,17 +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.
-        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])}
@@ -190,6 +206,7 @@ class OneHotEncoder(base.BaseTransformer):
         max_categories: Optional[int] = None,
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
+        passthrough_cols: Optional[Union[str, Iterable[str]]] = None,
         drop_input_cols: Optional[bool] = False,
     ) -> None:
         """See class-level docstring."""
@@ -218,6 +235,7 @@ class OneHotEncoder(base.BaseTransformer):
 
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
+        self.set_passthrough_cols(passthrough_cols)
 
     @property
     def infrequent_categories_(self) -> List[Optional[type_utils.LiteralNDArrayType]]:
@@ -658,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]:
@@ -1319,7 +1333,9 @@ class OneHotEncoder(base.BaseTransformer):
         """
         category_counts_list = []  # list of ndarray
         for idx, input_col in enumerate(self.input_cols):
-            counts = np.vectorize(lambda x: category_counts[input_col][x])(self._categories_list[idx])
+            counts = np.vectorize(lambda x, input_col=input_col: category_counts[input_col][x])(
+                self._categories_list[idx]
+            )
             category_counts_list.append(np.array(counts))
         self._infrequent_indices = [
             self._identify_infrequent(category_count, n_samples) for category_count in category_counts_list

snowflake/ml/modeling/preprocessing/ordinal_encoder.py

@@ -24,7 +24,7 @@ _COLUMN_BATCH_SIZE = 20
 # transformer with the sklearn version
 _SKLEARN_INITIAL_KEYWORDS = "categories"  # initial keywords in sklearn
 _SKLEARN_UNUSED_KEYWORDS = "dtype"  # sklearn keywords that are unused in snowml
-_SNOWML_ONLY_KEYWORDS = ["input_cols", "output_cols"]  # snowml only keywords not present in sklearn
+_SNOWML_ONLY_KEYWORDS = ["input_cols", "output_cols", "passthrough_cols"]  # snowml only keywords not present in sklearn
 
 # Added keywords mapped to the sklearn versions in which they were added. Update mappings in new
 # sklearn versions to support parameter validation.
@@ -45,26 +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.
-        drop_input_cols: Remove input columns from output if set True. False by default.
+
+        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: 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.
     """
@@ -78,6 +99,7 @@ class OrdinalEncoder(base.BaseTransformer):
         encoded_missing_value: Union[int, float] = np.nan,
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
+        passthrough_cols: Optional[Union[str, Iterable[str]]] = None,
         drop_input_cols: Optional[bool] = False,
     ) -> None:
         """
@@ -110,6 +132,11 @@ class OrdinalEncoder(base.BaseTransformer):
             encoded_missing_value: Encoded value of missing categories.
             input_cols: Single or multiple input columns.
             output_cols: 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 helful in scenarios
+                requiring automatic input_cols inference, but need to avoid using specific
+                columns, like index columns, during in training or inference.
             drop_input_cols: Remove input columns from output if set True. False by default.
 
         Attributes:
@@ -129,6 +156,7 @@ class OrdinalEncoder(base.BaseTransformer):
 
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
+        self.set_passthrough_cols(passthrough_cols)
 
     def _reset(self) -> None:
         """
@@ -417,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.