snowflake-ml-python 1.7.5__py3-none-any.whl → 1.8.1__py3-none-any.whl

snowflake/ml/model/_packager/model_meta/model_meta.py

@@ -48,6 +48,7 @@ def create_model_metadata(
     ext_modules: Optional[List[ModuleType]] = None,
     conda_dependencies: Optional[List[str]] = None,
     pip_requirements: Optional[List[str]] = None,
+    artifact_repository_map: Optional[Dict[str, str]] = None,
     python_version: Optional[str] = None,
     task: model_types.Task = model_types.Task.UNKNOWN,
     **kwargs: Any,
@@ -67,6 +68,7 @@ def create_model_metadata(
         ext_modules: List of names of modules that need to be pickled with the model. Defaults to None.
         conda_dependencies: List of conda requirements for running the model. Defaults to None.
         pip_requirements: List of pip Python packages requirements for running the model. Defaults to None.
+        artifact_repository_map: A dict mapping from package channel to artifact repository name.
         python_version: A string of python version where model is run. Used for user override. If specified as None,
             current version would be captured. Defaults to None.
         task: The task of the Model Version. It is an enum class Task with values TABULAR_REGRESSION,
@@ -102,6 +104,7 @@ def create_model_metadata(
     env = _create_env_for_model_metadata(
         conda_dependencies=conda_dependencies,
         pip_requirements=pip_requirements,
+        artifact_repository_map=artifact_repository_map,
         python_version=python_version,
         embed_local_ml_library=embed_local_ml_library,
     )
@@ -151,6 +154,7 @@ def _create_env_for_model_metadata(
     *,
     conda_dependencies: Optional[List[str]] = None,
     pip_requirements: Optional[List[str]] = None,
+    artifact_repository_map: Optional[Dict[str, str]] = None,
     python_version: Optional[str] = None,
     embed_local_ml_library: bool = False,
 ) -> model_env.ModelEnv:
@@ -159,6 +163,7 @@ def _create_env_for_model_metadata(
     # Mypy doesn't like getter and setter have different types. See python/mypy #3004
     env.conda_dependencies = conda_dependencies  # type: ignore[assignment]
     env.pip_requirements = pip_requirements  # type: ignore[assignment]
+    env.artifact_repository_map = artifact_repository_map
     env.python_version = python_version  # type: ignore[assignment]
     env.snowpark_ml_version = snowml_env.VERSION
 
@@ -331,7 +336,6 @@ class ModelMetadata:
                 "function_properties": self.function_properties,
             }
         )
-
         with open(model_yaml_path, "w", encoding="utf-8") as out:
             yaml.SafeDumper.ignore_aliases = lambda *args: True  # type: ignore[method-assign]
             yaml.safe_dump(model_dict, stream=out, default_flow_style=False)

snowflake/ml/model/_packager/model_meta/model_meta_schema.py

@@ -18,6 +18,7 @@ class FunctionProperties(Enum):
 class ModelRuntimeDependenciesDict(TypedDict):
     conda: Required[str]
     pip: Required[str]
+    artifact_repository_map: NotRequired[Optional[Dict[str, str]]]
 
 
 class ModelRuntimeDict(TypedDict):
@@ -28,6 +29,7 @@ class ModelRuntimeDict(TypedDict):
 class ModelEnvDict(TypedDict):
     conda: Required[str]
     pip: Required[str]
+    artifact_repository_map: NotRequired[Optional[Dict[str, str]]]
     python_version: Required[str]
     cuda_version: NotRequired[Optional[str]]
     snowpark_ml_version: Required[str]
@@ -61,8 +63,17 @@ class XgboostModelBlobOptions(BaseModelBlobOptions):
     xgb_estimator_type: Required[str]
 
 
+class PyTorchModelBlobOptions(BaseModelBlobOptions):
+    multiple_inputs: Required[bool]
+
+
+class TorchScriptModelBlobOptions(BaseModelBlobOptions):
+    multiple_inputs: Required[bool]
+
+
 class TensorflowModelBlobOptions(BaseModelBlobOptions):
     save_format: Required[str]
+    multiple_inputs: Required[bool]
 
 
 class SentenceTransformersModelBlobOptions(BaseModelBlobOptions):
@@ -71,9 +82,12 @@ class SentenceTransformersModelBlobOptions(BaseModelBlobOptions):
 
 ModelBlobOptions = Union[
     BaseModelBlobOptions,
+    CatBoostModelBlobOptions,
     HuggingFacePipelineModelBlobOptions,
     MLFlowModelBlobOptions,
     XgboostModelBlobOptions,
+    PyTorchModelBlobOptions,
+    TorchScriptModelBlobOptions,
     TensorflowModelBlobOptions,
     SentenceTransformersModelBlobOptions,
 ]

snowflake/ml/model/_packager/model_packager.py

@@ -43,13 +43,13 @@ class ModelPackager:
         metadata: Optional[Dict[str, str]] = None,
         conda_dependencies: Optional[List[str]] = None,
         pip_requirements: Optional[List[str]] = None,
+        artifact_repository_map: Optional[Dict[str, str]] = None,
         python_version: Optional[str] = None,
         ext_modules: Optional[List[ModuleType]] = None,
         code_paths: Optional[List[str]] = None,
-        options: Optional[model_types.ModelSaveOption] = None,
+        options: model_types.ModelSaveOption,
         task: model_types.Task = model_types.Task.UNKNOWN,
     ) -> model_meta.ModelMetadata:
-
         if (signatures is None) and (sample_input_data is None) and not model_handler.is_auto_signature_model(model):
             raise snowml_exceptions.SnowflakeMLException(
                 error_code=error_codes.INVALID_ARGUMENT,
@@ -58,9 +58,6 @@ class ModelPackager:
                 ),
             )
 
-        if not options:
-            options = model_types.BaseModelSaveOption()
-
         handler = model_handler.find_handler(model)
         if handler is None:
             raise snowml_exceptions.SnowflakeMLException(
@@ -77,6 +74,7 @@ class ModelPackager:
             ext_modules=ext_modules,
             conda_dependencies=conda_dependencies,
             pip_requirements=pip_requirements,
+            artifact_repository_map=artifact_repository_map,
             python_version=python_version,
             task=task,
             **options,

snowflake/ml/model/_packager/model_runtime/_snowml_inference_alternative_requirements.py

@@ -1,2 +1 @@
-REQUIREMENTS = ['absl-py>=0.15,<2', 'aiohttp!=4.0.0a0, !=4.0.0a1', 'anyio>=3.5.0,<5', 'cachetools>=3.1.1,<6', 'cloudpickle>=2.0.0', 'cryptography', 'fsspec>=2024.6.1,<2026', 'importlib_resources>=6.1.1, <7', 'numpy>=1.23,<2', 'packaging>=20.9,<25', 'pandas>=1.0.0,<3', 'pyarrow', 'pyjwt>=2.0.0, <3', 'pytimeparse>=1.1.8,<2', 'pyyaml>=6.0,<7', 'requests', 'retrying>=1.3.3,<2', 's3fs>=2024.6.1,<2026', 'scikit-learn>=1.4,<1.6', 'scipy>=1.9,<2', 'snowflake-connector-python>=3.5.0,<4', 'snowflake-snowpark-python>=1.17.0,<2,!=1.26.0', 'sqlparse>=0.4,<1', 'typing-extensions>=4.1.0,<5', 'xgboost>=1.7.3,<3']
-ALL_REQUIREMENTS=['absl-py>=0.15,<2', 'aiohttp!=4.0.0a0, !=4.0.0a1', 'anyio>=3.5.0,<5', 'cachetools>=3.1.1,<6', 'catboost>=1.2.0, <2', 'cloudpickle>=2.0.0', 'cryptography', 'fsspec>=2024.6.1,<2026', 'importlib_resources>=6.1.1, <7', 'keras>=2.0.0,<4', 'lightgbm>=4.1.0, <5', 'mlflow>=2.16.0, <3', 'numpy>=1.23,<2', 'packaging>=20.9,<25', 'pandas>=1.0.0,<3', 'pyarrow', 'pyjwt>=2.0.0, <3', 'pytimeparse>=1.1.8,<2', 'pytorch>=2.0.1,<3', 'pyyaml>=6.0,<7', 'requests', 'retrying>=1.3.3,<2', 's3fs>=2024.6.1,<2026', 'scikit-learn>=1.4,<1.6', 'scipy>=1.9,<2', 'sentence-transformers>=2.7.0,<3', 'sentencepiece>=0.1.95,<0.2.0', 'shap>=0.46.0,<1', 'snowflake-connector-python>=3.5.0,<4', 'snowflake-snowpark-python>=1.17.0,<2,!=1.26.0', 'sqlparse>=0.4,<1', 'tensorflow>=2.17.0,<3', 'tokenizers>=0.15.1,<1', 'torchdata>=0.4,<1', 'transformers>=4.37.2,<5', 'typing-extensions>=4.1.0,<5', 'xgboost>=1.7.3,<3']
+REQUIREMENTS = ['absl-py>=0.15,<2', 'aiohttp!=4.0.0a0, !=4.0.0a1', 'anyio>=3.5.0,<5', 'cachetools>=3.1.1,<6', 'cloudpickle>=2.0.0,<3', 'cryptography', 'fsspec>=2024.6.1,<2026', 'importlib_resources>=6.1.1, <7', 'numpy>=1.23,<2', 'packaging>=20.9,<25', 'pandas>=1.0.0,<3', 'pyarrow', 'pyjwt>=2.0.0, <3', 'pytimeparse>=1.1.8,<2', 'pyyaml>=6.0,<7', 'requests', 'retrying>=1.3.3,<2', 's3fs>=2024.6.1,<2026', 'scikit-learn>=1.4,<1.6', 'scipy>=1.9,<2', 'snowflake-connector-python>=3.12.0,<4', 'snowflake-snowpark-python>=1.17.0,<2,!=1.26.0', 'sqlparse>=0.4,<1', 'typing-extensions>=4.1.0,<5', 'xgboost>=1.7.3,<3']

snowflake/ml/model/_packager/model_runtime/model_runtime.py

@@ -98,6 +98,9 @@ class ModelRuntime:
             dependencies=model_meta_schema.ModelRuntimeDependenciesDict(
                 conda=env_dict["conda"],
                 pip=env_dict["pip"],
+                artifact_repository_map=env_dict["artifact_repository_map"]
+                if env_dict.get("artifact_repository_map") is not None
+                else {},
             ),
         )
 
@@ -112,6 +115,7 @@ class ModelRuntime:
         env.python_version = meta_env.python_version
         env.cuda_version = meta_env.cuda_version
         env.snowpark_ml_version = meta_env.snowpark_ml_version
+        env.artifact_repository_map = meta_env.artifact_repository_map
 
         conda_env_rel_path = pathlib.PurePosixPath(loaded_dict["dependencies"]["conda"])
         pip_requirements_rel_path = pathlib.PurePosixPath(loaded_dict["dependencies"]["pip"])

snowflake/ml/model/_signatures/builtins_handler.py

@@ -14,21 +14,32 @@ from snowflake.ml.model._signatures import base_handler, core, pandas_handler
 
 
 class ListOfBuiltinHandler(base_handler.BaseDataHandler[model_types._SupportedBuiltinsList]):
+    @staticmethod
+    def _can_handle_element(
+        element: model_types._SupportedBuiltins,
+    ) -> TypeGuard[model_types._SupportedBuiltins]:
+        if isinstance(element, abc.Sequence) and not isinstance(element, str):
+            for sub_element in element:
+                if not ListOfBuiltinHandler._can_handle_element(sub_element):
+                    return False
+            return True
+        elif isinstance(element, abc.Mapping):
+            for key, value in element.items():
+                if not isinstance(key, str):
+                    return False
+                if not ListOfBuiltinHandler._can_handle_element(value):
+                    return False
+            return True
+        else:
+            return isinstance(element, (int, float, bool, str, datetime.datetime))
+
     @staticmethod
     def can_handle(data: model_types.SupportedDataType) -> TypeGuard[model_types._SupportedBuiltinsList]:
         if not isinstance(data, abc.Sequence) or isinstance(data, str):
             return False
         if len(data) == 0:
             return False
-        can_handle = True
-        for element in data:
-            # String is a Sequence but we take them as an whole
-            if isinstance(element, abc.Sequence) and not isinstance(element, str):
-                can_handle = ListOfBuiltinHandler.can_handle(element)
-            elif not isinstance(element, (int, float, bool, str, datetime.datetime)):
-                can_handle = False
-                break
-        return can_handle
+        return ListOfBuiltinHandler._can_handle_element(data)
 
     @staticmethod
     def count(data: model_types._SupportedBuiltinsList) -> int:

snowflake/ml/model/_signatures/core.py

@@ -199,9 +199,16 @@ class DataType(Enum):
 class BaseFeatureSpec(ABC):
     """Abstract Class for specification of a feature."""
 
-    def __init__(self, name: str) -> None:
+    def __init__(self, name: str, shape: Optional[Tuple[int, ...]]) -> None:
         self._name = name
 
+        if shape and not isinstance(shape, tuple):
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_TYPE,
+                original_exception=TypeError("Shape should be a tuple if presented."),
+            )
+        self._shape = shape
+
     @final
     @property
     def name(self) -> str:
@@ -213,6 +220,11 @@ class BaseFeatureSpec(ABC):
         """Convert to corresponding Snowpark Type."""
         pass
 
+    @abstractmethod
+    def as_dtype(self, force_numpy_dtype: bool = False) -> Union[npt.DTypeLike, str, PandasExtensionTypes]:
+        """Convert to corresponding local Type."""
+        pass
+
     @abstractmethod
     def to_dict(self) -> Dict[str, Any]:
         """Serialization"""
@@ -256,7 +268,7 @@ class FeatureSpec(BaseFeatureSpec):
             SnowflakeMLException: TypeError: When the dtype input type is incorrect.
             SnowflakeMLException: TypeError: When the shape input type is incorrect.
         """
-        super().__init__(name=name)
+        super().__init__(name=name, shape=shape)
 
         if not isinstance(dtype, DataType):
             raise snowml_exceptions.SnowflakeMLException(
@@ -265,13 +277,6 @@ class FeatureSpec(BaseFeatureSpec):
             )
         self._dtype = dtype
 
-        if shape and not isinstance(shape, tuple):
-            raise snowml_exceptions.SnowflakeMLException(
-                error_code=error_codes.INVALID_TYPE,
-                original_exception=TypeError("Shape should be a tuple if presented."),
-            )
-        self._shape = shape
-
         self._nullable = nullable
 
     def as_snowpark_type(self) -> spt.DataType:
@@ -386,15 +391,23 @@ class FeatureSpec(BaseFeatureSpec):
 class FeatureGroupSpec(BaseFeatureSpec):
     """Specification of a group of features in Snowflake native model packaging."""
 
-    def __init__(self, name: str, specs: List[FeatureSpec]) -> None:
+    def __init__(self, name: str, specs: List[BaseFeatureSpec], shape: Optional[Tuple[int, ...]] = None) -> None:
         """Initialize a feature group.
 
         Args:
             name: Name of the feature group.
             specs: A list of feature specifications that composes the group. All children feature specs have to have
                 name. And all of them should have the same type.
+            shape: Used to represent scalar feature, 1-d feature list,
+                or n-d tensor. Use -1 to represent variable length. Defaults to None.
+
+                Examples:
+                    - None: scalar
+                    - (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.
         """
-        super().__init__(name=name)
+        super().__init__(name=name, shape=shape)
         self._specs = specs
         self._validate()
 
@@ -409,47 +422,52 @@ class FeatureGroupSpec(BaseFeatureSpec):
                 error_code=error_codes.INVALID_ARGUMENT,
                 original_exception=ValueError("All children feature specs have to have name."),
             )
-        if not (all(s._shape is None for s in self._specs) or all(s._shape is not None for s in self._specs)):
-            raise snowml_exceptions.SnowflakeMLException(
-                error_code=error_codes.INVALID_ARGUMENT,
-                original_exception=ValueError("All children feature specs have to have same shape."),
-            )
-        first_type = self._specs[0]._dtype
-        if not all(s._dtype == first_type for s in self._specs):
-            raise snowml_exceptions.SnowflakeMLException(
-                error_code=error_codes.INVALID_ARGUMENT,
-                original_exception=ValueError("All children feature specs have to have same type."),
-            )
 
     def as_snowpark_type(self) -> spt.DataType:
-        first_type = self._specs[0].as_snowpark_type()
-        return spt.MapType(spt.StringType(), first_type)
+        spt_type = spt.StructType(
+            fields=[
+                spt.StructField(
+                    s._name, datatype=s.as_snowpark_type(), nullable=s._nullable if isinstance(s, FeatureSpec) else True
+                )
+                for s in self._specs
+            ]
+        )
+        if not self._shape:
+            return spt_type
+        return spt.ArrayType(spt_type)
 
     def __eq__(self, other: object) -> bool:
         if isinstance(other, FeatureGroupSpec):
-            return self._specs == other._specs
+            return self._name == other._name and self._specs == other._specs and self._shape == other._shape
         else:
             return False
 
     def __repr__(self) -> str:
         spec_strs = ",\n\t\t".join(repr(spec) for spec in self._specs)
+        shape_str = f", shape={repr(self._shape)}" if self._shape else ""
         return textwrap.dedent(
             f"""FeatureGroupSpec(
                 name={repr(self._name)},
                 specs=[
                     {spec_strs}
-                ]
+                ]{shape_str}
             )
             """
         )
 
+    def as_dtype(self, force_numpy_dtype: bool = False) -> Union[npt.DTypeLike, str, PandasExtensionTypes]:
+        return np.object_
+
     def to_dict(self) -> Dict[str, Any]:
         """Serialize the feature group into a dict.
 
         Returns:
             A dict that serializes the feature group.
         """
-        return {"feature_group": {"name": self._name, "specs": [s.to_dict() for s in self._specs]}}
+        base_dict: Dict[str, Any] = {"name": self._name, "specs": [s.to_dict() for s in self._specs]}
+        if self._shape is not None:
+            base_dict["shape"] = self._shape
+        return base_dict
 
     @classmethod
     def from_dict(cls, input_dict: Dict[str, Any]) -> "FeatureGroupSpec":
@@ -462,10 +480,13 @@ class FeatureGroupSpec(BaseFeatureSpec):
             A feature group instance deserialized and created from the dict.
         """
         specs = []
-        for e in input_dict["feature_group"]["specs"]:
-            spec = FeatureSpec.from_dict(e)
+        for e in input_dict["specs"]:
+            spec = FeatureGroupSpec.from_dict(e) if "specs" in e else FeatureSpec.from_dict(e)
             specs.append(spec)
-        return FeatureGroupSpec(name=input_dict["feature_group"]["name"], specs=specs)
+        shape = input_dict.get("shape", None)
+        if shape:
+            shape = tuple(shape)
+        return FeatureGroupSpec(name=input_dict["name"], specs=specs, shape=shape)
 
 
 class ModelSignature:
@@ -525,7 +546,7 @@ class ModelSignature:
         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)
+            FeatureGroupSpec.from_dict(sig_spec) if "specs" in sig_spec else FeatureSpec.from_dict(sig_spec)
         )
 
         return ModelSignature(

snowflake/ml/model/_signatures/dmatrix_handler.py

@@ -0,0 +1,98 @@
+from typing import TYPE_CHECKING, List, Literal, Optional, Sequence
+
+import numpy as np
+import pandas as pd
+from typing_extensions import TypeGuard
+
+from snowflake.ml._internal import type_utils
+from snowflake.ml._internal.exceptions import (
+    error_codes,
+    exceptions as snowml_exceptions,
+)
+from snowflake.ml.model import type_hints as model_types
+from snowflake.ml.model._signatures import base_handler, core
+
+if TYPE_CHECKING:
+    import xgboost
+
+
+class XGBoostDMatrixHandler(base_handler.BaseDataHandler["xgboost.DMatrix"]):
+    @staticmethod
+    def can_handle(data: model_types.SupportedDataType) -> TypeGuard["xgboost.DMatrix"]:
+        return type_utils.LazyType("xgboost.DMatrix").isinstance(data)
+
+    @staticmethod
+    def count(data: "xgboost.DMatrix") -> int:
+        return data.num_row()
+
+    @staticmethod
+    def truncate(data: "xgboost.DMatrix", length: int) -> "xgboost.DMatrix":
+
+        num_rows = min(
+            XGBoostDMatrixHandler.count(data),
+            length,
+        )
+        return data.slice(list(range(num_rows)))
+
+    @staticmethod
+    def validate(data: "xgboost.DMatrix") -> None:
+        if data.num_row() == 0:
+            raise snowml_exceptions.SnowflakeMLException(
+                error_code=error_codes.INVALID_DATA,
+                original_exception=ValueError("Data Validation Error: Empty data is found."),
+            )
+
+    @staticmethod
+    def infer_signature(data: "xgboost.DMatrix", role: Literal["input", "output"]) -> Sequence[core.BaseFeatureSpec]:
+        feature_prefix = f"{XGBoostDMatrixHandler.FEATURE_PREFIX}_"
+        features: List[core.BaseFeatureSpec] = []
+        role_prefix = (
+            XGBoostDMatrixHandler.INPUT_PREFIX if role == "input" else XGBoostDMatrixHandler.OUTPUT_PREFIX
+        ) + "_"
+
+        feature_names = data.feature_names or []
+        feature_types = data.feature_types or []
+
+        for i, (feature_name, dtype) in enumerate(zip(feature_names, feature_types)):
+            if not feature_name:
+                ft_name = f"{role_prefix}{feature_prefix}{i}"
+            else:
+                ft_name = feature_name
+
+            features.append(core.FeatureSpec(dtype=core.DataType.from_numpy_type(np.dtype(dtype)), name=ft_name))
+        return features
+
+    @staticmethod
+    def convert_to_df(data: "xgboost.DMatrix", ensure_serializable: bool = True) -> pd.DataFrame:
+        df = pd.DataFrame(data.get_data().toarray(), columns=data.feature_names)
+
+        feature_types = data.feature_types or []
+
+        if feature_types:
+            for idx, col in enumerate(df.columns):
+                dtype = feature_types[idx]
+                df[col] = df[col].astype(dtype)
+
+        return df
+
+    @staticmethod
+    def convert_from_df(
+        df: pd.DataFrame, features: Optional[Sequence[core.BaseFeatureSpec]] = None
+    ) -> "xgboost.DMatrix":
+        import xgboost as xgb
+
+        if not features:
+            return xgb.DMatrix(df)
+        else:
+            feature_names = []
+            feature_types = []
+            for feature in features:
+                if isinstance(feature, core.FeatureGroupSpec):
+                    raise snowml_exceptions.SnowflakeMLException(
+                        error_code=error_codes.NOT_IMPLEMENTED,
+                        original_exception=NotImplementedError("FeatureGroupSpec is not supported."),
+                    )
+                assert isinstance(feature, core.FeatureSpec), "Invalid feature kind."
+                feature_names.append(feature.name)
+                feature_types.append(feature._dtype._numpy_type)
+            return xgb.DMatrix(df, feature_names=feature_names, feature_types=feature_types)

snowflake/ml/model/_signatures/numpy_handler.py

@@ -1,5 +1,5 @@
 from collections import abc
-from typing import List, Literal, Sequence
+from typing import Literal, Sequence
 
 import numpy as np
 import pandas as pd
@@ -10,7 +10,7 @@ from snowflake.ml._internal.exceptions import (
     exceptions as snowml_exceptions,
 )
 from snowflake.ml.model import type_hints as model_types
-from snowflake.ml.model._signatures import base_handler, core
+from snowflake.ml.model._signatures import base_handler, core, pandas_handler
 
 
 class NumpyArrayHandler(base_handler.BaseDataHandler[model_types._SupportedNumpyArray]):
@@ -46,6 +46,10 @@ class NumpyArrayHandler(base_handler.BaseDataHandler[model_types._SupportedNumpy
     def infer_signature(
         data: model_types._SupportedNumpyArray, role: Literal["input", "output"]
     ) -> Sequence[core.BaseFeatureSpec]:
+        if data.dtype == np.object_:
+            return pandas_handler.PandasDataFrameHandler.infer_signature(
+                NumpyArrayHandler.convert_to_df(data), role=role
+            )
         feature_prefix = f"{NumpyArrayHandler.FEATURE_PREFIX}_"
         dtype = core.DataType.from_numpy_type(data.dtype)
         role_prefix = (NumpyArrayHandler.INPUT_PREFIX if role == "input" else NumpyArrayHandler.OUTPUT_PREFIX) + "_"
@@ -108,21 +112,9 @@ class SeqOfNumpyArrayHandler(base_handler.BaseDataHandler[Sequence[model_types._
     def infer_signature(
         data: Sequence[model_types._SupportedNumpyArray], role: Literal["input", "output"]
     ) -> Sequence[core.BaseFeatureSpec]:
-        feature_prefix = f"{SeqOfNumpyArrayHandler.FEATURE_PREFIX}_"
-        features: List[core.BaseFeatureSpec] = []
-        role_prefix = (
-            SeqOfNumpyArrayHandler.INPUT_PREFIX if role == "input" else SeqOfNumpyArrayHandler.OUTPUT_PREFIX
-        ) + "_"
-
-        for i, data_col in enumerate(data):
-            dtype = core.DataType.from_numpy_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, nullable=False))
-            else:
-                ft_shape = tuple(data_col.shape[1:])
-                features.append(core.FeatureSpec(dtype=dtype, name=ft_name, shape=ft_shape, nullable=False))
-        return features
+        return pandas_handler.PandasDataFrameHandler.infer_signature(
+            SeqOfNumpyArrayHandler.convert_to_df(data, ensure_serializable=False), role=role
+        )
 
     @staticmethod
     def convert_to_df(

snowflake/ml/model/_signatures/pandas_handler.py

@@ -97,25 +97,7 @@ class PandasDataFrameHandler(base_handler.BaseDataHandler[pd.DataFrame]):
                         ),
                     )
 
-                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 df_col_data]
-
-                    if not all(
-                        core.DataType.from_numpy_type(converted_data.dtype) == arr_dtype
-                        for converted_data in converted_data_list
-                    ):
-                        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 {df_col_data}."
-                            ),
-                        )
-
-                elif isinstance(df_col_data.iloc[0], np.ndarray):
+                if 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 df_col_data):
@@ -126,7 +108,7 @@ class PandasDataFrameHandler(base_handler.BaseDataHandler[pd.DataFrame]):
                                 + f"Inconsistent type of element in object found in column data {df_col_data}."
                             ),
                         )
-                elif not isinstance(df_col_data.iloc[0], (str, bytes)):
+                elif not isinstance(df_col_data.iloc[0], (str, bytes, dict, list)):
                     raise snowml_exceptions.SnowflakeMLException(
                         error_code=error_codes.INVALID_DATA,
                         original_exception=ValueError(
@@ -171,16 +153,23 @@ class PandasDataFrameHandler(base_handler.BaseDataHandler[pd.DataFrame]):
 
             if df_col_dtype == np.dtype("O"):
                 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(df_col_data.iloc[0])
-
-                    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))
+                    spec_0 = utils.infer_list(ft_name, df_col_data.iloc[0])
+                    for i in range(1, len(df_col_data)):
+                        spec = utils.infer_list(ft_name, df_col_data.iloc[i])
+                        if spec._shape != spec_0._shape:
+                            spec_0._shape = (-1,)
+                            spec._shape = (-1,)
+                        if spec != spec_0:
+                            raise snowml_exceptions.SnowflakeMLException(
+                                error_code=error_codes.INVALID_DATA,
+                                original_exception=ValueError(
+                                    "Unable to construct signature: "
+                                    f"Ragged nested or Unsupported list-like data {df_col_data} confronted."
+                                ),
+                            )
+                    specs.append(spec_0)
+                elif isinstance(df_col_data.iloc[0], dict):
+                    specs.append(utils.infer_dict(ft_name, df_col_data.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])