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

snowflake/ml/modeling/neural_network/mlp_regressor.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.neural_network".replace("sklearn.", "").split("_")])
 
 
-
 class MLPRegressor(BaseTransformer):
     r"""Multi-layer Perceptron regressor
     For more details on this class, see [sklearn.neural_network.MLPRegressor]
@@ -60,6 +61,51 @@ class MLPRegressor(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]]]
+        A string or list of strings representing column names that contain labels.
+        Label columns must be specified with this parameter during initialization
+        or with the `set_label_cols` method before fitting.
+
+    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.
+
     hidden_layer_sizes: array-like of shape(n_layers - 2,), default=(100,)
         The ith element represents the number of neurons in the ith
         hidden layer.
@@ -205,35 +251,6 @@ class MLPRegressor(BaseTransformer):
         of iterations reaches max_iter, or this number of function calls.
         Note that number of function calls will be greater than or equal to
         the number of iterations for the MLPRegressor.
-
-    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 and sample_weight_col 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.
-
-    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]
@@ -265,6 +282,7 @@ class MLPRegressor(BaseTransformer):
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
         label_cols: Optional[Union[str, Iterable[str]]] = None,
+        passthrough_cols: Optional[Union[str, Iterable[str]]] = None,
         drop_input_cols: Optional[bool] = False,
         sample_weight_col: Optional[str] = None,
     ) -> None:
@@ -273,9 +291,10 @@ class MLPRegressor(BaseTransformer):
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
         self.set_label_cols(label_cols)
+        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)
         
@@ -306,13 +325,14 @@ class MLPRegressor(BaseTransformer):
             args=init_args,
             klass=sklearn.neural_network.MLPRegressor
         )
-        self._sklearn_object = sklearn.neural_network.MLPRegressor(
+        self._sklearn_object: Any = sklearn.neural_network.MLPRegressor(
             **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=MLPRegressor.__class__.__name__, subproject=_SUBPROJECT, autogenerated=True, wrapper_provider=SklearnWrapperProvider())
+        self._handlers: FitPredictHandlers = HandlersImpl(class_name=MLPRegressor.__class__.__name__, subproject=_SUBPROJECT, autogenerated=True)
+        self._autogenerated = True
 
     def _get_rand_id(self) -> str:
         """
@@ -323,24 +343,6 @@ class MLPRegressor(BaseTransformer):
         """
         return str(uuid4()).replace("-", "_").upper()
 
-    def _infer_input_output_cols(self, dataset: Union[DataFrame, pd.DataFrame]) -> None:
-        """
-        Infer `self.input_cols` and `self.output_cols` if they are not explicitly set.
-
-        Args:
-            dataset: Input dataset.
-        """
-        if not self.input_cols:
-            cols = [
-                c for c in dataset.columns 
-                if c not in self.get_label_cols() and c != self.sample_weight_col
-            ]
-            self.set_input_cols(input_cols=cols)
-
-        if not self.output_cols:
-            cols = [identifier.concat_names(ids=['OUTPUT_', c]) for c in self.label_cols]
-            self.set_output_cols(output_cols=cols)
-
     def set_input_cols(self, input_cols: Optional[Union[str, Iterable[str]]]) -> "MLPRegressor":
         """
         Input columns setter.
@@ -386,54 +388,48 @@ class MLPRegressor(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(), MLPRegressor.__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 []
@@ -621,11 +617,6 @@ class MLPRegressor(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]:
         """Predict using the multi-layer perceptron model
         For more details on this function, see [sklearn.neural_network.MLPRegressor.predict]
@@ -679,11 +670,6 @@ class MLPRegressor(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]:
         """Method not supported for this class.
 
@@ -740,7 +726,8 @@ class MLPRegressor(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
 
@@ -776,6 +763,7 @@ class MLPRegressor(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
@@ -786,11 +774,6 @@ class MLPRegressor(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]:
@@ -831,11 +814,6 @@ class MLPRegressor(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]:
@@ -872,16 +850,6 @@ class MLPRegressor(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]:
@@ -982,11 +950,6 @@ class MLPRegressor(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],
@@ -1046,18 +1009,28 @@ class MLPRegressor(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)
+            # For mixture models that use the density mixin, `predict` returns the argmax of the log prob.
+            # For outlier models, returns -1 for outliers and 1 for inliers.
+            # Clusterer returns int64 cluster labels. 
+            elif self._sklearn_object._estimator_type in ["DensityEstimator", "clusterer", "outlier_detector"]:
+                outputs = [FeatureSpec(dtype=DataType.INT64, name=c) for c in self.output_cols]
+                self._model_signature_dict["predict"] = ModelSignature(inputs,
+                                                                       ([] if self._drop_input_cols else inputs)
+                                                                       + outputs)
+            
             # For regressor, the type of predict is float64
             elif self._sklearn_object._estimator_type == 'regressor':
                 outputs = [FeatureSpec(dtype=DataType.DOUBLE, name=c) for c in self.output_cols]
                 self._model_signature_dict["predict"] = ModelSignature(inputs,
                                                                        ([] if self._drop_input_cols else inputs)
                                                                        + outputs)
+                
         for prob_func in PROB_FUNCTIONS:
             if hasattr(self, prob_func):
                 output_cols_prefix: str = f"{prob_func}_"

snowflake/ml/modeling/parameters/disable_distributed_hpo.py

@@ -1,8 +1,4 @@
 """Disables the distributed implementation of Grid Search and Randomized Search CV"""
-from snowflake.ml.modeling.model_selection.grid_search_cv import GridSearchCV
-from snowflake.ml.modeling.model_selection.randomized_search_cv import (
-    RandomizedSearchCV,
-)
+from snowflake.ml.modeling._internal.model_trainer_builder import ModelTrainerBuilder
 
-GridSearchCV._ENABLE_DISTRIBUTED = False
-RandomizedSearchCV._ENABLE_DISTRIBUTED = False
+ModelTrainerBuilder._ENABLE_DISTRIBUTED = False

snowflake/ml/modeling/preprocessing/binarizer.py

@@ -21,11 +21,25 @@ class Binarizer(base.BaseTransformer):
     (https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.Binarizer.html).
 
     Args:
-        threshold: Feature values below or equal to this are replaced by 0, above it by 1. Default values is 0.0.
-        input_cols: The name(s) of one or more columns in a DataFrame containing a feature to be binarized.
-        output_cols: The name(s) of one or more columns in a DataFrame in which results will be stored. The number of
+        threshold: float, default=0.0
+            Feature values below or equal to this are replaced by 0, above it by 1. Default values is 0.0.
+
+        input_cols: Optional[Union[str, Iterable[str]]], default=None
+            The name(s) of one or more columns in a DataFrame containing a feature to be binarized.
+
+        output_cols: Optional[Union[str, Iterable[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, Iterable[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.
     """
 
     def __init__(
@@ -34,6 +48,7 @@ class Binarizer(base.BaseTransformer):
         threshold: float = 0.0,
         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:
         """
@@ -49,12 +64,18 @@ class Binarizer(base.BaseTransformer):
             input_cols: The name(s) of one or more columns in a DataFrame containing a feature to be binarized.
             output_cols: 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
+                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.
         """
         super().__init__(drop_input_cols=drop_input_cols)
         self.threshold = threshold
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
+        self.set_passthrough_cols(passthrough_cols)
 
     def _reset(self) -> None:
         """
@@ -96,10 +117,6 @@ class Binarizer(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]:
         """
         Binarize the data. Map to 1 if it is strictly greater than the threshold, otherwise 0.

snowflake/ml/modeling/preprocessing/k_bins_discretizer.py

@@ -38,6 +38,7 @@ _SKLEARN_UNUSED_KEYWORDS = [
 _SNOWML_ONLY_KEYWORDS = [
     "input_cols",
     "output_cols",
+    "passthrough_cols",
 ]  # snowml only keywords not present in sklearn
 
 _VALID_ENCODING_SCHEME = ["onehot", "onehot-dense", "ordinal"]
@@ -78,6 +79,12 @@ class KBinsDiscretizer(base.BaseTransformer):
         output_cols: str or Iterable [column_name], 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: boolean, default=False
             Remove input columns from output if set True.
 
@@ -97,6 +104,7 @@ class KBinsDiscretizer(base.BaseTransformer):
         strategy: str = "quantile",
         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)
@@ -105,6 +113,7 @@ class KBinsDiscretizer(base.BaseTransformer):
         self.strategy = strategy
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
+        self.set_passthrough_cols(passthrough_cols)
 
     def _enforce_params(self) -> None:
         self.n_bins = self.n_bins if isinstance(self.n_bins, Iterable) else [self.n_bins] * len(self.input_cols)
@@ -168,10 +177,6 @@ class KBinsDiscretizer(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/label_encoder.py

@@ -24,30 +24,53 @@ class LabelEncoder(base.BaseTransformer):
     (https://scikit-learn.org/stable/modules/generated/sklearn.preprocessing.LabelEncoder.html).
 
     Args:
-        input_cols: The name of a column in a DataFrame to be encoded. May be a string or a list containing one string.
-        output_cols: The name of a column in a DataFrame where the results will be stored. May be a string or a list
+        input_cols: Optional[Union[str, List[str]]]
+            The name of a column in a DataFrame to be encoded. May be a string or a list containing one string.
+
+        output_cols: Optional[Union[str, List[str]]]
+            The name of a column in a DataFrame where the results will be stored. May be a string or a list
             containing one string.
-        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[bool], default=False
+            Remove input columns from output if set True. False by default.
     """
 
     def __init__(
         self,
         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:
         """
         Encode target labels with integers between 0 and n_classes-1.
 
         Args:
-            input_cols: The name of a column in a DataFrame to be encoded. May be a string or a list containing one
+            input_cols: Optional[Union[str, List[str]]]
+                The name of a column in a DataFrame to be encoded. May be a string or a list containing one
                 string.
-            output_cols: The name of a column in a DataFrame where the results will be stored. May be a string or a list
+            output_cols: Optional[Union[str, List[str]]]
+                The name of a column in a DataFrame where the results will be stored. May be a string or a list
                 containing one string.
-            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 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: Optional[bool], default=False
+                Remove input columns from output if set True. False by default.
 
         Attributes:
-            classes_: A np.ndarray that holds the label for each class.
+            classes_: Optional[type_utils.LiteralNDArrayType]
+                A np.ndarray that holds the label for each class.
                 Attributes are valid only after fit() has been called.
 
         """
@@ -56,6 +79,7 @@ class LabelEncoder(base.BaseTransformer):
         self.classes_: Optional[type_utils.LiteralNDArrayType] = None
         self.set_input_cols(input_cols)
         self.set_output_cols(output_cols)
+        self.set_passthrough_cols(passthrough_cols)
 
     def _reset(self) -> None:
         super()._reset()
@@ -114,10 +138,6 @@ class LabelEncoder(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]:
         """
         Use fit result to transform snowpark dataframe or pandas dataframe. The original dataset with