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

snowflake/ml/model/_signatures/core.py

@@ -14,10 +14,12 @@ from typing import (
     Type,
     Union,
     final,
+    get_args,
 )
 
 import numpy as np
 import numpy.typing as npt
+import pandas as pd
 
 import snowflake.snowpark.types as spt
 from snowflake.ml._internal.exceptions import (
@@ -29,6 +31,21 @@ if TYPE_CHECKING:
     import mlflow
     import torch
 
+PandasExtensionTypes = Union[
+    pd.Int8Dtype,
+    pd.Int16Dtype,
+    pd.Int32Dtype,
+    pd.Int64Dtype,
+    pd.UInt8Dtype,
+    pd.UInt16Dtype,
+    pd.UInt32Dtype,
+    pd.UInt64Dtype,
+    pd.Float32Dtype,
+    pd.Float64Dtype,
+    pd.BooleanDtype,
+    pd.StringDtype,
+]
+
 
 class DataType(Enum):
     def __init__(self, value: str, snowpark_type: Type[spt.DataType], numpy_type: npt.DTypeLike) -> None:
@@ -67,11 +84,11 @@ class DataType(Enum):
         return f"DataType.{self.name}"
 
     @classmethod
-    def from_numpy_type(cls, np_type: npt.DTypeLike) -> "DataType":
+    def from_numpy_type(cls, input_type: Union[npt.DTypeLike, PandasExtensionTypes]) -> "DataType":
         """Translate numpy dtype to DataType for signature definition.
 
         Args:
-            np_type: The numpy dtype.
+            input_type: The numpy dtype or Pandas Extension Dtype
 
         Raises:
             SnowflakeMLException: NotImplementedError: Raised when the given numpy type is not supported.
@@ -79,6 +96,10 @@ class DataType(Enum):
         Returns:
             Corresponding DataType.
         """
+        # To support pandas extension dtype
+        if isinstance(input_type, get_args(PandasExtensionTypes)):
+            input_type = input_type.type
+
         np_to_snowml_type_mapping = {i._numpy_type: i for i in DataType}
 
         # Add datetime types:
@@ -88,12 +109,12 @@ class DataType(Enum):
             np_to_snowml_type_mapping[f"datetime64[{res}]"] = DataType.TIMESTAMP_NTZ
 
         for potential_type in np_to_snowml_type_mapping.keys():
-            if np.can_cast(np_type, potential_type, casting="no"):
+            if np.can_cast(input_type, potential_type, casting="no"):
                 # This is used since the same dtype might represented in different ways.
                 return np_to_snowml_type_mapping[potential_type]
         raise snowml_exceptions.SnowflakeMLException(
             error_code=error_codes.NOT_IMPLEMENTED,
-            original_exception=NotImplementedError(f"Type {np_type} is not supported as a DataType."),
+            original_exception=NotImplementedError(f"Type {input_type} is not supported as a DataType."),
         )
 
     @classmethod
@@ -212,6 +233,7 @@ class FeatureSpec(BaseFeatureSpec):
         name: str,
         dtype: DataType,
         shape: Optional[Tuple[int, ...]] = None,
+        nullable: bool = True,
     ) -> None:
         """
         Initialize a feature.
@@ -219,6 +241,7 @@ class FeatureSpec(BaseFeatureSpec):
         Args:
             name: Name of the feature.
             dtype: Type of the elements in the feature.
+            nullable: Whether the feature is nullable. Defaults to True.
             shape: Used to represent scalar feature, 1-d feature list,
                 or n-d tensor. Use -1 to represent variable length. Defaults to None.
 
@@ -227,6 +250,7 @@ class FeatureSpec(BaseFeatureSpec):
                     - (2,): 1d list with a fixed length of 2.
                     - (-1,): 1d list with variable length, used for ragged tensor representation.
                     - (d1, d2, d3): 3d tensor.
+            nullable: Whether the feature is nullable. Defaults to True.
 
         Raises:
             SnowflakeMLException: TypeError: When the dtype input type is incorrect.
@@ -248,6 +272,8 @@ class FeatureSpec(BaseFeatureSpec):
             )
         self._shape = shape
 
+        self._nullable = nullable
+
     def as_snowpark_type(self) -> spt.DataType:
         result_type = self._dtype.as_snowpark_type()
         if not self._shape:
@@ -256,13 +282,34 @@ class FeatureSpec(BaseFeatureSpec):
             result_type = spt.ArrayType(result_type)
         return result_type
 
-    def as_dtype(self) -> Union[npt.DTypeLike, str]:
+    def as_dtype(self) -> Union[npt.DTypeLike, str, PandasExtensionTypes]:
         """Convert to corresponding local Type."""
+
         if not self._shape:
             # scalar dtype: use keys from `np.sctypeDict` to prevent unit-less dtype 'datetime64'
             if "datetime64" in self._dtype._value:
                 return self._dtype._value
-            return self._dtype._numpy_type
+
+            np_type = self._dtype._numpy_type
+            if self._nullable:
+                np_to_pd_dtype_mapping = {
+                    np.int8: pd.Int8Dtype(),
+                    np.int16: pd.Int16Dtype(),
+                    np.int32: pd.Int32Dtype(),
+                    np.int64: pd.Int64Dtype(),
+                    np.uint8: pd.UInt8Dtype(),
+                    np.uint16: pd.UInt16Dtype(),
+                    np.uint32: pd.UInt32Dtype(),
+                    np.uint64: pd.UInt64Dtype(),
+                    np.float32: pd.Float32Dtype(),
+                    np.float64: pd.Float64Dtype(),
+                    np.bool_: pd.BooleanDtype(),
+                    np.str_: pd.StringDtype(),
+                }
+
+                return np_to_pd_dtype_mapping.get(np_type, np_type)  # type: ignore[arg-type]
+
+            return np_type
         return np.object_
 
     def __eq__(self, other: object) -> bool:
@@ -273,7 +320,10 @@ class FeatureSpec(BaseFeatureSpec):
 
     def __repr__(self) -> str:
         shape_str = f", shape={repr(self._shape)}" if self._shape else ""
-        return f"FeatureSpec(dtype={repr(self._dtype)}, name={repr(self._name)}{shape_str})"
+        return (
+            f"FeatureSpec(dtype={repr(self._dtype)}, "
+            f"name={repr(self._name)}{shape_str}, nullable={repr(self._nullable)})"
+        )
 
     def to_dict(self) -> Dict[str, Any]:
         """Serialize the feature group into a dict.
@@ -281,10 +331,7 @@ class FeatureSpec(BaseFeatureSpec):
         Returns:
             A dict that serializes the feature group.
         """
-        base_dict: Dict[str, Any] = {
-            "type": self._dtype.name,
-            "name": self._name,
-        }
+        base_dict: Dict[str, Any] = {"type": self._dtype.name, "name": self._name, "nullable": self._nullable}
         if self._shape is not None:
             base_dict["shape"] = self._shape
         return base_dict
@@ -304,7 +351,9 @@ class FeatureSpec(BaseFeatureSpec):
         if shape:
             shape = tuple(shape)
         type = DataType[input_dict["type"]]
-        return FeatureSpec(name=name, dtype=type, shape=shape)
+        # If nullable is not provided, default to False for backward compatibility.
+        nullable = input_dict.get("nullable", False)
+        return FeatureSpec(name=name, dtype=type, shape=shape, nullable=nullable)
 
     @classmethod
     def from_mlflow_spec(
@@ -475,10 +524,8 @@ class ModelSignature:
         sig_outs = loaded["outputs"]
         sig_inputs = loaded["inputs"]
 
-        deserialize_spec: Callable[[Dict[str, Any]], BaseFeatureSpec] = (
-            lambda sig_spec: FeatureGroupSpec.from_dict(sig_spec)
-            if "feature_group" in sig_spec
-            else FeatureSpec.from_dict(sig_spec)
+        deserialize_spec: Callable[[Dict[str, Any]], BaseFeatureSpec] = lambda sig_spec: (
+            FeatureGroupSpec.from_dict(sig_spec) if "feature_group" in sig_spec else FeatureSpec.from_dict(sig_spec)
         )
 
         return ModelSignature(

snowflake/ml/model/_signatures/pandas_handler.py

@@ -1,4 +1,5 @@
-from typing import Literal, Sequence
+import warnings
+from typing import Literal, Sequence, Union
 
 import numpy as np
 import pandas as pd
@@ -14,8 +15,8 @@ from snowflake.ml.model._signatures import base_handler, core, utils
 
 class PandasDataFrameHandler(base_handler.BaseDataHandler[pd.DataFrame]):
     @staticmethod
-    def can_handle(data: model_types.SupportedDataType) -> TypeGuard[pd.DataFrame]:
-        return isinstance(data, pd.DataFrame)
+    def can_handle(data: model_types.SupportedDataType) -> TypeGuard[Union[pd.DataFrame, pd.Series]]:
+        return isinstance(data, pd.DataFrame) or isinstance(data, pd.Series)
 
     @staticmethod
     def count(data: pd.DataFrame) -> int:
@@ -26,7 +27,17 @@ class PandasDataFrameHandler(base_handler.BaseDataHandler[pd.DataFrame]):
         return data.head(min(PandasDataFrameHandler.count(data), PandasDataFrameHandler.SIG_INFER_ROWS_COUNT_LIMIT))
 
     @staticmethod
-    def validate(data: pd.DataFrame) -> None:
+    def validate(data: Union[pd.DataFrame, pd.Series]) -> None:
+        if isinstance(data, pd.Series):
+            # check if the series is empty and throw error
+            if data.empty:
+                raise snowml_exceptions.SnowflakeMLException(
+                    error_code=error_codes.INVALID_DATA,
+                    original_exception=ValueError("Data Validation Error: Empty data is found."),
+                )
+            # convert the series to a dataframe
+            data = data.to_frame()
+
         df_cols = data.columns
 
         if df_cols.has_duplicates:  # Rule out categorical index with duplicates
@@ -60,21 +71,44 @@ class PandasDataFrameHandler(base_handler.BaseDataHandler[pd.DataFrame]):
 
         df_col_dtypes = [data[col].dtype for col in data.columns]
         for df_col, df_col_dtype in zip(df_cols, df_col_dtypes):
+            df_col_data = data[df_col]
+            if df_col_data.isnull().all():
+                raise snowml_exceptions.SnowflakeMLException(
+                    error_code=error_codes.INVALID_DATA,
+                    original_exception=ValueError(
+                        f"Data Validation Error: There is no non-null data in column {df_col}."
+                    ),
+                )
+            if df_col_data.isnull().any():
+                warnings.warn(
+                    (
+                        f"Null value detected in column {df_col}, model signature inference might not accurate, "
+                        "or your prediction might fail if your model does not support null input. If this is not "
+                        "expected, please check your input dataframe."
+                    ),
+                    category=UserWarning,
+                    stacklevel=2,
+                )
+
+                df_col_data = utils.series_dropna(df_col_data)
+                df_col_dtype = df_col_data.dtype
+
             if df_col_dtype == np.dtype("O"):
                 # Check if all objects have the same type
-                if not all(isinstance(data_row, type(data[df_col].iloc[0])) for data_row in data[df_col]):
+                if not all(isinstance(data_row, type(df_col_data.iloc[0])) for data_row in df_col_data):
                     raise snowml_exceptions.SnowflakeMLException(
                         error_code=error_codes.INVALID_DATA,
                         original_exception=ValueError(
-                            f"Data Validation Error: Inconsistent type of object found in column data {data[df_col]}."
+                            "Data Validation Error: "
+                            + f"Inconsistent type of element in object found in column data {df_col_data}."
                         ),
                     )
 
-                if isinstance(data[df_col].iloc[0], list):
-                    arr = utils.convert_list_to_ndarray(data[df_col].iloc[0])
+                if isinstance(df_col_data.iloc[0], list):
+                    arr = utils.convert_list_to_ndarray(df_col_data.iloc[0])
                     arr_dtype = core.DataType.from_numpy_type(arr.dtype)
 
-                    converted_data_list = [utils.convert_list_to_ndarray(data_row) for data_row in data[df_col]]
+                    converted_data_list = [utils.convert_list_to_ndarray(data_row) for data_row in df_col_data]
 
                     if not all(
                         core.DataType.from_numpy_type(converted_data.dtype) == arr_dtype
@@ -84,32 +118,37 @@ class PandasDataFrameHandler(base_handler.BaseDataHandler[pd.DataFrame]):
                             error_code=error_codes.INVALID_DATA,
                             original_exception=ValueError(
                                 "Data Validation Error: "
-                                + f"Inconsistent type of element in object found in column data {data[df_col]}."
+                                + f"Inconsistent type of element in object found in column data {df_col_data}."
                             ),
                         )
 
-                elif isinstance(data[df_col].iloc[0], np.ndarray):
-                    arr_dtype = core.DataType.from_numpy_type(data[df_col].iloc[0].dtype)
+                elif isinstance(df_col_data.iloc[0], np.ndarray):
+                    arr_dtype = core.DataType.from_numpy_type(df_col_data.iloc[0].dtype)
 
-                    if not all(core.DataType.from_numpy_type(data_row.dtype) == arr_dtype for data_row in data[df_col]):
+                    if not all(core.DataType.from_numpy_type(data_row.dtype) == arr_dtype for data_row in df_col_data):
                         raise snowml_exceptions.SnowflakeMLException(
                             error_code=error_codes.INVALID_DATA,
                             original_exception=ValueError(
                                 "Data Validation Error: "
-                                + f"Inconsistent type of element in object found in column data {data[df_col]}."
+                                + f"Inconsistent type of element in object found in column data {df_col_data}."
                             ),
                         )
-                elif not isinstance(data[df_col].iloc[0], (str, bytes)):
+                elif not isinstance(df_col_data.iloc[0], (str, bytes)):
                     raise snowml_exceptions.SnowflakeMLException(
                         error_code=error_codes.INVALID_DATA,
                         original_exception=ValueError(
-                            f"Data Validation Error: Unsupported type confronted in {data[df_col]}"
+                            f"Data Validation Error: Unsupported type confronted in {df_col_data}"
                         ),
                     )
 
     @staticmethod
-    def infer_signature(data: pd.DataFrame, role: Literal["input", "output"]) -> Sequence[core.BaseFeatureSpec]:
+    def infer_signature(
+        data: Union[pd.DataFrame, pd.Series],
+        role: Literal["input", "output"],
+    ) -> Sequence[core.BaseFeatureSpec]:
         feature_prefix = f"{PandasDataFrameHandler.FEATURE_PREFIX}_"
+        if isinstance(data, pd.Series):
+            data = data.to_frame()
         df_cols = data.columns
         role_prefix = (
             PandasDataFrameHandler.INPUT_PREFIX if role == "input" else PandasDataFrameHandler.OUTPUT_PREFIX
@@ -123,29 +162,34 @@ class PandasDataFrameHandler(base_handler.BaseDataHandler[pd.DataFrame]):
 
         specs = []
         for df_col, df_col_dtype, ft_name in zip(df_cols, df_col_dtypes, ft_names):
+            df_col_data = data[df_col]
+            if df_col_data.isnull().any():
+                df_col_data = utils.series_dropna(df_col_data)
+            df_col_dtype = df_col_data.dtype
+
             if df_col_dtype == np.dtype("O"):
-                if isinstance(data[df_col].iloc[0], list):
-                    arr = utils.convert_list_to_ndarray(data[df_col].iloc[0])
+                if isinstance(df_col_data.iloc[0], list):
+                    arr = utils.convert_list_to_ndarray(df_col_data.iloc[0])
                     arr_dtype = core.DataType.from_numpy_type(arr.dtype)
-                    ft_shape = np.shape(data[df_col].iloc[0])
+                    ft_shape = np.shape(df_col_data.iloc[0])
 
-                    converted_data_list = [utils.convert_list_to_ndarray(data_row) for data_row in data[df_col]]
+                    converted_data_list = [utils.convert_list_to_ndarray(data_row) for data_row in df_col_data]
 
                     if not all(np.shape(converted_data) == ft_shape for converted_data in converted_data_list):
                         ft_shape = (-1,)
 
                     specs.append(core.FeatureSpec(dtype=arr_dtype, name=ft_name, shape=ft_shape))
-                elif isinstance(data[df_col].iloc[0], np.ndarray):
-                    arr_dtype = core.DataType.from_numpy_type(data[df_col].iloc[0].dtype)
-                    ft_shape = np.shape(data[df_col].iloc[0])
+                elif isinstance(df_col_data.iloc[0], np.ndarray):
+                    arr_dtype = core.DataType.from_numpy_type(df_col_data.iloc[0].dtype)
+                    ft_shape = np.shape(df_col_data.iloc[0])
 
-                    if not all(np.shape(data_row) == ft_shape for data_row in data[df_col]):
+                    if not all(np.shape(data_row) == ft_shape for data_row in df_col_data):
                         ft_shape = (-1,)
 
                     specs.append(core.FeatureSpec(dtype=arr_dtype, name=ft_name, shape=ft_shape))
-                elif isinstance(data[df_col].iloc[0], str):
+                elif isinstance(df_col_data.iloc[0], str):
                     specs.append(core.FeatureSpec(dtype=core.DataType.STRING, name=ft_name))
-                elif isinstance(data[df_col].iloc[0], bytes):
+                elif isinstance(df_col_data.iloc[0], bytes):
                     specs.append(core.FeatureSpec(dtype=core.DataType.BYTES, name=ft_name))
             elif isinstance(df_col_dtype, pd.CategoricalDtype):
                 category_dtype = df_col_dtype.categories.dtype

snowflake/ml/model/_signatures/pytorch_handler.py

@@ -72,10 +72,10 @@ class SeqOfPyTorchTensorHandler(base_handler.BaseDataHandler[Sequence["torch.Ten
             dtype = core.DataType.from_torch_type(data_col.dtype)
             ft_name = f"{role_prefix}{feature_prefix}{i}"
             if len(data_col.shape) == 1:
-                features.append(core.FeatureSpec(dtype=dtype, name=ft_name))
+                features.append(core.FeatureSpec(dtype=dtype, name=ft_name, nullable=False))
             else:
                 ft_shape = tuple(data_col.shape[1:])
-                features.append(core.FeatureSpec(dtype=dtype, name=ft_name, shape=ft_shape))
+                features.append(core.FeatureSpec(dtype=dtype, name=ft_name, shape=ft_shape, nullable=False))
         return features
 
     @staticmethod

snowflake/ml/model/_signatures/snowpark_handler.py

@@ -82,7 +82,8 @@ class SnowparkDataFrameHandler(base_handler.BaseDataHandler[snowflake.snowpark.D
                     identifier.get_unescaped_names(field.name)
                 ].map(json.loads)
         # Only when the feature is not from inference, we are confident to do the type casting.
-        # Otherwise, dtype_map will be empty
+        # Otherwise, dtype_map will be empty.
+        # Errors are ignored to make sure None won't be converted and won't raise Error
         df_local = df_local.astype(dtype=dtype_map)
         return df_local
 

snowflake/ml/model/_signatures/tensorflow_handler.py

@@ -109,10 +109,10 @@ class SeqOfTensorflowTensorHandler(
             dtype = core.DataType.from_numpy_type(data_col.dtype.as_numpy_dtype)
             ft_name = f"{role_prefix}{feature_prefix}{i}"
             if len(data_col.shape) == 1:
-                features.append(core.FeatureSpec(dtype=dtype, name=ft_name))
+                features.append(core.FeatureSpec(dtype=dtype, name=ft_name, nullable=False))
             else:
                 ft_shape = tuple(data_col.shape[1:])
-                features.append(core.FeatureSpec(dtype=dtype, name=ft_name, shape=ft_shape))
+                features.append(core.FeatureSpec(dtype=dtype, name=ft_name, shape=ft_shape, nullable=False))
         return features
 
     @staticmethod

snowflake/ml/model/_signatures/utils.py

@@ -118,7 +118,6 @@ def huggingface_pipeline_signature_auto_infer(task: str, params: Dict[str, Any])
             category=DeprecationWarning,
             stacklevel=1,
         )
-
         return core.ModelSignature(
             inputs=[
                 core.FeatureSpec(name="user_inputs", dtype=core.DataType.STRING, shape=(-1,)),
@@ -297,3 +296,7 @@ def huggingface_pipeline_signature_auto_infer(task: str, params: Dict[str, Any])
         )
 
     return None
+
+
+def series_dropna(series: pd.Series) -> pd.Series:
+    return series.dropna(inplace=False).reset_index(drop=True).convert_dtypes()

snowflake/ml/model/model_signature.py

@@ -139,9 +139,32 @@ def _rename_signature_with_snowflake_identifiers(
     return signature
 
 
-def _validate_numpy_array(
-    arr: model_types._SupportedNumpyArray, feature_type: core.DataType, strict: bool = False
+def _validate_array_or_series_type(
+    arr: Union[model_types._SupportedNumpyArray, pd.Series], feature_type: core.DataType, strict: bool = False
 ) -> bool:
+    original_dtype = arr.dtype
+    dtype = arr.dtype
+    if isinstance(
+        dtype,
+        (
+            pd.Int8Dtype,
+            pd.Int16Dtype,
+            pd.Int32Dtype,
+            pd.Int64Dtype,
+            pd.UInt8Dtype,
+            pd.UInt16Dtype,
+            pd.UInt32Dtype,
+            pd.UInt64Dtype,
+            pd.Float32Dtype,
+            pd.Float64Dtype,
+            pd.BooleanDtype,
+        ),
+    ):
+        dtype = dtype.type
+    elif isinstance(dtype, pd.CategoricalDtype):
+        dtype = dtype.categories.dtype
+    elif isinstance(dtype, pd.StringDtype):
+        dtype = np.str_
     if feature_type in [
         core.DataType.INT8,
         core.DataType.INT16,
@@ -152,14 +175,17 @@ def _validate_numpy_array(
         core.DataType.UINT32,
         core.DataType.UINT64,
     ]:
-        if not (np.issubdtype(arr.dtype, np.integer)):
+        if not (np.issubdtype(dtype, np.integer)):
             return False
         if not strict:
             return True
-        min_v, max_v = arr.min(), arr.max()
+        if isinstance(original_dtype, pd.CategoricalDtype):
+            min_v, max_v = arr.cat.as_ordered().min(), arr.cat.as_ordered().min()  # type: ignore[union-attr]
+        else:
+            min_v, max_v = arr.min(), arr.max()
         return bool(max_v <= np.iinfo(feature_type._numpy_type).max and min_v >= np.iinfo(feature_type._numpy_type).min)
     elif feature_type in [core.DataType.FLOAT, core.DataType.DOUBLE]:
-        if not (np.issubdtype(arr.dtype, np.integer) or np.issubdtype(arr.dtype, np.floating)):
+        if not (np.issubdtype(dtype, np.integer) or np.issubdtype(dtype, np.floating)):
             return False
         if not strict:
             return True
@@ -171,7 +197,7 @@ def _validate_numpy_array(
     elif feature_type in [core.DataType.TIMESTAMP_NTZ]:
         return np.issubdtype(arr.dtype, np.datetime64)
     else:
-        return np.can_cast(arr.dtype, feature_type._numpy_type, casting="no")
+        return np.can_cast(dtype, feature_type._numpy_type, casting="no")
 
 
 def _validate_pandas_df(data: pd.DataFrame, features: Sequence[core.BaseFeatureSpec], strict: bool = False) -> None:
@@ -204,7 +230,10 @@ def _validate_pandas_df(data: pd.DataFrame, features: Sequence[core.BaseFeatureS
                 original_exception=ValueError(f"Data Validation Error: feature {ft_name} does not exist in data."),
             )
 
+        if data_col.isnull().any():
+            data_col = utils.series_dropna(data_col)
         df_col_dtype = data_col.dtype
+
         if isinstance(feature, core.FeatureGroupSpec):
             raise snowml_exceptions.SnowflakeMLException(
                 error_code=error_codes.NOT_IMPLEMENTED,
@@ -217,7 +246,7 @@ def _validate_pandas_df(data: pd.DataFrame, features: Sequence[core.BaseFeatureS
         if isinstance(df_col_dtype, pd.CategoricalDtype):
             df_col_dtype = df_col_dtype.categories.dtype
         if df_col_dtype != np.dtype("O"):
-            if not _validate_numpy_array(data_col.to_numpy(), ft_type, strict=strict):
+            if not _validate_array_or_series_type(data_col, ft_type, strict=strict):
                 raise snowml_exceptions.SnowflakeMLException(
                     error_code=error_codes.INVALID_DATA,
                     original_exception=ValueError(
@@ -247,7 +276,7 @@ def _validate_pandas_df(data: pd.DataFrame, features: Sequence[core.BaseFeatureS
                 converted_data_list = [utils.convert_list_to_ndarray(data_row) for data_row in data_col]
 
                 if not all(
-                    _validate_numpy_array(converted_data, ft_type, strict=strict)
+                    _validate_array_or_series_type(converted_data, ft_type, strict=strict)
                     for converted_data in converted_data_list
                 ):
                     raise snowml_exceptions.SnowflakeMLException(
@@ -278,7 +307,7 @@ def _validate_pandas_df(data: pd.DataFrame, features: Sequence[core.BaseFeatureS
                         ),
                     )
 
-                if not all(_validate_numpy_array(data_row, ft_type, strict=strict) for data_row in data_col):
+                if not all(_validate_array_or_series_type(data_row, ft_type, strict=strict) for data_row in data_col):
                     raise snowml_exceptions.SnowflakeMLException(
                         error_code=error_codes.INVALID_DATA,
                         original_exception=ValueError(

snowflake/ml/model/type_hints.py

@@ -66,7 +66,7 @@ SupportedRequireSignatureModelType = Union[
     "xgboost.XGBModel",
     "xgboost.Booster",
     "torch.nn.Module",
-    "torch.jit.ScriptModule",  # type:ignore[name-defined]
+    "torch.jit.ScriptModule",
     "tensorflow.Module",
 ]
 

snowflake/ml/modeling/lightgbm/lgbm_classifier.py

@@ -130,8 +130,7 @@ class LGBMClassifier(BaseTransformer):
         reg_alpha=0.0,
         reg_lambda=0.0,
         random_state=None,
-        n_jobs=-1,
-        silent="warn",
+        n_jobs=None,
         importance_type="split",
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
@@ -172,8 +171,7 @@ class LGBMClassifier(BaseTransformer):
             'reg_alpha':(reg_alpha, 0.0, False),
             'reg_lambda':(reg_lambda, 0.0, False),
             'random_state':(random_state, None, False),
-            'n_jobs':(n_jobs, -1, False),
-            'silent':(silent, "warn", False),
+            'n_jobs':(n_jobs, None, False),
             'importance_type':(importance_type, "split", False),}
         cleaned_up_init_args = validate_sklearn_args(
             args=init_args,

snowflake/ml/modeling/lightgbm/lgbm_regressor.py

@@ -130,8 +130,7 @@ class LGBMRegressor(BaseTransformer):
         reg_alpha=0.0,
         reg_lambda=0.0,
         random_state=None,
-        n_jobs=-1,
-        silent="warn",
+        n_jobs=None,
         importance_type="split",
         input_cols: Optional[Union[str, Iterable[str]]] = None,
         output_cols: Optional[Union[str, Iterable[str]]] = None,
@@ -172,8 +171,7 @@ class LGBMRegressor(BaseTransformer):
             'reg_alpha':(reg_alpha, 0.0, False),
             'reg_lambda':(reg_lambda, 0.0, False),
             'random_state':(random_state, None, False),
-            'n_jobs':(n_jobs, -1, False),
-            'silent':(silent, "warn", False),
+            'n_jobs':(n_jobs, None, False),
             'importance_type':(importance_type, "split", False),}
         cleaned_up_init_args = validate_sklearn_args(
             args=init_args,