snowflake-ml-python 1.23.0__py3-none-any.whl → 1.25.0__py3-none-any.whl

snowflake/ml/model/_client/sql/service.py

@@ -75,10 +75,8 @@ class ServiceSQLClient(_base._BaseSQLClient):
     DESC_SERVICE_SPEC_COL_NAME = "spec"
     DESC_SERVICE_CONTAINERS_SPEC_NAME = "containers"
     DESC_SERVICE_NAME_SPEC_NAME = "name"
-    DESC_SERVICE_PROXY_SPEC_ENV_NAME = "env"
-    PROXY_CONTAINER_NAME = "proxy"
+    DESC_SERVICE_ENV_SPEC_NAME = "env"
     MODEL_INFERENCE_AUTOCAPTURE_ENV_NAME = "SPCS_MODEL_INFERENCE_SERVER__AUTOCAPTURE_ENABLED"
-    FEATURE_MODEL_INFERENCE_AUTOCAPTURE = "FEATURE_MODEL_INFERENCE_AUTOCAPTURE"
 
     @contextlib.contextmanager
     def _qmark_paramstyle(self) -> Generator[None, None, None]:
@@ -285,39 +283,33 @@ class ServiceSQLClient(_base._BaseSQLClient):
         )
         return rows[0]
 
-    def get_proxy_container_autocapture(self, row: row.Row) -> bool:
-        """Extract whether service has autocapture enabled from proxy container spec.
+    def is_autocapture_enabled(self, row: row.Row) -> bool:
+        """Extract whether service has autocapture enabled in any container from service spec.
 
         Args:
             row: A row.Row object from DESCRIBE SERVICE containing the service YAML spec.
 
         Returns:
-            True if autocapture is enabled in proxy spec
-            False if disabled or not set in proxy spec
-            False if service doesn't have proxy container
+            True if autocapture is enabled in any container.
+            False if autocapture is disabled or not set in any container.
         """
-        try:
-            spec_yaml = row[ServiceSQLClient.DESC_SERVICE_SPEC_COL_NAME]
-            if spec_yaml is None:
-                return False
-            spec_raw = yaml.safe_load(spec_yaml)
-            if spec_raw is None:
-                return False
-            spec = cast(dict[str, Any], spec_raw)
-
-            proxy_container_spec = next(
-                container
-                for container in spec[ServiceSQLClient.DESC_SERVICE_SPEC_COL_NAME][
-                    ServiceSQLClient.DESC_SERVICE_CONTAINERS_SPEC_NAME
-                ]
-                if container[ServiceSQLClient.DESC_SERVICE_NAME_SPEC_NAME] == ServiceSQLClient.PROXY_CONTAINER_NAME
-            )
-            env = proxy_container_spec.get(ServiceSQLClient.DESC_SERVICE_PROXY_SPEC_ENV_NAME, {})
-            autocapture_enabled = env.get(ServiceSQLClient.MODEL_INFERENCE_AUTOCAPTURE_ENV_NAME, "false")
-            return str(autocapture_enabled).lower() == "true"
-
-        except StopIteration:
+        spec_yaml = row.as_dict().get(ServiceSQLClient.DESC_SERVICE_SPEC_COL_NAME)
+        if spec_yaml is None:
             return False
+        spec_raw = yaml.safe_load(spec_yaml)
+        if spec_raw is None:
+            return False
+        spec = cast(dict[str, Any], spec_raw)
+
+        containers = spec[ServiceSQLClient.DESC_SERVICE_SPEC_COL_NAME][
+            ServiceSQLClient.DESC_SERVICE_CONTAINERS_SPEC_NAME
+        ]
+        for container in containers:
+            env = container.get(ServiceSQLClient.DESC_SERVICE_ENV_SPEC_NAME, {})
+            autocapture_enabled = env.get(ServiceSQLClient.MODEL_INFERENCE_AUTOCAPTURE_ENV_NAME, "false")
+            if str(autocapture_enabled).lower() == "true":
+                return True
+        return False
 
     def drop_service(
         self,

snowflake/ml/model/_model_composer/model_method/model_method.py

@@ -156,7 +156,8 @@ class ModelMethod:
                 f"Your parameter {param_spec.name} cannot be resolved as valid SQL identifier. "
                 "Try specifying `case_sensitive` as True."
             ) from e
-        default_value = param_spec.default_value if param_spec.default_value is None else str(param_spec.default_value)
+        # Convert None to "NULL" string so MANIFEST parser can interpret it as SQL NULL
+        default_value = "NULL" if param_spec.default_value is None else str(param_spec.default_value)
         return model_manifest_schema.ModelMethodSignatureFieldWithNameAndDefault(
             name=param_name.resolved(),
             type=type_utils.convert_sp_to_sf_type(param_spec.dtype.as_snowpark_type()),

snowflake/ml/model/_packager/model_handlers/huggingface.py

@@ -574,6 +574,26 @@ class TransformersPipelineHandler(
                         input_col = signature.inputs[0].name
                         audio_inputs = X[input_col].to_list()
                         temp_res = [getattr(raw_model, target_method)(audio) for audio in audio_inputs]
+                    elif isinstance(raw_model, transformers.VideoClassificationPipeline):
+                        # Video classification expects file paths. Write bytes to temp files,
+                        # process them, and clean up.
+                        import tempfile
+
+                        input_col = signature.inputs[0].name
+                        video_bytes_list = X[input_col].to_list()
+                        temp_file_paths = []
+                        temp_files = []
+                        try:
+                            # TODO: parallelize this if needed
+                            for video_bytes in video_bytes_list:
+                                temp_file = tempfile.NamedTemporaryFile()
+                                temp_file.write(video_bytes)
+                                temp_file_paths.append(temp_file.name)
+                                temp_files.append(temp_file)
+                            temp_res = getattr(raw_model, target_method)(temp_file_paths)
+                        finally:
+                            for f in temp_files:
+                                f.close()
                     else:
                         # TODO: remove conversational pipeline code
                         # For others, we could offer the whole dataframe as a list.

snowflake/ml/model/_packager/model_handlers/sentence_transformers.py

@@ -16,6 +16,7 @@ from snowflake.ml.model._packager.model_meta import (
     model_meta as model_meta_api,
     model_meta_schema,
 )
+from snowflake.ml.model._signatures import utils as model_signature_utils
 from snowflake.snowpark._internal import utils as snowpark_utils
 
 if TYPE_CHECKING:
@@ -24,10 +25,14 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 
 # Allowlist of supported target methods for SentenceTransformer models.
-_ALLOWED_TARGET_METHODS = ["encode", "encode_queries", "encode_documents"]
+# Note: sentence-transformers >= 3.0 uses singular names (encode_query, encode_document)
+# while older versions may use plural names (encode_queries, encode_documents).
+_ALLOWED_TARGET_METHODS = ["encode", "encode_query", "encode_document", "encode_queries", "encode_documents"]
 
 
-def _validate_sentence_transformers_signatures(sigs: dict[str, model_signature.ModelSignature]) -> None:
+def _validate_sentence_transformers_signatures(
+    sigs: dict[str, model_signature.ModelSignature],
+) -> None:
     """Validate signatures for SentenceTransformer models.
 
     Args:
@@ -82,7 +87,9 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
     _HANDLER_MIGRATOR_PLANS: dict[str, type[base_migrator.BaseModelHandlerMigrator]] = {}
 
     MODEL_BLOB_FILE_OR_DIR = "model"
-    DEFAULT_TARGET_METHODS = ["encode", "encode_queries", "encode_documents"]
+    # Default to singular names which are used in sentence-transformers >= 3.0
+    DEFAULT_TARGET_METHODS = ["encode", "encode_query", "encode_document"]
+    IS_AUTO_SIGNATURE = True
 
     @classmethod
     def can_handle(
@@ -138,7 +145,8 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
                 raise ValueError(f"target_methods {target_methods} must be a subset of {_ALLOWED_TARGET_METHODS}.")
 
             def get_prediction(
-                target_method_name: str, sample_input_data: model_types.SupportedLocalDataType
+                target_method_name: str,
+                sample_input_data: model_types.SupportedLocalDataType,
             ) -> model_types.SupportedLocalDataType:
                 if not isinstance(sample_input_data, pd.DataFrame):
                     sample_input_data = model_signature._convert_local_data_to_df(data=sample_input_data)
@@ -149,8 +157,13 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
                     )
                 X_list = sample_input_data.iloc[:, 0].tolist()
 
-                assert callable(getattr(model, "encode", None))
-                return pd.DataFrame({0: model.encode(X_list, batch_size=batch_size).tolist()})
+                # Call the appropriate method based on target_method_name
+                method_to_call = getattr(model, target_method_name, None)
+                if not callable(method_to_call):
+                    raise ValueError(
+                        f"SentenceTransformer model does not have a callable method '{target_method_name}'."
+                    )
+                return pd.DataFrame({0: method_to_call(X_list, batch_size=batch_size).tolist()})
 
             if model_meta.signatures:
                 handlers_utils.validate_target_methods(model, list(model_meta.signatures.keys()))
@@ -171,6 +184,36 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
                         sample_input_data=sample_input_data,
                         get_prediction_fn=get_prediction,
                     )
+                else:
+                    # Auto-infer signature from model when no sample_input_data is provided
+                    # Get the embedding dimension from the model
+                    embedding_dim = model.get_sentence_embedding_dimension()
+                    if embedding_dim is None:
+                        raise ValueError(
+                            "Unable to auto-infer signature: model.get_sentence_embedding_dimension() returned None. "
+                            "Please provide sample_input_data or signatures explicitly."
+                        )
+
+                    for target_method in target_methods:
+                        # target_methods are already validated as callable by get_target_methods()
+                        inferred_sig = model_signature_utils.sentence_transformers_signature_auto_infer(
+                            target_method=target_method,
+                            embedding_dim=embedding_dim,
+                        )
+                        if inferred_sig is None:
+                            raise ValueError(
+                                f"Unable to auto-infer signature for method '{target_method}'. "
+                                "Please provide sample_input_data or signatures explicitly."
+                            )
+                        model_meta.signatures[target_method] = inferred_sig
+
+                    # Ensure at least one method was successfully inferred
+                    if not model_meta.signatures:
+                        raise ValueError(
+                            "No valid target methods found on the model. "
+                            "Please provide sample_input_data or signatures explicitly, "
+                            "or specify target_methods that exist on your model."
+                        )
 
             _validate_sentence_transformers_signatures(model_meta.signatures)
 
@@ -196,7 +239,10 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
 
         model_meta.env.include_if_absent(
             [
-                model_env.ModelDependency(requirement="sentence-transformers", pip_name="sentence-transformers"),
+                model_env.ModelDependency(
+                    requirement="sentence-transformers",
+                    pip_name="sentence-transformers",
+                ),
                 model_env.ModelDependency(requirement="transformers", pip_name="transformers"),
                 model_env.ModelDependency(requirement="pytorch", pip_name="torch"),
             ],
@@ -205,7 +251,9 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
         model_meta.env.cuda_version = kwargs.get("cuda_version", handlers_utils.get_default_cuda_version())
 
     @staticmethod
-    def _get_device_config(**kwargs: Unpack[model_types.SentenceTransformersLoadOptions]) -> Optional[str]:
+    def _get_device_config(
+        **kwargs: Unpack[model_types.SentenceTransformersLoadOptions],
+    ) -> Optional[str]:
         if kwargs.get("device", None) is not None:
             return kwargs["device"]
         elif kwargs.get("use_gpu", False):
@@ -262,7 +310,8 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
             model_meta: model_meta_api.ModelMetadata,
         ) -> type[custom_model.CustomModel]:
             batch_size = cast(
-                model_meta_schema.SentenceTransformersModelBlobOptions, model_meta.models[model_meta.name].options
+                model_meta_schema.SentenceTransformersModelBlobOptions,
+                model_meta.models[model_meta.name].options,
             ).get("batch_size", None)
 
             def get_prediction(
@@ -270,12 +319,20 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
                 signature: model_signature.ModelSignature,
                 target_method: str,
             ) -> Callable[[custom_model.CustomModel, pd.DataFrame], pd.DataFrame]:
+                # Capture target_method in closure to call the correct model method
+                method_to_call = getattr(raw_model, target_method, None)
+                if not callable(method_to_call):
+                    raise ValueError(
+                        f"SentenceTransformer model does not have a callable method '{target_method}'. "
+                        f"This method may not be available in your version of sentence-transformers."
+                    )
+
                 @custom_model.inference_api
                 def fn(self: custom_model.CustomModel, X: pd.DataFrame) -> pd.DataFrame:
                     X_list = X.iloc[:, 0].tolist()
 
                     return pd.DataFrame(
-                        {signature.outputs[0].name: raw_model.encode(X_list, batch_size=batch_size).tolist()}
+                        {signature.outputs[0].name: method_to_call(X_list, batch_size=batch_size).tolist()}
                     )
 
                 return fn
@@ -298,7 +355,6 @@ class SentenceTransformerHandler(_base.BaseModelHandler["sentence_transformers.S
         model = raw_model
 
         _SentenceTransformer = _create_custom_model(model, model_meta)
-        sentence_transformers_SentenceTransformer_model = _SentenceTransformer(custom_model.ModelContext())
-        predict_method = getattr(sentence_transformers_SentenceTransformer_model, "encode", None)
-        assert callable(predict_method)
-        return sentence_transformers_SentenceTransformer_model
+        sentence_transformers_model = _SentenceTransformer(custom_model.ModelContext())
+
+        return sentence_transformers_model

snowflake/ml/model/_signatures/utils.py

@@ -298,6 +298,24 @@ def huggingface_pipeline_signature_auto_infer(
                             shape=(-1,),  # Variable length list of chunks
                         ),
                     ],
+                )
+            ],
+        )
+
+    # https://huggingface.co/docs/transformers/en/main_classes/pipelines#transformers.VideoClassificationPipeline
+    if task == "video-classification":
+        return core.ModelSignature(
+            inputs=[
+                core.FeatureSpec(name="video", dtype=core.DataType.BYTES),
+            ],
+            outputs=[
+                core.FeatureGroupSpec(
+                    name="labels",
+                    specs=[
+                        core.FeatureSpec(name="label", dtype=core.DataType.STRING),
+                        core.FeatureSpec(name="score", dtype=core.DataType.DOUBLE),
+                    ],
+                    shape=(-1,),
                 ),
             ],
         )
@@ -333,7 +351,11 @@ def huggingface_pipeline_signature_auto_infer(
         )
 
     # https://huggingface.co/docs/transformers/en/main_classes/pipelines#transformers.ImageTextToTextPipeline
-    if task == "image-text-to-text":
+    if task in [
+        "image-text-to-text",
+        "video-text-to-text",
+        "audio-text-to-text",
+    ]:
         if params.get("return_tensors", False):
             raise NotImplementedError(
                 f"Auto deployment for HuggingFace pipeline {task} "
@@ -461,3 +483,56 @@ def infer_dict(name: str, data: dict[str, Any]) -> core.FeatureGroupSpec:
 
 def check_if_series_is_empty(series: Optional[pd.Series]) -> bool:
     return series is None or series.empty
+
+
+def sentence_transformers_signature_auto_infer(
+    target_method: str,
+    embedding_dim: int,
+) -> Optional[core.ModelSignature]:
+    """Auto-infer signature for SentenceTransformer models.
+
+    SentenceTransformer models have a simple signature: they take a string input
+    and return an embedding vector (array of floats).
+
+    Args:
+        target_method: The target method name. Supported methods:
+            - "encode": General encoding method
+            - "encode_query" / "encode_queries": Query encoding for asymmetric search
+            - "encode_document" / "encode_documents": Document encoding for asymmetric search
+        embedding_dim: The dimension of the embedding vector output by the model.
+
+    Returns:
+        A ModelSignature for the target method, or None if the method is not supported.
+
+    Note:
+        sentence-transformers >= 3.0 uses singular names (encode_query, encode_document)
+        while older versions may use plural names (encode_queries, encode_documents).
+        Both naming conventions are supported for backward compatibility.
+    """
+    # Support both singular (new) and plural (old) naming conventions
+    supported_methods = [
+        "encode",
+        "encode_query",
+        "encode_document",
+        "encode_queries",
+        "encode_documents",
+    ]
+
+    if target_method not in supported_methods:
+        return None
+
+    # All SentenceTransformer encode methods have the same signature pattern:
+    # - Input: a single string column
+    # - Output: a single column containing embedding vectors (array of floats)
+    return core.ModelSignature(
+        inputs=[
+            core.FeatureSpec(name="text", dtype=core.DataType.STRING),
+        ],
+        outputs=[
+            core.FeatureSpec(
+                name="output",
+                dtype=core.DataType.DOUBLE,
+                shape=(embedding_dim,),
+            ),
+        ],
+    )

snowflake/ml/model/models/huggingface_pipeline.py

@@ -105,6 +105,7 @@ class HuggingFacePipelineModel(huggingface.TransformersPipeline):
         image_repo: Optional[str] = None,
         image_build_compute_pool: Optional[str] = None,
         ingress_enabled: bool = False,
+        min_instances: int = 0,
         max_instances: int = 1,
         cpu_requests: Optional[str] = None,
         memory_requests: Optional[str] = None,
@@ -133,6 +134,7 @@ class HuggingFacePipelineModel(huggingface.TransformersPipeline):
             image_build_compute_pool: The name of the compute pool used to build the model inference image. It uses
             the service compute pool if None.
             ingress_enabled: Whether ingress is enabled. Defaults to False.
+            min_instances: Minimum number of instances. Defaults to 0.
             max_instances: Maximum number of instances. Defaults to 1.
             cpu_requests: CPU requests configuration. Defaults to None.
             memory_requests: Memory requests configuration. Defaults to None.
@@ -225,6 +227,7 @@ class HuggingFacePipelineModel(huggingface.TransformersPipeline):
                     service_compute_pool_name=sql_identifier.SqlIdentifier(service_compute_pool),
                     image_repo_name=image_repo,
                     ingress_enabled=ingress_enabled,
+                    min_instances=min_instances,
                     max_instances=max_instances,
                     cpu_requests=cpu_requests,
                     memory_requests=memory_requests,

snowflake/ml/model/openai_signatures.py

@@ -88,6 +88,96 @@ _OPENAI_CHAT_SIGNATURE_SPEC = core.ModelSignature(
     ],
 )
 
+_OPENAI_CHAT_SIGNATURE_WITH_PARAMS_SPEC = core.ModelSignature(
+    inputs=[
+        core.FeatureGroupSpec(
+            name="messages",
+            specs=[
+                core.FeatureGroupSpec(
+                    name="content",
+                    specs=[
+                        core.FeatureSpec(name="type", dtype=core.DataType.STRING),
+                        # Text prompts
+                        core.FeatureSpec(name="text", dtype=core.DataType.STRING),
+                        # Image URL prompts
+                        core.FeatureGroupSpec(
+                            name="image_url",
+                            specs=[
+                                # Base64 encoded image URL or image URL
+                                core.FeatureSpec(name="url", dtype=core.DataType.STRING),
+                                # Image detail level (e.g., "low", "high", "auto")
+                                core.FeatureSpec(name="detail", dtype=core.DataType.STRING),
+                            ],
+                        ),
+                        # Video URL prompts
+                        core.FeatureGroupSpec(
+                            name="video_url",
+                            specs=[
+                                # Base64 encoded video URL
+                                core.FeatureSpec(name="url", dtype=core.DataType.STRING),
+                            ],
+                        ),
+                        # Audio prompts
+                        core.FeatureGroupSpec(
+                            name="input_audio",
+                            specs=[
+                                core.FeatureSpec(name="data", dtype=core.DataType.STRING),
+                                core.FeatureSpec(name="format", dtype=core.DataType.STRING),
+                            ],
+                        ),
+                    ],
+                    shape=(-1,),
+                ),
+                core.FeatureSpec(name="name", dtype=core.DataType.STRING),
+                core.FeatureSpec(name="role", dtype=core.DataType.STRING),
+                core.FeatureSpec(name="title", dtype=core.DataType.STRING),
+            ],
+            shape=(-1,),
+        ),
+    ],
+    outputs=[
+        core.FeatureSpec(name="id", dtype=core.DataType.STRING),
+        core.FeatureSpec(name="object", dtype=core.DataType.STRING),
+        core.FeatureSpec(name="created", dtype=core.DataType.FLOAT),
+        core.FeatureSpec(name="model", dtype=core.DataType.STRING),
+        core.FeatureGroupSpec(
+            name="choices",
+            specs=[
+                core.FeatureSpec(name="index", dtype=core.DataType.INT32),
+                core.FeatureGroupSpec(
+                    name="message",
+                    specs=[
+                        core.FeatureSpec(name="content", dtype=core.DataType.STRING),
+                        core.FeatureSpec(name="name", dtype=core.DataType.STRING),
+                        core.FeatureSpec(name="role", dtype=core.DataType.STRING),
+                    ],
+                ),
+                core.FeatureSpec(name="logprobs", dtype=core.DataType.STRING),
+                core.FeatureSpec(name="finish_reason", dtype=core.DataType.STRING),
+            ],
+            shape=(-1,),
+        ),
+        core.FeatureGroupSpec(
+            name="usage",
+            specs=[
+                core.FeatureSpec(name="completion_tokens", dtype=core.DataType.INT32),
+                core.FeatureSpec(name="prompt_tokens", dtype=core.DataType.INT32),
+                core.FeatureSpec(name="total_tokens", dtype=core.DataType.INT32),
+            ],
+        ),
+    ],
+    params=[
+        core.ParamSpec(name="temperature", dtype=core.DataType.DOUBLE, default_value=1.0),
+        core.ParamSpec(name="max_completion_tokens", dtype=core.DataType.INT64, default_value=250),
+        core.ParamSpec(name="stop", dtype=core.DataType.STRING, default_value=""),
+        core.ParamSpec(name="n", dtype=core.DataType.INT32, default_value=1),
+        core.ParamSpec(name="stream", dtype=core.DataType.BOOL, default_value=False),
+        core.ParamSpec(name="top_p", dtype=core.DataType.DOUBLE, default_value=1.0),
+        core.ParamSpec(name="frequency_penalty", dtype=core.DataType.DOUBLE, default_value=0.0),
+        core.ParamSpec(name="presence_penalty", dtype=core.DataType.DOUBLE, default_value=0.0),
+    ],
+)
+
 _OPENAI_CHAT_SIGNATURE_SPEC_WITH_CONTENT_FORMAT_STRING = core.ModelSignature(
     inputs=[
         core.FeatureGroupSpec(
@@ -142,6 +232,62 @@ _OPENAI_CHAT_SIGNATURE_SPEC_WITH_CONTENT_FORMAT_STRING = core.ModelSignature(
     ],
 )
 
+_OPENAI_CHAT_SIGNATURE_WITH_PARAMS_SPEC_WITH_CONTENT_FORMAT_STRING = core.ModelSignature(
+    inputs=[
+        core.FeatureGroupSpec(
+            name="messages",
+            specs=[
+                core.FeatureSpec(name="content", dtype=core.DataType.STRING),
+                core.FeatureSpec(name="name", dtype=core.DataType.STRING),
+                core.FeatureSpec(name="role", dtype=core.DataType.STRING),
+                core.FeatureSpec(name="title", dtype=core.DataType.STRING),
+            ],
+            shape=(-1,),
+        ),
+    ],
+    outputs=[
+        core.FeatureSpec(name="id", dtype=core.DataType.STRING),
+        core.FeatureSpec(name="object", dtype=core.DataType.STRING),
+        core.FeatureSpec(name="created", dtype=core.DataType.FLOAT),
+        core.FeatureSpec(name="model", dtype=core.DataType.STRING),
+        core.FeatureGroupSpec(
+            name="choices",
+            specs=[
+                core.FeatureSpec(name="index", dtype=core.DataType.INT32),
+                core.FeatureGroupSpec(
+                    name="message",
+                    specs=[
+                        core.FeatureSpec(name="content", dtype=core.DataType.STRING),
+                        core.FeatureSpec(name="name", dtype=core.DataType.STRING),
+                        core.FeatureSpec(name="role", dtype=core.DataType.STRING),
+                    ],
+                ),
+                core.FeatureSpec(name="logprobs", dtype=core.DataType.STRING),
+                core.FeatureSpec(name="finish_reason", dtype=core.DataType.STRING),
+            ],
+            shape=(-1,),
+        ),
+        core.FeatureGroupSpec(
+            name="usage",
+            specs=[
+                core.FeatureSpec(name="completion_tokens", dtype=core.DataType.INT32),
+                core.FeatureSpec(name="prompt_tokens", dtype=core.DataType.INT32),
+                core.FeatureSpec(name="total_tokens", dtype=core.DataType.INT32),
+            ],
+        ),
+    ],
+    params=[
+        core.ParamSpec(name="temperature", dtype=core.DataType.DOUBLE, default_value=1.0),
+        core.ParamSpec(name="max_completion_tokens", dtype=core.DataType.INT64, default_value=250),
+        core.ParamSpec(name="stop", dtype=core.DataType.STRING, default_value=""),
+        core.ParamSpec(name="n", dtype=core.DataType.INT32, default_value=1),
+        core.ParamSpec(name="stream", dtype=core.DataType.BOOL, default_value=False),
+        core.ParamSpec(name="top_p", dtype=core.DataType.DOUBLE, default_value=1.0),
+        core.ParamSpec(name="frequency_penalty", dtype=core.DataType.DOUBLE, default_value=0.0),
+        core.ParamSpec(name="presence_penalty", dtype=core.DataType.DOUBLE, default_value=0.0),
+    ],
+)
+
 
 # Refer vLLM documentation: https://docs.vllm.ai/en/stable/serving/openai_compatible_server/#chat-template
 
@@ -152,3 +298,11 @@ OPENAI_CHAT_SIGNATURE_WITH_CONTENT_FORMAT_STRING = {"__call__": _OPENAI_CHAT_SIG
 # This is the default signature.
 # The content format allows vLLM to handler content parts like text, image, video, audio, file, etc.
 OPENAI_CHAT_SIGNATURE = {"__call__": _OPENAI_CHAT_SIGNATURE_SPEC}
+
+# Use this signature to leverage ParamSpec with the default ChatML template.
+OPENAI_CHAT_WITH_PARAMS_SIGNATURE = {"__call__": _OPENAI_CHAT_SIGNATURE_WITH_PARAMS_SPEC}
+
+# Use this signature to leverage ParamSpec with the content format string.
+OPENAI_CHAT_WITH_PARAMS_SIGNATURE_WITH_CONTENT_FORMAT_STRING = {
+    "__call__": _OPENAI_CHAT_SIGNATURE_WITH_PARAMS_SPEC_WITH_CONTENT_FORMAT_STRING
+}

snowflake/ml/registry/_manager/model_parameter_reconciler.py

@@ -193,12 +193,11 @@ class ModelParameterReconciler:
         if enable_explainability:
             if only_spcs or not is_warehouse_runnable:
                 raise ValueError(
-                    "`enable_explainability` cannot be set to True when the model is not runnable in WH "
-                    "or the target platforms include SPCS."
+                    "`enable_explainability` cannot be set to True when the model cannot run in Warehouse."
                 )
             elif has_both_platforms:
                 warnings.warn(
-                    ("Explain function will only be available for model deployed to warehouse."),
+                    ("Explain function will only be available for model deployed to Warehouse."),
                     category=UserWarning,
                     stacklevel=2,
                 )

snowflake/ml/version.py

@@ -1,2 +1,2 @@
 # This is parsed by regex in conda recipe meta file. Make sure not to break it.
-VERSION = "1.23.0"
+VERSION = "1.25.0"