snowflake-ml-python 1.3.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

snowflake/ml/modeling/impute/missing_indicator.py

@@ -285,18 +285,24 @@ class MissingIndicator(BaseTransformer):
         self._get_model_signatures(dataset)
         return self
 
-    def _get_pass_through_columns(self, dataset: DataFrame) -> List[str]:
-        if self._drop_input_cols:
-            return []
-        else:
-            return list(set(dataset.columns) - set(self.output_cols))
-
     def _batch_inference_validate_snowpark(
         self,
         dataset: DataFrame,
         inference_method: str,
     ) -> List[str]:
-        """Util method to run validate that batch inference can be run on a snowpark dataframe.
+        """Util method to run validate that batch inference can be run on a snowpark dataframe and
+        return the available package that exists in the snowflake anaconda channel
+
+        Args:
+            dataset: snowpark dataframe
+            inference_method: the inference method such as predict, score...
+
+        Raises:
+            SnowflakeMLException: If the estimator is not fitted, raise error
+            SnowflakeMLException: If the session is None, raise error
+
+        Returns:
+            A list of available package that exists in the snowflake anaconda channel
         """
         if not self._is_fitted:
             raise exceptions.SnowflakeMLException(
@@ -368,7 +374,7 @@ class MissingIndicator(BaseTransformer):
             transform_kwargs = dict(
                 session = dataset._session,
                 dependencies = self._deps,
-                pass_through_cols = self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type = expected_type_inferred,
             )
 
@@ -430,16 +436,16 @@ class MissingIndicator(BaseTransformer):
                 # from (n_samples, n_estimators) to (n_samples, n_estimators * n_classes) (and everything in between)
                 # based on init param values. We will convert that to pandas dataframe of shape (n_samples, 1) with
                 # each row containing a list of values.
-                expected_dtype = "ARRAY"
+                expected_dtype = "array"
 
             # If we were unable to assign a type to this transform in the factory, infer the type here.
             if expected_dtype == "":
-                # If this is a clustering transformer, if the number of output columns does not equal the number of clusters the response will be an "ARRAY"
+                # If this is a clustering transformer, if the number of output columns does not equal the number of clusters the response will be an "array"
                 if hasattr(self._sklearn_object, "n_clusters") and getattr(self._sklearn_object, "n_clusters") != len(self.output_cols):
-                    expected_dtype = "ARRAY"
-                # If this is a decomposition transformer, if the number of output columns does not equal the number of components the response will be an "ARRAY"
+                    expected_dtype = "array"
+                # If this is a decomposition transformer, if the number of output columns does not equal the number of components the response will be an "array"
                 elif hasattr(self._sklearn_object, "n_components") and getattr(self._sklearn_object, "n_components") != len(self.output_cols):
-                    expected_dtype = "ARRAY"
+                    expected_dtype = "array"
                 else:
                     output_types = [signature.as_snowpark_type() for signature in _infer_signature(dataset[self.input_cols], "output", use_snowflake_identifiers=True)]
                     # We can only infer the output types from the input types if the following two statemetns are true:
@@ -457,7 +463,7 @@ class MissingIndicator(BaseTransformer):
             transform_kwargs = dict(
                 session = dataset._session,
                 dependencies = self._deps,
-                pass_through_cols = self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type = expected_dtype,
             )
 
@@ -508,7 +514,7 @@ class MissingIndicator(BaseTransformer):
             subproject=_SUBPROJECT,
         )
         output_result, fitted_estimator = model_trainer.train_fit_predict(
-            pass_through_columns=self._get_pass_through_columns(dataset),
+            drop_input_cols=self._drop_input_cols,
             expected_output_cols_list=self.output_cols if self.output_cols else self._get_output_column_names(output_cols_prefix),
         )
         self._sklearn_object = fitted_estimator
@@ -526,44 +532,6 @@ class MissingIndicator(BaseTransformer):
         assert self._sklearn_object is not None
         return self._sklearn_object.embedding_
 
-
-    def _get_output_column_names(self, output_cols_prefix: str, output_cols: Optional[List[str]] = None) -> List[str]:
-        """ Returns the list of output columns for predict_proba(), decision_function(), etc.. functions.
-        Returns a list with output_cols_prefix as the only element if the estimator is not a classifier.
-        """
-        output_cols_prefix = identifier.resolve_identifier(output_cols_prefix)
-        if output_cols:
-            output_cols = [
-                identifier.concat_names([output_cols_prefix, identifier.resolve_identifier(c)])
-                for c in output_cols
-            ]
-        elif getattr(self._sklearn_object, "classes_", None) is None:
-            output_cols = [output_cols_prefix]
-        elif self._sklearn_object is not None:
-            classes = self._sklearn_object.classes_
-            if isinstance(classes, numpy.ndarray):
-                output_cols = [f'{output_cols_prefix}{str(c)}' for c in classes.tolist()]
-            elif isinstance(classes, list) and len(classes) > 0 and isinstance(classes[0], numpy.ndarray):
-                # If the estimator is a multioutput estimator, classes_ will be a list of ndarrays.
-                output_cols = []
-                for i, cl in enumerate(classes):
-                    # For binary classification, there is only one output column for each class
-                    # ndarray as the two classes are complementary.
-                    if len(cl) == 2:
-                        output_cols.append(f'{output_cols_prefix}{i}_{cl[0]}')
-                    else:
-                        output_cols.extend([
-                            f'{output_cols_prefix}{i}_{c}' for c in cl.tolist()
-                        ])
-        else:
-            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
-
     @available_if(original_estimator_has_callable("predict_proba"))  # type: ignore[misc]
     @telemetry.send_api_usage_telemetry(
         project=_PROJECT,
@@ -603,7 +571,7 @@ class MissingIndicator(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
 
@@ -668,7 +636,7 @@ class MissingIndicator(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
         elif isinstance(dataset, pd.DataFrame):
@@ -729,7 +697,7 @@ class MissingIndicator(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
 
@@ -794,7 +762,7 @@ class MissingIndicator(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
 
@@ -848,13 +816,17 @@ class MissingIndicator(BaseTransformer):
         transform_kwargs: ScoreKwargsTypedDict = dict()  
 
         if isinstance(dataset, DataFrame):
+            self._deps = self._batch_inference_validate_snowpark(
+                dataset=dataset,
+                inference_method="score",
+            )
             selected_cols = self._get_active_columns()
             if len(selected_cols) > 0:
                 dataset = dataset.select(selected_cols)
             assert isinstance(dataset._session, Session) # keep mypy happy
             transform_kwargs = dict(
                 session=dataset._session,
-                dependencies=["snowflake-snowpark-python"] + self._get_dependencies(),
+                dependencies=["snowflake-snowpark-python"] + self._deps,
                 score_sproc_imports=['sklearn'],
             )
         elif isinstance(dataset, pd.DataFrame):
@@ -928,9 +900,9 @@ class MissingIndicator(BaseTransformer):
             transform_kwargs = dict(
                 session = dataset._session,
                 dependencies = self._deps,
-                pass_through_cols = self._get_pass_through_columns(dataset),
-                expected_output_cols_type =  "array",
-                n_neighbors =  n_neighbors,
+                drop_input_cols = self._drop_input_cols,
+                expected_output_cols_type="array",
+                n_neighbors = n_neighbors,
                 return_distance =  return_distance
             )
         elif isinstance(dataset, pd.DataFrame):

snowflake/ml/modeling/impute/simple_imputer.py

@@ -74,8 +74,6 @@ _NUMERIC_TYPES = [
 ]
 
 
-# TODO(thoyt): Implement logic for `add_indicator` parameter and `indicator_` attribute.Requires
-#  `snowflake.ml.impute.MissingIndicator` to be implemented.
 class SimpleImputer(base.BaseTransformer):
     """
     Univariate imputer for completing missing values with simple strategies.
@@ -96,7 +94,8 @@ class SimpleImputer(base.BaseTransformer):
             * If "most_frequent", replace missing using the most frequent value along each column.
               Can be used with strings or numeric data.
               If there is more than one such value, only the smallest is returned.
-            * If "constant", replace the missing values with `fill_value`. Can be used with strings or numeric data.
+            * If "constant", replace the missing values with `fill_value`, including columns that are entirely
+              null. Can be used with strings or numeric data.
 
         fill_value: Optional[str]
             When `strategy == "constant"`, `fill_value` is used to replace all occurrences of `missing_values`.
@@ -262,18 +261,8 @@ class SimpleImputer(base.BaseTransformer):
                         break
 
             for input_col in self.input_cols:
-                # Check whether input column is empty if necessary.
-                if (
-                    # TODO(hayu): [SNOW-752265] Support SimpleImputer keep_empty_features.
-                    #  Add back when `keep_empty_features` is supported.
-                    # not self.keep_empty_features
-                    # and dataset.filter(F.col(input_col).is_not_null()).count(statement_params=statement_params) == 0
-                    dataset.filter(F.col(input_col).is_not_null()).count(statement_params=statement_params)
-                    == 0
-                ):
-                    self.statistics_[input_col] = np.nan
-                else:
-                    self.statistics_[input_col] = self.fill_value
+                self.statistics_[input_col] = self.fill_value
+
         else:
             state = STRATEGY_TO_STATE_DICT[self.strategy]
             assert state is not None

snowflake/ml/modeling/kernel_approximation/additive_chi2_sampler.py

@@ -260,18 +260,24 @@ class AdditiveChi2Sampler(BaseTransformer):
         self._get_model_signatures(dataset)
         return self
 
-    def _get_pass_through_columns(self, dataset: DataFrame) -> List[str]:
-        if self._drop_input_cols:
-            return []
-        else:
-            return list(set(dataset.columns) - set(self.output_cols))
-
     def _batch_inference_validate_snowpark(
         self,
         dataset: DataFrame,
         inference_method: str,
     ) -> List[str]:
-        """Util method to run validate that batch inference can be run on a snowpark dataframe.
+        """Util method to run validate that batch inference can be run on a snowpark dataframe and
+        return the available package that exists in the snowflake anaconda channel
+
+        Args:
+            dataset: snowpark dataframe
+            inference_method: the inference method such as predict, score...
+
+        Raises:
+            SnowflakeMLException: If the estimator is not fitted, raise error
+            SnowflakeMLException: If the session is None, raise error
+
+        Returns:
+            A list of available package that exists in the snowflake anaconda channel
         """
         if not self._is_fitted:
             raise exceptions.SnowflakeMLException(
@@ -343,7 +349,7 @@ class AdditiveChi2Sampler(BaseTransformer):
             transform_kwargs = dict(
                 session = dataset._session,
                 dependencies = self._deps,
-                pass_through_cols = self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type = expected_type_inferred,
             )
 
@@ -405,16 +411,16 @@ class AdditiveChi2Sampler(BaseTransformer):
                 # from (n_samples, n_estimators) to (n_samples, n_estimators * n_classes) (and everything in between)
                 # based on init param values. We will convert that to pandas dataframe of shape (n_samples, 1) with
                 # each row containing a list of values.
-                expected_dtype = "ARRAY"
+                expected_dtype = "array"
 
             # If we were unable to assign a type to this transform in the factory, infer the type here.
             if expected_dtype == "":
-                # If this is a clustering transformer, if the number of output columns does not equal the number of clusters the response will be an "ARRAY"
+                # If this is a clustering transformer, if the number of output columns does not equal the number of clusters the response will be an "array"
                 if hasattr(self._sklearn_object, "n_clusters") and getattr(self._sklearn_object, "n_clusters") != len(self.output_cols):
-                    expected_dtype = "ARRAY"
-                # If this is a decomposition transformer, if the number of output columns does not equal the number of components the response will be an "ARRAY"
+                    expected_dtype = "array"
+                # If this is a decomposition transformer, if the number of output columns does not equal the number of components the response will be an "array"
                 elif hasattr(self._sklearn_object, "n_components") and getattr(self._sklearn_object, "n_components") != len(self.output_cols):
-                    expected_dtype = "ARRAY"
+                    expected_dtype = "array"
                 else:
                     output_types = [signature.as_snowpark_type() for signature in _infer_signature(dataset[self.input_cols], "output", use_snowflake_identifiers=True)]
                     # We can only infer the output types from the input types if the following two statemetns are true:
@@ -432,7 +438,7 @@ class AdditiveChi2Sampler(BaseTransformer):
             transform_kwargs = dict(
                 session = dataset._session,
                 dependencies = self._deps,
-                pass_through_cols = self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type = expected_dtype,
             )
 
@@ -483,7 +489,7 @@ class AdditiveChi2Sampler(BaseTransformer):
             subproject=_SUBPROJECT,
         )
         output_result, fitted_estimator = model_trainer.train_fit_predict(
-            pass_through_columns=self._get_pass_through_columns(dataset),
+            drop_input_cols=self._drop_input_cols,
             expected_output_cols_list=self.output_cols if self.output_cols else self._get_output_column_names(output_cols_prefix),
         )
         self._sklearn_object = fitted_estimator
@@ -501,44 +507,6 @@ class AdditiveChi2Sampler(BaseTransformer):
         assert self._sklearn_object is not None
         return self._sklearn_object.embedding_
 
-
-    def _get_output_column_names(self, output_cols_prefix: str, output_cols: Optional[List[str]] = None) -> List[str]:
-        """ Returns the list of output columns for predict_proba(), decision_function(), etc.. functions.
-        Returns a list with output_cols_prefix as the only element if the estimator is not a classifier.
-        """
-        output_cols_prefix = identifier.resolve_identifier(output_cols_prefix)
-        if output_cols:
-            output_cols = [
-                identifier.concat_names([output_cols_prefix, identifier.resolve_identifier(c)])
-                for c in output_cols
-            ]
-        elif getattr(self._sklearn_object, "classes_", None) is None:
-            output_cols = [output_cols_prefix]
-        elif self._sklearn_object is not None:
-            classes = self._sklearn_object.classes_
-            if isinstance(classes, numpy.ndarray):
-                output_cols = [f'{output_cols_prefix}{str(c)}' for c in classes.tolist()]
-            elif isinstance(classes, list) and len(classes) > 0 and isinstance(classes[0], numpy.ndarray):
-                # If the estimator is a multioutput estimator, classes_ will be a list of ndarrays.
-                output_cols = []
-                for i, cl in enumerate(classes):
-                    # For binary classification, there is only one output column for each class
-                    # ndarray as the two classes are complementary.
-                    if len(cl) == 2:
-                        output_cols.append(f'{output_cols_prefix}{i}_{cl[0]}')
-                    else:
-                        output_cols.extend([
-                            f'{output_cols_prefix}{i}_{c}' for c in cl.tolist()
-                        ])
-        else:
-            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
-
     @available_if(original_estimator_has_callable("predict_proba"))  # type: ignore[misc]
     @telemetry.send_api_usage_telemetry(
         project=_PROJECT,
@@ -578,7 +546,7 @@ class AdditiveChi2Sampler(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
 
@@ -643,7 +611,7 @@ class AdditiveChi2Sampler(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
         elif isinstance(dataset, pd.DataFrame):
@@ -704,7 +672,7 @@ class AdditiveChi2Sampler(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
 
@@ -769,7 +737,7 @@ class AdditiveChi2Sampler(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
 
@@ -823,13 +791,17 @@ class AdditiveChi2Sampler(BaseTransformer):
         transform_kwargs: ScoreKwargsTypedDict = dict()  
 
         if isinstance(dataset, DataFrame):
+            self._deps = self._batch_inference_validate_snowpark(
+                dataset=dataset,
+                inference_method="score",
+            )
             selected_cols = self._get_active_columns()
             if len(selected_cols) > 0:
                 dataset = dataset.select(selected_cols)
             assert isinstance(dataset._session, Session) # keep mypy happy
             transform_kwargs = dict(
                 session=dataset._session,
-                dependencies=["snowflake-snowpark-python"] + self._get_dependencies(),
+                dependencies=["snowflake-snowpark-python"] + self._deps,
                 score_sproc_imports=['sklearn'],
             )
         elif isinstance(dataset, pd.DataFrame):
@@ -903,9 +875,9 @@ class AdditiveChi2Sampler(BaseTransformer):
             transform_kwargs = dict(
                 session = dataset._session,
                 dependencies = self._deps,
-                pass_through_cols = self._get_pass_through_columns(dataset),
-                expected_output_cols_type =  "array",
-                n_neighbors =  n_neighbors,
+                drop_input_cols = self._drop_input_cols,
+                expected_output_cols_type="array",
+                n_neighbors = n_neighbors,
                 return_distance =  return_distance
             )
         elif isinstance(dataset, pd.DataFrame):

snowflake/ml/modeling/kernel_approximation/nystroem.py

@@ -308,18 +308,24 @@ class Nystroem(BaseTransformer):
         self._get_model_signatures(dataset)
         return self
 
-    def _get_pass_through_columns(self, dataset: DataFrame) -> List[str]:
-        if self._drop_input_cols:
-            return []
-        else:
-            return list(set(dataset.columns) - set(self.output_cols))
-
     def _batch_inference_validate_snowpark(
         self,
         dataset: DataFrame,
         inference_method: str,
     ) -> List[str]:
-        """Util method to run validate that batch inference can be run on a snowpark dataframe.
+        """Util method to run validate that batch inference can be run on a snowpark dataframe and
+        return the available package that exists in the snowflake anaconda channel
+
+        Args:
+            dataset: snowpark dataframe
+            inference_method: the inference method such as predict, score...
+
+        Raises:
+            SnowflakeMLException: If the estimator is not fitted, raise error
+            SnowflakeMLException: If the session is None, raise error
+
+        Returns:
+            A list of available package that exists in the snowflake anaconda channel
         """
         if not self._is_fitted:
             raise exceptions.SnowflakeMLException(
@@ -391,7 +397,7 @@ class Nystroem(BaseTransformer):
             transform_kwargs = dict(
                 session = dataset._session,
                 dependencies = self._deps,
-                pass_through_cols = self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type = expected_type_inferred,
             )
 
@@ -453,16 +459,16 @@ class Nystroem(BaseTransformer):
                 # from (n_samples, n_estimators) to (n_samples, n_estimators * n_classes) (and everything in between)
                 # based on init param values. We will convert that to pandas dataframe of shape (n_samples, 1) with
                 # each row containing a list of values.
-                expected_dtype = "ARRAY"
+                expected_dtype = "array"
 
             # If we were unable to assign a type to this transform in the factory, infer the type here.
             if expected_dtype == "":
-                # If this is a clustering transformer, if the number of output columns does not equal the number of clusters the response will be an "ARRAY"
+                # If this is a clustering transformer, if the number of output columns does not equal the number of clusters the response will be an "array"
                 if hasattr(self._sklearn_object, "n_clusters") and getattr(self._sklearn_object, "n_clusters") != len(self.output_cols):
-                    expected_dtype = "ARRAY"
-                # If this is a decomposition transformer, if the number of output columns does not equal the number of components the response will be an "ARRAY"
+                    expected_dtype = "array"
+                # If this is a decomposition transformer, if the number of output columns does not equal the number of components the response will be an "array"
                 elif hasattr(self._sklearn_object, "n_components") and getattr(self._sklearn_object, "n_components") != len(self.output_cols):
-                    expected_dtype = "ARRAY"
+                    expected_dtype = "array"
                 else:
                     output_types = [signature.as_snowpark_type() for signature in _infer_signature(dataset[self.input_cols], "output", use_snowflake_identifiers=True)]
                     # We can only infer the output types from the input types if the following two statemetns are true:
@@ -480,7 +486,7 @@ class Nystroem(BaseTransformer):
             transform_kwargs = dict(
                 session = dataset._session,
                 dependencies = self._deps,
-                pass_through_cols = self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type = expected_dtype,
             )
 
@@ -531,7 +537,7 @@ class Nystroem(BaseTransformer):
             subproject=_SUBPROJECT,
         )
         output_result, fitted_estimator = model_trainer.train_fit_predict(
-            pass_through_columns=self._get_pass_through_columns(dataset),
+            drop_input_cols=self._drop_input_cols,
             expected_output_cols_list=self.output_cols if self.output_cols else self._get_output_column_names(output_cols_prefix),
         )
         self._sklearn_object = fitted_estimator
@@ -549,44 +555,6 @@ class Nystroem(BaseTransformer):
         assert self._sklearn_object is not None
         return self._sklearn_object.embedding_
 
-
-    def _get_output_column_names(self, output_cols_prefix: str, output_cols: Optional[List[str]] = None) -> List[str]:
-        """ Returns the list of output columns for predict_proba(), decision_function(), etc.. functions.
-        Returns a list with output_cols_prefix as the only element if the estimator is not a classifier.
-        """
-        output_cols_prefix = identifier.resolve_identifier(output_cols_prefix)
-        if output_cols:
-            output_cols = [
-                identifier.concat_names([output_cols_prefix, identifier.resolve_identifier(c)])
-                for c in output_cols
-            ]
-        elif getattr(self._sklearn_object, "classes_", None) is None:
-            output_cols = [output_cols_prefix]
-        elif self._sklearn_object is not None:
-            classes = self._sklearn_object.classes_
-            if isinstance(classes, numpy.ndarray):
-                output_cols = [f'{output_cols_prefix}{str(c)}' for c in classes.tolist()]
-            elif isinstance(classes, list) and len(classes) > 0 and isinstance(classes[0], numpy.ndarray):
-                # If the estimator is a multioutput estimator, classes_ will be a list of ndarrays.
-                output_cols = []
-                for i, cl in enumerate(classes):
-                    # For binary classification, there is only one output column for each class
-                    # ndarray as the two classes are complementary.
-                    if len(cl) == 2:
-                        output_cols.append(f'{output_cols_prefix}{i}_{cl[0]}')
-                    else:
-                        output_cols.extend([
-                            f'{output_cols_prefix}{i}_{c}' for c in cl.tolist()
-                        ])
-        else:
-            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
-
     @available_if(original_estimator_has_callable("predict_proba"))  # type: ignore[misc]
     @telemetry.send_api_usage_telemetry(
         project=_PROJECT,
@@ -626,7 +594,7 @@ class Nystroem(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
 
@@ -691,7 +659,7 @@ class Nystroem(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
         elif isinstance(dataset, pd.DataFrame):
@@ -752,7 +720,7 @@ class Nystroem(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
 
@@ -817,7 +785,7 @@ class Nystroem(BaseTransformer):
             transform_kwargs = dict(
                 session=dataset._session,
                 dependencies=self._deps,
-                pass_through_cols=self._get_pass_through_columns(dataset),
+                drop_input_cols = self._drop_input_cols,
                 expected_output_cols_type="float",
             )
 
@@ -871,13 +839,17 @@ class Nystroem(BaseTransformer):
         transform_kwargs: ScoreKwargsTypedDict = dict()  
 
         if isinstance(dataset, DataFrame):
+            self._deps = self._batch_inference_validate_snowpark(
+                dataset=dataset,
+                inference_method="score",
+            )
             selected_cols = self._get_active_columns()
             if len(selected_cols) > 0:
                 dataset = dataset.select(selected_cols)
             assert isinstance(dataset._session, Session) # keep mypy happy
             transform_kwargs = dict(
                 session=dataset._session,
-                dependencies=["snowflake-snowpark-python"] + self._get_dependencies(),
+                dependencies=["snowflake-snowpark-python"] + self._deps,
                 score_sproc_imports=['sklearn'],
             )
         elif isinstance(dataset, pd.DataFrame):
@@ -951,9 +923,9 @@ class Nystroem(BaseTransformer):
             transform_kwargs = dict(
                 session = dataset._session,
                 dependencies = self._deps,
-                pass_through_cols = self._get_pass_through_columns(dataset),
-                expected_output_cols_type =  "array",
-                n_neighbors =  n_neighbors,
+                drop_input_cols = self._drop_input_cols,
+                expected_output_cols_type="array",
+                n_neighbors = n_neighbors,
                 return_distance =  return_distance
             )
         elif isinstance(dataset, pd.DataFrame):